Line data Source code
1 : /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
2 : * Copyright (C) 1998, 1999, 2000, 2001 Brian Bruns
3 : * Copyright (C) 2002, 2003, 2004, 2005 James K. Lowden
4 : * Copyright (C) 2011-2015 Frediano Ziglio
5 : *
6 : * This library is free software; you can redistribute it and/or
7 : * modify it under the terms of the GNU Library General Public
8 : * License as published by the Free Software Foundation; either
9 : * version 2 of the License, or (at your option) any later version.
10 : *
11 : * This library is distributed in the hope that it will be useful,
12 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : * Library General Public License for more details.
15 : *
16 : * You should have received a copy of the GNU Library General Public
17 : * License along with this library; if not, write to the
18 : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 : * Boston, MA 02111-1307, USA.
20 : */
21 :
22 : #include <config.h>
23 :
24 : #include <stdarg.h>
25 : #include <stdio.h>
26 : #include <assert.h>
27 :
28 : #if HAVE_STDLIB_H
29 : #include <stdlib.h>
30 : #endif /* HAVE_STDLIB_H */
31 :
32 : #if HAVE_STRING_H
33 : #include <string.h>
34 : #endif /* HAVE_STRING_H */
35 :
36 : #include "ctpublic.h"
37 : #include "ctlib.h"
38 : #include <freetds/utils/string.h>
39 : #include <freetds/utils.h>
40 : #include <freetds/enum_cap.h>
41 : #include <freetds/data.h>
42 : #include <freetds/replacements.h>
43 :
44 :
45 : static const char * ct_describe_cmd_state(CS_INT state);
46 : /**
47 : * Read a row of data
48 : * @return 0 on success
49 : */
50 : static int _ct_fetch_cursor(CS_COMMAND * cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT * rows_read);
51 : static int _ct_fetchable_results(CS_COMMAND * cmd);
52 : static TDSRET _ct_process_return_status(TDSSOCKET * tds);
53 :
54 : static int _ct_fill_param(CS_INT cmd_type, CS_PARAM * param, const CS_DATAFMT_LARGE * datafmt, CS_VOID * data,
55 : CS_INT * datalen, CS_SMALLINT * indicator, CS_BYTE byvalue);
56 : static void _ct_initialise_cmd(CS_COMMAND *cmd);
57 : static CS_RETCODE _ct_cancel_cleanup(CS_COMMAND * cmd);
58 : static CS_INT _ct_map_compute_op(CS_INT comp_op);
59 : static bool query_has_for_update(const char *query);
60 :
61 : /* Added for CT_DIAG */
62 : /* Code changes starts here - CT_DIAG - 01 */
63 :
64 : static CS_INT ct_diag_storeclientmsg(CS_CONTEXT * context, CS_CONNECTION * conn, CS_CLIENTMSG * message);
65 : static CS_INT ct_diag_storeservermsg(CS_CONTEXT * context, CS_CONNECTION * conn, CS_SERVERMSG * message);
66 : static CS_INT ct_diag_countmsg(CS_CONTEXT * context, CS_INT type, CS_INT * count);
67 : static CS_INT ct_diag_getclientmsg(CS_CONTEXT * context, CS_INT idx, CS_CLIENTMSG * message);
68 : static CS_INT ct_diag_getservermsg(CS_CONTEXT * context, CS_INT idx, CS_SERVERMSG * message);
69 :
70 : /* Code changes ends here - CT_DIAG - 01 */
71 :
72 : /* Added code for RPC functionality -SUHA */
73 : /* RPC Code changes starts here */
74 :
75 : static void rpc_clear(CSREMOTE_PROC * rpc);
76 : static void param_clear(CSREMOTE_PROC_PARAM * pparam);
77 :
78 : static TDSPARAMINFO *paraminfoalloc(TDSSOCKET * tds, CS_PARAM * first_param);
79 :
80 : static CS_DYNAMIC * _ct_allocate_dynamic(CS_CONNECTION * con, char *id, int idlen);
81 : static CS_INT _ct_deallocate_dynamic(CS_CONNECTION * con, CS_DYNAMIC *dyn);
82 : static CS_DYNAMIC * _ct_locate_dynamic(CS_CONNECTION * con, char *id, int idlen);
83 :
84 : /* RPC Code changes ends here */
85 :
86 : static const char *
87 530 : _ct_get_layer(int layer)
88 : {
89 530 : tdsdump_log(TDS_DBG_FUNC, "_ct_get_layer(%d)\n", layer);
90 :
91 530 : switch (layer) {
92 : case 1:
93 : return "user api layer";
94 : break;
95 0 : case 2:
96 0 : return "blk layer";
97 : break;
98 : default:
99 : break;
100 : }
101 0 : return "unrecognized layer";
102 : }
103 :
104 : static const char *
105 530 : _ct_get_origin(int origin)
106 : {
107 530 : tdsdump_log(TDS_DBG_FUNC, "_ct_get_origin(%d)\n", origin);
108 :
109 530 : switch (origin) {
110 : case 1:
111 : return "external error";
112 : break;
113 0 : case 2:
114 0 : return "internal CT-Library error";
115 : break;
116 0 : case 4:
117 0 : return "common library error";
118 : break;
119 0 : case 5:
120 0 : return "intl library error";
121 : break;
122 0 : case 6:
123 0 : return "user error";
124 : break;
125 0 : case 7:
126 0 : return "internal BLK-Library error";
127 : break;
128 : default:
129 : break;
130 : }
131 0 : return "unrecognized origin";
132 : }
133 :
134 : static const char *
135 530 : _ct_get_user_api_layer_error(int error)
136 : {
137 530 : tdsdump_log(TDS_DBG_FUNC, "_ct_get_user_api_layer_error(%d)\n", error);
138 :
139 530 : switch (error) {
140 : case 2:
141 : return "Memory allocation failure.";
142 : break;
143 20 : case 3:
144 20 : return "The parameter %1! cannot be NULL.";
145 : break;
146 10 : case 4:
147 10 : return "Parameter %1! has an illegal value of %2!.";
148 : break;
149 210 : case 5:
150 210 : return "An illegal value of %1! given for parameter %2!.";
151 : break;
152 10 : case 6:
153 10 : return "The parameter %1! cannot be NULL.";
154 : break;
155 90 : case 8:
156 90 : return "The %1! parameter must be NULL.";
157 : break;
158 90 : case 9:
159 90 : return "The %1! parameter must be set to CS_UNUSED.";
160 : break;
161 10 : case 15:
162 10 : return "Use direction CS_BLK_IN or CS_BLK_OUT for a bulk copy operation.";
163 : break;
164 20 : case 18:
165 20 : return "A cursor must be declared before this command type can be initialized.";
166 : break;
167 0 : case 29:
168 0 : return "This type of command cannot be batched with the command already initialized on the command structure.";
169 : break;
170 10 : case 51:
171 10 : return "Exactly one of context and connection must be non-NULL.";
172 : break;
173 20 : case 135:
174 20 : return "The specified id does not exist on this connection.";
175 : break;
176 20 : case 137:
177 20 : return "A bind count of %1! is not consistent with the count supplied for existing binds. "
178 : "The current bind count is %2!.";
179 : break;
180 0 : case 140:
181 0 : return "Failed when processing results from server.";
182 : break;
183 0 : case 141:
184 0 : return "Parameter %1! has an illegal value of %2!";
185 : break;
186 0 : case 142:
187 0 : return "No value or default value available and NULL not allowed. col = %1! row = %2! .";
188 : break;
189 0 : case 143:
190 0 : return "parameter name(s) must be supplied for LANGUAGE command.";
191 : break;
192 10 : case 155:
193 10 : return "This routine cannot be called when the command structure is idle.";
194 : break;
195 10 : case 171:
196 10 : return "A cursor must be opened before this command type can be initialized.";
197 : break;
198 : default:
199 : break;
200 : }
201 0 : return "unrecognized error";
202 : }
203 :
204 : static char *
205 530 : _ct_get_msgstr(const char *funcname, int layer, int origin, int severity, int number)
206 : {
207 : char *m;
208 :
209 530 : tdsdump_log(TDS_DBG_FUNC, "_ct_get_msgstr(%s, %d, %d, %d, %d)\n", funcname, layer, origin, severity, number);
210 :
211 530 : if (asprintf(&m,
212 : "%s: %s: %s: %s", funcname, _ct_get_layer(layer), _ct_get_origin(origin), _ct_get_user_api_layer_error(number)
213 : ) < 0) {
214 : return NULL;
215 : }
216 530 : return m;
217 : }
218 :
219 : void
220 530 : _ctclient_msg(CS_CONTEXT *ctx, CS_CONNECTION * con, const char *funcname,
221 : int layer, int origin, int severity, int number, const char *fmt, ...)
222 : {
223 : va_list ap;
224 : CS_CLIENTMSG cm;
225 : char *msgstr;
226 530 : CS_CLIENTMSG_FUNC clientmsg_cb = NULL;
227 :
228 530 : tdsdump_log(TDS_DBG_FUNC, "_ctclient_msg(%p, %p, %s, %d, %d, %d, %d, %s)\n",
229 : ctx, con, funcname, layer, origin, severity, number, fmt);
230 :
231 530 : if (!con && !ctx)
232 0 : return;
233 :
234 530 : if (con) {
235 510 : ctx = con->ctx;
236 510 : clientmsg_cb = con->clientmsg_cb;
237 : }
238 510 : if (!clientmsg_cb)
239 80 : clientmsg_cb = ctx->clientmsg_cb;
240 :
241 530 : va_start(ap, fmt);
242 :
243 530 : if (clientmsg_cb) {
244 530 : cm.severity = severity;
245 1060 : cm.msgnumber = (((layer << 24) & 0xFF000000)
246 530 : | ((origin << 16) & 0x00FF0000)
247 530 : | ((severity << 8) & 0x0000FF00)
248 530 : | ((number) & 0x000000FF));
249 530 : msgstr = _ct_get_msgstr(funcname, layer, origin, severity, number);
250 530 : tds_vstrbuild(cm.msgstring, CS_MAX_MSG, &(cm.msgstringlen), msgstr, CS_NULLTERM, fmt, CS_NULLTERM, ap);
251 530 : cm.msgstring[cm.msgstringlen] = '\0';
252 530 : free(msgstr);
253 530 : cm.osnumber = 0;
254 530 : cm.osstring[0] = '\0';
255 530 : cm.osstringlen = 0;
256 530 : cm.status = 0;
257 : /* cm.sqlstate */
258 530 : cm.sqlstatelen = 0;
259 530 : clientmsg_cb(ctx, con, &cm);
260 : }
261 :
262 530 : va_end(ap);
263 : }
264 :
265 : static CS_RETCODE
266 18056 : ct_set_command_state(CS_COMMAND *cmd, CS_INT state)
267 : {
268 18056 : tdsdump_log(TDS_DBG_FUNC, "setting command state to %s (from %s)\n",
269 : ct_describe_cmd_state(state),
270 : ct_describe_cmd_state(cmd->command_state));
271 :
272 18056 : cmd->command_state = state;
273 :
274 18056 : return CS_SUCCEED;
275 : }
276 :
277 : static const char *
278 0 : ct_describe_cmd_state(CS_INT state)
279 : {
280 0 : tdsdump_log(TDS_DBG_FUNC, "ct_describe_cmd_state(%d)\n", state);
281 :
282 0 : switch (state) {
283 : case _CS_COMMAND_IDLE:
284 : return "IDLE";
285 0 : case _CS_COMMAND_BUILDING:
286 0 : return "BUILDING";
287 0 : case _CS_COMMAND_READY:
288 0 : return "READY";
289 0 : case _CS_COMMAND_SENT:
290 0 : return "SENT";
291 : }
292 0 : return "???";
293 : }
294 :
295 : CS_RETCODE
296 1380 : ct_exit(CS_CONTEXT * ctx, CS_INT unused)
297 : {
298 1380 : tdsdump_log(TDS_DBG_FUNC, "ct_exit(%p, %d)\n", ctx, unused);
299 :
300 1380 : return CS_SUCCEED;
301 : }
302 :
303 : CS_RETCODE
304 1380 : ct_init(CS_CONTEXT * ctx, CS_INT version)
305 : {
306 : /* uncomment the next line to get pre-login trace */
307 : /* tdsdump_open("/tmp/tds2.log"); */
308 1380 : tdsdump_log(TDS_DBG_FUNC, "ct_init(%p, %d)\n", ctx, version);
309 :
310 1380 : ctx->tds_ctx->msg_handler = _ct_handle_server_message;
311 1380 : ctx->tds_ctx->err_handler = _ct_handle_client_message;
312 1380 : ctx->use_large_identifiers = _ct_is_large_identifiers_version(version);
313 :
314 1380 : return CS_SUCCEED;
315 : }
316 :
317 : CS_RETCODE
318 1360 : ct_con_alloc(CS_CONTEXT * ctx, CS_CONNECTION ** con)
319 : {
320 : TDSLOGIN *login;
321 :
322 1360 : tdsdump_log(TDS_DBG_FUNC, "ct_con_alloc(%p, %p)\n", ctx, con);
323 :
324 1360 : login = tds_alloc_login(true);
325 1360 : if (!login)
326 : return CS_FAIL;
327 :
328 : /* set default values */
329 1360 : if (!tds_set_library(login, "CT-Library")) {
330 0 : tds_free_login(login);
331 0 : return CS_FAIL;
332 : }
333 :
334 1360 : *con = tds_new0(CS_CONNECTION, 1);
335 1360 : if (!*con) {
336 0 : tds_free_login(login);
337 0 : return CS_FAIL;
338 : }
339 1360 : (*con)->tds_login = login;
340 1360 : (*con)->server_addr = NULL;
341 :
342 : /* so we know who we belong to */
343 1360 : (*con)->ctx = ctx;
344 :
345 : /* tds_set_packet((*con)->tds_login, TDS_DEF_BLKSZ); */
346 1360 : return CS_SUCCEED;
347 : }
348 :
349 : CS_RETCODE
350 2848 : ct_callback(CS_CONTEXT * ctx, CS_CONNECTION * con, CS_INT action, CS_INT type, CS_VOID * func)
351 : {
352 2848 : int (*funcptr) (void *, void *, void *) = (int (*)(void *, void *, void *)) func;
353 :
354 2848 : tdsdump_log(TDS_DBG_FUNC, "ct_callback(%p, %p, %d, %d, %p)\n", ctx, con, action, type, func);
355 :
356 2848 : tdsdump_log(TDS_DBG_FUNC, "ct_callback() action = %s\n", CS_GET ? "CS_GET" : "CS_SET");
357 : /* one of these has to be defined */
358 2848 : if (!ctx && !con)
359 : return CS_FAIL;
360 :
361 2838 : if (!!ctx == !!con) {
362 10 : _ctclient_msg(ctx, con, "ct_callback()", 1, 1, 1, 51, "");
363 10 : return CS_FAIL;
364 : }
365 :
366 2828 : if (action != CS_GET && action != CS_SET) {
367 20 : _ctclient_msg(ctx, con, "ct_callback()", 1, 1, 1, 5, "%d, %s", action, "action");
368 20 : return CS_FAIL;
369 : }
370 :
371 2808 : if (action == CS_GET) {
372 : CS_VOID *out_func;
373 :
374 50 : switch (type) {
375 10 : case CS_CLIENTMSG_CB:
376 10 : out_func = (CS_VOID *) (con ? con->clientmsg_cb : ctx->clientmsg_cb);
377 : break;
378 10 : case CS_SERVERMSG_CB:
379 10 : out_func = (CS_VOID *) (con ? con->servermsg_cb : ctx->servermsg_cb);
380 : break;
381 0 : case CS_INTERRUPT_CB:
382 0 : out_func = (CS_VOID *) (con ? con->interrupt_cb : ctx->interrupt_cb);
383 : break;
384 : #if ENABLE_EXTRA_CHECKS
385 : case CS_QUERY_HAS_FOR_UPDATE:
386 : out_func = (CS_VOID *) query_has_for_update;
387 : break;
388 : #endif
389 20 : default:
390 20 : _ctclient_msg(ctx, con, "ct_callback()", 1, 1, 1, 5, "%d, %s", type, "type");
391 20 : return CS_FAIL;
392 : }
393 :
394 30 : if (!func) {
395 20 : _ctclient_msg(ctx, con, "ct_callback()", 1, 1, 1, 3, "func");
396 20 : return CS_FAIL;
397 : }
398 10 : *(void **) func = out_func;
399 10 : return CS_SUCCEED;
400 : }
401 :
402 : /* CS_SET */
403 2758 : switch (type) {
404 1370 : case CS_CLIENTMSG_CB:
405 1370 : if (con)
406 30 : con->clientmsg_cb = (CS_CLIENTMSG_FUNC) funcptr;
407 : else
408 1340 : ctx->clientmsg_cb = (CS_CLIENTMSG_FUNC) funcptr;
409 : break;
410 1358 : case CS_SERVERMSG_CB:
411 1358 : if (con)
412 10 : con->servermsg_cb = (CS_SERVERMSG_FUNC) funcptr;
413 : else
414 1348 : ctx->servermsg_cb = (CS_SERVERMSG_FUNC) funcptr;
415 : break;
416 10 : case CS_INTERRUPT_CB:
417 10 : if (funcptr) {
418 10 : if (con)
419 10 : ctx = con->ctx;
420 : /* install shim on demand */
421 10 : ctx->tds_ctx->int_handler = _ct_handle_interrupt;
422 : }
423 10 : if (con)
424 10 : con->interrupt_cb = (CS_INTERRUPT_FUNC) funcptr;
425 : else
426 0 : ctx->interrupt_cb = (CS_INTERRUPT_FUNC) funcptr;
427 : break;
428 20 : default:
429 20 : _ctclient_msg(ctx, con, "ct_callback()", 1, 1, 1, 5, "%d, %s", type, "type");
430 20 : return CS_FAIL;
431 : }
432 : return CS_SUCCEED;
433 : }
434 :
435 : CS_RETCODE
436 4130 : ct_con_props(CS_CONNECTION * con, CS_INT action, CS_INT property, CS_VOID * buffer, CS_INT buflen, CS_INT * out_len)
437 : {
438 : CS_INT intval, maxcp;
439 : TDSSOCKET *tds;
440 : TDSLOGIN *tds_login;
441 :
442 4130 : tdsdump_log(TDS_DBG_FUNC, "ct_con_props(%p, %d, %d, %p, %d, %p)\n", con, action, property, buffer, buflen, out_len);
443 :
444 4130 : if (!con)
445 : return CS_FAIL;
446 :
447 4120 : tdsdump_log(TDS_DBG_FUNC, "ct_con_props() action = %s property = %d\n", action == CS_GET ? "CS_GET" : "CS_SET", property);
448 :
449 4120 : tds = con->tds_socket;
450 4120 : tds_login = con->tds_login;
451 :
452 4120 : if (action == CS_SET) {
453 4050 : char *set_buffer = NULL;
454 4050 : bool copy_ret = true;
455 :
456 4050 : switch (property) {
457 : /* string properties */
458 2700 : case CS_USERNAME:
459 : case CS_PASSWORD:
460 : case CS_APPNAME:
461 : case CS_HOSTNAME:
462 : case CS_CLIENTCHARSET:
463 : case CS_DATABASE:
464 : case CS_SERVERADDR:
465 : case CS_SEC_SERVERPRINCIPAL:
466 2700 : buflen = _ct_get_string_length(buffer, buflen);
467 2700 : if (buflen < 0) {
468 20 : _ctclient_msg(NULL, con, "ct_con_props(SET,APPNAME)", 1, 1, 1, 5, "%d, %s", buflen, "buflen");
469 20 : return CS_FAIL;
470 : }
471 2680 : set_buffer = tds_strndup(buffer, buflen);
472 2680 : if (!set_buffer)
473 : return CS_FAIL;
474 : break;
475 : }
476 :
477 : /*
478 : * XXX "login" properties shouldn't be set after
479 : * login. I don't know if it should fail silently
480 : * or return an error.
481 : */
482 4030 : switch (property) {
483 1340 : case CS_USERNAME:
484 1340 : copy_ret = tds_set_user(tds_login, set_buffer);
485 1340 : break;
486 1340 : case CS_PASSWORD:
487 1340 : copy_ret = tds_set_passwd(tds_login, set_buffer);
488 1340 : break;
489 0 : case CS_APPNAME:
490 0 : copy_ret = tds_set_app(tds_login, set_buffer);
491 0 : break;
492 0 : case CS_HOSTNAME:
493 0 : copy_ret = tds_set_host(tds_login, set_buffer);
494 0 : break;
495 0 : case CS_CLIENTCHARSET:
496 0 : copy_ret = tds_set_client_charset(tds_login, set_buffer);
497 0 : break;
498 0 : case CS_PORT:
499 0 : tds_set_port(tds_login, *((int *) buffer));
500 0 : break;
501 0 : case CS_DATABASE:
502 0 : copy_ret = !!tds_dstr_copy(&tds_login->database, set_buffer);
503 0 : break;
504 0 : case CS_SERVERADDR: {
505 : /* Format of this property: "[hostname] [port]" */
506 0 : char *host, *port, *lasts = NULL;
507 : int portno;
508 0 : host= strtok_r(set_buffer, " ", &lasts);
509 0 : port= strtok_r(NULL, " ", &lasts);
510 0 : if (!host || !port) {
511 0 : free(set_buffer);
512 0 : return CS_FAIL;
513 : }
514 :
515 0 : portno = (int)strtol(port, NULL, 10);
516 0 : if (portno < 1 || portno >= 65536) {
517 0 : free(set_buffer);
518 0 : return CS_FAIL;
519 : }
520 0 : con->server_addr = strdup(host);
521 0 : tds_set_port(tds_login, portno);
522 0 : break;
523 : }
524 0 : case CS_SEC_SERVERPRINCIPAL:
525 0 : copy_ret = !!tds_dstr_copy(&tds_login->server_spn, set_buffer);
526 0 : break;
527 0 : case CS_LOC_PROP:
528 : /* sybase docs say that this structure must be copied, not referenced */
529 0 : if (!buffer)
530 : return CS_FAIL;
531 :
532 0 : if (con->locale)
533 0 : _cs_locale_free(con->locale);
534 0 : con->locale = _cs_locale_copy((CS_LOCALE *) buffer);
535 0 : if (!con->locale)
536 : return CS_FAIL;
537 : break;
538 0 : case CS_USERDATA:
539 0 : free(con->userdata);
540 0 : con->userdata = (void *) malloc(buflen + 1);
541 0 : if (!con->userdata)
542 : return CS_FAIL;
543 0 : tdsdump_log(TDS_DBG_INFO2, "setting userdata orig %p new %p\n", buffer, con->userdata);
544 0 : con->userdata_len = buflen;
545 0 : memcpy(con->userdata, buffer, buflen);
546 0 : break;
547 1330 : case CS_BULK_LOGIN:
548 1330 : memcpy(&intval, buffer, sizeof(intval));
549 1330 : tds_set_bulk(tds_login, !!intval);
550 1330 : break;
551 0 : case CS_PACKETSIZE:
552 0 : memcpy(&intval, buffer, sizeof(intval));
553 0 : tds_set_packet(tds_login, (short) intval);
554 0 : break;
555 0 : case CS_TDS_VERSION:
556 : /*
557 : * FIXME
558 : * (a) We don't support all versions in tds/login.c -
559 : * I tried to pick reasonable versions.
560 : * (b) Might need support outside of tds/login.c
561 : * (c) It's a "negotiated" property so probably
562 : * needs tds_process_env_chg() support
563 : * (d) Minor - we don't check against context
564 : * which should limit the acceptable values
565 : */
566 0 : if (*(int *) buffer == CS_TDS_AUTO) {
567 0 : tds_set_version(tds_login, 0, 0);
568 0 : } else if (*(int *) buffer == CS_TDS_40) {
569 0 : tds_set_version(tds_login, 4, 2);
570 0 : } else if (*(int *) buffer == CS_TDS_42) {
571 0 : tds_set_version(tds_login, 4, 2);
572 0 : } else if (*(int *) buffer == CS_TDS_46) {
573 0 : tds_set_version(tds_login, 4, 6);
574 0 : } else if (*(int *) buffer == CS_TDS_495) {
575 0 : tds_set_version(tds_login, 4, 6);
576 0 : } else if (*(int *) buffer == CS_TDS_50) {
577 0 : tds_set_version(tds_login, 5, 0);
578 0 : } else if (*(int *) buffer == CS_TDS_70) {
579 0 : tds_set_version(tds_login, 7, 0);
580 0 : } else if (*(int *) buffer == CS_TDS_71) {
581 0 : tds_set_version(tds_login, 7, 1);
582 0 : } else if (*(int *) buffer == CS_TDS_72) {
583 0 : tds_set_version(tds_login, 7, 2);
584 0 : } else if (*(int *) buffer == CS_TDS_73) {
585 0 : tds_set_version(tds_login, 7, 3);
586 0 : } else if (*(int *) buffer == CS_TDS_74) {
587 0 : tds_set_version(tds_login, 7, 4);
588 0 : } else if (*(int *) buffer == CS_TDS_80) {
589 0 : tds_set_version(tds_login, 8, 0);
590 : } else {
591 : return CS_FAIL;
592 : }
593 : break;
594 20 : case CS_TIMEOUT:
595 : /* set the query timeout as an integer in seconds */
596 20 : tds_login->query_timeout = *(CS_INT *) buffer;
597 20 : if (tds_login->query_timeout == CS_NO_LIMIT)
598 0 : tds_login->query_timeout = 0;
599 20 : if (tds)
600 20 : tds->query_timeout = tds_login->query_timeout;
601 : break;
602 0 : case CS_LOGIN_TIMEOUT:
603 : /* set the connect timeout as an integer in seconds */
604 0 : tds_login->connect_timeout = *(CS_INT *) buffer;
605 0 : if (tds_login->connect_timeout == CS_NO_LIMIT)
606 0 : tds_login->connect_timeout = 0;
607 : break;
608 0 : case CS_SEC_NETWORKAUTH:
609 0 : con->network_auth = !!(*(CS_INT *) buffer);
610 0 : break;
611 0 : case CS_SEC_MUTUALAUTH:
612 0 : tds_login->mutual_authentication = !!(*(CS_INT *) buffer);
613 0 : break;
614 0 : case CS_SEC_DELEGATION:
615 0 : tds_login->gssapi_use_delegation = !!(*(CS_INT *) buffer);
616 0 : break;
617 0 : default:
618 0 : tdsdump_log(TDS_DBG_ERROR, "Unknown property %d\n", property);
619 : break;
620 : }
621 4030 : free(set_buffer);
622 4030 : if (!copy_ret)
623 : return CS_FAIL;
624 70 : } else if (action == CS_GET) {
625 : DSTR *s;
626 :
627 70 : switch (property) {
628 0 : case CS_USERNAME:
629 0 : s = &tds_login->user_name;
630 0 : goto str_copy;
631 0 : case CS_PASSWORD:
632 0 : s = &tds_login->password;
633 0 : goto str_copy;
634 0 : case CS_APPNAME:
635 0 : s = &tds_login->app_name;
636 0 : goto str_copy;
637 0 : case CS_HOSTNAME:
638 0 : s = &tds_login->client_host_name;
639 0 : goto str_copy;
640 0 : case CS_SERVERNAME:
641 0 : s = &tds_login->server_name;
642 0 : goto str_copy;
643 0 : case CS_CLIENTCHARSET:
644 0 : s = &tds_login->client_charset;
645 0 : goto str_copy;
646 0 : case CS_DATABASE:
647 0 : s = &tds_login->database;
648 0 : str_copy:
649 0 : if (out_len)
650 0 : *out_len = (CS_INT) tds_dstr_len(s);
651 0 : strlcpy((char *) buffer, tds_dstr_cstr(s), buflen);
652 0 : break;
653 0 : case CS_PRODUCT_NAME:
654 0 : if (IS_TDSDEAD(tds) || tds->conn->product_name == NULL)
655 : /* TODO return proper error */
656 : return CS_FAIL;
657 0 : if (out_len)
658 0 : *out_len = (CS_INT) strlen(tds->conn->product_name);
659 0 : strlcpy((char *) buffer, tds->conn->product_name, buflen);
660 0 : break;
661 0 : case CS_LOC_PROP:
662 0 : if (buflen != CS_UNUSED || !con->locale || !buffer)
663 : return CS_FAIL;
664 :
665 0 : if (!_cs_locale_copy_inplace((CS_LOCALE *) buffer, con->locale))
666 : return CS_FAIL;
667 : break;
668 0 : case CS_USERDATA:
669 0 : tdsdump_log(TDS_DBG_INFO2, "fetching userdata %p\n", con->userdata);
670 0 : maxcp = con->userdata_len;
671 0 : if (out_len)
672 0 : *out_len = maxcp;
673 0 : if (maxcp > buflen)
674 0 : maxcp = buflen;
675 0 : memcpy(buffer, con->userdata, maxcp);
676 0 : break;
677 0 : case CS_CON_STATUS:
678 0 : intval = 0;
679 0 : if (!(IS_TDSDEAD(tds)))
680 0 : intval |= CS_CONSTAT_CONNECTED;
681 0 : if (tds && tds->state == TDS_DEAD)
682 0 : intval |= CS_CONSTAT_DEAD;
683 0 : memcpy(buffer, &intval, sizeof(intval));
684 0 : break;
685 0 : case CS_BULK_LOGIN:
686 0 : if (tds_login->bulk_copy)
687 : intval = CS_FALSE;
688 : else
689 0 : intval = CS_TRUE;
690 0 : memcpy(buffer, &intval, sizeof(intval));
691 0 : break;
692 0 : case CS_PACKETSIZE:
693 0 : if (tds)
694 0 : intval = tds->conn->env.block_size;
695 : else
696 0 : intval = tds_login->block_size;
697 0 : memcpy(buffer, &intval, sizeof(intval));
698 0 : if (out_len)
699 0 : *out_len = sizeof(intval);
700 : break;
701 20 : case CS_TDS_VERSION:
702 20 : switch (tds->conn->tds_version) {
703 0 : case 0x400:
704 0 : (*(int *) buffer = CS_TDS_40);
705 0 : break;
706 0 : case 0x402:
707 0 : (*(int *) buffer = CS_TDS_42);
708 0 : break;
709 0 : case 0x406:
710 0 : (*(int *) buffer = CS_TDS_46);
711 0 : break;
712 0 : case 0x400 + 95:
713 0 : (*(int *) buffer = CS_TDS_495);
714 0 : break;
715 4 : case 0x500:
716 4 : (*(int *) buffer = CS_TDS_50);
717 4 : break;
718 0 : case 0x700:
719 0 : (*(int *) buffer = CS_TDS_70);
720 0 : break;
721 8 : case 0x701:
722 8 : (*(int *) buffer = CS_TDS_71);
723 8 : break;
724 0 : case 0x702:
725 0 : (*(int *) buffer = CS_TDS_72);
726 0 : break;
727 4 : case 0x703:
728 4 : (*(int *) buffer = CS_TDS_73);
729 4 : break;
730 4 : case 0x704:
731 4 : (*(int *) buffer = CS_TDS_74);
732 4 : break;
733 0 : case 0x800:
734 0 : (*(int *) buffer = CS_TDS_80);
735 0 : break;
736 : default:
737 : return CS_FAIL;
738 : }
739 : break;
740 50 : case CS_PARENT_HANDLE:
741 50 : *(CS_CONTEXT **) buffer = con->ctx;
742 50 : break;
743 0 : case CS_TIMEOUT:
744 0 : *(CS_INT *) buffer = tds_login->query_timeout;
745 0 : if (tds_login->query_timeout == 0)
746 0 : *(CS_INT *) buffer = CS_NO_LIMIT;
747 : break;
748 0 : case CS_LOGIN_TIMEOUT:
749 0 : *(CS_INT *) buffer = tds_login->connect_timeout;
750 0 : if (tds_login->connect_timeout == 0)
751 0 : *(CS_INT *) buffer = CS_NO_LIMIT;
752 : break;
753 0 : case CS_ENDPOINT:
754 0 : *(CS_INT *) buffer = tds_get_s(con->tds_socket);
755 0 : break;
756 0 : default:
757 0 : tdsdump_log(TDS_DBG_ERROR, "Unknown property %d\n", property);
758 : break;
759 : }
760 0 : }
761 : return CS_SUCCEED;
762 : }
763 :
764 : CS_RETCODE
765 1350 : ct_connect(CS_CONNECTION * con, CS_CHAR * servername, CS_INT snamelen)
766 : {
767 : char *server;
768 1350 : int needfree = 0;
769 : CS_CONTEXT *ctx;
770 : TDSLOGIN *login;
771 : bool copy_ret;
772 :
773 1350 : tdsdump_log(TDS_DBG_FUNC, "ct_connect(%p, %s, %d)\n", con, servername ? servername : "NULL", snamelen);
774 :
775 1350 : if (con->server_addr) {
776 : server = "";
777 1350 : } else if (!servername || snamelen == 0 || snamelen == CS_UNUSED) {
778 : server = NULL;
779 1350 : } else if (snamelen == CS_NULLTERM) {
780 : server = (char *) servername;
781 10 : } else if (snamelen < 0) {
782 10 : _ctclient_msg(NULL, con, "ct_connect()", 1, 1, 1, 5, "%d, %s", snamelen, "snamelen");
783 10 : return CS_FAIL;
784 : } else {
785 0 : server = tds_strndup(servername, snamelen);
786 0 : needfree++;
787 : }
788 1340 : copy_ret = tds_set_server(con->tds_login, server);
789 1340 : if (needfree)
790 0 : free(server);
791 1340 : if (!copy_ret)
792 : return CS_FAIL;
793 1340 : ctx = con->ctx;
794 1340 : if (!(con->tds_socket = tds_alloc_socket(ctx->tds_ctx, 512)))
795 : return CS_FAIL;
796 1340 : tds_set_parent(con->tds_socket, (void *) con);
797 1340 : if (!(login = tds_read_config_info(con->tds_socket, con->tds_login, ctx->tds_ctx->locale))) {
798 0 : tds_free_socket(con->tds_socket);
799 0 : con->tds_socket = NULL;
800 0 : return CS_FAIL;
801 : }
802 1340 : if (con->server_addr) {
803 0 : if (TDS_FAILED(tds_lookup_host_set(con->server_addr, &login->ip_addrs)))
804 : goto Cleanup;
805 0 : if (!tds_dstr_copy(&login->server_host_name, con->server_addr))
806 : goto Cleanup;
807 : }
808 :
809 : /* Timeouts ... */
810 1340 : if (ctx->login_timeout > 0) {
811 0 : login->connect_timeout = ctx->login_timeout;
812 : }
813 :
814 1340 : if (ctx->query_timeout > 0) {
815 0 : login->query_timeout = ctx->query_timeout;
816 : }
817 :
818 : /* override locale settings with CS_CONNECTION settings, if any */
819 1340 : if (con->locale) {
820 0 : if (con->locale->charset) {
821 0 : if (!tds_dstr_copy(&login->server_charset, con->locale->charset))
822 : goto Cleanup;
823 : }
824 0 : if (con->locale->language) {
825 0 : if (!tds_dstr_copy(&login->language, con->locale->language))
826 : goto Cleanup;
827 : }
828 0 : if (con->locale->time && tds_get_ctx(con->tds_socket)) {
829 0 : TDSLOCALE *locale = tds_get_ctx(con->tds_socket)->locale;
830 0 : free(locale->datetime_fmt);
831 : /* TODO convert format from CTLib to libTDS */
832 0 : locale->datetime_fmt = strdup(con->locale->time);
833 0 : if (!locale->datetime_fmt)
834 : goto Cleanup;
835 : }
836 : /* TODO how to handle this?
837 : if (con->locale->collate) {
838 : }
839 : */
840 : }
841 :
842 1340 : if (con->network_auth) {
843 0 : tds_dstr_empty(&login->user_name);
844 0 : tds_dstr_empty(&login->password);
845 : }
846 :
847 1340 : if (TDS_FAILED(tds_connect_and_login(con->tds_socket, login)))
848 : goto Cleanup;
849 :
850 1330 : tds_free_login(login);
851 :
852 1330 : tdsdump_log(TDS_DBG_FUNC, "leaving ct_connect() returning %d\n", CS_SUCCEED);
853 : return CS_SUCCEED;
854 :
855 10 : Cleanup:
856 10 : tds_free_socket(con->tds_socket);
857 10 : con->tds_socket = NULL;
858 10 : tds_free_login(login);
859 10 : tdsdump_log(TDS_DBG_FUNC, "leaving ct_connect() returning %d\n", CS_FAIL);
860 : return CS_FAIL;
861 : }
862 :
863 : CS_RETCODE
864 1380 : ct_cmd_alloc(CS_CONNECTION * con, CS_COMMAND ** pcmd)
865 : {
866 : CS_COMMAND *pcommand, *cmd;
867 :
868 1380 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_alloc(%p, %p)\n", con, pcmd);
869 :
870 1380 : if (!con)
871 : return CS_FAIL;
872 :
873 1380 : *pcmd = cmd = tds_new0(CS_COMMAND, 1);
874 1380 : if (!cmd)
875 : return CS_FAIL;
876 :
877 : /* so we know who we belong to */
878 1380 : cmd->con = con;
879 :
880 : /* initialise command state */
881 1380 : ct_set_command_state(cmd, _CS_COMMAND_IDLE);
882 :
883 1380 : if (!con->cmds) {
884 1340 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_alloc() : allocating command list to head\n");
885 1340 : con->cmds = cmd;
886 : } else {
887 10 : for (pcommand = con->cmds; pcommand->next != NULL; pcommand = pcommand->next)
888 10 : continue;
889 40 : pcommand->next = cmd;
890 : }
891 :
892 : return CS_SUCCEED;
893 : }
894 :
895 : CS_RETCODE
896 2948 : ct_command(CS_COMMAND * cmd, CS_INT type, const CS_VOID * buffer, CS_INT buflen, CS_INT option)
897 : {
898 : ptrdiff_t query_len, current_query_len;
899 :
900 2948 : tdsdump_log(TDS_DBG_FUNC, "ct_command(%p, %d, %p, %d, %d)\n", cmd, type, buffer, buflen, option);
901 :
902 2948 : if (!cmd)
903 : return CS_FAIL;
904 :
905 : /*
906 : * Unless we are in the process of building a CS_LANG_CMD command,
907 : * clear everything, ready to start anew
908 : */
909 2948 : if (cmd->command_state != _CS_COMMAND_BUILDING) {
910 2938 : _ct_initialise_cmd(cmd);
911 2938 : ct_set_command_state(cmd, _CS_COMMAND_IDLE);
912 : }
913 :
914 2948 : switch (type) {
915 2856 : case CS_LANG_CMD:
916 2856 : switch (option) {
917 2856 : case CS_MORE: /* The text in buffer is only part of the language command to be executed. */
918 : case CS_END: /* The text in buffer is the last part of the language command to be executed. */
919 : case CS_UNUSED: /* Equivalent to CS_END. */
920 2856 : query_len = _ct_get_string_length(buffer, buflen);
921 2856 : if (query_len < 0) {
922 20 : _ctclient_msg(NULL, cmd->con, "ct_command(LANG)", 1, 1, 1, 5, "%d, %s", buflen, "buflen");
923 20 : return CS_FAIL;
924 : }
925 2836 : switch (cmd->command_state) {
926 2826 : case _CS_COMMAND_IDLE:
927 2826 : cmd->query = tds_strndup(buffer, query_len);
928 2826 : if (option == CS_MORE) {
929 10 : ct_set_command_state(cmd, _CS_COMMAND_BUILDING);
930 : } else {
931 2816 : ct_set_command_state(cmd, _CS_COMMAND_READY);
932 : }
933 : break;
934 10 : case _CS_COMMAND_BUILDING:
935 10 : current_query_len = strlen(cmd->query);
936 10 : if (!tds_realloc((void **) &cmd->query, current_query_len + query_len + 1))
937 : return CS_FAIL;
938 10 : strncat(cmd->query, (const char *) buffer, query_len);
939 10 : cmd->query[current_query_len + query_len] = '\0';
940 10 : if (option == CS_MORE) {
941 0 : ct_set_command_state(cmd, _CS_COMMAND_BUILDING);
942 : } else {
943 10 : ct_set_command_state(cmd, _CS_COMMAND_READY);
944 : }
945 : break;
946 : }
947 : break;
948 : default:
949 : return CS_FAIL;
950 : }
951 : break;
952 :
953 86 : case CS_RPC_CMD:
954 : /* Code changed for RPC functionality -SUHA */
955 : /* RPC code changes starts here */
956 86 : buflen = _ct_get_string_length(buffer, buflen);
957 86 : if (buflen < 0) {
958 10 : _ctclient_msg(NULL, cmd->con, "ct_command(RPC)", 1, 1, 1, 5, "%d, %s", buflen, "buflen");
959 10 : return CS_FAIL;
960 : }
961 :
962 76 : cmd->rpc = tds_new0(CSREMOTE_PROC, 1);
963 76 : if (!cmd->rpc) {
964 0 : _ctclient_msg(NULL, cmd->con, "ct_command(RPC)", 1, 1, 1, 2, "");
965 0 : return CS_FAIL;
966 : }
967 :
968 76 : cmd->rpc->name = tds_strndup(buffer, buflen);
969 76 : if (!cmd->rpc->name) {
970 0 : TDS_ZERO_FREE(cmd->rpc);
971 0 : _ctclient_msg(NULL, cmd->con, "ct_command(RPC)", 1, 1, 1, 2, "");
972 0 : return CS_FAIL;
973 : }
974 :
975 76 : cmd->rpc->param_list = NULL;
976 :
977 76 : tdsdump_log(TDS_DBG_INFO1, "ct_command() added rpcname \"%s\"\n", cmd->rpc->name);
978 :
979 : /* FIXME: I don't know the value for RECOMPILE, NORECOMPILE options. Hence assigning zero */
980 76 : switch (option) {
981 0 : case CS_RECOMPILE: /* Recompile the stored procedure before executing it. */
982 0 : cmd->rpc->options = 0;
983 0 : break;
984 70 : case CS_NO_RECOMPILE: /* Do not recompile the stored procedure before executing it. */
985 70 : cmd->rpc->options = 0;
986 70 : break;
987 6 : case CS_UNUSED: /* Equivalent to CS_NO_RECOMPILE. */
988 6 : cmd->rpc->options = 0;
989 6 : break;
990 : default:
991 : return CS_FAIL;
992 : }
993 76 : ct_set_command_state(cmd, _CS_COMMAND_READY);
994 76 : break;
995 : /* RPC code changes ends here */
996 :
997 6 : case CS_SEND_DATA_CMD:
998 6 : switch (option) {
999 6 : case CS_COLUMN_DATA: /* The data will be used for a text or image column update. */
1000 6 : cmd->send_data_started = 0;
1001 : break;
1002 : case CS_BULK_DATA: /* For internal Sybase use only. The data will be used for a bulk copy operation. */
1003 : default:
1004 : return CS_FAIL;
1005 : }
1006 6 : ct_set_command_state(cmd, _CS_COMMAND_READY);
1007 6 : break;
1008 :
1009 : case CS_SEND_BULK_CMD:
1010 : switch (option) {
1011 : case CS_BULK_INIT: /* For internal Sybase use only. Initialize a bulk copy operation. */
1012 : case CS_BULK_CONT: /* For internal Sybase use only. Continue a bulk copy operation. */
1013 : default:
1014 : return CS_FAIL;
1015 : }
1016 : ct_set_command_state(cmd, _CS_COMMAND_READY);
1017 : break;
1018 :
1019 : default:
1020 : return CS_FAIL;
1021 : }
1022 :
1023 2918 : cmd->command_type = type;
1024 :
1025 :
1026 2918 : return CS_SUCCEED;
1027 : }
1028 :
1029 : static void
1030 4368 : _ct_initialise_cmd(CS_COMMAND *cmd)
1031 : {
1032 4368 : free(cmd->query);
1033 4368 : cmd->query = NULL;
1034 :
1035 4368 : tdsdump_log(TDS_DBG_FUNC, "_ct_initialise_cmd(%p)\n", cmd);
1036 :
1037 4368 : if (cmd->input_params) {
1038 30 : param_clear(cmd->input_params);
1039 30 : cmd->input_params = NULL;
1040 : }
1041 4368 : ct_set_command_state(cmd, _CS_COMMAND_IDLE);
1042 :
1043 4368 : rpc_clear(cmd->rpc);
1044 4368 : cmd->rpc = NULL;
1045 4368 : }
1046 :
1047 : CS_RETCODE
1048 3148 : ct_send(CS_COMMAND * cmd)
1049 : {
1050 : TDSSOCKET *tds;
1051 : TDSPARAMINFO *pparam_info;
1052 :
1053 3148 : tdsdump_log(TDS_DBG_FUNC, "ct_send(%p)\n", cmd);
1054 :
1055 3148 : if (!cmd || !cmd->con || !cmd->con->tds_socket)
1056 : return CS_FAIL;
1057 :
1058 3148 : tdsdump_log(TDS_DBG_FUNC, "ct_send() command_type = %d\n", cmd->command_type);
1059 :
1060 3148 : tds = cmd->con->tds_socket;
1061 :
1062 3148 : if (cmd->cancel_state == _CS_CANCEL_PENDING) {
1063 0 : _ct_cancel_cleanup(cmd);
1064 0 : return CS_CANCELED;
1065 : }
1066 :
1067 3148 : if (cmd->command_state == _CS_COMMAND_IDLE) {
1068 10 : tdsdump_log(TDS_DBG_FUNC, "ct_send() command_state = IDLE\n");
1069 10 : _ctclient_msg(NULL, cmd->con, "ct_send", 1, 1, 1, 155, "");
1070 10 : return CS_FAIL;
1071 : }
1072 :
1073 3138 : cmd->results_state = _CS_RES_NONE;
1074 :
1075 3138 : if (cmd->command_type == CS_DYNAMIC_CMD) {
1076 90 : CS_DYNAMIC *dyn = cmd->dyn;
1077 : TDSDYNAMIC *tdsdyn;
1078 :
1079 90 : if (!dyn)
1080 : return CS_FAIL;
1081 :
1082 80 : switch (cmd->dynamic_cmd) {
1083 20 : case CS_PREPARE:
1084 20 : if (TDS_FAILED(tds_submit_prepare(tds, dyn->stmt, dyn->id, &dyn->tdsdyn, NULL)))
1085 : return CS_FAIL;
1086 20 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1087 20 : return CS_SUCCEED;
1088 : break;
1089 30 : case CS_EXECUTE:
1090 30 : tdsdyn = dyn->tdsdyn;
1091 30 : if (!tdsdyn) {
1092 0 : tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_EXECUTE) no tdsdyn!\n");
1093 : return CS_FAIL;
1094 : }
1095 30 : pparam_info = paraminfoalloc(tds, dyn->param_list);
1096 30 : if (!pparam_info && dyn->param_list)
1097 : return CS_FAIL;
1098 30 : tds_free_input_params(tdsdyn);
1099 30 : tdsdyn->params = pparam_info;
1100 30 : if (TDS_FAILED(tds_submit_execute(tds, tdsdyn)))
1101 : return CS_FAIL;
1102 30 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1103 30 : return CS_SUCCEED;
1104 : break;
1105 10 : case CS_DESCRIBE_INPUT:
1106 10 : tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_DESCRIBE_INPUT)\n");
1107 10 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1108 10 : cmd->results_state = _CS_RES_DESCRIBE_RESULT;
1109 10 : if (tds->cur_dyn)
1110 10 : tds_set_current_results(tds, tds->cur_dyn->res_info);
1111 : else
1112 0 : tds_set_current_results(tds, tds->param_info);
1113 : break;
1114 :
1115 10 : case CS_DESCRIBE_OUTPUT:
1116 10 : tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_DESCRIBE_OUTPUT)\n");
1117 10 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1118 10 : cmd->results_state = _CS_RES_DESCRIBE_RESULT;
1119 10 : tds_set_current_results(tds, tds->res_info);
1120 10 : break;
1121 :
1122 10 : case CS_DEALLOC:
1123 10 : tdsdyn = dyn->tdsdyn;
1124 10 : if (!tdsdyn) {
1125 0 : tdsdump_log(TDS_DBG_INFO1, "ct_send(CS_DEALLOC) no tdsdyn!\n");
1126 : return CS_FAIL;
1127 : }
1128 10 : if (TDS_FAILED(tds_submit_unprepare(tds, tdsdyn)))
1129 : return CS_FAIL;
1130 :
1131 10 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1132 10 : return CS_SUCCEED;
1133 : break;
1134 :
1135 : default:
1136 : return CS_FAIL;
1137 : }
1138 3048 : }
1139 :
1140 3068 : if (cmd->command_type == CS_RPC_CMD) {
1141 86 : CSREMOTE_PROC *rpc = cmd->rpc;
1142 : TDSRET ret;
1143 :
1144 : /* sanity */
1145 86 : if (!cmd->rpc /* ct_command should allocate pointer */
1146 86 : || !rpc->name) { /* can't be ready without a name */
1147 : return CS_FAIL;
1148 : }
1149 :
1150 86 : pparam_info = paraminfoalloc(tds, rpc->param_list);
1151 86 : ret = tds_submit_rpc(tds, rpc->name, pparam_info, NULL);
1152 :
1153 86 : tds_free_param_results(pparam_info);
1154 :
1155 86 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1156 :
1157 86 : if (TDS_FAILED(ret))
1158 : return CS_FAIL;
1159 :
1160 86 : return CS_SUCCEED;
1161 : }
1162 :
1163 : /* RPC Code changes ends here */
1164 :
1165 2982 : if (cmd->command_type == CS_LANG_CMD) {
1166 : TDSRET ret;
1167 :
1168 2826 : if (cmd->input_params) {
1169 30 : pparam_info = paraminfoalloc(tds, cmd->input_params);
1170 30 : ret = tds_submit_query_params(tds, cmd->query, pparam_info, NULL);
1171 30 : tds_free_param_results(pparam_info);
1172 : } else {
1173 2796 : ret = tds_submit_query(tds, cmd->query);
1174 : }
1175 :
1176 2826 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1177 :
1178 2826 : if (TDS_FAILED(ret)) {
1179 2 : tdsdump_log(TDS_DBG_WARN, "ct_send() failed\n");
1180 : return CS_FAIL;
1181 : }
1182 2824 : tdsdump_log(TDS_DBG_INFO2, "ct_send() succeeded\n");
1183 : return CS_SUCCEED;
1184 : }
1185 :
1186 : /* Code added for CURSOR support */
1187 :
1188 156 : if (cmd->command_type == CS_CUR_CMD) {
1189 : TDSCURSOR *cursor;
1190 130 : TDSRET ret = TDS_SUCCESS;
1191 :
1192 : /* sanity */
1193 : /*
1194 : * ct_cursor declare should allocate cursor pointer
1195 : * cursor stmt cannot be NULL
1196 : * cursor name cannot be NULL
1197 : */
1198 :
1199 130 : bool something_to_send = false;
1200 :
1201 130 : tdsdump_log(TDS_DBG_FUNC, "ct_send() : CS_CUR_CMD\n");
1202 :
1203 130 : cursor = cmd->cursor;
1204 130 : if (!cursor) {
1205 0 : tdsdump_log(TDS_DBG_FUNC, "ct_send() : cursor not present\n");
1206 : return CS_FAIL;
1207 : }
1208 :
1209 130 : if (!cursor->query) {
1210 0 : tdsdump_log(TDS_DBG_FUNC, "ct_send() : cursor->query is null\n");
1211 : return CS_FAIL;
1212 : }
1213 130 : if (!cursor->cursor_name) {
1214 0 : tdsdump_log(TDS_DBG_FUNC, "ct_send() : cursor->name is null\n");
1215 : return CS_FAIL;
1216 : }
1217 :
1218 130 : if (cursor->status.declare == _CS_CURS_TYPE_REQUESTED) {
1219 40 : TDSRET ret = tds_cursor_declare(tds, cursor, &something_to_send);
1220 40 : if (TDS_FAILED(ret)){
1221 0 : tdsdump_log(TDS_DBG_WARN, "ct_send(): cursor declare failed \n");
1222 : return CS_FAIL;
1223 : }
1224 40 : cursor->status.declare = TDS_CURSOR_STATE_SENT; /* Cursor is declared */
1225 40 : if (!something_to_send) {
1226 32 : cmd->results_state = _CS_RES_END_RESULTS;
1227 : }
1228 : }
1229 :
1230 170 : if (cursor->status.cursor_row == _CS_CURS_TYPE_REQUESTED &&
1231 40 : cursor->status.declare == _CS_CURS_TYPE_SENT) {
1232 :
1233 40 : TDSRET ret = tds_cursor_setrows(tds, cursor, &something_to_send);
1234 40 : if (TDS_FAILED(ret)){
1235 0 : tdsdump_log(TDS_DBG_WARN, "ct_send(): cursor set rows failed\n");
1236 : return CS_FAIL;
1237 : }
1238 40 : cursor->status.cursor_row = TDS_CURSOR_STATE_SENT; /* Cursor rows set */
1239 40 : if (!something_to_send) {
1240 32 : cmd->results_state = _CS_RES_END_RESULTS;
1241 : }
1242 : }
1243 :
1244 170 : if (cursor->status.open == _CS_CURS_TYPE_REQUESTED &&
1245 40 : cursor->status.declare == _CS_CURS_TYPE_SENT) {
1246 :
1247 40 : TDSRET ret = tds_cursor_open(tds, cursor, NULL, &something_to_send);
1248 40 : if (TDS_FAILED(ret)){
1249 0 : tdsdump_log(TDS_DBG_WARN, "ct_send(): cursor open failed\n");
1250 : return CS_FAIL;
1251 : }
1252 40 : cursor->status.open = TDS_CURSOR_STATE_SENT;
1253 40 : cmd->results_state = _CS_RES_INIT;
1254 : }
1255 :
1256 130 : if (something_to_send) {
1257 44 : tdsdump_log(TDS_DBG_WARN, "ct_send(): sending cursor commands\n");
1258 44 : tds_flush_packet(tds);
1259 44 : tds_set_state(tds, TDS_PENDING);
1260 44 : something_to_send = false;
1261 :
1262 44 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1263 :
1264 44 : return CS_SUCCEED;
1265 : }
1266 :
1267 86 : if (cursor->status.close == _CS_CURS_TYPE_REQUESTED){
1268 40 : if (cursor->status.dealloc == TDS_CURSOR_STATE_REQUESTED) {
1269 : /* FIXME what happen if tds_cursor_dealloc return TDS_FAIL ?? */
1270 10 : ret = tds_cursor_close(tds, cursor);
1271 10 : tds_release_cursor(&cmd->cursor);
1272 10 : cursor = NULL;
1273 : } else {
1274 30 : ret = tds_cursor_close(tds, cursor);
1275 30 : cursor->status.close = TDS_CURSOR_STATE_SENT;
1276 : }
1277 : }
1278 :
1279 76 : if (cursor && cursor->status.dealloc == _CS_CURS_TYPE_REQUESTED) {
1280 : /* FIXME what happen if tds_cursor_dealloc return TDS_FAIL ?? */
1281 30 : ret = tds_cursor_dealloc(tds, cursor);
1282 30 : tds_release_cursor(&cmd->cursor);
1283 30 : tds_free_all_results(tds);
1284 : }
1285 :
1286 86 : if (TDS_SUCCEED(ret))
1287 86 : cmd->results_state = _CS_RES_INIT;
1288 :
1289 86 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1290 86 : return CS_SUCCEED;
1291 : }
1292 :
1293 26 : if (cmd->command_type == CS_SEND_DATA_CMD) {
1294 6 : tds_writetext_end(tds);
1295 6 : ct_set_command_state(cmd, _CS_COMMAND_SENT);
1296 : }
1297 :
1298 : return CS_SUCCEED;
1299 : }
1300 :
1301 :
1302 : CS_RETCODE
1303 9682 : ct_results(CS_COMMAND * cmd, CS_INT * result_type)
1304 : {
1305 : TDSSOCKET *tds;
1306 : CS_CONTEXT *context;
1307 : TDSRET tdsret;
1308 : CS_INT res_type;
1309 : CS_INT done_flags;
1310 : TDS_INT8 rows_affected;
1311 : unsigned process_flags;
1312 :
1313 9682 : tdsdump_log(TDS_DBG_FUNC, "ct_results(%p, %p)\n", cmd, result_type);
1314 :
1315 9682 : if (cmd->cancel_state == _CS_CANCEL_PENDING) {
1316 0 : _ct_cancel_cleanup(cmd);
1317 0 : return CS_CANCELED;
1318 : }
1319 :
1320 9682 : if (!cmd->con || !cmd->con->tds_socket)
1321 : return CS_FAIL;
1322 :
1323 9682 : cmd->bind_count = CS_UNUSED;
1324 :
1325 9682 : context = cmd->con->ctx;
1326 :
1327 9682 : tds = cmd->con->tds_socket;
1328 9682 : cmd->row_prefetched = 0;
1329 :
1330 : /*
1331 : * depending on the current results state, we may
1332 : * not need to call tds_process_tokens...
1333 : */
1334 :
1335 9682 : switch (cmd->results_state) {
1336 20 : case _CS_RES_CMD_SUCCEED:
1337 20 : *result_type = CS_CMD_SUCCEED;
1338 20 : cmd->results_state = _CS_RES_CMD_DONE;
1339 20 : return CS_SUCCEED;
1340 2914 : case _CS_RES_CMD_DONE:
1341 2914 : *result_type = CS_CMD_DONE;
1342 2914 : cmd->results_state = _CS_RES_INIT;
1343 2914 : return CS_SUCCEED;
1344 0 : case _CS_RES_END_RESULTS:
1345 0 : *result_type = CS_CMD_DONE;
1346 0 : cmd->results_state = _CS_RES_INIT;
1347 0 : return CS_END_RESULTS;
1348 20 : case _CS_RES_DESCRIBE_RESULT:
1349 20 : *result_type = CS_DESCRIBE_RESULT;
1350 20 : cmd->results_state = _CS_RES_CMD_DONE;
1351 20 : return CS_SUCCEED;
1352 2980 : case _CS_RES_NONE: /* first time in after ct_send */
1353 2980 : cmd->results_state = _CS_RES_INIT;
1354 2980 : tds->rows_affected = TDS_NO_COUNT;
1355 2980 : break;
1356 3322 : case _CS_RES_INIT:
1357 3322 : tds->rows_affected = TDS_NO_COUNT;
1358 3322 : break;
1359 : default:
1360 : break;
1361 : }
1362 :
1363 6728 : rows_affected = tds->rows_affected;
1364 :
1365 : /*
1366 : * see what "result" tokens we have. a "result" in ct-lib terms also
1367 : * includes row data. Some result types always get reported back to
1368 : * the calling program, others are only reported back if the relevant
1369 : * config flag is set.
1370 : */
1371 :
1372 6728 : process_flags = TDS_TOKEN_RESULTS;
1373 : for (;;) {
1374 :
1375 8178 : tdsret = tds_process_tokens(tds, &res_type, &done_flags, process_flags);
1376 :
1377 8178 : tdsdump_log(TDS_DBG_FUNC, "ct_results() process_result_tokens returned %d (type %d) \n",
1378 : tdsret, res_type);
1379 :
1380 8178 : switch (tdsret) {
1381 :
1382 5066 : case TDS_SUCCESS:
1383 :
1384 5066 : cmd->curr_result_type = res_type;
1385 :
1386 5066 : switch (res_type) {
1387 :
1388 16 : case CS_COMPUTEFMT_RESULT:
1389 :
1390 : /*
1391 : * set results state to indicate that we
1392 : * have a result set (empty for the moment)
1393 : * If the CS_EXPOSE_FMTS property has been
1394 : * set in ct_config(), we need to return an
1395 : * appropraite format result, otherwise just
1396 : * carry on and get the next token.....
1397 : */
1398 :
1399 16 : cmd->results_state = _CS_RES_RESULTSET_EMPTY;
1400 :
1401 16 : if (context->config.cs_expose_formats) {
1402 0 : *result_type = res_type;
1403 0 : return CS_SUCCEED;
1404 : }
1405 : break;
1406 :
1407 348 : case CS_ROWFMT_RESULT:
1408 348 : cmd->curr_result_type = CS_ROW_RESULT;
1409 348 : cmd->results_state = _CS_RES_RESULTSET_EMPTY;
1410 348 : rows_affected = tds->rows_affected = TDS_NO_COUNT;
1411 :
1412 348 : if (cmd->command_type == CS_CUR_CMD ||
1413 : cmd->command_type == CS_DYNAMIC_CMD)
1414 : break;
1415 :
1416 : /* don't process DONE tokens */
1417 268 : process_flags = TDS_RETURN_ROWFMT|TDS_RETURN_COMPUTEFMT|TDS_STOPAT_DONE|TDS_STOPAT_ROW|
1418 : TDS_STOPAT_COMPUTE|TDS_RETURN_PROC;
1419 268 : break;
1420 :
1421 274 : case CS_ROW_RESULT:
1422 :
1423 : /*
1424 : * we've hit a data row. pass back that fact
1425 : * to the calling program. set results state
1426 : * to show that the result set has rows...
1427 : */
1428 :
1429 274 : cmd->results_state = _CS_RES_RESULTSET_ROWS;
1430 274 : if (cmd->command_type == CS_CUR_CMD) {
1431 0 : *result_type = CS_CURSOR_RESULT;
1432 : } else {
1433 274 : *result_type = CS_ROW_RESULT;
1434 : }
1435 : return CS_SUCCEED;
1436 : break;
1437 :
1438 24 : case CS_COMPUTE_RESULT:
1439 :
1440 : /*
1441 : * we've hit a compute data row. We have to get hold of this
1442 : * data now, as it's necessary to tie this data back to its
1443 : * result format...the user may call ct_res_info() & friends
1444 : * after getting back a compute "result".
1445 : *
1446 : * but first, if we've hit this compute row without having
1447 : * hit a data row first, we need to return a CS_ROW_RESULT
1448 : * before letting them have the compute row...
1449 : */
1450 :
1451 24 : if (cmd->results_state == _CS_RES_RESULTSET_EMPTY) {
1452 0 : *result_type = CS_ROW_RESULT;
1453 0 : tds_set_current_results(tds, tds->res_info);
1454 0 : cmd->results_state = _CS_RES_RESULTSET_ROWS;
1455 0 : return CS_SUCCEED;
1456 : }
1457 :
1458 24 : tdsret = tds_process_tokens(tds, &res_type, NULL,
1459 : TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);
1460 :
1461 : /* set results state to show that the result set has rows... */
1462 :
1463 24 : cmd->results_state = _CS_RES_RESULTSET_ROWS;
1464 :
1465 24 : *result_type = res_type;
1466 24 : if (tdsret == TDS_SUCCESS && (res_type == TDS_ROW_RESULT || res_type == TDS_COMPUTE_RESULT)) {
1467 24 : if (res_type == TDS_COMPUTE_RESULT) {
1468 24 : cmd->row_prefetched = 1;
1469 24 : return CS_SUCCEED;
1470 : } else {
1471 : /* this couldn't really happen, but... */
1472 : return CS_FAIL;
1473 : }
1474 : } else
1475 : return CS_FAIL;
1476 : break;
1477 :
1478 2990 : case TDS_DONE_RESULT:
1479 :
1480 : /*
1481 : * A done token signifies the end of a logical
1482 : * command. There are three possibilities...
1483 : * 1. Simple command with no result set, i.e.
1484 : * update, delete, insert
1485 : * 2. Command with result set but no rows
1486 : * 3. Command with result set and rows
1487 : * in these cases we need to:
1488 : * 1. return CS_CMD_FAIL/SUCCED depending on
1489 : * the status returned in done_flags
1490 : * 2. "manufacture" a CS_ROW_RESULT return,
1491 : * and set the results state to DONE
1492 : * 3. return with CS_CMD_DONE and reset the
1493 : * results_state
1494 : */
1495 :
1496 2990 : tdsdump_log(TDS_DBG_FUNC, "ct_results() results state = %d\n",cmd->results_state);
1497 2990 : tdsdump_log(TDS_DBG_FUNC, "ct_results() command type = %d\n",cmd->command_type);
1498 2990 : tdsdump_log(TDS_DBG_FUNC, "ct_results() dynamic cmd = %d\n",cmd->dynamic_cmd);
1499 :
1500 2996 : if ((cmd->command_type == CS_DYNAMIC_CMD) &&
1501 6 : (cmd->dynamic_cmd == CS_PREPARE || cmd->dynamic_cmd == CS_DEALLOC)) {
1502 6 : *result_type = CS_CMD_SUCCEED;
1503 6 : cmd->results_state = _CS_RES_CMD_DONE;
1504 6 : return CS_SUCCEED;
1505 : }
1506 :
1507 2984 : if (tds->rows_affected != TDS_NO_COUNT)
1508 852 : rows_affected = tds->rows_affected;
1509 2984 : tds->rows_affected = rows_affected;
1510 :
1511 2984 : switch (cmd->results_state) {
1512 :
1513 2754 : case _CS_RES_INIT:
1514 : case _CS_RES_STATUS:
1515 2754 : if (done_flags & TDS_DONE_ERROR)
1516 94 : *result_type = CS_CMD_FAIL;
1517 : else
1518 2660 : *result_type = CS_CMD_SUCCEED;
1519 2754 : cmd->results_state = _CS_RES_CMD_DONE;
1520 2754 : break;
1521 :
1522 42 : case _CS_RES_RESULTSET_EMPTY:
1523 42 : if (cmd->command_type == CS_CUR_CMD) {
1524 40 : *result_type = CS_CURSOR_RESULT;
1525 : } else {
1526 2 : *result_type = CS_ROW_RESULT;
1527 : }
1528 42 : cmd->results_state = _CS_RES_RESULTSET_ROWS;
1529 42 : break;
1530 :
1531 188 : case _CS_RES_RESULTSET_ROWS:
1532 188 : *result_type = CS_CMD_DONE;
1533 188 : cmd->results_state = _CS_RES_INIT;
1534 188 : break;
1535 :
1536 : }
1537 : return CS_SUCCEED;
1538 : break;
1539 :
1540 1196 : case TDS_DONEINPROC_RESULT:
1541 :
1542 : /*
1543 : * A doneinproc token may signify the end of a
1544 : * logical command if the command had a result
1545 : * set. Otherwise it is ignored....
1546 : */
1547 :
1548 1196 : if (tds->rows_affected != TDS_NO_COUNT)
1549 786 : rows_affected = tds->rows_affected;
1550 1196 : tds->rows_affected = rows_affected;
1551 :
1552 1196 : switch (cmd->results_state) {
1553 : case _CS_RES_INIT: /* command had no result set */
1554 : break;
1555 20 : case _CS_RES_RESULTSET_EMPTY:
1556 20 : if (cmd->command_type == CS_CUR_CMD) {
1557 0 : *result_type = CS_CURSOR_RESULT;
1558 0 : cmd->results_state = _CS_RES_CMD_DONE;
1559 : } else {
1560 20 : *result_type = CS_ROW_RESULT;
1561 20 : cmd->results_state = _CS_RES_RESULTSET_ROWS;
1562 : }
1563 : return CS_SUCCEED;
1564 : break;
1565 90 : case _CS_RES_RESULTSET_ROWS:
1566 90 : *result_type = CS_CMD_DONE;
1567 90 : cmd->results_state = _CS_RES_INIT;
1568 90 : return CS_SUCCEED;
1569 : break;
1570 : }
1571 : break;
1572 :
1573 128 : case TDS_DONEPROC_RESULT:
1574 :
1575 : /*
1576 : * A DONEPROC result means the end of a logical
1577 : * command only if it was one of the commands
1578 : * directly sent from ct_send, not as a result
1579 : * of a nested stored procedure call. We know
1580 : * if this is the case if a STATUS_RESULT was
1581 : * received immediately prior to the DONE_PROC
1582 : */
1583 :
1584 128 : if (tds->rows_affected != TDS_NO_COUNT)
1585 74 : rows_affected = tds->rows_affected;
1586 128 : tds->rows_affected = rows_affected;
1587 :
1588 128 : if (done_flags & TDS_DONE_ERROR)
1589 8 : *result_type = CS_CMD_FAIL;
1590 : else
1591 120 : *result_type = CS_CMD_SUCCEED;
1592 128 : cmd->results_state = _CS_RES_CMD_DONE;
1593 128 : return CS_SUCCEED;
1594 : break;
1595 :
1596 18 : case TDS_PARAM_RESULT:
1597 18 : cmd->row_prefetched = 1;
1598 18 : *result_type = res_type;
1599 18 : return CS_SUCCEED;
1600 : break;
1601 :
1602 72 : case TDS_STATUS_RESULT:
1603 72 : _ct_process_return_status(tds);
1604 72 : cmd->row_prefetched = 1;
1605 72 : *result_type = res_type;
1606 72 : cmd->results_state = _CS_RES_STATUS;
1607 72 : return CS_SUCCEED;
1608 : break;
1609 :
1610 0 : case TDS_DESCRIBE_RESULT:
1611 0 : if (cmd->dynamic_cmd == CS_DESCRIBE_INPUT ||
1612 : cmd->dynamic_cmd == CS_DESCRIBE_OUTPUT) {
1613 0 : *result_type = res_type;
1614 0 : return CS_SUCCEED;
1615 : }
1616 : break;
1617 0 : default:
1618 0 : *result_type = res_type;
1619 0 : return CS_SUCCEED;
1620 : break;
1621 : }
1622 :
1623 80 : break;
1624 :
1625 3100 : case TDS_NO_MORE_RESULTS:
1626 :
1627 : /* some commands can be re-sent once completed */
1628 : /* so mark the command state as 'ready'... */
1629 :
1630 6200 : if (cmd->command_type == CS_LANG_CMD ||
1631 3100 : cmd->command_type == CS_RPC_CMD ||
1632 86 : cmd->command_type == CS_CUR_CMD ||
1633 : cmd->command_type == CS_DYNAMIC_CMD) {
1634 3094 : ct_set_command_state(cmd, _CS_COMMAND_READY);
1635 : }
1636 : /* if we have just completed processing a dynamic deallocate */
1637 : /* get rid of our dynamic statement structure... */
1638 :
1639 3180 : if (cmd->command_type == CS_DYNAMIC_CMD &&
1640 80 : cmd->dynamic_cmd == CS_DEALLOC) {
1641 10 : _ct_deallocate_dynamic(cmd->con, cmd->dyn);
1642 10 : cmd->dyn = NULL;
1643 : }
1644 : return CS_END_RESULTS;
1645 : break;
1646 :
1647 0 : case TDS_CANCELLED:
1648 0 : cmd->cancel_state = _CS_CANCEL_NOCANCEL;
1649 0 : return CS_CANCELED;
1650 : break;
1651 :
1652 : default:
1653 : return CS_FAIL;
1654 : break;
1655 :
1656 : } /* switch (tdsret) */
1657 : } /* for (;;) */
1658 : }
1659 :
1660 : CS_RETCODE
1661 996 : ct_bind(CS_COMMAND * cmd, CS_INT item, CS_DATAFMT * datafmt_arg, CS_VOID * buffer, CS_INT * copied, CS_SMALLINT * indicator)
1662 : {
1663 : TDSCOLUMN *colinfo;
1664 : TDSRESULTINFO *resinfo;
1665 : TDSSOCKET *tds;
1666 996 : CS_CONNECTION *con = cmd->con;
1667 : const CS_DATAFMT_COMMON * datafmt;
1668 : CS_INT bind_count;
1669 :
1670 996 : tdsdump_log(TDS_DBG_FUNC, "ct_bind(%p, %d, %p, %p, %p, %p)\n", cmd, item, datafmt_arg, buffer, copied, indicator);
1671 :
1672 996 : if (!con || !con->tds_socket)
1673 : return CS_FAIL;
1674 :
1675 996 : datafmt = _ct_datafmt_common(con->ctx, datafmt_arg);
1676 :
1677 996 : bind_count = datafmt->count;
1678 :
1679 996 : tdsdump_log(TDS_DBG_FUNC, "ct_bind() datafmt count = %d column_number = %d\n", bind_count, item);
1680 :
1681 996 : tds = con->tds_socket;
1682 996 : resinfo = tds->current_results;
1683 :
1684 : /* check item value */
1685 996 : if (!resinfo || item <= 0 || item > resinfo->num_cols)
1686 : return CS_FAIL;
1687 :
1688 : /*
1689 : * Check whether the request is for array binding, and ensure that the user
1690 : * supplies the same datafmt->count to the subsequent ct_bind calls
1691 : */
1692 :
1693 996 : bind_count = (datafmt->count == 0) ? 1 : datafmt->count;
1694 :
1695 : /* first bind for this result set */
1696 :
1697 996 : if (cmd->bind_count == CS_UNUSED) {
1698 318 : cmd->bind_count = bind_count;
1699 : } else {
1700 : /* all subsequent binds for this result set - the bind counts must be the same */
1701 678 : if (cmd->bind_count != bind_count) {
1702 20 : _ctclient_msg(NULL, con, "ct_bind", 1, 1, 1, 137, "%d, %d", bind_count, cmd->bind_count);
1703 20 : return CS_FAIL;
1704 : }
1705 : }
1706 :
1707 : /* bind the column_varaddr to the address of the buffer */
1708 :
1709 976 : colinfo = resinfo->columns[item - 1];
1710 976 : colinfo->column_varaddr = (char *) buffer;
1711 976 : colinfo->column_bindtype = datafmt->datatype;
1712 976 : colinfo->column_bindfmt = datafmt->format;
1713 976 : colinfo->column_bindlen = datafmt->maxlength;
1714 976 : if (indicator) {
1715 976 : colinfo->column_nullbind = indicator;
1716 : }
1717 976 : if (copied) {
1718 976 : colinfo->column_lenbind = copied;
1719 : }
1720 : return CS_SUCCEED;
1721 : }
1722 :
1723 : CS_RETCODE
1724 17656 : ct_fetch(CS_COMMAND * cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT * prows_read)
1725 : {
1726 : TDS_INT ret_type;
1727 : TDSRET ret;
1728 : TDS_INT marker;
1729 : TDS_INT temp_count;
1730 : TDSSOCKET *tds;
1731 : CS_INT rows_read_dummy;
1732 :
1733 17656 : tdsdump_log(TDS_DBG_FUNC, "ct_fetch(%p, %d, %d, %d, %p)\n", cmd, type, offset, option, prows_read);
1734 :
1735 17656 : if (!cmd->con || !cmd->con->tds_socket)
1736 : return CS_FAIL;
1737 :
1738 17656 : if (cmd->command_state == _CS_COMMAND_IDLE) {
1739 0 : _ctclient_msg(NULL, cmd->con, "ct_fetch", 1, 1, 1, 155, "");
1740 0 : return CS_FAIL;
1741 : }
1742 :
1743 17656 : if (cmd->cancel_state == _CS_CANCEL_PENDING) {
1744 0 : _ct_cancel_cleanup(cmd);
1745 0 : return CS_CANCELED;
1746 : }
1747 :
1748 17656 : if (!prows_read)
1749 0 : prows_read = &rows_read_dummy;
1750 :
1751 17656 : tds = cmd->con->tds_socket;
1752 :
1753 : /*
1754 : * Call a special function for fetches from a cursor because
1755 : * the processing is too incompatible to patch into a single function
1756 : */
1757 17656 : if (cmd->command_type == CS_CUR_CMD) {
1758 150 : return _ct_fetch_cursor(cmd, type, offset, option, prows_read);
1759 : }
1760 :
1761 17506 : *prows_read = 0;
1762 :
1763 17506 : if ( cmd->bind_count == CS_UNUSED )
1764 122 : cmd->bind_count = 1;
1765 :
1766 : /* compute rows and parameter results have been pre-fetched by ct_results() */
1767 :
1768 17506 : if (cmd->row_prefetched) {
1769 104 : cmd->row_prefetched = 0;
1770 104 : cmd->get_data_item = 0;
1771 104 : cmd->get_data_bytes_returned = 0;
1772 104 : if (_ct_bind_data(cmd->con->ctx, tds->current_results, tds->current_results, 0))
1773 : return CS_ROW_FAIL;
1774 104 : *prows_read = 1;
1775 104 : return CS_SUCCEED;
1776 : }
1777 :
1778 17402 : if (cmd->results_state == _CS_RES_CMD_DONE)
1779 : return CS_END_DATA;
1780 17402 : if (cmd->curr_result_type == CS_COMPUTE_RESULT)
1781 : return CS_END_DATA;
1782 17378 : if (cmd->curr_result_type == CS_CMD_FAIL)
1783 : return CS_CMD_FAIL;
1784 :
1785 :
1786 17378 : marker = tds_peek(tds);
1787 17378 : if ((cmd->curr_result_type == CS_ROW_RESULT && marker != TDS_ROW_TOKEN && marker != TDS_NBC_ROW_TOKEN)
1788 17120 : || (cmd->curr_result_type == CS_STATUS_RESULT && marker != TDS_RETURNSTATUS_TOKEN) )
1789 : return CS_END_DATA;
1790 :
1791 : /* Array Binding Code changes start here */
1792 :
1793 16784 : for (temp_count = 0; temp_count < cmd->bind_count; temp_count++) {
1794 :
1795 17094 : ret = tds_process_tokens(tds, &ret_type, NULL,
1796 : TDS_STOPAT_ROWFMT|TDS_STOPAT_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);
1797 :
1798 17094 : tdsdump_log(TDS_DBG_FUNC, "inside ct_fetch() process_row_tokens returned %d\n", ret);
1799 :
1800 17094 : switch (ret) {
1801 17084 : case TDS_SUCCESS:
1802 17084 : if (ret_type == TDS_ROW_RESULT || ret_type == TDS_COMPUTE_RESULT) {
1803 17048 : cmd->get_data_item = 0;
1804 17048 : cmd->get_data_bytes_returned = 0;
1805 17048 : if (_ct_bind_data(cmd->con->ctx, tds->current_results, tds->current_results, temp_count))
1806 : return CS_ROW_FAIL;
1807 17048 : (*prows_read)++;
1808 : break;
1809 : }
1810 : case TDS_NO_MORE_RESULTS:
1811 : return CS_END_DATA;
1812 : break;
1813 :
1814 10 : case TDS_CANCELLED:
1815 10 : cmd->cancel_state = _CS_CANCEL_NOCANCEL;
1816 10 : return CS_CANCELED;
1817 : break;
1818 :
1819 0 : default:
1820 0 : return CS_FAIL;
1821 : break;
1822 : }
1823 :
1824 : /* have we reached the end of the rows ? */
1825 :
1826 17048 : marker = tds_peek(tds);
1827 :
1828 34096 : if (cmd->curr_result_type == CS_ROW_RESULT && marker != TDS_ROW_TOKEN && marker != TDS_NBC_ROW_TOKEN)
1829 : break;
1830 :
1831 : }
1832 :
1833 : /* Array Binding Code changes end here */
1834 :
1835 : return CS_SUCCEED;
1836 : }
1837 :
1838 : static CS_RETCODE
1839 150 : _ct_fetch_cursor(CS_COMMAND * cmd, CS_INT type, CS_INT offset, CS_INT option, CS_INT * rows_read)
1840 : {
1841 : TDSSOCKET * tds;
1842 : TDSCURSOR *cursor;
1843 : TDS_INT restype;
1844 : TDSRET ret;
1845 : TDS_INT temp_count;
1846 : TDS_INT done_flags;
1847 150 : TDS_INT rows_this_fetch = 0;
1848 :
1849 150 : tdsdump_log(TDS_DBG_FUNC, "_ct_fetch_cursor(%p, %d, %d, %d, %p)\n", cmd, type, offset, option, rows_read);
1850 :
1851 150 : if (!cmd->con || !cmd->con->tds_socket)
1852 : return CS_FAIL;
1853 :
1854 150 : tds = cmd->con->tds_socket;
1855 :
1856 150 : if (rows_read)
1857 150 : *rows_read = 0;
1858 :
1859 : /* taking a copy of the cmd->bind_count value. */
1860 150 : temp_count = cmd->bind_count;
1861 :
1862 150 : if ( cmd->bind_count == CS_UNUSED )
1863 20 : cmd->bind_count = 1;
1864 :
1865 150 : cursor = cmd->cursor;
1866 150 : if (!cursor) {
1867 0 : tdsdump_log(TDS_DBG_FUNC, "ct_fetch_cursor() : cursor not present\n");
1868 : return CS_FAIL;
1869 : }
1870 :
1871 : /* currently we are placing this restriction on cursor fetches. */
1872 : /* the alternatives are too awful to contemplate at the moment */
1873 : /* i.e. buffering all the rows from the fetch internally... */
1874 :
1875 150 : if (cmd->bind_count < cursor->cursor_rows) {
1876 0 : tdsdump_log(TDS_DBG_WARN, "_ct_fetch_cursor(): bind count must equal cursor rows \n");
1877 : return CS_FAIL;
1878 : }
1879 :
1880 150 : if (TDS_FAILED(tds_cursor_fetch(tds, cursor, TDS_CURSOR_FETCH_NEXT, 0))) {
1881 0 : tdsdump_log(TDS_DBG_WARN, "ct_fetch(): cursor fetch failed\n");
1882 : return CS_FAIL;
1883 : }
1884 150 : cursor->status.fetch = TDS_CURSOR_STATE_SENT;
1885 :
1886 450 : while ((tds_process_tokens(tds, &restype, &done_flags, TDS_TOKEN_RESULTS)) == TDS_SUCCESS) {
1887 150 : switch (restype) {
1888 : case CS_ROWFMT_RESULT:
1889 : break;
1890 : case CS_ROW_RESULT:
1891 120 : for (temp_count = 0; temp_count < cmd->bind_count; temp_count++) {
1892 :
1893 120 : ret = tds_process_tokens(tds, &restype, NULL,
1894 : TDS_STOPAT_ROWFMT|TDS_STOPAT_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE);
1895 :
1896 120 : tdsdump_log(TDS_DBG_FUNC, "_ct_fetch_cursor() tds_process_tokens returned %d\n", ret);
1897 :
1898 120 : if (ret == TDS_SUCCESS && (restype == TDS_ROW_RESULT || restype == TDS_COMPUTE_RESULT)) {
1899 120 : cmd->get_data_item = 0;
1900 120 : cmd->get_data_bytes_returned = 0;
1901 120 : if (restype == TDS_ROW_RESULT) {
1902 120 : if (_ct_bind_data(cmd->con->ctx, tds->current_results,
1903 : tds->current_results, temp_count))
1904 : return CS_ROW_FAIL;
1905 120 : if (rows_read)
1906 120 : *rows_read = *rows_read + 1;
1907 120 : rows_this_fetch++;
1908 : }
1909 : } else {
1910 0 : if (TDS_FAILED(ret))
1911 : return CS_FAIL;
1912 : break;
1913 : }
1914 : }
1915 : break;
1916 : case TDS_DONE_RESULT:
1917 : break;
1918 : }
1919 : }
1920 150 : if (rows_this_fetch)
1921 : return CS_SUCCEED;
1922 :
1923 30 : cmd->results_state = _CS_RES_CMD_SUCCEED;
1924 30 : return CS_END_DATA;
1925 : }
1926 :
1927 :
1928 : int
1929 18532 : _ct_bind_data(CS_CONTEXT *ctx, TDSRESULTINFO * resinfo, TDSRESULTINFO *bindinfo, CS_INT offset)
1930 : {
1931 : TDSCOLUMN *curcol, *bindcol;
1932 : unsigned char *src, *dest;
1933 18532 : int i, result = 0;
1934 : CS_DATAFMT_COMMON srcfmt, destfmt;
1935 : TDS_INT datalen_dummy, *pdatalen;
1936 : TDS_SMALLINT nullind_dummy, *nullind;
1937 :
1938 18532 : tdsdump_log(TDS_DBG_FUNC, "_ct_bind_data(%p, %p, %p, %d)\n", ctx, resinfo, bindinfo, offset);
1939 :
1940 115970 : for (i = 0; i < resinfo->num_cols; i++) {
1941 :
1942 : CS_RETCODE ret;
1943 : CONV_RESULT convert_buffer;
1944 : CS_INT srctype;
1945 :
1946 115970 : curcol = resinfo->columns[i];
1947 115970 : bindcol = bindinfo->columns[i];
1948 :
1949 115970 : tdsdump_log(TDS_DBG_FUNC, "_ct_bind_data(): column %d is type %d and has length %d\n",
1950 : i, curcol->column_type, curcol->column_cur_size);
1951 :
1952 115970 : if (curcol->column_hidden)
1953 111178 : continue;
1954 :
1955 : /*
1956 : * Retrieve the initial bound column_varaddress and increment it if offset specified
1957 : */
1958 :
1959 115874 : dest = (unsigned char *) bindcol->column_varaddr;
1960 115874 : if (dest)
1961 5226 : dest += offset * bindcol->column_bindlen;
1962 :
1963 115874 : nullind = &nullind_dummy;
1964 115874 : if (bindcol->column_nullbind) {
1965 4016 : nullind = bindcol->column_nullbind;
1966 : assert(nullind);
1967 4016 : nullind += offset;
1968 : }
1969 115874 : pdatalen = &datalen_dummy;
1970 115874 : if (bindcol->column_lenbind) {
1971 5226 : pdatalen = bindcol->column_lenbind;
1972 : assert(pdatalen);
1973 5226 : pdatalen += offset;
1974 : }
1975 :
1976 : /* no destination specified */
1977 115874 : if (!dest) {
1978 110648 : *pdatalen = 0;
1979 110648 : continue;
1980 : }
1981 :
1982 : /* NULL column */
1983 5226 : if (curcol->column_cur_size < 0) {
1984 338 : *nullind = -1;
1985 338 : *pdatalen = 0;
1986 338 : continue;
1987 : }
1988 :
1989 4888 : src = curcol->column_data;
1990 4888 : if (is_blob_col(curcol))
1991 566 : src = (unsigned char *) ((TDSBLOB *) src)->textvalue;
1992 :
1993 4888 : srctype = _cs_convert_not_client(ctx, curcol, &convert_buffer, &src);
1994 4888 : if (srctype == CS_ILLEGAL_TYPE)
1995 4808 : srctype = _ct_get_client_type(curcol, false);
1996 4888 : if (srctype == CS_ILLEGAL_TYPE) {
1997 0 : result = 1;
1998 0 : continue;
1999 : }
2000 :
2001 4888 : srcfmt.datatype = srctype;
2002 4888 : srcfmt.maxlength = curcol->column_cur_size;
2003 :
2004 4888 : destfmt.datatype = bindcol->column_bindtype;
2005 4888 : destfmt.maxlength = bindcol->column_bindlen;
2006 4888 : destfmt.precision = bindcol->column_prec;
2007 4888 : destfmt.scale = bindcol->column_scale;
2008 4888 : destfmt.format = bindcol->column_bindfmt;
2009 :
2010 : /* if convert return FAIL mark error but process other columns */
2011 4888 : ret = _cs_convert(ctx, &srcfmt, src, &destfmt, dest, pdatalen);
2012 4888 : if (ret != CS_SUCCEED) {
2013 0 : tdsdump_log(TDS_DBG_FUNC, "cs_convert-result = %d\n", ret);
2014 0 : result = 1;
2015 0 : tdsdump_log(TDS_DBG_INFO1, "error: converted only %d bytes for type %d \n",
2016 : *pdatalen, srctype);
2017 : }
2018 :
2019 4888 : *nullind = 0;
2020 : }
2021 18532 : return result;
2022 : }
2023 :
2024 : CS_RETCODE
2025 1380 : ct_cmd_drop(CS_COMMAND * cmd)
2026 : {
2027 : CS_CONNECTION *con;
2028 :
2029 1380 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop(%p)\n", cmd);
2030 :
2031 1380 : if (cmd) {
2032 1380 : free(cmd->query);
2033 1380 : if (cmd->input_params)
2034 0 : param_clear(cmd->input_params);
2035 1380 : free(cmd->userdata);
2036 1380 : if (cmd->rpc) {
2037 0 : if (cmd->rpc->param_list)
2038 0 : param_clear(cmd->rpc->param_list);
2039 0 : free(cmd->rpc->name);
2040 0 : free(cmd->rpc);
2041 : }
2042 1380 : free(cmd->iodesc);
2043 :
2044 : /* now remove this command from the list of commands in the connection */
2045 1380 : con = cmd->con;
2046 1380 : if (con) {
2047 : CS_COMMAND **pvictim;
2048 :
2049 2800 : for (pvictim = &con->cmds; *pvictim != cmd; ) {
2050 40 : if (!*pvictim) {
2051 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_drop() : cannot find command entry in list \n");
2052 : return CS_FAIL;
2053 : }
2054 40 : pvictim = &(*pvictim)->next;
2055 : }
2056 : /* remove from list */
2057 1380 : *pvictim = cmd->next;
2058 1380 : cmd->next = NULL;
2059 : }
2060 :
2061 1380 : tds_release_cursor(&cmd->cursor);
2062 1380 : free(cmd);
2063 : }
2064 : return CS_SUCCEED;
2065 : }
2066 :
2067 : CS_RETCODE
2068 1340 : ct_close(CS_CONNECTION * con, CS_INT option)
2069 : {
2070 1340 : tdsdump_log(TDS_DBG_FUNC, "ct_close(%p, %d)\n", con, option);
2071 :
2072 1340 : tds_close_socket(con->tds_socket);
2073 1340 : tds_free_socket(con->tds_socket);
2074 1340 : con->tds_socket = NULL;
2075 1340 : return CS_SUCCEED;
2076 : }
2077 :
2078 : CS_RETCODE
2079 1360 : ct_con_drop(CS_CONNECTION * con)
2080 : {
2081 : CS_COMMAND *cmd, *next_cmd;
2082 :
2083 1360 : tdsdump_log(TDS_DBG_FUNC, "ct_con_drop(%p)\n", con);
2084 :
2085 1360 : if (con) {
2086 1360 : free(con->userdata);
2087 1360 : if (con->tds_login)
2088 1360 : tds_free_login(con->tds_login);
2089 1360 : while ((cmd = con->cmds) != NULL) {
2090 0 : next_cmd = cmd->next;
2091 0 : cmd->con = NULL;
2092 0 : cmd->dyn = NULL;
2093 0 : cmd->next = NULL;
2094 0 : con->cmds = next_cmd;
2095 : }
2096 1380 : while (con->dynlist)
2097 20 : _ct_deallocate_dynamic(con, con->dynlist);
2098 1360 : if (con->locale)
2099 0 : _cs_locale_free(con->locale);
2100 1360 : tds_free_socket(con->tds_socket);
2101 : con->tds_socket = NULL;
2102 1360 : free(con->server_addr);
2103 1360 : free(con);
2104 : }
2105 1360 : return CS_SUCCEED;
2106 : }
2107 :
2108 : int
2109 6966 : _ct_get_client_type(const TDSCOLUMN *col, bool describe)
2110 : {
2111 6966 : TDS_SERVER_TYPE type = col->column_type;
2112 6966 : TDS_INT size = col->column_size;
2113 :
2114 6966 : tdsdump_log(TDS_DBG_FUNC, "_ct_get_client_type(type %d, user %d, size %d)\n", type, col->column_usertype, size);
2115 :
2116 6966 : if (type == SYBVARIANT && describe)
2117 : return CS_CHAR_TYPE;
2118 :
2119 6958 : if (type == SYBVARIANT) {
2120 964 : type = ((const TDSVARIANT *) col->column_data)->type;
2121 964 : size = ((const TDSVARIANT *) col->column_data)->size;
2122 : }
2123 :
2124 6958 : switch (tds_get_conversion_type(type, size)) {
2125 : case SYBBIT:
2126 : return CS_BIT_TYPE;
2127 : break;
2128 2566 : case SYBCHAR:
2129 : case SYBVARCHAR:
2130 2566 : return CS_CHAR_TYPE;
2131 : break;
2132 206 : case SYBINT8:
2133 206 : return CS_BIGINT_TYPE;
2134 : break;
2135 782 : case SYBINT4:
2136 782 : return CS_INT_TYPE;
2137 : break;
2138 832 : case SYBINT2:
2139 832 : return CS_SMALLINT_TYPE;
2140 : break;
2141 156 : case SYBINT1:
2142 156 : return CS_TINYINT_TYPE;
2143 : break;
2144 156 : case SYBREAL:
2145 156 : return CS_REAL_TYPE;
2146 : break;
2147 212 : case SYBFLT8:
2148 212 : return CS_FLOAT_TYPE;
2149 : break;
2150 212 : case SYBMONEY:
2151 212 : return CS_MONEY_TYPE;
2152 : break;
2153 156 : case SYBMONEY4:
2154 156 : return CS_MONEY4_TYPE;
2155 : break;
2156 362 : case SYBDATETIME:
2157 362 : return CS_DATETIME_TYPE;
2158 : break;
2159 184 : case SYBDATETIME4:
2160 184 : return CS_DATETIME4_TYPE;
2161 : break;
2162 104 : case SYBNUMERIC:
2163 104 : return CS_NUMERIC_TYPE;
2164 : break;
2165 76 : case SYBDECIMAL:
2166 76 : return CS_DECIMAL_TYPE;
2167 : break;
2168 220 : case SYBBINARY:
2169 : case SYBVARBINARY:
2170 220 : return CS_BINARY_TYPE;
2171 : break;
2172 20 : case SYBIMAGE:
2173 20 : return CS_IMAGE_TYPE;
2174 : break;
2175 46 : case SYBTEXT:
2176 46 : return CS_TEXT_TYPE;
2177 : break;
2178 40 : case SYBUNIQUE:
2179 40 : return CS_UNIQUE_TYPE;
2180 : break;
2181 8 : case SYBLONGCHAR:
2182 8 : return CS_LONGCHAR_TYPE;
2183 : break;
2184 36 : case SYBLONGBINARY:
2185 36 : if (col->column_usertype == USER_UNICHAR_TYPE || col->column_usertype == USER_UNIVARCHAR_TYPE)
2186 : return CS_UNICHAR_TYPE;
2187 36 : return CS_LONGBINARY_TYPE;
2188 : break;
2189 60 : case SYBUINT1:
2190 60 : return CS_TINYINT_TYPE;
2191 : break;
2192 60 : case SYBUINT2:
2193 60 : return CS_USMALLINT_TYPE;
2194 : break;
2195 60 : case SYBUINT4:
2196 60 : return CS_UINT_TYPE;
2197 : break;
2198 60 : case SYBUINT8:
2199 60 : return CS_UBIGINT_TYPE;
2200 : break;
2201 60 : case SYBDATE:
2202 60 : return CS_DATE_TYPE;
2203 : break;
2204 60 : case SYBTIME:
2205 60 : return CS_TIME_TYPE;
2206 : break;
2207 20 : case SYB5BIGTIME:
2208 20 : return CS_BIGTIME_TYPE;
2209 : break;
2210 20 : case SYB5BIGDATETIME:
2211 20 : return CS_BIGDATETIME_TYPE;
2212 : break;
2213 0 : case SYBVARIANT:
2214 0 : return CS_CHAR_TYPE;
2215 : break;
2216 : /* handled by _cs_convert_not_client */
2217 : case SYBMSDATE:
2218 : case SYBMSTIME:
2219 : case SYBMSDATETIME2:
2220 : case SYBMSDATETIMEOFFSET:
2221 : break;
2222 :
2223 : /* nullable types should not occur here... */
2224 : case SYBBITN:
2225 : case SYBINTN:
2226 : case SYBDATETIMN:
2227 : case SYBFLTN:
2228 : case SYBMONEYN:
2229 : case SYBUINTN:
2230 : case SYBTIMEN:
2231 : case SYBDATEN:
2232 :
2233 : /* handled by tds_get_conversion_type */
2234 : case SYB5INT8:
2235 0 : assert(0);
2236 :
2237 : /* TODO... */
2238 : case SYBVOID:
2239 : case SYBNVARCHAR:
2240 : case XSYBVARCHAR:
2241 : case XSYBNVARCHAR:
2242 : case XSYBNCHAR:
2243 : case XSYBVARBINARY:
2244 : case XSYBBINARY:
2245 : case SYBMSUDT:
2246 : case SYBMSXML:
2247 : case SYBMSTABLE:
2248 : case SYBINTERVAL:
2249 : case SYBSINT1:
2250 : case SYBUNITEXT:
2251 : case SYBXML:
2252 : case SYBNTEXT:
2253 : break;
2254 : }
2255 :
2256 80 : return _cs_convert_not_client(NULL, col, NULL, NULL);
2257 : }
2258 :
2259 : TDS_SERVER_TYPE
2260 1881298 : _ct_get_server_type(TDSSOCKET *tds, int datatype)
2261 : {
2262 1881298 : tdsdump_log(TDS_DBG_FUNC, "_ct_get_server_type(%d)\n", datatype);
2263 :
2264 1881298 : switch (datatype) {
2265 : case CS_IMAGE_TYPE: return SYBIMAGE;
2266 1070 : case CS_BINARY_TYPE: return SYBBINARY;
2267 952 : case CS_BIT_TYPE: return SYBBIT;
2268 4984 : case CS_CHAR_TYPE: return SYBCHAR;
2269 940 : case CS_VARCHAR_TYPE: return SYBVARCHAR;
2270 30 : case CS_LONG_TYPE:
2271 : case CS_UBIGINT_TYPE:
2272 30 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_UINT8))
2273 : return SYBUINT8;
2274 : return SYBINT8;
2275 30 : case CS_UINT_TYPE:
2276 30 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_UINT4))
2277 : return SYBUINT4;
2278 : return SYBINT4;
2279 30 : case CS_USMALLINT_TYPE:
2280 30 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_UINT2))
2281 : return SYBUINT2;
2282 : return SYBINT2;
2283 106 : case CS_BIGINT_TYPE: return SYBINT8;
2284 2730 : case CS_INT_TYPE: return SYBINT4;
2285 1768 : case CS_SMALLINT_TYPE: return SYBINT2;
2286 1102 : case CS_TINYINT_TYPE: return SYBINT1;
2287 1052 : case CS_REAL_TYPE: return SYBREAL;
2288 1190 : case CS_FLOAT_TYPE: return SYBFLT8;
2289 1220 : case CS_MONEY_TYPE: return SYBMONEY;
2290 1142 : case CS_MONEY4_TYPE: return SYBMONEY4;
2291 1740 : case CS_DATETIME_TYPE: return SYBDATETIME;
2292 1016 : case CS_DATETIME4_TYPE: return SYBDATETIME4;
2293 930 : case CS_NUMERIC_TYPE: return SYBNUMERIC;
2294 912 : case CS_DECIMAL_TYPE: return SYBDECIMAL;
2295 860 : case CS_VARBINARY_TYPE: return SYBVARBINARY;
2296 860 : case CS_TEXT_TYPE: return SYBTEXT;
2297 20 : case CS_UNIQUE_TYPE: return SYBUNIQUE;
2298 828 : case CS_LONGBINARY_TYPE: return SYBLONGBINARY;
2299 480 : case CS_UNICHAR_TYPE: return SYBVARCHAR;
2300 924 : case CS_LONGCHAR_TYPE:
2301 924 : if (!tds || IS_TDS7_PLUS(tds->conn))
2302 : return SYBVARCHAR;
2303 0 : return SYBLONGCHAR;
2304 1400 : case CS_DATE_TYPE:
2305 1400 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_DATE))
2306 : return SYBDATE;
2307 : return SYBDATETIME;
2308 1380 : case CS_TIME_TYPE:
2309 1380 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_TIME))
2310 : return SYBTIME;
2311 : return SYBDATETIME;
2312 50 : case CS_BIGDATETIME_TYPE:
2313 50 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_BIGDATETIME))
2314 : return SYB5BIGDATETIME;
2315 : return SYBDATETIME;
2316 30 : case CS_BIGTIME_TYPE:
2317 30 : if (!tds || tds_capability_has_req(tds->conn, TDS_REQ_DATA_BIGTIME))
2318 : return SYB5BIGTIME;
2319 : return SYBDATETIME;
2320 :
2321 : /* TODO */
2322 1850620 : case CS_SENSITIVITY_TYPE:
2323 : case CS_BOUNDARY_TYPE:
2324 : case CS_VOID_TYPE:
2325 : case CS_USHORT_TYPE:
2326 : case CS_BLOB_TYPE:
2327 : case CS_UNITEXT_TYPE:
2328 : case CS_XML_TYPE:
2329 : case CS_TEXTLOCATOR_TYPE:
2330 : case CS_IMAGELOCATOR_TYPE:
2331 : case CS_UNITEXTLOCATOR_TYPE:
2332 : default:
2333 1850620 : return TDS_INVALID_TYPE;
2334 : break;
2335 : }
2336 : }
2337 :
2338 : CS_RETCODE
2339 1506 : ct_cancel(CS_CONNECTION * conn, CS_COMMAND * cmd, CS_INT type)
2340 : {
2341 : CS_RETCODE ret;
2342 : CS_COMMAND *cmds;
2343 : CS_COMMAND *conn_cmd;
2344 : CS_CONNECTION *cmd_conn;
2345 :
2346 1506 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel(%p, %p, %d)\n", conn, cmd, type);
2347 :
2348 : /*
2349 : * Comments taken from Sybase ct-library reference manual
2350 : * ------------------------------------------------------
2351 : *
2352 : * "To cancel current results, an application calls ct_cancel
2353 : * with type as CT_CANCEL CURRENT. This is equivalent to
2354 : * calling ct_fetch until it returns CS_END_DATA"
2355 : *
2356 : * "For CS_CANCEL_CURRENT cancels, cmd must be supplied"
2357 : * "For CS_CANCEL_CURRENT cancels, connection must be NULL"
2358 : */
2359 :
2360 1506 : if (type == CS_CANCEL_CURRENT) {
2361 :
2362 :
2363 0 : tdsdump_log(TDS_DBG_FUNC, "CS_CANCEL_CURRENT\n");
2364 0 : if (conn || !cmd)
2365 : return CS_FAIL;
2366 :
2367 :
2368 0 : if (!_ct_fetchable_results(cmd)) {
2369 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() no fetchable results - return()\n");
2370 : return CS_SUCCEED;
2371 : }
2372 :
2373 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() - fetching results()\n");
2374 : do {
2375 0 : ret = ct_fetch(cmd, CS_UNUSED, CS_UNUSED, CS_UNUSED, NULL);
2376 0 : } while ((ret == CS_SUCCEED) || (ret == CS_ROW_FAIL));
2377 :
2378 0 : if (cmd->con && cmd->con->tds_socket)
2379 0 : tds_free_all_results(cmd->con->tds_socket);
2380 :
2381 0 : if (ret == CS_END_DATA) {
2382 : return CS_SUCCEED;
2383 : }
2384 0 : return CS_FAIL;
2385 : }
2386 :
2387 : /*
2388 : * Comments taken from Sybase ct-library reference manual
2389 : * ------------------------------------------------------
2390 : *
2391 : * "To cancel the current command and all results generated
2392 : * by it, call ct_cancel with type as CS_CANCEL_ATTN or
2393 : * CS_CANCEL_ALL. Both of these calls tell client library
2394 : * to :
2395 : * * Send an attention to the server
2396 : * * discard any results already generated by the command
2397 : * Both types of cancel return CS_SUCCEED immediately, w/o
2398 : * sending an attention, if no command is in progress.
2399 : * If an application has not yet called ct_send to send an
2400 : * initiated command, a CS_CANCEL_ATTN has no effect.
2401 : *
2402 : * If a command has been sent and ct_results has not been
2403 : * called, a ct_cancel (CS_CANCEL_ATTN) has no effect."
2404 : *
2405 : * "For CS_CANCEL_ATTN cancels, one of connection or cmd
2406 : * must be NULL. if cmd is supplied and connection is NULL
2407 : * the cancel operation applies only to the command pend-
2408 : * ing for this command structure. If cmd is NULL and
2409 : * connection is supplied, the cancel operation applies to
2410 : * all commands pending for this connection.
2411 : */
2412 :
2413 1506 : if (type == CS_CANCEL_ATTN) {
2414 66 : if ((conn && cmd) || (!conn && !cmd)) {
2415 : return CS_FAIL;
2416 : }
2417 66 : if (cmd) {
2418 66 : tdsdump_log(TDS_DBG_FUNC, "CS_CANCEL_ATTN with cmd\n");
2419 66 : cmd_conn = cmd->con;
2420 66 : switch (cmd->command_state) {
2421 0 : case _CS_COMMAND_IDLE:
2422 : case _CS_COMMAND_READY:
2423 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state READY/IDLE\n");
2424 : break;
2425 66 : case _CS_COMMAND_SENT:
2426 66 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state SENT results_state %d\n",
2427 : cmd->results_state);
2428 66 : if (cmd->results_state != _CS_RES_NONE) {
2429 66 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() sending a cancel \n");
2430 66 : tds_send_cancel(cmd_conn->tds_socket);
2431 66 : cmd->cancel_state = _CS_CANCEL_PENDING;
2432 : }
2433 : break;
2434 : }
2435 : }
2436 66 : if (conn) {
2437 0 : tdsdump_log(TDS_DBG_FUNC, "CS_CANCEL_ATTN with connection\n");
2438 0 : for (cmds = conn->cmds; cmds != NULL; cmds = cmds->next) {
2439 0 : conn_cmd = cmds;
2440 0 : switch (conn_cmd->command_state) {
2441 0 : case _CS_COMMAND_IDLE:
2442 : case _CS_COMMAND_READY:
2443 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state READY/IDLE\n");
2444 : break;
2445 0 : case _CS_COMMAND_SENT:
2446 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state SENT\n");
2447 0 : if (conn_cmd->results_state != _CS_RES_NONE) {
2448 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() sending a cancel \n");
2449 0 : tds_send_cancel(conn->tds_socket);
2450 0 : conn_cmd->cancel_state = _CS_CANCEL_PENDING;
2451 : }
2452 : break;
2453 : }
2454 : }
2455 : }
2456 :
2457 : return CS_SUCCEED;
2458 : }
2459 :
2460 : /*
2461 : * Comments taken from Sybase ct-library reference manual
2462 : * ------------------------------------------------------
2463 : *
2464 : * "To cancel the current command and all results generated
2465 : * by it, call ct_cancel with type as CS_CANCEL_ATTN or
2466 : * CS_CANCEL_ALL. Both of these calls tell client library
2467 : * to :
2468 : * * Send an attention to the server
2469 : * * discard any results already generated by the command
2470 : * Both types of cancel return CS_SUCCEED immediately, w/o
2471 : * sending an attention, if no command is in progress.
2472 : *
2473 : * If an application has not yet called ct_send to send an
2474 : * initiated command, a CS_CANCEL_ALL cancel discards the
2475 : * initiated command without sending an attention to the
2476 : * server.
2477 : *
2478 : * CS_CANCEL_ALL leaves the command structure in a 'clean'
2479 : * state, available for use in another operation.
2480 : *
2481 : * "For CS_CANCEL_ALL cancels, one of connection or cmd
2482 : * must be NULL. if cmd is supplied and connection is NULL
2483 : * the cancel operation applies only to the command pend-
2484 : * ing for this command structure. If cmd is NULL and
2485 : * connection is supplied, the cancel operation applies to
2486 : * all commands pending for this connection.
2487 : */
2488 :
2489 1440 : if (type == CS_CANCEL_ALL) {
2490 :
2491 1440 : if ((conn && cmd) || (!conn && !cmd)) {
2492 : return CS_FAIL;
2493 : }
2494 1440 : if (cmd) {
2495 0 : tdsdump_log(TDS_DBG_FUNC, "CS_CANCEL_ALL with cmd\n");
2496 0 : cmd_conn = cmd->con;
2497 0 : switch (cmd->command_state) {
2498 0 : case _CS_COMMAND_IDLE:
2499 : case _CS_COMMAND_BUILDING:
2500 : case _CS_COMMAND_READY:
2501 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state READY/IDLE\n");
2502 0 : _ct_initialise_cmd(cmd);
2503 0 : break;
2504 0 : case _CS_COMMAND_SENT:
2505 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state SENT\n");
2506 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() sending a cancel \n");
2507 0 : tds_send_cancel(cmd_conn->tds_socket);
2508 0 : tds_process_cancel(cmd_conn->tds_socket);
2509 0 : _ct_initialise_cmd(cmd);
2510 0 : cmd->cancel_state = _CS_CANCEL_PENDING;
2511 0 : break;
2512 : }
2513 : }
2514 1440 : if (conn) {
2515 1440 : tdsdump_log(TDS_DBG_FUNC, "CS_CANCEL_ALL with connection\n");
2516 2870 : for (cmds = conn->cmds; cmds != NULL; cmds = cmds->next) {
2517 1430 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() cancelling a command for a connection\n");
2518 1430 : conn_cmd = cmds;
2519 1430 : switch (conn_cmd->command_state) {
2520 1406 : case _CS_COMMAND_IDLE:
2521 : case _CS_COMMAND_BUILDING:
2522 : case _CS_COMMAND_READY:
2523 1406 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state SENT\n");
2524 1406 : _ct_initialise_cmd(conn_cmd);
2525 1406 : break;
2526 24 : case _CS_COMMAND_SENT:
2527 24 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() command state SENT\n");
2528 24 : tdsdump_log(TDS_DBG_FUNC, "ct_cancel() sending a cancel \n");
2529 24 : tds_send_cancel(conn->tds_socket);
2530 24 : tds_process_cancel(conn->tds_socket);
2531 24 : _ct_initialise_cmd(conn_cmd);
2532 24 : conn_cmd->cancel_state = _CS_CANCEL_PENDING;
2533 24 : break;
2534 : }
2535 : }
2536 : }
2537 :
2538 : return CS_SUCCEED;
2539 : }
2540 : return CS_FAIL;
2541 : }
2542 :
2543 : static CS_RETCODE
2544 0 : _ct_cancel_cleanup(CS_COMMAND * cmd)
2545 : {
2546 : CS_CONNECTION * con;
2547 :
2548 0 : tdsdump_log(TDS_DBG_FUNC, "_ct_cancel_cleanup(%p)\n", cmd);
2549 :
2550 0 : con = cmd->con;
2551 :
2552 0 : if (con && !IS_TDSDEAD(con->tds_socket))
2553 0 : tds_process_cancel(con->tds_socket);
2554 :
2555 0 : cmd->cancel_state = _CS_CANCEL_NOCANCEL;
2556 :
2557 0 : return CS_SUCCEED;
2558 :
2559 : }
2560 :
2561 : CS_RETCODE
2562 578 : ct_describe(CS_COMMAND * cmd, CS_INT item, CS_DATAFMT * datafmt_arg)
2563 : {
2564 : TDSSOCKET *tds;
2565 : TDSRESULTINFO *resinfo;
2566 : TDSCOLUMN *curcol;
2567 : CS_DATAFMT_LARGE *datafmt;
2568 : CS_DATAFMT_LARGE datafmt_buf;
2569 : CS_INT status;
2570 :
2571 578 : tdsdump_log(TDS_DBG_FUNC, "ct_describe(%p, %d, %p)\n", cmd, item, datafmt_arg);
2572 :
2573 578 : if (!cmd->con || !cmd->con->tds_socket)
2574 : return CS_FAIL;
2575 :
2576 578 : datafmt = _ct_datafmt_conv_prepare(cmd->con->ctx, datafmt_arg, &datafmt_buf);
2577 578 : tds = cmd->con->tds_socket;
2578 578 : resinfo = tds->current_results;;
2579 :
2580 578 : if (item < 1 || item > resinfo->num_cols)
2581 : return CS_FAIL;
2582 :
2583 578 : curcol = resinfo->columns[item - 1];
2584 : /* name is always null terminated */
2585 1156 : strlcpy(datafmt->name, tds_dstr_cstr(&curcol->column_name), sizeof(datafmt->name));
2586 578 : datafmt->namelen = (CS_INT) strlen(datafmt->name);
2587 : /* need to turn the SYBxxx into a CS_xxx_TYPE */
2588 578 : datafmt->datatype = _ct_get_client_type(curcol, true);
2589 578 : if (datafmt->datatype == CS_ILLEGAL_TYPE) {
2590 0 : _ctclient_msg(NULL, cmd->con, "ct_describe", 1, 1, 1, 4,
2591 0 : "%s, %s", "column type", tds_prtype(curcol->column_type));
2592 0 : return CS_FAIL;
2593 : }
2594 578 : tdsdump_log(TDS_DBG_INFO1, "ct_describe() datafmt->datatype = %d server type %d\n", datafmt->datatype,
2595 : curcol->column_type);
2596 578 : if (is_numeric_type(curcol->column_type))
2597 10 : datafmt->maxlength = sizeof(CS_NUMERIC);
2598 : else
2599 568 : datafmt->maxlength = curcol->column_size;
2600 578 : datafmt->usertype = curcol->column_usertype;
2601 578 : if (datafmt->usertype == 0 && datafmt->datatype == CS_BIGDATETIME_TYPE)
2602 0 : datafmt->usertype = curcol->column_type;
2603 578 : datafmt->precision = curcol->column_prec;
2604 578 : datafmt->scale = curcol->column_scale;
2605 578 : datafmt->format = curcol->column_bindfmt;
2606 :
2607 : /*
2608 : * There are other options that can be returned, but these are the
2609 : * only two being noted via the TDS layer.
2610 : */
2611 578 : status = 0;
2612 578 : if (curcol->column_nullable)
2613 254 : status |= CS_CANBENULL;
2614 578 : if (curcol->column_identity)
2615 0 : status |= CS_IDENTITY;
2616 578 : if (curcol->column_writeable)
2617 310 : status |= CS_UPDATABLE;
2618 578 : if (curcol->column_key)
2619 0 : status |= CS_KEY;
2620 578 : if (curcol->column_hidden)
2621 0 : status |= CS_HIDDEN;
2622 578 : if (curcol->column_timestamp)
2623 0 : status |= CS_TIMESTAMP;
2624 578 : datafmt->status = status;
2625 :
2626 578 : datafmt->count = 1;
2627 578 : datafmt->locale = NULL;
2628 :
2629 578 : _ct_datafmt_conv_back(datafmt_arg, datafmt);
2630 578 : return CS_SUCCEED;
2631 : }
2632 :
2633 : CS_RETCODE
2634 612 : ct_res_info(CS_COMMAND * cmd, CS_INT type, CS_VOID * buffer, CS_INT buflen, CS_INT * out_len)
2635 : {
2636 : TDSSOCKET *tds;
2637 : TDSRESULTINFO *resinfo;
2638 : TDSCOLUMN *curcol;
2639 : CS_INT int_val;
2640 : int i;
2641 :
2642 612 : tdsdump_log(TDS_DBG_FUNC, "ct_res_info(%p, %d, %p, %d, %p)\n", cmd, type, buffer, buflen, out_len);
2643 :
2644 612 : if (!cmd->con || !cmd->con->tds_socket)
2645 : return CS_FAIL;
2646 :
2647 612 : tds = cmd->con->tds_socket;
2648 612 : resinfo = tds->current_results;
2649 :
2650 612 : switch (type) {
2651 342 : case CS_NUMDATA:
2652 342 : int_val = 0;
2653 342 : if (resinfo) {
2654 1030 : for (i = 0; i < resinfo->num_cols; i++) {
2655 1030 : curcol = resinfo->columns[i];
2656 1030 : if (!curcol->column_hidden) {
2657 998 : int_val++;
2658 : }
2659 : }
2660 : }
2661 342 : tdsdump_log(TDS_DBG_FUNC, "ct_res_info(): Number of columns is %d\n", int_val);
2662 342 : memcpy(buffer, &int_val, sizeof(CS_INT));
2663 342 : break;
2664 260 : case CS_ROW_COUNT:
2665 260 : if (cmd->results_state == _CS_RES_STATUS)
2666 : return CS_FAIL;
2667 : /* 64 -> 32 bit conversion saturate to the maximum */
2668 220 : int_val = tds->rows_affected > 0x7fffffff ? 0x7fffffff : (CS_INT) tds->rows_affected;
2669 220 : tdsdump_log(TDS_DBG_FUNC, "ct_res_info(): Number of rows is %d\n", int_val);
2670 220 : memcpy(buffer, &int_val, sizeof(CS_INT));
2671 220 : break;
2672 10 : default:
2673 10 : _ctclient_msg(NULL, cmd->con, "ct_res_info", 1, 1, 1, 5, "%d, %s", type, "operation");
2674 10 : return CS_FAIL;
2675 : break;
2676 : }
2677 : return CS_SUCCEED;
2678 :
2679 : }
2680 :
2681 : static CS_RETCODE
2682 0 : config_bool(CS_INT action, CS_INT *buf, bool *variable)
2683 : {
2684 0 : switch (action) {
2685 0 : case CS_SUPPORTED:
2686 0 : if (buf) {
2687 0 : *buf = CS_TRUE;
2688 0 : return CS_SUCCEED;
2689 : }
2690 : break;
2691 0 : case CS_SET:
2692 0 : if (buf && (*buf == CS_TRUE || *buf == CS_FALSE)) {
2693 0 : *variable = (*buf != CS_FALSE);
2694 0 : return CS_SUCCEED;
2695 : }
2696 : break;
2697 0 : case CS_GET:
2698 0 : if (buf) {
2699 0 : *buf = (*variable ? CS_TRUE : CS_FALSE);
2700 0 : return CS_SUCCEED;
2701 : }
2702 : break;
2703 0 : case CS_CLEAR:
2704 0 : *variable = false;
2705 0 : return CS_SUCCEED;
2706 : default:
2707 : break;
2708 : }
2709 : return CS_FAIL;
2710 : }
2711 :
2712 : CS_RETCODE
2713 0 : ct_config(CS_CONTEXT * ctx, CS_INT action, CS_INT property, CS_VOID * buffer, CS_INT buflen, CS_INT * outlen)
2714 : {
2715 0 : CS_RETCODE ret = CS_SUCCEED;
2716 0 : CS_INT *buf = (CS_INT *) buffer;
2717 :
2718 0 : tdsdump_log(TDS_DBG_FUNC, "ct_config(%p, %d, %d, %p, %d, %p)\n", ctx, action, property, buffer, buflen, outlen);
2719 :
2720 0 : tdsdump_log(TDS_DBG_FUNC, "ct_config() action = %s property = %d\n",
2721 : CS_GET ? "CS_GET" : CS_SET ? "CS_SET" : CS_SUPPORTED ? "CS_SUPPORTED" : "CS_CLEAR", property);
2722 :
2723 0 : switch (property) {
2724 0 : case CS_EXPOSE_FMTS:
2725 0 : ret = config_bool(action, buf, &ctx->config.cs_expose_formats);
2726 0 : break;
2727 0 : case CS_VER_STRING: {
2728 0 : ret = CS_FAIL;
2729 0 : switch (action) {
2730 0 : case CS_GET: {
2731 0 : if (buffer && buflen > 0 && outlen) {
2732 0 : const TDS_COMPILETIME_SETTINGS *settings= tds_get_compiletime_settings();
2733 0 : *outlen= snprintf((char*)buffer, buflen, "%s (%s, default tds version=%s)",
2734 : settings->freetds_version,
2735 0 : (settings->threadsafe ? "threadsafe" : "non-threadsafe"),
2736 : settings->tdsver
2737 : );
2738 0 : ((char*)buffer)[buflen - 1]= 0;
2739 0 : if (*outlen < 0)
2740 0 : *outlen = (CS_INT) strlen((char*) buffer);
2741 : ret = CS_SUCCEED;
2742 : }
2743 : break;
2744 : default:
2745 : ret = CS_FAIL;
2746 : break;
2747 : }
2748 : }
2749 : }
2750 : break;
2751 0 : case CS_VERSION:
2752 0 : ret = CS_FAIL;
2753 0 : switch (action) {
2754 0 : case CS_GET: {
2755 0 : if (buffer && buflen > 0 && outlen) {
2756 0 : const TDS_COMPILETIME_SETTINGS *settings= tds_get_compiletime_settings();
2757 0 : *outlen= snprintf((char*) buffer, buflen, "%s", settings->freetds_version);
2758 0 : ((char*)buffer)[buflen - 1]= 0;
2759 0 : if (*outlen < 0)
2760 0 : *outlen = (CS_INT) strlen((char*) buffer);
2761 : ret = CS_SUCCEED;
2762 : }
2763 : break;
2764 : default:
2765 : ret = CS_FAIL;
2766 : break;
2767 : }
2768 : }
2769 : break;
2770 0 : case CS_TIMEOUT:
2771 0 : switch (action) {
2772 0 : case CS_SET:
2773 0 : ctx->query_timeout = *((unsigned int*)buf);
2774 0 : break;
2775 0 : case CS_GET:
2776 0 : *((unsigned int*)buf) = ctx->query_timeout;
2777 0 : break;
2778 0 : case CS_CLEAR:
2779 0 : ctx->query_timeout = -1;
2780 0 : break;
2781 : default:
2782 : ret = CS_FAIL;
2783 : break;
2784 : }
2785 : break;
2786 0 : case CS_LOGIN_TIMEOUT:
2787 0 : switch (action) {
2788 0 : case CS_SET:
2789 0 : ctx->login_timeout = *((unsigned int*)buf);
2790 0 : break;
2791 0 : case CS_GET:
2792 0 : *((unsigned int*)buf) = ctx->login_timeout;
2793 0 : break;
2794 0 : case CS_CLEAR:
2795 0 : ctx->login_timeout = -1;
2796 0 : break;
2797 : default:
2798 : ret = CS_FAIL;
2799 : break;
2800 : }
2801 : break;
2802 0 : case CS_NOTE_EMPTY_DATA:
2803 0 : ret = config_bool(action, buf, &ctx->config.cs_note_empty_data);
2804 0 : break;
2805 : default:
2806 : ret = CS_SUCCEED;
2807 : break;
2808 : }
2809 :
2810 0 : return ret;
2811 : }
2812 :
2813 : CS_RETCODE
2814 80 : ct_cmd_props(CS_COMMAND * cmd, CS_INT action, CS_INT property, CS_VOID * buffer, CS_INT buflen, CS_INT * outlen)
2815 : {
2816 : TDSCURSOR *cursor;
2817 : int maxcp;
2818 :
2819 80 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_props(%p, %d, %d, %p, %d, %p)\n", cmd, action, property, buffer, buflen, outlen);
2820 :
2821 80 : if (!cmd->con || !cmd->con->tds_socket)
2822 : return CS_FAIL;
2823 :
2824 80 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_props() action = %s property = %d\n", CS_GET ? "CS_GET" : "CS_SET", property);
2825 80 : if (action == CS_SET) {
2826 0 : switch (property) {
2827 0 : case CS_USERDATA:
2828 0 : free(cmd->userdata);
2829 0 : cmd->userdata = (void *) malloc(buflen + 1);
2830 0 : if (!cmd->userdata)
2831 : return CS_FAIL;
2832 0 : tdsdump_log(TDS_DBG_INFO2, "setting userdata orig %p new %p\n", buffer, cmd->userdata);
2833 0 : cmd->userdata_len = buflen;
2834 0 : memcpy(cmd->userdata, buffer, buflen);
2835 0 : break;
2836 : default:
2837 : break;
2838 : }
2839 80 : }
2840 80 : if (action == CS_GET) {
2841 80 : switch (property) {
2842 :
2843 50 : case CS_PARENT_HANDLE:
2844 50 : *(CS_CONNECTION **) buffer = cmd->con;
2845 50 : break;
2846 :
2847 30 : case CS_CUR_STATUS:
2848 : case CS_CUR_ID:
2849 : case CS_CUR_NAME:
2850 : case CS_CUR_ROWCOUNT:
2851 :
2852 30 : if (property == CS_CUR_STATUS && buflen != CS_UNUSED) {
2853 10 : _ctclient_msg(NULL, cmd->con, "ct_cmd_props(GET,CUR_STATUS)", 1, 1, 1, 9, "%s", "buflen");
2854 10 : return CS_FAIL;
2855 : }
2856 :
2857 20 : cursor = cmd->cursor;
2858 :
2859 20 : if (!cursor) {
2860 10 : tdsdump_log(TDS_DBG_FUNC, "ct_cmd_props() : cannot find cursor\n");
2861 10 : if (property == CS_CUR_STATUS) {
2862 10 : *(CS_INT *)buffer = (CS_INT) CS_CURSTAT_NONE;
2863 10 : if (outlen) *outlen = sizeof(CS_INT);
2864 : return CS_SUCCEED;
2865 : } else {
2866 : return CS_FAIL;
2867 : }
2868 : }
2869 :
2870 10 : if (property == CS_CUR_STATUS) {
2871 10 : *(CS_INT *)buffer = cursor->srv_status;
2872 10 : if (outlen) *outlen = sizeof(CS_INT);
2873 : }
2874 10 : if (property == CS_CUR_ID) {
2875 0 : *(CS_INT *)buffer = cursor->cursor_id;
2876 0 : if (outlen) *outlen = sizeof(CS_INT);
2877 : }
2878 10 : if (property == CS_CUR_NAME) {
2879 0 : CS_INT len = (CS_INT) strlen(cursor->cursor_name);
2880 0 : if (len >= buflen)
2881 : return CS_FAIL;
2882 0 : strcpy((char*) buffer, cursor->cursor_name);
2883 0 : if (outlen) *outlen = len;
2884 : }
2885 10 : if (property == CS_CUR_ROWCOUNT) {
2886 0 : *(CS_INT *)buffer = cursor->cursor_rows;
2887 0 : if (outlen) *outlen = sizeof(CS_INT);
2888 : }
2889 : break;
2890 :
2891 0 : case CS_USERDATA:
2892 0 : tdsdump_log(TDS_DBG_INFO2, "fetching userdata %p\n", cmd->userdata);
2893 0 : maxcp = cmd->userdata_len;
2894 0 : if (outlen) *outlen = maxcp;
2895 0 : if (maxcp > buflen)
2896 0 : maxcp = buflen;
2897 0 : memcpy(buffer, cmd->userdata, maxcp);
2898 0 : break;
2899 : default:
2900 : break;
2901 : }
2902 0 : }
2903 : return CS_SUCCEED;
2904 : }
2905 :
2906 : CS_RETCODE
2907 24 : ct_compute_info(CS_COMMAND * cmd, CS_INT type, CS_INT colnum, CS_VOID * buffer, CS_INT buflen, CS_INT * outlen)
2908 : {
2909 : TDSSOCKET *tds;
2910 : TDSRESULTINFO *resinfo;
2911 : TDSCOLUMN *curcol;
2912 : CS_INT int_val;
2913 : CS_SMALLINT *dest_by_col_ptr;
2914 : TDS_SMALLINT *src_by_col_ptr;
2915 : int i;
2916 :
2917 24 : tdsdump_log(TDS_DBG_FUNC, "ct_compute_info(%p, %d, %d, %p, %d, %p)\n", cmd, type, colnum, buffer, buflen, outlen);
2918 :
2919 24 : tdsdump_log(TDS_DBG_FUNC, "ct_compute_info() type = %d, colnum = %d\n", type, colnum);
2920 :
2921 24 : if (!cmd->con || !cmd->con->tds_socket)
2922 : return CS_FAIL;
2923 :
2924 24 : tds = cmd->con->tds_socket;
2925 24 : resinfo = tds->current_results;
2926 :
2927 24 : switch (type) {
2928 0 : case CS_BYLIST_LEN:
2929 0 : if (!resinfo) {
2930 : int_val = 0;
2931 : } else {
2932 0 : int_val = resinfo->by_cols;
2933 : }
2934 0 : memcpy(buffer, &int_val, sizeof(CS_INT));
2935 0 : if (outlen)
2936 0 : *outlen = sizeof(CS_INT);
2937 : break;
2938 0 : case CS_COMP_BYLIST:
2939 0 : if (buflen < (CS_INT) (resinfo->by_cols * sizeof(CS_SMALLINT))) {
2940 : return CS_FAIL;
2941 : } else {
2942 0 : dest_by_col_ptr = (CS_SMALLINT *) buffer;
2943 0 : src_by_col_ptr = resinfo->bycolumns;
2944 0 : for (i = 0; i < resinfo->by_cols; i++) {
2945 0 : *dest_by_col_ptr = *src_by_col_ptr;
2946 0 : dest_by_col_ptr++;
2947 0 : src_by_col_ptr++;
2948 : }
2949 0 : if (outlen)
2950 0 : *outlen = (resinfo->by_cols * sizeof(CS_SMALLINT));
2951 : }
2952 : break;
2953 0 : case CS_COMP_COLID:
2954 0 : if (!resinfo) {
2955 : int_val = 0;
2956 : } else {
2957 0 : curcol = resinfo->columns[colnum - 1];
2958 0 : int_val = curcol->column_operand;
2959 : }
2960 0 : memcpy(buffer, &int_val, sizeof(CS_INT));
2961 0 : if (outlen)
2962 0 : *outlen = sizeof(CS_INT);
2963 : break;
2964 24 : case CS_COMP_ID:
2965 24 : if (!resinfo) {
2966 : int_val = 0;
2967 : } else {
2968 24 : int_val = resinfo->computeid;
2969 : }
2970 24 : memcpy(buffer, &int_val, sizeof(CS_INT));
2971 24 : if (outlen)
2972 0 : *outlen = sizeof(CS_INT);
2973 : break;
2974 0 : case CS_COMP_OP:
2975 0 : if (!resinfo) {
2976 : int_val = 0;
2977 : } else {
2978 0 : curcol = resinfo->columns[colnum - 1];
2979 0 : int_val = _ct_map_compute_op(curcol->column_operator);
2980 : }
2981 0 : memcpy(buffer, &int_val, sizeof(CS_INT));
2982 0 : if (outlen)
2983 0 : *outlen = sizeof(CS_INT);
2984 : break;
2985 0 : default:
2986 0 : _ctclient_msg(NULL, cmd->con, "ct_compute_info", 1, 1, 1, 5, "%d, %s", type, "type");
2987 0 : return CS_FAIL;
2988 : break;
2989 : }
2990 : return CS_SUCCEED;
2991 : }
2992 :
2993 : CS_RETCODE
2994 18 : ct_get_data(CS_COMMAND * cmd, CS_INT item, CS_VOID * buffer, CS_INT buflen, CS_INT * outlen)
2995 : {
2996 : TDSRESULTINFO *resinfo;
2997 : TDSCOLUMN *curcol;
2998 : unsigned char *src;
2999 : TDS_INT srclen;
3000 :
3001 18 : tdsdump_log(TDS_DBG_FUNC, "ct_get_data(%p, %d, %p, %d, %p)\n", cmd, item, buffer, buflen, outlen);
3002 :
3003 18 : tdsdump_log(TDS_DBG_FUNC, "ct_get_data() item = %d buflen = %d\n", item, buflen);
3004 :
3005 : /* basic validations... */
3006 18 : if (!cmd || !cmd->con || !cmd->con->tds_socket || !(resinfo = cmd->con->tds_socket->current_results))
3007 : return CS_FAIL;
3008 18 : if (item < 1 || item > resinfo->num_cols)
3009 : return CS_FAIL;
3010 18 : if (!buffer)
3011 : return CS_FAIL;
3012 18 : if (buflen == CS_UNUSED)
3013 : return CS_FAIL;
3014 :
3015 18 : if (cmd->cancel_state == _CS_CANCEL_PENDING) {
3016 0 : _ct_cancel_cleanup(cmd);
3017 0 : return CS_CANCELED;
3018 : }
3019 :
3020 : /* This is a new column we are being asked to return */
3021 :
3022 18 : if (item != cmd->get_data_item) {
3023 6 : TDSBLOB *blob = NULL;
3024 : size_t table_namelen, column_namelen, namelen;
3025 :
3026 : /* allocate needed descriptor if needed */
3027 6 : free(cmd->iodesc);
3028 6 : cmd->iodesc = tds_new0(CS_IODESC, 1);
3029 6 : if (!cmd->iodesc)
3030 : return CS_FAIL;
3031 :
3032 : /* reset these values */
3033 6 : cmd->get_data_item = item;
3034 6 : cmd->get_data_bytes_returned = 0;
3035 :
3036 : /* get at the source data and length */
3037 6 : curcol = resinfo->columns[item - 1];
3038 :
3039 6 : src = curcol->column_data;
3040 6 : if (is_blob_col(curcol)) {
3041 6 : blob = (TDSBLOB *) src;
3042 6 : src = (unsigned char *) blob->textvalue;
3043 : }
3044 :
3045 : /* now populate the io_desc structure for this data item */
3046 :
3047 6 : cmd->iodesc->iotype = CS_IODATA;
3048 6 : cmd->iodesc->datatype = _ct_get_client_type(curcol, true);
3049 6 : cmd->iodesc->locale = cmd->con->locale;
3050 6 : cmd->iodesc->usertype = curcol->column_usertype;
3051 6 : cmd->iodesc->total_txtlen = curcol->column_cur_size;
3052 6 : cmd->iodesc->offset = 0;
3053 6 : cmd->iodesc->log_on_update = CS_FALSE;
3054 :
3055 : /* TODO quote needed ?? */
3056 : /* avoid possible buffer overflow */
3057 12 : table_namelen = tds_dstr_len(&curcol->table_name);
3058 6 : table_namelen = TDS_MIN(table_namelen, sizeof(cmd->iodesc->name) - 2);
3059 12 : column_namelen = tds_dstr_len(&curcol->column_name);
3060 6 : column_namelen = TDS_MIN(column_namelen, sizeof(cmd->iodesc->name) - 2 - table_namelen);
3061 :
3062 6 : namelen = 0;
3063 6 : if (table_namelen) {
3064 12 : memcpy(cmd->iodesc->name, tds_dstr_cstr(&curcol->table_name), table_namelen);
3065 6 : namelen += table_namelen;
3066 : }
3067 :
3068 6 : cmd->iodesc->name[namelen] = '.';
3069 6 : ++namelen;
3070 :
3071 6 : if (column_namelen) {
3072 12 : memcpy(cmd->iodesc->name + namelen, tds_dstr_cstr(&curcol->column_name), column_namelen);
3073 6 : namelen += column_namelen;
3074 : }
3075 :
3076 6 : cmd->iodesc->name[namelen] = '\0';
3077 6 : cmd->iodesc->namelen = (CS_INT) namelen;
3078 :
3079 6 : if (blob && blob->valid_ptr) {
3080 6 : memcpy(cmd->iodesc->timestamp, blob->timestamp, CS_TS_SIZE);
3081 6 : cmd->iodesc->timestamplen = CS_TS_SIZE;
3082 6 : memcpy(cmd->iodesc->textptr, blob->textptr, CS_TP_SIZE);
3083 6 : cmd->iodesc->textptrlen = CS_TP_SIZE;
3084 : }
3085 : } else {
3086 : /* get at the source data */
3087 12 : curcol = resinfo->columns[item - 1];
3088 12 : src = curcol->column_data;
3089 12 : if (is_blob_col(curcol))
3090 12 : src = (unsigned char *) ((TDSBLOB *) src)->textvalue;
3091 :
3092 : }
3093 :
3094 : /*
3095 : * and adjust the data and length based on
3096 : * what we may have already returned
3097 : */
3098 :
3099 18 : srclen = curcol->column_cur_size;
3100 18 : if (srclen < 0) {
3101 : /* this is NULL */
3102 0 : if (!cmd->con->ctx->config.cs_note_empty_data) {
3103 : srclen = 0;
3104 : } else {
3105 0 : if (outlen)
3106 0 : *outlen = srclen;
3107 0 : if (item < resinfo->num_cols)
3108 : return CS_END_ITEM;
3109 0 : return CS_END_DATA;
3110 : }
3111 : }
3112 :
3113 18 : src += cmd->get_data_bytes_returned;
3114 18 : srclen -= cmd->get_data_bytes_returned;
3115 :
3116 : /* if we have enough buffer to cope with all the data */
3117 :
3118 18 : if (buflen >= srclen) {
3119 6 : memcpy(buffer, src, srclen);
3120 6 : cmd->get_data_bytes_returned += srclen;
3121 6 : if (outlen)
3122 6 : *outlen = srclen;
3123 6 : if (item < resinfo->num_cols)
3124 : return CS_END_ITEM;
3125 6 : return CS_END_DATA;
3126 :
3127 : }
3128 12 : memcpy(buffer, src, buflen);
3129 12 : cmd->get_data_bytes_returned += buflen;
3130 12 : if (outlen)
3131 12 : *outlen = buflen;
3132 : return CS_SUCCEED;
3133 : }
3134 :
3135 : CS_RETCODE
3136 24 : ct_send_data(CS_COMMAND * cmd, CS_VOID * buffer, CS_INT buflen)
3137 : {
3138 : TDSSOCKET *tds;
3139 :
3140 : char textptr_string[35]; /* 16 * 2 + 2 (0x) + 1 */
3141 : char timestamp_string[19]; /* 8 * 2 + 2 (0x) + 1 */
3142 : char *c;
3143 : int s;
3144 : char hex2[3];
3145 :
3146 24 : tdsdump_log(TDS_DBG_FUNC, "ct_send_data(%p, %p, %d)\n", cmd, buffer, buflen);
3147 :
3148 24 : if (!cmd->con || !cmd->con->tds_socket)
3149 : return CS_FAIL;
3150 :
3151 24 : tds = cmd->con->tds_socket;
3152 :
3153 : /* basic validations */
3154 :
3155 24 : if (cmd->command_type != CS_SEND_DATA_CMD)
3156 : return CS_FAIL;
3157 :
3158 24 : if (!cmd->iodesc || !cmd->iodesc->textptrlen)
3159 : return CS_FAIL;
3160 :
3161 : /* first ct_send_data for this column */
3162 :
3163 24 : if (!cmd->send_data_started) {
3164 :
3165 : /* turn the timestamp and textptr into character format */
3166 :
3167 : c = textptr_string;
3168 :
3169 96 : for (s = 0; s < cmd->iodesc->textptrlen; s++) {
3170 96 : sprintf(hex2, "%02x", cmd->iodesc->textptr[s]);
3171 96 : *c++ = hex2[0];
3172 96 : *c++ = hex2[1];
3173 : }
3174 6 : *c = '\0';
3175 :
3176 6 : c = timestamp_string;
3177 :
3178 54 : for (s = 0; s < cmd->iodesc->timestamplen; s++) {
3179 48 : sprintf(hex2, "%02x", cmd->iodesc->timestamp[s]);
3180 48 : *c++ = hex2[0];
3181 48 : *c++ = hex2[1];
3182 : }
3183 6 : *c = '\0';
3184 :
3185 : /* submit the writetext command */
3186 6 : if (TDS_FAILED(tds_writetext_start(tds, cmd->iodesc->name,
3187 : textptr_string, timestamp_string, (cmd->iodesc->log_on_update == CS_TRUE), cmd->iodesc->total_txtlen)))
3188 : return CS_FAIL;
3189 :
3190 6 : cmd->send_data_started = 1;
3191 : }
3192 :
3193 24 : if (TDS_FAILED(tds_writetext_continue(tds, (const TDS_UCHAR*) buffer, buflen)))
3194 : return CS_FAIL;
3195 :
3196 24 : return CS_SUCCEED;
3197 : }
3198 :
3199 : CS_RETCODE
3200 12 : ct_data_info(CS_COMMAND * cmd, CS_INT action, CS_INT colnum, CS_IODESC * iodesc)
3201 : {
3202 : TDSSOCKET *tds;
3203 : TDSRESULTINFO *resinfo;
3204 :
3205 12 : tdsdump_log(TDS_DBG_FUNC, "ct_data_info(%p, %d, %d, %p)\n", cmd, action, colnum, iodesc);
3206 :
3207 12 : if (!cmd->con || !cmd->con->tds_socket)
3208 : return CS_FAIL;
3209 :
3210 12 : tds = cmd->con->tds_socket;
3211 12 : resinfo = tds->current_results;
3212 :
3213 12 : switch (action) {
3214 6 : case CS_SET:
3215 6 : if (iodesc->timestamplen < 0 || iodesc->timestamplen > CS_TS_SIZE)
3216 : return CS_FAIL;
3217 6 : if (iodesc->textptrlen < 0 || iodesc->textptrlen > CS_TP_SIZE)
3218 : return CS_FAIL;
3219 6 : free(cmd->iodesc);
3220 6 : cmd->iodesc = tds_new0(CS_IODESC, 1);
3221 6 : if (!cmd->iodesc)
3222 : return CS_FAIL;
3223 :
3224 6 : cmd->iodesc->iotype = CS_IODATA;
3225 6 : cmd->iodesc->datatype = iodesc->datatype;
3226 6 : cmd->iodesc->locale = cmd->con->locale;
3227 6 : cmd->iodesc->usertype = iodesc->usertype;
3228 6 : cmd->iodesc->total_txtlen = iodesc->total_txtlen;
3229 6 : cmd->iodesc->offset = iodesc->offset;
3230 6 : cmd->iodesc->log_on_update = iodesc->log_on_update;
3231 6 : strcpy(cmd->iodesc->name, iodesc->name);
3232 6 : cmd->iodesc->namelen = iodesc->namelen;
3233 6 : memcpy(cmd->iodesc->timestamp, iodesc->timestamp, iodesc->timestamplen);
3234 6 : cmd->iodesc->timestamplen = iodesc->timestamplen;
3235 6 : memcpy(cmd->iodesc->textptr, iodesc->textptr, iodesc->textptrlen);
3236 6 : cmd->iodesc->textptrlen = iodesc->textptrlen;
3237 6 : break;
3238 :
3239 6 : case CS_GET:
3240 :
3241 6 : if (colnum < 1 || colnum > resinfo->num_cols)
3242 : return CS_FAIL;
3243 6 : if (colnum != cmd->get_data_item)
3244 : return CS_FAIL;
3245 :
3246 6 : iodesc->iotype = cmd->iodesc->iotype;
3247 6 : iodesc->datatype = cmd->iodesc->datatype;
3248 6 : iodesc->locale = cmd->iodesc->locale;
3249 6 : iodesc->usertype = cmd->iodesc->usertype;
3250 6 : iodesc->total_txtlen = cmd->iodesc->total_txtlen;
3251 6 : iodesc->offset = cmd->iodesc->offset;
3252 6 : iodesc->log_on_update = CS_FALSE;
3253 6 : strcpy(iodesc->name, cmd->iodesc->name);
3254 6 : iodesc->namelen = cmd->iodesc->namelen;
3255 6 : memcpy(iodesc->timestamp, cmd->iodesc->timestamp, cmd->iodesc->timestamplen);
3256 6 : iodesc->timestamplen = cmd->iodesc->timestamplen;
3257 6 : memcpy(iodesc->textptr, cmd->iodesc->textptr, cmd->iodesc->textptrlen);
3258 6 : iodesc->textptrlen = cmd->iodesc->textptrlen;
3259 6 : break;
3260 :
3261 : default:
3262 : return CS_FAIL;
3263 : }
3264 :
3265 : return CS_SUCCEED;
3266 : }
3267 :
3268 : CS_RETCODE
3269 0 : ct_capability(CS_CONNECTION * con, CS_INT action, CS_INT type, CS_INT capability, CS_VOID * value)
3270 : {
3271 : TDSLOGIN *login;
3272 0 : int idx = 0;
3273 0 : unsigned char bitmask = 0;
3274 0 : TDS_CAPABILITY_TYPE *cap = NULL;
3275 :
3276 0 : tdsdump_log(TDS_DBG_FUNC, "ct_capability(%p, %d, %d, %d, %p)\n", con, action, type, capability, value);
3277 :
3278 0 : login = (TDSLOGIN *) con->tds_login;
3279 :
3280 : #define CONV_CAP(ct,tds) case ct: idx=tds; break;
3281 0 : if (type == CS_CAP_RESPONSE) {
3282 0 : cap = &login->capabilities.types[1];
3283 0 : switch (capability) {
3284 0 : CONV_CAP(CS_DATA_NOBOUNDARY, TDS_RES_DATA_NOBOUNDARY);
3285 0 : CONV_CAP(CS_RES_NOTDSDEBUG, TDS_RES_NOTDSDEBUG);
3286 0 : CONV_CAP(CS_RES_NOSTRIPBLANKS, TDS_RES_NOSTRIPBLANKS);
3287 0 : CONV_CAP(CS_DATA_NOINT8, TDS_RES_DATA_NOINT8);
3288 :
3289 0 : CONV_CAP(CS_DATA_NOINTN, TDS_RES_DATA_INTN);
3290 0 : CONV_CAP(CS_DATA_NODATETIMEN, TDS_RES_DATA_NODATETIMEN);
3291 0 : CONV_CAP(CS_DATA_NOMONEYN, TDS_RES_DATA_NOMONEYN);
3292 0 : CONV_CAP(CS_CON_NOOOB, TDS_RES_CON_NOOOB);
3293 0 : CONV_CAP(CS_CON_NOINBAND, TDS_RES_CON_NOINBAND);
3294 0 : CONV_CAP(CS_PROTO_NOTEXT, TDS_RES_PROTO_NOTEXT);
3295 0 : CONV_CAP(CS_PROTO_NOBULK, TDS_RES_PROTO_NOBULK);
3296 0 : CONV_CAP(CS_DATA_NOSENSITIVITY, TDS_RES_DATA_NOSENSITIVITY);
3297 :
3298 0 : CONV_CAP(CS_DATA_NOFLT4, TDS_RES_DATA_NOFLT4);
3299 0 : CONV_CAP(CS_DATA_NOFLT8, TDS_RES_DATA_NOFLT8);
3300 0 : CONV_CAP(CS_DATA_NONUM, TDS_RES_DATA_NONUM);
3301 0 : CONV_CAP(CS_DATA_NOTEXT, TDS_RES_DATA_NOTEXT);
3302 0 : CONV_CAP(CS_DATA_NOIMAGE, TDS_RES_DATA_NOIMAGE);
3303 0 : CONV_CAP(CS_DATA_NODEC, TDS_RES_DATA_NODEC);
3304 0 : CONV_CAP(CS_DATA_NOLCHAR, TDS_RES_DATA_NOLCHAR);
3305 0 : CONV_CAP(CS_DATA_NOLBIN, TDS_RES_DATA_NOLBIN);
3306 :
3307 0 : CONV_CAP(CS_DATA_NOCHAR, TDS_RES_DATA_NOCHAR);
3308 0 : CONV_CAP(CS_DATA_NOVCHAR, TDS_RES_DATA_NOVCHAR);
3309 0 : CONV_CAP(CS_DATA_NOBIN, TDS_RES_DATA_NOBIN);
3310 0 : CONV_CAP(CS_DATA_NOVBIN, TDS_RES_DATA_NOVBIN);
3311 0 : CONV_CAP(CS_DATA_NOMNY8, TDS_RES_DATA_NOMNY8);
3312 0 : CONV_CAP(CS_DATA_NOMNY4, TDS_RES_DATA_NOMNY4);
3313 0 : CONV_CAP(CS_DATA_NODATE8, TDS_RES_DATA_NODATE8);
3314 0 : CONV_CAP(CS_DATA_NODATE4, TDS_RES_DATA_NODATE4);
3315 :
3316 0 : CONV_CAP(CS_RES_NOMSG, TDS_RES_NOMSG);
3317 0 : CONV_CAP(CS_RES_NOEED, TDS_RES_NOEED);
3318 0 : CONV_CAP(CS_RES_NOPARAM, TDS_RES_NOPARAM);
3319 0 : CONV_CAP(CS_DATA_NOINT1, TDS_RES_DATA_NOINT1);
3320 0 : CONV_CAP(CS_DATA_NOINT2, TDS_RES_DATA_NOINT2);
3321 0 : CONV_CAP(CS_DATA_NOINT4, TDS_RES_DATA_NOINT4);
3322 0 : CONV_CAP(CS_DATA_NOBIT, TDS_RES_DATA_NOBIT);
3323 : } /* end capability */
3324 : } /* End handling CS_CAP_RESPONSE (returned) */
3325 :
3326 : /*
3327 : * Begin handling CS_CAP_REQUEST
3328 : * These capabilities describe the types of requests that a server can support.
3329 : */
3330 0 : if (type == CS_CAP_REQUEST) {
3331 0 : if (action == CS_SET) {
3332 0 : tdsdump_log(TDS_DBG_SEVERE,
3333 : "ct_capability -- attempt to set a read-only capability (type %d, action %d)\n",
3334 : type, action);
3335 : return CS_FAIL;
3336 : }
3337 :
3338 0 : cap = &login->capabilities.types[0];
3339 0 : switch (capability) {
3340 0 : CONV_CAP(CS_PROTO_DYNPROC, TDS_REQ_PROTO_DYNPROC);
3341 0 : CONV_CAP(CS_DATA_FLTN, TDS_REQ_DATA_FLTN);
3342 0 : CONV_CAP(CS_DATA_BITN, TDS_REQ_DATA_BITN);
3343 0 : CONV_CAP(CS_DATA_INT8, TDS_REQ_DATA_INT8);
3344 0 : CONV_CAP(CS_DATA_VOID, TDS_REQ_DATA_VOID);
3345 :
3346 0 : CONV_CAP(CS_CON_INBAND, TDS_REQ_CON_INBAND);
3347 0 : CONV_CAP(CS_CON_LOGICAL, TDS_REQ_CON_LOGICAL);
3348 0 : CONV_CAP(CS_PROTO_TEXT, TDS_REQ_PROTO_TEXT);
3349 0 : CONV_CAP(CS_PROTO_BULK, TDS_REQ_PROTO_BULK);
3350 0 : CONV_CAP(CS_REQ_URGNOTIF, TDS_REQ_URGEVT);
3351 0 : CONV_CAP(CS_DATA_SENSITIVITY, TDS_REQ_DATA_SENSITIVITY);
3352 0 : CONV_CAP(CS_DATA_BOUNDARY, TDS_REQ_DATA_BOUNDARY);
3353 0 : CONV_CAP(CS_PROTO_DYNAMIC, TDS_REQ_PROTO_DYNAMIC);
3354 :
3355 0 : CONV_CAP(CS_DATA_MONEYN, TDS_REQ_DATA_MONEYN);
3356 0 : CONV_CAP(CS_CSR_PREV, TDS_REQ_CSR_PREV);
3357 0 : CONV_CAP(CS_CSR_FIRST, TDS_REQ_CSR_FIRST);
3358 0 : CONV_CAP(CS_CSR_LAST, TDS_REQ_CSR_LAST);
3359 0 : CONV_CAP(CS_CSR_ABS, TDS_REQ_CSR_ABS);
3360 0 : CONV_CAP(CS_CSR_REL, TDS_REQ_CSR_REL);
3361 0 : CONV_CAP(CS_CSR_MULTI, TDS_REQ_CSR_MULTI);
3362 0 : CONV_CAP(CS_CON_OOB, TDS_REQ_CON_OOB);
3363 :
3364 0 : CONV_CAP(CS_DATA_NUM, TDS_REQ_DATA_NUM);
3365 0 : CONV_CAP(CS_DATA_TEXT, TDS_REQ_DATA_TEXT);
3366 0 : CONV_CAP(CS_DATA_IMAGE, TDS_REQ_DATA_IMAGE);
3367 0 : CONV_CAP(CS_DATA_DEC, TDS_REQ_DATA_DEC);
3368 0 : CONV_CAP(CS_DATA_LCHAR, TDS_REQ_DATA_LCHAR);
3369 0 : CONV_CAP(CS_DATA_LBIN, TDS_REQ_DATA_LBIN);
3370 0 : CONV_CAP(CS_DATA_INTN, TDS_REQ_DATA_INTN);
3371 0 : CONV_CAP(CS_DATA_DATETIMEN, TDS_REQ_DATA_DATETIMEN);
3372 :
3373 0 : CONV_CAP(CS_DATA_BIN, TDS_REQ_DATA_BIN);
3374 0 : CONV_CAP(CS_DATA_VBIN, TDS_REQ_DATA_VBIN);
3375 0 : CONV_CAP(CS_DATA_MNY8, TDS_REQ_DATA_MNY8);
3376 0 : CONV_CAP(CS_DATA_MNY4, TDS_REQ_DATA_MNY4);
3377 0 : CONV_CAP(CS_DATA_DATE8, TDS_REQ_DATA_DATE8);
3378 0 : CONV_CAP(CS_DATA_DATE4, TDS_REQ_DATA_DATE4);
3379 0 : CONV_CAP(CS_DATA_FLT4, TDS_REQ_DATA_FLT4);
3380 0 : CONV_CAP(CS_DATA_FLT8, TDS_REQ_DATA_FLT8);
3381 :
3382 0 : CONV_CAP(CS_REQ_MSG, TDS_REQ_MSG);
3383 0 : CONV_CAP(CS_REQ_PARAM, TDS_REQ_PARAM);
3384 0 : CONV_CAP(CS_DATA_INT1, TDS_REQ_DATA_INT1);
3385 0 : CONV_CAP(CS_DATA_INT2, TDS_REQ_DATA_INT2);
3386 0 : CONV_CAP(CS_DATA_INT4, TDS_REQ_DATA_INT4);
3387 0 : CONV_CAP(CS_DATA_BIT, TDS_REQ_DATA_BIT);
3388 0 : CONV_CAP(CS_DATA_CHAR, TDS_REQ_DATA_CHAR);
3389 0 : CONV_CAP(CS_DATA_VCHAR, TDS_REQ_DATA_VCHAR);
3390 :
3391 0 : CONV_CAP(CS_REQ_LANG, TDS_REQ_LANG);
3392 0 : CONV_CAP(CS_REQ_RPC, TDS_REQ_RPC);
3393 0 : CONV_CAP(CS_REQ_NOTIF, TDS_REQ_EVT);
3394 0 : CONV_CAP(CS_REQ_MSTMT, TDS_REQ_MSTMT);
3395 0 : CONV_CAP(CS_REQ_BCP, TDS_REQ_BCP);
3396 0 : CONV_CAP(CS_REQ_CURSOR, TDS_REQ_CURSOR);
3397 0 : CONV_CAP(CS_REQ_DYN, TDS_REQ_DYNF);
3398 : } /* end capability */
3399 : } /* End handling CS_CAP_REQUEST */
3400 : #undef CONV_CAP
3401 :
3402 0 : if (!cap) {
3403 0 : tdsdump_log(TDS_DBG_SEVERE, "ct_capability -- unknown capability type\n");
3404 : return CS_FAIL;
3405 : }
3406 0 : if (idx == 0) {
3407 0 : tdsdump_log(TDS_DBG_SEVERE, "ct_capability -- attempt to set/get a non-existant capability\n");
3408 : return CS_FAIL;
3409 : }
3410 :
3411 0 : bitmask = 1 << (idx&7);
3412 0 : idx = sizeof(cap->values) - 1 - (idx>>3);
3413 : assert(0 <= idx && idx <= sizeof(cap->values));
3414 :
3415 0 : switch (action) {
3416 0 : case CS_SET:
3417 : /* Having established the offset and the bitmask, we can now turn the capability on or off */
3418 0 : switch (*(CS_BOOL *) value) {
3419 0 : case CS_TRUE:
3420 0 : cap->values[idx] |= bitmask;
3421 0 : break;
3422 0 : case CS_FALSE:
3423 0 : cap->values[idx] &= ~bitmask;
3424 0 : break;
3425 0 : default:
3426 0 : tdsdump_log(TDS_DBG_SEVERE, "ct_capability -- unknown value\n");
3427 : return CS_FAIL;
3428 : }
3429 : break;
3430 0 : case CS_GET:
3431 0 : *(CS_BOOL *) value = (cap->values[idx] & bitmask) ? CS_TRUE : CS_FALSE;
3432 0 : break;
3433 0 : default:
3434 0 : tdsdump_log(TDS_DBG_SEVERE, "ct_capability -- unknown action\n");
3435 : return CS_FAIL;
3436 : }
3437 : return CS_SUCCEED;
3438 : } /* end ct_capability */
3439 :
3440 :
3441 : CS_RETCODE
3442 140 : ct_dynamic(CS_COMMAND * cmd, CS_INT type, CS_CHAR * id, CS_INT idlen, CS_CHAR * buffer, CS_INT buflen)
3443 : {
3444 : ptrdiff_t query_len;
3445 : CS_CONNECTION *con;
3446 : CS_DYNAMIC *dyn;
3447 :
3448 140 : tdsdump_log(TDS_DBG_FUNC, "ct_dynamic(%p, %d, %p, %d, %p, %d)\n", cmd, type, id, idlen, buffer, buflen);
3449 :
3450 140 : if (!cmd || !cmd->con)
3451 : return CS_FAIL;
3452 :
3453 140 : con = cmd->con;
3454 :
3455 140 : switch (type) {
3456 50 : case CS_PREPARE:
3457 :
3458 50 : dyn = _ct_allocate_dynamic(con, id, idlen);
3459 :
3460 50 : if (!dyn)
3461 : return CS_FAIL;
3462 :
3463 : /* now the query */
3464 30 : query_len = _ct_get_string_length(buffer, buflen);
3465 30 : if (query_len < 0) {
3466 10 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 5, "%d, buflen", buflen);
3467 10 : return CS_FAIL;
3468 : }
3469 20 : dyn->stmt = tds_strndup(buffer, query_len);
3470 :
3471 20 : cmd->dyn = dyn;
3472 :
3473 20 : break;
3474 40 : case CS_DEALLOC:
3475 40 : cmd->dyn = _ct_locate_dynamic(con, id, idlen);
3476 40 : if (!cmd->dyn)
3477 : return CS_FAIL;
3478 : break;
3479 20 : case CS_DESCRIBE_INPUT:
3480 : case CS_DESCRIBE_OUTPUT:
3481 20 : cmd->dyn = _ct_locate_dynamic(con, id, idlen);
3482 20 : if (!cmd->dyn)
3483 : return CS_FAIL;
3484 : break;
3485 20 : case CS_EXECUTE:
3486 20 : cmd->dyn = _ct_locate_dynamic(con, id, idlen);
3487 20 : if (!cmd->dyn)
3488 : return CS_FAIL;
3489 :
3490 20 : tdsdump_log(TDS_DBG_FUNC, "ct_dynamic() calling param_clear\n");
3491 20 : param_clear(cmd->dyn->param_list);
3492 20 : cmd->dyn->param_list = NULL;
3493 20 : break;
3494 10 : default:
3495 10 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 5, "%d, type", type);
3496 10 : return CS_FAIL;
3497 : }
3498 :
3499 70 : cmd->command_type = CS_DYNAMIC_CMD;
3500 70 : cmd->dynamic_cmd = type;
3501 :
3502 70 : ct_set_command_state(cmd, _CS_COMMAND_READY);
3503 70 : return CS_SUCCEED;
3504 : }
3505 :
3506 : CS_RETCODE
3507 270 : ct_param(CS_COMMAND * cmd, CS_DATAFMT * datafmt_arg, CS_VOID * data, CS_INT datalen, CS_SMALLINT indicator)
3508 : {
3509 : CSREMOTE_PROC *rpc;
3510 : CS_DYNAMIC *dyn;
3511 : CS_PARAM **pparam;
3512 : CS_PARAM *param;
3513 : const CS_DATAFMT_LARGE *datafmt;
3514 : CS_DATAFMT_LARGE datafmt_buf;
3515 :
3516 270 : tdsdump_log(TDS_DBG_FUNC, "ct_param(%p, %p, %p, %d, %hd)\n", cmd, datafmt_arg, data, datalen, indicator);
3517 :
3518 270 : if (!cmd || !cmd->con)
3519 : return CS_FAIL;
3520 :
3521 270 : datafmt = _ct_datafmt_conv_in(cmd->con->ctx, datafmt_arg, &datafmt_buf);
3522 :
3523 270 : switch (cmd->command_type) {
3524 90 : case CS_RPC_CMD:
3525 90 : if (!cmd->rpc) {
3526 0 : tdsdump_log(TDS_DBG_ERROR, "RPC is NULL in ct_param\n");
3527 : return CS_FAIL;
3528 : }
3529 :
3530 90 : param = tds_new0(CSREMOTE_PROC_PARAM, 1);
3531 90 : if (!param)
3532 : return CS_FAIL;
3533 :
3534 90 : if (CS_SUCCEED != _ct_fill_param(cmd->command_type, param, datafmt, data, &datalen, &indicator, 1)) {
3535 0 : tdsdump_log(TDS_DBG_INFO1, "ct_param() failed to add rpc param\n");
3536 0 : tdsdump_log(TDS_DBG_INFO1, "ct_param() failed to add input value\n");
3537 0 : free(param);
3538 0 : return CS_FAIL;
3539 : }
3540 :
3541 90 : rpc = cmd->rpc;
3542 90 : pparam = &rpc->param_list;
3543 540 : while (*pparam) {
3544 360 : pparam = &(*pparam)->next;
3545 : }
3546 :
3547 90 : *pparam = param;
3548 90 : tdsdump_log(TDS_DBG_INFO1, " ct_param() added rpc parameter %s \n", (*param).name);
3549 : return CS_SUCCEED;
3550 : break;
3551 :
3552 180 : case CS_LANG_CMD:
3553 : /* only accept CS_INPUTVALUE as the status */
3554 180 : if (CS_INPUTVALUE != datafmt->status) {
3555 0 : tdsdump_log(TDS_DBG_ERROR, "illegal datafmt->status(%d) passed to ct_param()\n", datafmt->status);
3556 : return CS_FAIL;
3557 : }
3558 :
3559 180 : param = tds_new0(CSREMOTE_PROC_PARAM, 1);
3560 180 : if (!param)
3561 : return CS_FAIL;
3562 :
3563 180 : if (CS_SUCCEED != _ct_fill_param(cmd->command_type, param, datafmt, data, &datalen, &indicator, 1)) {
3564 0 : free(param);
3565 0 : return CS_FAIL;
3566 : }
3567 :
3568 180 : pparam = &cmd->input_params;
3569 810 : while (*pparam)
3570 450 : pparam = &(*pparam)->next;
3571 180 : *pparam = param;
3572 :
3573 180 : tdsdump_log(TDS_DBG_INFO1, "ct_param() added input value\n");
3574 : return CS_SUCCEED;
3575 : break;
3576 :
3577 0 : case CS_DYNAMIC_CMD:
3578 0 : if (!cmd->dyn) {
3579 0 : tdsdump_log(TDS_DBG_INFO1, "cmd->dyn is NULL ct_param\n");
3580 : return CS_FAIL;
3581 : }
3582 :
3583 0 : param = tds_new0(CS_DYNAMIC_PARAM, 1);
3584 0 : if (!param)
3585 : return CS_FAIL;
3586 :
3587 0 : if (CS_SUCCEED != _ct_fill_param(cmd->command_type, param, datafmt, data, &datalen, &indicator, 1)) {
3588 0 : tdsdump_log(TDS_DBG_INFO1, "ct_param() failed to add CS_DYNAMIC param\n");
3589 0 : free(param);
3590 0 : return CS_FAIL;
3591 : }
3592 :
3593 0 : dyn = cmd->dyn;
3594 0 : pparam = &dyn->param_list;
3595 0 : while (*pparam) {
3596 0 : pparam = &(*pparam)->next;
3597 : }
3598 :
3599 0 : *pparam = param;
3600 0 : return CS_SUCCEED;
3601 : break;
3602 : }
3603 : return CS_FAIL;
3604 : }
3605 :
3606 : CS_RETCODE
3607 96 : ct_setparam(CS_COMMAND * cmd, CS_DATAFMT * datafmt_arg, CS_VOID * data, CS_INT * datalen, CS_SMALLINT * indicator)
3608 : {
3609 : CSREMOTE_PROC *rpc;
3610 : CS_PARAM **pparam;
3611 : CS_PARAM *param;
3612 : CS_DYNAMIC *dyn;
3613 : const CS_DATAFMT_LARGE *datafmt;
3614 : CS_DATAFMT_LARGE datafmt_buf;
3615 :
3616 96 : tdsdump_log(TDS_DBG_FUNC, "ct_setparam(%p, %p, %p, %p, %p)\n", cmd, datafmt_arg, data, datalen, indicator);
3617 :
3618 96 : if (!cmd || !cmd->con)
3619 : return CS_FAIL;
3620 :
3621 96 : datafmt = _ct_datafmt_conv_in(cmd->con->ctx, datafmt_arg, &datafmt_buf);
3622 :
3623 : /* Code changed for RPC functionality - SUHA */
3624 : /* RPC code changes starts here */
3625 :
3626 96 : tdsdump_log(TDS_DBG_FUNC, "ct_setparam() command type = %d, data type = %d\n", cmd->command_type, datafmt->datatype);
3627 :
3628 96 : switch (cmd->command_type) {
3629 :
3630 76 : case CS_RPC_CMD:
3631 :
3632 76 : if (!cmd->rpc) {
3633 0 : tdsdump_log(TDS_DBG_ERROR, "RPC is NULL in ct_setparam\n");
3634 : return CS_FAIL;
3635 : }
3636 :
3637 76 : param = tds_new0(CSREMOTE_PROC_PARAM, 1);
3638 76 : if (!param)
3639 : return CS_FAIL;
3640 :
3641 76 : if (CS_SUCCEED != _ct_fill_param(cmd->command_type, param, datafmt, data, datalen, indicator, 0)) {
3642 0 : tdsdump_log(TDS_DBG_INFO1, "ct_setparam() failed to add rpc param\n");
3643 0 : tdsdump_log(TDS_DBG_INFO1, "ct_setparam() failed to add input value\n");
3644 0 : free(param);
3645 0 : return CS_FAIL;
3646 : }
3647 :
3648 76 : rpc = cmd->rpc;
3649 76 : pparam = &rpc->param_list;
3650 76 : tdsdump_log(TDS_DBG_INFO1, " ct_setparam() reached here\n");
3651 76 : if (*pparam != NULL) {
3652 210 : while ((*pparam)->next != NULL) {
3653 150 : pparam = &(*pparam)->next;
3654 : }
3655 :
3656 60 : pparam = &(*pparam)->next;
3657 : }
3658 76 : *pparam = param;
3659 76 : param->next = NULL;
3660 76 : tdsdump_log(TDS_DBG_INFO1, " ct_setparam() added parameter %s \n", (*param).name);
3661 : return CS_SUCCEED;
3662 : break;
3663 :
3664 20 : case CS_DYNAMIC_CMD :
3665 :
3666 20 : if (!cmd->dyn) {
3667 0 : tdsdump_log(TDS_DBG_ERROR, "cmd->dyn is NULL in ct_setparam\n");
3668 : return CS_FAIL;
3669 : }
3670 :
3671 20 : param = tds_new0(CS_DYNAMIC_PARAM, 1);
3672 20 : if (!param)
3673 : return CS_FAIL;
3674 :
3675 20 : if (CS_SUCCEED != _ct_fill_param(cmd->command_type, param, datafmt, data, datalen, indicator, 0)) {
3676 0 : tdsdump_log(TDS_DBG_INFO1, "ct_setparam() failed to add dynamic param\n");
3677 0 : free(param);
3678 0 : return CS_FAIL;
3679 : }
3680 :
3681 20 : dyn = cmd->dyn;
3682 20 : pparam = &dyn->param_list;
3683 20 : if (*pparam != NULL) {
3684 0 : while ((*pparam)->next != NULL) {
3685 0 : pparam = &(*pparam)->next;
3686 : }
3687 :
3688 0 : pparam = &(*pparam)->next;
3689 : }
3690 20 : *pparam = param;
3691 20 : param->next = NULL;
3692 20 : tdsdump_log(TDS_DBG_INFO1, "ct_setparam() added dynamic parameter\n");
3693 : return CS_SUCCEED;
3694 : break;
3695 :
3696 0 : case CS_LANG_CMD:
3697 :
3698 : /* only accept CS_INPUTVALUE as the status */
3699 0 : if (CS_INPUTVALUE != datafmt->status) {
3700 0 : tdsdump_log(TDS_DBG_ERROR, "illegal datafmt->status(%d) passed to ct_setparam()\n", datafmt->status);
3701 : return CS_FAIL;
3702 : }
3703 :
3704 0 : param = tds_new0(CSREMOTE_PROC_PARAM, 1);
3705 0 : if (!param)
3706 : return CS_FAIL;
3707 :
3708 0 : if (CS_SUCCEED != _ct_fill_param(cmd->command_type, param, datafmt, data, datalen, indicator, 0)) {
3709 0 : tdsdump_log(TDS_DBG_INFO1, "ct_setparam() failed to add language param\n");
3710 0 : free(param);
3711 0 : return CS_FAIL;
3712 : }
3713 :
3714 0 : if (!cmd->input_params) {
3715 0 : cmd->input_params = param;
3716 : } else {
3717 0 : pparam = &cmd->input_params;
3718 0 : while ((*pparam)->next)
3719 0 : pparam = &(*pparam)->next;
3720 0 : (*pparam)->next = param;
3721 : }
3722 0 : tdsdump_log(TDS_DBG_INFO1, "ct_setparam() added language parameter\n");
3723 : return CS_SUCCEED;
3724 : break;
3725 : }
3726 : return CS_FAIL;
3727 : }
3728 :
3729 : CS_RETCODE
3730 80 : ct_options(CS_CONNECTION * con, CS_INT action, CS_INT option, CS_VOID * param, CS_INT paramlen, CS_INT * outlen)
3731 : {
3732 : TDS_OPTION_CMD tds_command;
3733 80 : TDS_OPTION tds_option = 0;
3734 : TDS_OPTION_ARG tds_argument;
3735 80 : TDS_INT tds_argsize = 0;
3736 : TDSSOCKET *tds;
3737 :
3738 80 : const char *action_string = NULL;
3739 : int i;
3740 :
3741 : /* boolean options can all be treated the same way */
3742 : static const struct TDS_BOOL_OPTION_MAP
3743 : {
3744 : CS_INT option;
3745 : TDS_OPTION tds_option;
3746 : } tds_bool_option_map[] = {
3747 : { CS_OPT_ANSINULL, TDS_OPT_ANSINULL }
3748 : , { CS_OPT_CHAINXACTS, TDS_OPT_CHAINXACTS }
3749 : , { CS_OPT_CURCLOSEONXACT, TDS_OPT_CURCLOSEONXACT }
3750 : , { CS_OPT_FIPSFLAG, TDS_OPT_FIPSFLAG }
3751 : , { CS_OPT_FORCEPLAN, TDS_OPT_FORCEPLAN }
3752 : , { CS_OPT_FORMATONLY, TDS_OPT_FORMATONLY }
3753 : , { CS_OPT_GETDATA, TDS_OPT_GETDATA }
3754 : , { CS_OPT_NOCOUNT, TDS_OPT_NOCOUNT }
3755 : , { CS_OPT_NOEXEC, TDS_OPT_NOEXEC }
3756 : , { CS_OPT_PARSEONLY, TDS_OPT_PARSEONLY }
3757 : , { CS_OPT_QUOTED_IDENT, TDS_OPT_QUOTED_IDENT }
3758 : , { CS_OPT_RESTREES, TDS_OPT_RESTREES }
3759 : , { CS_OPT_SHOWPLAN, TDS_OPT_SHOWPLAN }
3760 : , { CS_OPT_STATS_IO, TDS_OPT_STAT_IO }
3761 : , { CS_OPT_STATS_TIME, TDS_OPT_STAT_TIME }
3762 : , { CS_OPT_ARITHIGNORE, TDS_OPT_ARITHIGNOREON }
3763 : , { CS_OPT_ARITHABORT, TDS_OPT_ARITHABORTON }
3764 : };
3765 :
3766 80 : tdsdump_log(TDS_DBG_FUNC, "ct_options(%p, %d, %d, %p, %d, %p)\n", con, action, option, param, paramlen, outlen);
3767 :
3768 80 : if (!param)
3769 : return CS_FAIL;
3770 :
3771 80 : if (!con || !(tds=con->tds_socket))
3772 : return CS_FAIL;
3773 :
3774 : /*
3775 : * Set the tds command
3776 : */
3777 80 : switch (action) {
3778 : case CS_GET:
3779 : tds_command = TDS_OPT_LIST; /* will be acknowledged by TDS_OPT_INFO */
3780 : action_string = "CS_GET";
3781 : tds_argsize = 0;
3782 : break;
3783 40 : case CS_SET:
3784 40 : tds_command = TDS_OPT_SET;
3785 40 : action_string = "CS_SET";
3786 40 : break;
3787 0 : case CS_CLEAR:
3788 0 : tds_command = TDS_OPT_DEFAULT;
3789 0 : action_string = "CS_CLEAR";
3790 0 : tds_argsize = 0;
3791 0 : break;
3792 0 : default:
3793 0 : tdsdump_log(TDS_DBG_FUNC, "ct_options: invalid action = %d\n", action);
3794 : return CS_FAIL;
3795 : }
3796 :
3797 : assert(tds_command && action_string);
3798 :
3799 80 : tdsdump_log(TDS_DBG_FUNC, "ct_options: %s, option = %d\n", action_string, option);
3800 :
3801 : /*
3802 : * Set the tds option
3803 : * The following TDS options apparently cannot be set with this function.
3804 : * TDS_OPT_CHARSET
3805 : * TDS_OPT_CURREAD
3806 : * TDS_OPT_IDENTITYOFF
3807 : * TDS_OPT_IDENTITYON
3808 : * TDS_OPT_CURWRITE
3809 : * TDS_OPT_NATLANG
3810 : * TDS_OPT_ROWCOUNT
3811 : */
3812 :
3813 : /*
3814 : * First, take care of the easy cases, the booleans.
3815 : */
3816 1560 : for (i = 0; i < TDS_VECTOR_SIZE(tds_bool_option_map); i++) {
3817 740 : if (tds_bool_option_map[i].option != option)
3818 700 : continue;
3819 :
3820 40 : tds_option = tds_bool_option_map[i].tds_option;
3821 40 : if (action == CS_SET) {
3822 20 : switch (*(CS_BOOL *) param) {
3823 20 : case CS_TRUE:
3824 20 : tds_argument.ti = 1;
3825 20 : break;
3826 0 : case CS_FALSE:
3827 0 : tds_argument.ti = 0;
3828 0 : break;
3829 : default:
3830 : return CS_FAIL;
3831 : }
3832 : tds_argsize = 1;
3833 : }
3834 40 : if (action == CS_GET) {
3835 20 : tds_argsize = 0;
3836 : }
3837 : goto SEND_OPTION;
3838 : }
3839 :
3840 : /*
3841 : * Non-booleans are more complicated.
3842 : */
3843 40 : switch (option) {
3844 0 : case CS_OPT_ANSIPERM:
3845 : case CS_OPT_STR_RTRUNC:
3846 : /* no documented tds option */
3847 0 : switch (*(CS_BOOL *) param) {
3848 : case CS_TRUE:
3849 : case CS_FALSE:
3850 : break; /* end valid choices */
3851 0 : default:
3852 0 : if (action == CS_SET)
3853 : return CS_FAIL;
3854 : }
3855 : break;
3856 0 : case CS_OPT_AUTHOFF:
3857 0 : tds_option = TDS_OPT_AUTHOFF;
3858 0 : tds_argument.c = (TDS_CHAR *) param;
3859 0 : tds_argsize = (action == CS_SET) ? paramlen : 0;
3860 : break;
3861 0 : case CS_OPT_AUTHON:
3862 0 : tds_option = TDS_OPT_AUTHON;
3863 0 : tds_argument.c = (TDS_CHAR *) param;
3864 0 : tds_argsize = (action == CS_SET) ? paramlen : 0;
3865 : break;
3866 :
3867 20 : case CS_OPT_DATEFIRST:
3868 20 : tds_option = TDS_OPT_DATEFIRST;
3869 20 : switch (*(CS_INT *) param) {
3870 0 : case CS_OPT_SUNDAY:
3871 0 : tds_argument.ti = TDS_OPT_SUNDAY;
3872 0 : break;
3873 0 : case CS_OPT_MONDAY:
3874 0 : tds_argument.ti = TDS_OPT_MONDAY;
3875 0 : break;
3876 0 : case CS_OPT_TUESDAY:
3877 0 : tds_argument.ti = TDS_OPT_TUESDAY;
3878 0 : break;
3879 10 : case CS_OPT_WEDNESDAY:
3880 10 : tds_argument.ti = TDS_OPT_WEDNESDAY;
3881 10 : break;
3882 0 : case CS_OPT_THURSDAY:
3883 0 : tds_argument.ti = TDS_OPT_THURSDAY;
3884 0 : break;
3885 0 : case CS_OPT_FRIDAY:
3886 0 : tds_argument.ti = TDS_OPT_FRIDAY;
3887 0 : break;
3888 0 : case CS_OPT_SATURDAY:
3889 0 : tds_argument.ti = TDS_OPT_SATURDAY;
3890 0 : break;
3891 10 : default:
3892 10 : if (action == CS_SET)
3893 : return CS_FAIL;
3894 : }
3895 20 : tds_argsize = (action == CS_SET) ? 1 : 0;
3896 20 : break;
3897 20 : case CS_OPT_DATEFORMAT:
3898 20 : tds_option = TDS_OPT_DATEFORMAT;
3899 20 : switch (*(CS_INT *) param) {
3900 0 : case CS_OPT_FMTMDY:
3901 0 : tds_argument.ti = TDS_OPT_FMTMDY;
3902 0 : break;
3903 0 : case CS_OPT_FMTDMY:
3904 0 : tds_argument.ti = TDS_OPT_FMTDMY;
3905 0 : break;
3906 0 : case CS_OPT_FMTYMD:
3907 0 : tds_argument.ti = TDS_OPT_FMTYMD;
3908 0 : break;
3909 0 : case CS_OPT_FMTYDM:
3910 0 : tds_argument.ti = TDS_OPT_FMTYDM;
3911 0 : break;
3912 10 : case CS_OPT_FMTMYD:
3913 10 : tds_argument.ti = TDS_OPT_FMTMYD;
3914 10 : break;
3915 0 : case CS_OPT_FMTDYM:
3916 0 : tds_argument.ti = TDS_OPT_FMTDYM;
3917 0 : break;
3918 10 : default:
3919 10 : if (action == CS_SET)
3920 : return CS_FAIL;
3921 : }
3922 20 : tds_argsize = (action == CS_SET) ? 1 : 0;
3923 20 : break;
3924 0 : case CS_OPT_ISOLATION:
3925 0 : tds_option = TDS_OPT_ISOLATION;
3926 0 : switch (*(char *) param) {
3927 0 : case CS_OPT_LEVEL0: /* CS_OPT_LEVEL0 requires SQL Server version 11.0 or later or Adaptive Server. */
3928 0 : tds_argument.ti = TDS_OPT_LEVEL0;
3929 0 : break;
3930 0 : case CS_OPT_LEVEL1:
3931 0 : tds_argument.ti = TDS_OPT_LEVEL1;
3932 0 : break;
3933 0 : case CS_OPT_LEVEL2:
3934 0 : tds_argument.ti = TDS_OPT_LEVEL2;
3935 0 : break;
3936 0 : case CS_OPT_LEVEL3:
3937 0 : tds_argument.ti = TDS_OPT_LEVEL3;
3938 0 : break;
3939 0 : default:
3940 0 : if (action == CS_SET)
3941 : return CS_FAIL;
3942 : }
3943 0 : tds_argsize = (action == CS_SET) ? 1 : 0;
3944 0 : break;
3945 0 : case CS_OPT_TEXTSIZE:
3946 0 : tds_option = TDS_OPT_TEXTSIZE;
3947 0 : tds_argument.i = *(CS_INT *) param;
3948 0 : tds_argsize = (action == CS_SET) ? sizeof(tds_argument.i) : 0;
3949 : break;
3950 0 : case CS_OPT_TRUNCIGNORE:
3951 0 : tds_option = TDS_OPT_TRUNCABORT; /* note inverted sense */
3952 0 : switch (*(CS_BOOL *) param) {
3953 : case CS_TRUE:
3954 : case CS_FALSE:
3955 : break;
3956 0 : default:
3957 0 : if (action == CS_SET)
3958 : return CS_FAIL;
3959 : }
3960 0 : tds_argument.ti = !*(CS_BOOL *) param;
3961 0 : tds_argsize = (action == CS_SET) ? 1 : 0;
3962 0 : break;
3963 : default:
3964 : return CS_FAIL; /* invalid option */
3965 : }
3966 :
3967 80 : SEND_OPTION:
3968 :
3969 80 : tdsdump_log(TDS_DBG_FUNC, "\ttds_submit_optioncmd will be action(%s) option(%d) arg(%x) arglen(%d)\n",
3970 : action_string, tds_option,
3971 : tds_argsize == 1 ? tds_argument.ti : (tds_argsize == 4 ? tds_argument.i : 0), tds_argsize);
3972 :
3973 80 : if (TDS_FAILED(tds_submit_optioncmd(tds, tds_command, tds_option, &tds_argument, tds_argsize))) {
3974 : return CS_FAIL;
3975 : }
3976 :
3977 80 : if (action == CS_GET) {
3978 40 : switch (option) {
3979 20 : case CS_OPT_ANSINULL :
3980 : case CS_OPT_CHAINXACTS :
3981 : case CS_OPT_CURCLOSEONXACT :
3982 : case CS_OPT_NOCOUNT :
3983 : case CS_OPT_QUOTED_IDENT :
3984 20 : *(CS_BOOL *)param = tds->option_value;
3985 20 : break;
3986 10 : case CS_OPT_DATEFIRST:
3987 10 : switch (tds->option_value) {
3988 0 : case TDS_OPT_SUNDAY: *(CS_INT *)param = CS_OPT_SUNDAY; break;
3989 0 : case TDS_OPT_MONDAY: *(CS_INT *)param = CS_OPT_MONDAY; break;
3990 0 : case TDS_OPT_TUESDAY: *(CS_INT *)param = CS_OPT_TUESDAY; break;
3991 10 : case TDS_OPT_WEDNESDAY: *(CS_INT *)param = CS_OPT_WEDNESDAY; break;
3992 0 : case TDS_OPT_THURSDAY: *(CS_INT *)param = CS_OPT_THURSDAY; break;
3993 0 : case TDS_OPT_FRIDAY: *(CS_INT *)param = CS_OPT_FRIDAY; break;
3994 0 : case TDS_OPT_SATURDAY: *(CS_INT *)param = CS_OPT_SATURDAY; break;
3995 : default: return CS_FAIL;
3996 : }
3997 : break;
3998 10 : case CS_OPT_DATEFORMAT:
3999 10 : switch (tds->option_value) {
4000 0 : case TDS_OPT_FMTDMY: *(CS_INT *)param = CS_OPT_FMTDMY; break;
4001 0 : case TDS_OPT_FMTDYM: *(CS_INT *)param = CS_OPT_FMTDYM; break;
4002 0 : case TDS_OPT_FMTMDY: *(CS_INT *)param = CS_OPT_FMTMDY; break;
4003 10 : case TDS_OPT_FMTMYD: *(CS_INT *)param = CS_OPT_FMTMYD; break;
4004 0 : case TDS_OPT_FMTYMD: *(CS_INT *)param = CS_OPT_FMTYMD; break;
4005 0 : case TDS_OPT_FMTYDM: *(CS_INT *)param = CS_OPT_FMTYDM; break;
4006 : default: return CS_FAIL;
4007 : }
4008 : break;
4009 0 : case CS_OPT_ARITHABORT :
4010 : case CS_OPT_ARITHIGNORE :
4011 0 : *(CS_BOOL *)param = tds->option_value;
4012 0 : break;
4013 : case CS_OPT_TRUNCIGNORE :
4014 : break;
4015 : }
4016 : }
4017 :
4018 : return CS_SUCCEED;
4019 : } /* end ct_options() */
4020 :
4021 : CS_RETCODE
4022 0 : ct_poll(CS_CONTEXT * ctx, CS_CONNECTION * connection, CS_INT milliseconds, CS_CONNECTION ** compconn, CS_COMMAND ** compcmd,
4023 : CS_INT * compid, CS_INT * compstatus)
4024 : {
4025 0 : tdsdump_log(TDS_DBG_FUNC, "UNIMPLEMENTED ct_poll()\n");
4026 0 : tdsdump_log(TDS_DBG_FUNC, "ct_poll(%p, %p, %d, %p, %p, %p, %p)\n",
4027 : ctx, connection, milliseconds, compconn, compcmd, compid, compstatus);
4028 :
4029 0 : return CS_FAIL;
4030 : }
4031 :
4032 : static CS_RETCODE
4033 350 : _ct_cursor_no_name_text(CS_COMMAND * cmd, const char *funcname, CS_CHAR * name, CS_INT namelen, CS_CHAR * text, CS_INT tlen)
4034 : {
4035 350 : if (name != NULL) {
4036 50 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 8, "%s", "name");
4037 : return CS_FAIL;
4038 : }
4039 300 : if (namelen != CS_UNUSED) {
4040 40 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 9, "%s", "namelen");
4041 : return CS_FAIL;
4042 : }
4043 260 : if (text != NULL) {
4044 40 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 8, "%s", "text");
4045 : return CS_FAIL;
4046 : }
4047 220 : if (tlen != CS_UNUSED) {
4048 40 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 9, "%s", "tlen");
4049 : return CS_FAIL;
4050 : }
4051 : return CS_SUCCEED;
4052 : }
4053 :
4054 : static const char*
4055 680 : get_next_tok(const char* str, size_t *tok_len)
4056 : {
4057 : static const char delimiter[] = "\n\t,.[]() /-";
4058 :
4059 1880 : while (*str) {
4060 1120 : switch (str[0]) {
4061 : /* handle quoted strings/identifiers */
4062 0 : case '\'':
4063 : case '\"':
4064 : case '[':
4065 0 : *tok_len = tds_skip_quoted(str) - str;
4066 0 : return str;
4067 : /* skip comments */
4068 30 : case '-':
4069 : case '/':
4070 30 : str = tds_skip_comment(str);
4071 30 : continue;
4072 : /* skip delimiters */
4073 490 : case '\n':
4074 : case '\t':
4075 : case ' ':
4076 : case ',':
4077 : case '.':
4078 : case '(':
4079 : case ')':
4080 490 : ++str;
4081 490 : continue;
4082 : }
4083 :
4084 600 : if ((*tok_len = strcspn(str, delimiter)) == 0)
4085 : return NULL;
4086 600 : return str;
4087 : }
4088 : return NULL;
4089 : }
4090 :
4091 : static bool
4092 110 : query_has_for_update(const char *query)
4093 : {
4094 : enum {
4095 : tok_baseline,
4096 : tok_for,
4097 110 : } state = tok_baseline;
4098 : size_t tok_len;
4099 :
4100 110 : const char* tok = get_next_tok(query, &tok_len);
4101 790 : while (tok != NULL) {
4102 600 : if (tok_len == 3 && strncasecmp(tok, "FOR", 3) == 0) {
4103 : state = tok_for;
4104 560 : } else if (state == tok_for && tok_len == 6 && strncasecmp(tok, "UPDATE", 6) == 0) {
4105 : return true;
4106 : } else {
4107 : state = tok_baseline;
4108 : }
4109 :
4110 570 : tok = get_next_tok(tok + tok_len, &tok_len);
4111 : }
4112 : return false;
4113 : }
4114 :
4115 : CS_RETCODE
4116 430 : ct_cursor(CS_COMMAND * cmd, CS_INT type, CS_CHAR * name, CS_INT namelen, CS_CHAR * text, CS_INT tlen, CS_INT option)
4117 : {
4118 : TDSSOCKET *tds;
4119 : TDSCURSOR *cursor;
4120 : const char *funcname;
4121 : CS_RETCODE ret;
4122 :
4123 430 : tdsdump_log(TDS_DBG_FUNC, "ct_cursor(%p, %d, %p, %d, %p, %d, %d)\n", cmd, type, name, namelen, text, tlen, option);
4124 :
4125 430 : if (!cmd || !cmd->con || !cmd->con->tds_socket)
4126 : return CS_FAIL;
4127 :
4128 430 : tds = cmd->con->tds_socket;
4129 430 : cmd->command_type = CS_CUR_CMD;
4130 :
4131 430 : tdsdump_log(TDS_DBG_FUNC, "ct_cursor() : type = %d \n", type);
4132 :
4133 430 : switch (type) {
4134 80 : case CS_CURSOR_DECLARE:
4135 :
4136 80 : funcname = "ct_cursor(DECLARE)";
4137 80 : namelen = _ct_get_string_length(name, namelen);
4138 80 : if (namelen < 0) {
4139 20 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 5, "%d, %s", namelen, "namelen");
4140 20 : return CS_FAIL;
4141 : }
4142 60 : tlen = _ct_get_string_length(text, tlen);
4143 60 : if (tlen < 0) {
4144 10 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 5, "%d, %s", tlen, "tlen");
4145 10 : return CS_FAIL;
4146 : }
4147 50 : cursor = tds_alloc_cursor(tds, name, (CS_UINT) namelen, text, (CS_UINT) tlen);
4148 50 : if (!cursor)
4149 : return CS_FAIL;
4150 :
4151 50 : cursor->cursor_rows = 1;
4152 50 : cursor->options = option;
4153 50 : cursor->status.declare = TDS_CURSOR_STATE_REQUESTED;
4154 50 : cursor->status.cursor_row = TDS_CURSOR_STATE_UNACTIONED;
4155 50 : cursor->status.open = TDS_CURSOR_STATE_UNACTIONED;
4156 50 : cursor->status.fetch = TDS_CURSOR_STATE_UNACTIONED;
4157 50 : cursor->status.close = TDS_CURSOR_STATE_UNACTIONED;
4158 50 : cursor->status.dealloc = TDS_CURSOR_STATE_UNACTIONED;
4159 :
4160 50 : if (option == CS_UNUSED || (option & CS_END) != 0) {
4161 : /* Try to figure out type of the cursor. */
4162 50 : if (query_has_for_update(cursor->query)) {
4163 0 : cursor->type = TDS_CUR_TYPE_FORWARD; /* Forward-only cursor. */
4164 : } else {
4165 : /* readonly */
4166 50 : cursor->type = TDS_CUR_TYPE_KEYSET;
4167 : /* Keyset-driven cursor. Default value. */
4168 : }
4169 0 : } else if ((option & CS_FOR_UPDATE) != 0) {
4170 0 : cursor->type = TDS_CUR_TYPE_FORWARD; /* Forward-only cursor. */
4171 : } else {
4172 0 : cursor->type = TDS_CUR_TYPE_KEYSET;
4173 : /* Keyset-driven cursor. Default value. */
4174 : }
4175 :
4176 50 : cursor->concurrency =
4177 : TDS_CUR_CONCUR_ALLOW_DIRECT | TDS_CUR_CONCUR_OPTIMISTIC;
4178 : /* Optimistic. Checks timestamps if available, else values. */
4179 :
4180 50 : tds_release_cursor(&cmd->cursor);
4181 50 : cmd->cursor = cursor;
4182 50 : ct_set_command_state(cmd, _CS_COMMAND_READY);
4183 50 : return CS_SUCCEED;
4184 : break;
4185 :
4186 100 : case CS_CURSOR_ROWS:
4187 :
4188 100 : funcname = "ct_cursor(ROWS)";
4189 :
4190 100 : ret = _ct_cursor_no_name_text(cmd, funcname, name, namelen, text, tlen);
4191 100 : if (ret != CS_SUCCEED)
4192 : return ret;
4193 :
4194 50 : cursor = cmd->cursor;
4195 50 : if (!cursor) {
4196 10 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 18, "");
4197 10 : return CS_FAIL;
4198 : }
4199 :
4200 40 : if (cursor->status.declare == _CS_CURS_TYPE_REQUESTED ||
4201 : cursor->status.declare == _CS_CURS_TYPE_SENT) {
4202 :
4203 40 : cursor->cursor_rows = option;
4204 40 : cursor->status.cursor_row = TDS_CURSOR_STATE_REQUESTED;
4205 :
4206 40 : ct_set_command_state(cmd, _CS_COMMAND_READY);
4207 40 : return CS_SUCCEED;
4208 : } else {
4209 0 : cursor->status.cursor_row = TDS_CURSOR_STATE_UNACTIONED;
4210 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cursor() : cursor not declared\n");
4211 : return CS_FAIL;
4212 : }
4213 : break;
4214 :
4215 80 : case CS_CURSOR_OPEN:
4216 :
4217 80 : funcname = "ct_cursor(OPEN)";
4218 :
4219 80 : ret = _ct_cursor_no_name_text(cmd, funcname, name, namelen, text, tlen);
4220 80 : if (ret != CS_SUCCEED)
4221 : return ret;
4222 :
4223 40 : cursor = cmd->cursor;
4224 40 : if (!cursor) {
4225 0 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 18, "");
4226 0 : return CS_FAIL;
4227 : }
4228 :
4229 40 : if (cursor->status.declare == _CS_CURS_TYPE_REQUESTED ||
4230 : cursor->status.declare == _CS_CURS_TYPE_SENT ) {
4231 :
4232 40 : cursor->status.open = TDS_CURSOR_STATE_REQUESTED;
4233 :
4234 40 : return CS_SUCCEED;
4235 : ct_set_command_state(cmd, _CS_COMMAND_READY);
4236 : } else {
4237 0 : cursor->status.open = TDS_CURSOR_STATE_UNACTIONED;
4238 0 : tdsdump_log(TDS_DBG_FUNC, "ct_cursor() : cursor not declared\n");
4239 : return CS_FAIL;
4240 : }
4241 :
4242 : break;
4243 :
4244 90 : case CS_CURSOR_CLOSE:
4245 :
4246 90 : funcname = "ct_cursor(CLOSE)";
4247 :
4248 90 : ret = _ct_cursor_no_name_text(cmd, funcname, name, namelen, text, tlen);
4249 90 : if (ret != CS_SUCCEED)
4250 : return ret;
4251 :
4252 50 : cursor = cmd->cursor;
4253 50 : if (!cursor) {
4254 10 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 171, "");
4255 10 : return CS_FAIL;
4256 : }
4257 :
4258 40 : cursor->status.cursor_row = TDS_CURSOR_STATE_UNACTIONED;
4259 40 : cursor->status.open = TDS_CURSOR_STATE_UNACTIONED;
4260 40 : cursor->status.fetch = TDS_CURSOR_STATE_UNACTIONED;
4261 40 : cursor->status.close = TDS_CURSOR_STATE_REQUESTED;
4262 40 : if (option == CS_DEALLOC) {
4263 10 : cursor->status.dealloc = TDS_CURSOR_STATE_REQUESTED;
4264 : }
4265 40 : ct_set_command_state(cmd, _CS_COMMAND_READY);
4266 40 : return CS_SUCCEED;
4267 :
4268 80 : case CS_CURSOR_DEALLOC:
4269 :
4270 80 : funcname = "ct_cursor(DEALLOC)";
4271 :
4272 80 : ret = _ct_cursor_no_name_text(cmd, funcname, name, namelen, text, tlen);
4273 80 : if (ret != CS_SUCCEED)
4274 : return ret;
4275 :
4276 40 : cursor = cmd->cursor;
4277 40 : if (!cursor) {
4278 10 : _ctclient_msg(NULL, cmd->con, funcname, 1, 1, 1, 18, "");
4279 10 : return CS_FAIL;
4280 : }
4281 30 : cursor->status.dealloc = TDS_CURSOR_STATE_REQUESTED;
4282 30 : ct_set_command_state(cmd, _CS_COMMAND_READY);
4283 30 : return CS_SUCCEED;
4284 :
4285 0 : case CS_IMPLICIT_CURSOR:
4286 0 : tdsdump_log(TDS_DBG_INFO1, "CS_IMPLICIT_CURSOR: Option not implemented\n");
4287 : return CS_FAIL;
4288 0 : case CS_CURSOR_OPTION:
4289 0 : tdsdump_log(TDS_DBG_INFO1, "CS_CURSOR_OPTION: Option not implemented\n");
4290 : return CS_FAIL;
4291 0 : case CS_CURSOR_UPDATE:
4292 0 : tdsdump_log(TDS_DBG_INFO1, "CS_CURSOR_UPDATE: Option not implemented\n");
4293 : return CS_FAIL;
4294 0 : case CS_CURSOR_DELETE:
4295 0 : tdsdump_log(TDS_DBG_INFO1, "CS_CURSOR_DELETE: Option not implemented\n");
4296 : return CS_FAIL;
4297 :
4298 : }
4299 :
4300 : return CS_FAIL;
4301 : }
4302 :
4303 : static int
4304 0 : _ct_fetchable_results(CS_COMMAND * cmd)
4305 : {
4306 0 : tdsdump_log(TDS_DBG_FUNC, "_ct_fetchable_results(%p)\n", cmd);
4307 :
4308 0 : switch (cmd->curr_result_type) {
4309 : case CS_COMPUTE_RESULT:
4310 : case CS_CURSOR_RESULT:
4311 : case CS_PARAM_RESULT:
4312 : case CS_ROW_RESULT:
4313 : case CS_STATUS_RESULT:
4314 : return 1;
4315 : }
4316 : return 0;
4317 : }
4318 :
4319 : static TDSRET
4320 72 : _ct_process_return_status(TDSSOCKET * tds)
4321 : {
4322 : TDSRESULTINFO *info;
4323 : TDSCOLUMN *curcol;
4324 : TDS_INT saved_status;
4325 : TDSRET rc;
4326 :
4327 : enum { num_cols = 1 };
4328 :
4329 72 : tdsdump_log(TDS_DBG_FUNC, "_ct_process_return_status(%p)\n", tds);
4330 :
4331 72 : assert(tds);
4332 72 : saved_status = tds->ret_status;
4333 72 : tds_free_all_results(tds);
4334 :
4335 : /* allocate the columns structure */
4336 72 : tds->res_info = tds_alloc_results(num_cols);
4337 72 : tds_set_current_results(tds, tds->res_info);
4338 :
4339 72 : if (!tds->res_info)
4340 : return TDS_FAIL;
4341 :
4342 72 : info = tds->res_info;
4343 :
4344 72 : curcol = info->columns[0];
4345 :
4346 72 : tds_set_column_type(tds->conn, curcol, SYBINT4);
4347 :
4348 72 : tdsdump_log(TDS_DBG_INFO1, "generating return status row. type = %d(%s), varint_size %d\n",
4349 : curcol->column_type, tds_prtype(curcol->column_type), curcol->column_varint_size);
4350 :
4351 72 : rc = tds_alloc_row(info);
4352 72 : if (TDS_FAILED(rc))
4353 : return rc;
4354 :
4355 72 : assert(curcol->column_data != NULL);
4356 :
4357 72 : *(TDS_INT *) curcol->column_data = saved_status;
4358 :
4359 72 : return TDS_SUCCESS;
4360 : }
4361 :
4362 : /* Code added for RPC functionality - SUHA */
4363 : /* RPC code changes starts here */
4364 :
4365 : static const unsigned char *
4366 446 : paramrowalloc(TDSPARAMINFO * params, TDSCOLUMN * curcol, int param_num, void *value, int size)
4367 : {
4368 446 : const void *row = tds_alloc_param_data(curcol);
4369 :
4370 446 : tdsdump_log(TDS_DBG_INFO1, "paramrowalloc, size = %d, data = %p, row_size = %d\n",
4371 : size, curcol->column_data, params->row_size);
4372 446 : if (!row)
4373 : return NULL;
4374 :
4375 446 : if (value) {
4376 : /* TODO check for BLOB and numeric */
4377 376 : if (size > curcol->column_size) {
4378 0 : tdsdump_log(TDS_DBG_FUNC, "paramrowalloc(): RESIZE %d to %d\n", size, curcol->column_size);
4379 0 : size = curcol->column_size;
4380 : }
4381 : /* TODO blobs */
4382 376 : if (!is_blob_col(curcol))
4383 366 : memcpy(curcol->column_data, value, size);
4384 : else {
4385 10 : TDSBLOB *blob = (TDSBLOB *) curcol->column_data;
4386 10 : blob->textvalue = tds_new(TDS_CHAR, size ? size : 1);
4387 10 : tdsdump_log(TDS_DBG_FUNC, "blob parameter supported, size %d textvalue pointer is %p\n",
4388 : size, blob->textvalue);
4389 10 : if (!blob->textvalue)
4390 : return NULL;
4391 10 : memcpy(blob->textvalue, value, size);
4392 : }
4393 376 : curcol->column_cur_size = size;
4394 : } else {
4395 70 : tdsdump_log(TDS_DBG_FUNC, "paramrowalloc(): setting parameter #%d to NULL\n", param_num);
4396 70 : curcol->column_cur_size = -1;
4397 : }
4398 :
4399 : return (const unsigned char*) row;
4400 : }
4401 :
4402 : /**
4403 : * Allocate memory and copy the rpc information into a TDSPARAMINFO structure.
4404 : */
4405 : static TDSPARAMINFO *
4406 146 : paraminfoalloc(TDSSOCKET * tds, CS_PARAM * first_param)
4407 : {
4408 : int i;
4409 : CS_PARAM *p;
4410 : TDSCOLUMN *pcol;
4411 146 : TDSPARAMINFO *params = NULL, *new_params;
4412 :
4413 : int temp_type;
4414 : TDS_SERVER_TYPE tds_type;
4415 :
4416 146 : tdsdump_log(TDS_DBG_FUNC, "paraminfoalloc(%p, %p)\n", tds, first_param);
4417 :
4418 : /* sanity */
4419 146 : if (!first_param)
4420 : return NULL;
4421 :
4422 446 : for (i = 0, p = first_param; p != NULL; p = p->next, i++) {
4423 : const unsigned char *prow;
4424 446 : CS_BYTE *temp_value = NULL;
4425 446 : CS_INT temp_datalen = 0;
4426 :
4427 446 : if (!(new_params = tds_alloc_param_result(params)))
4428 : goto memory_error;
4429 446 : params = new_params;
4430 :
4431 : /*
4432 : * The parameteter data has been passed by reference
4433 : * i.e. using ct_setparam rather than ct_param
4434 : */
4435 446 : temp_type = p->datatype;
4436 446 : tds_type = _ct_get_server_type(tds, p->datatype);
4437 446 : if (tds_type == TDS_INVALID_TYPE)
4438 : goto type_error;
4439 446 : if (p->param_by_value == 0) {
4440 :
4441 : /*
4442 : * there are three ways to indicate null parameters
4443 : * 1) *ind == -1
4444 : * 2) *datalen == 0
4445 : * 3) value, datalen and ind as NULL. Here value == NULL is
4446 : * sufficient
4447 : */
4448 176 : if (*(p->ind) != -1 && p->value != NULL && *(p->datalen) != 0) {
4449 : /* datafmt.datalen is ignored for fixed length types */
4450 136 : if (is_fixed_type(tds_type)) {
4451 110 : temp_datalen = tds_get_size_by_type(tds_type);
4452 : } else {
4453 26 : temp_datalen = (*(p->datalen) == CS_UNUSED) ? 0 : *(p->datalen);
4454 : }
4455 :
4456 136 : temp_value = p->value;
4457 : }
4458 : } else {
4459 270 : temp_value = p->value;
4460 270 : temp_datalen = *(p->datalen);
4461 : }
4462 :
4463 446 : if (temp_type == CS_VARCHAR_TYPE || temp_type == CS_VARBINARY_TYPE) {
4464 10 : CS_VARCHAR *vc = (CS_VARCHAR *) temp_value;
4465 :
4466 10 : if (vc) {
4467 0 : temp_datalen = vc->len;
4468 0 : temp_value = (CS_BYTE *) vc->str;
4469 : }
4470 : }
4471 :
4472 446 : pcol = params->columns[i];
4473 :
4474 : /* meta data */
4475 446 : if (p->name)
4476 296 : if (!tds_dstr_copy(&pcol->column_name, p->name))
4477 : goto memory_error;
4478 :
4479 446 : tds_set_param_type(tds->conn, pcol, tds_type);
4480 :
4481 446 : if (temp_datalen == CS_NULLTERM && temp_value)
4482 0 : temp_datalen = strlen((const char*) temp_value);
4483 :
4484 446 : pcol->column_prec = p->precision;
4485 446 : pcol->column_scale = p->scale;
4486 446 : if (pcol->column_varint_size) {
4487 444 : if (p->maxlen < 0) {
4488 0 : tds_free_param_results(params);
4489 0 : return NULL;
4490 : }
4491 444 : pcol->on_server.column_size = pcol->column_size = p->maxlen;
4492 444 : pcol->column_cur_size = temp_value ? temp_datalen : -1;
4493 444 : if (temp_datalen > 0 && temp_datalen > p->maxlen)
4494 6 : pcol->on_server.column_size = pcol->column_size = temp_datalen;
4495 : } else {
4496 2 : pcol->column_cur_size = pcol->column_size;
4497 : }
4498 :
4499 446 : if (p->status == CS_RETURN)
4500 190 : pcol->column_output = 1;
4501 : else
4502 256 : pcol->column_output = 0;
4503 :
4504 : /* actual data */
4505 446 : tdsdump_log(TDS_DBG_FUNC, "paraminfoalloc: status = %d, maxlen %d \n", p->status, p->maxlen);
4506 446 : tdsdump_log(TDS_DBG_FUNC,
4507 : "paraminfoalloc: name = %s, varint size %d "
4508 : "column_type %d size %d, %d column_cur_size %d column_output = %d\n",
4509 : tds_dstr_cstr(&pcol->column_name),
4510 : pcol->column_varint_size, pcol->column_type,
4511 : pcol->on_server.column_size, pcol->column_size,
4512 : pcol->column_cur_size, pcol->column_output);
4513 446 : prow = paramrowalloc(params, pcol, i, temp_value, temp_datalen);
4514 446 : if (!prow)
4515 : goto memory_error;
4516 : }
4517 :
4518 : return params;
4519 :
4520 0 : memory_error:
4521 0 : tdsdump_log(TDS_DBG_SEVERE, "out of memory for rpc!");
4522 0 : _ctclient_msg(NULL, ((CS_CONNECTION*)tds_get_parent(tds)), "paraminfoalloc", 1, 1, 17, 2, "");
4523 0 : type_error:
4524 0 : tds_free_param_results(params);
4525 0 : return NULL;
4526 : }
4527 :
4528 : static void
4529 4368 : rpc_clear(CSREMOTE_PROC * rpc)
4530 : {
4531 4368 : tdsdump_log(TDS_DBG_FUNC, "rpc_clear(%p)\n", rpc);
4532 :
4533 4368 : if (!rpc)
4534 : return;
4535 :
4536 76 : param_clear(rpc->param_list);
4537 :
4538 76 : free(rpc->name);
4539 76 : free(rpc);
4540 : }
4541 :
4542 : /**
4543 : * recursively erase the parameter list
4544 : */
4545 : static void
4546 446 : param_clear(CS_PARAM * pparam)
4547 : {
4548 446 : tdsdump_log(TDS_DBG_FUNC, "param_clear(%p)\n", pparam);
4549 :
4550 446 : if (!pparam)
4551 : return;
4552 :
4553 366 : if (pparam->next) {
4554 290 : param_clear(pparam->next);
4555 290 : pparam->next = NULL;
4556 : }
4557 :
4558 : /* free self after clearing children */
4559 :
4560 366 : free(pparam->name);
4561 366 : if (pparam->param_by_value)
4562 270 : free(pparam->value);
4563 :
4564 : /*
4565 : * DO NOT free datalen or ind, they are just pointer
4566 : * to client data or private structure
4567 : */
4568 :
4569 366 : free(pparam);
4570 : }
4571 :
4572 : /* RPC Code changes ends here */
4573 :
4574 :
4575 : static int
4576 366 : _ct_fill_param(CS_INT cmd_type, CS_PARAM *param,
4577 : const CS_DATAFMT_LARGE *datafmt, CS_VOID *data, CS_INT *p_datalen,
4578 : CS_SMALLINT *indicator, CS_BYTE byvalue)
4579 : {
4580 : TDS_SERVER_TYPE desttype;
4581 :
4582 366 : tdsdump_log(TDS_DBG_FUNC, "_ct_fill_param(%d, %p, %p, %p, %p, %p, %x)\n",
4583 : cmd_type, param, datafmt, data, p_datalen, indicator, byvalue);
4584 :
4585 366 : if (cmd_type == CS_DYNAMIC_CMD) {
4586 20 : param->name = NULL;
4587 : } else {
4588 346 : CS_INT namelen = datafmt->namelen;
4589 346 : namelen = _ct_get_string_length(datafmt->name, namelen);
4590 346 : if (namelen > 0) {
4591 226 : param->name = tds_strndup(datafmt->name, namelen);
4592 226 : if (!param->name)
4593 : return CS_FAIL;
4594 : } else {
4595 120 : param->name = NULL;
4596 : }
4597 : }
4598 :
4599 366 : param->status = datafmt->status;
4600 366 : tdsdump_log(TDS_DBG_INFO1, " _ct_fill_param() status = %d \n", param->status);
4601 :
4602 : /*
4603 : * translate datafmt.datatype, e.g. CS_SMALLINT_TYPE
4604 : * to Server type, e.g. SYBINT2
4605 : */
4606 366 : desttype = _ct_get_server_type(NULL, datafmt->datatype);
4607 366 : if (desttype == TDS_INVALID_TYPE)
4608 : return CS_FAIL;
4609 366 : param->datatype = datafmt->datatype;
4610 :
4611 366 : if (is_numeric_type(desttype)) {
4612 0 : param->scale = datafmt->scale;
4613 0 : param->precision = datafmt->precision;
4614 0 : if (param->scale < 0 || param->precision < 0
4615 0 : || param->precision > MAXPRECISION || param->scale > param->precision)
4616 : return CS_FAIL;
4617 : }
4618 :
4619 366 : param->maxlen = datafmt->maxlength;
4620 :
4621 366 : if (is_fixed_type(desttype)) {
4622 250 : param->maxlen = tds_get_size_by_type(desttype);
4623 : }
4624 :
4625 366 : param->param_by_value = byvalue;
4626 :
4627 366 : if (byvalue) {
4628 270 : CS_INT datalen = *p_datalen;
4629 :
4630 270 : param->datalen = ¶m->datalen_value;
4631 270 : *(param->datalen) = datalen;
4632 :
4633 270 : param->ind = ¶m->indicator_value;
4634 270 : *(param->ind) = *indicator;
4635 :
4636 : /*
4637 : * There are two ways to indicate a parameter with a null value:
4638 : * - Pass indicator as -1. In this case, data and datalen are ignored.
4639 : * - Pass data as NULL and datalen as 0 or CS_UNUSED
4640 : */
4641 270 : if (*indicator == -1 || (!data && (datalen == 0 || datalen == CS_UNUSED))) {
4642 30 : param->value = NULL;
4643 30 : datalen = 0;
4644 : } else {
4645 : /* datafmt.datalen is ignored for fixed length types */
4646 :
4647 240 : if (is_fixed_type(desttype)) {
4648 170 : datalen = tds_get_size_by_type(desttype);
4649 : } else {
4650 70 : datalen = (datalen == CS_UNUSED) ? 0 : datalen;
4651 : }
4652 :
4653 240 : if (data) {
4654 240 : if (datalen == CS_NULLTERM) {
4655 0 : tdsdump_log(TDS_DBG_INFO1,
4656 : " _ct_fill_param() about to strdup string %u bytes long\n",
4657 : (unsigned int) strlen((const char*) data));
4658 0 : datalen = strlen((const char*) data);
4659 240 : } else if (datalen < 0) {
4660 : return CS_FAIL;
4661 : }
4662 240 : param->value = tds_new(CS_BYTE, datalen ? datalen : 1);
4663 240 : if (!param->value)
4664 : return CS_FAIL;
4665 240 : memcpy(param->value, data, datalen);
4666 240 : param->param_by_value = 1;
4667 : } else {
4668 0 : param->value = NULL;
4669 0 : datalen = 0;
4670 : }
4671 : }
4672 270 : *(param->datalen) = datalen;
4673 : } else { /* not by value, i.e. by reference */
4674 96 : param->datalen = p_datalen;
4675 96 : param->ind = indicator;
4676 96 : param->value = (CS_BYTE*) data;
4677 : }
4678 : return CS_SUCCEED;
4679 : }
4680 :
4681 : /* Code added for ct_diag implementation */
4682 : /* Code changes start here - CT_DIAG - 02*/
4683 :
4684 : CS_RETCODE
4685 220 : ct_diag(CS_CONNECTION * conn, CS_INT operation, CS_INT type, CS_INT idx, CS_VOID * buffer)
4686 : {
4687 220 : tdsdump_log(TDS_DBG_FUNC, "ct_diag(%p, %d, %d, %d, %p)\n", conn, operation, type, idx, buffer);
4688 :
4689 220 : switch (operation) {
4690 30 : case CS_INIT:
4691 30 : if (conn->ctx->cs_errhandletype == _CS_ERRHAND_CB) {
4692 : /* contrary to the manual page you don't seem to */
4693 : /* be able to turn on inline message handling */
4694 : /* using cs_diag, once a callback is installed! */
4695 : return CS_FAIL;
4696 : }
4697 :
4698 30 : conn->ctx->cs_errhandletype = _CS_ERRHAND_INLINE;
4699 :
4700 30 : if (conn->ctx->cs_diag_msglimit_client == 0)
4701 30 : conn->ctx->cs_diag_msglimit_client = CS_NO_LIMIT;
4702 :
4703 30 : if (conn->ctx->cs_diag_msglimit_server == 0)
4704 30 : conn->ctx->cs_diag_msglimit_server = CS_NO_LIMIT;
4705 :
4706 30 : if (conn->ctx->cs_diag_msglimit_total == 0)
4707 30 : conn->ctx->cs_diag_msglimit_total = CS_NO_LIMIT;
4708 :
4709 30 : conn->ctx->clientmsg_cb = (CS_CLIENTMSG_FUNC) ct_diag_storeclientmsg;
4710 30 : conn->ctx->servermsg_cb = (CS_SERVERMSG_FUNC) ct_diag_storeservermsg;
4711 :
4712 30 : break;
4713 :
4714 30 : case CS_MSGLIMIT:
4715 30 : if (conn->ctx->cs_errhandletype != _CS_ERRHAND_INLINE)
4716 : return CS_FAIL;
4717 :
4718 30 : if (type == CS_CLIENTMSG_TYPE)
4719 10 : conn->ctx->cs_diag_msglimit_client = *(CS_INT *) buffer;
4720 :
4721 30 : if (type == CS_SERVERMSG_TYPE)
4722 10 : conn->ctx->cs_diag_msglimit_server = *(CS_INT *) buffer;
4723 :
4724 30 : if (type == CS_ALLMSG_TYPE)
4725 10 : conn->ctx->cs_diag_msglimit_total = *(CS_INT *) buffer;
4726 :
4727 : break;
4728 :
4729 30 : case CS_CLEAR:
4730 30 : if (conn->ctx->cs_errhandletype != _CS_ERRHAND_INLINE)
4731 : return CS_FAIL;
4732 30 : return _ct_diag_clearmsg(conn->ctx, type);
4733 : break;
4734 :
4735 50 : case CS_GET:
4736 50 : if (conn->ctx->cs_errhandletype != _CS_ERRHAND_INLINE)
4737 : return CS_FAIL;
4738 :
4739 50 : if (!buffer)
4740 : return CS_FAIL;
4741 :
4742 50 : if (type == CS_CLIENTMSG_TYPE) {
4743 20 : if (idx == 0
4744 20 : || (conn->ctx->cs_diag_msglimit_client != CS_NO_LIMIT && idx > conn->ctx->cs_diag_msglimit_client))
4745 : return CS_FAIL;
4746 :
4747 20 : return ct_diag_getclientmsg(conn->ctx, idx, (CS_CLIENTMSG *) buffer);
4748 : }
4749 :
4750 30 : if (type == CS_SERVERMSG_TYPE) {
4751 30 : if (idx == 0
4752 30 : || (conn->ctx->cs_diag_msglimit_server != CS_NO_LIMIT && idx > conn->ctx->cs_diag_msglimit_server))
4753 : return CS_FAIL;
4754 30 : return ct_diag_getservermsg(conn->ctx, idx, (CS_SERVERMSG *) buffer);
4755 : }
4756 :
4757 : break;
4758 :
4759 80 : case CS_STATUS:
4760 80 : if (conn->ctx->cs_errhandletype != _CS_ERRHAND_INLINE)
4761 : return CS_FAIL;
4762 80 : if (!buffer)
4763 : return CS_FAIL;
4764 :
4765 80 : return (ct_diag_countmsg(conn->ctx, type, (CS_INT *) buffer));
4766 : break;
4767 : }
4768 : return CS_SUCCEED;
4769 : }
4770 :
4771 : static CS_INT
4772 20 : ct_diag_storeclientmsg(CS_CONTEXT * context, CS_CONNECTION * conn, CS_CLIENTMSG * message)
4773 : {
4774 : struct cs_diag_msg_client **curptr;
4775 20 : CS_INT msg_count = 0;
4776 :
4777 20 : tdsdump_log(TDS_DBG_FUNC, "ct_diag_storeclientmsg(%p, %p, %p)\n", context, conn, message);
4778 :
4779 20 : curptr = &(conn->ctx->clientstore);
4780 :
4781 : /* if we already have a list of messages, go to the end of the list... */
4782 :
4783 40 : while (*curptr != NULL) {
4784 0 : msg_count++;
4785 0 : curptr = &((*curptr)->next);
4786 : }
4787 :
4788 : /* messages over and above the agreed limit */
4789 : /* are simply discarded... */
4790 :
4791 20 : if (conn->ctx->cs_diag_msglimit_client != CS_NO_LIMIT && msg_count >= conn->ctx->cs_diag_msglimit_client) {
4792 : return CS_FAIL;
4793 : }
4794 :
4795 : /* messages over and above the agreed TOTAL limit */
4796 : /* are simply discarded */
4797 :
4798 20 : if (conn->ctx->cs_diag_msglimit_total != CS_NO_LIMIT) {
4799 : const struct cs_diag_msg_svr *scurptr;
4800 :
4801 10 : scurptr = conn->ctx->svrstore;
4802 20 : while (scurptr != NULL) {
4803 0 : msg_count++;
4804 0 : scurptr = scurptr->next;
4805 : }
4806 10 : if (msg_count >= conn->ctx->cs_diag_msglimit_total) {
4807 : return CS_FAIL;
4808 : }
4809 : }
4810 :
4811 20 : *curptr = tds_new(struct cs_diag_msg_client, 1);
4812 20 : if (!*curptr)
4813 : return CS_FAIL;
4814 :
4815 20 : (*curptr)->next = NULL;
4816 20 : memcpy(&(*curptr)->clientmsg, message, sizeof(CS_CLIENTMSG));
4817 :
4818 20 : return CS_SUCCEED;
4819 : }
4820 :
4821 : static CS_INT
4822 30 : ct_diag_storeservermsg(CS_CONTEXT * context, CS_CONNECTION * conn, CS_SERVERMSG * message)
4823 : {
4824 : struct cs_diag_msg_svr **curptr;
4825 :
4826 30 : CS_INT msg_count = 0;
4827 :
4828 30 : tdsdump_log(TDS_DBG_FUNC, "ct_diag_storeservermsg(%p, %p, %p)\n", context, conn, message);
4829 :
4830 30 : curptr = &(conn->ctx->svrstore);
4831 :
4832 : /* if we already have a list of messages, go to the end of the list... */
4833 :
4834 90 : while (*curptr != NULL) {
4835 30 : msg_count++;
4836 30 : curptr = &((*curptr)->next);
4837 : }
4838 :
4839 : /* messages over and above the agreed limit */
4840 : /* are simply discarded... */
4841 :
4842 30 : if (conn->ctx->cs_diag_msglimit_server != CS_NO_LIMIT && msg_count >= conn->ctx->cs_diag_msglimit_server) {
4843 : return CS_FAIL;
4844 : }
4845 :
4846 : /* messages over and above the agreed TOTAL limit */
4847 : /* are simply discarded... */
4848 :
4849 30 : if (conn->ctx->cs_diag_msglimit_total != CS_NO_LIMIT) {
4850 : const struct cs_diag_msg_client *ccurptr;
4851 :
4852 30 : ccurptr = conn->ctx->clientstore;
4853 90 : while (ccurptr != NULL) {
4854 30 : msg_count++;
4855 30 : ccurptr = ccurptr->next;
4856 : }
4857 30 : if (msg_count >= conn->ctx->cs_diag_msglimit_total) {
4858 : return CS_FAIL;
4859 : }
4860 : }
4861 :
4862 30 : *curptr = tds_new(struct cs_diag_msg_svr, 1);
4863 30 : if (!*curptr)
4864 : return CS_FAIL;
4865 :
4866 30 : (*curptr)->next = NULL;
4867 60 : memcpy(&(*curptr)->servermsg, message, cs_servermsg_len(conn->ctx));
4868 :
4869 30 : return CS_SUCCEED;
4870 : }
4871 :
4872 : static CS_INT
4873 20 : ct_diag_getclientmsg(CS_CONTEXT * context, CS_INT idx, CS_CLIENTMSG * message)
4874 : {
4875 : const struct cs_diag_msg_client *curptr;
4876 20 : CS_INT msg_count = 0;
4877 :
4878 20 : tdsdump_log(TDS_DBG_FUNC, "ct_diag_getclientmsg(%p, %d, %p)\n", context, idx, message);
4879 :
4880 20 : curptr = context->clientstore;
4881 :
4882 : /* if we already have a list of messages, go to the end of the list... */
4883 :
4884 40 : while (curptr != NULL) {
4885 20 : msg_count++;
4886 20 : if (msg_count == idx) {
4887 20 : memcpy(message, &curptr->clientmsg, sizeof(CS_CLIENTMSG));
4888 20 : return CS_SUCCEED;
4889 : }
4890 0 : curptr = curptr->next;
4891 : }
4892 :
4893 : return CS_NOMSG;
4894 : }
4895 :
4896 : static CS_INT
4897 30 : ct_diag_getservermsg(CS_CONTEXT * context, CS_INT idx, CS_SERVERMSG * message)
4898 : {
4899 : struct cs_diag_msg_svr *curptr;
4900 30 : CS_INT msg_count = 0;
4901 :
4902 30 : tdsdump_log(TDS_DBG_FUNC, "ct_diag_getservermsg(%p, %d, %p)\n", context, idx, message);
4903 :
4904 30 : curptr = context->svrstore;
4905 :
4906 : /* if we already have a list of messages, go to the end of the list... */
4907 :
4908 90 : while (curptr != NULL) {
4909 60 : msg_count++;
4910 60 : if (msg_count == idx) {
4911 60 : memcpy(message, &curptr->servermsg, cs_servermsg_len(context));
4912 30 : return CS_SUCCEED;
4913 : }
4914 30 : curptr = curptr->next;
4915 : }
4916 :
4917 : return CS_NOMSG;
4918 : }
4919 :
4920 : CS_INT
4921 1440 : _ct_diag_clearmsg(CS_CONTEXT * context, CS_INT type)
4922 : {
4923 1440 : tdsdump_log(TDS_DBG_FUNC, "_ct_diag_clearmsg(%p, %d)\n", context, type);
4924 :
4925 1440 : if (type == CS_CLIENTMSG_TYPE || type == CS_ALLMSG_TYPE) {
4926 : struct cs_diag_msg_client *curptr, *freeptr;
4927 :
4928 1430 : curptr = context->clientstore;
4929 1430 : context->clientstore = NULL;
4930 :
4931 2880 : while (curptr != NULL) {
4932 20 : freeptr = curptr;
4933 20 : curptr = freeptr->next;
4934 20 : free(freeptr);
4935 : }
4936 : }
4937 :
4938 1440 : if (type == CS_SERVERMSG_TYPE || type == CS_ALLMSG_TYPE) {
4939 : struct cs_diag_msg_svr *scurptr, *sfreeptr;
4940 :
4941 1430 : scurptr = context->svrstore;
4942 1430 : context->svrstore = NULL;
4943 :
4944 2890 : while (scurptr != NULL) {
4945 30 : sfreeptr = scurptr;
4946 30 : scurptr = sfreeptr->next;
4947 30 : free(sfreeptr);
4948 : }
4949 : }
4950 1440 : return CS_SUCCEED;
4951 : }
4952 :
4953 : static CS_INT
4954 80 : ct_diag_countmsg(CS_CONTEXT * context, CS_INT type, CS_INT * count)
4955 : {
4956 80 : CS_INT msg_count = 0;
4957 :
4958 80 : tdsdump_log(TDS_DBG_FUNC, "ct_diag_countmsg(%p, %d, %p)\n", context, type, count);
4959 :
4960 80 : if (type == CS_CLIENTMSG_TYPE || type == CS_ALLMSG_TYPE) {
4961 : const struct cs_diag_msg_client *curptr;
4962 :
4963 50 : curptr = context->clientstore;
4964 :
4965 130 : while (curptr != NULL) {
4966 30 : msg_count++;
4967 30 : curptr = curptr->next;
4968 : }
4969 : }
4970 :
4971 80 : if (type == CS_SERVERMSG_TYPE || type == CS_ALLMSG_TYPE) {
4972 : const struct cs_diag_msg_svr *scurptr;
4973 :
4974 50 : scurptr = context->svrstore;
4975 :
4976 160 : while (scurptr != NULL) {
4977 60 : msg_count++;
4978 60 : scurptr = scurptr->next;
4979 : }
4980 : }
4981 80 : *count = msg_count;
4982 :
4983 80 : return CS_SUCCEED;
4984 : }
4985 :
4986 : /* Code changes ends here - CT_DIAG - 02*/
4987 :
4988 : static CS_DYNAMIC *
4989 50 : _ct_allocate_dynamic(CS_CONNECTION * con, char *id, int id_len)
4990 : {
4991 : CS_DYNAMIC *dyn;
4992 : CS_DYNAMIC **pdyn;
4993 :
4994 50 : tdsdump_log(TDS_DBG_FUNC, "_ct_allocate_dynamic(%p, %p, %d)\n", con, id, id_len);
4995 :
4996 50 : id_len = _ct_get_string_length(id, id_len);
4997 50 : if (id_len < 0) {
4998 20 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 5, "%d, idlen", id_len);
4999 20 : return NULL;
5000 : }
5001 :
5002 30 : dyn = tds_new0(CS_DYNAMIC, 1);
5003 30 : if (!dyn) {
5004 0 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 2, "");
5005 0 : return NULL;
5006 : }
5007 :
5008 30 : dyn->id = tds_strndup(id, id_len);
5009 30 : if (!dyn->id) {
5010 0 : free(dyn);
5011 0 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 2, "");
5012 0 : return NULL;
5013 : }
5014 :
5015 30 : if (!con->dynlist) {
5016 30 : tdsdump_log(TDS_DBG_INFO1, "_ct_allocate_dynamic() attaching dynamic command to head\n");
5017 30 : con->dynlist = dyn;
5018 : } else {
5019 0 : pdyn = &con->dynlist;
5020 0 : while (*pdyn) {
5021 0 : pdyn = &(*pdyn)->next;
5022 : }
5023 :
5024 0 : *pdyn = dyn;
5025 : }
5026 : return dyn;
5027 : }
5028 :
5029 : static CS_DYNAMIC *
5030 80 : _ct_locate_dynamic(CS_CONNECTION * con, char *id, int id_len)
5031 : {
5032 : CS_DYNAMIC *dyn;
5033 :
5034 80 : tdsdump_log(TDS_DBG_FUNC, "_ct_locate_dynamic(%p, %p, %d)\n", con, id, id_len);
5035 :
5036 80 : id_len = _ct_get_string_length(id, id_len);
5037 80 : if (id_len < 0) {
5038 10 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 5, "%d, idlen", id_len);
5039 10 : return NULL;
5040 : }
5041 :
5042 70 : tdsdump_log(TDS_DBG_INFO1, "_ct_locate_dynamic() looking for %s\n", (char *) id);
5043 :
5044 90 : for (dyn = con->dynlist; dyn != NULL; dyn = dyn->next) {
5045 70 : tdsdump_log(TDS_DBG_INFO1, "_ct_locate_dynamic() matching with %s\n", (char *) dyn->id);
5046 70 : if (strncmp(dyn->id, id, id_len) == 0 && strlen(dyn->id) == id_len + 0u)
5047 : break;
5048 : }
5049 :
5050 70 : if (!dyn)
5051 20 : _ctclient_msg(NULL, con, "ct_dynamic", 1, 1, 1, 135, "");
5052 : return dyn;
5053 : }
5054 :
5055 : static CS_INT
5056 30 : _ct_deallocate_dynamic(CS_CONNECTION * con, CS_DYNAMIC *dyn)
5057 : {
5058 : CS_DYNAMIC **pvictim;
5059 :
5060 30 : tdsdump_log(TDS_DBG_FUNC, "_ct_deallocate_dynamic(%p, %p)\n", con, dyn);
5061 :
5062 30 : if (!dyn)
5063 : return CS_SUCCEED;
5064 :
5065 30 : pvictim = &con->dynlist;
5066 60 : for (; *pvictim != dyn;) {
5067 0 : if (!*pvictim) {
5068 0 : tdsdump_log(TDS_DBG_FUNC, "ct_deallocate_dynamic() : cannot find entry in list\n");
5069 : return CS_FAIL;
5070 : }
5071 0 : pvictim = &(*pvictim)->next;
5072 : }
5073 :
5074 : /* detach node */
5075 30 : tdsdump_log(TDS_DBG_FUNC, "ct_deallocate_dynamic() : relinking list\n");
5076 30 : *pvictim = dyn->next;
5077 30 : dyn->next = NULL;
5078 30 : tdsdump_log(TDS_DBG_FUNC, "ct_deallocate_dynamic() : relinked list\n");
5079 :
5080 : /* free dynamic */
5081 30 : tds_release_dynamic(&dyn->tdsdyn);
5082 30 : free(dyn->id);
5083 30 : free(dyn->stmt);
5084 30 : param_clear(dyn->param_list);
5085 :
5086 30 : free(dyn);
5087 :
5088 30 : return CS_SUCCEED;
5089 : }
5090 :
5091 : static CS_INT
5092 : _ct_map_compute_op(CS_INT comp_op)
5093 : {
5094 0 : switch (comp_op) {
5095 : case SYBAOPCNT:
5096 : case SYBAOPCNTU:
5097 : case SYBAOPCNT_BIG:
5098 : return CS_OP_COUNT;
5099 0 : case SYBAOPSUM:
5100 : case SYBAOPSUMU:
5101 : return CS_OP_SUM;
5102 0 : case SYBAOPAVG:
5103 : case SYBAOPAVGU:
5104 : return CS_OP_AVG;
5105 0 : case SYBAOPMIN:
5106 : return CS_OP_MIN;
5107 0 : case SYBAOPMAX:
5108 : return CS_OP_MAX;
5109 : }
5110 : return comp_op;
5111 : }
|
