/*
* pool_mbr_login open a single pool login, to be call at init time or
* to reconnect.
*/
static TDSSOCKET *
pool_mbr_login(TDS_POOL * pool)
{
TDSCONTEXT *context;
TDSLOGIN *login;
TDSSOCKET *tds;
TDSLOGIN *connection;
TDSRET rc;
char *query;
char hostname[MAXHOSTNAMELEN];
login = tds_alloc_login();
tds_set_passwd(login, pool->password);
tds_set_user(login, pool->user);
tds_set_app(login, "tdspool");
#if HAVE_GETHOSTNAME
if (gethostname(hostname, MAXHOSTNAMELEN) < 0)
#endif
tds_strlcpy(hostname, "tdspool", MAXHOSTNAMELEN);
tds_set_host(login, hostname);
tds_set_library(login, "TDS-Library");
tds_set_server(login, pool->server);
tds_set_client_charset(login, "iso_1");
tds_set_language(login, "us_english");
tds_set_packet(login, 512);
context = tds_alloc_context(NULL);
tds = tds_alloc_socket(context, 512);
connection = tds_read_config_info(tds, login, context->locale);
if (!connection || tds_connect_and_login(tds, connection) != TDS_SUCCESS) {
tds_free_socket(tds);
tds_free_login(connection);
/* what to do? */
fprintf(stderr, "Could not open connection to server %s\n", pool->server);
return NULL;
}
tds_free_login(connection);
/*
* FIXME -- tds_connect_and_login no longer preallocates the in_buf need to
* do something like what tds_read_packet does
*/
tds->in_buf = (unsigned char *) calloc(BLOCKSIZ, 1);
if (pool->database && strlen(pool->database)) {
query = (char *) malloc(strlen(pool->database) + 5);
sprintf(query, "use %s", pool->database);
rc = tds_submit_query(tds, query);
free(query);
if (rc != TDS_SUCCESS) {
fprintf(stderr, "changing database failed\n");
return NULL;
}
if (tds_process_simple_query(tds) != TDS_SUCCESS)
return NULL;
}
return tds;
}
/*
* pool_mbr_login open a single pool login, to be call at init time or
* to reconnect.
*/
static TDSSOCKET *
pool_mbr_login(TDS_POOL * pool)
{
TDSCONTEXT *context;
TDSLOGIN *login;
TDSSOCKET *tds;
TDSLOGIN *connection;
char hostname[MAXHOSTNAMELEN];
login = tds_alloc_login(1);
if (gethostname(hostname, MAXHOSTNAMELEN) < 0)
strlcpy(hostname, "tdspool", MAXHOSTNAMELEN);
if (!tds_set_passwd(login, pool->password)
|| !tds_set_user(login, pool->user)
|| !tds_set_app(login, "tdspool")
|| !tds_set_host(login, hostname)
|| !tds_set_library(login, "TDS-Library")
|| !tds_set_server(login, pool->server)
|| !tds_set_client_charset(login, "iso_1")
|| !tds_set_language(login, "us_english")) {
tds_free_login(login);
return NULL;
}
if (pool->database && strlen(pool->database)) {
if (!tds_dstr_copy(&login->database, pool->database)) {
tds_free_login(login);
return NULL;
}
}
context = tds_alloc_context(NULL);
tds = tds_alloc_socket(context, 512);
connection = tds_read_config_info(tds, login, context->locale);
if (!connection || TDS_FAILED(tds_connect_and_login(tds, connection))) {
tds_free_socket(tds);
tds_free_login(connection);
/* what to do? */
fprintf(stderr, "Could not open connection to server %s\n", pool->server);
return NULL;
}
tds_free_login(connection);
if (pool->database && strlen(pool->database)) {
if (strcasecmp(tds->conn->env.database, pool->database) != 0) {
fprintf(stderr, "changing database failed\n");
return NULL;
}
}
return tds;
}
/** Destroy a DSNINFO struct, freeing all memory associated with it */
static void
free_dsninfo(DSNINFO * di)
{ /* the DSNINFO struct to be freed */
tds_free_login(di->login);
tds_dstr_free(&di->origdsn);
tds_dstr_free(&di->dsn);
free(di);
}
/* Note that this always suceeds */
int
try_tds_logout(TDSLOGIN * login, TDSSOCKET * tds, int verbose)
{
if (verbose) {
fprintf(stdout, "Entered tds_try_logout()\n");
}
tds_free_socket(tds);
tds_free_login(login);
tds_free_context(test_context);
test_context = NULL;
return TDS_SUCCEED;
}
void CloseDB()
{
if (sock)
{
tds_free_socket(sock);
sock = NULL;
}
if (context)
{
tds_free_context(context);
context = NULL;
}
if (login)
{
tds_free_login(login);
login = NULL;
}
}
/*
* pool_free_user
* close out a disconnected user.
*/
void
pool_free_user(TDS_POOL *pool, TDS_POOL_USER * puser)
{
TDS_POOL_MEMBER *pmbr = puser->assigned_member;
if (pmbr) {
pool_deassign_member(pmbr);
pool_reset_member(pool, pmbr);
}
tds_free_socket(puser->sock.tds);
tds_free_login(puser->login);
/* make sure to decrement the waiters list if he is waiting */
if (puser->user_state == TDS_SRV_WAIT)
dlist_user_remove(&pool->waiters, puser);
else
dlist_user_remove(&pool->users, puser);
pool->num_users--;
free(puser);
}
static int mssql_disconnect(void)
{
if (tds) {
tds_free_socket(tds);
tds = NULL;
}
if (context) {
tds_free_context(context);
context = NULL;
}
if (login) {
tds_free_login(login);
login = NULL;
}
connected = 0;
return 0;
}
// close database
bool TdsDatabaseLayer::Close()
{
//puts("Resetting error codes");
ResetErrorCodes();
//puts("Closing result sets");
CloseResultSets();
//puts("Closing statements");
CloseStatements();
if (m_pDatabase != NULL)
{
//puts("Freeing socket");
tds_free_socket(m_pDatabase);
m_pDatabase = NULL;
}
if (m_pLogin != NULL)
{
//puts("Freeing login");
tds_free_login(m_pLogin);
m_pLogin = NULL;
}
if (m_pContext != NULL)
{
// Remove the context (and this databaselayer) from the lookup map
// used by the error handler
//puts("Removing TDS layer from hash");
TdsDatabaseLayer::RemoveTdsLayer(m_pContext);
// Free the context
//puts("Freeing context");
tds_free_context(m_pContext);
m_pContext = NULL;
}
return true;
}
/**
* tds_read_config_info() will fill the tds connection structure based on configuration
* information gathered in the following order:
* 1) Program specified in TDSLOGIN structure
* 2) The environment variables TDSVER, TDSDUMP, TDSPORT, TDSQUERY, TDSHOST
* 3) A config file with the following search order:
* a) a readable file specified by environment variable FREETDSCONF
* b) a readable file in ~/.freetds.conf
* c) a readable file in $prefix/etc/freetds.conf
* 3) ~/.interfaces if exists
* 4) $SYBASE/interfaces if exists
* 5) TDS_DEF_* default values
*
* .tdsrc and freetds.conf have been added to make the package easier to
* integration with various Linux and *BSD distributions.
*/
TDSLOGIN *
tds_read_config_info(TDSSOCKET * tds, TDSLOGIN * login, TDSLOCALE * locale)
{
TDSLOGIN *connection;
char *s;
char *path;
pid_t pid;
int opened = 0, found;
struct addrinfo *addrs;
/* allocate a new structure with hard coded and build-time defaults */
connection = tds_alloc_login(0);
if (!connection || !tds_init_login(connection, locale)) {
tds_free_login(connection);
return NULL;
}
s = getenv("TDSDUMPCONFIG");
if (s) {
if (*s) {
opened = tdsdump_open(s);
} else {
pid = getpid();
if (asprintf(&path, pid_config_logpath, pid) >= 0) {
if (*path) {
opened = tdsdump_open(path);
}
free(path);
}
}
}
tdsdump_log(TDS_DBG_INFO1, "Getting connection information for [%s].\n",
tds_dstr_cstr(&login->server_name)); /* (The server name is set in login.c.) */
/* Read the config files. */
tdsdump_log(TDS_DBG_INFO1, "Attempting to read conf files.\n");
found = tds_read_conf_file(connection, tds_dstr_cstr(&login->server_name));
if (!found) {
if (parse_server_name_for_port(connection, login)) {
found = tds_read_conf_file(connection, tds_dstr_cstr(&connection->server_name));
/* do it again to really override what found in freetds.conf */
if (found) {
parse_server_name_for_port(connection, login);
} else if (TDS_SUCCEED(tds_lookup_host_set(tds_dstr_cstr(&connection->server_name), &connection->ip_addrs))) {
if (!tds_dstr_dup(&connection->server_host_name, &connection->server_name)) {
tds_free_login(connection);
return NULL;
}
found = 1;
}
}
}
if (!found) {
/* fallback to interfaces file */
tdsdump_log(TDS_DBG_INFO1, "Failed in reading conf file. Trying interface files.\n");
if (!tds_read_interfaces(tds_dstr_cstr(&login->server_name), connection)) {
tdsdump_log(TDS_DBG_INFO1, "Failed to find [%s] in configuration files; trying '%s' instead.\n",
tds_dstr_cstr(&login->server_name), tds_dstr_cstr(&connection->server_name));
if (connection->ip_addrs == NULL)
tdserror(tds_get_ctx(tds), tds, TDSEINTF, 0);
}
}
/* Override config file settings with environment variables. */
tds_fix_login(connection);
/* And finally apply anything from the login structure */
if (!tds_config_login(connection, login)) {
tds_free_login(connection);
return NULL;
}
if (opened) {
char tmp[128];
tdsdump_log(TDS_DBG_INFO1, "Final connection parameters:\n");
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "server_name", tds_dstr_cstr(&connection->server_name));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "server_host_name", tds_dstr_cstr(&connection->server_host_name));
for (addrs = connection->ip_addrs; addrs != NULL; addrs = addrs->ai_next)
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "ip_addr", tds_addrinfo2str(addrs, tmp, sizeof(tmp)));
if (connection->ip_addrs == NULL)
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "ip_addr", "");
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "instance_name", tds_dstr_cstr(&connection->instance_name));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "port", connection->port);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "major_version", TDS_MAJOR(connection));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "minor_version", TDS_MINOR(connection));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "block_size", connection->block_size);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "language", tds_dstr_cstr(&connection->language));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "server_charset", tds_dstr_cstr(&connection->server_charset));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "connect_timeout", connection->connect_timeout);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "client_host_name", tds_dstr_cstr(&connection->client_host_name));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "client_charset", tds_dstr_cstr(&connection->client_charset));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "use_utf16", connection->use_utf16);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "app_name", tds_dstr_cstr(&connection->app_name));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "user_name", tds_dstr_cstr(&connection->user_name));
/* tdsdump_log(TDS_DBG_PASSWD, "\t%20s = %s\n", "password", tds_dstr_cstr(&connection->password));
(no such flag yet) */
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "library", tds_dstr_cstr(&connection->library));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "bulk_copy", (int)connection->bulk_copy);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "suppress_language", (int)connection->suppress_language);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "encrypt level", (int)connection->encryption_level);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "query_timeout", connection->query_timeout);
/* tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "capabilities", tds_dstr_cstr(&connection->capabilities));
(not null terminated) */
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "database", tds_dstr_cstr(&connection->database));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "dump_file", tds_dstr_cstr(&connection->dump_file));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %x\n", "debug_flags", connection->debug_flags);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "text_size", connection->text_size);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "emul_little_endian", connection->emul_little_endian);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "server_realm_name", tds_dstr_cstr(&connection->server_realm_name));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "server_spn", tds_dstr_cstr(&connection->server_spn));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "cafile", tds_dstr_cstr(&connection->cafile));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "crlfile", tds_dstr_cstr(&connection->crlfile));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "check_ssl_hostname", connection->check_ssl_hostname);
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %s\n", "db_filename", tds_dstr_cstr(&connection->db_filename));
tdsdump_log(TDS_DBG_INFO1, "\t%20s = %d\n", "readonly_intent", connection->readonly_intent);
tdsdump_close();
}
/*
* If a dump file has been specified, start logging
*/
if (!tds_dstr_isempty(&connection->dump_file) && !tdsdump_isopen()) {
if (connection->debug_flags)
tds_debug_flags = connection->debug_flags;
tdsdump_open(tds_dstr_cstr(&connection->dump_file));
}
return connection;
}
int
try_tds_login(TDSLOGIN ** login, TDSSOCKET ** tds, const char *appname, int verbose)
{
TDSLOGIN *connection;
const char* base_appname;
base_appname = strrchr(appname, '/');
if (base_appname == NULL) {
base_appname = appname;
} else {
++base_appname;
}
if (verbose) {
fprintf(stdout, "Entered tds_try_login()\n");
}
if (!login) {
fprintf(stderr, "Invalid TDSLOGIN**\n");
return TDS_FAIL;
}
if (!tds) {
fprintf(stderr, "Invalid TDSSOCKET**\n");
return TDS_FAIL;
}
if (verbose) {
fprintf(stdout, "Trying read_login_info()\n");
}
read_login_info();
if (verbose) {
fprintf(stdout, "Setting login parameters\n");
}
*login = tds_alloc_login(1);
if (!*login) {
fprintf(stderr, "tds_alloc_login() failed.\n");
return TDS_FAIL;
}
tds_set_passwd(*login, PASSWORD);
tds_set_user(*login, USER);
tds_set_app(*login, base_appname);
tds_set_host(*login, "myhost");
tds_set_library(*login, "TDS-Library");
tds_set_server(*login, SERVER);
tds_set_client_charset(*login, CHARSET);
tds_set_language(*login, "us_english");
if (verbose) {
fprintf(stdout, "Connecting to database\n");
}
test_context = tds_alloc_context(NULL);
*tds = tds_alloc_socket(test_context, 512);
tds_set_parent(*tds, NULL);
connection = tds_read_config_info(*tds, *login, test_context->locale);
if (!connection || tds_connect_and_login(*tds, connection) != TDS_SUCCESS) {
if (connection) {
tds_free_socket(*tds);
*tds = NULL;
tds_free_login(connection);
}
fprintf(stderr, "tds_connect_and_login() failed\n");
return TDS_FAIL;
}
tds_free_login(connection);
return TDS_SUCCESS;
}
bool
pool_user_send_login_ack(TDS_POOL * pool, TDS_POOL_USER * puser)
{
char msg[256];
char block[32];
TDSSOCKET *tds = puser->sock.tds, *mtds = puser->assigned_member->sock.tds;
TDSLOGIN *login = puser->login;
const char *database;
const char *server = mtds->conn->server ? mtds->conn->server : "JDBC";
bool dbname_mismatch, odbc_mismatch;
pool->user_logins++;
/* copy a bit of information, resize socket with block */
tds->conn->tds_version = mtds->conn->tds_version;
tds->conn->product_version = mtds->conn->product_version;
memcpy(tds->conn->collation, mtds->conn->collation, sizeof(tds->conn->collation));
tds->conn->tds71rev1 = mtds->conn->tds71rev1;
free(tds->conn->product_name);
tds->conn->product_name = strdup(mtds->conn->product_name);
tds_realloc_socket(tds, mtds->conn->env.block_size);
tds->conn->env.block_size = mtds->conn->env.block_size;
tds->conn->client_spid = mtds->conn->spid;
/* if database is different use USE statement */
database = pool->database;
dbname_mismatch = !tds_dstr_isempty(&login->database)
&& strcasecmp(tds_dstr_cstr(&login->database), database) != 0;
odbc_mismatch = (login->option_flag2 & TDS_ODBC_ON) == 0;
if (dbname_mismatch || odbc_mismatch) {
char *str;
int len = 128 + tds_quote_id(mtds, NULL, tds_dstr_cstr(&login->database),-1);
TDSRET ret;
if ((str = (char *) malloc(len)) == NULL)
return false;
str[0] = 0;
/* swicth to dblib options */
if (odbc_mismatch)
strcat(str, "SET ANSI_DEFAULTS OFF\nSET CONCAT_NULL_YIELDS_NULL OFF\n");
if (dbname_mismatch) {
strcat(str, "USE ");
tds_quote_id(mtds, strchr(str, 0), tds_dstr_cstr(&login->database), -1);
}
ret = tds_submit_query(mtds, str);
free(str);
if (TDS_FAILED(ret) || TDS_FAILED(tds_process_simple_query(mtds)))
return false;
if (dbname_mismatch)
database = tds_dstr_cstr(&login->database);
else
database = mtds->conn->env.database;
}
// 7.0
// env database
// database change message (with server name correct)
// env language
// language change message
// env 0x3 charset ("iso_1")
// env 0x5 lcid ("1033")
// env 0x6 ("196609" ?? 0x30001)
// loginack
// env 0x4 packet size
// done
//
// 7.1/7.2/7.3
// env database
// database change message (with server name correct)
// env 0x7 collation
// env language
// language change message
// loginack
// env 0x4 packet size
// done
tds->out_flag = TDS_REPLY;
tds_env_change(tds, TDS_ENV_DATABASE, "master", database);
sprintf(msg, "Changed database context to '%s'.", database);
tds_send_msg(tds, 5701, 2, 0, msg, server, NULL, 1);
if (!login->suppress_language) {
tds_env_change(tds, TDS_ENV_LANG, NULL, "us_english");
tds_send_msg(tds, 5703, 1, 0, "Changed language setting to 'us_english'.", server, NULL, 1);
}
if (IS_TDS71_PLUS(tds->conn)) {
tds_put_byte(tds, TDS_ENVCHANGE_TOKEN);
tds_put_smallint(tds, 8);
tds_put_byte(tds, TDS_ENV_SQLCOLLATION);
tds_put_byte(tds, 5);
tds_put_n(tds, tds->conn->collation, 5);
tds_put_byte(tds, 0);
}
tds_send_login_ack(tds, mtds->conn->product_name);
sprintf(block, "%d", tds->conn->env.block_size);
tds_env_change(tds, TDS_ENV_PACKSIZE, block, block);
/* tds_send_capabilities_token(tds); */
tds_send_done_token(tds, 0, 0);
/* send it! */
tds_flush_packet(tds);
tds_free_login(login);
puser->login = NULL;
return true;
}
// Connect to the server
bool TdsDatabaseLayer::Connect()
{
m_pLogin = tds_alloc_login();
if (m_pLogin == NULL)
{
//fprintf(stderr, "tds_alloc_login() failed.\n");
SetError(DATABASE_LAYER_ERROR, wxT("Failed to allocate login"));
// Reset the variables so there are not mistaken as initialized
m_pDatabase = NULL;
m_pLogin = NULL;
if (m_pContext)
{
tds_free_context(m_pContext);
m_pContext = NULL;
}
ThrowDatabaseException();
return false;
}
wxCharBuffer serverBuffer = ConvertToUnicodeStream(m_strServer);
tds_set_server(m_pLogin, serverBuffer);
wxCharBuffer loginBuffer = ConvertToUnicodeStream(m_strLogin);
tds_set_user(m_pLogin, loginBuffer);
wxCharBuffer passwordBuffer = ConvertToUnicodeStream(m_strPassword);
tds_set_passwd(m_pLogin, passwordBuffer);
tds_set_app(m_pLogin, "DatabaseLayer");
tds_set_library(m_pLogin, "TDS-Library");
tds_set_client_charset(m_pLogin, "UTF-8");
switch (m_nTdsVersion)
{
case TDS_42:
tds_set_version(m_pLogin, 4, 2);
break;
case TDS_46:
tds_set_version(m_pLogin, 4, 6);
break;
case TDS_50:
tds_set_version(m_pLogin, 5, 0);
break;
case TDS_70:
tds_set_version(m_pLogin, 7, 0);
break;
case TDS_80:
tds_set_version(m_pLogin, 8, 0);
break;
default:
tds_set_version(m_pLogin, 0, 0);
break;
};
m_pContext = tds_alloc_context(NULL);
if (m_pContext == NULL)
{
//fprintf(stderr, "tds_alloc_context() failed.\n");
SetError(DATABASE_LAYER_ERROR, wxT("Failed to allocate context"));
// Reset the variables so there are not mistaken as initialized
m_pDatabase = NULL;
if (m_pLogin)
{
tds_free_login(m_pLogin);
m_pLogin = NULL;
}
if (m_pContext)
{
tds_free_context(m_pContext);
m_pContext = NULL;
}
ThrowDatabaseException();
return false;
}
m_pContext->msg_handler = tsql_handle_message;
m_pContext->err_handler = tsql_handle_error;
// Add the context (and this databaselayer) from the lookup map
// used by the error handler
TdsDatabaseLayer::AddTdsLayer(m_pContext, this);
m_pDatabase = tds_alloc_socket(m_pContext, 512);
if (m_pDatabase == NULL)
{
//fprintf(stderr, "tds_alloc_socket() failed.\n");
SetError(DATABASE_LAYER_ERROR, wxT("Failed to allocate socket"));
// Reset the variables so there are not mistaken as initialized
m_pDatabase = NULL;
if (m_pLogin)
{
tds_free_login(m_pLogin);
m_pLogin = NULL;
}
if (m_pContext)
{
tds_free_context(m_pContext);
m_pContext = NULL;
}
ThrowDatabaseException();
return false;
}
tds_set_parent(m_pDatabase, NULL);
TDSCONNECTION* pConnection = tds_read_config_info(NULL, m_pLogin, m_pContext->locale);
if (!pConnection || tds_connect(m_pDatabase, pConnection) == TDS_FAIL)
{
if (pConnection)
{
tds_free_socket(m_pDatabase);
//m_pDatabase = NULL;
tds_free_connection(pConnection);
}
//fprintf(stderr, "tds_connect() failed\n");
if (GetErrorCode() == DATABASE_LAYER_OK)
{
SetError(DATABASE_LAYER_ERROR, wxT("Database connection failed"));
}
// Reset the variables so there are not mistaken as initialized
m_pDatabase = NULL;
if (m_pLogin)
{
tds_free_login(m_pLogin);
m_pLogin = NULL;
}
if (m_pContext)
{
tds_free_context(m_pContext);
m_pContext = NULL;
}
ThrowDatabaseException();
return false;
}
tds_free_connection(pConnection);
return true;
}
int
main(int argc, char **argv)
{
TDSCONTEXT *ctx;
TDSSOCKET *tds;
TDSLOGIN *login;
TDSRESULTINFO *resinfo;
if (argc < 2 || atoi(argv[1]) <= 0) {
fprintf(stderr, "syntax: %s <port>\n", argv[0]);
return 1;
}
ctx = tds_alloc_context(NULL);
tds = tds_listen(ctx, atoi(argv[1]));
if (!tds)
return 1;
/* get_incoming(tds->s); */
login = tds_alloc_read_login(tds);
if (!login) {
fprintf(stderr, "Error reading login\n");
exit(1);
}
dump_login(login);
if (!strcmp(tds_dstr_cstr(&login->user_name), "guest") && !strcmp(tds_dstr_cstr(&login->password), "sybase")) {
tds->out_flag = TDS_REPLY;
tds_env_change(tds, TDS_ENV_DATABASE, "master", "pubs2");
tds_send_msg(tds, 5701, 2, 10, "Changed database context to 'pubs2'.", "JDBC", "ZZZZZ", 1);
if (!login->suppress_language) {
tds_env_change(tds, TDS_ENV_LANG, NULL, "us_english");
tds_send_msg(tds, 5703, 1, 10, "Changed language setting to 'us_english'.", "JDBC", "ZZZZZ", 1);
}
tds_env_change(tds, TDS_ENV_PACKSIZE, NULL, "512");
/* TODO set mssql if tds7+ */
tds_send_login_ack(tds, "sql server");
if (IS_TDS50(tds))
tds_send_capabilities_token(tds);
tds_send_done_token(tds, 0, 1);
} else {
/* send nack before exiting */
exit(1);
}
tds_flush_packet(tds);
tds_free_login(login);
login = NULL;
/* printf("incoming packet %d\n", tds_read_packet(tds)); */
printf("query : %s\n", tds_get_generic_query(tds));
tds->out_flag = TDS_REPLY;
resinfo = tds_alloc_results(1);
resinfo->columns[0]->column_type = SYBVARCHAR;
resinfo->columns[0]->column_size = 30;
strcpy(resinfo->columns[0]->column_name, "name");
resinfo->columns[0]->column_namelen = 4;
resinfo->current_row = (TDS_UCHAR*) "pubs2";
resinfo->columns[0]->column_data = resinfo->current_row;
tds_send_result(tds, resinfo);
tds_send_control_token(tds, 1);
tds_send_row(tds, resinfo);
tds_send_done_token(tds, 16, 1);
tds_flush_packet(tds);
sleep(30);
tds_free_results(resinfo);
tds_free_socket(tds);
tds_free_context(ctx);
return 0;
}
static void tdsl_free(void *login)
{
tds_free_login(login);
} // tdsl_free;
