unknown[24];
58 case CS_FAIL:
return "CS_FAIL";
62 case CS_BUSY:
return "CS_BUSY";
79sprintf(unknown,
"oops: %u ??", retcode);
91 return "cslib user api layer";
96 return "unrecognized layer";
106 return "external error";
109 return "internal CS-Library error";
112 return "common library error";
115 return "intl library error";
120 return "unrecognized origin";
130 return "Memory allocation failure.";
133 return "Conversion between %1! and %2! datatypes is not supported.";
136 return "The conversion/operation resulted in overflow.";
139 return "The conversion/operation was stopped due to a syntax error in the source field.";
142 return "Data is truncated during conversion.";
145 return "Data-conversion resulted in overflow.";
148 return "Unknown callback %1!.";
151 return "Unknown type: %1!.";
154 return "Out of memory!";
159 return "unrecognized error";
167 tdsdump_log(
TDS_DBG_FUNC,
"_cs_get_msgstr(%s, %d, %d, %d, %d)\n", funcname, layer,
origin, severity,
number);
171:
"unrecognized error") < 0) {
184 tdsdump_log(
TDS_DBG_FUNC,
"_csclient_msg(%p, %s, %d, %d, %d, %d, %s)\n",
ctx, funcname, layer,
origin, severity,
number, fmt);
190cm.
msgnumber= (((layer << 24) & 0xFF000000)
191| ((
origin<< 16) & 0x00FF0000)
192| ((severity << 8) & 0x0000FF00)
193| ((
number) & 0x000000FF));
257 if(
orig->language) {
263 if(
orig->charset) {
271 if(!new_locale->
time)
275 if(
orig->collate) {
300 if(
orig->language) {
306 if(
orig->charset) {
314 if(!new_locale->
time)
318 if(
orig->collate) {
368 if(global_cs_ctx !=
NULL) {
369*
ctx= global_cs_ctx;
375global_cs_ctx = *
ctx;
399 tdsdump_log(
TDS_DBG_FUNC,
"cs_config(%p, %d, %d, %p, %d, %p)\n",
ctx, action, property,
buffer, buflen, outlen);
439maxcp = strlen((
char*)
buffer) + 1;
496 intsrc_len, destlen,
len;
504 "cs_convert(%p, %p, %p, %p, %p, %p, %d, %p, %p)\n",
505 ctx, srcfmt, srcdata, destfmt, destdata, resultlen,
506desttype, handle, blk_status);
509 if(destdata ==
NULL) {
517 if(destfmt ==
NULL) {
524 if(resultlen ==
NULL)
525resultlen = &
dummy;
528 if(srcdata ==
NULL) {
531memset(destdata,
'\0', destfmt->
maxlength);
561destlen =
sizeof(destvc->
str);
562destdata = destvc->
str;
568src_type, src_len, desttype, destlen);
574dest = (
unsigned char*) destdata;
578 if(src_type == desttype) {
579 intminlen = src_len < destlen? src_len : destlen;
580 if(handle !=
NULL&& destvc ==
NULL) {
582 if(type_len > minlen) {
586dest = (
unsigned char*) *handle;
596memcpy(dest, srcdata, minlen);
599 if(src_len > destlen) {
601 if(blk_status ==
NULL) {
613 switch(destfmt->
format) {
615memset(dest + src_len,
'\0', destlen - src_len);
616*resultlen = destlen;
627destvc->
len= minlen;
628*resultlen =
sizeof(*destvc);
639 if(src_len > destlen && blk_status !=
NULL) {
645memcpy(dest, srcdata, minlen);
648 if(src_len > destlen) {
654 switch(destfmt->
format) {
656 if(src_len == destlen) {
657*resultlen = src_len;
661dest[src_len] =
'\0';
662*resultlen = src_len + 1;
668memset(dest + src_len,
' ', destlen - src_len);
669*resultlen = destlen;
673memset(dest + src_len,
'\0', destlen - src_len);
674*resultlen = destlen;
687destvc->
len= minlen;
688*resultlen =
sizeof(*destvc);
712memcpy(dest, srcdata, *resultlen);
721memcpy(dest, srcdata, minlen);
724 if(src_len > destlen) {
745 assert(src_type != desttype);
764 char* s = (
char*) srcdata;
765 intsrc_len2 = destlen * 2;
766 if(src_len > 1 && s[0] ==
'0'&& (s[1] ==
'x'|| s[1] ==
'X'))
771 if(src_len2 < src_len)
773src_len2, desttype, &cres);
775 "cs_convert(): retry returned %d\n",
len);
780 if(
len== destlen &&
isxdigit(s[src_len2 - 1])) {
796 _csclient_msg(
ctx,
"cs_convert", 2, 1, 1, 16,
"%d, %d", src_type, desttype);
826 if(
len> destlen) {
828 if(blk_status ==
NULL) {
842 if(handle ==
NULL) {
843memcpy(dest, cres.
ib,
len);
853*resultlen =
sizeof(*destvc);
855memset(dest +
len,
'\0', destlen -
len);
880memcpy(dest, &(cres.
ti), *resultlen);
886memcpy(dest, &(cres.
n), src_len);
887*resultlen = src_len;
895memcpy(dest, &(cres.
dta), *resultlen);
904 if(
len> destlen) {
907 if(blk_status ==
NULL) {
930 switch(destfmt->
format) {
934 if(
len== destlen) {
938 if(handle ==
NULL) {
939memcpy(dest, cres.
c,
len);
946*resultlen =
len+ 1;
953 if(handle ==
NULL) {
954memcpy(dest, cres.
c,
len);
960memset(dest +
len,
' ', destlen -
len);
961*resultlen = destlen;
967 if(handle ==
NULL) {
968memcpy(dest, cres.
c,
len);
974memset(dest +
len,
'\0', destlen -
len);
975*resultlen = destlen;
979 if(handle ==
NULL) {
980memcpy(dest, cres.
c,
len);
993*resultlen =
sizeof(*destvc);
995 if(handle ==
NULL|| *handle != cres.
c) {
1020 boolextended =
false;
1092*locptr = tds_csloc;
1113 tdsdump_log(
TDS_DBG_FUNC,
"cs_locale(%p, %d, %p, %d, %p, %d, %p)\n",
ctx, action,
locale,
type,
buffer, buflen, outlen);
1126buflen = (
int) strlen((
char*)
buffer);
1139buflen = (
int) strlen((
char*)
buffer);
1156buflen = (
int) strlen(
b);
1160 for(
i= 0;
i< buflen; ++
i) {
1161 if(
b[
i] ==
'.') {
1175 if(
i!= (buflen - 1)) {
1201 else if(action ==
CS_GET)
1218((
char*)
buffer)[0] =
'\0';
1223tlen = (
locale->language ?
1224(
int) strlen(
locale->language) : 0) + 1;
1234((
char*)
buffer)[0] =
'\0';
1242tlen = (
locale->language ?
1243(
int) strlen(
locale->language) : 0) + 1;
1244clen = (
locale->charset ?
1245(
int) strlen(
locale->charset) : 0) + 1;
1247 if(buflen < (tlen + clen))
1250*outlen = tlen + clen;
1256((
char*)
buffer)[0] =
'\0';
1259tlen = (
int) strlen((
char*)
buffer);
1278((
char*)
buffer)[0] =
'\0';
1310 ctx,
buffer, buflen, resultlen,
text, textlen, formats, formatlen);
1312va_start(ap, formatlen);
1323 tdsdump_log(
TDS_DBG_FUNC,
"cs_calc(%p, %d, %d, %p, %p, %p)\n",
ctx, op, datatype, var1, var2, dest);
1333 tdsdump_log(
TDS_DBG_FUNC,
"cs_cmp(%p, %d, %p, %p, %p)\n",
ctx, datatype, var1, var2,
result);
1352 tdsdump_log(
TDS_DBG_FUNC,
"cs_diag(%p, %d, %d, %d, %p)\n",
ctx,
operation,
type, idx,
buffer);
1412 tdsdump_log(
TDS_DBG_FUNC,
"cs_manage_convert(%p, %d, %d, %p, %d, %d, %p, %d, %p, %p)\n",
1413 ctx, action, srctype, srcname, srcnamelen, desttype, destname, destnamelen, conv_multiplier, func);
1433 tdsdump_log(
TDS_DBG_FUNC,
"cs_set_convert(%p, %d, %d, %d, %p)\n",
ctx, action, srctype, desttype, func);
1465 tdsdump_log(
TDS_DBG_FUNC,
"cs_time(%p, %p, %p, %d, %p, %p)\n",
ctx,
locale,
buffer, buflen, outlen, daterec);
1496 while(*curptr !=
NULL) {
1498curptr = &((*curptr)->next);
1510 if(*curptr ==
NULL) {
1513(*curptr)->next =
NULL;
1515 if((*curptr)->msg ==
NULL) {
1518memcpy((*curptr)->msg, message,
sizeof(
CS_CLIENTMSG));
1529 CS_INTmsg_count = 0, msg_found = 0;
1538 while(curptr !=
NULL) {
1540 if(msg_count == idx) {
1544curptr = curptr->
next;
1564 while(curptr !=
NULL) {
1566curptr = freeptr->
next;
1583 while(curptr !=
NULL) {
1585curptr = curptr->
next;
1587*
count= msg_count;
1621 if(convert_buffer) {
1626*p_src = (
unsigned char*) convert_buffer;
#define CS_DATETIME4_TYPE
#define CS_BIGDATETIME_TYPE
CS_RETCODE(* CS_CSLIBMSG_FUNC)(CS_CONTEXT *, CS_CLIENTMSG *)
#define CS_SYB_LANG_CHARSET
#define CS_VARBINARY_TYPE
CS_RETCODE(* CS_CONV_FUNC)(CS_CONTEXT *context, CS_DATAFMT *srcfmt, CS_VOID *src, CS_DATAFMT *detsfmt, CS_VOID *dest, CS_INT *destlen)
#define CS_RET_HAFAILOVER
CS_RETCODE cs_ctx_alloc(CS_INT version, CS_CONTEXT **ctx)
CS_RETCODE cs_dt_crack_v2(CS_CONTEXT *ctx, CS_INT datetype, CS_VOID *dateval, CS_DATEREC *daterec)
CS_LOCALE * _cs_locale_copy(CS_LOCALE *orig)
CS_RETCODE cs_dt_info(CS_CONTEXT *ctx, CS_INT action, CS_LOCALE *locale, CS_INT type, CS_INT item, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
CS_RETCODE cs_strcmp(CS_CONTEXT *ctx, CS_LOCALE *locale, CS_INT type, CS_CHAR *str1, CS_INT len1, CS_CHAR *str2, CS_INT len2, CS_INT *result)
CS_RETCODE cs_locale(CS_CONTEXT *ctx, CS_INT action, CS_LOCALE *locale, CS_INT type, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
CS_RETCODE cs_dt_crack(CS_CONTEXT *ctx, CS_INT datetype, CS_VOID *dateval, CS_DATEREC *daterec)
CS_RETCODE cs_config(CS_CONTEXT *ctx, CS_INT action, CS_INT property, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen)
CS_RETCODE cs_calc(CS_CONTEXT *ctx, CS_INT op, CS_INT datatype, CS_VOID *var1, CS_VOID *var2, CS_VOID *dest)
CS_RETCODE cs_set_convert(CS_CONTEXT *ctx, CS_INT action, CS_INT srctype, CS_INT desttype, CS_CONV_FUNC *func)
CS_RETCODE cs_will_convert(CS_CONTEXT *ctx, CS_INT srctype, CS_INT desttype, CS_BOOL *result)
CS_RETCODE cs_loc_alloc(CS_CONTEXT *ctx, CS_LOCALE **locptr)
void _cs_locale_free(CS_LOCALE *locale)
int _cs_locale_copy_inplace(CS_LOCALE *new_locale, CS_LOCALE *orig)
CS_RETCODE cs_ctx_drop(CS_CONTEXT *ctx)
void _csclient_msg(CS_CONTEXT *ctx, const char *funcname, int layer, int origin, int severity, int number, const char *fmt,...)
CS_RETCODE cs_diag(CS_CONTEXT *ctx, CS_INT operation, CS_INT type, CS_INT idx, CS_VOID *buffer)
CS_RETCODE cs_conv_mult(CS_CONTEXT *ctx, CS_LOCALE *srcloc, CS_LOCALE *destloc, CS_INT *conv_multiplier)
CS_RETCODE cs_strbuild(CS_CONTEXT *ctx, CS_CHAR *buffer, CS_INT buflen, CS_INT *resultlen, CS_CHAR *text, CS_INT textlen, CS_CHAR *formats, CS_INT formatlen,...)
CS_RETCODE cs_objects(CS_CONTEXT *ctx, CS_INT action, CS_OBJNAME *objname, CS_OBJDATA *objdata)
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.
CS_RETCODE cs_time(CS_CONTEXT *ctx, CS_LOCALE *locale, CS_VOID *buffer, CS_INT buflen, CS_INT *outlen, CS_DATEREC *daterec)
CS_RETCODE cs_cmp(CS_CONTEXT *ctx, CS_INT datatype, CS_VOID *var1, CS_VOID *var2, CS_INT *result)
CS_RETCODE cs_setnull(CS_CONTEXT *ctx, CS_DATAFMT *datafmt, CS_VOID *buffer, CS_INT buflen)
CS_RETCODE cs_manage_convert(CS_CONTEXT *ctx, CS_INT action, CS_INT srctype, CS_CHAR *srcname, CS_INT srcnamelen, CS_INT desttype, CS_CHAR *destname, CS_INT destnamelen, CS_INT *conv_multiplier, CS_CONV_FUNC *func)
CS_RETCODE cs_ctx_global(CS_INT version, CS_CONTEXT **ctx)
CS_RETCODE cs_loc_drop(CS_CONTEXT *ctx, CS_LOCALE *locale)
CS_RETCODE cs_convert(CS_CONTEXT *ctx, CS_DATAFMT *srcfmt, CS_VOID *srcdata, CS_DATAFMT *destfmt, CS_VOID *destdata, CS_INT *resultlen)
const char * cs_prretcode(int retcode)
TDS_SERVER_TYPE _ct_get_server_type(TDSSOCKET *tds, int datatype)
#define _CS_ERRHAND_INLINE
CS_INT _ct_diag_clearmsg(CS_CONTEXT *context, CS_INT type)
#define TDS_CONVERT_SYNTAX
#define TDS_CONVERT_OVERFLOW
#define TDS_CONVERT_NOMEM
#define TDS_CONVERT_NOAVAIL
struct tdsnumeric TDS_NUMERIC
#define is_numeric_type(x)
tds_sysdep_int32_type TDS_INT
#define is_datetime_type(x)
return true if type is a datetime (but not date or time)
#define tds_new0(type, n)
#define SYBMSDATETIMEOFFSET
#define tds_get_size_by_type
#define tds_numeric_bytes_per_prec
#define tds_alloc_context
static void _cs_locale_free_contents(CS_LOCALE *locale)
static const char * _cs_get_layer(int layer)
static CS_INT cs_diag_clearmsg(CS_CONTEXT *context, CS_INT type)
static const char * _cs_get_origin(int origin)
static const char * _cs_get_user_api_layer_error(int error)
static CS_INT cs_diag_storemsg(CS_CONTEXT *context, CS_CLIENTMSG *message)
static CS_INT cs_diag_getmsg(CS_CONTEXT *context, CS_INT idx, CS_CLIENTMSG *message)
static CS_LOCALE * _cs_locale_alloc(void)
Allocate new CS_LOCALE and initialize it returns NULL on out of memory errors.
CS_RETCODE _cs_convert(CS_CONTEXT *ctx, const CS_DATAFMT_COMMON *srcfmt, CS_VOID *srcdata, const CS_DATAFMT_COMMON *destfmt, CS_VOID *destdata, CS_INT *resultlen, TDS_SERVER_TYPE desttype, CS_VOID **handle, BLK_CONV_STATUS *blk_status)
static char * _cs_get_msgstr(const char *funcname, int layer, int origin, int severity, int number)
static CS_INT cs_diag_countmsg(CS_CONTEXT *context, CS_INT *count)
bool _ct_is_large_identifiers_version(CS_INT version)
Check if a give version supports large identifiers.
const CS_DATAFMT_COMMON * _ct_datafmt_common(CS_CONTEXT *ctx, const CS_DATAFMT *datafmt)
#define is_binary_type(x)
operation
Bit operations.
unsigned int
A callback function used to compare two keys in a database.
where boath are integers</td > n< td ></td > n</tr > n< tr > n< td > tse</td > n< td > optional</td > n< td > String</td > n< td class=\"description\"> TSE option controls what blob is orig
static void text(MDB_val *v)
const string version
version string
static const GLdouble origin[]
static const char * locale
this structure is not directed connected to a TDS protocol but keeps any DATE/TIME information.
int login_timeout
not used unless positive
CS_CSLIBMSG_FUNC _cslibmsg_cb
bool use_large_identifiers
structures uses large identifiers
struct cs_diag_msg * msgstore
int query_timeout
not used unless positive
struct cs_diag_msg * next
Metadata about columns in regular and compute rows.
TDS_SERVER_TYPE column_type
This type can be different from wire type because conversion (e.g.
unsigned char * column_data
TDS_INT column_cur_size
size written in variable (ie: char, text, binary).
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