Ejemplo n.º 1
0
//static kconn_t *MYSQL_qopen(CTX ctx, kbytes_t url)
kconn_t *MYSQL_qopen(CTX ctx, kbytes_t url)
{
    char *puser, user[MYSQL_USER_MAXLEN+1] = {0};
    char *ppass, pass[MYSQL_PASS_MAXLEN+1] = {0}; // temporary defined
    char *phost, host[MYSQL_HOST_MAXLEN+1] = {0};
    unsigned int port = 0;
    char *pdbnm, dbnm[MYSQL_DBNM_MAXLEN+1] = {0};

    kbytes_t bt = knh_bytes_last(url, 8); // skip: mysql://
    const char *btstr = bt.text;
    sscanf(btstr, "%16[^ :\r\n\t]:%255[^ @\r\n\t]@%255[^ :\r\n\t]:%5d/%64[^ \r\n\t]",
           (char*)&user, (char*)&pass, (char*)&host, &port, (char*)&dbnm); // consider to buffer over run

    puser = (user[0]) ? user : NULL;
    ppass = (pass[0]) ? pass : NULL;
    phost = (host[0]) ? host : NULL;
    pdbnm = (dbnm[0]) ? dbnm : NULL;

    MYSQL *db = mysql_init(NULL);
    KNH_NTRACE2(ctx, "mysql_init", (db != NULL) ? K_OK : K_FAILED, KNH_LDATA(LOG_s("init", mysql_error(db))));
    db = mysql_real_connect(db, phost, puser, ppass, pdbnm, port, NULL, 0);
    KNH_NTRACE2(ctx, "mysql_real_connect", (db != NULL) ? K_OK : K_FAILED, KNH_LDATA(LOG_s("host", phost), LOG_s("user", puser), /* LOG_s("passwd", ppass), */
                LOG_s("dbname", pdbnm), LOG_i("port", port), LOG_i("errno", mysql_errno(db)),
                LOG_s("error", mysql_error(db))));
    //if (!mysql_real_connect(db, phost, puser, ppass, pdbnm, port, NULL, 0)) {
    //	knh_mysql_perror(ctx, db, 0);
    //	mysql_close(db);
    //	db = NULL;
    //}
    return (kconn_t*)db;
}
Ejemplo n.º 2
0
//static int MYSQL_qnext(CTX ctx, kqcur_t *qcur, struct kResultSet *rs)
int MYSQL_qnext(CTX ctx, kqcur_t *qcur, struct kResultSet *rs)
{
    MYSQL_ROW row;
    if ((row = mysql_fetch_row((MYSQL_RES*)qcur)) != NULL) {
        KNH_NTRACE2(ctx, "mysql_fetch_row", K_OK, KNH_LDATA0);
        int i;
        kint_t ival;
        kfloat_t fval;
        for (i = 0; i < DP(rs)->column_size; i++) {
            if (row[i] == NULL) {
                ResultSet_setNULL(ctx, rs, i);
                continue;
            }
            switch (DP(rs)->column[i].dbtype) {
            case MYSQL_TYPE_TINY:
            case MYSQL_TYPE_SHORT:
            case MYSQL_TYPE_INT24:
            case MYSQL_TYPE_LONG:
            case MYSQL_TYPE_LONGLONG:
            case MYSQL_TYPE_YEAR:
                knh_bytes_parseint(B(row[i]), &ival);
                ResultSet_setInt(ctx, rs, i, ival);
                break;
            case MYSQL_TYPE_FLOAT:
            case MYSQL_TYPE_DOUBLE:
                knh_bytes_parsefloat(B(row[i]), &fval);
                ResultSet_setFloat(ctx, rs, i, fval);
                break;
            case MYSQL_TYPE_NEWDECIMAL:
            case MYSQL_TYPE_STRING:
            case MYSQL_TYPE_VAR_STRING:
            case MYSQL_TYPE_TINY_BLOB:
            case MYSQL_TYPE_BLOB:
            case MYSQL_TYPE_MEDIUM_BLOB:
            case MYSQL_TYPE_LONG_BLOB:
            case MYSQL_TYPE_BIT:
            case MYSQL_TYPE_TIME:
            case MYSQL_TYPE_DATE:
            case MYSQL_TYPE_DATETIME:
            case MYSQL_TYPE_TIMESTAMP:
                ResultSet_setText(ctx, rs, i, B(row[i]));
                break;
            case MYSQL_TYPE_NULL:
            default:
                //KNH_SYSLOG(ctx, LOG_WARNING, "mysql", "mysql_qnext(dbtype)='unknown datatype [%d]'", DP(rs)->column[i].dbtype);
                ResultSet_setNULL(ctx, rs, i);
                break;
            }
        } /* for */
        return 1; /* CONTINUE */
    } else {
        KNH_NTRACE2(ctx, "mysql_fetch_row", K_FAILED, KNH_LDATA0);
    }
    return 0; /* NOMORE */
}
Ejemplo n.º 3
0
static kcontext_t* new_hcontext(CTX ctx0)
{
	kcontext_t *ctx;
	static volatile size_t ctxid_counter = 0;
	if(ctx0 == NULL) {
		ctxid_counter = 0;
		ctx = (kcontext_t*)malloc(sizeof(kcontext_t));
		knh_bzero(ctx, sizeof(kcontext_t));
	}
	else {
		KNH_ASSERT_CTX0(ctx0);
		ctx = (kcontext_t*)KNH_MALLOC(ctx0, sizeof(kcontext_t));
		knh_bzero(ctx, sizeof(kcontext_t));
	}
	ctx->flag = 0;
	ctx->ctxid = ctxid_counter;
	ctxid_counter++;
//	ctx->freeObjectList = NULL;
//	ctx->freeMemoryList = NULL;
	ctx->parent = ctx;
	ctx->api2 = getapi2();
	{
		kuintptr_t i = 0, ch;
		kuint_t t = knh_rand();
		ch = t % 26;
		ctx->trace[i] = 'A' + ch;
		for(i = 1; i < 9; i++) {
			t = t / 36;
			if (t == 0) t = knh_rand();
			ch = t % 36;
			ctx->trace[i] = (ch < 10) ? '0' + ch : 'A' + (ch - 10);
		}
	}
	ctx->seq = 0;
	ctx->ctxobjNC = NULL;
	if(ctx0 == NULL) {
		const char *ptrace = knh_getenv(K_DEOS_TRACE);
		if(ptrace == NULL) {
			ptrace = "$(setenv " K_DEOS_TRACE ")";
		}
		KNH_NTRACE2(ctx, "konoha:newtrace", K_NOTICE, KNH_LDATA(
					LOG_s("parent", ptrace)
#if defined(K_USING_POSIX_)
					, LOG_u("ppid", getppid())
#endif /* !defined(K_USING_POSIX_) */
					));
	}
	else {
		KNH_NTRACE2(ctx, "konoha:newtrace", K_NOTICE, KNH_LDATA(LOG_s("parent", ctx0->trace), LOG_u("seq", ctx0->seq)));
	}
	return ctx;
}
Ejemplo n.º 4
0
//static kqcur_t *MYSQL_query(CTX ctx, kconn_t *hdr, kbytes_t sql, kResultSet *rs)
kqcur_t *MYSQL_query(CTX ctx, kconn_t *hdr, kbytes_t sql, kResultSet *rs)
{
    MYSQL_RES *res = NULL;
    MYSQL *db = (MYSQL*)hdr;
    if (db == NULL) {
        /* return NULL */
    }
    else if (rs == NULL) {
        /* Connection.exec */
        int r = mysql_query(db, sql.text);
        KNH_NTRACE2(ctx, "mysql_query", (r == 0) ? K_OK : K_FAILED, KNH_LDATA(LOG_s("query", sql.text), LOG_i("errno", mysql_errno(db))));
        //if(r > 0) {
        //	knh_mysql_perror(ctx, (MYSQL*)db, r);
        //}
    }
    else {
        /* Connection.query */
        int r = mysql_query((MYSQL*)db, sql.text);
        KNH_NTRACE2(ctx, "mysql_query", (r == 0) ? K_OK : K_FAILED, KNH_LDATA(
                        LOG_s("query", sql.text), LOG_i("errno", mysql_errno(db)),
                        LOG_s("error", mysql_error(db))
                    ));
        if (r == 0) {
            res = mysql_store_result((MYSQL*)db);
            if (res == NULL) { // NULL RESULT
                if (mysql_errno(db) != 0) {
                    mysql_free_result(res);
                    KNH_NTRACE2(ctx, "mysql_store_result", K_FAILED, KNH_LDATA(LOG_i("errno", mysql_errno(db)), LOG_s("error", mysql_error(db))));
                } else {
                    KNH_NTRACE2(ctx, "mysql_store_result", K_OK, KNH_LDATA(LOG_i("errno", mysql_errno(db)), LOG_s("error", mysql_error(db))));
                }
            }
            else {
                knh_ResultSet_initColumn(ctx, rs, (size_t)mysql_num_fields(res));
                KNH_NTRACE2(ctx, "mysql_store_result", K_OK, KNH_LDATA(LOG_i("errno", mysql_errno(db)), LOG_s("error", mysql_error(db))));
                int i = 0;
                MYSQL_FIELD *field = NULL;
                while((field = mysql_fetch_field(res))) {
                    DP(rs)->column[i].dbtype = field->type;
                    kString *s = new_String(ctx, field->name);
                    ResultSet_setName(ctx, rs, i, s);
                    i++;
                }
            }
        }
    }
    return (kqcur_t *) res;
}
Ejemplo n.º 5
0
void *knh_dlsym(CTX, void* handler, const char* symbol, const char *another, int isTest)
{
	const char *func = __FUNCTION__, *emsg = NULL;
	void *p = NULL;
#if defined(K_USING_WINDOWS_)
	func = "GetProcAddress";
	p = GetProcAddress((HMODULE)handler, (LPCSTR)symbol);
	if(p == NULL && another != NULL) {
		symbol = another;
		p = GetProcAddress((HMODULE)handler, (LPCSTR)symbol);
	}
	return p;
#elif defined(K_USING_POSIX_)
	func = "dlsym";
	p = dlsym(handler, symbol);
	if(p == NULL && another != NULL) {
		symbol = another;
		p = dlsym(handler, symbol);
	}
	if(p == NULL) {
		emsg = dlerror();
	}
#else
#endif
	if(!isTest) {
		int pe = (p == NULL) ? K_PERROR : K_OK;
		KNH_NTRACE2(_ctx, func, pe, KNH_LDATA(LOG_p("handler", handler), LOG_s("symbol", symbol)));
	}
	return p;
}
Ejemplo n.º 6
0
void knh_mutex_free(CTX, kmutex_t *m)
{
	if(knh_mutex_destroy(m) != 0) {
		KNH_NTRACE2(_ctx, "mutex_destroy", K_PERROR, KNH_LDATA(LOG_p("mutex", m)));
	}
	free(m);
}
Ejemplo n.º 7
0
kmutex_t *knh_mutex_malloc(CTX)
{
	kmutex_t *m = (kmutex_t*)malloc(sizeof(kmutex_t));
	knh_bzero(m, sizeof(kmutex_t));
	if(knh_mutex_init(m) != 0) {
		KNH_NTRACE2(_ctx, "mutex_init", K_PERROR, KNH_LDATA(LOG_p("mutex", m)));
	}
	return m;
}
Ejemplo n.º 8
0
kfileid_t knh_getURI(CTX, kbytes_t t)
{
	OLD_LOCK(_ctx, LOCK_SYSTBL, NULL);
	kindex_t idx = knh_DictSet_index(_ctx->share->urnDictSet, t);
	if(idx == -1) {
		kString *s = new_kString(t.text, t.len, SPOL_POOL);
		idx = kArray_size(_ctx->share->urns);
		knh_DictSet_set(_ctx, ctx->share->urnDictSet, s, idx);
		kArray_add(ctx->share->urns, s);
		KNH_NTRACE2(_ctx, "konoha:newfileid", K_OK, KNH_LDATA(LOG_s("urn", S_text(s)), LOG_i("fileid", idx)));
	}
	else {
		idx = knh_DictSet_valueAt(_ctx->share->urnDictSet, idx);
	}
	OLD_UNLOCK(_ctx, LOCK_SYSTBL, NULL);
	return (kfileid_t)idx;
}
Ejemplo n.º 9
0
kuri_t knh_getURI(CTX ctx, kbytes_t t)
{
    OLD_LOCK(ctx, LOCK_SYSTBL, NULL);
    kindex_t idx = knh_DictSet_index(ctx->share->urnDictSet, t);
    if(idx == -1) {
        kString *s = new_String2(ctx, CLASS_String, t.text, t.len, SPOL_POOLALWAYS);
        idx = knh_Array_size(ctx->share->urns);
        knh_DictSet_set(ctx, ctx->share->urnDictSet, s, idx);
        knh_Array_add(ctx, ctx->share->urns, s);
        KNH_NTRACE2(ctx, "konoha:newuri", K_OK, KNH_LDATA(LOG_s("urn", S_totext(s)), LOG_i("uri", idx)));
    }
    else {
        idx = knh_DictSet_valueAt(ctx->share->urnDictSet, idx);
    }
    OLD_UNLOCK(ctx, LOCK_SYSTBL, NULL);
    return (kuri_t)idx;
}
Ejemplo n.º 10
0
void *knh_dlopen(CTX, const char* path)
{
	const char *func = __FUNCTION__;
	void *handler = NULL;
#if defined(K_USING_WINDOWS_)
	func = "LoadLibrary";
	handler = (void*)LoadLibraryA((LPCTSTR)path);
#elif defined(K_USING_POSIX_)
	func = "dlopen";
	handler = dlopen(path, RTLD_LAZY);
#else

#endif
	int pe = (handler == NULL) ? K_PERROR : K_OK;
	{
		KNH_NTRACE2(_ctx, func, pe, KNH_LDATA(LOG_s("path", path), LOG_p("handler", handler)));
	}
	return handler;
}
Ejemplo n.º 11
0
static int open_socket(CTX ctx, ksfp_t *sfp, const char *ip_or_host, int port)
{
	int sd = IO_NULL;
	struct in_addr addr = {0};
	struct sockaddr_in server = {0};
	const char *errfunc = NULL;

	if ((addr.s_addr = inet_addr(ip_or_host)) == -1) {
		struct hostent *host = gethostbyname(ip_or_host);
		if (host == NULL) {
			errfunc = "gethostname";
			goto L_PERROR;
		}
		memcpy(&addr, (struct in_addr *)*host->h_addr_list, sizeof(struct in_addr));
	}

	server.sin_family = AF_INET;
	server.sin_addr = addr;
	server.sin_port = htons(port);

	if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		errfunc = "socket";
		goto L_PERROR;
	}

	if (connect(sd, (struct sockaddr *)&server, sizeof(server)) == -1) {
		errfunc = "connect";
		close(sd);
		goto L_PERROR;
	}

	L_PERROR:;
	if (errfunc != NULL) {
		KNH_NTHROW2(ctx, sfp, "Socket!!", errfunc, K_PERROR, KNH_LDATA(LOG_s("host", ip_or_host), LOG_i("port", port), LOG_sfp));
		sd = IO_NULL;
	}
	else {
		KNH_NTRACE2(ctx, "connect", K_OK, KNH_LDATA(LOG_s("host", ip_or_host), LOG_i("port", port), LOG_sfp));
	}
	return (int) sd;
}
Ejemplo n.º 12
0
static void trapSIGINT(int sig RECARG)
{
	CTX ctx = knh_getCurrentContext();
//	record_signal(ctx, sig RECDATA);
	if(ctx != NULL) {
//#if defined(K_USING_MINGW_)
//		knh_ldata_t ldata[] = {LOG_END};
//#else
//		knh_ldata_t ldata[] = {LOG_i("sender_pid", si->si_pid), LOG_i("sender_uid", si->si_uid), LOG_END};
//#endif /* defined(K_USING_MINGW_) */
//		KNH_NTRACE(ctx, "konoha:signal", K_NOTICE, ldata);
		KNH_NTRACE2(ctx, "konoha:signal", K_NOTICE,
#if defined(K_USING_MINGW_)
				KNH_LDATA0
#else
				KNH_LDATA(LOG_i("sender_pid", si->si_pid), LOG_i("sender_uid", si->si_uid))
#endif
		);
	}
	_Exit(0);
}
Ejemplo n.º 13
0
int main(int argc, const char *argv[])
{
	MPI_Init(&argc, (char***)&argv);
	konoha_ginit(argc, argv);
	konoha_t konoha = konoha_open();
	int _world_rank;
	MPI_Comm_rank(MPI_COMM_WORLD, &_world_rank);
#ifdef KNH_MPI_PROFILE
	double _begin = MPI_Wtime();
#endif
	konoha_main(konoha, argc, argv);
#ifdef KNH_MPI_PROFILE
	double _finish = MPI_Wtime();
	double _duration = _finish - _begin;
	{
		CTX ctx = (CTX)konoha;
		KNH_NTRACE2(ctx, "konoha_main(MPI)", K_NOTICE,
					KNH_LDATA(LOG_f("begin", _begin), LOG_f("finish", _finish), LOG_f("duration", _duration), LOG_i("myrank", _world_rank)));
	}
#endif
	konoha_close(konoha);
	MPI_Finalize();
	return 0;
}