/* We'll call a special function for fetches from a cursor            */	/* the processing is too incompatible to patch into a single function */	if (cmd->command_type == CS_CUR_CMD) {		return _ct_fetch_cursor(cmd, type, offset, option, rows_read);	}	if (rows_read)		*rows_read = 0;	/* taking a copy of the cmd->bind_count value. */	temp_count = cmd->bind_count;	if ( cmd->bind_count == CS_UNUSED )		cmd->bind_count = 1;	/* compute rows and parameter results have been pre-fetched by ct_results() */	if (cmd->row_prefetched) {		cmd->row_prefetched = 0;		cmd->get_data_item = 0;		cmd->get_data_bytes_returned = 0;		if (_ct_bind_data(cmd->con->ctx, tds->current_results, tds->current_results, 0))			return CS_ROW_FAIL;		if (rows_read)			*rows_read = 1;		return CS_SUCCEED;	}	if (cmd->results_state == _CS_RES_CMD_DONE)		return CS_END_DATA;	if (cmd->curr_result_type == CS_COMPUTE_RESULT)		return CS_END_DATA;	if (cmd->curr_result_type == CS_CMD_FAIL)		return CS_CMD_FAIL;	marker = tds_peek(tds);	if ((cmd->curr_result_type == CS_ROW_RESULT && marker != TDS_ROW_TOKEN) ||		(cmd->curr_result_type == CS_STATUS_RESULT && marker != TDS_RETURNSTATUS_TOKEN) )		return CS_END_DATA;	/* Array Binding Code changes start here */	for (temp_count = 0; temp_count < cmd->bind_count; temp_count++) {		ret = tds_process_tokens(tds, &ret_type, NULL, TDS_STOPAT_ROWFMT|TDS_STOPAT_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);		tdsdump_log(TDS_DBG_FUNC, "inside ct_fetch()process_row_tokens returned %d\n", ret);		switch (ret) {			case TDS_SUCCEED:				if (ret_type == TDS_ROW_RESULT || ret_type == TDS_COMPUTE_RESULT) {					cmd->get_data_item = 0;					cmd->get_data_bytes_returned = 0;					if (_ct_bind_data(cmd->con->ctx, tds->current_results, tds->current_results, temp_count))						return CS_ROW_FAIL;					if (rows_read)						*rows_read = *rows_read + 1;					break;				}			case TDS_NO_MORE_RESULTS:				return CS_END_DATA;				break;			case TDS_CANCELLED:				cmd->cancel_state = _CS_CANCEL_NOCANCEL;				return CS_CANCELED;				break;			default:				return CS_FAIL;				break;		}		/* have we reached the end of the rows ? */		marker = tds_peek(tds);		if (cmd->curr_result_type == CS_ROW_RESULT && marker != TDS_ROW_TOKEN)			break;	}	/* Array Binding Code changes end here */	return CS_SUCCEED;}static CS_RETCODE_ct_fetch_cursor(CS_COMMAND * cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT * rows_read){	TDSSOCKET * tds;	TDSCURSOR *cursor;	TDS_INT restype;	TDS_INT ret;	TDS_INT temp_count;	TDS_INT done_flags;	TDS_INT rows_this_fetch = 0;	tdsdump_log(TDS_DBG_FUNC, "_ct_fetch_cursor()\n");	if (!cmd->con || !cmd->con->tds_socket)		return CS_FAIL;	tds = cmd->con->tds_socket;	if (rows_read)		*rows_read = 0;	/* taking a copy of the cmd->bind_count value. */	temp_count = cmd->bind_count;	if ( cmd->bind_count == CS_UNUSED )		cmd->bind_count = 1;	cursor = cmd->cursor;	if (!cursor) {		tdsdump_log(TDS_DBG_FUNC, "ct_fetch_cursor() : cursor not present\n");		return CS_FAIL;	}	/* currently we are placing this restriction on cursor fetches.  */	/* the alternatives are too awful to contemplate at the moment   */	/* i.e. buffering all the rows from the fetch internally...      */	if (cmd->bind_count < cursor->cursor_rows) {		tdsdump_log(TDS_DBG_WARN, "_ct_fetch_cursor(): bind count must equal cursor rows \n");		return CS_FAIL;	}	if (tds_cursor_fetch(tds, cursor, TDS_CURSOR_FETCH_NEXT, 0) == CS_SUCCEED) {		cursor->status.fetch = _CS_CURS_TYPE_SENT;	}	else {		tdsdump_log(TDS_DBG_WARN, "ct_fetch(): cursor fetch failed\n");		return CS_FAIL;	}	while ((tds_process_tokens(tds, &restype, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCEED) {		switch (restype) {			case CS_ROWFMT_RESULT:				break;			case CS_ROW_RESULT:				for (temp_count = 0; temp_count < cmd->bind_count; temp_count++) {					ret = tds_process_tokens(tds, &restype, NULL, TDS_STOPAT_ROWFMT|TDS_STOPAT_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);					tdsdump_log(TDS_DBG_FUNC, "_ct_fetch_cursor() tds_process_tokens returned %d\n", ret);					if (ret == TDS_SUCCEED && (restype == TDS_ROW_RESULT || restype == TDS_COMPUTE_RESULT)) {						cmd->get_data_item = 0;						cmd->get_data_bytes_returned = 0;						if (restype == TDS_ROW_RESULT) {							if (_ct_bind_data(cmd->con->ctx, tds->current_results, tds->current_results, temp_count))								return CS_ROW_FAIL;							if (rows_read)								*rows_read = *rows_read + 1;							rows_this_fetch++;						}					} else {						if (ret != TDS_FAIL) {							break;						} else {							return CS_FAIL;						}					}				}				break;			case TDS_DONE_RESULT:				break;		}	}	if (rows_this_fetch)		return CS_SUCCEED;	else {		cmd->results_state = _CS_RES_CMD_SUCCEED;		return CS_END_DATA;	}}int_ct_bind_data(CS_CONTEXT *ctx, TDSRESULTINFO * resinfo, TDSRESULTINFO *bindinfo, CS_INT offset){	int i;	TDSCOLUMN *curcol;	TDSCOLUMN *bindcol;	unsigned char *src;	unsigned char *dest, *temp_add;	int result = 0;	TDS_INT srctype, srclen, desttype, len;	CS_DATAFMT srcfmt, destfmt;	TDS_INT *datalen = NULL;	TDS_SMALLINT *nullind = NULL;	tdsdump_log(TDS_DBG_FUNC, "_ct_bind_data()\n");	for (i = 0; i < resinfo->num_cols; i++) {		curcol = resinfo->columns[i];		bindcol = bindinfo->columns[i];		tdsdump_log(TDS_DBG_FUNC, "_ct_bind_data(): column_type: %d column_len: %d\n",			curcol->column_type,			curcol->column_cur_size		);		if (curcol->column_hidden)			continue;		srctype = curcol->column_type;		desttype = _ct_get_server_type(bindcol->column_bindtype);		/* retrieve the initial bound column_varaddress */		/* and increment it if offset specified         */		temp_add = (unsigned char *) bindcol->column_varaddr;		dest = temp_add + (offset * bindcol->column_bindlen);		if (bindcol->column_nullbind) {			nullind = bindcol->column_nullbind;			nullind += offset;		}		if (bindcol->column_lenbind) {			datalen = bindcol->column_lenbind;			datalen += offset;		}		if (dest) {			if (curcol->column_cur_size < 0) {				if (nullind)					*nullind = -1;				if (datalen)					*datalen = 0;			} else {				srctype = _ct_get_client_type(curcol->column_type, curcol->column_usertype, curcol->column_size);				src = curcol->column_data;				if (is_blob_type(curcol->column_type))					src = (unsigned char *) ((TDSBLOB *) src)->textvalue;				srclen = curcol->column_cur_size;				srcfmt.datatype = srctype;				srcfmt.maxlength = srclen;				destfmt.datatype = bindcol->column_bindtype;				destfmt.maxlength = bindcol->column_bindlen;				destfmt.format = bindcol->column_bindfmt;				/* if convert return FAIL mark error but process other columns */				if ((result= cs_convert(ctx, &srcfmt, (CS_VOID *) src, &destfmt, (CS_VOID *) dest, &len) != CS_SUCCEED)) {					tdsdump_log(TDS_DBG_FUNC, "cs_convert-result = %d\n", result);					result = 1;					len = 0;					tdsdump_log(TDS_DBG_INFO1, "\n  convert failed for %d \n", srcfmt.datatype);				}				if (nullind)					*nullind = 0;				if (datalen) {					*datalen = len;				}			}		} else {			if (datalen)				*datalen = 0;		}	}	return result;}CS_RETCODEct_cmd_drop(CS_COMMAND * cmd){	CS_RETCODE ret;	ret = _ct_cmd_drop(cmd, 1);	return ret;}static CS_RETCODE_ct_cmd_drop(CS_COMMAND * cmd, CS_INT free_conn_ref){	CS_COMMAND_LIST *victim = NULL;	CS_COMMAND_LIST *prev = NULL;	CS_COMMAND_LIST *next = NULL;	CS_CONNECTION *con;	tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop()\n");	if (cmd) {		free(cmd->query);		if (cmd->input_params)			param_clear(cmd->input_params);		free(cmd->userdata);		if (cmd->rpc) {			if (cmd->rpc->param_list)				param_clear(cmd->rpc->param_list);			free(cmd->rpc->name);			free(cmd->rpc);		}		free(cmd->iodesc);		/* now remove this command from the list of commands in the connection */		if (free_conn_ref && cmd->con) {			con = cmd->con;			victim = con->cmds;			for (;;) {				if (victim->cmd == cmd)					break;				prev = victim;				victim = victim->next;				if (victim == NULL) {					tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop() : cannot find command entry in list \n");					return CS_FAIL;				}			}			tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop() : command entry found in list\n");			next = victim->next;			free(victim);			tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop() : relinking list\n");			if (prev)				prev->next = next;			else				con->cmds = next;			tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop() : relinked list\n");		}		free(cmd);	}	return CS_SUCCEED;}CS_RETCODEct_close(CS_CONNECTION * con, CS_INT option){	tdsdump_log(TDS_DBG_FUNC, "ct_close()\n");	tds_free_socket(con->tds_socket);	con->tds_socket = NULL;	return CS_SUCCEED;}CS_RETCODEct_con_drop(CS_CONNECTION * con){	CS_COMMAND_LIST *currptr;	CS_COMMAND_LIST *freeptr;	tdsdump_log(TDS_DBG_FUNC, "ct_con_drop()\n");	if (con) {		free(con->userdata);		if (con->tds_login)			tds_free_login(con->tds_login);		if (con->cmds) {			currptr = con->cmds;			while (currptr != NULL) {				freeptr = currptr;				if (currptr->cmd)					currptr->cmd->con = NULL;				currptr = currptr->next;				free(freeptr);			}		}		if (con->locale)			_cs_locale_free(con->locale);		free(con);	}	return CS_SUCCEED;}int_ct_get_client_type(int datatype, int usertype, int size){	tdsdump_log(TDS_DBG_FUNC, "_ct_get_client_type(type %d, user %d, size %d)\n", datatype, usertype, size);	switch (datatype) {	case SYBBIT:	case SYBBITN:		return CS_BIT_TYPE;		break;	case SYBCHAR:	case SYBVARCHAR:		return CS_CHAR_TYPE;		break;	case SYBINT8:		return CS_LONG_TYPE;		break;	case SYBINT4:		return CS_INT_TYPE;		break;	case SYBINT2:		return CS_SMALLINT_TYPE;		break;	case SYBINT1:		return CS_TINYINT_TYPE;		break;	case SYBINTN:		switch (size) {		case 8:			return CS_LONG_TYPE;		case 4:			return CS_INT_TYPE;		case 2:			return CS_SMALLINT_TYPE;		case 1:			return CS_TINYINT_TYPE;		default:			fprintf(stderr, "Unknown size %d for SYBINTN\n", size);		}		break;	case SYBREAL:		return CS_REAL_TYPE;		break;	case SYBFLT8:		return CS_FLOAT_TYPE;		break;	case SYBFLTN:		if (size == 4) {			return CS_REAL_TYPE;		} else if (size == 8) {			return CS_FLOAT_TYPE;		} else {			fprintf(stderr, "Error! unknown float size of %d\n", size);		}	case SYBMONEY:		return CS_MONEY_TYPE;		break;	case SYBMONEY4:		return CS_MONEY4_TYPE;		break;	case SYBMONEYN:		if (size == 4) {			return CS_MONEY4_TYPE;		} else if (size == 8) {			return CS_MONEY_TYPE;		} else {			fprintf(stderr, "Error! unknown money size of %d\n", size);		}	case SYBDATETIME:		return CS_DATETIME_TYPE;		break;	case SYBDATETIME4:		return CS_DATETIME4_TYPE;		break;	case SYBDATETIMN:		if (size == 4) {			return CS_DATETIME4_TYPE;		} else if (size == 8) {			return CS_DATETIME_TYPE;		} else {			fprintf(stderr, "Error! unknown date size of %d\n", size);		}		break;	case SYBNUMERIC:		return CS_NUMERIC_TYPE;		break;	case SYBDECIMAL:		return CS_DECIMAL_TYPE;		break;	case SYBBINARY:		return CS_BINARY_TYPE;		break;	case SYBIMAGE:		return CS_IMAGE_TYPE;		break;	case SYBVARBINARY:		return CS_VARBINARY_TYPE;		break;	case SYBTEXT:		return CS_TEXT_TYPE;		break;	case SYBUNIQUE:		return CS_UNIQUE_TYPE;		break;	case SYBLONGBINARY:		if (usertype == USER_UNICHAR_TYPE || usertype == USER_UNIVARCHAR_TYPE)			return CS_UNICHAR_TYPE;		return CS_CHAR_TYPE;		break;	}	return CS_FAIL;}int_ct_get_server_type(int datatype){	tdsdump_log(TDS_DBG_FUNC, "_ct_get_server_type(%d)\n", datatype);	switch (datatype) {	case CS_IMAGE_TYPE:		return SYBIMAGE;		break;	case CS_BINARY_TYPE: