CS_RETCODE SybConnection::init_() { CS_RETCODE retcode; CS_INT netio_type = CS_SYNC_IO; // Get a context handle to use. if ((retcode = cs_ctx_alloc(EX_CTLIB_VERSION, &sContext_)) != CS_SUCCEED) { SysLogger::error("init_: cs_ctx_alloc() failed"); return retcode; } // Initialize Open Client. if ((retcode = ct_init(sContext_, EX_CTLIB_VERSION)) != CS_SUCCEED) { SysLogger::error("init_: ct_init() failed"); cs_ctx_drop(sContext_); sContext_ = NULL; return retcode; } // Install client message handlers. if ((retcode = ct_callback(sContext_, NULL, CS_SET, CS_CLIENTMSG_CB, (CS_VOID *)clientmsg_cb)) != CS_SUCCEED) { SysLogger::error("init_: ct_callback(CS_CLIENTMSG_CB) failed"); ct_exit(sContext_, CS_FORCE_EXIT); cs_ctx_drop(sContext_); sContext_ = NULL; return retcode; } // Install server message handlers. if ((retcode = ct_callback(sContext_, NULL, CS_SET, CS_SERVERMSG_CB, (CS_VOID *)servermsg_cb)) != CS_SUCCEED) { SysLogger::error("init_: ct_callback(CS_SERVERMSG_CB) failed"); ct_exit(sContext_, CS_FORCE_EXIT); cs_ctx_drop(sContext_); sContext_ = NULL; return retcode; } // Set the input/output type to synchronous. if ((retcode = ct_config(sContext_, CS_SET, CS_NETIO, &netio_type, CS_UNUSED, NULL)) != CS_SUCCEED) { SysLogger::error("init_: ct_config() failed"); ct_exit(sContext_, CS_FORCE_EXIT); cs_ctx_drop(sContext_); sContext_ = NULL; return retcode; } return CS_SUCCEED; }
/* Note: the programmer must not allow the context to be GC'd until all connections are closed, or they'll be killed. */ void mltds_ct_ctx_finalize(value context) { CS_CONTEXT* ctx = context_ptr(context); ct_exit(ctx, CS_FORCE_EXIT); cs_ctx_drop(ctx); }
int main(int argc, char **argv) { CS_CONTEXT *ctx; CS_CONNECTION *conn; int ret = 1; read_login_info(); if (cs_ctx_alloc(CS_VERSION_100, &ctx) != CS_SUCCEED) { fprintf(stderr, "Context Alloc failed!\n"); return ret; } if (ct_init(ctx, CS_VERSION_100) != CS_SUCCEED) { fprintf(stderr, "Library Init failed!\n"); return ret; } if (ct_con_alloc(ctx, &conn) != CS_SUCCEED) { fprintf(stderr, "Connect Alloc failed!\n"); return ret; } if (ct_con_props(conn, CS_SET, CS_USERNAME, (CS_VOID*) "sa", CS_NULLTERM, NULL) != CS_SUCCEED) { fprintf(stderr, "ct_con_props() SET USERNAME failed!\n"); return ret; } if (ct_con_props(conn, CS_SET, CS_PASSWORD, (CS_VOID*) "invalid", CS_NULLTERM, NULL) != CS_SUCCEED) { fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n"); return ret; } if (ct_connect(conn, SERVER, CS_NULLTERM) != CS_FAIL) { fprintf(stderr, "Connection succeeded??\n"); return ret; } if (ct_cancel(conn, NULL, CS_CANCEL_ALL) != CS_SUCCEED) { fprintf(stderr, "ct_cancel() failed!\n"); return ret; } if (ct_close(conn, CS_UNUSED) != CS_SUCCEED) { fprintf(stderr, "ct_close() failed!\n"); return ret; } if (ct_con_drop(conn) != CS_SUCCEED) { fprintf(stderr, "ct_con_drop() failed!\n"); return ret; } if (ct_exit(ctx, CS_UNUSED) != CS_SUCCEED) { fprintf(stderr, "ct_exit() failed!\n"); return ret; } if (cs_ctx_drop(ctx) != CS_SUCCEED) { fprintf(stderr, "cs_ctx_drop() failed!\n"); return ret; } fprintf(stdout, "Test succeeded\n"); return 0; }
CS_RETCODE try_ctlogout(CS_CONTEXT * ctx, CS_CONNECTION * conn, CS_COMMAND * cmd, int verbose) { CS_RETCODE ret; ret = ct_cancel(conn, NULL, CS_CANCEL_ALL); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "ct_cancel() failed!\n"); } return ret; } ct_cmd_drop(cmd); ct_close(conn, CS_UNUSED); ct_con_drop(conn); ct_exit(ctx, CS_UNUSED); cs_ctx_drop(ctx); return CS_SUCCEED; }
CS_RETCODE SybConnection::ctx_cleanup_(CS_RETCODE status) { if (sContext_) { CS_RETCODE retcode; CS_INT exit_option; exit_option = (status != CS_SUCCEED) ? CS_FORCE_EXIT : CS_UNUSED; retcode = ct_exit(sContext_, exit_option); if (retcode != CS_SUCCEED) { SysLogger::error("con_cleanup_: ct_exit() failed"); return retcode; } retcode = cs_ctx_drop(sContext_); if (retcode != CS_SUCCEED) { SysLogger::error("con_cleanup_: cs_ctx_drop() failed"); return retcode; } return retcode; } else { return CS_SUCCEED; } }
int main(int argc, char **argv) { CS_RETCODE ret; #ifdef tds_sysdep_int64_type volatile tds_sysdep_int64_type one = 1; #endif int verbose = 1; fprintf(stdout, "%s: Testing conversion\n", __FILE__); ret = cs_ctx_alloc(CS_VERSION_100, &ctx); if (ret != CS_SUCCEED) { fprintf(stderr, "Init failed\n"); return 1; } /* TODO For each conversion test different values of fromlen and tolen */ /* * * INT to everybody */ DO_TEST(CS_INT test = 12345; CS_INT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 12345; CS_INT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(test2) * 2, CS_SUCCEED, &test2, sizeof(test2)); /* FIXME: correct ?? */ DO_TEST(CS_INT test = 12345; CS_INT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(CS_SMALLINT), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 1234; CS_SMALLINT test2 = 1234, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, 1, CS_SUCCEED, &test2, sizeof(test2)); /* biggest and smallest SMALLINT */ DO_TEST(CS_INT test = 32767; CS_SMALLINT test2 = 32767, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = -32768; CS_SMALLINT test2 = -32768, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); /* overflow */ DO_TEST(CS_INT test = 32768; CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0); DO_TEST(CS_INT test = -32769; CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0); /* biggest and smallest TINYINT */ DO_TEST(CS_INT test = 255; CS_TINYINT test2 = 255, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 0; CS_TINYINT test2 = 0, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); /* overflow */ DO_TEST(CS_INT test = 256; CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0); DO_TEST(CS_INT test = -1; CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0); /* biggest and smallest BIT */ DO_TEST(CS_INT test = 1; CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 0; CS_BYTE test2 = 0, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); /* overflow FIXME: or 1 if != 0 ?? */ DO_TEST(CS_INT test = 2; CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = -1; CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 1234; CS_REAL test2 = 1234.0, CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = -8765; CS_REAL test2 = -8765.0, CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 1234; CS_FLOAT test2 = 1234.0, CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = -8765; CS_FLOAT test2 = -8765.0, CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = 1234678; CS_MONEY4 test2 = { 1234678} , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0); DO_TEST(CS_INT test = -8765; CS_MONEY4 test2 = { -8765 * 10000} , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); /* strange money formatting */ DO_TEST(CS_CHAR test[] = ""; CS_MONEY4 test2 = { 0} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = "."; CS_MONEY4 test2 = { 0} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = ".12"; CS_MONEY4 test2 = { 1200} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = "++++-123"; CS_MONEY4 test2 = { -123 * 10000} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0); DO_TEST(CS_CHAR test[] = " -123"; CS_MONEY4 test2 = { -123 * 10000} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = " +123"; CS_MONEY4 test2 = { 123 * 10000} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = "+123.1234"; CS_MONEY4 test2 = { 1231234} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = "+123.123411"; CS_MONEY4 test2 = { 1231234} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_CHAR test[] = "+123.12.3411"; CS_MONEY4 test2 = { 1231234} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0); DO_TEST(CS_CHAR test[] = "pippo"; CS_MONEY4 test2 = { 0} , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0); /* not terminated money */ DO_TEST(CS_CHAR test[] = "-1234567"; CS_MONEY4 test2 = { -1230000} , CS_CHAR_TYPE, test, 4, CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); #ifdef tds_sysdep_int64_type DO_TEST(CS_INT test = 1234678; CS_MONEY test2; test2.mnyhigh = ((one * 1234678) * 10000) >> 32; test2.mnylow = (CS_UINT) ((one * 1234678) * 10000), CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); DO_TEST(CS_INT test = -8765; CS_MONEY test2; test2.mnyhigh = ((one * -8765) * 10000) >> 32; test2.mnylow = (CS_UINT) ((one * -8765) * 10000), CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); #endif DO_TEST(CS_INT test = 12345; CS_CHAR test2[] = "12345", CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, sizeof(test2), CS_SUCCEED, test2, sizeof(test2) - 1); { CS_VARCHAR test2 = { 5, "12345"}; memset(test2.str+5, 23, 251); DO_TEST(CS_INT test = 12345, CS_INT_TYPE,&test,sizeof(test), CS_VARCHAR_TYPE,sizeof(test2), CS_SUCCEED,&test2,sizeof(test2)); } DO_TEST(CS_CHAR test[] = "12345"; CS_INT test2 = 12345, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); /* unterminated number */ DO_TEST(CS_CHAR test[] = " - 12345"; CS_INT test2 = -12, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2)); /* to binary */ DO_TEST(CS_CHAR test[] = "abc"; CS_CHAR test2[] = "abc", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3); #if 0 DO_TEST(CS_CHAR test[] = "abcdef"; CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 6, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2); DO_TEST(CS_CHAR test[] = "abc"; CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2); #endif DO_TEST(CS_CHAR test[] = "616263"; CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 6, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3); DO_TEST(CS_CHAR test[] = "616263646566"; CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3); /* to char */ DO_TEST(CS_INT test = 1234567; CS_CHAR test2[] = "1234567", CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, 7, CS_SUCCEED, test2, 7); DO_TEST(CS_CHAR test[] = "abc"; CS_CHAR test2[] = "ab", CS_CHAR_TYPE, test, 3, CS_CHAR_TYPE, 2, CS_FAIL, test2, 2); DO_TEST(CS_CHAR test[] = "abc"; CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 3, CS_CHAR_TYPE, 6, CS_SUCCEED, test2, 6); DO_TEST(CS_CHAR test[] = "abcdef"; CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 6, CS_CHAR_TYPE, 6, CS_FAIL, test2, 6); ret = cs_ctx_drop(ctx); if (ret != CS_SUCCEED) { fprintf(stderr, "Drop failed\n"); return 2; } if (verbose && allSuccess) { fprintf(stdout, "Test succeded\n"); } return allSuccess ? 0 : 1; }
int main(int argc, char **argv) { int verbose = 1; CS_CONTEXT *ctx; CS_CHAR string_in[16], string_out[16]; CS_INT int_in, int_out; CS_INT ret_len; if (verbose) { fprintf(stdout, "Trying cs_config with CS_USERDATA\n\n"); } if (cs_ctx_alloc(CS_VERSION_100, &ctx) != CS_SUCCEED) { fprintf(stderr, "cs_ctx_alloc() for first context failed\n"); } if (ct_init(ctx, CS_VERSION_100) != CS_SUCCEED) { fprintf(stderr, "ct_init() for first context failed\n"); } fprintf(stdout, "Testing CS_SET/GET USERDATA with char array\n"); strcpy(string_in,"FreeTDS"); if (cs_config(ctx, CS_SET, CS_USERDATA, (CS_VOID *)string_in, CS_NULLTERM, NULL) != CS_SUCCEED) { fprintf(stderr, "cs_config() set failed\n"); return 1; } if (cs_config(ctx, CS_GET, CS_USERDATA, (CS_VOID *)string_out, 16, &ret_len) != CS_SUCCEED) { fprintf(stderr, "cs_config() get failed\n"); return 1; } if (strcmp(string_in, string_out)) { fprintf(stdout, "returned value >%s< not as stored >%s<\n", (char *)string_out, (char *)string_in); return 1; } if (ret_len != (strlen(string_in) + 1)) { fprintf(stdout, "returned length >%d< not as expected >%u<\n", ret_len, (unsigned int) (strlen(string_in) + 1)); return 1; } fprintf(stdout, "Testing CS_SET/GET USERDATA with char array\n"); strcpy(string_in,"FreeTDS"); if (cs_config(ctx, CS_SET, CS_USERDATA, (CS_VOID *)string_in, CS_NULLTERM, NULL) != CS_SUCCEED) { fprintf(stderr, "cs_config() set failed\n"); return 1; } strcpy(string_out,"XXXXXXXXXXXXXXX"); if (cs_config(ctx, CS_GET, CS_USERDATA, (CS_VOID *)string_out, 4, &ret_len) != CS_SUCCEED) { fprintf(stderr, "cs_config() get failed\n"); return 1; } if (strcmp(string_out, "FreeXXXXXXXXXXX")) { fprintf(stdout, "returned value >%s< not as expected >%s<\n", (char *)string_out, "FreeXXXXXXXXXXX"); return 1; } if (ret_len != (strlen(string_in) + 1)) { fprintf(stdout, "returned length >%d< not as expected >%u<\n", ret_len, (unsigned int) (strlen(string_in) + 1)); return 1; } fprintf(stdout, "Testing CS_SET/GET USERDATA with int\n"); int_in = 255; if (cs_config(ctx, CS_SET, CS_USERDATA, (CS_VOID *)&int_in, sizeof(int), NULL) != CS_SUCCEED) { fprintf(stderr, "cs_config() set failed\n"); return 1; } if (cs_config(ctx, CS_GET, CS_USERDATA, (CS_VOID *)&int_out, sizeof(int), &ret_len) != CS_SUCCEED) { fprintf(stderr, "cs_config() get failed\n"); return 1; } if (int_in != int_out) { fprintf(stdout, "returned value >%d< not as stored >%d<\n", int_out, int_in); return 1; } if (ret_len != (sizeof(int))) { fprintf(stdout, "returned length >%d< not as expected >%u<\n", ret_len, (unsigned int) sizeof(int)); return 1; } cs_ctx_drop(ctx); return 0; }
CS_RETCODE continue_logging_in(CS_CONTEXT ** ctx, CS_CONNECTION ** conn, CS_COMMAND ** cmd, int verbose) { CS_RETCODE ret; char query[30]; #ifdef TDS_STATIC_CAST TDSCONTEXT *tds_ctx; #endif ret = cs_ctx_alloc(CS_VERSION_100, ctx); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "Context Alloc failed!\n"); } return ret; } #ifdef TDS_STATIC_CAST /* Force default date format, some tests rely on it */ tds_ctx = (TDSCONTEXT *) (*ctx)->tds_ctx; if (tds_ctx && tds_ctx->locale && tds_ctx->locale->date_fmt) { free(tds_ctx->locale->date_fmt); tds_ctx->locale->date_fmt = strdup("%b %d %Y %I:%M%p"); } #endif ret = ct_init(*ctx, CS_VERSION_100); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "Library Init failed!\n"); } return ret; } if ((ret = ct_callback(*ctx, NULL, CS_SET, CS_CLIENTMSG_CB, (CS_VOID*) clientmsg_cb)) != CS_SUCCEED) { fprintf(stderr, "ct_callback() failed\n"); return ret; } if ((ret = ct_callback(*ctx, NULL, CS_SET, CS_SERVERMSG_CB, servermsg_cb)) != CS_SUCCEED) { fprintf(stderr, "ct_callback() failed\n"); return ret; } ret = ct_con_alloc(*ctx, conn); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "Connect Alloc failed!\n"); } return ret; } ret = ct_con_props(*conn, CS_SET, CS_USERNAME, USER, CS_NULLTERM, NULL); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "ct_con_props() SET USERNAME failed!\n"); } return ret; } ret = ct_con_props(*conn, CS_SET, CS_PASSWORD, PASSWORD, CS_NULLTERM, NULL); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "ct_con_props() SET PASSWORD failed!\n"); } return ret; } printf("connecting as %s to %s.%s\n", USER, SERVER, DATABASE); ret = ct_connect(*conn, SERVER, CS_NULLTERM); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "Connection failed!\n"); } ct_con_drop(*conn); *conn = NULL; cs_ctx_drop(*ctx); *ctx = NULL; return ret; } ret = ct_cmd_alloc(*conn, cmd); if (ret != CS_SUCCEED) { if (verbose) { fprintf(stderr, "Command Alloc failed!\n"); } ct_con_drop(*conn); *conn = NULL; cs_ctx_drop(*ctx); *ctx = NULL; return ret; } strcpy(query, "use "); strncat(query, DATABASE, 20); ret = run_command(*cmd, query); if (ret != CS_SUCCEED) return ret; return CS_SUCCEED; }
/* * ct_send SQL |select name = @@servername| * ct_bind variable * ct_fetch and print results */ int main(int argc, char **argv) { int verbose = 1; CS_CONTEXT *ctx; CS_RETCODE ret; CS_DATAFMT srcfmt; CS_INT src = 32768; CS_DATAFMT dstfmt; CS_SMALLINT dst; CS_DATETIME dst_date; int i; CS_INT num_msgs; CS_CLIENTMSG client_message; fprintf(stdout, "%s: Testing context callbacks\n", __FILE__); srcfmt.datatype = CS_INT_TYPE; srcfmt.maxlength = sizeof(CS_INT); srcfmt.locale = NULL; dstfmt.datatype = CS_SMALLINT_TYPE; dstfmt.maxlength = sizeof(CS_SMALLINT); dstfmt.locale = NULL; if (verbose) { fprintf(stdout, "Trying clientmsg_cb with context\n"); } if (cs_ctx_alloc(CS_VERSION_100, &ctx) != CS_SUCCEED) { fprintf(stderr, "cs_ctx_alloc() failed\n"); } if (ct_init(ctx, CS_VERSION_100) != CS_SUCCEED) { fprintf(stderr, "ct_init() failed\n"); } if (cs_diag(ctx, CS_INIT, CS_UNUSED, CS_UNUSED, NULL) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_INIT) failed\n"); return 1; } if (cs_convert(ctx, &srcfmt, &src, &dstfmt, &dst, NULL) == CS_SUCCEED) { fprintf(stderr, "cs_convert() succeeded when failure was expected\n"); return 1; } dstfmt.datatype = CS_DATETIME_TYPE; dstfmt.maxlength = sizeof(CS_DATETIME); dstfmt.locale = NULL; if (cs_convert(ctx, &srcfmt, &src, &dstfmt, &dst_date, NULL) == CS_SUCCEED) { fprintf(stderr, "cs_convert() succeeded when failure was expected\n"); return 1; } if (cs_diag(ctx, CS_STATUS, CS_CLIENTMSG_TYPE, CS_UNUSED, &num_msgs) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_STATUS) failed\n"); return 1; } for (i = 0; i < num_msgs; i++ ) { if (cs_diag(ctx, CS_GET, CS_CLIENTMSG_TYPE, i + 1, &client_message) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_GET) failed\n"); return 1; } cslibmsg_cb(NULL, &client_message); } if ((ret = cs_diag(ctx, CS_GET, CS_CLIENTMSG_TYPE, i + 1, &client_message)) != CS_NOMSG) { fprintf(stderr, "cs_diag(CS_GET) did not fail with CS_NOMSG\n"); return 1; } if (cs_diag(ctx, CS_CLEAR, CS_CLIENTMSG_TYPE, CS_UNUSED, NULL) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_CLEAR) failed\n"); return 1; } if (cs_diag(ctx, CS_STATUS, CS_CLIENTMSG_TYPE, CS_UNUSED, &num_msgs) != CS_SUCCEED) { fprintf(stderr, "cs_diag(CS_STATUS) failed\n"); return 1; } if (num_msgs != 0) { fprintf(stderr, "cs_diag(CS_CLEAR) failed there are still %d messages on queue\n", num_msgs); return 1; } if (ct_exit(ctx, CS_UNUSED) != CS_SUCCEED) { fprintf(stderr, "ct_exit() failed\n"); } if (cs_ctx_drop(ctx) != CS_SUCCEED) { fprintf(stderr, "cx_ctx_drop() failed\n"); } return 0; }