*fmt, ...);
94 return "user api layer";
102 return "unrecognized layer";
112 return "external error";
115 return "internal CT-Library error";
118 return "common library error";
121 return "intl library error";
124 return "user error";
127 return "internal BLK-Library error";
132 return "unrecognized origin";
142 return "A bind count of %1! is not consistent with the count supplied for existing binds. " 143 "The current bind count is %2!.";
146 return "Use direction CS_BLK_IN or CS_BLK_OUT for a bulk copy operation.";
149 return "The parameter tblname cannot be NULL.";
152 return "Failed when processing results from server.";
155 return "Parameter %1! has an illegal value of %2!";
158 return "No value or default value available and NULL not allowed. col = %1! row = %2! .";
161 return "parameter name(s) must be supplied for LANGUAGE command.";
164 return "This routine cannot be called when the command structure is idle.";
169 return "unrecognized error";
177 tdsdump_log(
TDS_DBG_FUNC,
"_ct_get_msgstr(%s, %d, %d, %d, %d)\n", funcname, layer,
origin, severity,
number);
195 tdsdump_log(
TDS_DBG_FUNC,
"_ctclient_msg(%p, %s, %d, %d, %d, %d, %s)\n", con, funcname, layer,
origin, severity,
number, fmt);
201cm.
msgnumber= (((layer << 24) & 0xFF000000)
202| ((
origin<< 16) & 0x00FF0000)
203| ((severity << 8) & 0x0000FF00)
204| ((
number) & 0x000000FF));
294(*con)->tds_login =
login;
295(*con)->server_addr =
NULL;
308 int(*funcptr) (
void*,
void*,
void*) = (
int(*)(
void*,
void*,
void*)) func;
310 tdsdump_log(
TDS_DBG_FUNC,
"ct_callback(%p, %p, %d, %d, %p)\n",
ctx, con, action,
type, func);
328*(
void**) func =
NULL;
357 tdsdump_log(
TDS_DBG_FUNC,
"ct_con_props(%p, %d, %d, %p, %d, %p)\n", con, action, property,
buffer, buflen, out_len);
365 char*set_buffer =
NULL;
366 boolcopy_ret =
true;
402 char*host, *port, *lasts =
NULL;
404host=
strtok_r(set_buffer,
" ", &lasts);
406 if(!host || !port) {
411portno = (
int)strtol(port,
NULL, 10);
412 if(portno < 1 || portno >= 65536) {
439memcpy(&intval,
buffer,
sizeof(intval));
446memcpy(&intval,
buffer,
sizeof(intval));
460 if(*(
int*)
buffer== 0) {
510}
else if(action ==
CS_GET) {
555memcpy(
buffer, &intval,
sizeof(intval));
562memcpy(
buffer, &intval,
sizeof(intval));
569memcpy(
buffer, &intval,
sizeof(intval));
571*out_len =
sizeof(intval);
645}
else if(servername ==
NULL|| snamelen == 0
649server = (
char*) servername;
751 for(pcommand = con->
cmds; pcommand->
next!=
NULL; pcommand = pcommand->
next)
762 ssize_tquery_len, current_query_len;
764 tdsdump_log(
TDS_DBG_FUNC,
"ct_command(%p, %d, %p, %d, %d)\n",
cmd,
type,
buffer, buflen,
option);
785query_len = strlen((
const char*)
buffer);
804current_query_len = strlen(
cmd->
query);
807 cmd->
query[current_query_len + query_len] =
'\0';
832}
else if(buflen > 0) {
965tdsdyn->
params= pparam_info;
1062 intsomething_to_send = 0;
1085 if(something_to_send == 0) {
1101 if(something_to_send == 0) {
1125 if(something_to_send) {
1129something_to_send = 0;
1180 unsignedprocess_flags;
1271*result_type = res_type;
1334*result_type = res_type;
1467*result_type = res_type;
1474*result_type = res_type;
1482*result_type = res_type;
1487*result_type = res_type;
1539 tdsdump_log(
TDS_DBG_FUNC,
"ct_bind(%p, %d, %p, %p, %p, %p)\n",
cmd, item, datafmt,
buffer, copied, indicator);
1550 if(!resinfo || item <= 0 || item > resinfo->
num_cols)
1558bind_count = (datafmt->
count== 0) ? 1 : datafmt->
count;
1574colinfo = resinfo->
columns[item - 1];
1598 tdsdump_log(
TDS_DBG_FUNC,
"ct_fetch(%p, %d, %d, %d, %p)\n",
cmd,
type,
offset,
option, prows_read);
1613 if( prows_read ==
NULL)
1614prows_read = &rows_read_dummy;
1658 for(temp_count = 0; temp_count <
cmd->
bind_count; temp_count++) {
1714 tdsdump_log(
TDS_DBG_FUNC,
"_ct_fetch_cursor(%p, %d, %d, %d, %p)\n",
cmd,
type,
offset,
option, rows_read);
1756 for(temp_count = 0; temp_count <
cmd->
bind_count; temp_count++) {
1771*rows_read = *rows_read + 1;
1785 if(rows_this_fetch)
1797 unsigned char*src, *dest, *temp_add;
1800 TDS_INTdatalen_dummy, *pdatalen;
1810bindcol = bindinfo->
columns[
i];
1825nullind = &nullind_dummy;
1831pdatalen = &datalen_dummy;
1847src = (
unsigned char*) ((
TDSBLOB*) src)->textvalue;
1905 for(pvictim = &con->
cmds; *pvictim !=
cmd; ) {
1906 if(*pvictim ==
NULL) {
1910pvictim = &(*pvictim)->
next;
1949con->
cmds= next_cmd;
1972 "_ct_get_client_type: variant resolves to %d\n",
2438 if(item < 1 || item > resinfo->
num_cols)
2441curcol = resinfo->
columns[item - 1];
2484datafmt->
count= 1;
2499 tdsdump_log(
TDS_DBG_FUNC,
"ct_res_info(%p, %d, %p, %d, %p)\n",
cmd,
type,
buffer, buflen, out_len);
2545 tdsdump_log(
TDS_DBG_FUNC,
"ct_config(%p, %d, %d, %p, %d, %p)\n",
ctx, action, property,
buffer, buflen, outlen);
2579 if(
buffer&& buflen > 0 && outlen) {
2581*outlen= snprintf((
char*)
buffer, buflen,
"%s (%s, default tds version=%s)",
2583(settings->
threadsafe?
"threadsafe":
"non-threadsafe"),
2586((
char*)
buffer)[buflen - 1]= 0;
2589strlen((
char*)
buffer);
2604 if(
buffer&& buflen > 0 && outlen) {
2607((
char*)
buffer)[buflen - 1]= 0;
2610strlen((
char*)
buffer);
2666 tdsdump_log(
TDS_DBG_FUNC,
"ct_cmd_props(%p, %d, %d, %p, %d, %p)\n",
cmd, action, property,
buffer, buflen, outlen);
2703 if(outlen) *outlen =
sizeof(
CS_INT);
2712 if(outlen) *outlen =
sizeof(
CS_INT);
2716 if(outlen) *outlen =
sizeof(
CS_INT);
2727 if(outlen) *outlen =
sizeof(
CS_INT);
2734 if(outlen) *outlen = maxcp;
2757 tdsdump_log(
TDS_DBG_FUNC,
"ct_compute_info(%p, %d, %d, %p, %d, %p)\n",
cmd,
type, colnum,
buffer, buflen, outlen);
2776*outlen =
sizeof(
CS_INT);
2785*dest_by_col_ptr = *src_by_col_ptr;
2797curcol = resinfo->
columns[colnum - 1];
2802*outlen =
sizeof(
CS_INT);
2812*outlen =
sizeof(
CS_INT);
2818curcol = resinfo->
columns[colnum - 1];
2823*outlen =
sizeof(
CS_INT);
2842 tdsdump_log(
TDS_DBG_FUNC,
"ct_get_data(%p, %d, %p, %d, %p)\n",
cmd, item,
buffer, buflen, outlen);
2849 if(item < 1 || item > resinfo->
num_cols)
2865 size_ttable_namelen, column_namelen;
2878curcol = resinfo->
columns[item - 1];
2883src = (
unsigned char*) blob->
textvalue;
2902 if(table_namelen + column_namelen + 2 >
sizeof(
cmd->
iodesc->
name))
2903column_namelen =
sizeof(
cmd->
iodesc->
name) - 2 - table_namelen;
2912 if(table_namelen) {
2924 if(column_namelen) {
2942curcol = resinfo->
columns[item - 1];
2945src = (
unsigned char*) ((
TDSBLOB*) src)->textvalue;
2959 if(item < resinfo->num_cols)
2969 if(buflen >= srclen) {
2970memcpy(
buffer, src, srclen);
2974 if(item < resinfo->num_cols)
2979memcpy(
buffer, src, buflen);
2991 chartextptr_string[35];
2992 chartimestamp_string[19];
3027c = timestamp_string;
3094 if(colnum < 1 || colnum > resinfo->
num_cols)
3104resinfo->
columns[colnum - 1]);
3131 unsigned charbitmask = 0;
3134 tdsdump_log(
TDS_DBG_FUNC,
"ct_capability(%p, %d, %d, %d, %p)\n", con, action,
type, capability,
value);
3141 switch(capability) {
3191 "ct_capability -- attempt to set a read-only capability (type %d, action %d)\n",
3197 switch(capability) {
3269bitmask = 1 << (idx&7);
3270idx =
sizeof(cap->
values) - 1 - (idx>>3);
3278cap->
values[idx] |= bitmask;
3281cap->
values[idx] &= ~bitmask;
3306 tdsdump_log(
TDS_DBG_FUNC,
"ct_dynamic(%p, %d, %p, %d, %p, %d)\n",
cmd,
type,
id, idlen,
buffer, buflen);
3324query_len = strlen(
buffer);
3374 tdsdump_log(
TDS_DBG_FUNC,
"ct_param(%p, %p, %p, %d, %hd)\n",
cmd, datafmt,
data, datalen, indicator);
3386 for(
i= 0;
i< datalen; ++
i) {
3387 if(((
const char*)
data)[
i] & 0x80) {
3407 "RPC is NULL in ct_param\n");
3425pparam = &(*pparam)->
next;
3453 while((*pparam)->next)
3454pparam = &(*pparam)->
next;
3455(*pparam)->
next= param;
3480pparam = &(*pparam)->
next;
3498 tdsdump_log(
TDS_DBG_FUNC,
"ct_setparam(%p, %p, %p, %p, %p)\n",
cmd, datafmt,
data, datalen, indicator);
3514 "RPC is NULL in ct_setparam\n");
3532 if(*pparam !=
NULL) {
3533 while((*pparam)->next !=
NULL) {
3534pparam = &(*pparam)->
next;
3537pparam = &(*pparam)->
next;
3549 "cmd->dyn is NULL in ct_setparam\n");
3565 if(*pparam !=
NULL) {
3566 while((*pparam)->next !=
NULL) {
3567pparam = &(*pparam)->
next;
3570pparam = &(*pparam)->
next;
3600 while((*pparam)->next)
3601pparam = &(*pparam)->
next;
3602(*pparam)->
next= param;
3620 const char*action_string =
NULL;
3624 static const structTDS_BOOL_OPTION_MAP
3628} tds_bool_option_map[] = {
3648 tdsdump_log(
TDS_DBG_FUNC,
"ct_options(%p, %d, %d, %p, %d, %p)\n", con, action,
option, param, paramlen, outlen);
3662action_string =
"CS_GET";
3667action_string =
"CS_SET";
3671action_string =
"CS_CLEAR";
3679 assert(tds_command && action_string);
3702tds_option = tds_bool_option_map[
i].tds_option;
3704 switch(*(
CS_BOOL*) param) {
3706tds_argument.
ti= 1;
3709tds_argument.
ti= 0;
3729 switch(*(
CS_BOOL*) param) {
3741tds_argsize = (action ==
CS_SET) ? paramlen : 0;
3746tds_argsize = (action ==
CS_SET) ? paramlen : 0;
3751 switch(*(
CS_INT*) param) {
3777tds_argsize = (action ==
CS_SET) ? 1 : 0;
3781 switch(*(
CS_INT*) param) {
3804tds_argsize = (action ==
CS_SET) ? 1 : 0;
3808 switch(*(
char*) param) {
3825tds_argsize = (action ==
CS_SET) ? 1 : 0;
3829tds_argument.
i= *(
CS_INT*) param;
3830tds_argsize = (action ==
CS_SET) ?
sizeof(tds_argument.
i) : 0;
3834 switch(*(
CS_BOOL*) param) {
3842tds_argument.
ti= !*(
CS_BOOL*) param;
3843tds_argsize = (action ==
CS_SET) ? 1 : 0;
3852action_string, tds_option,
3853tds_argsize == 1 ? tds_argument.
ti: (tds_argsize == 4 ? tds_argument.
i: 0), tds_argsize);
3909 ctx, connection, milliseconds, compconn, compcmd, compid, compstatus);
3920 for(
i= 0;
i<
len; ++
i) {
3924 if(c1 >=
'a'&& c1 <=
'z') {
3928 if(c2 >=
'a'&& c2 <=
'z') {
3936}
else if(c1 < c2) {
3953 size_tstr_len = strlen(
str);
3961 if(pos != str_len) {
3978 tdsdump_log(
TDS_DBG_FUNC,
"ct_cursor(%p, %d, %p, %d, %p, %d, %d)\n",
cmd,
type, name, namelen,
text, tlen,
option);
4009 char* savept =
NULL;
4013 while(tok !=
NULL) {
4016 if(
str_icmp(tok,
"FOR", 3) == 0) {
4018}
else if(
str_icmp(tok,
"UPDATE", 6) == 0) {
4032cursor->
type= 0x4;
4035cursor->
type= 0x1;
4039cursor->
type= 0x4;
4041cursor->
type= 0x1;
4173 enum{ num_cols = 1 };
4190curcol =
info->columns[0];
4211 static const unsigned char*
4245 return(
const unsigned char*)
row;
4265 if(first_param ==
NULL)
4268 for(
i= 0, p = first_param; p !=
NULL; p = p->
next,
i++) {
4269 const unsigned char*prow;
4275params = new_params;
4302temp_value = p->
value;
4305temp_value = p->
value;
4306temp_datalen = *(p->
datalen);
4315temp_datalen = vc->
len;
4330temp_datalen = strlen((
const char*) temp_value);
4341 "paraminfoalloc", 2, 1, 10, 25,
4347}
else if(p->
maxlen== 0
4353p->
maxlen= temp_datalen * 2;
4357 if(temp_datalen > 0 && temp_datalen > p->
maxlen)
4371 "paraminfoalloc: name = %s, varint size %d " 4372 "column_type %d size %d, %d column_cur_size %d column_output = %d\n",
4377prow =
paramrowalloc(params, pcol,
i, temp_value, temp_datalen);
4387 "paraminfoalloc", 2, 1, 17, 33,
"");
4415 if(pparam ==
NULL)
4418 if(pparam->
next) {
4447cmd_type, param, datafmt,
data, datalen, indicator, byvalue);
4456}
else if(datafmt->
namelen> 0) {
4495*(param->
datalen) = *datalen;
4498*(param->
ind) = *indicator;
4505 if(*indicator == -1 || (
data==
NULL&& (*datalen == 0 || *datalen ==
CS_UNUSED))) {
4520 " _ct_fill_param() about to strdup string %u bytes long\n",
4521(
unsigned int) strlen((
const char*)
data));
4522*(param->
datalen) = strlen((
const char*)
data);
4523}
else if(*(param->
datalen) < 0) {
4538param->
ind= indicator;
4550 tdsdump_log(
TDS_DBG_FUNC,
"ct_diag(%p, %d, %d, %d, %p)\n",
conn,
operation,
type, idx,
buffer);
4650 while(*curptr !=
NULL) {
4652curptr = &((*curptr)->next);
4666 while(*scurptr !=
NULL) {
4668scurptr = &((*scurptr)->next);
4676 if(*curptr ==
NULL) {
4679(*curptr)->next =
NULL;
4681 if((*curptr)->clientmsg ==
NULL) {
4684memcpy((*curptr)->clientmsg, message,
sizeof(
CS_CLIENTMSG));
4706 while(*curptr !=
NULL) {
4708curptr = &((*curptr)->next);
4722 while(*ccurptr !=
NULL) {
4724ccurptr = &((*ccurptr)->next);
4732 if(*curptr ==
NULL) {
4735(*curptr)->next =
NULL;
4737 if((*curptr)->servermsg ==
NULL) {
4740memcpy((*curptr)->servermsg, message,
sizeof(
CS_SERVERMSG));
4751 CS_INTmsg_count = 0, msg_found = 0;
4759 while(curptr !=
NULL) {
4761 if(msg_count == idx) {
4765curptr = curptr->
next;
4779 CS_INTmsg_count = 0, msg_found = 0;
4787 while(curptr !=
NULL) {
4789 if(msg_count == idx) {
4793curptr = curptr->
next;
4816 while(curptr !=
NULL) {
4818curptr = freeptr->
next;
4828 while(scurptr !=
NULL) {
4830scurptr = sfreeptr->
next;
4851 while(curptr !=
NULL) {
4853curptr = curptr->
next;
4860 while(scurptr !=
NULL) {
4862scurptr = scurptr->
next;
4865*
count= msg_count;
4884id_len = strlen(
id);
4897pdyn = &(*pdyn)->
next;
4915id_len = strlen(
id);
4923 if(
strncmp(dyn->
id,
id, id_len) == 0)
4941 for(; *pvictim != dyn;) {
4942 if(*pvictim ==
NULL) {
4946pvictim = &(*pvictim)->
next;
4951*pvictim = dyn->
next;
#define CS_SERVERMSG_TYPE
#define CS_DATA_NOSENSITIVITY
#define CS_DATA_NOBOUNDARY
#define CS_NLONGCHAR_TYPE
#define CS_OPT_CURCLOSEONXACT
#define CS_DATETIME4_TYPE
CS_RETCODE(* CS_SERVERMSG_FUNC)(CS_CONTEXT *, CS_CONNECTION *, CS_SERVERMSG *)
#define CS_OPT_QUOTED_IDENT
#define CS_COMPUTEFMT_RESULT
#define CS_LONGBINARY_TYPE
#define CS_OPT_TRUNCIGNORE
#define CS_DESCRIBE_OUTPUT
#define CS_IMPLICIT_CURSOR
#define CS_OPT_ARITHIGNORE
#define CS_OPT_ARITHABORT
#define CS_OPT_DATEFORMAT
#define CS_DATA_DATETIMEN
#define CS_OPT_CHAINXACTS
#define CS_OPT_FORMATONLY
#define CS_DATA_NODATETIMEN
#define CS_BIGDATETIME_TYPE
#define CS_USMALLINT_TYPE
#define CS_DATA_SENSITIVITY
CS_RETCODE(* CS_CLIENTMSG_FUNC)(CS_CONTEXT *, CS_CONNECTION *, CS_CLIENTMSG *)
#define CS_CONSTAT_CONNECTED
#define CS_DESCRIBE_RESULT
#define CS_OPT_STR_RTRUNC
#define CS_COMPUTE_RESULT
#define CS_VARBINARY_TYPE
#define CS_CLIENTMSG_TYPE
#define CS_RES_NOTDSDEBUG
#define CS_DESCRIBE_INPUT
#define CS_CURSOR_DECLARE
#define CS_CURSOR_DEALLOC
#define CS_CANCEL_CURRENT
#define CS_OPT_STATS_TIME
CS_RETCODE cs_convert(CS_CONTEXT *ctx, CS_DATAFMT *srcfmt, CS_VOID *srcdata, CS_DATAFMT *destfmt, CS_VOID *destdata, CS_INT *resultlen)
#define CS_RES_NOSTRIPBLANKS
struct _cs_numeric CS_NUMERIC
CS_RETCODE ct_dynamic(CS_COMMAND *cmd, CS_INT type, CS_CHAR *id, CS_INT idlen, CS_CHAR *buffer, CS_INT buflen)
CS_RETCODE ct_cursor(CS_COMMAND *cmd, CS_INT type, CS_CHAR *name, CS_INT namelen, CS_CHAR *text, CS_INT tlen, CS_INT option)
static CS_INT _ct_deallocate_dynamic(CS_CONNECTION *con, CS_DYNAMIC *dyn)
CS_RETCODE ct_compute_info(CS_COMMAND *cmd, CS_INT type, CS_INT colnum, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
CS_RETCODE ct_command(CS_COMMAND *cmd, CS_INT type, const CS_VOID *buffer, CS_INT buflen, CS_INT option)
static CS_INT ct_diag_storeclientmsg(CS_CONTEXT *context, CS_CONNECTION *conn, CS_CLIENTMSG *message)
static CS_RETCODE _ct_cancel_cleanup(CS_COMMAND *cmd)
static CS_DYNAMIC * _ct_locate_dynamic(CS_CONNECTION *con, char *id, int idlen)
CS_RETCODE ct_connect(CS_CONNECTION *con, CS_CHAR *servername, CS_INT snamelen)
CS_RETCODE ct_results(CS_COMMAND *cmd, CS_INT *result_type)
CS_RETCODE ct_cmd_alloc(CS_CONNECTION *con, CS_COMMAND **pcmd)
CS_RETCODE ct_res_info(CS_COMMAND *cmd, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
CS_RETCODE ct_callback(CS_CONTEXT *ctx, CS_CONNECTION *con, CS_INT action, CS_INT type, CS_VOID *func)
static CS_INT _ct_map_compute_op(CS_INT comp_op)
static const char * _ct_get_user_api_layer_error(int error)
static CS_INT ct_diag_storeservermsg(CS_CONTEXT *context, CS_CONNECTION *conn, CS_SERVERMSG *message)
CS_RETCODE ct_fetch(CS_COMMAND *cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT *prows_read)
CS_RETCODE ct_poll(CS_CONTEXT *ctx, CS_CONNECTION *connection, CS_INT milliseconds, CS_CONNECTION **compconn, CS_COMMAND **compcmd, CS_INT *compid, CS_INT *compstatus)
static char * get_next_tok(char *str, char *delimiter, char **ptrptr)
CS_RETCODE ct_cmd_drop(CS_COMMAND *cmd)
static void param_clear(CSREMOTE_PROC_PARAM *pparam)
recursively erase the parameter list
static char * _ct_get_msgstr(const char *funcname, int layer, int origin, int severity, int number)
CS_RETCODE ct_get_data(CS_COMMAND *cmd, CS_INT item, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
static CS_INT ct_diag_getservermsg(CS_CONTEXT *context, CS_INT idx, CS_SERVERMSG *message)
CS_RETCODE ct_cmd_props(CS_COMMAND *cmd, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
CS_RETCODE ct_param(CS_COMMAND *cmd, CS_DATAFMT *datafmt, CS_VOID *data, CS_INT datalen, CS_SMALLINT indicator)
CS_RETCODE ct_con_alloc(CS_CONTEXT *ctx, CS_CONNECTION **con)
TDS_SERVER_TYPE _ct_get_server_type(TDSSOCKET *tds, int datatype)
CS_RETCODE ct_con_drop(CS_CONNECTION *con)
static int str_icmp(char *s1, char *s2, int len)
static void rpc_clear(CSREMOTE_PROC *rpc)
static const char * _ct_get_layer(int layer)
int _ct_bind_data(CS_CONTEXT *ctx, TDSRESULTINFO *resinfo, TDSRESULTINFO *bindinfo, CS_INT offset)
static const unsigned char * paramrowalloc(TDSPARAMINFO *params, TDSCOLUMN *curcol, int param_num, void *value, int size)
void _ctclient_msg(CS_CONNECTION *con, const char *funcname, int layer, int origin, int severity, int number, const char *fmt,...)
static const char * ct_describe_cmd_state(CS_INT state)
static int _ct_fetch_cursor(CS_COMMAND *cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT *rows_read)
Read a row of data.
static CS_RETCODE ct_set_command_state(CS_COMMAND *cmd, CS_INT state)
CS_RETCODE ct_diag(CS_CONNECTION *conn, CS_INT operation, CS_INT type, CS_INT idx, CS_VOID *buffer)
static TDSRET _ct_process_return_status(TDSSOCKET *tds)
static CS_INT ct_diag_getclientmsg(CS_CONTEXT *context, CS_INT idx, CS_CLIENTMSG *message)
int _ct_get_client_type(CS_CONTEXT *ctx, TDSCOLUMN *col)
CS_RETCODE ct_close(CS_CONNECTION *con, CS_INT option)
CS_INT _ct_diag_clearmsg(CS_CONTEXT *context, CS_INT type)
CS_RETCODE ct_options(CS_CONNECTION *con, CS_INT action, CS_INT option, CS_VOID *param, CS_INT paramlen, CS_INT *outlen)
CS_RETCODE ct_capability(CS_CONNECTION *con, CS_INT action, CS_INT type, CS_INT capability, CS_VOID *value)
CS_RETCODE ct_send(CS_COMMAND *cmd)
CS_RETCODE ct_data_info(CS_COMMAND *cmd, CS_INT action, CS_INT colnum, CS_IODESC *iodesc)
CS_RETCODE ct_send_data(CS_COMMAND *cmd, CS_VOID *buffer, CS_INT buflen)
CS_RETCODE ct_bind(CS_COMMAND *cmd, CS_INT item, CS_DATAFMT *datafmt, CS_VOID *buffer, CS_INT *copied, CS_SMALLINT *indicator)
CS_RETCODE ct_cancel(CS_CONNECTION *conn, CS_COMMAND *cmd, CS_INT type)
CS_RETCODE ct_con_props(CS_CONNECTION *con, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *out_len)
CS_RETCODE ct_init(CS_CONTEXT *ctx, CS_INT version)
static TDSPARAMINFO * paraminfoalloc(TDSSOCKET *tds, CS_PARAM *first_param)
Allocate memory and copy the rpc information into a TDSPARAMINFO structure.
CS_RETCODE ct_exit(CS_CONTEXT *ctx, CS_INT unused)
static int _ct_fetchable_results(CS_COMMAND *cmd)
CS_RETCODE ct_config(CS_CONTEXT *ctx, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
static CS_DYNAMIC * _ct_allocate_dynamic(CS_CONNECTION *con, char *id, int idlen)
static int _ct_fill_param(CS_INT cmd_type, CS_PARAM *param, CS_DATAFMT *datafmt, CS_VOID *data, CS_INT *datalen, CS_SMALLINT *indicator, CS_BYTE byvalue)
CS_RETCODE ct_describe(CS_COMMAND *cmd, CS_INT item, CS_DATAFMT *datafmt)
CS_RETCODE ct_setparam(CS_COMMAND *cmd, CS_DATAFMT *datafmt, CS_VOID *data, CS_INT *datalen, CS_SMALLINT *indicator)
static CS_INT ct_diag_countmsg(CS_CONTEXT *context, CS_INT type, CS_INT *count)
static const char * _ct_get_origin(int origin)
static void _ct_initialise_cmd(CS_COMMAND *cmd)
#define CONV_CAP(ct, tds)
static CS_CONNECTION * conn
#define _CS_CANCEL_PENDING
CS_LOCALE * _cs_locale_copy(CS_LOCALE *orig)
int _ct_handle_client_message(const TDSCONTEXT *ctxptr, TDSSOCKET *tdsptr, TDSMESSAGE *msgptr)
#define _CS_CURS_TYPE_SENT
#define _CS_RES_DESCRIBE_RESULT
#define _CS_COMMAND_BUILDING
void _cs_locale_free(CS_LOCALE *locale)
#define _CS_ERRHAND_INLINE
int _cs_locale_copy_inplace(CS_LOCALE *new_locale, CS_LOCALE *orig)
#define _CS_CANCEL_NOCANCEL
void _csclient_msg(CS_CONTEXT *ctx, const char *funcname, int layer, int origin, int severity, int number, const char *fmt,...)
#define _CS_COMMAND_READY
int _cs_convert_not_client(CS_CONTEXT *ctx, TDSCOLUMN *curcol, CONV_RESULT *convert_buffer, unsigned char **p_src)
Try to convert to a type we can handle.
#define _CS_RES_END_RESULTS
TDSRET _ct_handle_server_message(const TDSCONTEXT *ctxptr, TDSSOCKET *tdsptr, TDSMESSAGE *msgptr)
#define _CS_RES_CMD_SUCCEED
#define _CS_RES_RESULTSET_EMPTY
#define _CS_CURS_TYPE_REQUESTED
#define _CS_RES_RESULTSET_ROWS
@ TDS_RES_DATA_NOBOUNDARY
@ TDS_RES_DATA_NOSENSITIVITY
@ TDS_RES_DATA_NODATETIMEN
@ TDS_REQ_DATA_BIGDATETIME
@ TDS_REQ_DATA_SENSITIVITY
TDS_OPTION_CMD
options that can be sent with a TDS_OPTIONCMD token
@ TDS_OPT_LIST
Request current setting of a specific option.
@ TDS_OPT_DEFAULT
Set option to its default value.
@ TDS_OPT_SET
Set an option.
#define TDS_NBC_ROW_TOKEN
#define TDS_RETURNSTATUS_TOKEN
#define is_numeric_type(x)
#define TDS_DONEPROC_RESULT
#define tds_capability_has_req(conn, cap)
tds_sysdep_int32_type TDS_INT
#define tds_get_parent(tds)
#define TDS_NO_MORE_RESULTS
tds_sysdep_int64_type TDS_INT8
#define is_unicode_type(x)
#define TDS_DESCRIBE_RESULT
#define TDS_COMPUTE_RESULT
@ TDS_CURSOR_STATE_UNACTIONED
@ TDS_CURSOR_STATE_REQUESTED
@ TDS_PENDING
cilent is waiting for data
tds_sysdep_int16_type TDS_SMALLINT
#define TDS_VECTOR_SIZE(x)
#define tds_new0(type, n)
@ TDS_DONE_ERROR
error occurred
#define TDS_STATUS_RESULT
#define tds_set_parent(tds, val)
#define TDS_DONEINPROC_RESULT
static const char * str(char *buf, int n)
#define tds_cursor_setrows
#define tds_set_param_type
#define tds_alloc_results
#define tds_submit_unprepare
#define tds_read_config_info
#define tds_cursor_declare
#define tds_free_param_results
#define tds_writetext_end
#define tds_set_column_type
#define tds_free_all_results
#define tds_submit_optioncmd
#define tds_release_dynamic
#define tds_free_input_params
#define tds_get_size_by_type
#define tds_writetext_continue
#define tds_connect_and_login
#define tds_submit_prepare
#define tds_alloc_param_result
#define tds_release_cursor
#define tds_set_current_results
#define tds_cursor_dealloc
#define tds_lookup_host_set
#define tds_process_cancel
#define tds_alloc_param_data
#define tds_submit_query_params
#define tds_writetext_start
#define tds_process_tokens
#define tds_submit_execute
operation
Bit operations.
#define tds_get_compiletime_settings
Return a structure capturing the compile-time settings provided to the configure script.
static const char * tds_dstr_cstr(DSTR *s)
Returns a C version (NUL terminated string) of dstr.
DSTR * tds_dstr_copy(DSTR *s, const char *src) TDS_WUR
copy a string from another
static size_t tds_dstr_len(DSTR *s)
Returns the length of the string in bytes.
unsigned int
A callback function used to compare two keys in a database.
if(yy_accept[yy_current_state])
static const CS_INT unused
static void text(MDB_val *v)
const string version
version string
const struct ncbi::grid::netcache::search::fields::SIZE size
const GenericPointer< typename T::ValueType > T2 value
int strncmp(const char *str1, const char *str2, size_t count)
static const GLdouble origin[]
static const char * locale
static const char delimiter[]
#define row(bind, expected)
int get_data_bytes_returned
struct _cs_command * next
CS_SERVERMSG_FUNC _servermsg_cb
CS_CLIENTMSG_FUNC _clientmsg_cb
CS_INT cs_diag_msglimit_client
int login_timeout
not used unless positive
struct cs_diag_msg_client * clientstore
CS_INT cs_diag_msglimit_total
CS_INT cs_diag_msglimit_server
struct cs_diag_msg_svr * svrstore
int query_timeout
not used unless positive
CS_SERVERMSG_FUNC _servermsg_cb
CS_CLIENTMSG_FUNC _clientmsg_cb
struct _cs_dynamic * next
CS_DYNAMIC_PARAM * param_list
CS_SMALLINT indicator_value
CSREMOTE_PROC_PARAM * param_list
struct cs_diag_msg_client * next
struct cs_diag_msg_svr * next
Information about blobs (e.g.
TDS_CAPABILITY_TYPE types[2]
unsigned char values[32/2-2]
Metadata about columns in regular and compute rows.
TDS_TINYINT column_varint_size
size of length when reading from wire (0, 1, 2 or 4)
TDS_TINYINT column_operator
TDS_INT column_size
maximun size of data.
TDS_SMALLINT column_operand
TDS_SMALLINT * column_nullbind
unsigned int column_timestamp
TDS_SMALLINT column_bindtype
unsigned int column_writeable
TDS_TINYINT column_prec
precision for decimal/numeric
TDS_SERVER_TYPE column_type
This type can be different from wire type because conversion (e.g.
unsigned int column_identity
TDS_SMALLINT column_bindfmt
unsigned int column_nullable
TDS_TINYINT column_scale
scale for decimal/numeric
unsigned char * column_data
unsigned int column_output
struct tds_column::@124 on_server
TDS_CHAR * column_varaddr
TDS_INT column_cur_size
size written in variable (ie: char, text, binary).
unsigned int column_hidden
A structure to hold all the compile-time settings.
const char * freetds_version
TDSENV env
environment is shared between all sessions
TDS_USMALLINT tds_version
int(* msg_handler)(const TDSCONTEXT *, TDSSOCKET *, TDSMESSAGE *)
int(* err_handler)(const TDSCONTEXT *, TDSSOCKET *, TDSMESSAGE *)
TDS_CURSOR_STATE cursor_row
Holds informations about a cursor.
TDS_TINYINT options
read only|updatable TODO use it
char * cursor_name
name of the cursor
TDS_INT cursor_id
cursor id returned by the server after cursor declare
TDS_INT cursor_rows
< number of updatable columns
TDS_INT type
row fetched from this cursor
TDS_CURSOR_STATUS status
cursor parameter
Structure to hold a string.
Holds information for a dynamic (also called prepared) query.
TDSPARAMINFO * params
query parameters.
TDSPARAMINFO * res_info
query results
int block_size
packet size (512-65535)
DSTR user_name
account for login
struct addrinfo * ip_addrs
ip(s) of server
DSTR password
password of account login
TDS_CAPABILITIES capabilities
DSTR server_name
server name (in freetds.conf)
DSTR server_charset
charset of server e.g.
unsigned int bulk_copy
if bulk copy should be enabled
Hold information for any results.
Information for a server connection.
TDS_INT ret_status
return status from store procedure
TDS_INT8 rows_affected
rows updated/deleted/inserted/selected, TDS_NO_COUNT if not valid
TDSDYNAMIC * cur_dyn
dynamic structure in use
TDSRESULTINFO * current_results
Current query information.
TDSPARAMINFO * param_info
Store variant informations.
static CS_CONTEXT * context
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4