ct.c

在Linux/Unix下面访问WINDOWS SQLSERVER 的ODBC驱动程序

			memcpy(buffer, &intval, sizeof(intval));
			break;
		case CS_BULK_LOGIN:
			if (tds_login->bulk_copy)
				intval = CS_FALSE;
			else
				intval = CS_TRUE;
			memcpy(buffer, &intval, sizeof(intval));
			break;
		case CS_PACKETSIZE:
			if (tds)
				intval = tds->env.block_size;
			else
				intval = tds_login->block_size;
			memcpy(buffer, &intval, sizeof(intval));
			if (out_len)
				*out_len = sizeof(intval);
			break;
		case CS_TDS_VERSION:
			switch (tds_version(tds, NULL)) {
			case 40:
				(*(int *) buffer = CS_TDS_40);
				break;
			case 42:
				(*(int *) buffer = CS_TDS_42);
				break;
			case 46:
				(*(int *) buffer = CS_TDS_46);
				break;
			case 40 + 95:
				(*(int *) buffer = CS_TDS_495);
				break;
			case 50:
				(*(int *) buffer = CS_TDS_50);
				break;
			case 70:
				(*(int *) buffer = CS_TDS_70);
				break;
			case 80:
				(*(int *) buffer = CS_TDS_80);
				break;
			default:
				return CS_FAIL;
			}
			break;
		case CS_PARENT_HANDLE:
			*(CS_CONTEXT **) buffer = con->ctx;
			break;

		default:
			tdsdump_log(TDS_DBG_ERROR, "Unknown property %d\n", property);
			break;
		}
	}
	return CS_SUCCEED;
}

CS_RETCODE
ct_connect(CS_CONNECTION * con, CS_CHAR * servername, CS_INT snamelen)
{
	char *server;
	int needfree = 0;
	CS_CONTEXT *ctx;
	TDSCONNECTION *connection;

	tdsdump_log(TDS_DBG_FUNC, "ct_connect() servername = %s\n", servername ? servername : "NULL");

	if (!tds_dstr_isempty(&con->tds_login->server_addr)) {
		server = tds_dstr_buf(&con->tds_login->server_addr);
	} else if (snamelen == 0 || snamelen == CS_UNUSED) {
		server = NULL;
	} else if (snamelen == CS_NULLTERM) {
		server = (char *) servername;
	} else {
		server = (char *) malloc(snamelen + 1);
		needfree++;
		strncpy(server, servername, snamelen);
		server[snamelen] = '\0';
	}
	tds_set_server(con->tds_login, server);
	if (needfree)
		free(server);
	ctx = con->ctx;
	if (!(con->tds_socket = tds_alloc_socket(ctx->tds_ctx, 512)))
		return CS_FAIL;
	tds_set_parent(con->tds_socket, (void *) con);
	if (!(connection = tds_read_config_info(NULL, con->tds_login, ctx->tds_ctx->locale))) {
		tds_free_socket(con->tds_socket);
		con->tds_socket = NULL;
		return CS_FAIL;
	}

	/* override locale settings with CS_CONNECTION settings, if any */
	if (con->locale) {
		if (con->locale->charset) {
			if (!tds_dstr_copy(&connection->server_charset, con->locale->charset)) 
				goto Cleanup;
		}
		if (con->locale->language) {
			if (!tds_dstr_copy(&connection->language, con->locale->language)) 
				goto Cleanup;
		}
		if (con->locale->time) {
			free(con->tds_socket->date_fmt);
			/* TODO convert format from CTLib to libTDS */
			con->tds_socket->date_fmt = strdup(con->locale->time);
			if (!con->tds_socket->date_fmt)
				goto Cleanup;
		}
		/* TODO how to handle this?
		if (con->locale->collate) {
		}
		*/
	}

	if (tds_connect(con->tds_socket, connection) == TDS_FAIL)
		goto Cleanup;

	tds_free_connection(connection);

	tdsdump_log(TDS_DBG_FUNC, "leaving ct_connect() returning %d\n", CS_SUCCEED);
	return CS_SUCCEED;

Cleanup:
	tds_free_socket(con->tds_socket);
	con->tds_socket = NULL;
	tds_free_connection(connection);
	tdsdump_log(TDS_DBG_FUNC, "leaving ct_connect() returning %d\n", CS_FAIL);
	return CS_FAIL;
}

