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; }
static VALUE connection_Close(VALUE self) { TDS_Connection* conn; Data_Get_Struct(self, TDS_Connection, conn); ct_close(conn->connection, CS_FORCE_CLOSE); ct_exit(conn->context, CS_FORCE_EXIT); conn->connection = NULL; conn->context = NULL; return Qnil; }
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; }
static void check_topology_on(dbref player, dbref i) { warn_type flags; /* Skip it if it's NOWARN or the player checking is the owner and * is NOWARN. Also skip GOING objects. */ if (Going(i) || NoWarn(i)) return; /* If the owner is checking, use the flags on the object, and fall back * on the owner's flags as default. If it's not the owner checking * (therefore, an admin), ignore the object flags, use the admin's flags */ if (Owner(player) == Owner(i)) { if (!(flags = Warnings(i))) flags = Warnings(player); } else flags = Warnings(player); ct_generic(player, i, flags); switch (Typeof(i)) { case TYPE_ROOM: ct_room(player, i, flags); break; case TYPE_THING: ct_thing(player, i, flags); break; case TYPE_EXIT: ct_exit(player, i, flags); break; case TYPE_PLAYER: ct_player(player, i, flags); break; } return; }
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; } }
/* * 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; }