static int
read_row(TDS_POOL_MEMBER * pmbr, const unsigned char *buf, int maxlen, int *bytes_read)
{
TDSCOLUMN *curcol;
TDSRESULTINFO *info;
int i, colsize;
int pos = 1; /* skip marker */
info = pmbr->tds->res_info;
die_if((!info), "Entered read_row() without a res_info structure.");
for (i = 0; i < info->num_cols; i++) {
curcol = info->columns[i];
if (!is_fixed_type(curcol->column_type)) {
if (bytes_left(pmbr, buf, pos, maxlen, 1)) {
*bytes_read = maxlen;
return 0;
}
colsize = buf[pos++];
} else {
colsize = tds_get_size_by_type(curcol->column_type);
}
if (bytes_left(pmbr, buf, pos, maxlen, colsize)) {
*bytes_read = maxlen;
return 0;
}
pos += colsize;
}
*bytes_read = pos;
return 1;
}
static int
read_col_info(TDS_POOL_MEMBER * pmbr, const unsigned char *buf, int maxlen, int *bytes_read)
{
TDS_SMALLINT hdrsize;
int pos = 0;
int col, rest;
TDSCOLUMN *curcol;
TDSRESULTINFO *info;
TDSSOCKET *tds = pmbr->tds;
/* header size */
if (bytes_left(pmbr, buf, pos, maxlen, 3)) {
*bytes_read = maxlen;
return 0;
}
/* FIX ME -- endian */
hdrsize = buf[1] + buf[2] * 256;
pos += 3;
info = tds->res_info;
for (col = 0; col < info->num_cols; col++) {
curcol = info->columns[col];
if (bytes_left(pmbr, buf, pos, maxlen, 5)) {
*bytes_read = maxlen;
return 0;
}
pos += 4;
curcol->column_type = buf[pos++];
/* FIX ME -- blob types */
if (!is_fixed_type(curcol->column_type)) {
if (bytes_left(pmbr, buf, pos, maxlen, 1)) {
*bytes_read = maxlen;
return 0;
}
curcol->column_size = buf[pos++];
} else {
curcol->column_size = tds_get_size_by_type(curcol->column_type);
}
}
rest = hdrsize + 3 - pos;
if (rest > 0) {
if (bytes_left(pmbr, buf, pos, maxlen, rest)) {
*bytes_read = maxlen;
return 0;
}
fprintf(stderr, "read_col_info: draining %d bytes\n", rest);
pos += rest;
}
*bytes_read = pos;
return 1;
}
/**
* Set type of column initializing all dependency
* @param curcol column to set
* @param type type to set
*/
void
tds_set_column_type(TDSSOCKET * tds, TDSCOLUMN * curcol, int type)
{
/* set type */
curcol->on_server.column_type = type;
curcol->column_type = tds_get_cardinal_type(type);
/* set size */
curcol->column_cur_size = -1;
curcol->column_varint_size = tds_get_varint_size(tds, type);
if (curcol->column_varint_size == 0)
curcol->column_cur_size = curcol->on_server.column_size = curcol->column_size = tds_get_size_by_type(type);
}
void
tds_send_row(TDSSOCKET * tds, TDSRESULTINFO * resinfo)
{
TDSCOLUMN *curcol;
int colsize, i;
tds_put_byte(tds, TDS_ROW_TOKEN);
for (i = 0; i < resinfo->num_cols; i++) {
curcol = resinfo->columns[i];
if (!is_fixed_type(curcol->column_type)) {
/* FIX ME -- I have no way of knowing the actual length of non character variable data (eg nullable int) */
colsize = strlen((char *) curcol->column_data);
tds_put_byte(tds, colsize);
tds_put_n(tds, curcol->column_data, colsize);
} else {
tds_put_n(tds, curcol->column_data, tds_get_size_by_type(curcol->column_type));
}
}
}
CS_RETCODE
cs_convert(CS_CONTEXT * ctx, CS_DATAFMT * srcfmt, CS_VOID * srcdata, CS_DATAFMT * destfmt, CS_VOID * destdata, CS_INT * resultlen)
{
int src_type, src_len, desttype, destlen, len, i = 0;
CONV_RESULT cres;
unsigned char *dest;
CS_RETCODE ret;
CS_INT dummy;
CS_VARCHAR *destvc = NULL;
tdsdump_log(TDS_DBG_FUNC, "cs_convert(%p, %p, %p, %p, %p, %p)\n", ctx, srcfmt, srcdata, destfmt, destdata, resultlen);
/* If destination is NULL we have a problem */
if (destdata == NULL) {
/* TODO: add error message */
tdsdump_log(TDS_DBG_FUNC, "error: destdata is null\n");
return CS_FAIL;
}
/* If destfmt is NULL we have a problem */
if (destfmt == NULL) {
/* TODO: add error message */
tdsdump_log(TDS_DBG_FUNC, "error: destfmt is null\n");
return CS_FAIL;
}
if (resultlen == NULL)
resultlen = &dummy;
/* If source is indicated to be NULL, set dest to low values */
if (srcdata == NULL) {
/* TODO: implement cs_setnull */
tdsdump_log(TDS_DBG_FUNC, "srcdata is null\n");
memset(destdata, '\0', destfmt->maxlength);
*resultlen = 0;
return CS_SUCCEED;
}
src_type = _ct_get_server_type(NULL, srcfmt->datatype);
src_len = srcfmt->maxlength;
if (srcfmt->datatype == CS_VARCHAR_TYPE || srcfmt->datatype == CS_VARBINARY_TYPE) {
CS_VARCHAR *vc = (CS_VARCHAR *) srcdata;
src_len = vc->len;
srcdata = vc->str;
}
desttype = _ct_get_server_type(NULL, destfmt->datatype);
destlen = destfmt->maxlength;
if (destfmt->datatype == CS_VARCHAR_TYPE || destfmt->datatype == CS_VARBINARY_TYPE) {
destvc = (CS_VARCHAR *) destdata;
destlen = sizeof(destvc->str);
destdata = destvc->str;
} else if (is_numeric_type(desttype)) {
destlen = sizeof(TDS_NUMERIC);
}
tdsdump_log(TDS_DBG_FUNC, "converting type %d (%d bytes) to type = %d (%d bytes)\n",
src_type, src_len, desttype, destlen);
if (!is_fixed_type(desttype) && (destlen <= 0)) {
return CS_FAIL;
}
dest = (unsigned char *) destdata;
/* many times we are asked to convert a data type to itself */
if (src_type == desttype) {
int minlen = src_len < destlen? src_len : destlen;
tdsdump_log(TDS_DBG_FUNC, "cs_convert() srctype == desttype\n");
switch (desttype) {
case SYBLONGBINARY:
case SYBBINARY:
case SYBVARBINARY:
case SYBIMAGE:
memcpy(dest, srcdata, src_len);
*resultlen = src_len;
if (src_len > destlen) {
tdsdump_log(TDS_DBG_FUNC, "error: src_len > destlen\n");
ret = CS_FAIL;
} else {
switch (destfmt->format) {
case CS_FMT_PADNULL:
memset(dest + src_len, '\0', destlen - src_len);
*resultlen = destlen;
/* fall through */
case CS_FMT_UNUSED:
ret = CS_SUCCEED;
break;
default:
ret = CS_FAIL;
break;
}
}
if (destvc) {
destvc->len = minlen;
*resultlen = sizeof(*destvc);
}
break;
case SYBCHAR:
case SYBVARCHAR:
case SYBTEXT:
tdsdump_log(TDS_DBG_FUNC, "cs_convert() desttype = character\n");
memcpy(dest, srcdata, minlen);
*resultlen = minlen;
if (src_len > destlen) {
tdsdump_log(TDS_DBG_FUNC, "error: src_len > destlen\n");
ret = CS_FAIL;
} else {
switch (destfmt->format) {
case CS_FMT_NULLTERM:
if (src_len == destlen) {
*resultlen = src_len;
tdsdump_log(TDS_DBG_FUNC, "error: no room for null terminator\n");
ret = CS_FAIL;
} else {
dest[src_len] = '\0';
*resultlen = src_len + 1;
ret = CS_SUCCEED;
}
break;
case CS_FMT_PADBLANK:
memset(dest + src_len, ' ', destlen - src_len);
*resultlen = destlen;
ret = CS_SUCCEED;
break;
case CS_FMT_PADNULL:
memset(dest + src_len, '\0', destlen - src_len);
*resultlen = destlen;
ret = CS_SUCCEED;
break;
case CS_FMT_UNUSED:
ret = CS_SUCCEED;
break;
default:
tdsdump_log(TDS_DBG_FUNC, "no destination format specified!\n");
ret = CS_FAIL;
break;
}
}
if (destvc) {
destvc->len = minlen;
*resultlen = sizeof(*destvc);
}
break;
case SYBINT1:
case SYBUINT1:
case SYBINT2:
case SYBUINT2:
case SYBINT4:
case SYBUINT4:
case SYBINT8:
case SYBUINT8:
case SYBFLT8:
case SYBREAL:
case SYBBIT:
case SYBMONEY:
case SYBMONEY4:
case SYBDATETIME:
case SYBDATETIME4:
*resultlen = tds_get_size_by_type(src_type);
if (*resultlen > 0)
memcpy(dest, srcdata, *resultlen);
ret = CS_SUCCEED;
break;
case SYBNUMERIC:
case SYBDECIMAL:
src_len = tds_numeric_bytes_per_prec[((TDS_NUMERIC *) srcdata)->precision] + 2;
case SYBBITN:
case SYBUNIQUE:
memcpy(dest, srcdata, minlen);
*resultlen = minlen;
if (src_len > destlen) {
tdsdump_log(TDS_DBG_FUNC, "error: src_len > destlen\n");
ret = CS_FAIL;
} else {
ret = CS_SUCCEED;
}
break;
default:
tdsdump_log(TDS_DBG_FUNC, "error: unrecognized type\n");
ret = CS_FAIL;
break;
}
tdsdump_log(TDS_DBG_FUNC, "cs_convert() returning %s\n", cs_prretcode(ret));
return ret;
}
assert(src_type != desttype);
/* set the output precision/scale for conversions to numeric type */
if (is_numeric_type(desttype)) {
cres.n.precision = destfmt->precision;
cres.n.scale = destfmt->scale;
if (destfmt->precision == CS_SRC_VALUE)
cres.n.precision = srcfmt->precision;
if (destfmt->scale == CS_SRC_VALUE)
cres.n.scale = srcfmt->scale;
}
tdsdump_log(TDS_DBG_FUNC, "cs_convert() calling tds_convert\n");
len = tds_convert(ctx->tds_ctx, src_type, (TDS_CHAR*) srcdata, src_len, desttype, &cres);
tdsdump_log(TDS_DBG_FUNC, "cs_convert() tds_convert returned %d\n", len);
switch (len) {
case TDS_CONVERT_NOAVAIL:
_csclient_msg(ctx, "cs_convert", 2, 1, 1, 16, "%d, %d", src_type, desttype);
return CS_FAIL;
break;
case TDS_CONVERT_SYNTAX:
_csclient_msg(ctx, "cs_convert", 2, 4, 1, 24, "");
return CS_FAIL;
break;
case TDS_CONVERT_NOMEM:
_csclient_msg(ctx, "cs_convert", 2, 4, 1, 3, "");
return CS_FAIL;
break;
case TDS_CONVERT_OVERFLOW:
_csclient_msg(ctx, "cs_convert", 2, 4, 1, 20, "");
return CS_FAIL;
break;
case TDS_CONVERT_FAIL:
return CS_FAIL;
break;
default:
if (len < 0) {
return CS_FAIL;
}
break;
}
switch (desttype) {
case SYBBINARY:
case SYBVARBINARY:
case SYBIMAGE:
ret = CS_SUCCEED;
if (len > destlen) {
tdsdump_log(TDS_DBG_FUNC, "error_handler: Data-conversion resulted in overflow\n");
ret = CS_FAIL;
len = destlen;
}
memcpy(dest, cres.ib, len);
free(cres.ib);
*resultlen = destlen;
if (destvc) {
destvc->len = len;
*resultlen = sizeof(*destvc);
}
for (i = len; i < destlen; i++)
dest[i] = '\0';
break;
case SYBBIT:
case SYBBITN:
/* fall trough, act same way of TINYINT */
case SYBINT1:
case SYBUINT1:
case SYBINT2:
case SYBUINT2:
case SYBINT4:
case SYBUINT4:
case SYBINT8:
case SYBUINT8:
case SYBFLT8:
case SYBREAL:
case SYBMONEY:
case SYBMONEY4:
case SYBDATETIME:
case SYBDATETIME4:
case SYBUNIQUE:
*resultlen = tds_get_size_by_type(desttype);
memcpy(dest, &(cres.ti), *resultlen);
ret = CS_SUCCEED;
break;
case SYBNUMERIC:
case SYBDECIMAL:
src_len = tds_numeric_bytes_per_prec[cres.n.precision] + 2;
memcpy(dest, &(cres.n), src_len);
*resultlen = src_len;
ret = CS_SUCCEED;
break;
case SYBCHAR:
case SYBVARCHAR:
case SYBTEXT:
ret = CS_SUCCEED;
if (len > destlen) {
tdsdump_log(TDS_DBG_FUNC, "Data-conversion resulted in overflow\n");
len = destlen;
ret = CS_FAIL;
}
switch (destfmt->format) {
case CS_FMT_NULLTERM:
tdsdump_log(TDS_DBG_FUNC, "cs_convert() FMT_NULLTERM\n");
if (len == destlen) {
tdsdump_log(TDS_DBG_FUNC, "not enough room for data + a null terminator - error\n");
ret = CS_FAIL; /* not enough room for data + a null terminator - error */
} else {
memcpy(dest, cres.c, len);
dest[len] = 0;
*resultlen = len + 1;
}
break;
case CS_FMT_PADBLANK:
tdsdump_log(TDS_DBG_FUNC, "cs_convert() FMT_PADBLANK\n");
/* strcpy here can lead to a small buffer overflow */
memcpy(dest, cres.c, len);
for (i = len; i < destlen; i++)
dest[i] = ' ';
*resultlen = destlen;
break;
case CS_FMT_PADNULL:
tdsdump_log(TDS_DBG_FUNC, "cs_convert() FMT_PADNULL\n");
/* strcpy here can lead to a small buffer overflow */
memcpy(dest, cres.c, len);
for (i = len; i < destlen; i++)
dest[i] = '\0';
*resultlen = destlen;
break;
case CS_FMT_UNUSED:
tdsdump_log(TDS_DBG_FUNC, "cs_convert() FMT_UNUSED\n");
memcpy(dest, cres.c, len);
*resultlen = len;
break;
default:
ret = CS_FAIL;
break;
}
if (destvc) {
destvc->len = len;
*resultlen = sizeof(*destvc);
}
free(cres.c);
break;
default:
ret = CS_FAIL;
break;
}
tdsdump_log(TDS_DBG_FUNC, "cs_convert() returning %s\n", cs_prretcode(ret));
return (ret);
}
void
tds_check_column_extra(const TDSCOLUMN * column)
{
int size;
TDSCONNECTION conn;
int varint_ok;
int column_varint_size;
assert(column);
column_varint_size = column->column_varint_size;
/* 8 is for varchar(max) or similar */
assert(column_varint_size == 8 || (column_varint_size <= 5 && column_varint_size != 3));
assert(column->column_scale <= column->column_prec);
assert(column->column_prec <= MAXPRECISION);
/* I don't like this that much... freddy77 */
if (column->column_type == 0)
return;
assert(column->funcs);
assert(column->column_type > 0);
/* check type and server type same or SQLNCHAR -> SQLCHAR */
#define SPECIAL(ttype, server_type, varint) \
if (column->column_type == ttype && column->on_server.column_type == server_type && column_varint_size == varint) {} else
SPECIAL(SYBTEXT, XSYBVARCHAR, 8)
SPECIAL(SYBTEXT, XSYBNVARCHAR, 8)
SPECIAL(SYBIMAGE, XSYBVARBINARY, 8)
assert(tds_get_cardinal_type(column->on_server.column_type, column->column_usertype) == column->column_type
|| (tds_get_conversion_type(column->on_server.column_type, column->column_size) == column->column_type
&& column_varint_size == 1 && is_fixed_type(column->column_type)));
varint_ok = 0;
if (column_varint_size == 8) {
assert(column->on_server.column_type == XSYBVARCHAR || column->on_server.column_type == XSYBVARBINARY || column->on_server.column_type == XSYBNVARCHAR || column->on_server.column_type == SYBMSXML || column->on_server.column_type == SYBMSUDT);
varint_ok = 1;
} else if (is_blob_type(column->column_type)) {
assert(column_varint_size >= 4);
} else if (column->column_type == SYBVARIANT) {
assert(column_varint_size == 4);
}
conn.tds_version = 0x500;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
conn.tds_version = 0x700;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
assert(varint_ok);
/* check current size <= size */
if (is_numeric_type(column->column_type)) {
/* I don't like that much this difference between numeric and not numeric - freddy77 */
/* TODO what should be the size ?? */
assert(column->column_prec >= 1 && column->column_prec <= MAXPRECISION);
assert(column->column_scale <= column->column_prec);
/* assert(column->column_cur_size == tds_numeric_bytes_per_prec[column->column_prec] + 2 || column->column_cur_size == -1); */
} else {
assert(column->column_cur_size <= column->column_size);
}
/* check size of fixed type correct */
size = tds_get_size_by_type(column->column_type);
assert(size != 0 || column->column_type == SYBVOID);
if (size >= 0 && column->column_type != SYBBITN) {
/* check macro */
assert(is_fixed_type(column->column_type));
/* check current size */
if (column->column_type != SYBMSDATE)
assert(size == column->column_size);
/* check cases where server need nullable types */
if (column->column_type != column->on_server.column_type && (column->column_type != SYBINT8 || column->on_server.column_type != SYB5INT8)) {
assert(!is_fixed_type(column->on_server.column_type));
assert(column_varint_size == 1);
assert(column->column_size == column->column_cur_size || column->column_cur_size == -1);
} else {
assert(column_varint_size == 0
|| (column->column_type == SYBUNIQUE && column_varint_size == 1)
|| (column->column_type == SYBMSDATE && column_varint_size == 1));
assert(column->column_size == column->column_cur_size
|| (column->column_type == SYBUNIQUE && column->column_cur_size == -1)
|| (column->column_type == SYBMSDATE && column->column_cur_size == -1));
}
assert(column->column_size == column->on_server.column_size);
} else {
assert(!is_fixed_type(column->column_type));
assert(is_char_type(column->column_type) || (column->on_server.column_size == column->column_size || column->on_server.column_size == 0));
assert(column_varint_size != 0);
}
/* check size of nullable types (ie intN) it's supported */
if (tds_get_conversion_type(column->column_type, 4) != column->column_type) {
/* check macro */
assert(is_nullable_type(column->column_type));
/* check that size it's correct for this type of nullable */
assert(tds_get_conversion_type(column->column_type, column->column_size) != column->column_type);
/* check current size */
assert(column->column_size >= column->column_cur_size || column->column_cur_size == -1);
/* check same type and size on server */
assert(column->column_type == column->on_server.column_type);
assert(column->column_size == column->on_server.column_size);
}
}
void
tds_check_column_extra(const TDSCOLUMN * column)
{
int size;
TDSCONNECTION conn;
int varint_ok;
int column_varint_size;
assert(column);
column_varint_size = column->column_varint_size;
/* 8 is for varchar(max) or similar */
assert(column_varint_size == 8 || (column_varint_size <= 5 && column_varint_size != 3));
assert(column->column_scale <= column->column_prec);
assert(column->column_prec <= MAXPRECISION);
/* I don't like this that much... freddy77 */
if (column->column_type == 0)
return;
assert(column->funcs);
assert(column->column_type > 0);
/* specific checks, if true fully checked */
if (column->funcs->check(column))
return;
/* check type and server type same or SQLNCHAR -> SQLCHAR */
#define SPECIAL(ttype, server_type, varint) \
if (column->column_type == ttype && column->on_server.column_type == server_type && column_varint_size == varint) {} else
SPECIAL(SYBTEXT, XSYBVARCHAR, 8)
SPECIAL(SYBTEXT, XSYBNVARCHAR, 8)
SPECIAL(SYBIMAGE, XSYBVARBINARY, 8)
assert(tds_get_cardinal_type(column->on_server.column_type, column->column_usertype) == column->column_type
|| (tds_get_conversion_type(column->on_server.column_type, column->column_size) == column->column_type
&& column_varint_size == 1 && is_fixed_type(column->column_type)));
varint_ok = 0;
if (column_varint_size == 8) {
if (column->on_server.column_type == XSYBVARCHAR
|| column->on_server.column_type == XSYBVARBINARY
|| column->on_server.column_type == XSYBNVARCHAR)
varint_ok = 1;
} else if (is_blob_type(column->column_type)) {
assert(column_varint_size >= 4);
} else if (column->column_type == SYBVARIANT) {
assert(column_varint_size == 4);
}
conn.tds_version = 0x500;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
conn.tds_version = 0x700;
varint_ok = varint_ok || tds_get_varint_size(&conn, column->on_server.column_type) == column_varint_size;
assert(varint_ok);
assert(!is_numeric_type(column->column_type));
assert(column->column_cur_size <= column->column_size);
/* check size of fixed type correct */
size = tds_get_size_by_type(column->column_type);
assert(size != 0 || column->column_type == SYBVOID);
/* these peculiar types are variable but have only a possible size */
if (size >= 0 && (column->column_type != SYBBITN
&& column->column_type != SYBDATEN && column->column_type != SYBTIMEN)) {
/* check macro */
assert(is_fixed_type(column->column_type));
/* check current size */
assert(size == column->column_size);
/* check cases where server need nullable types */
if (column->column_type != column->on_server.column_type && (column->column_type != SYBINT8 || column->on_server.column_type != SYB5INT8)) {
assert(!is_fixed_type(column->on_server.column_type));
assert(column_varint_size == 1);
assert(column->column_size == column->column_cur_size || column->column_cur_size == -1);
} else {
assert(column_varint_size == 0
|| (column->column_type == SYBUNIQUE && column_varint_size == 1));
assert(column->column_size == column->column_cur_size
|| (column->column_type == SYBUNIQUE && column->column_cur_size == -1));
}
assert(column->column_size == column->on_server.column_size);
} else {
assert(!is_fixed_type(column->column_type));
assert(is_char_type(column->column_type) || (column->on_server.column_size == column->column_size || column->on_server.column_size == 0));
assert(column_varint_size != 0);
}
/* check size of nullable types (ie intN) it's supported */
if (tds_get_conversion_type(column->column_type, 4) != column->column_type) {
/* check macro */
assert(is_nullable_type(column->column_type));
/* check that size it's correct for this type of nullable */
assert(tds_get_conversion_type(column->column_type, column->column_size) != column->column_type);
/* check current size */
assert(column->column_size >= column->column_cur_size || column->column_cur_size == -1);
/* check same type and size on server */
assert(column->column_type == column->on_server.column_type);
assert(column->column_size == column->on_server.column_size);
}
}
/**
* Allocate memory and copy the rpc information into a TDSPARAMINFO structure.
*/
static TDSPARAMINFO *
param_info_alloc(TDSSOCKET * tds, DBREMOTE_PROC * rpc)
{
int i;
DBREMOTE_PROC_PARAM *p;
TDSCOLUMN *pcol;
TDSPARAMINFO *params = NULL, *new_params;
BYTE *temp_value;
int temp_datalen;
int temp_type;
int param_is_null;
/* sanity */
if (rpc == NULL)
return NULL;
/* see v 1.10 2002/11/23 for first broken attempt */
for (i = 0, p = rpc->param_list; p != NULL; p = p->next, i++) {
const unsigned char *prow;
if (!(new_params = tds_alloc_param_result(params))) {
tds_free_param_results(params);
tdsdump_log(TDS_DBG_ERROR, "out of rpc memory!");
return NULL;
}
params = new_params;
/*
* Determine whether an input parameter is NULL
* or not.
*/
param_is_null = 0;
temp_type = p->type;
temp_value = p->value;
temp_datalen = p->datalen;
if (p->datalen == 0)
param_is_null = 1;
tdsdump_log(TDS_DBG_INFO1, "parm_info_alloc(): parameter null-ness = %d\n", param_is_null);
if (param_is_null || (p->status & DBRPCRETURN)) {
if (param_is_null) {
temp_datalen = 0;
temp_value = NULL;
} else if (is_fixed_type(temp_type)) {
temp_datalen = tds_get_size_by_type(temp_type);
}
temp_type = tds_get_null_type(temp_type);
} else if (is_fixed_type(temp_type)) {
temp_datalen = tds_get_size_by_type(temp_type);
}
pcol = params->columns[i];
/* meta data */
if (p->name) {
tds_strlcpy(pcol->column_name, p->name, sizeof(pcol->column_name));
pcol->column_namelen = strlen(pcol->column_name);
}
tds_set_param_type(tds, pcol, temp_type);
if (p->maxlen > 0)
pcol->column_size = p->maxlen;
else {
if (is_fixed_type(p->type)) {
pcol->column_size = tds_get_size_by_type(p->type);
} else {
pcol->column_size = p->datalen;
}
}
pcol->on_server.column_size = pcol->column_size;
pcol->column_output = p->status;
pcol->column_cur_size = temp_datalen;
prow = param_row_alloc(params, pcol, i, temp_value, temp_datalen);
if (!prow) {
tds_free_param_results(params);
tdsdump_log(TDS_DBG_ERROR, "out of memory for rpc row!");
return NULL;
}
}
return params;
}
static TDSRET
_bcp_get_col_data(TDSBCPINFO *bcpinfo, TDSCOLUMN *bindcol, int offset)
{
TDS_TINYINT ti;
TDS_SMALLINT si;
TDS_INT li;
tds_sysdep_int64_type lli;
TDS_INT desttype;
int coltype;
SQLLEN col_len;
int data_is_null;
SQLLEN bytes_read;
int converted_data_size;
TDS_CHAR *dataptr;
TDS_DBC *dbc = (TDS_DBC *) bcpinfo->parent;
tdsdump_log(TDS_DBG_FUNC, "_bcp_get_col_data(%p, %p)\n", bcpinfo, bindcol);
dataptr = bindcol->column_varaddr;
data_is_null = 0;
col_len = SQL_NULL_DATA;
/* If a prefix length specified, read the correct amount of data. */
if (bindcol->bcp_prefix_len > 0) {
switch (bindcol->bcp_prefix_len) {
case 1:
memcpy(&ti, dataptr, 1);
dataptr += 1;
col_len = ti;
break;
case 2:
memcpy(&si, dataptr, 2);
dataptr += 2;
col_len = si;
break;
case 4:
memcpy(&li, dataptr, 4);
dataptr += 4;
col_len = li;
break;
case 8:
memcpy(&lli, dataptr, 8);
dataptr += 8;
col_len = lli;
if (lli != col_len)
return TDS_FAIL;
break;
}
if (col_len == SQL_NULL_DATA)
data_is_null = 1;
}
/* if (Max) column length specified take that into consideration. */
if (bindcol->column_bindlen == SQL_NULL_DATA)
data_is_null = 1;
else if (!data_is_null && bindcol->column_bindlen != SQL_VARLEN_DATA) {
if (col_len != SQL_NULL_DATA)
col_len = ((tds_sysdep_int64_type)bindcol->column_bindlen < col_len) ? bindcol->column_bindlen : col_len;
else
col_len = bindcol->column_bindlen;
}
desttype = tds_get_conversion_type(bindcol->column_type, bindcol->column_size);
/* Fixed Length data - this overrides anything else specified */
coltype = bindcol->column_bindtype == 0 ? desttype : bindcol->column_bindtype;
if (is_fixed_type(coltype)) {
col_len = tds_get_size_by_type(coltype);
}
/* read the data, finally */
if (!data_is_null && bindcol->bcp_term_len > 0) { /* terminated field */
bytes_read = _bcp_get_term_var(dataptr, bindcol->bcp_terminator, bindcol->bcp_term_len);
if (col_len != SQL_NULL_DATA)
col_len = (bytes_read < col_len) ? bytes_read : col_len;
else
col_len = bytes_read;
}
if (data_is_null) {
bindcol->bcp_column_data->datalen = 0;
bindcol->bcp_column_data->is_null = 1;
} else {
if ((converted_data_size =
_tdsodbc_dbconvert(dbc, coltype,
dataptr, col_len,
desttype, bindcol->bcp_column_data->data, bindcol)) == -1) {
return TDS_FAIL;
}
bindcol->bcp_column_data->datalen = converted_data_size;
bindcol->bcp_column_data->is_null = 0;
assert(converted_data_size > 0);
}
return TDS_SUCCESS;
}