CS_RETCODE
ct_cmd_alloc(CS_CONNECTION * con, CS_COMMAND ** cmd)
{

	CS_COMMAND_LIST *command_list;
	CS_COMMAND_LIST *pcommand;

	tdsdump_log(TDS_DBG_FUNC, "ct_cmd_alloc()\n");

	*cmd = (CS_COMMAND *) malloc(sizeof(CS_COMMAND));
	if (!*cmd)
		return CS_FAIL;
	memset(*cmd, '\0', sizeof(CS_COMMAND));

	/* so we know who we belong to */
	(*cmd)->con = con;

	/* initialise command state */
	ct_set_command_state(*cmd, _CS_COMMAND_IDLE);

	command_list = malloc(sizeof(CS_COMMAND_LIST));
	memset(command_list, '\0', sizeof(CS_COMMAND_LIST));
	command_list->cmd = *cmd;
	command_list->next = NULL;

	if ( con->cmds == NULL ) {
		tdsdump_log(TDS_DBG_FUNC, "ct_cmd_alloc() : allocating command list to head\n");
		con->cmds = command_list;
	} else {
		pcommand = con->cmds;
		for (;;) {
			tdsdump_log(TDS_DBG_FUNC, "ct_cmd_alloc() : stepping thru existing commands\n");
			if (pcommand->next == NULL)
				break;
			pcommand = pcommand->next;
		}
		pcommand->next = command_list;
	}

	return CS_SUCCEED;
}

CS_RETCODE
ct_command(CS_COMMAND * cmd, CS_INT type, const CS_VOID * buffer, CS_INT buflen, CS_INT option)
{
	int query_len;
	int current_query_len;

	tdsdump_log(TDS_DBG_FUNC, "ct_command()\n");

	/* Unless we are in the process of building a CS_LANG_CMD   */
	/* type command, then clear everything, ready to start anew */

	if (cmd->command_state != _CS_COMMAND_BUILDING) {
		_ct_initialise_cmd(cmd);
		ct_set_command_state(cmd, _CS_COMMAND_IDLE);
	}

	switch (type) {
	case CS_LANG_CMD:
		switch (option) {
		case CS_MORE:	/* The text in buffer is only part of the language command to be executed. */
		case CS_END:	/* The text in buffer is the last part of the language command to be executed. */
		case CS_UNUSED:	/* Equivalent to CS_END. */
			if (buflen == CS_NULLTERM) {
				query_len = strlen((const char *) buffer);
			} else {
				query_len = buflen;
			}
			/* small fix for no crash */
			if (query_len == CS_UNUSED) {
				cmd->query = NULL;
				return CS_FAIL;
			}
			if (cmd->command_state == _CS_COMMAND_IDLE) {
				cmd->query = (char *) malloc(query_len + 1);
				strncpy(cmd->query, (const char *) buffer, query_len);
				cmd->query[query_len] = '\0';
				if (option == CS_MORE) {
					ct_set_command_state(cmd, _CS_COMMAND_BUILDING);
				} else {
					ct_set_command_state(cmd, _CS_COMMAND_READY);
				}
			}
			if (cmd->command_state == _CS_COMMAND_BUILDING) {
				current_query_len = strlen(cmd->query);
				cmd->query = (char *) realloc(cmd->query, current_query_len + query_len + 1);
				strncat(cmd->query, (const char *) buffer, query_len);
				cmd->query[current_query_len + query_len] = '\0';
				if (option == CS_MORE) {
					ct_set_command_state(cmd, _CS_COMMAND_BUILDING);
				} else {
					ct_set_command_state(cmd, _CS_COMMAND_READY);
				}
			}

			break;
		default:
			return CS_FAIL;
		}
		break;

	case CS_RPC_CMD:

		/* Code changed for RPC functionality -SUHA */
		/* RPC code changes starts here */

		if (cmd == NULL)
			return CS_FAIL;

		cmd->rpc = (CSREMOTE_PROC *) malloc(sizeof(CSREMOTE_PROC));
		if (cmd->rpc == NULL)
			return CS_FAIL;

		memset(cmd->rpc, 0, sizeof(CSREMOTE_PROC));

		if (buflen == CS_NULLTERM) {
			cmd->rpc->name = strdup(buffer);
			if (cmd->rpc->name == NULL)
				return CS_FAIL;
		} else if (buflen > 0) {
			cmd->rpc->name = (char *) malloc(buflen + 1);
			if (cmd->rpc->name == NULL)
				return CS_FAIL;
			memset(cmd->rpc->name, 0, buflen + 1);
			strncpy(cmd->rpc->name, (const char *) buffer, buflen);
		} else {
			return CS_FAIL;
		}

		cmd->rpc->param_list = NULL;

		tdsdump_log(TDS_DBG_INFO1, "ct_command() added rpcname \"%s\"\n", cmd->rpc->name);

		/* FIXME: I don't know the value for RECOMPILE, NORECOMPILE options. Hence assigning zero  */
		switch (option) {
		case CS_RECOMPILE:	/* Recompile the stored procedure before executing it. */
			cmd->rpc->options = 0;
			break;
		case CS_NO_RECOMPILE:	/* Do not recompile the stored procedure before executing it. */
			cmd->rpc->options = 0;
			break;
		case CS_UNUSED:	/* Equivalent to CS_NO_RECOMPILE. */
			cmd->rpc->options = 0;
			break;
		default:
			return CS_FAIL;
		}
		ct_set_command_state(cmd, _CS_COMMAND_READY);
		break;
		/* RPC code changes ends here */

	case CS_SEND_DATA_CMD:
		switch (option) {
		case CS_COLUMN_DATA:	/* The data will be used for a text or image column update. */
			cmd->send_data_started = 0;
			break;
		case CS_BULK_DATA:	/* For internal Sybase use only. The data will be used for a bulk copy operation. */
		default:
			return CS_FAIL;
		}
		ct_set_command_state(cmd, _CS_COMMAND_READY);
		break;

	case CS_SEND_BULK_CMD:
		switch (option) {
		case CS_BULK_INIT:	/* For internal Sybase use only. Initialize a bulk copy operation. */
		case CS_BULK_CONT:	/* For internal Sybase use only. Continue a bulk copy operation. */
		default:
			return CS_FAIL;
		}
		ct_set_command_state(cmd, _CS_COMMAND_READY);
		break;

	default:
		return CS_FAIL;
	}

	cmd->command_type = type;


	return CS_SUCCEED;
}

