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;
}