static void
_ct_initialise_cmd(CS_COMMAND *cmd)
{
	free(cmd->query);
	cmd->query = NULL;

	if (cmd->input_params) {
		param_clear(cmd->input_params);
		cmd->input_params = NULL;
	}
	ct_set_command_state(cmd, _CS_COMMAND_IDLE);

	rpc_clear(cmd->rpc);
	cmd->rpc = NULL;
}

CS_RETCODE
ct_send(CS_COMMAND * cmd)
{
	TDSSOCKET *tds;
	CS_RETCODE ret;
	CSREMOTE_PROC **rpc;
	TDSPARAMINFO *pparam_info;
	TDSCURSOR *cursor;
	TDSDYNAMIC *tdsdyn;

	tdsdump_log(TDS_DBG_FUNC, "ct_send() command_type = %d\n", cmd->command_type);

	if (!cmd->con || !cmd->con->tds_socket)
		return CS_FAIL;

	tds = cmd->con->tds_socket;

	if (cmd->cancel_state == _CS_CANCEL_PENDING) {
		_ct_cancel_cleanup(cmd);
		return CS_CANCELED;
	}

	if (cmd->command_state == _CS_COMMAND_IDLE) {
		tdsdump_log(TDS_DBG_FUNC, "ct_send() command_state = IDLE\n");
		_ctclient_msg(cmd->con, "ct_send", 1, 1, 1, 16843163, "");
		return CS_FAIL;
	}

	cmd->results_state = _CS_RES_NONE;

	if (cmd->command_type == CS_DYNAMIC_CMD) {

		if (cmd->dyn == NULL)
			return CS_FAIL;

		switch (cmd->dynamic_cmd) {
		case CS_PREPARE:
			if (tds_submit_prepare(tds, cmd->dyn->stmt, cmd->dyn->id, NULL, NULL) == TDS_FAIL)
				return CS_FAIL;
			ct_set_command_state(cmd, _CS_COMMAND_SENT);
			return CS_SUCCEED;
			break;
		case CS_EXECUTE:
			pparam_info = paraminfoalloc(tds, cmd->dyn->param_list);
			tdsdyn = tds_lookup_dynamic(tds, cmd->dyn->id);
			if (!tdsdyn) {
				tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_EXECUTE) no tdsdyn!\n");
				return CS_FAIL;
			}
			tds_free_input_params(tdsdyn);
			tdsdyn->params = pparam_info;
			if (tds_submit_execute(tds, tdsdyn) == TDS_FAIL)
				return CS_FAIL;
			ct_set_command_state(cmd, _CS_COMMAND_SENT);
			return CS_SUCCEED;
			break;
		case CS_DESCRIBE_INPUT:
			tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_DESCRIBE_INPUT)\n");
			ct_set_command_state(cmd, _CS_COMMAND_SENT);
			cmd->results_state = _CS_RES_DESCRIBE_RESULT;
			if (tds->cur_dyn)
				tds->current_results = tds->cur_dyn->res_info;
			else
				tds->current_results = tds->param_info;
			break;

		case CS_DESCRIBE_OUTPUT:
			tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_DESCRIBE_OUTPUT)\n");
			ct_set_command_state(cmd, _CS_COMMAND_SENT);
			cmd->results_state = _CS_RES_DESCRIBE_RESULT;
			tds->current_results = tds->res_info;
			break;

		case CS_DEALLOC:
			tdsdyn = tds_lookup_dynamic(tds, cmd->dyn->id);
			if (!tdsdyn) {
				tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_DEALLOC) no tdsdyn!\n");
				return CS_FAIL;
			}
			if (tds_submit_unprepare(tds, tdsdyn) == TDS_FAIL)
				return CS_FAIL;

			ct_set_command_state(cmd, _CS_COMMAND_SENT);
			return CS_SUCCEED;
			break;

		default:
			return CS_FAIL;
		}
	}

	if (cmd->command_type == CS_RPC_CMD) {
		/* sanity */
		if (cmd == NULL || cmd->rpc == NULL	/* ct_command should allocate pointer */
		    || cmd->rpc->name == NULL) {	/* can't be ready without a name      */
			return CS_FAIL;
		}

		rpc = &(cmd->rpc);
		pparam_info = paraminfoalloc(tds, cmd->rpc->param_list);
		ret = tds_submit_rpc(tds, cmd->rpc->name, pparam_info);

		tds_free_param_results(pparam_info);

		ct_set_command_state(cmd, _CS_COMMAND_SENT);

		if (ret == TDS_FAIL) {
			return CS_FAIL;
		}

		return CS_SUCCEED;
	}

	/* RPC Code changes ends here */

	if (cmd->command_type == CS_LANG_CMD) {
		ret = CS_FAIL;
		if (cmd->input_params) {
			pparam_info = paraminfoalloc(tds, cmd->input_params);
			ret = tds_submit_query_params(tds, cmd->query, pparam_info);
			tds_free_param_results(pparam_info);
		} else {
			ret = tds_submit_query(tds, cmd->query);
		}

		ct_set_command_state(cmd, _CS_COMMAND_SENT);

		if (ret == TDS_FAIL) {
			tdsdump_log(TDS_DBG_WARN, "ct_send() failed\n");
			return CS_FAIL;
		}
		tdsdump_log(TDS_DBG_INFO2, "ct_send() succeeded\n");
		return CS_SUCCEED;
	}

	/* Code added for CURSOR support */

	if (cmd->command_type == CS_CUR_CMD) {
		/* sanity */
		/*
		 * ct_cursor declare should allocate cursor pointer
		 * cursor stmt cannot be NULL
		 * cursor name cannot be NULL
		 */

		int something_to_send = 0;

		tdsdump_log(TDS_DBG_FUNC, "ct_send() : CS_CUR_CMD\n");

		cursor = cmd->cursor;
		if (!cursor) {
			tdsdump_log(TDS_DBG_FUNC, "ct_send() : cursor not present\n");
			return CS_FAIL;
		}

		if (cmd == NULL ) {
			tdsdump_log(TDS_DBG_FUNC, "ct_send() : cmd is null\n");
			return CS_FAIL;
		}
		if (cursor->query == NULL ) {
			tdsdump_log(TDS_DBG_FUNC, "ct_send() : cursor->query is null\n");
			return CS_FAIL;
		}
		if ( cursor->cursor_name == NULL ) {
			tdsdump_log(TDS_DBG_FUNC, "ct_send() : cursor->name is null\n");
			return CS_FAIL;
		}

		if (cursor->status.declare == _CS_CURS_TYPE_REQUESTED) {
			ret =  tds_cursor_declare(tds, cursor, NULL, &something_to_send);
			if (ret == CS_SUCCEED){