LCOV - code coverage report
Current view: top level - src/odbc - odbc.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 2471 4200 58.8 %
Date: 2025-07-26 13:53:51 Functions: 68 79 86.1 %

          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-2012  Frediano Ziglio
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or
       6             :  * modify it under the terms of the GNU Library General Public
       7             :  * License as published by the Free Software Foundation; either
       8             :  * version 2 of the License, or (at your option) any later version.
       9             :  *
      10             :  * This library is distributed in the hope that it will be useful,
      11             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13             :  * Library General Public License for more details.
      14             :  *
      15             :  * You should have received a copy of the GNU Library General Public
      16             :  * License along with this library; if not, write to the
      17             :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      18             :  * Boston, MA 02111-1307, USA.
      19             :  */
      20             : 
      21             : #include <config.h>
      22             : 
      23             : #include <stdarg.h>
      24             : #include <stdio.h>
      25             : 
      26             : #if HAVE_STDLIB_H
      27             : #include <stdlib.h>
      28             : #endif /* HAVE_STDLIB_H */
      29             : 
      30             : #if HAVE_STRING_H
      31             : #include <string.h>
      32             : #endif /* HAVE_STRING_H */
      33             : 
      34             : #include <assert.h>
      35             : #include <ctype.h>
      36             : 
      37             : #include <freetds/utils.h>
      38             : #include <freetds/odbc.h>
      39             : #include <freetds/iconv.h>
      40             : #include <freetds/utils/string.h>
      41             : #include <freetds/convert.h>
      42             : #include <freetds/encodings.h>
      43             : #include <freetds/replacements.h>
      44             : #include "sqlwparams.h"
      45             : 
      46             : /* Include odbcss.h with all bcp functions */
      47             : /* The define trick is to make inline functions calls internal
      48             :  * odbc_SQLSetConnectAttr instead of SQLSetConnectAttr */
      49             : ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,ValuePtr), P(SQLINTEGER,StringLength) WIDE));
      50             : #define TDSODBC_BCP
      51             : #undef SQLSetConnectAttr
      52             : #define SQLSetConnectAttr(h, n, p, t) odbc_SQLSetConnectAttr(h, n, p, t _wide0)
      53             : #include <odbcss.h>
      54             : #undef SQLSetConnectAttr
      55             : 
      56             : static SQLRETURN odbc_SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc);
      57             : static SQLRETURN odbc_SQLAllocEnv(SQLHENV FAR * phenv, SQLINTEGER odbc_version);
      58             : static SQLRETURN odbc_SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt);
      59             : static SQLRETURN odbc_SQLAllocDesc(SQLHDBC hdbc, SQLHDESC FAR * phdesc);
      60             : static SQLRETURN odbc_SQLFreeConnect(SQLHDBC hdbc);
      61             : static SQLRETURN odbc_SQLFreeEnv(SQLHENV henv);
      62             : static SQLRETURN odbc_SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption, int force);
      63             : static SQLRETURN odbc_SQLFreeDesc(SQLHDESC hdesc);
      64             : static SQLRETURN odbc_SQLExecute(TDS_STMT * stmt);
      65             : static SQLRETURN odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength WIDE);
      66             : static SQLRETURN odbc_SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength,
      67             :                                      SQLINTEGER * StringLength WIDE);
      68             : static SQLRETURN odbc_SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc,
      69             :                                           SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc _WIDE);
      70             : static SQLRETURN odbc_SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset);
      71             : static SQLRETURN odbc_populate_ird(TDS_STMT * stmt);
      72             : static int odbc_errmsg_handler(const TDSCONTEXT * ctx, TDSSOCKET * tds, TDSMESSAGE * msg);
      73             : static void odbc_log_unimplemented_type(const char function_name[], int fType);
      74             : static void odbc_upper_column_names(TDS_STMT * stmt);
      75             : static void odbc_col_setname(TDS_STMT * stmt, int colpos, const char *name);
      76             : static SQLRETURN odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...);
      77             : static SQLRETURN odbc_free_dynamic(TDS_STMT * stmt);
      78             : static SQLRETURN odbc_free_cursor(TDS_STMT * stmt);
      79             : static SQLRETURN odbc_update_ird(TDS_STMT *stmt, TDS_ERRS *errs);
      80             : static SQLRETURN odbc_prepare(TDS_STMT *stmt);
      81             : static SQLSMALLINT odbc_swap_datetime_sql_type(SQLSMALLINT sql_type, int version);
      82             : static int odbc_process_tokens(TDS_STMT * stmt, unsigned flag);
      83             : static bool odbc_lock_statement(TDS_STMT* stmt);
      84             : static void odbc_unlock_statement(TDS_STMT* stmt);
      85             : static bool read_params(TDS_STMT *stmt);
      86             : 
      87             : #if ENABLE_EXTRA_CHECKS
      88             : static void odbc_ird_check(TDS_STMT * stmt);
      89             : 
      90             : #define IRD_CHECK odbc_ird_check(stmt)
      91             : #else
      92             : #define IRD_CHECK
      93             : #endif
      94             : 
      95             : /**
      96             :  * \defgroup odbc_api ODBC API
      97             :  * Functions callable by \c ODBC client programs
      98             :  */
      99             : 
     100             : 
     101             : /* utils to check handles */
     102             : #define INIT_HANDLE(t, n) \
     103             :         TDS_##t *n = (TDS_##t*)h##n; \
     104             :         if (SQL_NULL_H##t  == h##n || (n)->htype != SQL_HANDLE_##t) return SQL_INVALID_HANDLE; \
     105             :         tds_mutex_lock(&n->mtx); \
     106             :         CHECK_##t##_EXTRA(n); \
     107             :         odbc_errs_reset(&n->errs);
     108             : 
     109             : #define ODBC_ENTER_HSTMT INIT_HANDLE(STMT, stmt)
     110             : #define ODBC_ENTER_HDBC  INIT_HANDLE(DBC,  dbc)
     111             : #define ODBC_ENTER_HENV  INIT_HANDLE(ENV,  env)
     112             : #define ODBC_ENTER_HDESC INIT_HANDLE(DESC, desc)
     113             : 
     114             : #define IS_VALID_LEN(len) ((len) >= 0 || (len) == SQL_NTS || (len) == SQL_NULL_DATA)
     115             : 
     116             : #define ODBC_SAFE_ERROR(stmt) \
     117             :         do { \
     118             :                 if (!stmt->errs.num_errors) \
     119             :                         odbc_errs_add(&stmt->errs, "HY000", "Unknown error"); \
     120             :         } while(0)
     121             : 
     122             : #define DEFAULT_QUERY_TIMEOUT (~((SQLUINTEGER) 0))
     123             : 
     124             : /*
     125             :  * Note: I *HATE* hungarian notation, it has to be the most idiotic thing
     126             :  * I've ever seen. So, you will note it is avoided other than in the function
     127             :  * declarations. "Gee, let's make our code totally hard to read and they'll
     128             :  * beg for GUI tools"
     129             :  * Bah!
     130             :  */
     131             : 
     132             : static const char *
     133           0 : odbc_prret(SQLRETURN ret, char *unknown, size_t unknown_size)
     134             : {
     135           0 :         switch (ret) {
     136             :         case SQL_ERROR:                 return "SQL_ERROR";
     137           0 :         case SQL_INVALID_HANDLE:        return "SQL_INVALID_HANDLE";
     138           0 :         case SQL_SUCCESS:               return "SQL_SUCCESS";
     139           0 :         case SQL_SUCCESS_WITH_INFO:     return "SQL_SUCCESS_WITH_INFO";
     140             : #if ODBCVER >= 0x0300
     141           0 :         case SQL_NO_DATA:               return "SQL_NO_DATA";
     142             : #endif
     143           0 :         case SQL_STILL_EXECUTING:       return "SQL_STILL_EXECUTING";
     144           0 :         case SQL_NEED_DATA:             return "SQL_NEED_DATA";
     145             :         }
     146             : 
     147           0 :         snprintf(unknown, unknown_size, "unknown: %d", (int)ret);
     148             : 
     149           0 :         return unknown;
     150             : }
     151             : #define ODBC_PRRET_BUF  char unknown_prret_buf[24]
     152             : #define odbc_prret(ret) odbc_prret(ret, unknown_prret_buf, sizeof(unknown_prret_buf))
     153             : 
     154             : static void
     155         516 : odbc_col_setname(TDS_STMT * stmt, int colpos, const char *name)
     156             : {
     157             : #if ENABLE_EXTRA_CHECKS
     158             :         TDSRESULTINFO *resinfo;
     159             : #endif
     160             : 
     161         516 :         IRD_CHECK;
     162             : 
     163             : #if ENABLE_EXTRA_CHECKS
     164         516 :         if (colpos > 0 && stmt->tds != NULL && (resinfo = stmt->tds->current_results) != NULL) {
     165         516 :                 if (colpos <= resinfo->num_cols) {
     166             :                         /* no overflow possible, name is always shorter */
     167         516 :                         if (!tds_dstr_copy(&resinfo->columns[colpos - 1]->column_name, name))
     168           0 :                                 odbc_errs_add(&stmt->errs, "HY001", NULL);
     169         516 :                         tds_dstr_empty(&resinfo->columns[colpos - 1]->table_column_name);
     170             :                 }
     171             :         }
     172             : #endif
     173             : 
     174         516 :         if (colpos > 0 && colpos <= stmt->ird->header.sql_desc_count) {
     175         516 :                 --colpos;
     176         516 :                 if (!tds_dstr_copy(&stmt->ird->records[colpos].sql_desc_label, name)
     177         516 :                     || !tds_dstr_copy(&stmt->ird->records[colpos].sql_desc_name, name))
     178           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
     179             :         }
     180         516 : }
     181             : 
     182             : /* spinellia@acm.org : copied shamelessly from change_database */
     183             : static SQLRETURN
     184         260 : change_autocommit(TDS_DBC * dbc, int state)
     185             : {
     186         260 :         TDSSOCKET *tds = dbc->tds_socket;
     187             :         TDSRET ret;
     188             : 
     189         260 :         tds_mutex_check_owned(&dbc->mtx);
     190         260 :         if (dbc->attr.autocommit == state)
     191             :                 return SQL_SUCCESS;
     192             : 
     193             :         /*
     194             :          * We may not be connected yet and dbc->tds_socket
     195             :          * may not initialized.
     196             :          */
     197         232 :         if (tds) {
     198             :                 /* TODO better idle check, not thread safe */
     199         190 :                 if (tds->state == TDS_IDLE)
     200         190 :                         tds->query_timeout = dbc->default_query_timeout;
     201             : 
     202         190 :                 if (state == SQL_AUTOCOMMIT_ON)
     203          58 :                         ret = tds_submit_rollback(tds, 0);
     204             :                 else
     205         132 :                         ret = tds_submit_begin_tran(tds);
     206             : 
     207         190 :                 if (TDS_FAILED(ret)) {
     208           0 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change transaction status");
     209           0 :                         return SQL_ERROR;
     210             :                 }
     211         190 :                 if (TDS_FAILED(tds_process_simple_query(tds))) {
     212           0 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change transaction status");
     213           0 :                         return SQL_ERROR;
     214             :                 }
     215         190 :                 dbc->attr.autocommit = state;
     216             :         } else {
     217             :                 /* if not connected we will change auto-commit after login */
     218          42 :                 dbc->attr.autocommit = state;
     219             :         }
     220         232 :         ODBC_RETURN_(dbc);
     221             : }
     222             : 
     223             : static SQLRETURN
     224          80 : change_database(TDS_DBC * dbc, const char *database, size_t database_len)
     225             : {
     226          80 :         TDSSOCKET *tds = dbc->tds_socket;
     227          80 :         tds_mutex_check_owned(&dbc->mtx);
     228             : 
     229             :         /*
     230             :          * We may not be connected yet and dbc->tds_socket
     231             :          * may not initialized.
     232             :          */
     233          80 :         if (tds) {
     234             :                 /* build query */
     235          40 :                 char *query = tds_new(char, 6 + tds_quote_id(tds, NULL, database, database_len));
     236             : 
     237          40 :                 if (!query) {
     238           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
     239           0 :                         return SQL_ERROR;
     240             :                 }
     241          40 :                 strcpy(query, "USE ");
     242          40 :                 tds_quote_id(tds, query + 4, database, database_len);
     243             : 
     244             : 
     245          40 :                 tdsdump_log(TDS_DBG_INFO1, "change_database: executing %s\n", query);
     246             : 
     247             :                 /* TODO better idle check, not thread safe */
     248          40 :                 if (tds->state == TDS_IDLE)
     249          40 :                         tds->query_timeout = dbc->default_query_timeout;
     250          40 :                 if (TDS_FAILED(tds_submit_query(tds, query))) {
     251           0 :                         free(query);
     252           0 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change database");
     253           0 :                         return SQL_ERROR;
     254             :                 }
     255          40 :                 free(query);
     256          40 :                 if (TDS_FAILED(tds_process_simple_query(tds))) {
     257          10 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change database");
     258          10 :                         return SQL_ERROR;
     259             :                 }
     260             :         } else {
     261          40 :                 if (!tds_dstr_copyn(&dbc->attr.current_catalog, database, database_len)) {
     262           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
     263           0 :                         return SQL_ERROR;
     264             :                 }
     265             :         }
     266          70 :         ODBC_RETURN_(dbc);
     267             : }
     268             : 
     269             : static SQLRETURN
     270         124 : change_txn(TDS_DBC * dbc, SQLUINTEGER txn_isolation)
     271             : {
     272             :         char query[64];
     273             :         const char *level;
     274         124 :         TDSSOCKET *tds = dbc->tds_socket;
     275         124 :         tds_mutex_check_owned(&dbc->mtx);
     276             : 
     277         124 :         switch (txn_isolation) {
     278             :         case SQL_TXN_READ_COMMITTED:
     279             :                 level = "READ COMMITTED";
     280             :                 break;
     281          30 :         case SQL_TXN_READ_UNCOMMITTED:
     282          30 :                 level = "READ UNCOMMITTED";
     283          30 :                 break;
     284          44 :         case SQL_TXN_REPEATABLE_READ:
     285          44 :                 level = "REPEATABLE READ";
     286          44 :                 break;
     287          30 :         case SQL_TXN_SERIALIZABLE:
     288          30 :                 level = "SERIALIZABLE";
     289          30 :                 break;
     290          10 :         default:
     291          10 :                 odbc_errs_add(&dbc->errs, "HY024", NULL);
     292          10 :                 return SQL_ERROR;
     293             :         }
     294             : 
     295             :         /* if not connected return success, will be set after connection */
     296         114 :         if (!tds)
     297             :                 return SQL_SUCCESS;
     298             : 
     299          82 :         if (tds->state != TDS_IDLE) {
     300          10 :                 odbc_errs_add(&dbc->errs, "HY011", NULL);
     301          10 :                 return SQL_ERROR;
     302             :         }
     303             : 
     304          72 :         tds->query_timeout = dbc->default_query_timeout;
     305          72 :         sprintf(query, "SET TRANSACTION ISOLATION LEVEL %s", level);
     306          72 :         if (TDS_FAILED(tds_submit_query(tds, query))) {
     307           0 :                 ODBC_SAFE_ERROR(dbc);
     308             :                 return SQL_ERROR;
     309             :         }
     310          72 :         if (TDS_FAILED(tds_process_simple_query(tds))) {
     311           0 :                 ODBC_SAFE_ERROR(dbc);
     312             :                 return SQL_ERROR;
     313             :         }
     314             : 
     315             :         return SQL_SUCCESS;
     316             : }
     317             : 
     318             : static TDS_DBC*
     319       10654 : odbc_get_dbc(TDSSOCKET *tds)
     320             : {
     321       10654 :         TDS_CHK *chk = (TDS_CHK *) tds_get_parent(tds);
     322       10654 :         if (!chk)
     323             :                 return NULL;
     324       10654 :         if (chk->htype == SQL_HANDLE_DBC)
     325             :                 return (TDS_DBC *) chk;
     326        4508 :         assert(chk->htype == SQL_HANDLE_STMT);
     327        4508 :         return ((TDS_STMT *) chk)->dbc;
     328             : }
     329             : 
     330             : static TDS_STMT*
     331             : odbc_get_stmt(TDSSOCKET *tds)
     332             : {
     333        6149 :         TDS_CHK *chk = (TDS_CHK *) tds_get_parent(tds);
     334        6149 :         if (!chk || chk->htype != SQL_HANDLE_STMT)
     335             :                 return NULL;
     336             :         return (TDS_STMT *) chk;
     337             : }
     338             : 
     339             : 
     340             : static void
     341        4701 : odbc_env_change(TDSSOCKET * tds, int type, char *oldval TDS_UNUSED, char *newval)
     342             : {
     343             :         TDS_DBC *dbc;
     344             : 
     345        4701 :         assert(tds);
     346             : 
     347        4701 :         dbc = odbc_get_dbc(tds);
     348        4701 :         if (!dbc)
     349             :                 return;
     350             : 
     351        4701 :         switch (type) {
     352        2441 :         case TDS_ENV_DATABASE:
     353        2441 :                 tds_dstr_copy(&dbc->attr.current_catalog, newval);
     354        2441 :                 break;
     355        1130 :         case TDS_ENV_PACKSIZE:
     356        1130 :                 dbc->attr.packet_size = atoi(newval);
     357        1130 :                 break;
     358             :         }
     359             : }
     360             : 
     361             : static SQLRETURN
     362        1140 : odbc_connect(TDS_DBC * dbc, TDSLOGIN * login)
     363             : {
     364        1140 :         TDS_ENV *env = dbc->env;
     365        1140 :         tds_mutex_check_owned(&dbc->mtx);
     366             : 
     367             : #ifdef ENABLE_ODBC_WIDE
     368        1140 :         dbc->mb_conv = NULL;
     369             : #endif
     370        1140 :         dbc->tds_socket = tds_alloc_socket(env->tds_ctx, 512);
     371        1140 :         if (!dbc->tds_socket)
     372             :                 goto memory_error;
     373             : 
     374        1140 :         dbc->tds_socket->conn->use_iconv = 0;
     375        1140 :         tds_set_parent(dbc->tds_socket, (void *) dbc);
     376             : 
     377             :         /* Set up our environment change hook */
     378        1140 :         dbc->tds_socket->env_chg_func = odbc_env_change;
     379             : 
     380        1140 :         tds_fix_login(login);
     381             : 
     382             :         /* use connection timeout if set */
     383        1140 :         if (dbc->attr.connection_timeout)
     384          10 :                 login->connect_timeout = dbc->attr.connection_timeout;
     385             : 
     386             :         /* but override with login timeout, if set */
     387        1140 :         if (dbc->attr.login_timeout)
     388          10 :                 login->connect_timeout = dbc->attr.login_timeout;
     389             : 
     390        1140 :         if (dbc->attr.mars_enabled != SQL_MARS_ENABLED_NO)
     391         531 :                 login->mars = 1;
     392        1140 :         if (dbc->attr.bulk_enabled != SQL_BCP_OFF)
     393          10 :                 tds_set_bulk(login, true);
     394             : 
     395             : #ifdef ENABLE_ODBC_WIDE
     396             :         /* force utf-8 in order to support wide characters */
     397        2280 :         dbc->original_charset_num = tds_canonical_charset(tds_dstr_cstr(&login->client_charset));
     398        1140 :         if (dbc->original_charset_num < 0) {
     399             :                 char *msg;
     400             : 
     401           0 :                 tds_free_socket(dbc->tds_socket);
     402           0 :                 dbc->tds_socket = NULL;
     403             : 
     404           0 :                 if (asprintf(&msg, "Invalid \"%s\" character set specified", tds_dstr_cstr(&login->client_charset)) > 0) {
     405           0 :                         odbc_errs_add(&dbc->errs, "HY024", msg);
     406           0 :                         free(msg);
     407             :                 } else {
     408           0 :                         odbc_errs_add(&dbc->errs, "HY024", "Invalid character set specified");
     409             :                 }
     410           0 :                 ODBC_RETURN_(dbc);
     411             :         }
     412        1140 :         if (!tds_dstr_copy(&login->client_charset, "UTF-8"))
     413             :                 goto memory_error;
     414             : #endif
     415             : 
     416             :         /* replace password with old one */
     417        1140 :         if (dbc->use_oldpwd) {
     418           0 :                 if (!tds_dstr_dup(&login->new_password, &login->password)
     419           0 :                     || !tds_dstr_dup(&login->password, &dbc->oldpwd))
     420             :                         goto memory_error;
     421           0 :                 login->use_new_password = 1;
     422             :         }
     423             : 
     424        1140 :         if (!tds_dstr_dup(&login->db_filename, &dbc->db_filename))
     425             :                 goto memory_error;
     426             : 
     427        1140 :         if (TDS_FAILED(tds_connect_and_login(dbc->tds_socket, login))) {
     428          10 :                 tds_free_socket(dbc->tds_socket);
     429          10 :                 dbc->tds_socket = NULL;
     430          10 :                 odbc_errs_add(&dbc->errs, "08001", NULL);
     431          10 :                 return SQL_ERROR;
     432             :         }
     433             : #ifdef ENABLE_ODBC_WIDE
     434        1130 :         dbc->mb_conv = tds_iconv_get_info(dbc->tds_socket->conn, dbc->original_charset_num, TDS_CHARSET_UTF_8);
     435             : #endif
     436             : 
     437        1130 :         dbc->default_query_timeout = dbc->tds_socket->query_timeout;
     438             : 
     439        1130 :         if (IS_TDS7_PLUS(dbc->tds_socket->conn))
     440         914 :                 dbc->cursor_support = 1;
     441             : 
     442             : #if ENABLE_ODBC_MARS
     443             :         /* check if mars is enabled */
     444         565 :         if (!IS_TDS72_PLUS(dbc->tds_socket->conn) || !dbc->tds_socket->conn->mars)
     445         356 :                 dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
     446             : #else
     447         565 :         dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
     448             : #endif
     449             : 
     450        1130 :         if (dbc->attr.txn_isolation != SQL_TXN_READ_COMMITTED) {
     451          32 :                 if (!SQL_SUCCEEDED(change_txn(dbc, dbc->attr.txn_isolation)))
     452           0 :                         ODBC_RETURN_(dbc);
     453             :         }
     454             : 
     455        1130 :         if (dbc->attr.autocommit != SQL_AUTOCOMMIT_ON) {
     456          42 :                 dbc->attr.autocommit = SQL_AUTOCOMMIT_ON;
     457          42 :                 if (!SQL_SUCCEEDED(change_autocommit(dbc, SQL_AUTOCOMMIT_OFF)))
     458           0 :                         ODBC_RETURN_(dbc);
     459             :         }
     460             : 
     461             :         /* this overwrite any error arrived (wanted behavior, Sybase return error for conversion errors) */
     462        1130 :         ODBC_RETURN(dbc, SQL_SUCCESS);
     463             : 
     464           0 : memory_error:
     465           0 :         tds_free_socket(dbc->tds_socket);
     466           0 :         dbc->tds_socket = NULL;
     467           0 :         odbc_errs_add(&dbc->errs, "HY001", NULL);
     468           0 :         ODBC_RETURN_(dbc);
     469             : }
     470             : 
     471             : /**
     472             :  * Update IRD information.
     473             :  * This is needed if the IRD is not updated as requires query to be prepared.
     474             :  * For instance calling SQLNumResultCols after SQLPrepare we need to
     475             :  * know how many rows the query could return.
     476             :  */
     477             : static SQLRETURN
     478          74 : odbc_update_ird(TDS_STMT *stmt, TDS_ERRS *errs TDS_UNUSED)
     479             : {
     480             :         SQLRETURN res;
     481             : 
     482          74 :         if (!stmt->need_reprepare || stmt->prepared_query_is_rpc
     483          66 :             || !stmt->dbc || !IS_TDS7_PLUS(stmt->dbc->tds_socket->conn)) {
     484          10 :                 stmt->need_reprepare = 0;
     485             :                 return SQL_SUCCESS;
     486             :         }
     487             : 
     488             :         /* FIXME where error are put ?? on stmt... */
     489          64 :         if (!odbc_lock_statement(stmt))
     490           0 :                 ODBC_RETURN_(stmt);
     491             : 
     492             :         /* FIXME error */
     493          64 :         res = start_parse_prepared_query(stmt, false);
     494          64 :         if (res != SQL_SUCCESS) {
     495             :                 /* prepare with dummy parameters just to fill IRD */
     496           8 :                 tds_free_param_results(stmt->params);
     497           8 :                 stmt->params = NULL;
     498           8 :                 stmt->param_num = 0;
     499             :                 /*
     500             :                  * TODO
     501             :                  * we need to prepare again with parameters but need_reprepare
     502             :                  * flag is reset by odbc_prepare... perhaps should be checked
     503             :                  * later, not calling describeCol or similar
     504             :                  * we need prepare to get dynamic and cause we change parameters
     505             :                  */
     506             :         }
     507             : 
     508          64 :         return odbc_prepare(stmt);
     509             : }
     510             : 
     511             : static SQLRETURN
     512         360 : odbc_prepare(TDS_STMT *stmt)
     513             : {
     514         360 :         TDSSOCKET *tds = stmt->tds;
     515         360 :         bool in_row = false;
     516             : 
     517         720 :         if (TDS_FAILED(tds_submit_prepare(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params))) {
     518          20 :                 ODBC_SAFE_ERROR(stmt);
     519             :                 return SQL_ERROR;
     520             :         }
     521             : 
     522             :         /* try to go to the next recordset */
     523             :         /* TODO merge with similar code */
     524         340 :         desc_free_records(stmt->ird);
     525         340 :         stmt->row_status = PRE_NORMAL_ROW;
     526             :         for (;;) {
     527             :                 TDS_INT result_type;
     528             :                 int done_flags;
     529             : 
     530         758 :                 switch (tds_process_tokens(tds, &result_type, &done_flags, TDS_RETURN_ROWFMT|TDS_RETURN_DONE)) {
     531         418 :                 case TDS_SUCCESS:
     532         418 :                         switch (result_type) {
     533         330 :                         case TDS_DONE_RESULT:
     534             :                         case TDS_DONEPROC_RESULT:
     535             :                         case TDS_DONEINPROC_RESULT:
     536         330 :                                 stmt->row_count = tds->rows_affected;
     537         330 :                                 if (done_flags & TDS_DONE_ERROR && !stmt->dyn->emulated)
     538           2 :                                         stmt->errs.lastrc = SQL_ERROR;
     539             :                                 /* FIXME this row is used only as a flag for update binding,
     540             :                                  * should be cleared if binding/result changed */
     541         330 :                                 stmt->row = 0;
     542         330 :                                 break;
     543             : 
     544          88 :                         case TDS_ROWFMT_RESULT:
     545             :                                 /* store first row information */
     546          88 :                                 if (!in_row)
     547          72 :                                         odbc_populate_ird(stmt);
     548          88 :                                 stmt->row = 0;
     549          88 :                                 stmt->row_count = TDS_NO_COUNT;
     550          88 :                                 stmt->row_status = PRE_NORMAL_ROW;
     551          88 :                                 in_row = true;
     552          88 :                                 break;
     553             :                         }
     554         418 :                         continue;
     555             :                 case TDS_NO_MORE_RESULTS:
     556             :                         break;
     557           0 :                 case TDS_CANCELLED:
     558           0 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
     559          10 :                 default:
     560          10 :                         stmt->errs.lastrc = SQL_ERROR;
     561          10 :                         break;
     562             :                 }
     563         340 :                 break;
     564             :         }
     565             : 
     566         340 :         if (stmt->errs.lastrc == SQL_ERROR && !stmt->dyn->emulated) {
     567          12 :                 tds_release_dynamic(&stmt->dyn);
     568             :         }
     569         340 :         odbc_unlock_statement(stmt);
     570         340 :         stmt->need_reprepare = 0;
     571         340 :         ODBC_RETURN_(stmt);
     572             : }
     573             : 
     574         138 : ODBC_FUNC(SQLDriverConnect, (P(SQLHDBC,hdbc), P(SQLHWND,hwnd), PCHARIN(ConnStrIn,SQLSMALLINT),
     575             :         PCHAROUT(ConnStrOut,SQLSMALLINT), P(SQLUSMALLINT,fDriverCompletion) WIDE))
     576             : {
     577             :         TDSLOGIN *login;
     578             :         TDS_PARSED_PARAM params[ODBC_PARAM_SIZE];
     579         138 :         DSTR conn_str = DSTR_INITIALIZER;
     580             : 
     581         138 :         ODBC_ENTER_HDBC;
     582             : 
     583             : #ifdef TDS_NO_DM
     584             :         /* Check string length */
     585         138 :         if (!IS_VALID_LEN(cbConnStrIn) || cbConnStrIn == 0) {
     586           0 :                 odbc_errs_add(&dbc->errs, "HY090", NULL);
     587           0 :                 ODBC_EXIT_(dbc);
     588             :         }
     589             : 
     590             :         /* Check completion param */
     591         138 :         switch (fDriverCompletion) {
     592             :         case SQL_DRIVER_NOPROMPT:
     593             :         case SQL_DRIVER_COMPLETE:
     594             :         case SQL_DRIVER_PROMPT:
     595             :         case SQL_DRIVER_COMPLETE_REQUIRED:
     596             :                 break;
     597           0 :         default:
     598           0 :                 odbc_errs_add(&dbc->errs, "HY110", NULL);
     599           0 :                 ODBC_EXIT_(dbc);
     600             :         }
     601             : #endif
     602             : 
     603         138 :         if (!odbc_dstr_copy(dbc, &conn_str, cbConnStrIn, szConnStrIn)) {
     604           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
     605           0 :                 ODBC_EXIT_(dbc);
     606             :         }
     607             : 
     608         138 :         login = tds_alloc_login(false);
     609         138 :         if (!login || !tds_init_login(login, dbc->env->tds_ctx->locale)) {
     610           0 :                 tds_free_login(login);
     611           0 :                 tds_dstr_free(&conn_str);
     612           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
     613           0 :                 ODBC_EXIT_(dbc);
     614             :         }
     615             : 
     616         276 :         if (!tds_dstr_isempty(&dbc->attr.current_catalog))
     617          20 :                 if (!tds_dstr_dup(&login->database, &dbc->attr.current_catalog)) {
     618           0 :                         tds_free_login(login);
     619           0 :                         tds_dstr_free(&conn_str);
     620           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
     621           0 :                         ODBC_EXIT_(dbc);
     622             :                 }
     623             : 
     624             :         /* parse the DSN string */
     625         414 :         if (!odbc_parse_connect_string(&dbc->errs, tds_dstr_buf(&conn_str), tds_dstr_buf(&conn_str) + tds_dstr_len(&conn_str),
     626             :                                        login, params)) {
     627           0 :                 tds_dstr_free(&conn_str);
     628           0 :                 ODBC_EXIT_(dbc);
     629             :         }
     630             : 
     631         414 :         odbc_set_dstr(dbc, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, &conn_str);
     632         138 :         tds_dstr_free(&conn_str);
     633             : 
     634             :         /* add login info */
     635         138 :         if (hwnd && fDriverCompletion != SQL_DRIVER_NOPROMPT
     636           0 :             && (fDriverCompletion == SQL_DRIVER_PROMPT || (!params[ODBC_PARAM_UID].p && !params[ODBC_PARAM_Trusted_Connection].p)
     637           0 :                 || tds_dstr_isempty(&login->server_name))) {
     638             : #ifdef _WIN32
     639             :                 char *out = NULL;
     640             : 
     641             :                 /* prompt for login information */
     642             :                 if (!get_login_info(hwnd, login)) {
     643             :                         tds_free_login(login);
     644             :                         odbc_errs_add(&dbc->errs, "08001", "User canceled login");
     645             :                         ODBC_EXIT_(dbc);
     646             :                 }
     647             :                 if (tds_dstr_isempty(&login->user_name)) {
     648             :                         params[ODBC_PARAM_UID].p = NULL;
     649             :                         params[ODBC_PARAM_PWD].p = NULL;
     650             :                         params[ODBC_PARAM_Trusted_Connection].p = "Yes";
     651             :                         params[ODBC_PARAM_Trusted_Connection].len = 3;
     652             :                 } else {
     653             :                         params[ODBC_PARAM_UID].p   = tds_dstr_cstr(&login->user_name);
     654             :                         params[ODBC_PARAM_UID].len = tds_dstr_len(&login->user_name);
     655             :                         params[ODBC_PARAM_PWD].p   = tds_dstr_cstr(&login->password);
     656             :                         params[ODBC_PARAM_PWD].len = tds_dstr_len(&login->password);
     657             :                         params[ODBC_PARAM_Trusted_Connection].p = NULL;
     658             :                 }
     659             :                 if (!odbc_build_connect_string(&dbc->errs, params, &out))
     660             :                         ODBC_EXIT_(dbc);
     661             : 
     662             :                 odbc_set_string(dbc, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, out, -1);
     663             :                 tdsdump_log(TDS_DBG_INFO1, "connection string is now: %s\n", out);
     664             :                 free(out);
     665             : #else
     666             :                 /* we dont support a dialog box */
     667           0 :                 odbc_errs_add(&dbc->errs, "HYC00", NULL);
     668             : #endif
     669             :         }
     670             : 
     671         276 :         if (tds_dstr_isempty(&login->server_name)) {
     672           0 :                 tds_free_login(login);
     673           0 :                 odbc_errs_add(&dbc->errs, "IM007", "Could not find Servername or server parameter");
     674           0 :                 ODBC_EXIT_(dbc);
     675             :         }
     676             : 
     677         138 :         odbc_connect(dbc, login);
     678             : 
     679         138 :         tds_free_login(login);
     680         138 :         ODBC_EXIT_(dbc);
     681             : }
     682             : 
     683             : #if 0
     684             : SQLRETURN ODBC_PUBLIC ODBC_API
     685             : SQLBrowseConnect(SQLHDBC hdbc, SQLCHAR FAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR FAR * szConnStrOut,
     686             :                  SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR * pcbConnStrOut)
     687             : {
     688             :         ODBC_ENTER_HDBC;
     689             : 
     690             :         tdsdump_log(TDS_DBG_FUNC, "SQLBrowseConnect(%p, %s, %d, %p, %d, %p)\n",
     691             :                         hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
     692             :         odbc_errs_add(&dbc->errs, "HYC00", "SQLBrowseConnect: function not implemented");
     693             :         ODBC_EXIT_(dbc);
     694             : }
     695             : #endif
     696             : 
     697             : 
     698           0 : ODBC_FUNC(SQLColumnPrivileges, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT), PCHARIN(SchemaName,SQLSMALLINT),
     699             :         PCHARIN(TableName,SQLSMALLINT), PCHARIN(ColumnName,SQLSMALLINT) WIDE))
     700             : {
     701             :         int retcode;
     702             : 
     703           0 :         ODBC_ENTER_HSTMT;
     704             : 
     705           0 :         retcode =
     706           0 :                 odbc_stat_execute(stmt _wide, "sp_column_privileges", 4, "O@table_qualifier", szCatalogName, cbCatalogName,
     707             :                                   "O@table_owner", szSchemaName, cbSchemaName, "O@table_name", szTableName, cbTableName,
     708             :                                   "P@column_name", szColumnName, cbColumnName);
     709           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
     710           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
     711           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
     712             :         }
     713           0 :         ODBC_EXIT_(stmt);
     714             : }
     715             : 
     716             : SQLRETURN ODBC_PUBLIC ODBC_API
     717             : SQLDescribeParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT FAR * pfSqlType, SQLULEN FAR * pcbParamDef,
     718             :                  SQLSMALLINT FAR * pibScale, SQLSMALLINT FAR * pfNullable)
     719             : {
     720             :         TDS_DESC *ipd;
     721             :         struct _drecord *drec;
     722             : 
     723          27 :         ODBC_ENTER_HSTMT;
     724             : 
     725          27 :         tdsdump_log(TDS_DBG_FUNC, "SQLDescribeParam(%p, %d, %p, %p, %p, %p)\n",
     726             :                         hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
     727             : 
     728             :         /* Check if we need to ask server (not set params, we not asked before). */
     729             :         /* We need to reset set params resetting them. */
     730          27 :         if (!stmt->params_queried && !stmt->params_set && stmt->param_count > 0)
     731           9 :                 read_params(stmt);
     732             : 
     733             :         /* return information from IPD */
     734          27 :         ipd = stmt->ipd;
     735          27 :         if (ipar < 1 || ipar > ipd->header.sql_desc_count) {
     736           7 :                 odbc_errs_add(&stmt->errs, "07009", NULL);
     737           7 :                 ODBC_EXIT_(stmt);
     738             :         }
     739          20 :         drec = &ipd->records[ipar - 1];
     740             : 
     741          20 :         if (pfSqlType)
     742          20 :                 *pfSqlType = drec->sql_desc_type;
     743          20 :         if (pfNullable)
     744          20 :                 *pfNullable = drec->sql_desc_nullable;
     745          20 :         switch (drec->sql_desc_type) {
     746           2 :         case SQL_DECIMAL:
     747             :         case SQL_NUMERIC:
     748           2 :                 if (pcbParamDef)
     749           2 :                         *pcbParamDef = drec->sql_desc_precision;
     750           2 :                 if (pibScale)
     751           2 :                         *pibScale = drec->sql_desc_scale;
     752             :                 break;
     753          18 :         default:
     754          18 :                 if (pcbParamDef)
     755          18 :                         *pcbParamDef = drec->sql_desc_length;
     756          18 :                 if (pibScale)
     757          18 :                         *pibScale = 0;
     758             :                 break;
     759             :         }
     760          20 :         ODBC_EXIT_(stmt);
     761             : }
     762             : 
     763             : SQLRETURN ODBC_PUBLIC ODBC_API
     764             : SQLExtendedFetch(SQLHSTMT hstmt, SQLUSMALLINT fFetchType, SQLROWOFFSET irow,
     765             :                  SQLROWSETSIZE FAR * pcrow, SQLUSMALLINT FAR * rgfRowStatus)
     766             : {
     767             :         SQLRETURN ret;
     768             :         SQLULEN * tmp_rows;
     769             :         SQLUSMALLINT * tmp_status;
     770             :         SQLULEN tmp_size;
     771             :         SQLLEN * tmp_offset;
     772             :         SQLPOINTER tmp_bookmark;
     773             :         SQLULEN bookmark;
     774          18 :         SQLULEN out_len = 0;
     775             : 
     776          18 :         ODBC_ENTER_HSTMT;
     777             : 
     778          18 :         tdsdump_log(TDS_DBG_FUNC, "SQLExtendedFetch(%p, %d, %d, %p, %p)\n",
     779             :                         hstmt, fFetchType, (int)irow, pcrow, rgfRowStatus);
     780             : 
     781          18 :         if (fFetchType != SQL_FETCH_NEXT && !stmt->dbc->cursor_support) {
     782           0 :                 odbc_errs_add(&stmt->errs, "HY106", NULL);
     783           0 :                 ODBC_EXIT_(stmt);
     784             :         }
     785             : 
     786             :         /* save and change IRD/ARD state */
     787          18 :         tmp_rows = stmt->ird->header.sql_desc_rows_processed_ptr;
     788          18 :         stmt->ird->header.sql_desc_rows_processed_ptr = &out_len;
     789          18 :         tmp_status = stmt->ird->header.sql_desc_array_status_ptr;
     790          18 :         stmt->ird->header.sql_desc_array_status_ptr = rgfRowStatus;
     791          18 :         tmp_size = stmt->ard->header.sql_desc_array_size;
     792          18 :         stmt->ard->header.sql_desc_array_size = stmt->sql_rowset_size;
     793          18 :         tmp_offset = stmt->ard->header.sql_desc_bind_offset_ptr;
     794          18 :         stmt->ard->header.sql_desc_bind_offset_ptr = NULL;
     795          18 :         tmp_bookmark = stmt->attr.fetch_bookmark_ptr;
     796             : 
     797             :         /* SQL_FETCH_BOOKMARK different */
     798          18 :         if (fFetchType == SQL_FETCH_BOOKMARK) {
     799           0 :                 bookmark = irow;
     800           0 :                 irow = 0;
     801           0 :                 stmt->attr.fetch_bookmark_ptr = &bookmark;
     802             :         }
     803             : 
     804             :         /* TODO errors are sligthly different ... perhaps it's better to leave DM do this job ?? */
     805             :         /* TODO check fFetchType can be converted to USMALLINT */
     806          18 :         ret = odbc_SQLFetch(stmt, fFetchType, irow);
     807             : 
     808             :         /* restore IRD/ARD */
     809          18 :         stmt->ird->header.sql_desc_rows_processed_ptr = tmp_rows;
     810          18 :         if (pcrow)
     811          18 :                 *pcrow = out_len;
     812          18 :         stmt->ird->header.sql_desc_array_status_ptr = tmp_status;
     813          18 :         stmt->ard->header.sql_desc_array_size = tmp_size;
     814          18 :         stmt->ard->header.sql_desc_bind_offset_ptr = tmp_offset;
     815          18 :         stmt->attr.fetch_bookmark_ptr = tmp_bookmark;
     816             : 
     817          18 :         ODBC_EXIT(stmt, ret);
     818             : }
     819             : 
     820           0 : ODBC_FUNC(SQLForeignKeys, (P(SQLHSTMT,hstmt), PCHARIN(PkCatalogName,SQLSMALLINT),
     821             :         PCHARIN(PkSchemaName,SQLSMALLINT), PCHARIN(PkTableName,SQLSMALLINT),
     822             :         PCHARIN(FkCatalogName,SQLSMALLINT), PCHARIN(FkSchemaName,SQLSMALLINT),
     823             :         PCHARIN(FkTableName,SQLSMALLINT) WIDE))
     824             : {
     825             :         int retcode;
     826             : 
     827           0 :         ODBC_ENTER_HSTMT;
     828             : 
     829           0 :         retcode =
     830           0 :                 odbc_stat_execute(stmt _wide, "sp_fkeys", 6,
     831             :                                   "O@pktable_qualifier", szPkCatalogName, cbPkCatalogName,
     832             :                                   "O@pktable_owner", szPkSchemaName, cbPkSchemaName,
     833             :                                   "O@pktable_name", szPkTableName, cbPkTableName,
     834             :                                   "O@fktable_qualifier", szFkCatalogName, cbFkCatalogName,
     835             :                                   "O@fktable_owner", szFkSchemaName, cbFkSchemaName,
     836             :                                   "O@fktable_name", szFkTableName, cbFkTableName);
     837           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
     838           0 :                 odbc_col_setname(stmt, 1, "PKTABLE_CAT");
     839           0 :                 odbc_col_setname(stmt, 2, "PKTABLE_SCHEM");
     840           0 :                 odbc_col_setname(stmt, 5, "FKTABLE_CAT");
     841           0 :                 odbc_col_setname(stmt, 6, "FKTABLE_SCHEM");
     842             :         }
     843           0 :         ODBC_EXIT_(stmt);
     844             : }
     845             : 
     846             : static bool
     847       69279 : odbc_lock_statement(TDS_STMT* stmt)
     848             : {
     849             : #if ENABLE_ODBC_MARS
     850       34775 :         TDSSOCKET *tds = stmt->tds;
     851             : 
     852             : 
     853             :         /* we already own a socket, just use it */
     854       34775 :         if (!tds) {
     855             :                 /* try with one saved into DBC */
     856       16757 :                 TDSSOCKET *dbc_tds = stmt->dbc->tds_socket;
     857       16757 :                 tds_mutex_lock(&stmt->dbc->mtx);
     858             : 
     859       16757 :                 if (stmt->dbc->current_statement == NULL
     860          56 :                     || stmt->dbc->current_statement == stmt) {
     861       16701 :                         tds = dbc_tds;
     862       16701 :                         stmt->dbc->current_statement = stmt;
     863             :                 }
     864             : 
     865             :                 /* try to grab current locked one */
     866       16757 :                 if (!tds && dbc_tds->state == TDS_IDLE) {
     867          40 :                         stmt->dbc->current_statement->tds = NULL;
     868          40 :                         tds = dbc_tds;
     869          40 :                         stmt->dbc->current_statement = stmt;
     870             :                 }
     871       16757 :                 tds_mutex_unlock(&stmt->dbc->mtx);
     872             : 
     873             :                 /* try with MARS */
     874       16757 :                 if (!tds)
     875          16 :                         tds = tds_alloc_additional_socket(dbc_tds->conn);
     876             :         }
     877       34775 :         if (tds) {
     878       69538 :                 tds->query_timeout = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ?
     879       34769 :                         stmt->attr.query_timeout : stmt->dbc->default_query_timeout;
     880       34769 :                 tds_set_parent(tds, stmt);
     881       34769 :                 stmt->tds = tds;
     882       34769 :                 return true;
     883             :         }
     884           6 :         odbc_errs_add(&stmt->errs, "24000", NULL);
     885           6 :         return false;
     886             : #else
     887       34504 :         TDSSOCKET *tds = stmt->dbc->tds_socket;
     888             : 
     889       34504 :         tds_mutex_lock(&stmt->dbc->mtx);
     890       34504 :         if (stmt->dbc->current_statement != NULL
     891       17808 :             && stmt->dbc->current_statement != stmt) {
     892          51 :                 if (!tds || tds->state != TDS_IDLE) {
     893          11 :                         tds_mutex_unlock(&stmt->dbc->mtx);
     894          11 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
     895          11 :                         return false;
     896             :                 }
     897          40 :                 stmt->dbc->current_statement->tds = NULL;
     898             :         }
     899       34493 :         stmt->dbc->current_statement = stmt;
     900       34493 :         if (tds) {
     901       68986 :                 tds->query_timeout = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ?
     902       34493 :                         stmt->attr.query_timeout : stmt->dbc->default_query_timeout;
     903       34493 :                 tds_set_parent(tds, stmt);
     904       34493 :                 stmt->tds = tds;
     905             :         }
     906       34493 :         tds_mutex_unlock(&stmt->dbc->mtx);
     907       34493 :         return true;
     908             : #endif
     909             : }
     910             : 
     911             : static void
     912       48566 : odbc_unlock_statement(TDS_STMT* stmt)
     913             : {
     914             :         TDSSOCKET * tds;
     915             : 
     916       48566 :         tds_mutex_lock(&stmt->dbc->mtx);
     917       48566 :         tds = stmt->tds;
     918       48566 :         if (stmt->dbc->current_statement == stmt) {
     919       32899 :                 assert(tds == stmt->dbc->tds_socket);
     920       32899 :                 if (tds->state == TDS_IDLE || tds->state == TDS_DEAD) {
     921       32899 :                         stmt->dbc->current_statement = NULL;
     922       32899 :                         tds_set_parent(tds, stmt->dbc);
     923       32899 :                         stmt->tds = NULL;
     924             :                 }
     925             : #if ENABLE_ODBC_MARS
     926        7839 :         } else if (tds) {
     927          10 :                 if (tds->state == TDS_IDLE || tds->state == TDS_DEAD) {
     928          10 :                         assert(tds != stmt->dbc->tds_socket);
     929          10 :                         tds_free_socket(tds);
     930          10 :                         stmt->tds = NULL;
     931             :                 }
     932             : #endif
     933             :         }
     934       48566 :         tds_mutex_unlock(&stmt->dbc->mtx);
     935       48566 : }
     936             : 
     937             : SQLRETURN ODBC_PUBLIC ODBC_API
     938             : SQLMoreResults(SQLHSTMT hstmt)
     939             : {
     940             :         TDSSOCKET *tds;
     941             :         TDS_INT result_type;
     942             :         TDSRET tdsret;
     943       10964 :         bool in_row = false;
     944             :         SQLUSMALLINT param_status;
     945             :         unsigned int token_flags;
     946             : 
     947       10964 :         ODBC_ENTER_HSTMT;
     948             : 
     949       10964 :         tdsdump_log(TDS_DBG_FUNC, "SQLMoreResults(%p)\n", hstmt);
     950             : 
     951       10964 :         tds = stmt->tds;
     952             : 
     953             :         /* We already read all results... */
     954       10964 :         if (!tds)
     955         811 :                 ODBC_EXIT(stmt, SQL_NO_DATA);
     956             : 
     957       10153 :         stmt->row_count = TDS_NO_COUNT;
     958       10153 :         stmt->special_row = ODBC_SPECIAL_NONE;
     959             : 
     960             :         /* TODO this code is TOO similar to odbc_SQLExecute, merge it - freddy77 */
     961             :         /* try to go to the next recordset */
     962       10153 :         if (stmt->row_status == IN_COMPUTE_ROW) {
     963             :                 /* FIXME doesn't seem so fine ... - freddy77 */
     964          16 :                 tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
     965          16 :                 stmt->row_status = IN_COMPUTE_ROW;
     966          16 :                 in_row = true;
     967             :         }
     968             : 
     969       10153 :         param_status = SQL_PARAM_SUCCESS;
     970       10153 :         token_flags = (TDS_TOKEN_RESULTS & (~TDS_STOPAT_COMPUTE)) | TDS_RETURN_COMPUTE;
     971       10153 :         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
     972        8331 :                 token_flags |= TDS_RETURN_MSG;
     973             :         for (;;) {
     974       10696 :                 result_type = odbc_process_tokens(stmt, token_flags);
     975       10696 :                 tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: result_type=%d, row_count=%" PRId64 ", lastrc=%d\n",
     976           0 :                                                 result_type, stmt->row_count, stmt->errs.lastrc);
     977       10696 :                 switch (result_type) {
     978        8993 :                 case TDS_CMD_DONE:
     979             : #if 1 /* !UNIXODBC */
     980        8993 :                         tds_free_all_results(tds);
     981             : #endif
     982        8993 :                         odbc_populate_ird(stmt);
     983        8993 :                         odbc_unlock_statement(stmt);
     984        8993 :                         if (stmt->row_count == TDS_NO_COUNT && !in_row) {
     985        8965 :                                 stmt->row_status = NOT_IN_ROW;
     986        8965 :                                 tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: row_status=%d\n", stmt->row_status);
     987             :                         }
     988        8993 :                         tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: row_count=%" PRId64 ", lastrc=%d\n", stmt->row_count,
     989           0 :                                     stmt->errs.lastrc);
     990        8993 :                         if (stmt->row_count == TDS_NO_COUNT) {
     991        8977 :                                 if (stmt->errs.lastrc == SQL_SUCCESS || stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO)
     992        8973 :                                         ODBC_EXIT(stmt, SQL_NO_DATA);
     993             :                         }
     994          20 :                         ODBC_EXIT_(stmt);
     995             : 
     996           0 :                 case TDS_CMD_FAIL:
     997           0 :                         ODBC_SAFE_ERROR(stmt);
     998           0 :                         ODBC_EXIT_(stmt);
     999             : 
    1000          48 :                 case TDS_COMPUTE_RESULT:
    1001          48 :                         switch (stmt->row_status) {
    1002             :                         /* skip this recordset */
    1003             :                         case IN_COMPUTE_ROW:
    1004             :                                 /* TODO here we should set current_results to normal results */
    1005             :                                 in_row = true;
    1006             :                                 /* fall through */
    1007             :                         /* in normal row, put in compute status */
    1008          48 :                         case AFTER_COMPUTE_ROW:
    1009             :                         case IN_NORMAL_ROW:
    1010             :                         case PRE_NORMAL_ROW:
    1011          48 :                                 stmt->row_status = IN_COMPUTE_ROW;
    1012          48 :                                 odbc_populate_ird(stmt);
    1013          48 :                                 ODBC_EXIT_(stmt);
    1014           0 :                         case NOT_IN_ROW:
    1015             :                                 /* this should never happen, protocol error */
    1016           0 :                                 ODBC_SAFE_ERROR(stmt);
    1017           0 :                                 ODBC_EXIT_(stmt);
    1018             :                                 break;
    1019             :                         }
    1020             :                         break;
    1021             : 
    1022         389 :                 case TDS_ROW_RESULT:
    1023         389 :                         if (in_row || (stmt->row_status != IN_NORMAL_ROW && stmt->row_status != PRE_NORMAL_ROW)) {
    1024         158 :                                 stmt->row_status = PRE_NORMAL_ROW;
    1025         158 :                                 odbc_populate_ird(stmt);
    1026         158 :                                 ODBC_EXIT_(stmt);
    1027             :                         }
    1028             :                         /* Skipping current result set's rows to access next resultset or proc's retval */
    1029         231 :                         tdsret = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_STOPAT_COMPUTE);
    1030             :                         /* TODO should we set in_row ?? */
    1031         231 :                         switch (tdsret) {
    1032           0 :                         case TDS_CANCELLED:
    1033           0 :                                 odbc_errs_add(&stmt->errs, "HY008", NULL);
    1034         231 :                         default:
    1035         231 :                                 if (TDS_FAILED(tdsret)) {
    1036           0 :                                         ODBC_SAFE_ERROR(stmt);
    1037           0 :                                         ODBC_EXIT_(stmt);
    1038             :                                 }
    1039             :                         }
    1040             :                         break;
    1041             : 
    1042         872 :                 case TDS_DONE_RESULT:
    1043             :                 case TDS_DONEPROC_RESULT:
    1044             :                         /* FIXME here ??? */
    1045         872 :                         if (!in_row)
    1046         804 :                                 tds_free_all_results(tds);
    1047         872 :                         switch (stmt->errs.lastrc) {
    1048          70 :                         case SQL_ERROR:
    1049          70 :                                 param_status = SQL_PARAM_ERROR;
    1050          70 :                                 break;
    1051          58 :                         case SQL_SUCCESS_WITH_INFO:
    1052          58 :                                 param_status = SQL_PARAM_SUCCESS_WITH_INFO;
    1053          58 :                                 break;
    1054             :                         }
    1055         872 :                         if (stmt->curr_param_row < stmt->num_param_rows) {
    1056           0 :                                 if (stmt->ipd->header.sql_desc_array_status_ptr)
    1057           0 :                                         stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
    1058           0 :                                 ++stmt->curr_param_row;
    1059           0 :                                 if (stmt->ipd->header.sql_desc_rows_processed_ptr)
    1060           0 :                                         *stmt->ipd->header.sql_desc_rows_processed_ptr = stmt->curr_param_row;
    1061             :                         }
    1062         872 :                         if (stmt->curr_param_row < stmt->num_param_rows) {
    1063             : #if 0
    1064             :                                 if (stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO)
    1065             :                                         found_info = 1;
    1066             :                                 if (stmt->errs.lastrc == SQL_ERROR)
    1067             :                                         found_error = 1;
    1068             : #endif
    1069           0 :                                 stmt->errs.lastrc = SQL_SUCCESS;
    1070           0 :                                 param_status = SQL_PARAM_SUCCESS;
    1071           0 :                                 break;
    1072             :                         }
    1073         872 :                         odbc_populate_ird(stmt);
    1074         872 :                         ODBC_EXIT_(stmt);
    1075             :                         break;
    1076             : 
    1077             :                         /*
    1078             :                          * TODO test flags ? check error and change result ?
    1079             :                          * see also other DONEINPROC handle (below)
    1080             :                          */
    1081          86 :                 case TDS_DONEINPROC_RESULT:
    1082          86 :                         if (in_row) {
    1083          70 :                                 odbc_populate_ird(stmt);
    1084          70 :                                 ODBC_EXIT_(stmt);
    1085             :                         }
    1086             :                         /* TODO perhaps it can be a problem if SET NOCOUNT ON, test it */
    1087          16 :                         tds_free_all_results(tds);
    1088          16 :                         odbc_populate_ird(stmt);
    1089          16 :                         break;
    1090             : 
    1091             :                         /* do not stop at metadata, an error can follow... */
    1092         194 :                 case TDS_ROWFMT_RESULT:
    1093         194 :                         if (in_row) {
    1094          12 :                                 odbc_populate_ird(stmt);
    1095          12 :                                 ODBC_EXIT_(stmt);
    1096             :                         }
    1097         182 :                         stmt->row = 0;
    1098         182 :                         stmt->row_count = TDS_NO_COUNT;
    1099             :                         /* we expect a row */
    1100         182 :                         stmt->row_status = PRE_NORMAL_ROW;
    1101         182 :                         in_row = true;
    1102         182 :                         break;
    1103             : 
    1104         114 :                 case TDS_MSG_RESULT:
    1105         114 :                         if (!in_row) {
    1106         114 :                                 tds_free_all_results(tds);
    1107         114 :                                 odbc_populate_ird(stmt);
    1108             :                         }
    1109             :                         in_row = true;
    1110             :                         break;
    1111             :                 }
    1112             :         }
    1113             :         ODBC_EXIT(stmt, SQL_ERROR);
    1114             : }
    1115             : 
    1116           0 : ODBC_FUNC(SQLNativeSql, (P(SQLHDBC,hdbc), PCHARIN(SqlStrIn,SQLINTEGER),
    1117             :         PCHAROUT(SqlStr,SQLINTEGER) WIDE))
    1118             : {
    1119           0 :         SQLRETURN ret = SQL_SUCCESS;
    1120           0 :         DSTR query = DSTR_INITIALIZER;
    1121             : 
    1122           0 :         ODBC_ENTER_HDBC;
    1123             : 
    1124             : #ifdef TDS_NO_DM
    1125           0 :         if (!szSqlStrIn || !IS_VALID_LEN(cbSqlStrIn)) {
    1126           0 :                 odbc_errs_add(&dbc->errs, "HY009", NULL);
    1127           0 :                 ODBC_EXIT_(dbc);
    1128             :         }
    1129             : #endif
    1130             : 
    1131           0 :         if (!odbc_dstr_copy(dbc, &query, cbSqlStrIn, szSqlStrIn)) {
    1132           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1133           0 :                 ODBC_EXIT_(dbc);
    1134             :         }
    1135             : 
    1136           0 :         native_sql(dbc, &query);
    1137             : 
    1138             :         /* FIXME if error set some kind of error */
    1139           0 :         ret = odbc_set_dstr(dbc, szSqlStr, cbSqlStrMax, pcbSqlStr, &query);
    1140             : 
    1141           0 :         tds_dstr_free(&query);
    1142             : 
    1143           0 :         ODBC_EXIT(dbc, ret);
    1144             : }
    1145             : 
    1146             : SQLRETURN ODBC_PUBLIC ODBC_API
    1147             : SQLNumParams(SQLHSTMT hstmt, SQLSMALLINT FAR * pcpar)
    1148             : {
    1149          46 :         ODBC_ENTER_HSTMT;
    1150          46 :         tdsdump_log(TDS_DBG_FUNC, "SQLNumParams(%p, %p)\n", hstmt, pcpar);
    1151          46 :         *pcpar = stmt->param_count;
    1152          46 :         ODBC_EXIT_(stmt);
    1153             : }
    1154             : 
    1155             : SQLRETURN ODBC_PUBLIC ODBC_API
    1156             : SQLParamOptions(SQLHSTMT hstmt, SQLULEN crow, SQLULEN FAR * pirow)
    1157             : {
    1158             :         SQLRETURN res;
    1159             : 
    1160          20 :         tdsdump_log(TDS_DBG_FUNC, "SQLParamOptions(%p, %lu, %p)\n", hstmt, (unsigned long int)crow, pirow);
    1161             : 
    1162             :         /* emulate for ODBC 2 DM */
    1163          20 :         res = odbc_SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, pirow, 0 _wide0);
    1164          20 :         if (res != SQL_SUCCESS)
    1165             :                 return res;
    1166          20 :         return odbc_SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crow, 0 _wide0);
    1167             : }
    1168             : 
    1169           0 : ODBC_FUNC(SQLPrimaryKeys, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1170             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT) WIDE))
    1171             : {
    1172             :         int retcode;
    1173             : 
    1174           0 :         ODBC_ENTER_HSTMT;
    1175             : 
    1176           0 :         retcode =
    1177           0 :                 odbc_stat_execute(stmt _wide, "sp_pkeys", 3, "O@table_qualifier", szCatalogName, cbCatalogName, "O@table_owner",
    1178             :                                   szSchemaName, cbSchemaName, "O@table_name", szTableName, cbTableName);
    1179           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1180           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    1181           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    1182             :         }
    1183           0 :         ODBC_EXIT_(stmt);
    1184             : }
    1185             : 
    1186          20 : ODBC_FUNC(SQLProcedureColumns, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1187             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(ProcName,SQLSMALLINT), PCHARIN(ColumnName,SQLSMALLINT) WIDE))
    1188             : {
    1189             :         int retcode;
    1190             : 
    1191          20 :         ODBC_ENTER_HSTMT;
    1192             : 
    1193          20 :         retcode =
    1194          20 :                 odbc_stat_execute(stmt _wide, "sp_sproc_columns", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4,
    1195             :                                   "O@procedure_qualifier", szCatalogName, cbCatalogName,
    1196             :                                   "P@procedure_owner", szSchemaName, cbSchemaName, "P@procedure_name", szProcName, cbProcName,
    1197             :                                   "P@column_name", szColumnName, cbColumnName, "V@ODBCVer", (char*) NULL, 0);
    1198          20 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1199          10 :                 odbc_col_setname(stmt, 1, "PROCEDURE_CAT");
    1200          10 :                 odbc_col_setname(stmt, 2, "PROCEDURE_SCHEM");
    1201          10 :                 odbc_col_setname(stmt, 8, "COLUMN_SIZE");
    1202          10 :                 odbc_col_setname(stmt, 9, "BUFFER_LENGTH");
    1203          10 :                 odbc_col_setname(stmt, 10, "DECIMAL_DIGITS");
    1204          10 :                 odbc_col_setname(stmt, 11, "NUM_PREC_RADIX");
    1205          10 :                 if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
    1206           2 :                         stmt->special_row = ODBC_SPECIAL_PROCEDURECOLUMNS;
    1207             :         }
    1208          20 :         ODBC_EXIT_(stmt);
    1209             : }
    1210             : 
    1211           0 : ODBC_FUNC(SQLProcedures, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1212             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(ProcName,SQLSMALLINT) WIDE))
    1213             : {
    1214             :         int retcode;
    1215             : 
    1216           0 :         ODBC_ENTER_HSTMT;
    1217             : 
    1218           0 :         retcode =
    1219           0 :                 odbc_stat_execute(stmt _wide, "..sp_stored_procedures", 3,
    1220             :                                   "P@sp_name", szProcName, cbProcName,
    1221             :                                   "P@sp_owner", szSchemaName, cbSchemaName,
    1222             :                                   "O@sp_qualifier", szCatalogName, cbCatalogName);
    1223           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1224           0 :                 odbc_col_setname(stmt, 1, "PROCEDURE_CAT");
    1225           0 :                 odbc_col_setname(stmt, 2, "PROCEDURE_SCHEM");
    1226             :         }
    1227           0 :         ODBC_EXIT_(stmt);
    1228             : }
    1229             : 
    1230             : static TDSPARAMINFO*
    1231          80 : odbc_build_update_params(TDS_STMT * stmt, SQLSETPOSIROW n_row)
    1232             : {
    1233             :         SQLSMALLINT n;
    1234          80 :         TDSPARAMINFO * params = NULL;
    1235             :         struct _drecord *drec_ird;
    1236             : 
    1237         240 :         for (n = 0; n < stmt->ird->header.sql_desc_count && n < stmt->ard->header.sql_desc_count; ++n) {
    1238             :                 TDSPARAMINFO *temp_params;
    1239             :                 TDSCOLUMN *curcol;
    1240             : 
    1241         160 :                 drec_ird = &stmt->ird->records[n];
    1242             : 
    1243         160 :                 if (drec_ird->sql_desc_updatable == SQL_FALSE)
    1244          16 :                         continue;
    1245             : 
    1246             :                 /* we have certainly a parameter */
    1247         144 :                 if (!(temp_params = tds_alloc_param_result(params)))
    1248             :                         goto memory_error;
    1249         144 :                 params = temp_params;
    1250             : 
    1251         144 :                 curcol = params->columns[params->num_cols - 1];
    1252         144 :                 if (!tds_dstr_dup(&curcol->column_name, &drec_ird->sql_desc_name))
    1253             :                         goto memory_error;
    1254             : 
    1255             :                 /* TODO use all infos... */
    1256         144 :                 if (!tds_dstr_dup(&curcol->table_name, &drec_ird->sql_desc_base_table_name))
    1257             :                         goto memory_error;
    1258             : 
    1259         144 :                 switch (odbc_sql2tds(stmt, drec_ird, &stmt->ard->records[n], curcol, true, stmt->ard, n_row)) {
    1260             :                 case SQL_NEED_DATA:
    1261             :                         goto memory_error;
    1262           0 :                 case SQL_ERROR:
    1263           0 :                         tds_free_param_results(params);
    1264           0 :                         return NULL;
    1265             :                 }
    1266             :         }
    1267             :         return params;
    1268             : 
    1269           0 : memory_error:
    1270           0 :         tds_free_param_results(params);
    1271           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    1272           0 :         return NULL;
    1273             : }
    1274             : 
    1275             : SQLRETURN ODBC_PUBLIC ODBC_API
    1276             : SQLSetPos(SQLHSTMT hstmt, SQLSETPOSIROW irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock)
    1277             : {
    1278             :         TDSRET ret;
    1279             :         TDSSOCKET *tds;
    1280             :         TDS_CURSOR_OPERATION op;
    1281         320 :         TDSPARAMINFO *params = NULL;
    1282         320 :         ODBC_ENTER_HSTMT;
    1283             : 
    1284         320 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetPos(%p, %ld, %d, %d)\n",
    1285             :                         hstmt, (long) irow, fOption, fLock);
    1286             : 
    1287         320 :         if (!stmt->dbc->cursor_support) {
    1288           0 :                 odbc_errs_add(&stmt->errs, "HYC00", "SQLSetPos: function not implemented");
    1289           0 :                 ODBC_EXIT_(stmt);
    1290             :         }
    1291             : 
    1292             :         /* TODO handle irow == 0 (all rows) */
    1293             : 
    1294         320 :         if (!stmt->cursor) {
    1295           0 :                 odbc_errs_add(&stmt->errs, "HY109", NULL);
    1296           0 :                 ODBC_EXIT_(stmt);
    1297             :         }
    1298             : 
    1299         320 :         switch (fOption) {
    1300             :         case SQL_POSITION:
    1301             :                 op = TDS_CURSOR_POSITION;
    1302             :                 break;
    1303             :         /* TODO cursor support */
    1304           0 :         case SQL_REFRESH:
    1305             :         default:
    1306           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    1307           0 :                 ODBC_EXIT_(stmt);
    1308             :                 break;
    1309          80 :         case SQL_UPDATE:
    1310          80 :                 op = TDS_CURSOR_UPDATE;
    1311             :                 /* prepare paremeters for update */
    1312             :                 /* scan all columns and build parameter list */
    1313          80 :                 params = odbc_build_update_params(stmt, irow >= 1 ? irow - 1 : 0);
    1314          80 :                 if (!params) {
    1315           0 :                         ODBC_SAFE_ERROR(stmt);
    1316           0 :                         ODBC_EXIT_(stmt);
    1317             :                 }
    1318             :                 break;
    1319          80 :         case SQL_DELETE:
    1320          80 :                 op = TDS_CURSOR_DELETE;
    1321          80 :                 break;
    1322           0 :         case SQL_ADD:
    1323           0 :                 op = TDS_CURSOR_INSERT;
    1324           0 :                 break;
    1325             :         }
    1326             : 
    1327         320 :         if (!odbc_lock_statement(stmt)) {
    1328           0 :                 tds_free_param_results(params);
    1329           0 :                 ODBC_EXIT_(stmt);
    1330             :         }
    1331             : 
    1332         320 :         tds = stmt->tds;
    1333             : 
    1334         320 :         if (TDS_FAILED(tds_cursor_update(tds, stmt->cursor, op, irow, params))) {
    1335           0 :                 tds_free_param_results(params);
    1336           0 :                 ODBC_SAFE_ERROR(stmt);
    1337           0 :                 ODBC_EXIT_(stmt);
    1338             :         }
    1339         320 :         tds_free_param_results(params);
    1340         320 :         params = NULL;
    1341             : 
    1342         320 :         ret = tds_process_simple_query(tds);
    1343         320 :         odbc_unlock_statement(stmt);
    1344         320 :         if (TDS_FAILED(ret)) {
    1345           0 :                 ODBC_SAFE_ERROR(stmt);
    1346           0 :                 ODBC_EXIT_(stmt);
    1347             :         }
    1348             : 
    1349         320 :         ODBC_EXIT_(stmt);
    1350             : }
    1351             : 
    1352           0 : ODBC_FUNC(SQLTablePrivileges, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1353             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT) WIDE))
    1354             : {
    1355             :         int retcode;
    1356             : 
    1357           0 :         ODBC_ENTER_HSTMT;
    1358             : 
    1359           0 :         retcode =
    1360           0 :                 odbc_stat_execute(stmt _wide, "sp_table_privileges", 3, "O@table_qualifier", szCatalogName, cbCatalogName,
    1361             :                                   "P@table_owner", szSchemaName, cbSchemaName, "P@table_name", szTableName, cbTableName);
    1362           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1363           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    1364           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    1365             :         }
    1366           0 :         ODBC_EXIT_(stmt);
    1367             : }
    1368             : 
    1369             : #if (ODBCVER >= 0x0300)
    1370             : SQLRETURN ODBC_PUBLIC ODBC_API
    1371             : SQLSetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER StringLength)
    1372             : {
    1373         572 :         SQLINTEGER i_val = (SQLINTEGER) (TDS_INTPTR) Value;
    1374             : 
    1375         572 :         ODBC_ENTER_HENV;
    1376             : 
    1377         572 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetEnvAttr(%p, %d, %p, %d)\n", henv, (int)Attribute, Value, (int)StringLength);
    1378             : 
    1379         572 :         switch (Attribute) {
    1380           0 :         case SQL_ATTR_CONNECTION_POOLING:
    1381             :         case SQL_ATTR_CP_MATCH:
    1382           0 :                 odbc_errs_add(&env->errs, "HYC00", NULL);
    1383           0 :                 break;
    1384         572 :         case SQL_ATTR_ODBC_VERSION:
    1385         572 :                 switch (i_val) {
    1386         572 :                 case SQL_OV_ODBC3:
    1387             :                 case SQL_OV_ODBC2:
    1388         572 :                         env->attr.odbc_version = i_val;
    1389         572 :                         break;
    1390           0 :                 default:
    1391           0 :                         odbc_errs_add(&env->errs, "HY024", NULL);
    1392           0 :                         break;
    1393             :                 }
    1394             :                 break;
    1395           0 :         case SQL_ATTR_OUTPUT_NTS:
    1396             :                 /* TODO - Make this really work */
    1397             :                 /* env->attr.output_nts = i_val; */
    1398           0 :                 env->attr.output_nts = SQL_TRUE;
    1399           0 :                 break;
    1400           0 :         default:
    1401           0 :                 odbc_errs_add(&env->errs, "HY092", NULL);
    1402           0 :                 break;
    1403             :         }
    1404         572 :         ODBC_EXIT_(env);
    1405             : }
    1406             : 
    1407             : SQLRETURN ODBC_PUBLIC ODBC_API
    1408             : SQLGetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
    1409             : {
    1410             :         static const SQLINTEGER unicode_type =
    1411             :                 sizeof(SQLWCHAR) == 4 ? SQL_DM_CP_UCS4 : SQL_DM_CP_UTF16;
    1412             :         SQLINTEGER size;
    1413             :         const void *src;
    1414             : 
    1415           0 :         ODBC_ENTER_HENV;
    1416             : 
    1417           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetEnvAttr(%p, %d, %p, %d, %p)\n",
    1418             :                         henv, (int)Attribute, Value, (int)BufferLength, StringLength);
    1419             : 
    1420           0 :         switch (Attribute) {
    1421           0 :         case SQL_ATTR_CONNECTION_POOLING:
    1422           0 :                 src = &env->attr.connection_pooling;
    1423           0 :                 size = sizeof(env->attr.connection_pooling);
    1424           0 :                 break;
    1425           0 :         case SQL_ATTR_CP_MATCH:
    1426           0 :                 src = &env->attr.cp_match;
    1427           0 :                 size = sizeof(env->attr.cp_match);
    1428           0 :                 break;
    1429           0 :         case SQL_ATTR_ODBC_VERSION:
    1430           0 :                 src = &env->attr.odbc_version;
    1431           0 :                 size = sizeof(env->attr.odbc_version);
    1432           0 :                 break;
    1433           0 :         case SQL_ATTR_OUTPUT_NTS:
    1434             :                 /* TODO handle output_nts flags */
    1435           0 :                 env->attr.output_nts = SQL_TRUE;
    1436           0 :                 src = &env->attr.output_nts;
    1437           0 :                 size = sizeof(env->attr.output_nts);
    1438           0 :                 break;
    1439             :         case SQL_ATTR_DRIVER_UNICODE_TYPE:
    1440             :                 /* iODBC extension, tell which Unicode encoding we support */
    1441             :                 src = &unicode_type;
    1442             :                 size = sizeof(unicode_type);
    1443             :                 break;
    1444           0 :         default:
    1445           0 :                 odbc_errs_add(&env->errs, "HY092", NULL);
    1446           0 :                 ODBC_EXIT_(env);
    1447             :                 break;
    1448             :         }
    1449             : 
    1450           0 :         if (StringLength) {
    1451           0 :                 *StringLength = size;
    1452             :         }
    1453           0 :         memcpy(Value, src, size);
    1454             : 
    1455           0 :         ODBC_EXIT_(env);
    1456             : }
    1457             : 
    1458             : #endif
    1459             : 
    1460             : #define IRD_UPDATE(desc, errs, exit) \
    1461             :         do { \
    1462             :                 if (desc->type == DESC_IRD && ((TDS_STMT*)desc->parent)->need_reprepare && \
    1463             :                     odbc_update_ird((TDS_STMT*)desc->parent, errs) != SQL_SUCCESS) \
    1464             :                         exit; \
    1465             :         } while(0)
    1466             : 
    1467             : static SQLRETURN
    1468       15148 : odbc_SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
    1469             :                   SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    1470             : {
    1471             :         TDS_DESC *apd, *ipd;
    1472             :         struct _drecord *drec;
    1473             :         SQLSMALLINT orig_apd_size, orig_ipd_size;
    1474       15148 :         bool is_numeric = false;
    1475             : 
    1476       15148 :         ODBC_ENTER_HSTMT;
    1477             : 
    1478       15148 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLBindParameter(%p, %u, %d, %d, %d, %u, %d, %p, %d, %p)\n",
    1479             :                         hstmt, (unsigned)ipar, (int)fParamType, (int)fCType, (int)fSqlType, (unsigned int)cbColDef,
    1480             :                         (int)ibScale, rgbValue, (int)cbValueMax, pcbValue);
    1481             : 
    1482             : #ifdef TDS_NO_DM
    1483             :         /* TODO - more error checking ...  XXX smurph */
    1484             : 
    1485             :         /* Check param type */
    1486             :         switch (fParamType) {
    1487             :         case SQL_PARAM_INPUT:
    1488             :         case SQL_PARAM_INPUT_OUTPUT:
    1489             :         case SQL_PARAM_OUTPUT:
    1490             :                 break;
    1491           0 :         default:
    1492           0 :                 odbc_errs_add(&stmt->errs, "HY105", NULL);
    1493           0 :                 ODBC_EXIT_(stmt);
    1494             :         }
    1495             : 
    1496             :         /* Check max buffer length */
    1497       15148 :         if (cbValueMax < 0 && cbValueMax != SQL_NTS) {
    1498           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    1499           0 :                 ODBC_EXIT_(stmt);
    1500             :         }
    1501             : #endif
    1502             : 
    1503             :         /* check cbColDef and ibScale */
    1504       15148 :         if (fSqlType == SQL_DECIMAL || fSqlType == SQL_NUMERIC) {
    1505         220 :                 is_numeric = true;
    1506         220 :                 if (cbColDef < 1 || cbColDef > 38) {
    1507           0 :                         odbc_errs_add(&stmt->errs, "HY104", "Invalid precision value");
    1508           0 :                         ODBC_EXIT_(stmt);
    1509             :                 }
    1510         220 :                 if (ibScale < 0 || (SQLULEN) ibScale > cbColDef) {
    1511           0 :                         odbc_errs_add(&stmt->errs, "HY104", "Invalid scale value");
    1512           0 :                         ODBC_EXIT_(stmt);
    1513             :                 }
    1514             :         }
    1515             : 
    1516             :         /* Check parameter number */
    1517       15148 :         if (ipar <= 0 || ipar > 4000) {
    1518           0 :                 odbc_errs_add(&stmt->errs, "07009", NULL);
    1519           0 :                 ODBC_EXIT_(stmt);
    1520             :         }
    1521             : 
    1522             :         /* special checks for table type */
    1523       15148 :         if (fSqlType == SQL_SS_TABLE) {
    1524             :                 /* Table types are strictly read-only */
    1525        4152 :                 if (fParamType != SQL_PARAM_INPUT) {
    1526          12 :                         odbc_errs_add(&stmt->errs, "HY105", NULL);
    1527          12 :                         ODBC_EXIT_(stmt);
    1528             :                 }
    1529             : 
    1530             :                 /* Only SQL_C_DEFAULT is accepted */
    1531        4140 :                 if (fCType != SQL_C_DEFAULT) {
    1532           4 :                         odbc_errs_add(&stmt->errs, "07006", NULL);
    1533           4 :                         ODBC_EXIT_(stmt);
    1534             :                 }
    1535             :                 fCType = SQL_C_BINARY;
    1536             :         }
    1537             : 
    1538       15132 :         apd = stmt->apd;
    1539       15132 :         ipd = stmt->ipd;
    1540             : 
    1541             :         /* If the parameter focus is set to 0, bind values as arguments */
    1542             :         /* Otherwise, bind values as the columns of a table-valued parameter */
    1543       15132 :         if (stmt->attr.param_focus != 0) {
    1544             :                 SQLTVP *tvp;
    1545             : 
    1546             :                 /* a table type cannot contain a table type */
    1547        4148 :                 if (fSqlType == SQL_SS_TABLE) {
    1548           8 :                         odbc_errs_add(&stmt->errs, "HY004", NULL);
    1549           8 :                         ODBC_EXIT_(stmt);
    1550             :                 }
    1551             : 
    1552             :                 /* Columns of table types are strictly read-only */
    1553        4140 :                 if (fParamType != SQL_PARAM_INPUT) {
    1554           0 :                         odbc_errs_add(&stmt->errs, "HY105", NULL);
    1555           0 :                         ODBC_EXIT_(stmt);
    1556             :                 }
    1557             : 
    1558             :                 /* check index */
    1559        4140 :                 if (stmt->attr.param_focus > ipd->header.sql_desc_count) {
    1560           0 :                         odbc_errs_add(&stmt->errs, "IM020", NULL);
    1561           0 :                         ODBC_EXIT_(stmt);
    1562             :                 }
    1563             : 
    1564        4140 :                 drec = &ipd->records[stmt->attr.param_focus - 1];
    1565             : 
    1566             :                 /* check ipd type */
    1567        4140 :                 if (drec->sql_desc_concise_type != SQL_SS_TABLE) {
    1568           0 :                         odbc_errs_add(&stmt->errs, "IM020", NULL);
    1569           0 :                         ODBC_EXIT_(stmt);
    1570             :                 }
    1571             : 
    1572        4140 :                 tvp = (SQLTVP *) drec->sql_desc_data_ptr;
    1573        4140 :                 apd = tvp->apd;
    1574        4140 :                 ipd = tvp->ipd;
    1575             :         }
    1576             : 
    1577             :         /* fill APD related fields */
    1578       15124 :         orig_apd_size = apd->header.sql_desc_count;
    1579       15124 :         if (ipar > apd->header.sql_desc_count && desc_alloc_records(apd, ipar) != SQL_SUCCESS) {
    1580           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    1581           0 :                 ODBC_EXIT_(stmt);
    1582             :         }
    1583       15124 :         drec = &apd->records[ipar - 1];
    1584             : 
    1585       15124 :         if (odbc_set_concise_c_type(fCType, drec, 0) != SQL_SUCCESS) {
    1586          70 :                 desc_alloc_records(apd, orig_apd_size);
    1587          70 :                 odbc_errs_add(&stmt->errs, "HY004", NULL);
    1588          70 :                 ODBC_EXIT_(stmt);
    1589             :         }
    1590             : 
    1591       15054 :         stmt->need_reprepare = 1;
    1592             : 
    1593             :         /* TODO other types ?? handle SQL_C_DEFAULT */
    1594       15054 :         if (drec->sql_desc_type == SQL_C_CHAR || drec->sql_desc_type == SQL_C_WCHAR || drec->sql_desc_type == SQL_C_BINARY)
    1595        7456 :                 drec->sql_desc_octet_length = cbValueMax;
    1596       15054 :         drec->sql_desc_indicator_ptr = pcbValue;
    1597       15054 :         drec->sql_desc_octet_length_ptr = pcbValue;
    1598       15054 :         drec->sql_desc_data_ptr = (char *) rgbValue;
    1599             : 
    1600       15054 :         if (fSqlType == SQL_SS_TABLE)
    1601        4128 :                 drec->sql_desc_length = 1;
    1602             : 
    1603             :         /* field IPD related fields */
    1604       15054 :         orig_ipd_size = ipd->header.sql_desc_count;
    1605       15054 :         if (ipar > ipd->header.sql_desc_count && desc_alloc_records(ipd, ipar) != SQL_SUCCESS) {
    1606           0 :                 desc_alloc_records(apd, orig_apd_size);
    1607           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    1608           0 :                 ODBC_EXIT_(stmt);
    1609             :         }
    1610       15054 :         drec = &ipd->records[ipar - 1];
    1611             : 
    1612       15054 :         drec->sql_desc_parameter_type = fParamType;
    1613             : 
    1614       15054 :         if (odbc_set_concise_sql_type(fSqlType, drec, 0) != SQL_SUCCESS) {
    1615           0 :                 desc_alloc_records(ipd, orig_ipd_size);
    1616           0 :                 desc_alloc_records(apd, orig_apd_size);
    1617           0 :                 odbc_errs_add(&stmt->errs, "HY004", NULL);
    1618           0 :                 ODBC_EXIT_(stmt);
    1619             :         }
    1620       15054 :         if (is_numeric) {
    1621         220 :                 drec->sql_desc_precision = (SQLSMALLINT) cbColDef;
    1622         220 :                 drec->sql_desc_scale = ibScale;
    1623             :         } else {
    1624       14834 :                 drec->sql_desc_length = cbColDef;
    1625             :         }
    1626             : 
    1627       15054 :         if (fSqlType == SQL_SS_TABLE) {
    1628             :                 SQLTVP *tvp;
    1629        4128 :                 int wide TDS_UNUSED = 1;
    1630             : 
    1631        4128 :                 tvp = tvp_alloc(stmt);
    1632        4128 :                 if (tvp == NULL) {
    1633           0 :                         desc_alloc_records(ipd, orig_ipd_size);
    1634           0 :                         desc_alloc_records(apd, orig_apd_size);
    1635           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    1636           0 :                         ODBC_EXIT_(stmt);
    1637             :                 }
    1638        4128 :                 tvp->apd->header.sql_desc_array_size = cbColDef;
    1639             : 
    1640        4128 :                 if (!odbc_dstr_copy_oct(stmt->dbc, &tvp->type_name, cbValueMax, (ODBC_CHAR *) rgbValue)) {
    1641           0 :                         free(tvp);
    1642           0 :                         desc_alloc_records(ipd, orig_ipd_size);
    1643           0 :                         desc_alloc_records(apd, orig_apd_size);
    1644           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    1645           0 :                         ODBC_EXIT_(stmt);
    1646             :                 }
    1647             : 
    1648             :                 /* Use this the column type as a marker for us */
    1649             :                 /* to free up memory allocated with odbc_alloc_table() */
    1650        4128 :                 drec->sql_desc_type = drec->sql_desc_concise_type = SQL_SS_TABLE;
    1651             : 
    1652        4128 :                 drec->sql_desc_data_ptr = tvp;
    1653             : 
    1654        4128 :                 drec->sql_desc_length = 0;
    1655             :         }
    1656             : 
    1657       15054 :         stmt->params_set = 1;
    1658       15054 :         ODBC_EXIT_(stmt);
    1659             : }
    1660             : 
    1661             : SQLRETURN ODBC_PUBLIC ODBC_API
    1662             : SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
    1663             :                  SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    1664             : {
    1665       15148 :         tdsdump_log(TDS_DBG_FUNC, "SQLBindParameter(%p, %u, %d, %d, %d, %u, %d, %p, %d, %p)\n",
    1666             :                     hstmt, (unsigned)ipar, fParamType, fCType, (int)fSqlType, (unsigned)cbColDef, ibScale,
    1667             :                     rgbValue, (int)cbValueMax, pcbValue);
    1668       15148 :         return odbc_SQLBindParameter(hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale, rgbValue, cbValueMax, pcbValue);
    1669             : }
    1670             : 
    1671             : 
    1672             : /* compatibility with X/Open */
    1673             : SQLRETURN ODBC_PUBLIC ODBC_API
    1674             : SQLBindParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbColDef, SQLSMALLINT ibScale,
    1675             :              SQLPOINTER rgbValue, SQLLEN FAR * pcbValue)
    1676             : {
    1677           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLBindParam(%p, %d, %d, %d, %u, %d, %p, %p)\n",
    1678             :                         hstmt, ipar, fCType, fSqlType, (unsigned)cbColDef, ibScale, rgbValue, pcbValue);
    1679           0 :         return odbc_SQLBindParameter(hstmt, ipar, SQL_PARAM_INPUT, fCType, fSqlType, cbColDef, ibScale, rgbValue, 0, pcbValue);
    1680             : }
    1681             : 
    1682             : #if (ODBCVER >= 0x0300)
    1683             : SQLRETURN ODBC_PUBLIC ODBC_API
    1684             : SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
    1685             : {
    1686        1264 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocHandle(%d, %p, %p)\n", HandleType, InputHandle, OutputHandle);
    1687             : 
    1688        1264 :         switch (HandleType) {
    1689         120 :         case SQL_HANDLE_STMT:
    1690         120 :                 return odbc_SQLAllocStmt(InputHandle, OutputHandle);
    1691             :                 break;
    1692         562 :         case SQL_HANDLE_DBC:
    1693         562 :                 return odbc_SQLAllocConnect(InputHandle, OutputHandle);
    1694             :                 break;
    1695         562 :         case SQL_HANDLE_ENV:
    1696         562 :                 return odbc_SQLAllocEnv(OutputHandle, SQL_OV_ODBC3);
    1697             :                 break;
    1698          20 :         case SQL_HANDLE_DESC:
    1699          20 :                 return odbc_SQLAllocDesc(InputHandle, OutputHandle);
    1700             :                 break;
    1701             :         }
    1702             : 
    1703             :         /*
    1704             :          * As the documentation puts it,
    1705             :          *      "There is no handle with which to associate additional diagnostic information."
    1706             :          *
    1707             :          * The DM must catch HY092 because the driver has no valid handle at this early stage in which
    1708             :          * to store the error for later retrieval by the application.
    1709             :          */
    1710           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocHandle(): invalid HandleType, error HY092: should be caught by DM\n");
    1711             :         return SQL_ERROR;
    1712             : }
    1713             : #endif
    1714             : 
    1715             : static SQLRETURN
    1716        1160 : odbc_SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc)
    1717             : {
    1718             :         TDS_DBC *dbc;
    1719             : 
    1720        1160 :         ODBC_ENTER_HENV;
    1721             : 
    1722        1160 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLAllocConnect(%p, %p)\n", henv, phdbc);
    1723             : 
    1724        1160 :         dbc = tds_new0(TDS_DBC, 1);
    1725        1160 :         if (!dbc) {
    1726           0 :                 odbc_errs_add(&env->errs, "HY001", NULL);
    1727           0 :                 ODBC_EXIT_(env);
    1728             :         }
    1729             : 
    1730        1160 :         dbc->htype = SQL_HANDLE_DBC;
    1731        1160 :         dbc->env = env;
    1732        2320 :         tds_dstr_init(&dbc->dsn);
    1733             : 
    1734        1160 :         dbc->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    1735        1160 :         dbc->attr.access_mode = SQL_MODE_READ_WRITE;
    1736        1160 :         dbc->attr.async_enable = SQL_ASYNC_ENABLE_OFF;
    1737        1160 :         dbc->attr.auto_ipd = SQL_FALSE;
    1738             :         /*
    1739             :          * spinellia@acm.org
    1740             :          * after login is enabled autocommit
    1741             :          */
    1742        1160 :         dbc->attr.autocommit = SQL_AUTOCOMMIT_ON;
    1743        1160 :         dbc->attr.connection_dead = SQL_CD_TRUE;     /* No connection yet */
    1744        1160 :         dbc->attr.connection_timeout = 0;
    1745             :         /* This is set in the environment change function */
    1746        2320 :         tds_dstr_init(&dbc->attr.current_catalog);
    1747        1160 :         dbc->attr.login_timeout = 0; /* TODO */
    1748        1160 :         dbc->attr.metadata_id = SQL_FALSE;
    1749        1160 :         dbc->attr.odbc_cursors = SQL_CUR_USE_IF_NEEDED;
    1750        1160 :         dbc->attr.packet_size = 0;
    1751        1160 :         dbc->attr.quite_mode = NULL; /* We don't support GUI dialogs yet */
    1752             : #ifdef TDS_NO_DM
    1753        1160 :         dbc->attr.trace = SQL_OPT_TRACE_OFF;
    1754        2320 :         tds_dstr_init(&dbc->attr.tracefile);
    1755             : #endif
    1756        2320 :         tds_dstr_init(&dbc->attr.translate_lib);
    1757             : #ifdef ENABLE_ODBC_WIDE
    1758        1160 :         dbc->original_charset_num = TDS_CHARSET_UTF_8;
    1759             : #endif
    1760        2320 :         tds_dstr_init(&dbc->oldpwd);
    1761        2320 :         tds_dstr_init(&dbc->db_filename);
    1762        1160 :         dbc->attr.translate_option = 0;
    1763        1160 :         dbc->attr.txn_isolation = SQL_TXN_READ_COMMITTED;
    1764        1160 :         dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
    1765        1160 :         dbc->attr.bulk_enabled = SQL_BCP_OFF;
    1766             : 
    1767        2320 :         tds_mutex_init(&dbc->mtx);
    1768        1160 :         *phdbc = (SQLHDBC) dbc;
    1769             : 
    1770        1160 :         ODBC_EXIT_(env);
    1771             : }
    1772             : 
    1773             : SQLRETURN ODBC_PUBLIC ODBC_API
    1774             : SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc)
    1775             : {
    1776         598 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocConnect(%p, %p)\n", henv, phdbc);
    1777             : 
    1778         598 :         return odbc_SQLAllocConnect(henv, phdbc);
    1779             : }
    1780             : 
    1781             : static SQLRETURN
    1782        1160 : odbc_SQLAllocEnv(SQLHENV FAR * phenv, SQLINTEGER odbc_version)
    1783             : {
    1784             :         TDS_ENV *env;
    1785             :         TDSCONTEXT *ctx;
    1786             : 
    1787        1160 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLAllocEnv(%p, %d)\n",
    1788             :                         phenv, (int) odbc_version);
    1789             : 
    1790        1160 :         env = tds_new0(TDS_ENV, 1);
    1791        1160 :         if (!env)
    1792             :                 return SQL_ERROR;
    1793             : 
    1794        1160 :         env->htype = SQL_HANDLE_ENV;
    1795        1160 :         env->attr.odbc_version = odbc_version;
    1796             :         /* TODO use it */
    1797        1160 :         env->attr.output_nts = SQL_TRUE;
    1798             : 
    1799        1160 :         ctx = tds_alloc_context(env);
    1800        1160 :         if (!ctx) {
    1801           0 :                 free(env);
    1802           0 :                 return SQL_ERROR;
    1803             :         }
    1804        1160 :         env->tds_ctx = ctx;
    1805        1160 :         ctx->msg_handler = odbc_errmsg_handler;
    1806        1160 :         ctx->err_handler = odbc_errmsg_handler;
    1807             : 
    1808             :         /* ODBC has its own format */
    1809        1160 :         free(ctx->locale->datetime_fmt);
    1810        1160 :         ctx->locale->datetime_fmt = strdup("%Y-%m-%d %H:%M:%S.%z");
    1811        1160 :         free(ctx->locale->date_fmt);
    1812        1160 :         ctx->locale->date_fmt = strdup("%Y-%m-%d");
    1813        1160 :         free(ctx->locale->time_fmt);
    1814        1160 :         ctx->locale->time_fmt = strdup("%H:%M:%S.%z");
    1815             : 
    1816        2320 :         tds_mutex_init(&env->mtx);
    1817        1160 :         *phenv = (SQLHENV) env;
    1818             : 
    1819        1160 :         return SQL_SUCCESS;
    1820             : }
    1821             : 
    1822             : SQLRETURN ODBC_PUBLIC ODBC_API
    1823             : SQLAllocEnv(SQLHENV FAR * phenv)
    1824             : {
    1825         598 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocEnv(%p)\n", phenv);
    1826             : 
    1827         598 :         return odbc_SQLAllocEnv(phenv, SQL_OV_ODBC2);
    1828             : }
    1829             : 
    1830             : static SQLRETURN
    1831          20 : odbc_SQLAllocDesc(SQLHDBC hdbc, SQLHDESC FAR * phdesc)
    1832             : {
    1833             :         int i;
    1834             : 
    1835          20 :         ODBC_ENTER_HDBC;
    1836             : 
    1837          20 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLAllocDesc(%p, %p)\n", hdbc, phdesc);
    1838             : 
    1839          30 :         for (i = 0; ; ++i) {
    1840          40 :                 if (i >= TDS_MAX_APP_DESC) {
    1841           0 :                         odbc_errs_add(&dbc->errs, "HY014", NULL);
    1842           0 :                         break;
    1843             :                 }
    1844          30 :                 if (dbc->uad[i] == NULL) {
    1845          20 :                         TDS_DESC *desc = desc_alloc(dbc, DESC_ARD, SQL_DESC_ALLOC_USER);
    1846          20 :                         if (desc == NULL) {
    1847           0 :                                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1848           0 :                                 break;
    1849             :                         }
    1850          20 :                         dbc->uad[i] = desc;
    1851          20 :                         *phdesc = (SQLHDESC) desc;
    1852          20 :                         break;
    1853             :                 }
    1854             :         }
    1855          20 :         ODBC_EXIT_(dbc);
    1856             : }
    1857             : 
    1858             : static SQLRETURN
    1859       17679 : odbc_SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt)
    1860             : {
    1861             :         TDS_STMT *stmt;
    1862             :         char *pstr;
    1863             : 
    1864       17679 :         ODBC_ENTER_HDBC;
    1865             : 
    1866       17679 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLAllocStmt(%p, %p)\n", hdbc, phstmt);
    1867             : 
    1868       17679 :         stmt = tds_new0(TDS_STMT, 1);
    1869       17679 :         if (!stmt) {
    1870           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1871           0 :                 ODBC_EXIT_(dbc);
    1872             :         }
    1873       35358 :         tds_dstr_init(&stmt->cursor_name);
    1874       35358 :         tds_dstr_init(&stmt->query);
    1875             : 
    1876       17679 :         stmt->htype = SQL_HANDLE_STMT;
    1877       17679 :         stmt->dbc = dbc;
    1878       17679 :         stmt->num_param_rows = 1;
    1879       17679 :         pstr = NULL;
    1880             :         /* TODO test initial cursor ... */
    1881       17679 :         if (asprintf(&pstr, "SQL_CUR%p", stmt) < 0 || !tds_dstr_set(&stmt->cursor_name, pstr)) {
    1882           0 :                 free(stmt);
    1883           0 :                 free(pstr);
    1884           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1885           0 :                 ODBC_EXIT_(dbc);
    1886             :         }
    1887             :         /* do not free pstr tds_dstr_set do it if necessary */
    1888             : 
    1889             :         /* allocate descriptors */
    1890       17679 :         stmt->ird = desc_alloc(stmt, DESC_IRD, SQL_DESC_ALLOC_AUTO);
    1891       17679 :         stmt->ard = desc_alloc(stmt, DESC_ARD, SQL_DESC_ALLOC_AUTO);
    1892       17679 :         stmt->ipd = desc_alloc(stmt, DESC_IPD, SQL_DESC_ALLOC_AUTO);
    1893       17679 :         stmt->apd = desc_alloc(stmt, DESC_APD, SQL_DESC_ALLOC_AUTO);
    1894       17679 :         if (!stmt->ird || !stmt->ard || !stmt->ipd || !stmt->apd) {
    1895           0 :                 tds_dstr_free(&stmt->cursor_name);
    1896           0 :                 desc_free(stmt->ird);
    1897           0 :                 desc_free(stmt->ard);
    1898           0 :                 desc_free(stmt->ipd);
    1899           0 :                 desc_free(stmt->apd);
    1900           0 :                 free(stmt);
    1901           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1902           0 :                 ODBC_EXIT_(dbc);
    1903             :         }
    1904             : 
    1905             :         /* save original ARD and APD */
    1906       17679 :         stmt->orig_apd = stmt->apd;
    1907       17679 :         stmt->orig_ard = stmt->ard;
    1908             : 
    1909             :         /* set the default statement attributes */
    1910             : /*      stmt->attr.app_param_desc = stmt->apd; */
    1911             : /*      stmt->attr.app_row_desc = stmt->ard; */
    1912       17679 :         stmt->attr.async_enable = SQL_ASYNC_ENABLE_OFF;
    1913       17679 :         stmt->attr.concurrency = SQL_CONCUR_READ_ONLY;
    1914       17679 :         stmt->attr.cursor_scrollable = SQL_NONSCROLLABLE;
    1915       17679 :         stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    1916       17679 :         stmt->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    1917             :         /* TODO ?? why two attributes */
    1918       17679 :         stmt->attr.enable_auto_ipd = dbc->attr.auto_ipd = SQL_FALSE;
    1919       17679 :         stmt->attr.fetch_bookmark_ptr = NULL;
    1920             : /*      stmt->attr.imp_param_desc = stmt->ipd; */
    1921             : /*      stmt->attr.imp_row_desc = stmt->ird; */
    1922       17679 :         stmt->attr.keyset_size = 0;
    1923       17679 :         stmt->attr.max_length = 0;
    1924       17679 :         stmt->attr.max_rows = 0;
    1925       17679 :         stmt->attr.metadata_id = dbc->attr.metadata_id;
    1926             :         /* TODO check this flag in prepare_call */
    1927       17679 :         stmt->attr.noscan = SQL_NOSCAN_OFF;
    1928       17679 :         assert(stmt->apd->header.sql_desc_bind_offset_ptr == NULL);
    1929       17679 :         assert(stmt->apd->header.sql_desc_bind_type == SQL_PARAM_BIND_BY_COLUMN);
    1930       17679 :         assert(stmt->apd->header.sql_desc_array_status_ptr == NULL);
    1931       17679 :         assert(stmt->ipd->header.sql_desc_array_status_ptr == NULL);
    1932       17679 :         assert(stmt->ipd->header.sql_desc_rows_processed_ptr == NULL);
    1933       17679 :         assert(stmt->apd->header.sql_desc_array_size == 1);
    1934       17679 :         stmt->attr.query_timeout = DEFAULT_QUERY_TIMEOUT;
    1935       17679 :         stmt->attr.retrieve_data = SQL_RD_ON;
    1936       17679 :         assert(stmt->ard->header.sql_desc_array_size == 1);
    1937       17679 :         assert(stmt->ard->header.sql_desc_bind_offset_ptr == NULL);
    1938       17679 :         assert(stmt->ard->header.sql_desc_bind_type == SQL_BIND_BY_COLUMN);
    1939       17679 :         stmt->attr.row_number = 0;
    1940       17679 :         assert(stmt->ard->header.sql_desc_array_status_ptr == NULL);
    1941       17679 :         assert(stmt->ird->header.sql_desc_array_status_ptr == NULL);
    1942       17679 :         assert(stmt->ird->header.sql_desc_rows_processed_ptr == NULL);
    1943       17679 :         stmt->attr.simulate_cursor = SQL_SC_NON_UNIQUE;
    1944       17679 :         stmt->attr.use_bookmarks = SQL_UB_OFF;
    1945       35358 :         tds_dstr_init(&stmt->attr.qn_msgtext);
    1946       35358 :         tds_dstr_init(&stmt->attr.qn_options);
    1947       17679 :         stmt->attr.qn_timeout = 432000;
    1948             : 
    1949       17679 :         stmt->sql_rowset_size = 1;
    1950             : 
    1951       17679 :         stmt->row_count = TDS_NO_COUNT;
    1952       17679 :         stmt->row_status = NOT_IN_ROW;
    1953             : 
    1954             :         /* insert into list */
    1955       17679 :         stmt->next = dbc->stmt_list;
    1956       17679 :         if (dbc->stmt_list)
    1957         349 :                 dbc->stmt_list->prev = stmt;
    1958       17679 :         dbc->stmt_list = stmt;
    1959             : 
    1960       35358 :         tds_mutex_init(&stmt->mtx);
    1961       17679 :         *phstmt = (SQLHSTMT) stmt;
    1962             : 
    1963       17679 :         if (dbc->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY)
    1964           0 :                 odbc_SQLSetStmtAttr(stmt, SQL_CURSOR_TYPE, (SQLPOINTER) (TDS_INTPTR) dbc->attr.cursor_type, SQL_IS_INTEGER _wide0);
    1965             : 
    1966       17679 :         stmt->attr.param_focus = 0;
    1967             : 
    1968       17679 :         ODBC_EXIT_(dbc);
    1969             : }
    1970             : 
    1971             : SQLRETURN ODBC_PUBLIC ODBC_API
    1972             : SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt)
    1973             : {
    1974       17559 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocStmt(%p, %p)\n", hdbc, phstmt);
    1975             : 
    1976       17559 :         return odbc_SQLAllocStmt(hdbc, phstmt);
    1977             : }
    1978             : 
    1979             : SQLRETURN ODBC_PUBLIC ODBC_API
    1980             : SQLBindCol(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    1981             : {
    1982             :         TDS_DESC *ard;
    1983             :         struct _drecord *drec;
    1984             :         SQLSMALLINT orig_ard_size;
    1985             : 
    1986        6114 :         ODBC_ENTER_HSTMT;
    1987             : 
    1988        6114 :         tdsdump_log(TDS_DBG_FUNC, "SQLBindCol(%p, %d, %d, %p, %d, %p)\n",
    1989             :                         hstmt, icol, fCType, rgbValue, (int)cbValueMax, pcbValue);
    1990             : 
    1991             :         /* TODO - More error checking XXX smurph */
    1992             : 
    1993             : #ifdef TDS_NO_DM
    1994             :         /* check conversion type */
    1995        6114 :         switch (fCType) {
    1996        3182 :         case SQL_C_CHAR:
    1997             :         case SQL_C_WCHAR:
    1998             :         case SQL_C_BINARY:
    1999             :         case SQL_C_DEFAULT:
    2000             :                 /* check max buffer length */
    2001        3182 :                 if (!IS_VALID_LEN(cbValueMax)) {
    2002           0 :                         odbc_errs_add(&stmt->errs, "HY090", NULL);
    2003           0 :                         ODBC_EXIT_(stmt);
    2004             :                 }
    2005             :                 break;
    2006             :         }
    2007             : #endif
    2008             : 
    2009        6114 :         if (icol <= 0 || icol > 4000) {
    2010           0 :                 odbc_errs_add(&stmt->errs, "07009", NULL);
    2011           0 :                 ODBC_EXIT_(stmt);
    2012             :         }
    2013             : 
    2014        6114 :         ard = stmt->ard;
    2015        6114 :         orig_ard_size = ard->header.sql_desc_count;
    2016        6114 :         if (icol > ard->header.sql_desc_count && desc_alloc_records(ard, icol) != SQL_SUCCESS) {
    2017           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    2018           0 :                 ODBC_EXIT_(stmt);
    2019             :         }
    2020             : 
    2021        6114 :         drec = &ard->records[icol - 1];
    2022             : 
    2023        6114 :         if (odbc_set_concise_c_type(fCType, drec, 0) != SQL_SUCCESS) {
    2024           0 :                 desc_alloc_records(ard, orig_ard_size);
    2025           0 :                 odbc_errs_add(&stmt->errs, "HY003", NULL);
    2026           0 :                 ODBC_EXIT_(stmt);
    2027             :         }
    2028        6114 :         drec->sql_desc_octet_length = cbValueMax;
    2029        6114 :         drec->sql_desc_octet_length_ptr = pcbValue;
    2030        6114 :         drec->sql_desc_indicator_ptr = pcbValue;
    2031        6114 :         drec->sql_desc_data_ptr = rgbValue;
    2032             : 
    2033             :         /* force rebind */
    2034        6114 :         stmt->row = 0;
    2035             : 
    2036        6114 :         ODBC_EXIT_(stmt);
    2037             : }
    2038             : 
    2039             : SQLRETURN ODBC_PUBLIC ODBC_API
    2040             : SQLCancel(SQLHSTMT hstmt)
    2041             : {
    2042             :         TDSSOCKET *tds;
    2043             : 
    2044             :         /*
    2045             :          * FIXME this function can be called from other thread, do not free
    2046             :          * errors for this function
    2047             :          * If function is called from another thread errors are not touched
    2048             :          */
    2049             :         /* TODO some tests required */
    2050          80 :         TDS_STMT *stmt = (TDS_STMT*)hstmt;
    2051          80 :         if (SQL_NULL_HSTMT == hstmt || !IS_HSTMT(hstmt))
    2052             :                 return SQL_INVALID_HANDLE;
    2053             : 
    2054          80 :         tdsdump_log(TDS_DBG_FUNC, "SQLCancel(%p)\n", hstmt);
    2055             : 
    2056          80 :         tds = stmt->tds;
    2057             : 
    2058             :         /* cancelling an inactive statement */
    2059          80 :         if (!tds)
    2060             :                 /* Just return success */
    2061             :                 /* Note that we don't own locks so don't use ODBC_EXIT here. */
    2062             :                 return SQL_SUCCESS;
    2063             : 
    2064          50 :         if (tds_mutex_trylock(&stmt->mtx) == 0) {
    2065          10 :                 CHECK_STMT_EXTRA(stmt);
    2066          10 :                 odbc_errs_reset(&stmt->errs);
    2067             : 
    2068             :                 /* FIXME test current statement */
    2069             :                 /* FIXME here we are unlocked */
    2070             : 
    2071          10 :                 if (TDS_FAILED(tds_send_cancel(tds))) {
    2072           0 :                         ODBC_SAFE_ERROR(stmt);
    2073           0 :                         ODBC_EXIT_(stmt);
    2074             :                 }
    2075             : 
    2076          10 :                 if (TDS_FAILED(tds_process_cancel(tds))) {
    2077           0 :                         ODBC_SAFE_ERROR(stmt);
    2078           0 :                         ODBC_EXIT_(stmt);
    2079             :                 }
    2080             : 
    2081             :                 /* only if we processed cancel reset statement */
    2082          10 :                 if (tds->state == TDS_IDLE)
    2083          10 :                         odbc_unlock_statement(stmt);
    2084             : 
    2085          10 :                 ODBC_EXIT_(stmt);
    2086             :         }
    2087             : 
    2088             :         /* don't access error here, just return error */
    2089          40 :         if (TDS_FAILED(tds_send_cancel(tds)))
    2090             :                 return SQL_ERROR;
    2091          40 :         return SQL_SUCCESS;
    2092             : }
    2093             : 
    2094        1002 : ODBC_FUNC(SQLConnect, (P(SQLHDBC,hdbc), PCHARIN(DSN,SQLSMALLINT), PCHARIN(UID,SQLSMALLINT),
    2095             :         PCHARIN(AuthStr,SQLSMALLINT) WIDE))
    2096             : {
    2097             :         TDSLOGIN *login;
    2098             :         DSTR *s;
    2099             : 
    2100        1002 :         ODBC_ENTER_HDBC;
    2101             : 
    2102             : #ifdef TDS_NO_DM
    2103        1002 :         if (szDSN && !IS_VALID_LEN(cbDSN)) {
    2104           0 :                 odbc_errs_add(&dbc->errs, "HY090", "Invalid DSN buffer length");
    2105           0 :                 ODBC_EXIT_(dbc);
    2106             :         }
    2107             : 
    2108        1002 :         if (szUID && !IS_VALID_LEN(cbUID)) {
    2109           0 :                 odbc_errs_add(&dbc->errs, "HY090", "Invalid UID buffer length");
    2110           0 :                 ODBC_EXIT_(dbc);
    2111             :         }
    2112             : 
    2113        1002 :         if (szAuthStr && !IS_VALID_LEN(cbAuthStr)) {
    2114           0 :                 odbc_errs_add(&dbc->errs, "HY090", "Invalid PWD buffer length");
    2115           0 :                 ODBC_EXIT_(dbc);
    2116             :         }
    2117             : #endif
    2118             : 
    2119        1002 :         login = tds_alloc_login(false);
    2120        1002 :         if (!login || !tds_init_login(login, dbc->env->tds_ctx->locale))
    2121             :                 goto memory_error;
    2122             : 
    2123             :         /* data source name */
    2124        1002 :         if (odbc_get_string_size(cbDSN, szDSN _wide))
    2125        1002 :                 s = odbc_dstr_copy(dbc, &dbc->dsn, cbDSN, szDSN);
    2126             :         else
    2127           0 :                 s = tds_dstr_copy(&dbc->dsn, "DEFAULT");
    2128        1002 :         if (!s)
    2129             :                 goto memory_error;
    2130             : 
    2131             : 
    2132        2004 :         if (!odbc_get_dsn_info(&dbc->errs, tds_dstr_cstr(&dbc->dsn), login)) {
    2133           0 :                 tds_free_login(login);
    2134           0 :                 ODBC_EXIT_(dbc);
    2135             :         }
    2136             : 
    2137        2004 :         if (!tds_dstr_isempty(&dbc->attr.current_catalog))
    2138          20 :                 if (!tds_dstr_dup(&login->database, &dbc->attr.current_catalog))
    2139             :                         goto memory_error;
    2140             : 
    2141             :         /*
    2142             :          * username/password are never saved to ini file,
    2143             :          * so you do not check in ini file
    2144             :          */
    2145             :         /* user id */
    2146        1002 :         if (odbc_get_string_size(cbUID, szUID _wide)) {
    2147        1002 :                 if (!odbc_dstr_copy(dbc, &login->user_name, cbUID, szUID))
    2148             :                         goto memory_error;
    2149             :         }
    2150             : 
    2151             :         /* password */
    2152        2004 :         if (szAuthStr && !tds_dstr_isempty(&login->user_name)) {
    2153        1002 :                 if (!odbc_dstr_copy(dbc, &login->password, cbAuthStr, szAuthStr))
    2154             :                         goto memory_error;
    2155             :         }
    2156             : 
    2157             :         /* DO IT */
    2158        1002 :         odbc_connect(dbc, login);
    2159             : 
    2160        1002 :         tds_free_login(login);
    2161        1002 :         ODBC_EXIT_(dbc);
    2162             : 
    2163           0 : memory_error:
    2164           0 :         tds_free_login(login);
    2165           0 :         odbc_errs_add(&dbc->errs, "HY001", NULL);
    2166           0 :         ODBC_EXIT_(dbc);
    2167             : }
    2168             : 
    2169        2328 : ODBC_FUNC(SQLDescribeCol, (P(SQLHSTMT,hstmt), P(SQLUSMALLINT,icol), PCHAROUT(ColName,SQLSMALLINT),
    2170             :         P(SQLSMALLINT FAR *,pfSqlType), P(SQLULEN FAR *,pcbColDef),
    2171             :         P(SQLSMALLINT FAR *,pibScale), P(SQLSMALLINT FAR *,pfNullable) WIDE))
    2172             : {
    2173             :         TDS_DESC *ird;
    2174             :         struct _drecord *drec;
    2175             :         SQLRETURN result;
    2176             : 
    2177        2328 :         ODBC_ENTER_HSTMT;
    2178             : 
    2179        2328 :         ird = stmt->ird;
    2180        2328 :         IRD_UPDATE(ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    2181             : 
    2182        2328 :         if (icol <= 0 || icol > ird->header.sql_desc_count) {
    2183           0 :                 odbc_errs_add(&stmt->errs, "07009", "Column out of range");
    2184           0 :                 ODBC_EXIT_(stmt);
    2185             :         }
    2186             :         /* check name length */
    2187        2328 :         if (cbColNameMax < 0) {
    2188           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    2189           0 :                 ODBC_EXIT_(stmt);
    2190             :         }
    2191        2328 :         drec = &ird->records[icol - 1];
    2192             : 
    2193             :         /* cbColNameMax can be 0 (to retrieve name length) */
    2194        2328 :         if (szColName == NULL)
    2195        1052 :                 cbColNameMax = 0;
    2196             : 
    2197             :         /* straight copy column name up to cbColNameMax */
    2198        6984 :         result = odbc_set_dstr(stmt->dbc, szColName, cbColNameMax, pcbColName, &drec->sql_desc_label);
    2199        2328 :         if (szColName && result == SQL_SUCCESS_WITH_INFO)
    2200          30 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    2201             : 
    2202        2328 :         if (pfSqlType) {
    2203             :                 /* TODO sure ? check documentation for date and intervals */
    2204        2328 :                 *pfSqlType = drec->sql_desc_concise_type;
    2205             :         }
    2206             : 
    2207        2328 :         if (pcbColDef) {
    2208        1200 :                 if (drec->sql_desc_type == SQL_NUMERIC || drec->sql_desc_type == SQL_DECIMAL) {
    2209         180 :                         *pcbColDef = drec->sql_desc_precision;
    2210             :                 } else {
    2211        1020 :                         *pcbColDef = drec->sql_desc_length;
    2212             :                 }
    2213             :         }
    2214        2328 :         if (pibScale) {
    2215        1200 :                 *pibScale = drec->sql_desc_scale;
    2216             :         }
    2217        2328 :         if (pfNullable) {
    2218        1200 :                 *pfNullable = drec->sql_desc_nullable;
    2219             :         }
    2220        2328 :         ODBC_EXIT_(stmt);
    2221             : }
    2222             : 
    2223             : static SQLRETURN
    2224        6572 : odbc_SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax,
    2225             :                  SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc _WIDE)
    2226             : {
    2227             :         TDS_DESC *ird;
    2228             :         struct _drecord *drec;
    2229        6572 :         SQLRETURN result = SQL_SUCCESS;
    2230             : 
    2231        6572 :         ODBC_ENTER_HSTMT;
    2232             : 
    2233        6572 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLColAttribute(%p, %u, %u, %p, %d, %p, %p)\n",
    2234             :                         hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
    2235             : 
    2236        6572 :         ird = stmt->ird;
    2237             : 
    2238             : #define COUT(src) result = odbc_set_string_oct(stmt->dbc, rgbDesc, cbDescMax, pcbDesc, src ? src : "", -1);
    2239             : #define SOUT(src) result = odbc_set_dstr_oct(stmt->dbc, rgbDesc, cbDescMax, pcbDesc, &src);
    2240             : 
    2241             : /* SQLColAttribute returns always attributes using SQLINTEGER */
    2242             : #if ENABLE_EXTRA_CHECKS
    2243             : #define IOUT(type, src) do { \
    2244             :         /* trick warning if type wrong */ \
    2245             :         type *p_test = &src; p_test = p_test; \
    2246             :         *pfDesc = src; } while(0)
    2247             : #else
    2248             : #define IOUT(type, src) *pfDesc = src
    2249             : #endif
    2250             : 
    2251        6572 :         IRD_UPDATE(ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    2252             : 
    2253             :         /* dont check column index for these */
    2254        6572 :         switch (fDescType) {
    2255             : #if SQL_COLUMN_COUNT != SQL_DESC_COUNT
    2256           0 :         case SQL_COLUMN_COUNT:
    2257             : #endif
    2258             :         case SQL_DESC_COUNT:
    2259           0 :                 IOUT(SQLSMALLINT, ird->header.sql_desc_count);
    2260           0 :                 ODBC_EXIT(stmt, SQL_SUCCESS);
    2261             :                 break;
    2262             :         }
    2263             : 
    2264        6572 :         if (!ird->header.sql_desc_count) {
    2265           0 :                 odbc_errs_add(&stmt->errs, "07005", NULL);
    2266           0 :                 ODBC_EXIT_(stmt);
    2267             :         }
    2268             : 
    2269        6572 :         if (icol <= 0 || icol > ird->header.sql_desc_count) {
    2270           0 :                 odbc_errs_add(&stmt->errs, "07009", "Column out of range");
    2271           0 :                 ODBC_EXIT_(stmt);
    2272             :         }
    2273        6572 :         drec = &ird->records[icol - 1];
    2274             : 
    2275        6572 :         tdsdump_log(TDS_DBG_INFO1, "SQLColAttribute: fDescType is %d\n", fDescType);
    2276             : 
    2277        6572 :         switch (fDescType) {
    2278           0 :         case SQL_DESC_AUTO_UNIQUE_VALUE:
    2279           0 :                 IOUT(SQLUINTEGER, drec->sql_desc_auto_unique_value);
    2280             :                 break;
    2281           0 :         case SQL_DESC_BASE_COLUMN_NAME:
    2282           0 :                 SOUT(drec->sql_desc_base_column_name);
    2283           0 :                 break;
    2284           0 :         case SQL_DESC_BASE_TABLE_NAME:
    2285           0 :                 SOUT(drec->sql_desc_base_table_name);
    2286           0 :                 break;
    2287           0 :         case SQL_DESC_CASE_SENSITIVE:
    2288           0 :                 IOUT(SQLINTEGER, drec->sql_desc_case_sensitive);
    2289             :                 break;
    2290           0 :         case SQL_DESC_CATALOG_NAME:
    2291           0 :                 SOUT(drec->sql_desc_catalog_name);
    2292           0 :                 break;
    2293             : #if SQL_COLUMN_TYPE != SQL_DESC_CONCISE_TYPE
    2294             :         case SQL_COLUMN_TYPE:
    2295             : #endif
    2296         152 :         case SQL_DESC_CONCISE_TYPE:
    2297             :                 /* special case, get ODBC 2 type, not ODBC 3 SQL_DESC_CONCISE_TYPE (different for datetime) */
    2298         152 :                 if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    2299         112 :                         IOUT(SQLSMALLINT, drec->sql_desc_concise_type);
    2300             :                         break;
    2301             :                 }
    2302             : 
    2303             :                 /* get type and convert it to ODBC 2 type */
    2304             :                 {
    2305          40 :                         SQLSMALLINT type = drec->sql_desc_concise_type;
    2306             : 
    2307          40 :                         switch (type) {
    2308           0 :                         case SQL_TYPE_DATE:
    2309           0 :                                 type = SQL_DATE;
    2310           0 :                                 break;
    2311           0 :                         case SQL_TYPE_TIME:
    2312           0 :                                 type = SQL_TIME;
    2313           0 :                                 break;
    2314          20 :                         case SQL_TYPE_TIMESTAMP:
    2315          20 :                                 type = SQL_TIMESTAMP;
    2316          20 :                                 break;
    2317             :                         }
    2318          40 :                         IOUT(SQLSMALLINT, type);
    2319             :                 }
    2320             :                 break;
    2321         516 :         case SQL_DESC_DISPLAY_SIZE:
    2322         516 :                 IOUT(SQLLEN, drec->sql_desc_display_size);
    2323             :                 break;
    2324           0 :         case SQL_DESC_FIXED_PREC_SCALE:
    2325           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_fixed_prec_scale);
    2326             :                 break;
    2327        1068 :         case SQL_DESC_LABEL:
    2328        3204 :                 SOUT(drec->sql_desc_label);
    2329        1068 :                 break;
    2330             :                 /* FIXME special cases for SQL_COLUMN_LENGTH */
    2331         460 :         case SQL_COLUMN_LENGTH:
    2332         460 :                 IOUT(SQLLEN, drec->sql_desc_octet_length);
    2333             :                 break;
    2334         516 :         case SQL_DESC_LENGTH:
    2335         516 :                 IOUT(SQLULEN, drec->sql_desc_length);
    2336             :                 break;
    2337           0 :         case SQL_DESC_LITERAL_PREFIX:
    2338           0 :                 COUT(drec->sql_desc_literal_prefix);
    2339           0 :                 break;
    2340           0 :         case SQL_DESC_LITERAL_SUFFIX:
    2341           0 :                 COUT(drec->sql_desc_literal_suffix);
    2342           0 :                 break;
    2343           0 :         case SQL_DESC_LOCAL_TYPE_NAME:
    2344           0 :                 SOUT(drec->sql_desc_local_type_name);
    2345           0 :                 break;
    2346             : #if SQL_COLUMN_NAME != SQL_DESC_NAME
    2347        1068 :         case SQL_COLUMN_NAME:
    2348             : #endif
    2349             :         case SQL_DESC_NAME:
    2350        3204 :                 SOUT(drec->sql_desc_name);
    2351        1068 :                 break;
    2352             : #if SQL_COLUMN_NULLABLE != SQL_DESC_NULLABLE
    2353           0 :         case SQL_COLUMN_NULLABLE:
    2354             : #endif
    2355             :         case SQL_DESC_NULLABLE:
    2356           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_nullable);
    2357             :                 break;
    2358           0 :         case SQL_DESC_NUM_PREC_RADIX:
    2359           0 :                 IOUT(SQLINTEGER, drec->sql_desc_num_prec_radix);
    2360             :                 break;
    2361         516 :         case SQL_DESC_OCTET_LENGTH:
    2362         516 :                 IOUT(SQLLEN, drec->sql_desc_octet_length);
    2363             :                 break;
    2364             :                 /* FIXME special cases for SQL_COLUMN_PRECISION */
    2365         460 :         case SQL_COLUMN_PRECISION:
    2366         460 :                 if (drec->sql_desc_concise_type == SQL_REAL) {
    2367          20 :                         *pfDesc = 7;
    2368             :                         break;
    2369             :                 }
    2370         440 :                 if (drec->sql_desc_concise_type == SQL_DOUBLE) {
    2371          20 :                         *pfDesc = 15;
    2372             :                         break;
    2373             :                 }
    2374         420 :                 if (drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP || drec->sql_desc_concise_type == SQL_TIMESTAMP) {
    2375          40 :                         *pfDesc = drec->sql_desc_precision ? 23 : 16;
    2376             :                         break;
    2377             :                 }
    2378             :         case SQL_DESC_PRECISION:        /* this section may be wrong */
    2379        1792 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2380         896 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
    2381         684 :                     || drec->sql_desc_concise_type == SQL_TYPE_DATE
    2382         678 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIME
    2383         678 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2384         678 :                     || drec->sql_desc_concise_type == SQL_SS_TIME2
    2385         668 :                     || drec->sql_desc_concise_type == SQL_SS_TIMESTAMPOFFSET)
    2386         236 :                         IOUT(SQLSMALLINT, drec->sql_desc_precision);
    2387             :                 else
    2388         660 :                         *pfDesc = drec->sql_desc_length;
    2389             :                 break;
    2390             :                 /* FIXME special cases for SQL_COLUMN_SCALE */
    2391         980 :         case SQL_COLUMN_SCALE:
    2392             :         case SQL_DESC_SCALE:    /* this section may be wrong */
    2393        1960 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2394         980 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
    2395         728 :                     || drec->sql_desc_concise_type == SQL_TYPE_DATE
    2396         720 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIME
    2397         720 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2398         720 :                     || drec->sql_desc_concise_type == SQL_FLOAT
    2399         720 :                     || drec->sql_desc_concise_type == SQL_SS_TIME2
    2400         708 :                     || drec->sql_desc_concise_type == SQL_SS_TIMESTAMPOFFSET)
    2401         280 :                         IOUT(SQLSMALLINT, drec->sql_desc_scale);
    2402             :                 else
    2403         700 :                         *pfDesc = 0;
    2404             :                 break;
    2405           0 :         case SQL_DESC_SCHEMA_NAME:
    2406           0 :                 SOUT(drec->sql_desc_schema_name);
    2407           0 :                 break;
    2408           0 :         case SQL_DESC_SEARCHABLE:
    2409           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_searchable);
    2410             :                 break;
    2411           0 :         case SQL_DESC_TABLE_NAME:
    2412           0 :                 SOUT(drec->sql_desc_table_name);
    2413           0 :                 break;
    2414          60 :         case SQL_DESC_TYPE:
    2415          60 :                 IOUT(SQLSMALLINT, drec->sql_desc_type);
    2416             :                 break;
    2417         144 :         case SQL_DESC_TYPE_NAME:
    2418         144 :                 COUT(drec->sql_desc_type_name);
    2419         144 :                 break;
    2420           0 :         case SQL_DESC_UNNAMED:
    2421           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_unnamed);
    2422             :                 break;
    2423         116 :         case SQL_DESC_UNSIGNED:
    2424         116 :                 IOUT(SQLSMALLINT, drec->sql_desc_unsigned);
    2425             :                 break;
    2426           0 :         case SQL_DESC_UPDATABLE:
    2427           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_updatable);
    2428             :                 break;
    2429           0 :         default:
    2430           0 :                 tdsdump_log(TDS_DBG_INFO2, "SQLColAttribute: fDescType %d not catered for...\n", fDescType);
    2431           0 :                 odbc_errs_add(&stmt->errs, "HY091", NULL);
    2432           0 :                 ODBC_EXIT_(stmt);
    2433             :                 break;
    2434             :         }
    2435             : 
    2436        2280 :         if (result == SQL_SUCCESS_WITH_INFO)
    2437           0 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    2438             : 
    2439        6572 :         ODBC_EXIT(stmt, result);
    2440             : 
    2441             : #undef COUT
    2442             : #undef SOUT
    2443             : #undef IOUT
    2444             : }
    2445             : 
    2446             : SQLRETURN ODBC_PUBLIC ODBC_API
    2447             : SQLColAttributes(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
    2448             :                  SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc)
    2449             : {
    2450           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLColAttributes(%p, %d, %d, %p, %d, %p, %p)\n",
    2451             :                         hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
    2452             : 
    2453           0 :         return odbc_SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc _wide0);
    2454             : }
    2455             : 
    2456             : #if (ODBCVER >= 0x0300)
    2457             : SQLRETURN ODBC_PUBLIC ODBC_API
    2458             : SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
    2459             :                 SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc,
    2460             : #ifdef TDS_SQLCOLATTRIBUTE_SQLLEN
    2461             :                 SQLLEN FAR * pfDesc
    2462             : #else
    2463             :                 SQLPOINTER pfDesc
    2464             : #endif
    2465             :         )
    2466             : {
    2467             : 
    2468        3286 :         return odbc_SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, (SQLLEN*) pfDesc _wide0);
    2469             : }
    2470             : 
    2471             : #ifdef ENABLE_ODBC_WIDE
    2472             : SQLRETURN ODBC_PUBLIC ODBC_API
    2473             : SQLColAttributeW(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
    2474             :                 SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc,
    2475             : #ifdef TDS_SQLCOLATTRIBUTE_SQLLEN
    2476             :                 SQLLEN FAR * pfDesc
    2477             : #else
    2478             :                 SQLPOINTER pfDesc
    2479             : #endif
    2480             :         )
    2481             : {
    2482        3286 :         tdsdump_log(TDS_DBG_FUNC, "SQLColAttributeW(%p, %u, %u, %p, %d, %p, %p)\n",
    2483             :                         hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
    2484             : 
    2485        3286 :         return odbc_SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc, 1);
    2486             : }
    2487             : #endif
    2488             : #endif
    2489             : 
    2490             : SQLRETURN ODBC_PUBLIC ODBC_API
    2491             : SQLDisconnect(SQLHDBC hdbc)
    2492             : {
    2493             :         int i;
    2494             : 
    2495        1160 :         ODBC_ENTER_HDBC;
    2496             : 
    2497        1160 :         tdsdump_log(TDS_DBG_FUNC, "SQLDisconnect(%p)\n", hdbc);
    2498             : 
    2499             :         /* free all associated statements */
    2500        1196 :         while (dbc->stmt_list) {
    2501          36 :                 tds_mutex_unlock(&dbc->mtx);
    2502          36 :                 odbc_SQLFreeStmt(dbc->stmt_list, SQL_DROP, 1);
    2503          36 :                 tds_mutex_lock(&dbc->mtx);
    2504             :         }
    2505             : 
    2506             :         /* free all associated descriptors */
    2507      116000 :         for (i = 0; i < TDS_MAX_APP_DESC; ++i) {
    2508      116000 :                 if (dbc->uad[i]) {
    2509          10 :                         desc_free(dbc->uad[i]);
    2510          10 :                         dbc->uad[i] = NULL;
    2511             :                 }
    2512             :         }
    2513             : 
    2514             : #ifdef ENABLE_ODBC_WIDE
    2515        1160 :         dbc->mb_conv = NULL;
    2516             : #endif
    2517        1160 :         tds_close_socket(dbc->tds_socket);
    2518        1160 :         tds_free_socket(dbc->tds_socket);
    2519        1160 :         dbc->tds_socket = NULL;
    2520        1160 :         dbc->cursor_support = 0;
    2521             : 
    2522        1160 :         ODBC_EXIT_(dbc);
    2523             : }
    2524             : 
    2525             : static int
    2526        6149 : odbc_errmsg_handler(const TDSCONTEXT * ctx, TDSSOCKET * tds, TDSMESSAGE * msg)
    2527             : {
    2528        6149 :         struct _sql_errors *errs = NULL;
    2529        6149 :         TDS_DBC *dbc = NULL;
    2530        6149 :         TDS_STMT *stmt = NULL;
    2531             : 
    2532        6149 :         tdsdump_log(TDS_DBG_INFO1, "msgno %d %d\n", (int) msg->msgno, TDSETIME);
    2533             : 
    2534        6149 :         if (msg->msgno == TDSETIME) {
    2535             : 
    2536         206 :                 tdsdump_log(TDS_DBG_INFO1, "in timeout\n");
    2537         206 :                 if (!tds)
    2538             :                         return TDS_INT_CANCEL;
    2539             : 
    2540         196 :                 if ((stmt = odbc_get_stmt(tds)) != NULL) {
    2541             :                         /* first time, try to send a cancel */
    2542         196 :                         if (!tds->in_cancel) {
    2543         176 :                                 odbc_errs_add(&stmt->errs, "HYT00", "Timeout expired");
    2544         176 :                                 tdsdump_log(TDS_DBG_INFO1, "returning from timeout\n");
    2545             :                                 return TDS_INT_TIMEOUT;
    2546             :                         }
    2547          10 :                 } else if ((dbc = odbc_get_dbc(tds)) != NULL) {
    2548          10 :                         odbc_errs_add(&dbc->errs, "HYT00", "Timeout expired");
    2549             :                 }
    2550             : 
    2551          30 :                 tds_close_socket(tds);
    2552          30 :                 tdsdump_log(TDS_DBG_INFO1, "returning cancel from timeout\n");
    2553             :                 return TDS_INT_CANCEL;
    2554             :         }
    2555             : 
    2556        5943 :         if (tds && (dbc = odbc_get_dbc(tds)) != NULL) {
    2557        5943 :                 errs = &dbc->errs;
    2558        3424 :                 stmt = odbc_get_stmt(tds);
    2559             :                 if (stmt)
    2560        3424 :                         errs = &stmt->errs;
    2561           0 :         } else if (ctx->parent) {
    2562           0 :                 errs = &((TDS_ENV *) ctx->parent)->errs;
    2563             :         }
    2564        5943 :         if (errs) {
    2565        5943 :                 int severity = msg->severity;
    2566        5943 :                 const char * state = msg->sql_state;
    2567             : 
    2568             :                 /* fix severity for Sybase */
    2569        5943 :                 if (severity <= 10 && dbc && !TDS_IS_MSSQL(dbc->tds_socket) && msg->sql_state && msg->sql_state[0]
    2570          15 :                     && strncmp(msg->sql_state, "00", 2) != 0) {
    2571          15 :                         if (strncmp(msg->sql_state, "01", 2) != 0 && strncmp(msg->sql_state, "IM", 2) != 0)
    2572          11 :                                 severity = 11;
    2573             :                 }
    2574             : 
    2575             :                 /* compute state if not available */
    2576        5943 :                 if (!state)
    2577        4036 :                         state = severity <= 10 ? "01000" : "42000";
    2578             :                 /* add error, do not overwrite connection timeout error */
    2579        5943 :                 if (msg->msgno != TDSEFCON || errs->lastrc != SQL_ERROR || errs->num_errors < 1)
    2580       15290 :                         odbc_errs_add_rdbms(errs, msg->msgno, state, msg->message, msg->line_number, msg->severity,
    2581        9357 :                                             msg->server, stmt ? stmt->curr_param_row + 1 : 0);
    2582             : 
    2583             :                 /* set lastrc according */
    2584        5943 :                 if (severity <= 10) {
    2585        4645 :                         if (errs->lastrc == SQL_SUCCESS)
    2586        2534 :                                 errs->lastrc = SQL_SUCCESS_WITH_INFO;
    2587             :                 } else {
    2588        1298 :                         errs->lastrc = SQL_ERROR;
    2589             :                 }
    2590             :         }
    2591             :         return TDS_INT_CANCEL;
    2592             : }
    2593             : 
    2594             : /* TODO optimize, change only if some data change (set same value should not set this flag) */
    2595             : #define DESC_SET_NEED_REPREPARE \
    2596             :         do {\
    2597             :                 if (desc->type == DESC_IPD) {\
    2598             :                         assert(IS_HSTMT(desc->parent));\
    2599             :                         ((TDS_STMT *) desc->parent)->need_reprepare = 1;\
    2600             :                  }\
    2601             :         } while(0)
    2602             : 
    2603             : SQLRETURN ODBC_PUBLIC ODBC_API
    2604             : SQLSetDescRec(SQLHDESC hdesc, SQLSMALLINT nRecordNumber, SQLSMALLINT nType, SQLSMALLINT nSubType, SQLLEN nLength,
    2605             :               SQLSMALLINT nPrecision, SQLSMALLINT nScale, SQLPOINTER pData, SQLLEN FAR * pnStringLength, SQLLEN FAR * pnIndicator)
    2606             : {
    2607             :         struct _drecord *drec;
    2608             :         SQLSMALLINT concise_type;
    2609             : 
    2610           0 :         ODBC_ENTER_HDESC;
    2611             : 
    2612           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetDescRec(%p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
    2613             :                     hdesc, nRecordNumber, nType, nSubType, (int)nLength, nPrecision, nScale,
    2614             :                     pData, pnStringLength, pnIndicator);
    2615             : 
    2616           0 :         if (desc->type == DESC_IRD) {
    2617           0 :                 odbc_errs_add(&desc->errs, "HY016", NULL);
    2618           0 :                 ODBC_EXIT_(desc);
    2619             :         }
    2620             : 
    2621           0 :         if (nRecordNumber > desc->header.sql_desc_count || nRecordNumber <= 0) {
    2622           0 :                 odbc_errs_add(&desc->errs, "07009", NULL);
    2623           0 :                 ODBC_EXIT_(desc);
    2624             :         }
    2625             : 
    2626           0 :         drec = &desc->records[nRecordNumber - 1];
    2627             : 
    2628             :         /* check for valid types and return "HY021" if not */
    2629           0 :         if (desc->type == DESC_IPD) {
    2630           0 :                 DESC_SET_NEED_REPREPARE;
    2631           0 :                 concise_type = odbc_get_concise_sql_type(nType, nSubType);
    2632             :         } else {
    2633           0 :                 concise_type = odbc_get_concise_c_type(nType, nSubType);
    2634             :         }
    2635           0 :         if (nType == SQL_INTERVAL || nType == SQL_DATETIME) {
    2636           0 :                 if (!concise_type) {
    2637           0 :                         odbc_errs_add(&desc->errs, "HY021", NULL);
    2638           0 :                         ODBC_EXIT_(desc);
    2639             :                 }
    2640             :         } else {
    2641           0 :                 if (concise_type != nType) {
    2642           0 :                         odbc_errs_add(&desc->errs, "HY021", NULL);
    2643           0 :                         ODBC_EXIT_(desc);
    2644             :                 }
    2645             :                 nSubType = 0;
    2646             :         }
    2647           0 :         drec->sql_desc_concise_type = concise_type;
    2648           0 :         drec->sql_desc_type = nType;
    2649           0 :         drec->sql_desc_datetime_interval_code = nSubType;
    2650             : 
    2651           0 :         drec->sql_desc_octet_length = nLength;
    2652           0 :         drec->sql_desc_precision = nPrecision;
    2653           0 :         drec->sql_desc_scale = nScale;
    2654           0 :         drec->sql_desc_data_ptr = pData;
    2655           0 :         drec->sql_desc_octet_length_ptr = pnStringLength;
    2656           0 :         drec->sql_desc_indicator_ptr = pnIndicator;
    2657             : 
    2658           0 :         ODBC_EXIT_(desc);
    2659             : }
    2660             : 
    2661          30 : ODBC_FUNC(SQLGetDescRec, (P(SQLHDESC,hdesc), P(SQLSMALLINT,RecordNumber), PCHAROUT(Name,SQLSMALLINT),
    2662             :         P(SQLSMALLINT *,Type), P(SQLSMALLINT *,SubType), P(SQLLEN FAR *,Length),
    2663             :         P(SQLSMALLINT *,Precision), P(SQLSMALLINT *,Scale), P(SQLSMALLINT *,Nullable) WIDE))
    2664             : {
    2665          30 :         struct _drecord *drec = NULL;
    2666          30 :         SQLRETURN rc = SQL_SUCCESS;
    2667             : 
    2668          30 :         ODBC_ENTER_HDESC;
    2669             : 
    2670          30 :         if (RecordNumber <= 0) {
    2671          10 :                 odbc_errs_add(&desc->errs, "07009", NULL);
    2672          10 :                 ODBC_EXIT_(desc);
    2673             :         }
    2674             : 
    2675          20 :         IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    2676          20 :         if (RecordNumber > desc->header.sql_desc_count)
    2677          10 :                 ODBC_EXIT(desc, SQL_NO_DATA);
    2678             : 
    2679             :         if (desc->type == DESC_IRD && !desc->header.sql_desc_count) {
    2680             :                 odbc_errs_add(&desc->errs, "HY007", NULL);
    2681             :                 ODBC_EXIT_(desc);
    2682             :         }
    2683             : 
    2684          10 :         drec = &desc->records[RecordNumber - 1];
    2685             : 
    2686          30 :         if ((rc = odbc_set_dstr(desc_get_dbc(desc), szName, cbNameMax, pcbName, &drec->sql_desc_name)) != SQL_SUCCESS)
    2687           0 :                 odbc_errs_add(&desc->errs, "01004", NULL);
    2688             : 
    2689          10 :         if (Type)
    2690           0 :                 *Type = drec->sql_desc_type;
    2691          10 :         if (Length)
    2692           0 :                 *Length = drec->sql_desc_octet_length;
    2693          10 :         if (Precision)
    2694           0 :                 *Precision = drec->sql_desc_precision;
    2695          10 :         if (Scale)
    2696           0 :                 *Scale = drec->sql_desc_scale;
    2697          10 :         if (SubType)
    2698           0 :                 *SubType = drec->sql_desc_datetime_interval_code;
    2699          10 :         if (Nullable)
    2700           0 :                 *Nullable = drec->sql_desc_nullable;
    2701             : 
    2702          10 :         ODBC_EXIT(desc, rc);
    2703             : }
    2704             : 
    2705             : static TDS_DESC*
    2706        2802 : desc_get_focused(TDS_DESC *desc)
    2707             : {
    2708             :         struct _drecord *drec;
    2709        2802 :         int focus = desc->focus;
    2710        2802 :         bool was_apd = false;
    2711             : 
    2712        2802 :         if (focus <= 0)
    2713             :                 return desc;
    2714          20 :         if (desc->type != DESC_IPD && IS_HSTMT(desc->parent)) {
    2715          12 :                 desc = ((TDS_STMT *) desc->parent)->ipd;
    2716          12 :                 was_apd = true;
    2717             :         }
    2718          20 :         if (desc->type == DESC_IPD) {
    2719          20 :                 if (focus > desc->header.sql_desc_count)
    2720             :                         return desc;
    2721             : 
    2722          20 :                 drec = &desc->records[focus - 1];
    2723          20 :                 if (drec->sql_desc_concise_type != SQL_SS_TABLE)
    2724             :                         return desc;
    2725          20 :                 if (was_apd)
    2726          12 :                         return ((SQLTVP *) drec->sql_desc_data_ptr)->apd;
    2727           8 :                 return ((SQLTVP *) drec->sql_desc_data_ptr)->ipd;
    2728             :         }
    2729             :         return desc;
    2730             : }
    2731             : 
    2732        2112 : ODBC_FUNC(SQLGetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLINT,fDescType), P(SQLPOINTER,Value),
    2733             :         P(SQLINTEGER,BufferLength), P(SQLINTEGER *,StringLength) WIDE))
    2734             : {
    2735             :         struct _drecord *drec;
    2736        2112 :         SQLRETURN result = SQL_SUCCESS;
    2737             :         SQLINTEGER dummy_size;
    2738             :         TDS_DESC *fdesc;
    2739             : 
    2740        2112 :         ODBC_ENTER_HDESC;
    2741             : 
    2742             : #define COUT(src) result = odbc_set_string_oct(desc_get_dbc(desc), Value, BufferLength, StringLength, src, -1);
    2743             : #define SOUT(src) result = odbc_set_dstr_oct(desc_get_dbc(desc), Value, BufferLength, StringLength, &src);
    2744             : 
    2745             : #if ENABLE_EXTRA_CHECKS
    2746             : #define IOUT(type, src) do { \
    2747             :         /* trick warning if type wrong */ \
    2748             :         type *p_test = &src; p_test = p_test; \
    2749             :         *((type *)Value) = src; \
    2750             :         *StringLength = sizeof(type); } while(0)
    2751             : #else
    2752             : #define IOUT(type, src) do { \
    2753             :         *((type *)Value) = src; \
    2754             :         *StringLength = sizeof(type); } while(0)
    2755             : #endif
    2756             : 
    2757        2112 :         if (!StringLength)
    2758           0 :                 StringLength = &dummy_size;
    2759             : 
    2760        2112 :         fdesc = desc_get_focused(desc);
    2761             : 
    2762             :         /* dont check column index for these */
    2763        2112 :         switch (fDescType) {
    2764          40 :         case SQL_DESC_ALLOC_TYPE:
    2765          40 :                 IOUT(SQLSMALLINT, fdesc->header.sql_desc_alloc_type);
    2766          40 :                 ODBC_EXIT_(desc);
    2767             :                 break;
    2768           8 :         case SQL_DESC_ARRAY_SIZE:
    2769           8 :                 IOUT(SQLULEN, fdesc->header.sql_desc_array_size);
    2770           8 :                 ODBC_EXIT_(desc);
    2771             :                 break;
    2772           0 :         case SQL_DESC_ARRAY_STATUS_PTR:
    2773           0 :                 IOUT(SQLUSMALLINT *, fdesc->header.sql_desc_array_status_ptr);
    2774           0 :                 ODBC_EXIT_(desc);
    2775             :                 break;
    2776           0 :         case SQL_DESC_BIND_OFFSET_PTR:
    2777           0 :                 IOUT(SQLLEN *, fdesc->header.sql_desc_bind_offset_ptr);
    2778           0 :                 ODBC_EXIT_(desc);
    2779             :                 break;
    2780           0 :         case SQL_DESC_BIND_TYPE:
    2781           0 :                 IOUT(SQLINTEGER, fdesc->header.sql_desc_bind_type);
    2782           0 :                 ODBC_EXIT_(desc);
    2783             :                 break;
    2784          88 :         case SQL_DESC_COUNT:
    2785          88 :                 IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    2786          88 :                 IOUT(SQLSMALLINT, fdesc->header.sql_desc_count);
    2787          88 :                 ODBC_EXIT_(desc);
    2788             :                 break;
    2789         110 :         case SQL_DESC_ROWS_PROCESSED_PTR:
    2790         110 :                 IOUT(SQLULEN *, fdesc->header.sql_desc_rows_processed_ptr);
    2791         110 :                 ODBC_EXIT_(desc);
    2792             :                 break;
    2793             :         }
    2794             : 
    2795        1866 :         IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    2796        1866 :         if (!fdesc->header.sql_desc_count) {
    2797           0 :                 odbc_errs_add(&desc->errs, "07005", NULL);
    2798           0 :                 ODBC_EXIT_(desc);
    2799             :         }
    2800             : 
    2801        1866 :         if (icol < 1) {
    2802           0 :                 odbc_errs_add(&desc->errs, "07009", "Column out of range");
    2803           0 :                 ODBC_EXIT_(desc);
    2804             :         }
    2805        1866 :         if (icol > fdesc->header.sql_desc_count)
    2806           0 :                 ODBC_EXIT(desc, SQL_NO_DATA);
    2807        1866 :         drec = &fdesc->records[icol - 1];
    2808             : 
    2809        1866 :         tdsdump_log(TDS_DBG_INFO1, "SQLGetDescField: fDescType is %d\n", fDescType);
    2810             : 
    2811        1866 :         switch (fDescType) {
    2812           0 :         case SQL_DESC_AUTO_UNIQUE_VALUE:
    2813           0 :                 IOUT(SQLUINTEGER, drec->sql_desc_auto_unique_value);
    2814             :                 break;
    2815           0 :         case SQL_DESC_BASE_COLUMN_NAME:
    2816           0 :                 SOUT(drec->sql_desc_base_column_name);
    2817           0 :                 break;
    2818           0 :         case SQL_DESC_BASE_TABLE_NAME:
    2819           0 :                 SOUT(drec->sql_desc_base_table_name);
    2820           0 :                 break;
    2821           0 :         case SQL_DESC_CASE_SENSITIVE:
    2822           0 :                 IOUT(SQLINTEGER, drec->sql_desc_case_sensitive);
    2823             :                 break;
    2824           0 :         case SQL_DESC_CATALOG_NAME:
    2825           0 :                 SOUT(drec->sql_desc_catalog_name);
    2826           0 :                 break;
    2827         604 :         case SQL_DESC_CONCISE_TYPE:
    2828         604 :                 IOUT(SQLSMALLINT, drec->sql_desc_concise_type);
    2829             :                 break;
    2830          16 :         case SQL_DESC_DATA_PTR:
    2831          16 :                 IOUT(SQLPOINTER, drec->sql_desc_data_ptr);
    2832             :                 break;
    2833         590 :         case SQL_DESC_DATETIME_INTERVAL_CODE:
    2834         590 :                 IOUT(SQLSMALLINT, drec->sql_desc_datetime_interval_code);
    2835             :                 break;
    2836           0 :         case SQL_DESC_DATETIME_INTERVAL_PRECISION:
    2837           0 :                 IOUT(SQLINTEGER, drec->sql_desc_datetime_interval_precision);
    2838             :                 break;
    2839           0 :         case SQL_DESC_DISPLAY_SIZE:
    2840           0 :                 IOUT(SQLLEN, drec->sql_desc_display_size);
    2841             :                 break;
    2842           0 :         case SQL_DESC_FIXED_PREC_SCALE:
    2843           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_fixed_prec_scale);
    2844             :                 break;
    2845           8 :         case SQL_DESC_INDICATOR_PTR:
    2846           8 :                 IOUT(SQLLEN *, drec->sql_desc_indicator_ptr);
    2847             :                 break;
    2848           0 :         case SQL_DESC_LABEL:
    2849           0 :                 SOUT(drec->sql_desc_label);
    2850           0 :                 break;
    2851          14 :         case SQL_DESC_LENGTH:
    2852          14 :                 IOUT(SQLULEN, drec->sql_desc_length);
    2853             :                 break;
    2854           0 :         case SQL_DESC_LITERAL_PREFIX:
    2855           0 :                 COUT(drec->sql_desc_literal_prefix);
    2856           0 :                 break;
    2857           0 :         case SQL_DESC_LITERAL_SUFFIX:
    2858           0 :                 COUT(drec->sql_desc_literal_suffix);
    2859           0 :                 break;
    2860           0 :         case SQL_DESC_LOCAL_TYPE_NAME:
    2861           0 :                 SOUT(drec->sql_desc_local_type_name);
    2862           0 :                 break;
    2863           0 :         case SQL_DESC_NAME:
    2864           0 :                 SOUT(drec->sql_desc_name);
    2865           0 :                 break;
    2866           0 :         case SQL_DESC_NULLABLE:
    2867           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_nullable);
    2868             :                 break;
    2869           0 :         case SQL_DESC_NUM_PREC_RADIX:
    2870           0 :                 IOUT(SQLINTEGER, drec->sql_desc_num_prec_radix);
    2871             :                 break;
    2872           8 :         case SQL_DESC_OCTET_LENGTH:
    2873           8 :                 IOUT(SQLLEN, drec->sql_desc_octet_length);
    2874             :                 break;
    2875           8 :         case SQL_DESC_OCTET_LENGTH_PTR:
    2876           8 :                 IOUT(SQLLEN *, drec->sql_desc_octet_length_ptr);
    2877             :                 break;
    2878           0 :         case SQL_DESC_PARAMETER_TYPE:
    2879           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_parameter_type);
    2880             :                 break;
    2881           6 :         case SQL_DESC_PRECISION:
    2882          12 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2883           6 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2884           4 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP)
    2885           2 :                         IOUT(SQLSMALLINT, drec->sql_desc_precision);
    2886             :                 else
    2887             :                         /* TODO support date/time */
    2888           4 :                         *((SQLSMALLINT *) Value) = 0;
    2889             :                 break;
    2890             : #ifdef SQL_DESC_ROWVER
    2891           0 :         case SQL_DESC_ROWVER:
    2892           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_rowver);
    2893             :                 break;
    2894             : #endif
    2895           6 :         case SQL_DESC_SCALE:
    2896          12 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2897           6 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
    2898           4 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2899           4 :                     || drec->sql_desc_concise_type == SQL_FLOAT)
    2900           2 :                         IOUT(SQLSMALLINT, drec->sql_desc_scale);
    2901             :                 else
    2902           4 :                         *((SQLSMALLINT *) Value) = 0;
    2903             :                 break;
    2904           0 :         case SQL_DESC_SCHEMA_NAME:
    2905           0 :                 SOUT(drec->sql_desc_schema_name);
    2906           0 :                 break;
    2907           0 :         case SQL_DESC_SEARCHABLE:
    2908           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_searchable);
    2909             :                 break;
    2910           0 :         case SQL_DESC_TABLE_NAME:
    2911           0 :                 SOUT(drec->sql_desc_table_name);
    2912           0 :                 break;
    2913         606 :         case SQL_DESC_TYPE:
    2914         606 :                 IOUT(SQLSMALLINT, drec->sql_desc_type);
    2915             :                 break;
    2916           0 :         case SQL_DESC_TYPE_NAME:
    2917           0 :                 COUT(drec->sql_desc_type_name);
    2918           0 :                 break;
    2919           0 :         case SQL_DESC_UNNAMED:
    2920           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_unnamed);
    2921             :                 break;
    2922           0 :         case SQL_DESC_UNSIGNED:
    2923           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_unsigned);
    2924             :                 break;
    2925           0 :         case SQL_DESC_UPDATABLE:
    2926           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_updatable);
    2927             :                 break;
    2928           0 :         default:
    2929           0 :                 odbc_errs_add(&desc->errs, "HY091", NULL);
    2930           0 :                 ODBC_EXIT_(desc);
    2931             :                 break;
    2932             :         }
    2933             : 
    2934           0 :         if (result == SQL_SUCCESS_WITH_INFO)
    2935           0 :                 odbc_errs_add(&desc->errs, "01004", NULL);
    2936             : 
    2937        1866 :         ODBC_EXIT(desc, result);
    2938             : 
    2939             : #undef COUT
    2940             : #undef SOUT
    2941             : #undef IOUT
    2942             : }
    2943             : 
    2944         690 : ODBC_FUNC(SQLSetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLINT,fDescType),
    2945             :         P(SQLPOINTER,Value), P(SQLINTEGER,BufferLength) WIDE))
    2946             : {
    2947             :         struct _drecord *drec;
    2948         690 :         SQLRETURN result = SQL_SUCCESS;
    2949             :         TDS_DESC *fdesc;
    2950             : 
    2951         690 :         ODBC_ENTER_HDESC;
    2952             : 
    2953             : #if ENABLE_EXTRA_CHECKS
    2954             : #define IIN(type, dest) do { \
    2955             :         /* trick warning if type wrong */ \
    2956             :         type *p_test = &dest; p_test = p_test; \
    2957             :         dest = (type)(TDS_INTPTR)Value; } while(0)
    2958             : #define PIN(type, dest) do { \
    2959             :         /* trick warning if type wrong */ \
    2960             :         type *p_test = &dest; p_test = p_test; \
    2961             :         dest = (type)Value; } while(0)
    2962             : #else
    2963             : #define IIN(type, dest) dest = (type)(TDS_INTPTR)Value
    2964             : #define PIN(type, dest) dest = (type)Value
    2965             : #endif
    2966             : 
    2967             :         /* special case for IRD */
    2968         690 :         if (desc->type == DESC_IRD && fDescType != SQL_DESC_ARRAY_STATUS_PTR && fDescType != SQL_DESC_ROWS_PROCESSED_PTR) {
    2969           0 :                 odbc_errs_add(&desc->errs, "HY016", NULL);
    2970           0 :                 ODBC_EXIT_(desc);
    2971             :         }
    2972             : 
    2973         690 :         fdesc = desc_get_focused(desc);
    2974             : 
    2975             :         /* dont check column index for these */
    2976         690 :         switch (fDescType) {
    2977           0 :         case SQL_DESC_ALLOC_TYPE:
    2978           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    2979           0 :                 ODBC_EXIT_(desc);
    2980             :                 break;
    2981           0 :         case SQL_DESC_ARRAY_SIZE:
    2982           0 :                 IIN(SQLULEN, fdesc->header.sql_desc_array_size);
    2983           0 :                 ODBC_EXIT_(desc);
    2984             :                 break;
    2985           0 :         case SQL_DESC_ARRAY_STATUS_PTR:
    2986           0 :                 PIN(SQLUSMALLINT *, fdesc->header.sql_desc_array_status_ptr);
    2987           0 :                 ODBC_EXIT_(desc);
    2988             :                 break;
    2989          40 :         case SQL_DESC_ROWS_PROCESSED_PTR:
    2990          40 :                 PIN(SQLULEN *, fdesc->header.sql_desc_rows_processed_ptr);
    2991          40 :                 ODBC_EXIT_(desc);
    2992             :                 break;
    2993           0 :         case SQL_DESC_BIND_TYPE:
    2994           0 :                 IIN(SQLINTEGER, fdesc->header.sql_desc_bind_type);
    2995           0 :                 ODBC_EXIT_(desc);
    2996             :                 break;
    2997           2 :         case SQL_DESC_COUNT:
    2998             :                 {
    2999           2 :                         int n = (int) (TDS_INTPTR) Value;
    3000             : 
    3001           2 :                         if (n < 0 || n > 4000) {
    3002           0 :                                 odbc_errs_add(&desc->errs, "07009", NULL);
    3003           0 :                                 ODBC_EXIT_(desc);
    3004             :                         }
    3005           2 :                         result = desc_alloc_records(fdesc, n);
    3006           2 :                         if (result == SQL_ERROR)
    3007           0 :                                 odbc_errs_add(&desc->errs, "HY001", NULL);
    3008           2 :                         ODBC_EXIT(desc, result);
    3009             :                 }
    3010             :                 break;
    3011             :         }
    3012             : 
    3013         648 :         if (!fdesc->header.sql_desc_count) {
    3014           0 :                 odbc_errs_add(&desc->errs, "07005", NULL);
    3015           0 :                 ODBC_EXIT_(desc);
    3016             :         }
    3017             : 
    3018         648 :         if (icol <= 0 || icol > fdesc->header.sql_desc_count) {
    3019           0 :                 odbc_errs_add(&desc->errs, "07009", "Column out of range");
    3020           0 :                 ODBC_EXIT_(desc);
    3021             :         }
    3022         648 :         drec = &fdesc->records[icol - 1];
    3023             : 
    3024         648 :         tdsdump_log(TDS_DBG_INFO1, "SQLSetDescField: fDescType is %d\n", fDescType);
    3025             : 
    3026         648 :         switch (fDescType) {
    3027           0 :         case SQL_DESC_AUTO_UNIQUE_VALUE:
    3028             :         case SQL_DESC_BASE_COLUMN_NAME:
    3029             :         case SQL_DESC_BASE_TABLE_NAME:
    3030             :         case SQL_DESC_CASE_SENSITIVE:
    3031             :         case SQL_DESC_CATALOG_NAME:
    3032           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3033           0 :                 result = SQL_ERROR;
    3034           0 :                 break;
    3035         544 :         case SQL_DESC_CONCISE_TYPE:
    3036         544 :                 DESC_SET_NEED_REPREPARE;
    3037         544 :                 if (fdesc->type == DESC_IPD)
    3038         450 :                         result = odbc_set_concise_sql_type((SQLSMALLINT) (TDS_INTPTR) Value, drec, 0);
    3039             :                 else
    3040          94 :                         result = odbc_set_concise_c_type((SQLSMALLINT) (TDS_INTPTR) Value, drec, 0);
    3041         544 :                 if (result != SQL_SUCCESS)
    3042         310 :                         odbc_errs_add(&desc->errs, "HY021", NULL);
    3043             :                 break;
    3044           0 :         case SQL_DESC_DATA_PTR:
    3045           0 :                 PIN(SQLPOINTER, drec->sql_desc_data_ptr);
    3046           0 :                 break;
    3047             :                 /* TODO SQL_DESC_DATETIME_INTERVAL_CODE remember to check sql_desc_type */
    3048             :                 /* TODO SQL_DESC_DATETIME_INTERVAL_PRECISION */
    3049           0 :         case SQL_DESC_DISPLAY_SIZE:
    3050             :         case SQL_DESC_FIXED_PREC_SCALE:
    3051           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3052           0 :                 result = SQL_ERROR;
    3053           0 :                 break;
    3054           0 :         case SQL_DESC_INDICATOR_PTR:
    3055           0 :                 PIN(SQLLEN *, drec->sql_desc_indicator_ptr);
    3056           0 :                 break;
    3057           0 :         case SQL_DESC_LABEL:
    3058           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3059           0 :                 result = SQL_ERROR;
    3060           0 :                 break;
    3061           0 :         case SQL_DESC_LENGTH:
    3062           0 :                 DESC_SET_NEED_REPREPARE;
    3063           0 :                 IIN(SQLULEN, drec->sql_desc_length);
    3064           0 :                 break;
    3065           0 :         case SQL_DESC_LITERAL_PREFIX:
    3066             :         case SQL_DESC_LITERAL_SUFFIX:
    3067             :         case SQL_DESC_LOCAL_TYPE_NAME:
    3068           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3069           0 :                 result = SQL_ERROR;
    3070           0 :                 break;
    3071           0 :         case SQL_DESC_NAME:
    3072           0 :                 if (!odbc_dstr_copy_oct(desc_get_dbc(fdesc), &drec->sql_desc_name, BufferLength, (ODBC_CHAR*) Value)) {
    3073           0 :                         odbc_errs_add(&desc->errs, "HY001", NULL);
    3074           0 :                         result = SQL_ERROR;
    3075             :                 }
    3076             :                 break;
    3077           0 :         case SQL_DESC_NULLABLE:
    3078           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3079           0 :                 result = SQL_ERROR;
    3080           0 :                 break;
    3081           0 :         case SQL_DESC_NUM_PREC_RADIX:
    3082           0 :                 IIN(SQLINTEGER, drec->sql_desc_num_prec_radix);
    3083           0 :                 break;
    3084           0 :         case SQL_DESC_OCTET_LENGTH:
    3085           0 :                 DESC_SET_NEED_REPREPARE;
    3086           0 :                 IIN(SQLLEN, drec->sql_desc_octet_length);
    3087           0 :                 break;
    3088           4 :         case SQL_DESC_OCTET_LENGTH_PTR:
    3089           4 :                 PIN(SQLLEN *, drec->sql_desc_octet_length_ptr);
    3090           4 :                 break;
    3091           0 :         case SQL_DESC_PARAMETER_TYPE:
    3092           0 :                 DESC_SET_NEED_REPREPARE;
    3093           0 :                 IIN(SQLSMALLINT, drec->sql_desc_parameter_type);
    3094           0 :                 break;
    3095          50 :         case SQL_DESC_PRECISION:
    3096          50 :                 DESC_SET_NEED_REPREPARE;
    3097             :                 /* TODO correct ?? */
    3098          50 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL)
    3099          10 :                         IIN(SQLSMALLINT, drec->sql_desc_precision);
    3100             :                 else
    3101          40 :                         IIN(SQLULEN, drec->sql_desc_length);
    3102             :                 break;
    3103             : #ifdef SQL_DESC_ROWVER
    3104           0 :         case SQL_DESC_ROWVER:
    3105           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3106           0 :                 result = SQL_ERROR;
    3107           0 :                 break;
    3108             : #endif
    3109          50 :         case SQL_DESC_SCALE:
    3110          50 :                 DESC_SET_NEED_REPREPARE;
    3111          50 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL)
    3112          10 :                         IIN(SQLSMALLINT, drec->sql_desc_scale);
    3113             :                 else
    3114             :                         /* TODO even for datetime/money ?? */
    3115          40 :                         drec->sql_desc_scale = 0;
    3116             :                 break;
    3117           0 :         case SQL_DESC_SCHEMA_NAME:
    3118             :         case SQL_DESC_SEARCHABLE:
    3119             :         case SQL_DESC_TABLE_NAME:
    3120           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3121           0 :                 result = SQL_ERROR;
    3122           0 :                 break;
    3123           0 :         case SQL_DESC_TYPE:
    3124           0 :                 DESC_SET_NEED_REPREPARE;
    3125           0 :                 IIN(SQLSMALLINT, drec->sql_desc_type);
    3126             :                 /* FIXME what happen for interval/datetime ?? */
    3127           0 :                 drec->sql_desc_concise_type = drec->sql_desc_type;
    3128           0 :                 break;
    3129           0 :         case SQL_DESC_TYPE_NAME:
    3130           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3131           0 :                 result = SQL_ERROR;
    3132           0 :                 break;
    3133           0 :         case SQL_DESC_UNNAMED:
    3134           0 :                 IIN(SQLSMALLINT, drec->sql_desc_unnamed);
    3135           0 :                 break;
    3136           0 :         case SQL_DESC_UNSIGNED:
    3137             :         case SQL_DESC_UPDATABLE:
    3138           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3139           0 :                 result = SQL_ERROR;
    3140           0 :                 break;
    3141           0 :         default:
    3142           0 :                 odbc_errs_add(&desc->errs, "HY091", NULL);
    3143           0 :                 ODBC_EXIT_(desc);
    3144             :                 break;
    3145             :         }
    3146             : 
    3147             : #undef IIN
    3148             : 
    3149         648 :         ODBC_EXIT(desc, result);
    3150             : }
    3151             : 
    3152             : SQLRETURN ODBC_PUBLIC ODBC_API
    3153             : SQLCopyDesc(SQLHDESC hsrc, SQLHDESC hdesc)
    3154             : {
    3155             :         TDS_DESC *src;
    3156             : 
    3157          50 :         ODBC_ENTER_HDESC;
    3158             : 
    3159          30 :         tdsdump_log(TDS_DBG_FUNC, "SQLCopyDesc(%p, %p)\n",
    3160             :                         hsrc, hdesc);
    3161             : 
    3162             :         /* check source descriptor handle, destination one was already checked */
    3163          30 :         if (SQL_NULL_HDESC == hsrc || !IS_HDESC(hsrc)) {
    3164          20 :                 tds_mutex_unlock(&desc->mtx);
    3165          20 :                 return SQL_INVALID_HANDLE;
    3166             :         }
    3167             : 
    3168          10 :         src = (TDS_DESC *) hsrc;
    3169          10 :         CHECK_DESC_EXTRA(src);
    3170             : 
    3171             :         /* do not write on IRD */
    3172          10 :         if (desc->type == DESC_IRD) {
    3173           0 :                 odbc_errs_add(&desc->errs, "HY016", NULL);
    3174           0 :                 ODBC_EXIT_(desc);
    3175             :         }
    3176          10 :         IRD_UPDATE(src, &src->errs, ODBC_EXIT(desc, SQL_ERROR));
    3177             : 
    3178          10 :         ODBC_EXIT(desc, desc_copy(desc, src));
    3179             : }
    3180             : 
    3181             : #if ENABLE_EXTRA_CHECKS
    3182             : static void
    3183       19192 : odbc_ird_check(TDS_STMT * stmt TDS_UNUSED)
    3184             : {
    3185             : #if !ENABLE_ODBC_MARS
    3186       19192 :         TDS_DESC *ird = stmt->ird;
    3187       19192 :         TDSRESULTINFO *res_info = NULL;
    3188       19192 :         int cols = 0, i;
    3189             : 
    3190       19192 :         if (!stmt->tds)
    3191             :                 return;
    3192       18212 :         if (stmt->tds->current_results) {
    3193       18191 :                 res_info = stmt->tds->current_results;
    3194       18191 :                 cols = res_info->num_cols;
    3195             :         }
    3196       18212 :         if (stmt->cursor != NULL)
    3197             :                 return;
    3198             : 
    3199             :         /* check columns number */
    3200       17864 :         assert(ird->header.sql_desc_count <= cols || ird->header.sql_desc_count == 0);
    3201             : 
    3202             : 
    3203             :         /* check all columns */
    3204       74098 :         for (i = 0; i < ird->header.sql_desc_count; ++i) {
    3205       74098 :                 struct _drecord *drec = &ird->records[i];
    3206       74098 :                 TDSCOLUMN *col = res_info->columns[i];
    3207             : 
    3208      222294 :                 assert(strcmp(tds_dstr_cstr(&drec->sql_desc_label), tds_dstr_cstr(&col->column_name)) == 0);
    3209             :         }
    3210             : #endif
    3211             : }
    3212             : #endif
    3213             : 
    3214             : static void
    3215        3710 : odbc_unquote(char *buf, size_t buf_len, const char *start, const char *end)
    3216             : {
    3217             :         char quote;
    3218        3710 :         assert(buf_len > 0);
    3219             : 
    3220             :         /* empty string */
    3221        3710 :         if (start >= end) {
    3222           0 :                 buf[0] = 0;
    3223           0 :                 return;
    3224             :         }
    3225             : 
    3226             :         /* not quoted */
    3227        3710 :         if (*start != '[' && *start != '\"') {
    3228        2622 :                 --buf_len;
    3229        2622 :                 if (end < start + buf_len)
    3230        2622 :                         buf_len = end - start;
    3231        2622 :                 memcpy(buf, start, buf_len);
    3232        2622 :                 buf[buf_len] = 0;
    3233        2622 :                 return;
    3234             :         }
    3235             : 
    3236             :         /* quoted... unquote */
    3237        1088 :         quote = (*start == '[') ? ']' : *start;
    3238        1088 :         ++start;
    3239        7856 :         while (buf_len > 0 && start < end) {
    3240        6768 :                 if (*start == quote)
    3241        1088 :                         if (++start >= end)
    3242             :                                 break;
    3243        5680 :                 *buf++ = *start++;
    3244        5680 :                 --buf_len;
    3245             :         }
    3246        1088 :         *buf = 0;
    3247             : }
    3248             : 
    3249             : /* FIXME check result !!! */
    3250             : static SQLRETURN
    3251       43104 : odbc_populate_ird(TDS_STMT * stmt)
    3252             : {
    3253       43104 :         TDS_DESC *ird = stmt->ird;
    3254             :         struct _drecord *drec;
    3255             :         TDSCOLUMN *col;
    3256             :         TDSRESULTINFO *res_info;
    3257             :         int num_cols;
    3258             :         int i;
    3259             : 
    3260       43104 :         desc_free_records(ird);
    3261       43104 :         if (!stmt->tds || !(res_info = stmt->tds->current_results))
    3262             :                 return SQL_SUCCESS;
    3263       12011 :         if (res_info == stmt->tds->param_info)
    3264             :                 return SQL_SUCCESS;
    3265       11275 :         num_cols = res_info->num_cols;
    3266             : 
    3267             :         /* ignore hidden columns... TODO correct? */
    3268       22982 :         while (num_cols > 0 && res_info->columns[num_cols - 1]->column_hidden == 1)
    3269         432 :                 --num_cols;
    3270             : 
    3271       11275 :         if (desc_alloc_records(ird, num_cols) != SQL_SUCCESS)
    3272             :                 goto memory_error;
    3273             : 
    3274       18467 :         for (i = 0; i < num_cols; i++) {
    3275       18467 :                 drec = &ird->records[i];
    3276       18467 :                 col = res_info->columns[i];
    3277       18467 :                 drec->sql_desc_auto_unique_value = col->column_identity ? SQL_TRUE : SQL_FALSE;
    3278             :                 /* TODO SQL_FALSE ?? */
    3279       18467 :                 drec->sql_desc_case_sensitive = SQL_TRUE;
    3280             : 
    3281             :                 /*
    3282             :                  * TODO how to handle when in datetime we change precision ??
    3283             :                  * should we change display size too ??
    3284             :                  * is formatting function correct ??
    3285             :                  * we should not convert to string with invalid precision!
    3286             :                  */
    3287       18467 :                 odbc_set_sql_type_info(col, drec, stmt->dbc->env->attr.odbc_version);
    3288             : 
    3289       18467 :                 drec->sql_desc_fixed_prec_scale = (col->column_prec && col->column_scale) ? SQL_TRUE : SQL_FALSE;
    3290       18467 :                 if (!tds_dstr_dup(&drec->sql_desc_label, &col->column_name))
    3291             :                         goto memory_error;
    3292             : 
    3293       36934 :                 if (tds_dstr_isempty(&col->table_column_name)) {
    3294       16199 :                         if (!tds_dstr_dup(&drec->sql_desc_name, &col->column_name))
    3295             :                                 goto memory_error;
    3296             :                 } else {
    3297        2268 :                         if (!tds_dstr_dup(&drec->sql_desc_name, &col->table_column_name))
    3298             :                                 goto memory_error;
    3299        2268 :                         if (!tds_dstr_dup(&drec->sql_desc_base_column_name, &col->table_column_name))
    3300             :                                 goto memory_error;
    3301             :                 }
    3302             : 
    3303             :                 /* extract sql_desc_(catalog/schema/base_table)_name */
    3304             :                 /* TODO extract them dinamically (when needed) ? */
    3305             :                 /* TODO store in libTDS in different way (separately) ? */
    3306       36934 :                 if (!tds_dstr_isempty(&col->table_name)) {
    3307             :                         struct {
    3308             :                                 const char *start;
    3309             :                                 const char *end;
    3310             :                         } partials[4];
    3311             :                         const char *p;
    3312             :                         char buf[256];
    3313             :                         int i;
    3314             : 
    3315        7420 :                         p = tds_dstr_cstr(&col->table_name);
    3316        3710 :                         for (i = 0; ; ++i) {
    3317             :                                 const char *pend;
    3318             : 
    3319        3710 :                                 if (*p == '[' || *p == '\"') {
    3320        1088 :                                         pend = tds_skip_quoted(p);
    3321             :                                 } else {
    3322        2622 :                                         pend = strchr(p, '.');
    3323        2622 :                                         if (!pend)
    3324        2622 :                                                 pend = strchr(p, 0);
    3325             :                                 }
    3326        3710 :                                 partials[i].start = p;
    3327        3710 :                                 partials[i].end = pend;
    3328        3710 :                                 p = pend;
    3329        3710 :                                 if (i == 3 || *p != '.')
    3330             :                                         break;
    3331           0 :                                 ++p;
    3332             :                         }
    3333             : 
    3334             :                         /* here i points to last element */
    3335        3710 :                         odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
    3336        3710 :                         if (!tds_dstr_copy(&drec->sql_desc_base_table_name, buf))
    3337             :                                 goto memory_error;
    3338             : 
    3339        3710 :                         --i;
    3340        3710 :                         if (i >= 0) {
    3341           0 :                                 odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
    3342           0 :                                 if (!tds_dstr_copy(&drec->sql_desc_schema_name, buf))
    3343             :                                         goto memory_error;
    3344             :                         }
    3345             : 
    3346        3710 :                         --i;
    3347        3710 :                         if (i >= 0) {
    3348           0 :                                 odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
    3349           0 :                                 if (!tds_dstr_copy(&drec->sql_desc_catalog_name, buf))
    3350             :                                         goto memory_error;
    3351             :                         }
    3352             :                 }
    3353             : 
    3354       36934 :                 drec->sql_desc_unnamed = tds_dstr_isempty(&drec->sql_desc_name) ? SQL_UNNAMED : SQL_NAMED;
    3355             :                 /* TODO use is_nullable_type ?? */
    3356       18467 :                 drec->sql_desc_nullable = col->column_nullable ? SQL_TRUE : SQL_FALSE;
    3357             : 
    3358       18467 :                 drec->sql_desc_octet_length_ptr = NULL;
    3359             :                 /* TODO test timestamp from db, FOR BROWSE query */
    3360       18467 :                 drec->sql_desc_rowver = SQL_FALSE;
    3361             :                 /* TODO seem not correct */
    3362       18467 :                 drec->sql_desc_searchable = (drec->sql_desc_unnamed == SQL_NAMED) ? SQL_PRED_SEARCHABLE : SQL_UNSEARCHABLE;
    3363       18467 :                 drec->sql_desc_updatable = col->column_writeable && !col->column_identity ? SQL_TRUE : SQL_FALSE;
    3364             :         }
    3365             :         return SQL_SUCCESS;
    3366             : 
    3367           0 : memory_error:
    3368           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    3369           0 :         return SQL_ERROR;
    3370             : }
    3371             : 
    3372             : static TDSRET
    3373        2314 : odbc_cursor_execute(TDS_STMT * stmt)
    3374             : {
    3375        2314 :         TDSSOCKET *tds = stmt->tds;
    3376             :         int i;
    3377        2314 :         bool send = false;
    3378             :         TDSRET ret;
    3379             :         TDSCURSOR *cursor;
    3380        2314 :         TDSPARAMINFO *params = stmt->params;
    3381             : 
    3382        2314 :         assert(tds);
    3383        2314 :         assert(stmt->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY || stmt->attr.concurrency != SQL_CONCUR_READ_ONLY);
    3384             : 
    3385        2314 :         tds_release_cursor(&stmt->cursor);
    3386       11570 :         cursor = tds_alloc_cursor(tds, tds_dstr_cstr(&stmt->cursor_name), tds_dstr_len(&stmt->cursor_name),
    3387        4628 :                         tds_dstr_cstr(&stmt->query), tds_dstr_len(&stmt->query));
    3388        2314 :         if (!cursor) {
    3389           0 :                 odbc_unlock_statement(stmt);
    3390             : 
    3391           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    3392           0 :                 return TDS_FAIL;
    3393             :         }
    3394        2314 :         stmt->cursor = cursor;
    3395             : 
    3396             :         /* TODO cursor add enums for tds7 */
    3397        2314 :         switch (stmt->attr.cursor_type) {
    3398             :         default:
    3399             :         case SQL_CURSOR_FORWARD_ONLY:
    3400             :                 i = TDS_CUR_TYPE_FORWARD;
    3401             :                 break;
    3402             :         case SQL_CURSOR_STATIC:
    3403             :                 i = TDS_CUR_TYPE_STATIC;
    3404             :                 break;
    3405             :         case SQL_CURSOR_KEYSET_DRIVEN:
    3406             :                 i = TDS_CUR_TYPE_KEYSET;
    3407             :                 break;
    3408             :         case SQL_CURSOR_DYNAMIC:
    3409             :                 i = TDS_CUR_TYPE_DYNAMIC;
    3410             :                 break;
    3411             :         }
    3412        2314 :         cursor->type = i;
    3413             : 
    3414        2314 :         switch (stmt->attr.concurrency) {
    3415             :         default:
    3416             :         case SQL_CONCUR_READ_ONLY:
    3417             :                 i = TDS_CUR_CONCUR_READ_ONLY;
    3418             :                 break;
    3419             :         case SQL_CONCUR_LOCK:
    3420             :                 i = TDS_CUR_CONCUR_SCROLL_LOCKS;
    3421             :                 break;
    3422             :         case SQL_CONCUR_ROWVER:
    3423             :                 i = TDS_CUR_CONCUR_OPTIMISTIC;
    3424             :                 break;
    3425             :         case SQL_CONCUR_VALUES:
    3426             :                 i = TDS_CUR_CONCUR_OPTIMISTIC_VALUES;
    3427             :                 break;
    3428             :         }
    3429        2314 :         cursor->concurrency = TDS_CUR_CONCUR_ALLOW_DIRECT | i;
    3430             : 
    3431        2314 :         ret = tds_cursor_declare(tds, cursor, &send);
    3432        2314 :         if (TDS_FAILED(ret))
    3433             :                 return ret;
    3434        2314 :         ret = tds_cursor_open(tds, cursor, params, &send);
    3435        2314 :         if (TDS_FAILED(ret))
    3436             :                 return ret;
    3437             :         /* TODO read results, set row count, check type and scroll returned */
    3438        2314 :         ret = tds_flush_packet(tds);
    3439        2314 :         tds_set_state(tds, TDS_PENDING);
    3440             :         /* set cursor name for TDS7+ */
    3441        4628 :         if (TDS_SUCCEED(ret) && IS_TDS7_PLUS(tds->conn) && !tds_dstr_isempty(&stmt->cursor_name)) {
    3442        2314 :                 ret = odbc_process_tokens(stmt, TDS_RETURN_DONE|TDS_STOPAT_ROW|TDS_STOPAT_COMPUTE);
    3443        2314 :                 stmt->row_count = tds->rows_affected;
    3444        2314 :                 if (ret == TDS_CMD_DONE && cursor->cursor_id != 0) {
    3445         248 :                         ret = tds_cursor_setname(tds, cursor);
    3446         248 :                         tds_set_state(tds, TDS_PENDING);
    3447             :                 } else {
    3448        2066 :                         ret = (ret == TDS_CMD_FAIL) ? TDS_FAIL : TDS_SUCCESS;
    3449             :                 }
    3450        2314 :                 if (!cursor->cursor_id) {
    3451        2058 :                         tds_cursor_dealloc(tds, cursor);
    3452        2058 :                         tds_release_cursor(&stmt->cursor);
    3453             :                 }
    3454             :         }
    3455             :         return ret;
    3456             : }
    3457             : 
    3458             : static TDSHEADERS *
    3459       27721 : odbc_init_headers(TDS_STMT * stmt, TDSHEADERS * head)
    3460             : {
    3461       55446 :         if (tds_dstr_isempty(&stmt->attr.qn_msgtext) || tds_dstr_isempty(&stmt->attr.qn_options))
    3462             :                 return NULL;
    3463             : 
    3464           4 :         memset(head, 0, sizeof(*head));
    3465           4 :         head->qn_timeout = stmt->attr.qn_timeout;
    3466           8 :         head->qn_msgtext = tds_dstr_cstr(&stmt->attr.qn_msgtext);
    3467           8 :         head->qn_options = tds_dstr_cstr(&stmt->attr.qn_options);
    3468           4 :         return head;
    3469             : }
    3470             : 
    3471             : static SQLRETURN
    3472       32777 : odbc_SQLExecute(TDS_STMT * stmt)
    3473             : {
    3474             :         TDSRET ret;
    3475             :         TDSSOCKET *tds;
    3476             :         TDS_INT result_type;
    3477       32777 :         TDS_INT done = 0;
    3478       32777 :         bool in_row = false;
    3479             :         SQLUSMALLINT param_status;
    3480       32777 :         int found_info = 0, found_error = 0;
    3481       32777 :         TDS_INT8 total_rows = TDS_NO_COUNT;
    3482             :         TDSHEADERS head;
    3483             : 
    3484       32777 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLExecute(%p)\n",
    3485             :                         stmt);
    3486             : 
    3487       32777 :         stmt->row = 0;
    3488             : 
    3489             : 
    3490             :         /* check parameters are all OK */
    3491       32777 :         if (stmt->params && stmt->param_num <= (int) stmt->param_count) {
    3492             :                 /* TODO what error ?? */
    3493           0 :                 ODBC_SAFE_ERROR(stmt);
    3494             :                 return SQL_ERROR;
    3495             :         }
    3496             : 
    3497       32777 :         if (!odbc_lock_statement(stmt))
    3498             :                 return SQL_ERROR;
    3499             : 
    3500       32769 :         tds = stmt->tds;
    3501       32769 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLExecute() starting with state %d\n", tds->state);
    3502             : 
    3503       32769 :         if (tds->state != TDS_IDLE) {
    3504           0 :                 if (tds->state == TDS_DEAD) {
    3505           0 :                         odbc_errs_add(&stmt->errs, "08S01", NULL);
    3506             :                 } else {
    3507           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    3508             :                 }
    3509             :                 return SQL_ERROR;
    3510             :         }
    3511             : 
    3512       32769 :         stmt->curr_param_row = 0;
    3513       32769 :         stmt->num_param_rows = TDS_MAX(1, stmt->apd->header.sql_desc_array_size);
    3514             : 
    3515       32769 :         stmt->row_count = TDS_NO_COUNT;
    3516             : 
    3517       32769 :         if (stmt->prepared_query_is_rpc) {
    3518             :                 /* TODO support stmt->apd->header.sql_desc_array_size for RPC */
    3519             :                 /* get rpc name */
    3520             :                 /* TODO change method */
    3521             :                 /* TODO cursor change way of calling */
    3522        2212 :                 char *name = tds_dstr_buf(&stmt->query);
    3523             :                 char *end, tmp;
    3524             : 
    3525        1106 :                 end = name;
    3526        1106 :                 end = (char *) odbc_skip_rpc_name(end);
    3527        1106 :                 stmt->prepared_pos = end - name;
    3528        1106 :                 tmp = *end;
    3529        1106 :                 *end = 0;
    3530        1106 :                 ret = tds_submit_rpc(tds, name, stmt->params, odbc_init_headers(stmt, &head));
    3531        1106 :                 *end = tmp;
    3532       31663 :         } else if (stmt->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY || stmt->attr.concurrency != SQL_CONCUR_READ_ONLY) {
    3533        2314 :                 ret = odbc_cursor_execute(stmt);
    3534       29349 :         } else if (!stmt->is_prepared_query) {
    3535             :                 /* not prepared query */
    3536             :                 /* TODO cursor change way of calling */
    3537             :                 /* SQLExecDirect */
    3538       26615 :                 if (stmt->num_param_rows <= 1) {
    3539       26527 :                         if (!stmt->params) {
    3540       51466 :                                 ret = tds_submit_query_params(tds, tds_dstr_cstr(&stmt->query), NULL,
    3541             :                                                               odbc_init_headers(stmt, &head));
    3542             :                         } else {
    3543        1588 :                                 ret = tds_submit_execdirect(tds, tds_dstr_cstr(&stmt->query), stmt->params,
    3544             :                                                             odbc_init_headers(stmt, &head));
    3545             :                         }
    3546             :                 } else {
    3547             :                         /* pack multiple submit using language */
    3548             :                         TDSMULTIPLE multiple;
    3549             : 
    3550          88 :                         ret = tds_multiple_init(tds, &multiple, TDS_MULTIPLE_QUERY, odbc_init_headers(stmt, &head));
    3551         728 :                         for (stmt->curr_param_row = 0; TDS_SUCCEED(ret); ) {
    3552             :                                 /* submit a query */
    3553        1280 :                                 ret = tds_multiple_query(tds, &multiple, tds_dstr_cstr(&stmt->query), stmt->params);
    3554         640 :                                 if (++stmt->curr_param_row >= stmt->num_param_rows)
    3555             :                                         break;
    3556             :                                 /* than process others parameters */
    3557             :                                 /* TODO handle all results*/
    3558         552 :                                 if (start_parse_prepared_query(stmt, true) != SQL_SUCCESS)
    3559             :                                         break;
    3560             :                         }
    3561          88 :                         if (TDS_SUCCEED(ret))
    3562          88 :                                 ret = tds_multiple_done(tds, &multiple);
    3563             :                 }
    3564        2734 :         } else if (stmt->num_param_rows <= 1 && IS_TDS71_PLUS(tds->conn) && (!stmt->dyn || stmt->need_reprepare)) {
    3565        1792 :                         if (stmt->dyn) {
    3566          80 :                                 if (odbc_free_dynamic(stmt) != SQL_SUCCESS)
    3567           0 :                                         ODBC_RETURN(stmt, SQL_ERROR);
    3568             :                         }
    3569        1792 :                         stmt->need_reprepare = 0;
    3570        3584 :                         ret = tds71_submit_prepexec(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params);
    3571             :         } else {
    3572             :                 /* TODO cursor change way of calling */
    3573             :                 /* SQLPrepare */
    3574             :                 TDSDYNAMIC *dyn;
    3575             : 
    3576             :                 /* prepare dynamic query (only for first SQLExecute call) */
    3577         942 :                 if (!stmt->dyn || (stmt->need_reprepare && !stmt->dyn->emulated && IS_TDS7_PLUS(tds->conn))) {
    3578             : 
    3579             :                         /* free previous prepared statement */
    3580          56 :                         if (stmt->dyn) {
    3581           0 :                                 if (odbc_free_dynamic(stmt) != SQL_SUCCESS)
    3582           0 :                                         ODBC_RETURN(stmt, SQL_ERROR);
    3583             :                         }
    3584          56 :                         stmt->need_reprepare = 0;
    3585             : 
    3586          56 :                         tdsdump_log(TDS_DBG_INFO1, "Creating prepared statement\n");
    3587             :                         /* TODO use tds_submit_prepexec (mssql2k, tds71) */
    3588         112 :                         if (TDS_FAILED(tds_submit_prepare(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params))) {
    3589             :                                 /* TODO ?? tds_free_param_results(params); */
    3590           0 :                                 ODBC_SAFE_ERROR(stmt);
    3591             :                                 return SQL_ERROR;
    3592             :                         }
    3593          56 :                         if (TDS_FAILED(tds_process_simple_query(tds))) {
    3594           0 :                                 tds_release_dynamic(&stmt->dyn);
    3595             :                                 /* TODO ?? tds_free_param_results(params); */
    3596           0 :                                 ODBC_SAFE_ERROR(stmt);
    3597             :                                 return SQL_ERROR;
    3598             :                         }
    3599             :                 }
    3600         942 :                 stmt->row_count = TDS_NO_COUNT;
    3601         942 :                 if (stmt->num_param_rows <= 1) {
    3602         886 :                         dyn = stmt->dyn;
    3603         886 :                         tds_free_input_params(dyn);
    3604         886 :                         dyn->params = stmt->params;
    3605             :                         /* prevent double free */
    3606         886 :                         stmt->params = NULL;
    3607         886 :                         tdsdump_log(TDS_DBG_INFO1, "End prepare, execute\n");
    3608             :                         /* TODO return error to client */
    3609         886 :                         ret = tds_submit_execute(tds, dyn);
    3610             :                 } else {
    3611             :                         TDSMULTIPLE multiple;
    3612             : 
    3613          56 :                         ret = tds_multiple_init(tds, &multiple, TDS_MULTIPLE_EXECUTE, NULL);
    3614         616 :                         for (stmt->curr_param_row = 0; TDS_SUCCEED(ret); ) {
    3615         560 :                                 dyn = stmt->dyn;
    3616         560 :                                 tds_free_input_params(dyn);
    3617         560 :                                 dyn->params = stmt->params;
    3618             :                                 /* prevent double free */
    3619         560 :                                 stmt->params = NULL;
    3620         560 :                                 ret = tds_multiple_execute(tds, &multiple, dyn);
    3621         560 :                                 if (++stmt->curr_param_row >= stmt->num_param_rows)
    3622             :                                         break;
    3623             :                                 /* than process others parameters */
    3624             :                                 /* TODO handle all results*/
    3625         504 :                                 if (start_parse_prepared_query(stmt, true) != SQL_SUCCESS)
    3626             :                                         break;
    3627             :                         }
    3628          56 :                         if (TDS_SUCCEED(ret))
    3629          56 :                                 ret = tds_multiple_done(tds, &multiple);
    3630             :                 }
    3631             :         }
    3632       32769 :         if (TDS_FAILED(ret)) {
    3633          20 :                 ODBC_SAFE_ERROR(stmt);
    3634             :                 return SQL_ERROR;
    3635             :         }
    3636             :         /* catch all errors */
    3637       32749 :         if (!odbc_lock_statement(stmt))
    3638           0 :                 ODBC_RETURN_(stmt);
    3639             : 
    3640       32749 :         stmt->row_status = PRE_NORMAL_ROW;
    3641             : 
    3642       32749 :         stmt->curr_param_row = 0;
    3643       32749 :         param_status = SQL_PARAM_SUCCESS;
    3644             : 
    3645             :         /* TODO review this, ODBC return parameter in other way, for compute I don't know */
    3646             :         /* TODO perhaps we should return SQL_NO_DATA if no data available... see old SQLExecute code */
    3647             :         for (;;) {
    3648       54092 :                 result_type = odbc_process_tokens(stmt, TDS_TOKEN_RESULTS);
    3649       54092 :                 tdsdump_log(TDS_DBG_FUNC, "odbc_SQLExecute: odbc_process_tokens returned result_type %d\n", result_type);
    3650       54092 :                 switch (result_type) {
    3651       28851 :                 case TDS_CMD_FAIL:
    3652             :                 case TDS_CMD_DONE:
    3653             :                 case TDS_COMPUTE_RESULT:
    3654             :                 case TDS_ROW_RESULT:
    3655       28851 :                         done = 1;
    3656       28851 :                         break;
    3657             : 
    3658        4876 :                 case TDS_DONE_RESULT:
    3659             :                 case TDS_DONEPROC_RESULT:
    3660        4876 :                         switch (stmt->errs.lastrc) {
    3661         962 :                         case SQL_ERROR:
    3662         962 :                                 found_error = 1;
    3663         962 :                                 param_status = SQL_PARAM_ERROR;
    3664         962 :                                 break;
    3665         590 :                         case SQL_SUCCESS_WITH_INFO:
    3666         590 :                                 found_info = 1;
    3667         590 :                                 param_status = SQL_PARAM_SUCCESS_WITH_INFO;
    3668         590 :                                 break;
    3669             :                         }
    3670        4876 :                         if (stmt->curr_param_row < stmt->num_param_rows && stmt->ipd->header.sql_desc_array_status_ptr)
    3671         820 :                                 stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
    3672        4876 :                         param_status = SQL_PARAM_SUCCESS;
    3673        4876 :                         ++stmt->curr_param_row;
    3674             :                         /* actually is quite strange, if prepared always success with info or success
    3675             :                          * if not prepared return last one
    3676             :                          */
    3677        4876 :                         if (stmt->curr_param_row < stmt->num_param_rows || result_type == TDS_DONEPROC_RESULT)
    3678        1586 :                                 stmt->errs.lastrc = SQL_SUCCESS;
    3679        4876 :                         if (total_rows == TDS_NO_COUNT)
    3680        4012 :                                 total_rows = stmt->row_count;
    3681         864 :                         else if (stmt->row_count != TDS_NO_COUNT)
    3682         654 :                                 total_rows += stmt->row_count;
    3683        4876 :                         stmt->row_count = TDS_NO_COUNT;
    3684        4876 :                         if (stmt->curr_param_row >= stmt->num_param_rows) {
    3685        3820 :                                 done = 1;
    3686        3820 :                                 break;
    3687             :                         }
    3688             :                         break;
    3689             : 
    3690        9904 :                 case TDS_DONEINPROC_RESULT:
    3691        9904 :                         if (in_row)
    3692          78 :                                 done = 1;
    3693             :                         break;
    3694             : 
    3695             :                         /* ignore metadata, stop at done or row */
    3696       10425 :                 case TDS_ROWFMT_RESULT:
    3697       10425 :                         if (in_row) {
    3698             :                                 done = 1;
    3699             :                                 break;
    3700             :                         }
    3701       10425 :                         stmt->row = 0;
    3702       10425 :                         stmt->row_count = TDS_NO_COUNT;
    3703       10425 :                         stmt->row_status = PRE_NORMAL_ROW;
    3704       10425 :                         in_row = true;
    3705       10425 :                         break;
    3706             :                 }
    3707       54092 :                 if (done)
    3708             :                         break;
    3709             :         }
    3710       32749 :         if (found_error) {
    3711             :                 /* if the application uses status array it can examine it to determine
    3712             :                    which rows resulted in errors, but if it doesn't, it has no way to
    3713             :                    do it and we must return an error and not success with info to it */
    3714         426 :                 if (stmt->ipd->header.sql_desc_array_status_ptr)
    3715          64 :                         stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    3716             :                 else
    3717         362 :                         stmt->errs.lastrc = SQL_ERROR;
    3718       32323 :         } else if (found_info && stmt->errs.lastrc != SQL_ERROR)
    3719         590 :                 stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    3720             : 
    3721       98247 :         if (tds_dstr_isempty(&stmt->attr.qn_msgtext) != tds_dstr_isempty(&stmt->attr.qn_options)) {
    3722           0 :                 odbc_errs_add(&stmt->errs, "HY000", "Attribute ignored");
    3723           0 :                 stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    3724             :         }
    3725       32749 :         if (found_error && stmt->num_param_rows <= 1)
    3726         346 :                 stmt->errs.lastrc = SQL_ERROR;
    3727       32749 :         if (stmt->curr_param_row < stmt->num_param_rows) {
    3728       28929 :                 if (stmt->ipd->header.sql_desc_array_status_ptr)
    3729           0 :                         stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
    3730       28929 :                 ++stmt->curr_param_row;
    3731       28929 :                 if (total_rows == TDS_NO_COUNT)
    3732       28929 :                         total_rows = stmt->row_count;
    3733           0 :                 else if (stmt->row_count != TDS_NO_COUNT)
    3734           0 :                         total_rows += stmt->row_count;
    3735       28929 :                 stmt->row_count = TDS_NO_COUNT;
    3736             :         }
    3737       32749 :         if (stmt->ipd->header.sql_desc_rows_processed_ptr)
    3738         144 :                 *stmt->ipd->header.sql_desc_rows_processed_ptr = TDS_MIN(stmt->curr_param_row, stmt->num_param_rows);
    3739             : 
    3740       32749 :         if (total_rows != TDS_NO_COUNT)
    3741        8220 :                 stmt->row_count = total_rows;
    3742             : 
    3743       32749 :         odbc_populate_ird(stmt);
    3744       32749 :         switch (result_type) {
    3745       18432 :         case TDS_CMD_DONE:
    3746       18432 :                 odbc_unlock_statement(stmt);
    3747       18432 :                 if (stmt->errs.lastrc == SQL_SUCCESS && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3
    3748       15332 :                     && stmt->row_count == TDS_NO_COUNT && !stmt->cursor && stmt->ird->header.sql_desc_count <= 0)
    3749       10692 :                         ODBC_RETURN(stmt, SQL_NO_DATA);
    3750             :                 break;
    3751             : 
    3752         206 :         case TDS_CMD_FAIL:
    3753             :                 /* TODO test what happened, report correct error to client */
    3754         206 :                 tdsdump_log(TDS_DBG_INFO1, "SQLExecute: bad results\n");
    3755         206 :                 ODBC_SAFE_ERROR(stmt);
    3756             :                 return SQL_ERROR;
    3757             :         }
    3758       21851 :         ODBC_RETURN_(stmt);
    3759             : }
    3760             : 
    3761       27773 : ODBC_FUNC(SQLExecDirect, (P(SQLHSTMT,hstmt), PCHARIN(SqlStr,SQLINTEGER) WIDE))
    3762             : {
    3763             :         SQLRETURN res;
    3764             : 
    3765       27773 :         ODBC_ENTER_HSTMT;
    3766             : 
    3767       27773 :         if (SQL_SUCCESS != odbc_set_stmt_query(stmt, szSqlStr, cbSqlStr _wide)) {
    3768           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    3769           0 :                 ODBC_EXIT_(stmt);
    3770             :         }
    3771             : 
    3772             :         /* count placeholders */
    3773             :         /* note: szSqlStr can be no-null terminated, so first we set query and then count placeholders */
    3774       55546 :         stmt->param_count = tds_count_placeholders(tds_dstr_cstr(&stmt->query));
    3775       27773 :         stmt->param_data_called = 0;
    3776             : 
    3777       27773 :         if (SQL_SUCCESS != prepare_call(stmt)) {
    3778             :                 /* TODO return another better error, prepare_call should set error ?? */
    3779           0 :                 odbc_errs_add(&stmt->errs, "HY000", "Could not prepare call");
    3780           0 :                 ODBC_EXIT_(stmt);
    3781             :         }
    3782             : 
    3783       27773 :         res = start_parse_prepared_query(stmt, true);
    3784       27773 :         if (SQL_SUCCESS != res)
    3785          92 :                 ODBC_EXIT(stmt, res);
    3786             : 
    3787       27681 :         ODBC_EXIT(stmt, odbc_SQLExecute(stmt));
    3788             : }
    3789             : 
    3790             : SQLRETURN ODBC_PUBLIC ODBC_API
    3791             : SQLExecute(SQLHSTMT hstmt)
    3792             : {
    3793             :         ODBC_PRRET_BUF;
    3794             :         SQLRETURN res;
    3795             : 
    3796        4688 :         ODBC_ENTER_HSTMT;
    3797             : 
    3798        4688 :         tdsdump_log(TDS_DBG_FUNC, "SQLExecute(%p)\n", hstmt);
    3799             : 
    3800        4688 :         if (!stmt->is_prepared_query) {
    3801             :                 /* TODO error report, only without DM ?? */
    3802           0 :                 tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns SQL_ERROR (not prepared)\n");
    3803           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    3804             :         }
    3805             : 
    3806             :         /* TODO rebuild should be done for every bindings change, not every time */
    3807             :         /* TODO free previous parameters */
    3808             :         /* build parameters list */
    3809        4688 :         stmt->param_data_called = 0;
    3810        4688 :         stmt->curr_param_row = 0;
    3811        4688 :         if ((res = start_parse_prepared_query(stmt, true)) != SQL_SUCCESS) {
    3812         112 :                 tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns %s (start_parse_prepared_query failed)\n", odbc_prret(res));
    3813         112 :                 ODBC_EXIT(stmt, res);
    3814             :         }
    3815             : 
    3816             :         /* TODO test if two SQLPrepare on a statement */
    3817             :         /* TODO test unprepare on statement free or connection close */
    3818             : 
    3819        4576 :         res = odbc_SQLExecute(stmt);
    3820             : 
    3821        4576 :         tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns %s\n", odbc_prret(res));
    3822             : 
    3823        4576 :         ODBC_EXIT(stmt, res);
    3824             : }
    3825             : 
    3826             : static int
    3827       96916 : odbc_process_tokens(TDS_STMT * stmt, unsigned flag)
    3828             : {
    3829             :         TDS_INT result_type;
    3830       96916 :         int done_flags = 0;
    3831       96916 :         TDSSOCKET * tds = stmt->tds;
    3832             : 
    3833       96916 :         flag |= TDS_RETURN_DONE | TDS_RETURN_PROC;
    3834             :         for (;;) {
    3835      183684 :                 TDSRET retcode = tds_process_tokens(tds, &result_type, &done_flags, flag);
    3836      183684 :                 tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: tds_process_tokens returned %d\n", retcode);
    3837      183684 :                 tdsdump_log(TDS_DBG_FUNC, "    result_type=%d, TDS_DONE_COUNT=%x, TDS_DONE_ERROR=%x\n",
    3838             :                                                 result_type, (done_flags & TDS_DONE_COUNT), (done_flags & TDS_DONE_ERROR));
    3839      183684 :                 switch (retcode) {
    3840             :                 case TDS_SUCCESS:
    3841             :                         break;
    3842             :                 case TDS_NO_MORE_RESULTS:
    3843             :                         return TDS_CMD_DONE;
    3844         196 :                 case TDS_CANCELLED:
    3845         196 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
    3846             :                 default:
    3847             :                         return TDS_CMD_FAIL;
    3848             :                 }
    3849             : 
    3850      152813 :                 switch (result_type) {
    3851        1216 :                 case TDS_STATUS_RESULT:
    3852        1216 :                         odbc_set_return_status(stmt, TDS_MIN(stmt->curr_param_row, stmt->num_param_rows - 1));
    3853        1216 :                         break;
    3854         834 :                 case TDS_PARAM_RESULT:
    3855         834 :                         odbc_set_return_params(stmt, TDS_MIN(stmt->curr_param_row, stmt->num_param_rows - 1));
    3856         834 :                         break;
    3857             : 
    3858       97896 :                 case TDS_DONE_RESULT:
    3859             :                 case TDS_DONEPROC_RESULT:
    3860       97896 :                         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
    3861       91108 :                                 flag |= TDS_STOPAT_MSG;
    3862       97896 :                         if (done_flags & TDS_DONE_COUNT) {
    3863             :                                 /* correct ?? overwrite ?? */
    3864       11876 :                                 if (stmt->row_count == TDS_NO_COUNT)
    3865       11776 :                                         stmt->row_count = tds->rows_affected;
    3866             :                         }
    3867       97896 :                         if (done_flags & TDS_DONE_ERROR)
    3868         684 :                                 stmt->errs.lastrc = SQL_ERROR;
    3869             :                         /* test for internal_sp not very fine, used for param set  -- freddy77 */
    3870       97896 :                         if ((done_flags & (TDS_DONE_COUNT|TDS_DONE_ERROR)) != 0
    3871       85456 :                             || (stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
    3872       84840 :                             || (result_type == TDS_DONEPROC_RESULT && tds->current_op == TDS_OP_EXECUTE)) {
    3873             :                                 /* FIXME this row is used only as a flag for update binding,
    3874             :                                  * should be cleared if binding/result changed */
    3875       14096 :                                 stmt->row = 0;
    3876             : #if 0
    3877             :                                 tds_free_all_results(tds);
    3878             :                                 odbc_populate_ird(stmt);
    3879             : #endif
    3880       14096 :                                 tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: row_count=%" PRId64 "\n", stmt->row_count);
    3881       14096 :                                 return result_type;
    3882             :                         }
    3883       83800 :                         tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: processed %s\n",
    3884             :                                         result_type==TDS_DONE_RESULT? "TDS_DONE_RESULT" : "TDS_DONEPROC_RESULT");
    3885             :                         break;
    3886             : 
    3887             :                 /*
    3888             :                  * TODO test flags ? check error and change result ?
    3889             :                  * see also other DONEINPROC handle (below)
    3890             :                  */
    3891       10920 :                 case TDS_DONEINPROC_RESULT:
    3892       10920 :                         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
    3893        6124 :                                 flag |= TDS_STOPAT_MSG;
    3894       10920 :                         if (done_flags & TDS_DONE_COUNT) {
    3895        7068 :                                 stmt->row_count = tds->rows_affected;
    3896             :                         }
    3897       10920 :                         if (done_flags & TDS_DONE_ERROR)
    3898         448 :                                 stmt->errs.lastrc = SQL_ERROR;
    3899             :                         /* TODO perhaps it can be a problem if SET NOCOUNT ON, test it */
    3900             : #if 0
    3901             :                         tds_free_all_results(tds);
    3902             :                         odbc_populate_ird(stmt);
    3903             : #endif
    3904       10920 :                         tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: processed TDS_DONEINPROC_RESULT\n");
    3905       10920 :                         if (stmt->row_status == PRE_NORMAL_ROW)
    3906       10002 :                                 return result_type;
    3907             :                         break;
    3908             : 
    3909       41947 :                 default:
    3910       41947 :                         tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: returning result_type %d\n", result_type);
    3911       41947 :                         return result_type;
    3912             :                 }
    3913             :         }
    3914             : }
    3915             : 
    3916             : static void
    3917         160 : odbc_fix_data_type_col(TDS_STMT *stmt, int idx)
    3918             : {
    3919         160 :         TDSSOCKET *tds = stmt->tds;
    3920             :         TDSRESULTINFO *resinfo;
    3921             :         TDSCOLUMN *colinfo;
    3922             : 
    3923         160 :         if (!tds)
    3924             :                 return;
    3925             : 
    3926         160 :         resinfo = tds->current_results;
    3927         160 :         if (!resinfo || resinfo->num_cols <= idx)
    3928             :                 return;
    3929             : 
    3930         160 :         colinfo = resinfo->columns[idx];
    3931         160 :         if (colinfo->column_cur_size < 0)
    3932             :                 return;
    3933             : 
    3934         160 :         switch (tds_get_conversion_type(colinfo->column_type, colinfo->column_size)) {
    3935         160 :         case SYBINT2: {
    3936         160 :                 TDS_SMALLINT *data = (TDS_SMALLINT *) colinfo->column_data;
    3937         320 :                 *data = odbc_swap_datetime_sql_type(*data, 0);
    3938             :                 }
    3939         160 :                 break;
    3940           0 :         case SYBINT4: {
    3941           0 :                 TDS_INT *data = (TDS_INT *) colinfo->column_data;
    3942           0 :                 *data = odbc_swap_datetime_sql_type(*data, 0);
    3943             :                 }
    3944           0 :                 break;
    3945             :         default:
    3946             :                 break;
    3947             :         }
    3948             : }
    3949             : 
    3950             : static SQLUSMALLINT
    3951       19794 : copy_row(TDS_STMT * const stmt, const SQLLEN row_offset, const SQLULEN curr_row)
    3952             : {
    3953       19794 :         const TDS_DESC *const ard = stmt->ard;
    3954       19794 :         TDSRESULTINFO *const resinfo = stmt->tds->current_results;
    3955             :         int i;
    3956       19794 :         bool truncated = false;
    3957             : 
    3958             : #define AT_ROW(ptr, type) (row_offset ? (type*)(((char*)(ptr)) + row_offset) : &ptr[curr_row])
    3959             : 
    3960       96406 :         for (i = 0; i < resinfo->num_cols; i++) {
    3961             :                 TDSCOLUMN *colinfo;
    3962             :                 struct _drecord *drec_ard;
    3963             :                 SQLLEN len;
    3964             : 
    3965       76612 :                 colinfo = resinfo->columns[i];
    3966       76612 :                 colinfo->column_text_sqlgetdatapos = 0;
    3967       76612 :                 colinfo->column_iconv_left = 0;
    3968       76612 :                 drec_ard = (i < ard->header.sql_desc_count) ? &ard->records[i] : NULL;
    3969       19552 :                 if (!drec_ard)
    3970       57060 :                         continue;
    3971       19552 :                 if (colinfo->column_cur_size < 0) {
    3972        2380 :                         if (drec_ard->sql_desc_indicator_ptr) {
    3973        1264 :                                 *AT_ROW(drec_ard->sql_desc_indicator_ptr, SQLLEN) = SQL_NULL_DATA;
    3974        1116 :                         } else if (drec_ard->sql_desc_data_ptr) {
    3975           0 :                                 odbc_errs_add(&stmt->errs, "22002", NULL);
    3976           0 :                                 return SQL_ROW_ERROR;
    3977             :                         }
    3978        2380 :                         continue;
    3979             :                 }
    3980             :                 /* set indicator to 0 if data is not null */
    3981       17172 :                 if (drec_ard->sql_desc_indicator_ptr)
    3982       12122 :                         *AT_ROW(drec_ard->sql_desc_indicator_ptr, SQLLEN) = 0;
    3983             : 
    3984             :                 /* TODO what happen to length if no data is returned (drec->sql_desc_data_ptr == NULL) ?? */
    3985       17172 :                 len = 0;
    3986       17172 :                 if (drec_ard->sql_desc_data_ptr) {
    3987             :                         int c_type;
    3988       11840 :                         TDS_CHAR *data_ptr = (TDS_CHAR *) drec_ard->sql_desc_data_ptr;
    3989             : 
    3990       11840 :                         colinfo->column_text_sqlgetdatapos = 0;
    3991       11840 :                         colinfo->column_iconv_left = 0;
    3992       11840 :                         c_type = drec_ard->sql_desc_concise_type;
    3993       11840 :                         if (c_type == SQL_C_DEFAULT)
    3994          10 :                                 c_type = odbc_sql_to_c_type_default(stmt->ird->records[i].sql_desc_concise_type);
    3995       11840 :                         if (row_offset || curr_row == 0) {
    3996       10682 :                                 data_ptr += row_offset;
    3997             :                         } else {
    3998        1158 :                                 data_ptr += odbc_get_octet_len(c_type, drec_ard) * curr_row;
    3999             :                         }
    4000       11840 :                         len = odbc_tds2sql_col(stmt, colinfo, c_type, data_ptr, drec_ard->sql_desc_octet_length, drec_ard);
    4001       11840 :                         if (len == SQL_NULL_DATA)
    4002             :                                 return SQL_ROW_ERROR;
    4003             : 
    4004       11840 :                         if ((c_type == SQL_C_CHAR && len >= drec_ard->sql_desc_octet_length)
    4005       11652 :                             || (c_type == SQL_C_BINARY && len > drec_ard->sql_desc_octet_length)) {
    4006         188 :                                 truncated = true;
    4007         188 :                                 stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    4008             :                         }
    4009             :                 }
    4010       17172 :                 if (drec_ard->sql_desc_octet_length_ptr)
    4011       12122 :                         *AT_ROW(drec_ard->sql_desc_octet_length_ptr, SQLLEN) = len;
    4012             :         }
    4013             : 
    4014       19794 :         return truncated ? SQL_ROW_SUCCESS_WITH_INFO : SQL_ROW_SUCCESS;
    4015             : #undef AT_ROW
    4016             : }
    4017             : 
    4018             : /*
    4019             :  * - handle correctly SQLGetData (for forward cursors accept only row_size == 1
    4020             :  *   for other types application must use SQLSetPos)
    4021             :  * - handle correctly results (SQL_SUCCESS_WITH_INFO if error on some rows,
    4022             :  *   SQL_ERROR for all rows, see doc)
    4023             :  */
    4024             : static SQLRETURN
    4025       27496 : odbc_SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
    4026             : {
    4027             :         TDSSOCKET *tds;
    4028             :         TDSRESULTINFO *resinfo;
    4029             :         int i;
    4030             :         SQLULEN curr_row, num_rows;
    4031       27496 :         const TDS_DESC *const ard = stmt->ard;
    4032             :         SQLULEN dummy, *fetched_ptr;
    4033       27496 :         SQLUSMALLINT *status_ptr, row_status = SQL_ROW_SUCCESS;
    4034             :         TDS_INT result_type;
    4035       27496 :         bool truncated = false;
    4036             : 
    4037       27496 :         SQLLEN row_offset = 0;
    4038             : 
    4039       27496 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLFetch(%p, %d, %d)\n", stmt, (int)FetchOrientation, (int)FetchOffset);
    4040             : 
    4041       27496 :         if (ard->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN && ard->header.sql_desc_bind_offset_ptr)
    4042           0 :                 row_offset = *ard->header.sql_desc_bind_offset_ptr;
    4043             : 
    4044       27496 :         tds = stmt->tds;
    4045       27496 :         num_rows = ard->header.sql_desc_array_size;
    4046             : 
    4047             :         /* TODO cursor check also type of cursor (scrollable, not forward) */
    4048       27496 :         if (FetchOrientation != SQL_FETCH_NEXT && (!stmt->cursor || !stmt->dbc->cursor_support)) {
    4049           0 :                 odbc_errs_add(&stmt->errs, "HY106", NULL);
    4050           0 :                 return SQL_ERROR;
    4051             :         }
    4052             : 
    4053             :         /* handle cursors, fetch wanted rows */
    4054       27496 :         if (stmt->cursor && odbc_lock_statement(stmt)) {
    4055         696 :                 TDSCURSOR *cursor = stmt->cursor;
    4056         696 :                 TDS_CURSOR_FETCH fetch_type = TDS_CURSOR_FETCH_NEXT;
    4057             : 
    4058         696 :                 tds = stmt->tds;
    4059             : 
    4060         696 :                 switch (FetchOrientation) {
    4061             :                 case SQL_FETCH_NEXT:
    4062             :                         break;
    4063          16 :                 case SQL_FETCH_FIRST:
    4064          16 :                         fetch_type = TDS_CURSOR_FETCH_FIRST;
    4065          16 :                         break;
    4066          24 :                 case SQL_FETCH_LAST:
    4067          24 :                         fetch_type = TDS_CURSOR_FETCH_LAST;
    4068          24 :                         break;
    4069          32 :                 case SQL_FETCH_PRIOR:
    4070          32 :                         fetch_type = TDS_CURSOR_FETCH_PREV;
    4071          32 :                         break;
    4072          16 :                 case SQL_FETCH_ABSOLUTE:
    4073          16 :                         fetch_type = TDS_CURSOR_FETCH_ABSOLUTE;
    4074          16 :                         break;
    4075          56 :                 case SQL_FETCH_RELATIVE:
    4076          56 :                         fetch_type = TDS_CURSOR_FETCH_RELATIVE;
    4077          56 :                         break;
    4078             :                 /* TODO cursor bookmark */
    4079           0 :                 default:
    4080           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    4081           0 :                         return SQL_ERROR;
    4082             :                 }
    4083             : 
    4084         696 :                 if (cursor->cursor_rows != num_rows) {
    4085         248 :                         bool send = false;
    4086         248 :                         cursor->cursor_rows = num_rows;
    4087             :                         /* TODO handle change rows (tds5) */
    4088             :                         /*
    4089             :                          * TODO curerntly we support cursors only using tds7+
    4090             :                          * so this function can't fail but remember to add error
    4091             :                          * check when tds5 will be supported
    4092             :                          */
    4093         248 :                         tds_cursor_setrows(tds, cursor, &send);
    4094             :                 }
    4095             : 
    4096         696 :                 if (TDS_FAILED(tds_cursor_fetch(tds, cursor, fetch_type, FetchOffset))) {
    4097             :                         /* TODO what kind of error ?? */
    4098           0 :                         ODBC_SAFE_ERROR(stmt);
    4099             :                         return SQL_ERROR;
    4100             :                 }
    4101             : 
    4102             :                 /* TODO handle errors in a better way */
    4103         696 :                 odbc_process_tokens(stmt, TDS_RETURN_ROW|TDS_STOPAT_COMPUTE|TDS_STOPAT_ROW);
    4104         696 :                 stmt->row_status = PRE_NORMAL_ROW;
    4105             :         }
    4106             : 
    4107       27496 :         if (!tds && stmt->row_status == PRE_NORMAL_ROW && stmt->ird->header.sql_desc_count > 0)
    4108          10 :                 ODBC_RETURN(stmt, SQL_NO_DATA);
    4109       27486 :         if (!tds || stmt->row_status == NOT_IN_ROW) {
    4110          30 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    4111          30 :                 return SQL_ERROR;
    4112             :         }
    4113       27456 :         IRD_CHECK;
    4114             : 
    4115       27456 :         if (stmt->ird->header.sql_desc_count <= 0) {
    4116          34 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    4117          34 :                 return SQL_ERROR;
    4118             :         }
    4119             : 
    4120       27422 :         stmt->row++;
    4121             : 
    4122       27422 :         fetched_ptr = &dummy;
    4123       27422 :         if (stmt->ird->header.sql_desc_rows_processed_ptr)
    4124         630 :                 fetched_ptr = stmt->ird->header.sql_desc_rows_processed_ptr;
    4125       27422 :         *fetched_ptr = 0;
    4126             : 
    4127       27422 :         status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    4128       27422 :         if (status_ptr) {
    4129        2704 :                 for (i = 0; (SQLULEN) i < num_rows; ++i)
    4130        2704 :                         *status_ptr++ = SQL_ROW_NOROW;
    4131             :                 status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    4132             :         }
    4133             : 
    4134             :         curr_row = 0;
    4135             :         do {
    4136       29182 :                 row_status = SQL_ROW_SUCCESS;
    4137             : 
    4138             :                 /* do not get compute row if we are not expecting a compute row */
    4139       29182 :                 switch (stmt->row_status) {
    4140          32 :                 case AFTER_COMPUTE_ROW:
    4141             :                         /* handle done if needed */
    4142             :                         /* FIXME doesn't seem so fine ... - freddy77 */
    4143          32 :                         tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
    4144          32 :                         goto all_done;
    4145             : 
    4146          32 :                 case IN_COMPUTE_ROW:
    4147             :                         /* compute recorset contains only a row */
    4148             :                         /* we already fetched compute row in SQLMoreResults so do not fetch another one */
    4149          32 :                         num_rows = 1;
    4150          32 :                         stmt->row_status = AFTER_COMPUTE_ROW;
    4151          32 :                         break;
    4152             : 
    4153       29118 :                 default:
    4154             :                         /* FIXME stmt->row_count set correctly ?? TDS_DONE_COUNT not checked */
    4155       29118 :                         switch (odbc_process_tokens(stmt, TDS_STOPAT_ROWFMT|TDS_RETURN_ROW|TDS_STOPAT_COMPUTE)) {
    4156             :                         case TDS_ROW_RESULT:
    4157             :                                 break;
    4158        9356 :                         default:
    4159             : #if 0
    4160             :                                 stmt->row_count = tds->rows_affected;
    4161             : #endif
    4162             :                                 /*
    4163             :                                  * NOTE do not set row_status to NOT_IN_ROW,
    4164             :                                  * if compute tds_process_tokens above returns TDS_NO_MORE_RESULTS
    4165             :                                  */
    4166        9356 :                                 stmt->row_status = PRE_NORMAL_ROW;
    4167        9356 :                                 stmt->special_row = ODBC_SPECIAL_NONE;
    4168             : #if 0
    4169             :                                 odbc_populate_ird(stmt);
    4170             : #endif
    4171        9356 :                                 tdsdump_log(TDS_DBG_INFO1, "SQLFetch: NO_DATA_FOUND\n");
    4172             :                                 goto all_done;
    4173             :                                 break;
    4174           0 :                         case TDS_CMD_FAIL:
    4175           0 :                                 ODBC_SAFE_ERROR(stmt);
    4176             :                                 return SQL_ERROR;
    4177             :                                 break;
    4178             :                         }
    4179             : 
    4180       19762 :                         stmt->row_status = IN_NORMAL_ROW;
    4181             : 
    4182             :                         /* handle special row */
    4183       19762 :                         switch (stmt->special_row) {
    4184         148 :                         case ODBC_SPECIAL_GETTYPEINFO:
    4185         148 :                                 odbc_fix_data_type_col(stmt, 1);
    4186         148 :                                 break;
    4187           4 :                         case ODBC_SPECIAL_COLUMNS:
    4188           4 :                                 odbc_fix_data_type_col(stmt, 4);
    4189           4 :                                 odbc_fix_data_type_col(stmt, 13); /* TODO sure ?? */
    4190           4 :                                 break;
    4191           2 :                         case ODBC_SPECIAL_PROCEDURECOLUMNS:
    4192           2 :                                 odbc_fix_data_type_col(stmt, 5);
    4193           2 :                                 odbc_fix_data_type_col(stmt, 14); /* TODO sure ?? */
    4194           2 :                                 break;
    4195           0 :                         case ODBC_SPECIAL_SPECIALCOLUMNS:
    4196           0 :                                 odbc_fix_data_type_col(stmt, 2);
    4197           0 :                                 break;
    4198             :                         case ODBC_SPECIAL_NONE:
    4199             :                                 break;
    4200             :                         }
    4201             :                 }
    4202             : 
    4203       19794 :                 resinfo = tds->current_results;
    4204       19794 :                 if (!resinfo) {
    4205           0 :                         tdsdump_log(TDS_DBG_INFO1, "SQLFetch: !resinfo\n");
    4206             :                         break;
    4207             :                 }
    4208             : 
    4209             :                 /* we got a row, return a row readed even if error (for ODBC specifications) */
    4210       19794 :                 ++(*fetched_ptr);
    4211       19794 :                 row_status = copy_row(stmt, row_offset, curr_row);
    4212       19794 :                 if (row_status == SQL_ROW_SUCCESS_WITH_INFO)
    4213         188 :                         truncated = true;
    4214             : 
    4215       19794 :                 if (status_ptr)
    4216        2096 :                         *status_ptr++ = truncated ? SQL_ROW_ERROR : row_status;
    4217       19794 :                 if (row_status == SQL_ROW_ERROR) {
    4218           0 :                         stmt->errs.lastrc = SQL_ERROR;
    4219           0 :                         break;
    4220             :                 }
    4221             : #if SQL_BIND_BY_COLUMN != 0
    4222             :                 if (ard->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN)
    4223             : #endif
    4224       19794 :                         row_offset += ard->header.sql_desc_bind_type;
    4225       19794 :         } while (++curr_row < num_rows);
    4226             : 
    4227       18034 :         if (truncated)
    4228          98 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    4229             : 
    4230       45358 :       all_done:
    4231             :         /* TODO cursor correct ?? */
    4232       27422 :         if (stmt->cursor) {
    4233         696 :                 tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
    4234         696 :                 odbc_unlock_statement(stmt);
    4235             :         }
    4236       27422 :         if (*fetched_ptr == 0 && (stmt->errs.lastrc == SQL_SUCCESS || stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO))
    4237        9170 :                 ODBC_RETURN(stmt, SQL_NO_DATA);
    4238       18252 :         if (stmt->errs.lastrc == SQL_ERROR && (*fetched_ptr > 1 || (*fetched_ptr == 1 && row_status != SQL_ROW_ERROR)))
    4239           0 :                 ODBC_RETURN(stmt, SQL_SUCCESS_WITH_INFO);
    4240       18252 :         ODBC_RETURN_(stmt);
    4241             : }
    4242             : 
    4243             : SQLRETURN ODBC_PUBLIC ODBC_API
    4244             : SQLFetch(SQLHSTMT hstmt)
    4245             : {
    4246             :         SQLRETURN ret;
    4247             :         struct {
    4248             :                 SQLULEN  array_size;
    4249             :                 SQLULEN *rows_processed_ptr;
    4250             :                 SQLUSMALLINT *array_status_ptr;
    4251             :         } keep;
    4252             : 
    4253       26846 :         ODBC_ENTER_HSTMT;
    4254             : 
    4255       26846 :         tdsdump_log(TDS_DBG_FUNC, "SQLFetch(%p)\n", hstmt);
    4256             : 
    4257       26846 :         keep.array_size = stmt->ard->header.sql_desc_array_size;
    4258       26846 :         keep.rows_processed_ptr = stmt->ird->header.sql_desc_rows_processed_ptr;
    4259       26846 :         keep.array_status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    4260             : 
    4261       26846 :         if (stmt->dbc->env->attr.odbc_version != SQL_OV_ODBC3) {
    4262        4710 :                 stmt->ard->header.sql_desc_array_size = 1;
    4263        4710 :                 stmt->ird->header.sql_desc_rows_processed_ptr = NULL;
    4264        4710 :                 stmt->ird->header.sql_desc_array_status_ptr = NULL;
    4265             :         }
    4266             : 
    4267       26846 :         ret = odbc_SQLFetch(stmt, SQL_FETCH_NEXT, 0);
    4268             : 
    4269       26846 :         if (stmt->dbc->env->attr.odbc_version != SQL_OV_ODBC3) {
    4270        4710 :                 stmt->ard->header.sql_desc_array_size = keep.array_size;
    4271        4710 :                 stmt->ird->header.sql_desc_rows_processed_ptr = keep.rows_processed_ptr;
    4272        4710 :                 stmt->ird->header.sql_desc_array_status_ptr = keep.array_status_ptr;
    4273             :         }
    4274             : 
    4275       26846 :         ODBC_EXIT(stmt, ret);
    4276             : }
    4277             : 
    4278             : #if (ODBCVER >= 0x0300)
    4279             : SQLRETURN ODBC_PUBLIC ODBC_API
    4280             : SQLFetchScroll(SQLHSTMT hstmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
    4281             : {
    4282         632 :         ODBC_ENTER_HSTMT;
    4283             : 
    4284         632 :         tdsdump_log(TDS_DBG_FUNC, "SQLFetchScroll(%p, %d, %d)\n", hstmt, FetchOrientation, (int)FetchOffset);
    4285             : 
    4286         632 :         if (FetchOrientation != SQL_FETCH_NEXT && !stmt->dbc->cursor_support) {
    4287           0 :                 odbc_errs_add(&stmt->errs, "HY106", NULL);
    4288           0 :                 ODBC_EXIT_(stmt);
    4289             :         }
    4290             : 
    4291         632 :         ODBC_EXIT(stmt, odbc_SQLFetch(stmt, FetchOrientation, FetchOffset));
    4292             : }
    4293             : #endif
    4294             : 
    4295             : 
    4296             : #if (ODBCVER >= 0x0300)
    4297             : SQLRETURN ODBC_PUBLIC ODBC_API
    4298             : SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
    4299             : {
    4300         138 :         tdsdump_log(TDS_DBG_INFO1, "SQLFreeHandle(%d, %p)\n", HandleType, (void *) Handle);
    4301             : 
    4302         138 :         switch (HandleType) {
    4303         128 :         case SQL_HANDLE_STMT:
    4304         128 :                 return odbc_SQLFreeStmt(Handle, SQL_DROP, 0);
    4305             :                 break;
    4306           0 :         case SQL_HANDLE_DBC:
    4307           0 :                 return odbc_SQLFreeConnect(Handle);
    4308             :                 break;
    4309           0 :         case SQL_HANDLE_ENV:
    4310           0 :                 return odbc_SQLFreeEnv(Handle);
    4311             :                 break;
    4312          10 :         case SQL_HANDLE_DESC:
    4313          10 :                 return odbc_SQLFreeDesc(Handle);
    4314             :                 break;
    4315             :         }
    4316             :         return SQL_ERROR;
    4317             : }
    4318             : 
    4319             : static SQLRETURN
    4320        1160 : odbc_SQLFreeConnect(SQLHDBC hdbc)
    4321             : {
    4322             :         int i;
    4323             : 
    4324        1160 :         ODBC_ENTER_HDBC;
    4325             : 
    4326        1160 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLFreeConnect(%p)\n",
    4327             :                         hdbc);
    4328             : 
    4329        1160 :         tds_close_socket(dbc->tds_socket);
    4330             : 
    4331             :         /* TODO if connected return error */
    4332        1160 :         tds_free_socket(dbc->tds_socket);
    4333             : 
    4334        1160 :         odbc_bcp_free_storage(dbc);
    4335             :         /* free attributes */
    4336             : #ifdef TDS_NO_DM
    4337        1160 :         tds_dstr_free(&dbc->attr.tracefile);
    4338             : #endif
    4339        1160 :         tds_dstr_free(&dbc->attr.current_catalog);
    4340        1160 :         tds_dstr_free(&dbc->attr.translate_lib);
    4341        1160 :         tds_dstr_zero(&dbc->oldpwd);
    4342        1160 :         tds_dstr_free(&dbc->oldpwd);
    4343        1160 :         tds_dstr_free(&dbc->db_filename);
    4344             : 
    4345        1160 :         tds_dstr_free(&dbc->dsn);
    4346             : 
    4347      117160 :         for (i = 0; i < TDS_MAX_APP_DESC; i++) {
    4348      116000 :                 if (dbc->uad[i]) {
    4349           0 :                         desc_free(dbc->uad[i]);
    4350             :                 }
    4351             :         }
    4352        1160 :         odbc_errs_reset(&dbc->errs);
    4353        1160 :         tds_mutex_unlock(&dbc->mtx);
    4354        1160 :         tds_mutex_free(&dbc->mtx);
    4355             : 
    4356        1160 :         free(dbc);
    4357             : 
    4358        1160 :         return SQL_SUCCESS;
    4359             : }
    4360             : 
    4361             : SQLRETURN ODBC_PUBLIC ODBC_API
    4362             : SQLFreeConnect(SQLHDBC hdbc)
    4363             : {
    4364        1160 :         tdsdump_log(TDS_DBG_INFO2, "SQLFreeConnect(%p)\n", hdbc);
    4365        1160 :         return odbc_SQLFreeConnect(hdbc);
    4366             : }
    4367             : #endif
    4368             : 
    4369             : static SQLRETURN
    4370        1160 : odbc_SQLFreeEnv(SQLHENV henv)
    4371             : {
    4372        1160 :         ODBC_ENTER_HENV;
    4373             : 
    4374        1160 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLFreeEnv(%p)\n",
    4375             :                         henv);
    4376             : 
    4377        1160 :         odbc_errs_reset(&env->errs);
    4378        1160 :         tds_free_context(env->tds_ctx);
    4379        1160 :         tds_mutex_unlock(&env->mtx);
    4380        1160 :         tds_mutex_free(&env->mtx);
    4381        1160 :         free(env);
    4382             : 
    4383        1160 :         return SQL_SUCCESS;
    4384             : }
    4385             : 
    4386             : SQLRETURN ODBC_PUBLIC ODBC_API
    4387             : SQLFreeEnv(SQLHENV henv)
    4388             : {
    4389        1160 :         tdsdump_log(TDS_DBG_FUNC, "SQLFreeEnv(%p)\n", henv);
    4390             : 
    4391        1160 :         return odbc_SQLFreeEnv(henv);
    4392             : }
    4393             : 
    4394             : static SQLRETURN
    4395       20063 : odbc_SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption, int force)
    4396             : {
    4397             :         TDSSOCKET *tds;
    4398             : 
    4399       20063 :         ODBC_ENTER_HSTMT;
    4400             : 
    4401       20063 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLFreeStmt(%p, %d, %d)\n", hstmt, fOption, force);
    4402             : 
    4403             :         /* check if option correct */
    4404       20063 :         if (fOption != SQL_DROP && fOption != SQL_CLOSE && fOption != SQL_UNBIND && fOption != SQL_RESET_PARAMS) {
    4405           0 :                 tdsdump_log(TDS_DBG_ERROR, "SQLFreeStmt: Unknown option %d\n", fOption);
    4406           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    4407           0 :                 ODBC_EXIT_(stmt);
    4408             :         }
    4409             : 
    4410             :         /* if we have bound columns, free the temporary list */
    4411       20063 :         if (fOption == SQL_DROP || fOption == SQL_UNBIND) {
    4412       18567 :                 desc_free_records(stmt->ard);
    4413             :         }
    4414             : 
    4415             :         /* do the same for bound parameters */
    4416       20063 :         if (fOption == SQL_DROP || fOption == SQL_RESET_PARAMS) {
    4417       18525 :                 desc_free_records(stmt->apd);
    4418       18525 :                 desc_free_records(stmt->ipd);
    4419       18525 :                 stmt->params_set = 0;
    4420             :         }
    4421             : 
    4422             :         /* close statement */
    4423       20063 :         if (fOption == SQL_DROP || fOption == SQL_CLOSE) {
    4424             :                 SQLRETURN retcode;
    4425             : 
    4426       18329 :                 tds = stmt->tds;
    4427             :                 /*
    4428             :                  * FIXME -- otherwise make sure the current statement is complete
    4429             :                  */
    4430             :                 /* do not close other running query ! */
    4431       18329 :                 if (tds && tds->state != TDS_IDLE && tds->state != TDS_DEAD) {
    4432         570 :                         if (TDS_SUCCEED(tds_send_cancel(tds)))
    4433         570 :                                 tds_process_cancel(tds);
    4434             :                 }
    4435             : 
    4436             :                 /* free cursor */
    4437       18329 :                 retcode = odbc_free_cursor(stmt);
    4438       18329 :                 if (!force && retcode != SQL_SUCCESS)
    4439           0 :                         ODBC_EXIT(stmt, retcode);
    4440             :         }
    4441             : 
    4442             :         /* free it */
    4443       20063 :         if (fOption == SQL_DROP) {
    4444             :                 SQLRETURN retcode;
    4445             : 
    4446             :                 /* close prepared statement or add to connection */
    4447       17679 :                 retcode = odbc_free_dynamic(stmt);
    4448       17679 :                 if (!force && retcode != SQL_SUCCESS)
    4449           0 :                         ODBC_EXIT(stmt, retcode);
    4450             : 
    4451             :                 /* detatch from list */
    4452       17679 :                 tds_mutex_lock(&stmt->dbc->mtx);
    4453       17679 :                 if (stmt->next)
    4454         333 :                         stmt->next->prev = stmt->prev;
    4455       17679 :                 if (stmt->prev)
    4456          24 :                         stmt->prev->next = stmt->next;
    4457       17679 :                 if (stmt->dbc->stmt_list == stmt)
    4458       17655 :                         stmt->dbc->stmt_list = stmt->next;
    4459       17679 :                 tds_mutex_unlock(&stmt->dbc->mtx);
    4460             : 
    4461       17679 :                 tds_dstr_free(&stmt->query);
    4462       17679 :                 tds_free_param_results(stmt->params);
    4463       17679 :                 odbc_errs_reset(&stmt->errs);
    4464       17679 :                 odbc_unlock_statement(stmt);
    4465       17679 :                 tds_dstr_free(&stmt->cursor_name);
    4466       17679 :                 tds_dstr_free(&stmt->attr.qn_msgtext);
    4467       17679 :                 tds_dstr_free(&stmt->attr.qn_options);
    4468       17679 :                 desc_free(stmt->ird);
    4469       17679 :                 desc_free(stmt->ipd);
    4470       17679 :                 desc_free(stmt->orig_ard);
    4471       17679 :                 desc_free(stmt->orig_apd);
    4472       17679 :                 tds_mutex_unlock(&stmt->mtx);
    4473       17679 :                 tds_mutex_free(&stmt->mtx);
    4474       17679 :                 free(stmt);
    4475             : 
    4476             :                 /* NOTE we freed stmt, do not use ODBC_EXIT */
    4477       17679 :                 return SQL_SUCCESS;
    4478             :         }
    4479        2384 :         ODBC_EXIT_(stmt);
    4480             : }
    4481             : 
    4482             : SQLRETURN ODBC_PUBLIC ODBC_API
    4483             : SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption)
    4484             : {
    4485       19477 :         tdsdump_log(TDS_DBG_FUNC, "SQLFreeStmt(%p, %d)\n", hstmt, fOption);
    4486       19477 :         return odbc_SQLFreeStmt(hstmt, fOption, 0);
    4487             : }
    4488             : 
    4489             : 
    4490             : SQLRETURN ODBC_PUBLIC ODBC_API
    4491             : SQLCloseCursor(SQLHSTMT hstmt)
    4492             : {
    4493             :         /* TODO cursors */
    4494             :         /*
    4495             :          * Basic implementation for when no driver manager is present.
    4496             :          *  - according to ODBC documentation SQLCloseCursor is more or less
    4497             :          *    equivalent to SQLFreeStmt(..., SQL_CLOSE).
    4498             :          *  - indeed that is what the DM does if it can't find the function
    4499             :          *    in the driver, so this is pretty close.
    4500             :          */
    4501             :         /* TODO remember to close cursors really when get implemented */
    4502             :         /* TODO read all results and discard them or use cancellation ?? test behaviour */
    4503             : 
    4504         422 :         tdsdump_log(TDS_DBG_FUNC, "SQLCloseCursor(%p)\n", hstmt);
    4505         422 :         return odbc_SQLFreeStmt(hstmt, SQL_CLOSE, 0);
    4506             : }
    4507             : 
    4508             : static SQLRETURN
    4509          10 : odbc_SQLFreeDesc(SQLHDESC hdesc)
    4510             : {
    4511          10 :         ODBC_ENTER_HDESC;
    4512             : 
    4513          10 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLFreeDesc(%p)\n",
    4514             :                         hdesc);
    4515             : 
    4516          10 :         if (desc->header.sql_desc_alloc_type != SQL_DESC_ALLOC_USER) {
    4517           0 :                 odbc_errs_add(&desc->errs, "HY017", NULL);
    4518           0 :                 ODBC_EXIT_(desc);
    4519             :         }
    4520             : 
    4521          10 :         if (IS_HDBC(desc->parent)) {
    4522          10 :                 TDS_DBC *dbc = (TDS_DBC *) desc->parent;
    4523             :                 TDS_STMT *stmt;
    4524             :                 int i;
    4525             : 
    4526             :                 /* freeing descriptors associated to statements revert state of statements */
    4527          10 :                 tds_mutex_lock(&dbc->mtx);
    4528          20 :                 for (stmt = dbc->stmt_list; stmt != NULL; stmt = stmt->next) {
    4529          10 :                         if (stmt->ard == desc)
    4530           0 :                                 stmt->ard = stmt->orig_ard;
    4531          10 :                         if (stmt->apd == desc)
    4532           0 :                                 stmt->apd = stmt->orig_apd;
    4533             :                 }
    4534          10 :                 tds_mutex_unlock(&dbc->mtx);
    4535             : 
    4536          20 :                 for (i = 0; i < TDS_MAX_APP_DESC; ++i) {
    4537          20 :                         if (dbc->uad[i] == desc) {
    4538          10 :                                 dbc->uad[i] = NULL;
    4539          10 :                                 tds_mutex_unlock(&desc->mtx);
    4540          10 :                                 desc_free(desc);
    4541          10 :                                 break;
    4542             :                         }
    4543             :                 }
    4544             :         }
    4545             :         return SQL_SUCCESS;
    4546             : }
    4547             : 
    4548             : static SQLRETURN
    4549        1130 : odbc_SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value,
    4550             :                     SQLINTEGER BufferLength, SQLINTEGER * StringLength WIDE)
    4551             : {
    4552             :         static const SQLUINTEGER zero_ui = 0;
    4553             :         const void *src;
    4554             :         SQLINTEGER size;
    4555             : 
    4556        1130 :         ODBC_ENTER_HSTMT;
    4557             : 
    4558             :         /* TODO assign directly, use macro for size */
    4559        1130 :         switch (Attribute) {
    4560         524 :         case SQL_ATTR_APP_PARAM_DESC:
    4561         524 :                 size = sizeof(stmt->apd);
    4562         524 :                 src = &stmt->apd;
    4563         524 :                 break;
    4564         140 :         case SQL_ATTR_APP_ROW_DESC:
    4565         140 :                 size = sizeof(stmt->ard);
    4566         140 :                 src = &stmt->ard;
    4567         140 :                 break;
    4568           0 :         case SQL_ATTR_ASYNC_ENABLE:
    4569           0 :                 size = sizeof(stmt->attr.async_enable);
    4570           0 :                 src = &stmt->attr.async_enable;
    4571           0 :                 break;
    4572          16 :         case SQL_ATTR_CONCURRENCY:
    4573          16 :                 size = sizeof(stmt->attr.concurrency);
    4574          16 :                 src = &stmt->attr.concurrency;
    4575          16 :                 break;
    4576          16 :         case SQL_ATTR_CURSOR_TYPE:
    4577          16 :                 size = sizeof(stmt->attr.cursor_type);
    4578          16 :                 src = &stmt->attr.cursor_type;
    4579          16 :                 break;
    4580           0 :         case SQL_ATTR_ENABLE_AUTO_IPD:
    4581           0 :                 size = sizeof(stmt->attr.enable_auto_ipd);
    4582           0 :                 src = &stmt->attr.enable_auto_ipd;
    4583           0 :                 break;
    4584           0 :         case SQL_ATTR_FETCH_BOOKMARK_PTR:
    4585           0 :                 size = sizeof(stmt->attr.fetch_bookmark_ptr);
    4586           0 :                 src = &stmt->attr.fetch_bookmark_ptr;
    4587           0 :                 break;
    4588           0 :         case SQL_ATTR_KEYSET_SIZE:
    4589           0 :                 size = sizeof(stmt->attr.keyset_size);
    4590           0 :                 src = &stmt->attr.keyset_size;
    4591           0 :                 break;
    4592           0 :         case SQL_ATTR_MAX_LENGTH:
    4593           0 :                 size = sizeof(stmt->attr.max_length);
    4594           0 :                 src = &stmt->attr.max_length;
    4595           0 :                 break;
    4596           0 :         case SQL_ATTR_MAX_ROWS:
    4597           0 :                 size = sizeof(stmt->attr.max_rows);
    4598           0 :                 src = &stmt->attr.max_rows;
    4599           0 :                 break;
    4600           0 :         case SQL_ATTR_METADATA_ID:
    4601           0 :                 size = sizeof(stmt->attr.metadata_id);
    4602           0 :                 src = &stmt->attr.metadata_id;
    4603           0 :                 break;
    4604           0 :         case SQL_ATTR_NOSCAN:
    4605           0 :                 size = sizeof(stmt->attr.noscan);
    4606           0 :                 src = &stmt->attr.noscan;
    4607           0 :                 break;
    4608           0 :         case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
    4609           0 :                 size = sizeof(stmt->apd->header.sql_desc_bind_offset_ptr);
    4610           0 :                 src = &stmt->apd->header.sql_desc_bind_offset_ptr;
    4611           0 :                 break;
    4612           0 :         case SQL_ATTR_PARAM_BIND_TYPE:
    4613           0 :                 size = sizeof(stmt->apd->header.sql_desc_bind_type);
    4614           0 :                 src = &stmt->apd->header.sql_desc_bind_type;
    4615           0 :                 break;
    4616           0 :         case SQL_ATTR_PARAM_OPERATION_PTR:
    4617           0 :                 size = sizeof(stmt->apd->header.sql_desc_array_status_ptr);
    4618           0 :                 src = &stmt->apd->header.sql_desc_array_status_ptr;
    4619           0 :                 break;
    4620           0 :         case SQL_ATTR_PARAM_STATUS_PTR:
    4621           0 :                 size = sizeof(stmt->ipd->header.sql_desc_array_status_ptr);
    4622           0 :                 src = &stmt->ipd->header.sql_desc_array_status_ptr;
    4623           0 :                 break;
    4624          60 :         case SQL_ATTR_PARAMS_PROCESSED_PTR:
    4625          60 :                 size = sizeof(stmt->ipd->header.sql_desc_rows_processed_ptr);
    4626          60 :                 src = &stmt->ipd->header.sql_desc_rows_processed_ptr;
    4627          60 :                 break;
    4628           0 :         case SQL_ATTR_PARAMSET_SIZE:
    4629           0 :                 size = sizeof(stmt->apd->header.sql_desc_array_size);
    4630           0 :                 src = &stmt->apd->header.sql_desc_array_size;
    4631           0 :                 break;
    4632          32 :         case SQL_ATTR_QUERY_TIMEOUT:
    4633          32 :                 size = sizeof(stmt->attr.query_timeout);
    4634          32 :                 src = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ? &stmt->attr.query_timeout : &zero_ui;
    4635             :                 break;
    4636           0 :         case SQL_ATTR_RETRIEVE_DATA:
    4637           0 :                 size = sizeof(stmt->attr.retrieve_data);
    4638           0 :                 src = &stmt->attr.retrieve_data;
    4639           0 :                 break;
    4640           0 :         case SQL_ATTR_ROW_BIND_OFFSET_PTR:
    4641           0 :                 size = sizeof(stmt->ard->header.sql_desc_bind_offset_ptr);
    4642           0 :                 src = &stmt->ard->header.sql_desc_bind_offset_ptr;
    4643           0 :                 break;
    4644             : #if SQL_BIND_TYPE != SQL_ATTR_ROW_BIND_TYPE
    4645             :         case SQL_BIND_TYPE:     /* although this is ODBC2 we must support this attribute */
    4646             : #endif
    4647           0 :         case SQL_ATTR_ROW_BIND_TYPE:
    4648           0 :                 size = sizeof(stmt->ard->header.sql_desc_bind_type);
    4649           0 :                 src = &stmt->ard->header.sql_desc_bind_type;
    4650           0 :                 break;
    4651          24 :         case SQL_ATTR_ROW_NUMBER:
    4652             :                 /* TODO do not get info every time, cache somewhere */
    4653          24 :                 if (stmt->cursor && odbc_lock_statement(stmt)) {
    4654             :                         TDS_UINT row_number, row_count;
    4655             : 
    4656          24 :                         tds_cursor_get_cursor_info(stmt->tds, stmt->cursor, &row_number, &row_count);
    4657          24 :                         stmt->attr.row_number = row_number;
    4658             :                 }
    4659          24 :                 size = sizeof(stmt->attr.row_number);
    4660          24 :                 src = &stmt->attr.row_number;
    4661          24 :                 break;
    4662           0 :         case SQL_ATTR_ROW_OPERATION_PTR:
    4663           0 :                 size = sizeof(stmt->ard->header.sql_desc_array_status_ptr);
    4664           0 :                 src = &stmt->ard->header.sql_desc_array_status_ptr;
    4665           0 :                 break;
    4666           0 :         case SQL_ATTR_ROW_STATUS_PTR:
    4667           0 :                 size = sizeof(stmt->ird->header.sql_desc_array_status_ptr);
    4668           0 :                 src = &stmt->ird->header.sql_desc_array_status_ptr;
    4669           0 :                 break;
    4670          50 :         case SQL_ATTR_ROWS_FETCHED_PTR:
    4671          50 :                 size = sizeof(stmt->ird->header.sql_desc_rows_processed_ptr);
    4672          50 :                 src = &stmt->ird->header.sql_desc_rows_processed_ptr;
    4673          50 :                 break;
    4674           0 :         case SQL_ATTR_ROW_ARRAY_SIZE:
    4675           0 :                 size = sizeof(stmt->ard->header.sql_desc_array_size);
    4676           0 :                 src = &stmt->ard->header.sql_desc_array_size;
    4677           0 :                 break;
    4678           0 :         case SQL_ATTR_SIMULATE_CURSOR:
    4679           0 :                 size = sizeof(stmt->attr.simulate_cursor);
    4680           0 :                 src = &stmt->attr.simulate_cursor;
    4681           0 :                 break;
    4682           0 :         case SQL_ATTR_USE_BOOKMARKS:
    4683           0 :                 size = sizeof(stmt->attr.use_bookmarks);
    4684           0 :                 src = &stmt->attr.use_bookmarks;
    4685           0 :                 break;
    4686          16 :         case SQL_ATTR_CURSOR_SCROLLABLE:
    4687          16 :                 size = sizeof(stmt->attr.cursor_scrollable);
    4688          16 :                 src = &stmt->attr.cursor_scrollable;
    4689          16 :                 break;
    4690          16 :         case SQL_ATTR_CURSOR_SENSITIVITY:
    4691          16 :                 size = sizeof(stmt->attr.cursor_sensitivity);
    4692          16 :                 src = &stmt->attr.cursor_sensitivity;
    4693          16 :                 break;
    4694          90 :         case SQL_ATTR_IMP_ROW_DESC:
    4695          90 :                 size = sizeof(stmt->ird);
    4696          90 :                 src = &stmt->ird;
    4697          90 :                 break;
    4698         136 :         case SQL_ATTR_IMP_PARAM_DESC:
    4699         136 :                 size = sizeof(stmt->ipd);
    4700         136 :                 src = &stmt->ipd;
    4701         136 :                 break;
    4702          10 :         case SQL_ROWSET_SIZE:   /* although this is ODBC2 we must support this attribute */
    4703          10 :                 size = sizeof(stmt->sql_rowset_size);
    4704          10 :                 src = &stmt->sql_rowset_size;
    4705          10 :                 break;
    4706           0 :         case SQL_SOPT_SS_QUERYNOTIFICATION_TIMEOUT:
    4707           0 :                 size = sizeof(stmt->attr.qn_timeout);
    4708           0 :                 src = &stmt->attr.qn_timeout;
    4709           0 :                 break;
    4710           0 :         case SQL_SOPT_SS_QUERYNOTIFICATION_MSGTEXT:
    4711             :                 {
    4712           0 :                         SQLRETURN rc = odbc_set_dstr_oct(stmt->dbc, Value, BufferLength, StringLength, &stmt->attr.qn_msgtext);
    4713           0 :                         ODBC_EXIT(stmt, rc);
    4714             :                 }
    4715           0 :         case SQL_SOPT_SS_QUERYNOTIFICATION_OPTIONS:
    4716             :                 {
    4717           0 :                         SQLRETURN rc = odbc_set_dstr_oct(stmt->dbc, Value, BufferLength, StringLength, &stmt->attr.qn_options);
    4718           0 :                         ODBC_EXIT(stmt, rc);
    4719             :                 }
    4720             :                 /* TODO SQL_COLUMN_SEARCHABLE, although ODBC2 */
    4721           0 :         default:
    4722           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    4723           0 :                 ODBC_EXIT_(stmt);
    4724             :         }
    4725             : 
    4726        1130 :         memcpy(Value, src, size);
    4727        1130 :         if (StringLength)
    4728         968 :                 *StringLength = size;
    4729             : 
    4730        1130 :         ODBC_EXIT_(stmt);
    4731             : }
    4732             : 
    4733             : #if (ODBCVER >= 0x0300)
    4734             : SQLRETURN ODBC_PUBLIC ODBC_API
    4735             : SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
    4736             : {
    4737         565 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtAttr(%p, %d, %p, %d, %p)\n",
    4738             :                         hstmt, (int)Attribute, Value, (int)BufferLength, StringLength);
    4739             : 
    4740         565 :         return odbc_SQLGetStmtAttr(hstmt, Attribute, Value, BufferLength, StringLength _wide0);
    4741             : }
    4742             : 
    4743             : #ifdef ENABLE_ODBC_WIDE
    4744             : SQLRETURN ODBC_PUBLIC ODBC_API
    4745             : SQLGetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
    4746             : {
    4747         565 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtAttr(%p, %d, %p, %d, %p)\n",
    4748             :                         hstmt, (int)Attribute, Value, (int)BufferLength, StringLength);
    4749             : 
    4750         565 :         return odbc_SQLGetStmtAttr(hstmt, Attribute, Value, BufferLength, StringLength, 1);
    4751             : }
    4752             : #endif
    4753             : #endif
    4754             : 
    4755             : SQLRETURN ODBC_PUBLIC ODBC_API
    4756             : SQLGetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLPOINTER pvParam)
    4757             : {
    4758           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtOption(%p, %d, %p)\n",
    4759             :                         hstmt, fOption, pvParam);
    4760             : 
    4761           0 :         return odbc_SQLGetStmtAttr(hstmt, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL _wide0);
    4762             : }
    4763             : 
    4764             : SQLRETURN ODBC_PUBLIC ODBC_API
    4765             : SQLNumResultCols(SQLHSTMT hstmt, SQLSMALLINT FAR * pccol)
    4766             : {
    4767         894 :         ODBC_ENTER_HSTMT;
    4768             : 
    4769         894 :         tdsdump_log(TDS_DBG_FUNC, "SQLNumResultCols(%p, %p)\n",
    4770             :                         hstmt, pccol);
    4771             : 
    4772             :         /*
    4773             :          * 3/15/2001 bsb - DBD::ODBC calls SQLNumResultCols on non-result
    4774             :          * generating queries such as 'drop table'
    4775             :          */
    4776             : #if 0
    4777             :         if (stmt->row_status == NOT_IN_ROW) {
    4778             :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    4779             :                 ODBC_EXIT_(stmt);
    4780             :         }
    4781             : #endif
    4782         894 :         IRD_UPDATE(stmt->ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    4783         870 :         *pccol = stmt->ird->header.sql_desc_count;
    4784         870 :         ODBC_EXIT_(stmt);
    4785             : }
    4786             : 
    4787        4097 : ODBC_FUNC(SQLPrepare, (P(SQLHSTMT,hstmt), PCHARIN(SqlStr,SQLINTEGER) WIDE))
    4788             : {
    4789             :         SQLRETURN retcode;
    4790             : 
    4791        4097 :         ODBC_ENTER_HSTMT;
    4792             : 
    4793             :         /* try to free dynamic associated */
    4794        4097 :         retcode = odbc_free_dynamic(stmt);
    4795        4097 :         if (retcode != SQL_SUCCESS)
    4796           0 :                 ODBC_EXIT(stmt, retcode);
    4797             : 
    4798        4097 :         if (SQL_SUCCESS != odbc_set_stmt_query(stmt, szSqlStr, cbSqlStr _wide))
    4799           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    4800        4097 :         stmt->is_prepared_query = 1;
    4801             : 
    4802             :         /* count parameters */
    4803        8194 :         stmt->param_count = tds_count_placeholders(tds_dstr_cstr(&stmt->query));
    4804             : 
    4805             :         /* reset IPD and APD */
    4806        4097 :         if (!stmt->params_set) {
    4807        2179 :                 desc_alloc_records(stmt->ipd, 0);
    4808        2179 :                 desc_alloc_records(stmt->apd, 0);
    4809             :         }
    4810             : 
    4811             :         /* trasform to native (one time, not for every SQLExecute) */
    4812        4097 :         if (SQL_SUCCESS != prepare_call(stmt))
    4813           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    4814             : 
    4815             :         /* TODO needed ?? */
    4816        4097 :         tds_release_dynamic(&stmt->dyn);
    4817             : 
    4818             :         /* try to prepare query */
    4819             :         /* TODO support getting info for RPC */
    4820        4097 :         if (!stmt->prepared_query_is_rpc
    4821        3449 :                  && (stmt->attr.cursor_type == SQL_CURSOR_FORWARD_ONLY && stmt->attr.concurrency == SQL_CONCUR_READ_ONLY)) {
    4822             : 
    4823        2141 :                 tds_free_param_results(stmt->params);
    4824        2141 :                 stmt->params = NULL;
    4825        2141 :                 stmt->param_num = 0;
    4826        2141 :                 stmt->need_reprepare = 0;
    4827             :                 /*
    4828             :                  * using TDS7+ we need parameters to prepare a query so try
    4829             :                  * to get them
    4830             :                  * TDS5 do not need parameters type and we have always to
    4831             :                  * prepare sepatately so this is not an issue
    4832             :                  */
    4833        2141 :                 if (IS_TDS7_PLUS(stmt->dbc->tds_socket->conn)) {
    4834        1845 :                         stmt->need_reprepare = 1;
    4835        1845 :                         ODBC_EXIT_(stmt);
    4836             :                 }
    4837             : 
    4838         296 :                 tdsdump_log(TDS_DBG_INFO1, "Creating prepared statement\n");
    4839         296 :                 if (odbc_lock_statement(stmt))
    4840         296 :                         odbc_prepare(stmt);
    4841             :         }
    4842             : 
    4843        2252 :         ODBC_EXIT_(stmt);
    4844             : }
    4845             : 
    4846             : /* TDS_NO_COUNT must be -1 for SQLRowCount to return -1 when there is no rowcount */
    4847             : #if TDS_NO_COUNT != -1
    4848             : # error TDS_NO_COUNT != -1
    4849             : #endif
    4850             : 
    4851             : SQLRETURN
    4852         696 : odbc_SQLRowCount(SQLHSTMT hstmt, SQLLEN FAR * pcrow)
    4853             : {
    4854         696 :         ODBC_ENTER_HSTMT;
    4855             : 
    4856         696 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLRowCount(%p, %p),  %ld rows \n", hstmt, pcrow, (long)stmt->row_count);
    4857             : 
    4858         696 :         *pcrow = stmt->row_count;
    4859             : 
    4860         696 :         ODBC_EXIT_(stmt);
    4861             : }
    4862             : 
    4863             : SQLRETURN ODBC_PUBLIC ODBC_API
    4864             : SQLRowCount(SQLHSTMT hstmt, SQLLEN FAR * pcrow)
    4865             : {
    4866         696 :         SQLRETURN rc = odbc_SQLRowCount(hstmt, pcrow);
    4867         696 :         tdsdump_log(TDS_DBG_INFO1, "SQLRowCount returns %d, row count %ld\n", rc, (long int) *pcrow);
    4868         696 :         return rc;
    4869             : }
    4870             : 
    4871         104 : ODBC_FUNC(SQLSetCursorName, (P(SQLHSTMT,hstmt), PCHARIN(Cursor,SQLSMALLINT) WIDE))
    4872             : {
    4873         104 :         ODBC_ENTER_HSTMT;
    4874             : 
    4875             :         /* cursor already present, we cannot set name */
    4876         104 :         if (stmt->cursor) {
    4877           0 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    4878           0 :                 ODBC_EXIT_(stmt);
    4879             :         }
    4880             : 
    4881         104 :         if (!odbc_dstr_copy(stmt->dbc, &stmt->cursor_name, cbCursor, szCursor)) {
    4882           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    4883           0 :                 ODBC_EXIT_(stmt);
    4884             :         }
    4885         104 :         ODBC_EXIT_(stmt);
    4886             : }
    4887             : 
    4888           0 : ODBC_FUNC(SQLGetCursorName, (P(SQLHSTMT,hstmt), PCHAROUT(Cursor,SQLSMALLINT) WIDE))
    4889             : {
    4890             :         SQLRETURN rc;
    4891             : 
    4892           0 :         ODBC_ENTER_HSTMT;
    4893             : 
    4894           0 :         if ((rc = odbc_set_dstr(stmt->dbc, szCursor, cbCursorMax, pcbCursor, &stmt->cursor_name)))
    4895           0 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    4896             : 
    4897           0 :         ODBC_EXIT(stmt, rc);
    4898             : }
    4899             : 
    4900             : /*
    4901             :  * spinellia@acm.org : copied shamelessly from change_database
    4902             :  * transaction support
    4903             :  * 1 = commit, 0 = rollback
    4904             :  */
    4905             : static SQLRETURN
    4906         760 : change_transaction(TDS_DBC * dbc, int state)
    4907             : {
    4908         760 :         TDSSOCKET *tds = dbc->tds_socket;
    4909             :         int cont;
    4910             :         TDSRET ret;
    4911             : 
    4912         760 :         tdsdump_log(TDS_DBG_INFO1, "change_transaction(0x%p,%d)\n", dbc, state);
    4913         760 :         tds_mutex_check_owned(&dbc->mtx);
    4914             : 
    4915         760 :         if (dbc->attr.autocommit == SQL_AUTOCOMMIT_ON)
    4916             :                 return SQL_SUCCESS;
    4917         740 :         cont = 1;
    4918             : 
    4919             :         /* if pending drop all recordset, don't issue cancel */
    4920         740 :         if (tds->state == TDS_PENDING && dbc->current_statement != NULL) {
    4921             :                 /* TODO what happen on multiple errors ?? discard all ?? */
    4922          20 :                 if (TDS_FAILED(tds_process_simple_query(tds)))
    4923             :                         return SQL_ERROR;
    4924             :         }
    4925             : 
    4926             :         /* TODO better idle check, not thread safe */
    4927         740 :         if (tds->state == TDS_IDLE)
    4928         740 :                 tds->query_timeout = dbc->default_query_timeout;
    4929             : 
    4930             :         /* reset statement so errors will be reported on connection.
    4931             :          * Note that we own the connection lock */
    4932         740 :         if (dbc->current_statement) {
    4933         498 :                 dbc->current_statement->tds = NULL;
    4934         498 :                 dbc->current_statement = NULL;
    4935             :         }
    4936         740 :         tds_set_parent(tds, dbc);
    4937             : 
    4938         740 :         if (state)
    4939         282 :                 ret = tds_submit_commit(tds, cont);
    4940             :         else
    4941         458 :                 ret = tds_submit_rollback(tds, cont);
    4942             : 
    4943         740 :         if (TDS_FAILED(ret)) {
    4944          10 :                 odbc_errs_add(&dbc->errs, "HY000", "Could not perform COMMIT or ROLLBACK");
    4945          10 :                 return SQL_ERROR;
    4946             :         }
    4947             : 
    4948         730 :         if (TDS_FAILED(tds_process_simple_query(tds)))
    4949             :                 return SQL_ERROR;
    4950             : 
    4951             :         /* TODO some query can collect errors so perhaps it's better to return SUCCES_WITH_INFO in such case... */
    4952         730 :         return SQL_SUCCESS;
    4953             : }
    4954             : 
    4955             : static SQLRETURN
    4956         760 : odbc_SQLTransact(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT fType)
    4957             : {
    4958         760 :         int op = (fType == SQL_COMMIT ? 1 : 0);
    4959             : 
    4960             :         /* I may live without a HENV */
    4961             :         /*     CHECK_HENV; */
    4962             :         /* ..but not without a HDBC! */
    4963         760 :         ODBC_ENTER_HDBC;
    4964             : 
    4965         760 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLTransact(%p, %p, %d)\n",
    4966             :                         henv, hdbc, fType);
    4967             : 
    4968         760 :         ODBC_EXIT(dbc, change_transaction(dbc, op));
    4969             : }
    4970             : 
    4971             : SQLRETURN ODBC_PUBLIC ODBC_API
    4972             : SQLTransact(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT fType)
    4973             : {
    4974           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLTransact(%p, %p, %d)\n", henv, hdbc, fType);
    4975             : 
    4976           0 :         return odbc_SQLTransact(henv, hdbc, fType);
    4977             : }
    4978             : 
    4979             : #if ODBCVER >= 0x300
    4980             : SQLRETURN ODBC_PUBLIC ODBC_API
    4981             : SQLEndTran(SQLSMALLINT handleType, SQLHANDLE handle, SQLSMALLINT completionType)
    4982             : {
    4983             :         /*
    4984             :          * Do not call the exported SQLTransact(),
    4985             :          * because we may wind up calling a function with the same name implemented by the DM.
    4986             :          */
    4987         760 :         tdsdump_log(TDS_DBG_FUNC, "SQLEndTran(%d, %p, %d)\n", handleType, handle, completionType);
    4988             : 
    4989         760 :         switch (handleType) {
    4990           0 :         case SQL_HANDLE_ENV:
    4991           0 :                 return odbc_SQLTransact(handle, NULL, completionType);
    4992         760 :         case SQL_HANDLE_DBC:
    4993         760 :                 return odbc_SQLTransact(NULL, handle, completionType);
    4994             :         }
    4995             :         return SQL_ERROR;
    4996             : }
    4997             : #endif
    4998             : 
    4999             : /* end of transaction support */
    5000             : 
    5001             : SQLRETURN ODBC_PUBLIC ODBC_API
    5002             : SQLSetParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbParamDef,
    5003             :             SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN FAR * pcbValue)
    5004             : {
    5005           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetParam(%p, %d, %d, %d, %u, %d, %p, %p)\n",
    5006             :                         hstmt, ipar, fCType, fSqlType, (unsigned)cbParamDef, ibScale, rgbValue, pcbValue);
    5007             : 
    5008           0 :         return odbc_SQLBindParameter(hstmt, ipar, SQL_PARAM_INPUT_OUTPUT, fCType, fSqlType, cbParamDef, ibScale, rgbValue,
    5009             :                                  SQL_SETPARAM_VALUE_MAX, pcbValue);
    5010             : }
    5011             : 
    5012             : /**
    5013             :  * SQLColumns
    5014             :  *
    5015             :  * Return column information for a table or view. This is
    5016             :  * mapped to a call to sp_columns which - lucky for us - returns
    5017             :  * the exact result set we need.
    5018             :  *
    5019             :  * exec sp_columns [ @table_name = ] object
    5020             :  *                 [ , [ @table_owner = ] owner ]
    5021             :  *                 [ , [ @table_qualifier = ] qualifier ]
    5022             :  *                 [ , [ @column_name = ] column ]
    5023             :  *                 [ , [ @ODBCVer = ] ODBCVer ]
    5024             :  *
    5025             :  */
    5026          40 : ODBC_FUNC(SQLColumns, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),     /* object_qualifier */
    5027             :         PCHARIN(SchemaName,SQLSMALLINT),        /* object_owner */
    5028             :         PCHARIN(TableName,SQLSMALLINT), /* object_name */
    5029             :         PCHARIN(ColumnName,SQLSMALLINT) /* column_name */
    5030             :         WIDE))
    5031             : {
    5032             :         int retcode;
    5033          40 :         const char *proc = "sp_columns";
    5034             : 
    5035          40 :         ODBC_ENTER_HSTMT;
    5036             : 
    5037          40 :         if (odbc_get_string_size(cbCatalogName, szCatalogName _wide))
    5038          20 :                 proc = "..sp_columns";
    5039             : 
    5040          40 :         retcode =
    5041          40 :                 odbc_stat_execute(stmt _wide, proc, TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4,
    5042             :                                   "P@table_name", szTableName, cbTableName, "P@table_owner", szSchemaName,
    5043             :                                   cbSchemaName, "O@table_qualifier", szCatalogName, cbCatalogName, "P@column_name", szColumnName,
    5044             :                                   cbColumnName, "V@ODBCVer", (char*) NULL, 0);
    5045          40 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    5046          20 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    5047          20 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    5048          20 :                 odbc_col_setname(stmt, 7, "COLUMN_SIZE");
    5049          20 :                 odbc_col_setname(stmt, 8, "BUFFER_LENGTH");
    5050          20 :                 odbc_col_setname(stmt, 9, "DECIMAL_DIGITS");
    5051          20 :                 odbc_col_setname(stmt, 10, "NUM_PREC_RADIX");
    5052          20 :                 if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
    5053           4 :                         stmt->special_row = ODBC_SPECIAL_COLUMNS;
    5054             :         }
    5055          40 :         ODBC_EXIT_(stmt);
    5056             : }
    5057             : 
    5058          78 : ODBC_FUNC(SQLGetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,Value), P(SQLINTEGER,BufferLength),
    5059             :         P(SQLINTEGER *,StringLength) WIDE))
    5060             : {
    5061          78 :         const char *p = NULL;
    5062             : 
    5063          78 :         ODBC_ENTER_HDBC;
    5064             : 
    5065          78 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLGetConnectAttr(%p, %d, %p, %d, %p)\n",
    5066             :                         hdbc, (int)Attribute, Value, (int)BufferLength, StringLength);
    5067             : 
    5068          78 :         switch (Attribute) {
    5069           0 :         case SQL_ATTR_AUTOCOMMIT:
    5070           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.autocommit;
    5071             :                 break;
    5072             : #if defined(SQL_ATTR_CONNECTION_DEAD) && defined(SQL_CD_TRUE)
    5073           0 :         case SQL_ATTR_CONNECTION_DEAD:
    5074           0 :                 *((SQLUINTEGER *) Value) = IS_TDSDEAD(dbc->tds_socket) ? SQL_CD_TRUE : SQL_CD_FALSE;
    5075             :                 break;
    5076             : #endif
    5077           0 :         case SQL_ATTR_CONNECTION_TIMEOUT:
    5078           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.connection_timeout;
    5079             :                 break;
    5080           0 :         case SQL_ATTR_ACCESS_MODE:
    5081           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.access_mode;
    5082             :                 break;
    5083          68 :         case SQL_ATTR_CURRENT_CATALOG:
    5084         136 :                 p = tds_dstr_cstr(&dbc->attr.current_catalog);
    5085          68 :                 break;
    5086           0 :         case SQL_ATTR_LOGIN_TIMEOUT:
    5087           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.login_timeout;
    5088             :                 break;
    5089           0 :         case SQL_ATTR_ODBC_CURSORS:
    5090           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.odbc_cursors;
    5091             :                 break;
    5092           0 :         case SQL_ATTR_PACKET_SIZE:
    5093           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.packet_size;
    5094             :                 break;
    5095           0 :         case SQL_ATTR_QUIET_MODE:
    5096           0 :                 *((SQLHWND *) Value) = dbc->attr.quite_mode;
    5097             :                 break;
    5098             : #ifdef TDS_NO_DM
    5099           0 :         case SQL_ATTR_TRACE:
    5100           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.trace;
    5101             :                 break;
    5102           0 :         case SQL_ATTR_TRACEFILE:
    5103           0 :                 p = tds_dstr_cstr(&dbc->attr.tracefile);
    5104           0 :                 break;
    5105             : #endif
    5106           0 :         case SQL_ATTR_TXN_ISOLATION:
    5107           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.txn_isolation;
    5108             :                 break;
    5109          10 :         case SQL_COPT_SS_MARS_ENABLED:
    5110          10 :                 *((SQLUINTEGER *) Value) = dbc->attr.mars_enabled;
    5111             :                 break;
    5112           0 :         case SQL_ATTR_TRANSLATE_LIB:
    5113             :         case SQL_ATTR_TRANSLATE_OPTION:
    5114           0 :                 odbc_errs_add(&dbc->errs, "HYC00", NULL);
    5115             :                 break;
    5116           0 :         case SQL_COPT_SS_BCP:
    5117           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.bulk_enabled;
    5118             :                 break;
    5119           0 :         default:
    5120           0 :                 odbc_errs_add(&dbc->errs, "HY092", NULL);
    5121             :                 break;
    5122             :         }
    5123             : 
    5124          68 :         if (p) {
    5125          68 :                 SQLRETURN rc = odbc_set_string_oct(dbc, Value, BufferLength, StringLength, p, -1);
    5126          68 :                 ODBC_EXIT(dbc, rc);
    5127             :         }
    5128          10 :         ODBC_EXIT_(dbc);
    5129             : }
    5130             : 
    5131             : SQLRETURN ODBC_PUBLIC ODBC_API
    5132             : SQLGetConnectOption(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLPOINTER pvParam)
    5133             : {
    5134           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetConnectOption(%p, %u, %p)\n", hdbc, fOption, pvParam);
    5135             : 
    5136           0 :         return odbc_SQLGetConnectAttr(hdbc, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL _wide0);
    5137             : }
    5138             : 
    5139             : #ifdef ENABLE_ODBC_WIDE
    5140             : SQLRETURN ODBC_PUBLIC ODBC_API
    5141             : SQLGetConnectOptionW(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLPOINTER pvParam)
    5142             : {
    5143           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetConnectOptionW(%p, %u, %p)\n", hdbc, fOption, pvParam);
    5144             : 
    5145           0 :         return odbc_SQLGetConnectAttr(hdbc, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL, 1);
    5146             : }
    5147             : #endif
    5148             : 
    5149             : SQLRETURN ODBC_PUBLIC ODBC_API
    5150             : SQLGetData(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    5151             : {
    5152             :         /* TODO cursors fetch row if needed ?? */
    5153             :         TDSCOLUMN *colinfo;
    5154             :         TDSRESULTINFO *resinfo;
    5155             :         SQLLEN dummy_cb;
    5156             : 
    5157       10484 :         ODBC_ENTER_HSTMT;
    5158             : 
    5159       10484 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetData(%p, %u, %d, %p, %d, %p)\n",
    5160             :                         hstmt, icol, fCType, rgbValue, (int)cbValueMax, pcbValue);
    5161             : 
    5162       10484 :         if (cbValueMax < 0) {
    5163           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    5164           0 :                 ODBC_EXIT_(stmt);
    5165             :         }
    5166             : 
    5167             :         /* read data from TDS only if current statement */
    5168       10484 :         if ((stmt->cursor == NULL && !stmt->tds)
    5169       10412 :                 || stmt->row_status == PRE_NORMAL_ROW
    5170       10080 :                 || stmt->row_status == NOT_IN_ROW)
    5171             :         {
    5172         404 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    5173         404 :                 ODBC_EXIT_(stmt);
    5174             :         }
    5175             : 
    5176       10080 :         IRD_CHECK;
    5177             : 
    5178       10080 :         if (!pcbValue)
    5179         374 :                 pcbValue = &dummy_cb;
    5180             : 
    5181       10080 :         resinfo = stmt->cursor ? stmt->cursor->res_info : stmt->tds->current_results;
    5182       10080 :         if (!resinfo) {
    5183           0 :                 odbc_errs_add(&stmt->errs, "HY010", NULL);
    5184           0 :                 ODBC_EXIT_(stmt);
    5185             :         }
    5186       10080 :         if (icol <= 0 || icol > resinfo->num_cols) {
    5187           0 :                 odbc_errs_add(&stmt->errs, "07009", "Column out of range");
    5188           0 :                 ODBC_EXIT_(stmt);
    5189             :         }
    5190       10080 :         colinfo = resinfo->columns[icol - 1];
    5191             : 
    5192       10080 :         if (colinfo->column_cur_size < 0) {
    5193             :                 /* TODO check what should happen if pcbValue was NULL */
    5194         348 :                 *pcbValue = SQL_NULL_DATA;
    5195             :         } else {
    5196        9732 :                 if (colinfo->column_text_sqlgetdatapos > 0
    5197        2234 :                     && colinfo->column_text_sqlgetdatapos >= colinfo->column_cur_size
    5198         518 :                     && colinfo->column_iconv_left == 0)
    5199             :                         /* TODO check if SQL_SUCCESS instead !! */
    5200         458 :                         ODBC_EXIT(stmt, SQL_NO_DATA);
    5201             : 
    5202        9274 :                 if (!is_variable_type(colinfo->column_type)) {
    5203         554 :                         colinfo->column_text_sqlgetdatapos = 0;
    5204         554 :                         colinfo->column_iconv_left = 0;
    5205             :                 }
    5206             : 
    5207        9274 :                 if (fCType == SQL_C_DEFAULT)
    5208           0 :                         fCType = odbc_sql_to_c_type_default(stmt->ird->records[icol - 1].sql_desc_concise_type);
    5209        9274 :                 if (fCType == SQL_ARD_TYPE) {
    5210          10 :                         if (icol > stmt->ard->header.sql_desc_count) {
    5211          10 :                                 odbc_errs_add(&stmt->errs, "07009", NULL);
    5212          10 :                                 ODBC_EXIT_(stmt);
    5213             :                         }
    5214           0 :                         fCType = stmt->ard->records[icol - 1].sql_desc_concise_type;
    5215             :                 }
    5216        9264 :                 assert(fCType);
    5217             : 
    5218        9264 :                 *pcbValue = odbc_tds2sql_col(stmt, colinfo, fCType, (TDS_CHAR *) rgbValue, cbValueMax, NULL);
    5219        9264 :                 if (*pcbValue == SQL_NULL_DATA)
    5220          40 :                         ODBC_EXIT(stmt, SQL_ERROR);
    5221             : 
    5222        9224 :                 if (is_variable_type(colinfo->column_type)
    5223        8670 :                     && (fCType == SQL_C_CHAR || fCType == SQL_C_WCHAR || fCType == SQL_C_BINARY)) {
    5224             :                         /* avoid infinite SQL_SUCCESS on empty strings */
    5225        8670 :                         if (colinfo->column_text_sqlgetdatapos == 0 && cbValueMax > 0)
    5226          44 :                                 ++colinfo->column_text_sqlgetdatapos;
    5227             : 
    5228        8670 :                         if (colinfo->column_text_sqlgetdatapos < colinfo->column_cur_size || colinfo->column_iconv_left != 0) {
    5229             :                                 /* not all read ?? */
    5230        1848 :                                 odbc_errs_add(&stmt->errs, "01004", "String data, right truncated");
    5231        1848 :                                 ODBC_EXIT_(stmt);
    5232             :                         }
    5233             :                 } else {
    5234         554 :                         int nSybType = tds_get_conversion_type(colinfo->on_server.column_type, colinfo->on_server.column_size);
    5235         554 :                         colinfo->column_text_sqlgetdatapos = colinfo->column_cur_size;
    5236         554 :                         if (is_fixed_type(nSybType) && (fCType == SQL_C_CHAR || fCType == SQL_C_WCHAR || fCType == SQL_C_BINARY)
    5237         416 :                             && cbValueMax < *pcbValue) {
    5238          18 :                                 odbc_errs_add(&stmt->errs, "22003", NULL);
    5239          18 :                                 ODBC_EXIT_(stmt);
    5240             :                         }
    5241             :                 }
    5242             :         }
    5243        7706 :         ODBC_EXIT_(stmt);
    5244             : }
    5245             : 
    5246             : SQLRETURN ODBC_PUBLIC ODBC_API
    5247             : SQLGetFunctions(SQLHDBC hdbc, SQLUSMALLINT fFunction, SQLUSMALLINT FAR * pfExists)
    5248             : {
    5249             :         int i;
    5250             : 
    5251           0 :         ODBC_ENTER_HDBC;
    5252             : 
    5253           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetFunctions: fFunction is %d\n", fFunction);
    5254           0 :         switch (fFunction) {
    5255             : #if (ODBCVER >= 0x0300)
    5256             :         case SQL_API_ODBC3_ALL_FUNCTIONS:
    5257           0 :                 for (i = 0; i < SQL_API_ODBC3_ALL_FUNCTIONS_SIZE; ++i) {
    5258           0 :                         pfExists[i] = 0;
    5259             :                 }
    5260             : 
    5261             :                 /*
    5262             :                  * every api available are contained in a macro
    5263             :                  * all these macro begin with API followed by 2 letter
    5264             :                  * first letter mean pre ODBC 3 (_) or ODBC 3 (3)
    5265             :                  * second letter mean implemented (X) or unimplemented (_)
    5266             :                  * You should copy these macro 3 times... not very good
    5267             :                  * but works. Perhaps best method is build the bit array statically
    5268             :                  * and then use it but I don't know how to build it...
    5269             :                  */
    5270             : #undef ODBC_ALL_API
    5271             : #undef ODBC_COLATTRIBUTE
    5272             : 
    5273             : #if SQL_API_SQLCOLATTRIBUTE != SQL_API_SQLCOLATTRIBUTES
    5274             : #define ODBC_COLATTRIBUTE(s) s
    5275             : #else
    5276             : #define ODBC_COLATTRIBUTE(s)
    5277             : #endif
    5278             : 
    5279             : #define ODBC_ALL_API \
    5280             :         API_X(SQL_API_SQLALLOCCONNECT)\
    5281             :         API_X(SQL_API_SQLALLOCENV)\
    5282             :         API3X(SQL_API_SQLALLOCHANDLE)\
    5283             :         API_X(SQL_API_SQLALLOCSTMT)\
    5284             :         API_X(SQL_API_SQLBINDCOL)\
    5285             :         API_X(SQL_API_SQLBINDPARAM)\
    5286             :         API_X(SQL_API_SQLBINDPARAMETER)\
    5287             :         API__(SQL_API_SQLBROWSECONNECT)\
    5288             :         API3_(SQL_API_SQLBULKOPERATIONS)\
    5289             :         API_X(SQL_API_SQLCANCEL)\
    5290             :         API3X(SQL_API_SQLCLOSECURSOR)\
    5291             :         ODBC_COLATTRIBUTE(API3X(SQL_API_SQLCOLATTRIBUTE))\
    5292             :         API_X(SQL_API_SQLCOLATTRIBUTES)\
    5293             :         API_X(SQL_API_SQLCOLUMNPRIVILEGES)\
    5294             :         API_X(SQL_API_SQLCOLUMNS)\
    5295             :         API_X(SQL_API_SQLCONNECT)\
    5296             :         API3X(SQL_API_SQLCOPYDESC)\
    5297             :         API_X(SQL_API_SQLDESCRIBECOL)\
    5298             :         API_X(SQL_API_SQLDESCRIBEPARAM)\
    5299             :         API_X(SQL_API_SQLDISCONNECT)\
    5300             :         API_X(SQL_API_SQLDRIVERCONNECT)\
    5301             :         API3X(SQL_API_SQLENDTRAN)\
    5302             :         API_X(SQL_API_SQLERROR)\
    5303             :         API_X(SQL_API_SQLEXECDIRECT)\
    5304             :         API_X(SQL_API_SQLEXECUTE)\
    5305             :         API_X(SQL_API_SQLEXTENDEDFETCH)\
    5306             :         API_X(SQL_API_SQLFETCH)\
    5307             :         API3X(SQL_API_SQLFETCHSCROLL)\
    5308             :         API_X(SQL_API_SQLFOREIGNKEYS)\
    5309             :         API_X(SQL_API_SQLFREECONNECT)\
    5310             :         API_X(SQL_API_SQLFREEENV)\
    5311             :         API3X(SQL_API_SQLFREEHANDLE)\
    5312             :         API_X(SQL_API_SQLFREESTMT)\
    5313             :         API3X(SQL_API_SQLGETCONNECTATTR)\
    5314             :         API_X(SQL_API_SQLGETCONNECTOPTION)\
    5315             :         API_X(SQL_API_SQLGETCURSORNAME)\
    5316             :         API_X(SQL_API_SQLGETDATA)\
    5317             :         API3X(SQL_API_SQLGETDESCFIELD)\
    5318             :         API3X(SQL_API_SQLGETDESCREC)\
    5319             :         API3X(SQL_API_SQLGETDIAGFIELD)\
    5320             :         API3X(SQL_API_SQLGETDIAGREC)\
    5321             :         API3X(SQL_API_SQLGETENVATTR)\
    5322             :         API_X(SQL_API_SQLGETFUNCTIONS)\
    5323             :         API_X(SQL_API_SQLGETINFO)\
    5324             :         API3X(SQL_API_SQLGETSTMTATTR)\
    5325             :         API_X(SQL_API_SQLGETSTMTOPTION)\
    5326             :         API_X(SQL_API_SQLGETTYPEINFO)\
    5327             :         API_X(SQL_API_SQLMORERESULTS)\
    5328             :         API_X(SQL_API_SQLNATIVESQL)\
    5329             :         API_X(SQL_API_SQLNUMPARAMS)\
    5330             :         API_X(SQL_API_SQLNUMRESULTCOLS)\
    5331             :         API_X(SQL_API_SQLPARAMDATA)\
    5332             :         API_X(SQL_API_SQLPARAMOPTIONS)\
    5333             :         API_X(SQL_API_SQLPREPARE)\
    5334             :         API_X(SQL_API_SQLPRIMARYKEYS)\
    5335             :         API_X(SQL_API_SQLPROCEDURECOLUMNS)\
    5336             :         API_X(SQL_API_SQLPROCEDURES)\
    5337             :         API_X(SQL_API_SQLPUTDATA)\
    5338             :         API_X(SQL_API_SQLROWCOUNT)\
    5339             :         API3X(SQL_API_SQLSETCONNECTATTR)\
    5340             :         API_X(SQL_API_SQLSETCONNECTOPTION)\
    5341             :         API_X(SQL_API_SQLSETCURSORNAME)\
    5342             :         API3X(SQL_API_SQLSETDESCFIELD)\
    5343             :         API3X(SQL_API_SQLSETDESCREC)\
    5344             :         API3X(SQL_API_SQLSETENVATTR)\
    5345             :         API_X(SQL_API_SQLSETPARAM)\
    5346             :         API_X(SQL_API_SQLSETPOS)\
    5347             :         API_X(SQL_API_SQLSETSCROLLOPTIONS)\
    5348             :         API3X(SQL_API_SQLSETSTMTATTR)\
    5349             :         API_X(SQL_API_SQLSETSTMTOPTION)\
    5350             :         API_X(SQL_API_SQLSPECIALCOLUMNS)\
    5351             :         API_X(SQL_API_SQLSTATISTICS)\
    5352             :         API_X(SQL_API_SQLTABLEPRIVILEGES)\
    5353             :         API_X(SQL_API_SQLTABLES)\
    5354             :         API_X(SQL_API_SQLTRANSACT)
    5355             : 
    5356             : #define API_X(n) if (n >= 0 && n < (16*SQL_API_ODBC3_ALL_FUNCTIONS_SIZE)) pfExists[n/16] |= (1 << n%16);
    5357             : #define API__(n)
    5358             : #define API3X(n) if (n >= 0 && n < (16*SQL_API_ODBC3_ALL_FUNCTIONS_SIZE)) pfExists[n/16] |= (1 << n%16);
    5359             : #define API3_(n)
    5360           0 :                 ODBC_ALL_API
    5361             : #undef API_X
    5362             : #undef API__
    5363             : #undef API3X
    5364             : #undef API3_
    5365             :                 break;
    5366             : #endif
    5367             : 
    5368           0 :         case SQL_API_ALL_FUNCTIONS:
    5369           0 :                 tdsdump_log(TDS_DBG_FUNC, "SQLGetFunctions: " "fFunction is SQL_API_ALL_FUNCTIONS\n");
    5370           0 :                 for (i = 0; i < 100; ++i) {
    5371           0 :                         pfExists[i] = SQL_FALSE;
    5372             :                 }
    5373             : 
    5374             : #define API_X(n) if (n >= 0 && n < 100) pfExists[n] = SQL_TRUE;
    5375             : #define API__(n)
    5376             : #define API3X(n)
    5377             : #define API3_(n)
    5378           0 :                 ODBC_ALL_API
    5379             : #undef API_X
    5380             : #undef API__
    5381             : #undef API3X
    5382             : #undef API3_
    5383             :                 break;
    5384             : #define API_X(n) case n:
    5385             : #define API__(n)
    5386             : #if (ODBCVER >= 0x300)
    5387             : #define API3X(n) case n:
    5388             : #else
    5389             : #define API3X(n)
    5390             : #endif
    5391             : #define API3_(n)
    5392           0 :                 ODBC_ALL_API
    5393             : #undef API_X
    5394             : #undef API__
    5395             : #undef API3X
    5396             : #undef API3_
    5397           0 :                 *pfExists = SQL_TRUE;
    5398           0 :                 break;
    5399           0 :         default:
    5400           0 :                 *pfExists = SQL_FALSE;
    5401           0 :                 break;
    5402             :         }
    5403           0 :         ODBC_EXIT(dbc, SQL_SUCCESS);
    5404             : #undef ODBC_ALL_API
    5405             : }
    5406             : 
    5407             : 
    5408             : static SQLRETURN
    5409         892 : odbc_SQLGetInfo(TDS_DBC * dbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax,
    5410             :             SQLSMALLINT FAR * pcbInfoValue _WIDE)
    5411             : {
    5412         892 :         const char *p = NULL;
    5413             :         char buf[32];
    5414             :         TDSSOCKET *tds;
    5415         892 :         int is_ms = -1;
    5416         892 :         unsigned int smajor = 6;
    5417         892 :         SQLUINTEGER mssql7plus_mask = 0;
    5418         892 :         int out_len = -1;
    5419             : 
    5420         892 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLGetInfo(%p, %u, %p, %d, %p)\n",
    5421             :                         dbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
    5422             : 
    5423             : #define SIVAL out_len = sizeof(SQLSMALLINT), *((SQLSMALLINT *) rgbInfoValue)
    5424             : #define USIVAL out_len = sizeof(SQLUSMALLINT), *((SQLUSMALLINT *) rgbInfoValue)
    5425             : #define IVAL out_len = sizeof(SQLINTEGER), *((SQLINTEGER *) rgbInfoValue)
    5426             : #define UIVAL out_len = sizeof(SQLUINTEGER), *((SQLUINTEGER *) rgbInfoValue)
    5427             : #define ULVAL out_len = sizeof(SQLULEN), *((SQLULEN *) rgbInfoValue)
    5428             : 
    5429         892 :         if ((tds = dbc->tds_socket) != NULL) {
    5430         852 :                 is_ms = TDS_IS_MSSQL(tds);
    5431         852 :                 smajor = (tds->conn->product_version >> 24) & 0x7F;
    5432         852 :                 if (is_ms && smajor >= 7)
    5433         716 :                         mssql7plus_mask = ~((SQLUINTEGER) 0);
    5434             :         }
    5435             : 
    5436         892 :         switch (fInfoType) {
    5437             :         case SQL_ACCESSIBLE_PROCEDURES:
    5438             :         case SQL_ACCESSIBLE_TABLES:
    5439             :                 p = "Y";
    5440             :                 break;
    5441             :                 /* SQL_ACTIVE_CONNECTIONS renamed to SQL_MAX_DRIVER_CONNECTIONS */
    5442             : #if (ODBCVER >= 0x0300)
    5443           0 :         case SQL_ACTIVE_ENVIRONMENTS:
    5444           0 :                 UIVAL = 0;
    5445           0 :                 break;
    5446             : #endif /* ODBCVER >= 0x0300 */
    5447             : #if (ODBCVER >= 0x0300)
    5448           0 :         case SQL_AGGREGATE_FUNCTIONS:
    5449           0 :                 UIVAL = SQL_AF_ALL;
    5450           0 :                 break;
    5451           0 :         case SQL_ALTER_DOMAIN:
    5452           0 :                 UIVAL = 0;
    5453           0 :                 break;
    5454             : #endif /* ODBCVER >= 0x0300 */
    5455           0 :         case SQL_ALTER_TABLE:
    5456           0 :                 UIVAL = SQL_AT_ADD_COLUMN | SQL_AT_ADD_COLUMN_DEFAULT | SQL_AT_ADD_COLUMN_SINGLE | SQL_AT_ADD_CONSTRAINT |
    5457             :                         SQL_AT_ADD_TABLE_CONSTRAINT | SQL_AT_CONSTRAINT_NAME_DEFINITION | SQL_AT_DROP_COLUMN_RESTRICT;
    5458           0 :                 break;
    5459             : #if (ODBCVER >= 0x0300)
    5460           0 :         case SQL_ASYNC_MODE:
    5461             :                 /* TODO we hope so in a not-too-far future */
    5462             :                 /* UIVAL = SQL_AM_STATEMENT; */
    5463           0 :                 UIVAL = SQL_AM_NONE;
    5464           0 :                 break;
    5465           0 :         case SQL_BATCH_ROW_COUNT:
    5466           0 :                 UIVAL = SQL_BRC_EXPLICIT;
    5467           0 :                 break;
    5468           0 :         case SQL_BATCH_SUPPORT:
    5469           0 :                 UIVAL = SQL_BS_ROW_COUNT_EXPLICIT | SQL_BS_ROW_COUNT_PROC | SQL_BS_SELECT_EXPLICIT | SQL_BS_SELECT_PROC;
    5470           0 :                 break;
    5471             : #endif /* ODBCVER >= 0x0300 */
    5472           0 :         case SQL_BOOKMARK_PERSISTENCE:
    5473             :                 /* TODO ??? */
    5474           0 :                 UIVAL = SQL_BP_DELETE | SQL_BP_SCROLL | SQL_BP_UPDATE;
    5475           0 :                 break;
    5476           0 :         case SQL_CATALOG_LOCATION:
    5477           0 :                 SIVAL = SQL_CL_START;
    5478           0 :                 break;
    5479             : #if (ODBCVER >= 0x0300)
    5480             :         case SQL_CATALOG_NAME:
    5481             :                 p = "Y";
    5482             :                 break;
    5483             : #endif /* ODBCVER >= 0x0300 */
    5484           0 :         case SQL_CATALOG_NAME_SEPARATOR:
    5485           0 :                 p = ".";
    5486           0 :                 break;
    5487           0 :         case SQL_CATALOG_TERM:
    5488           0 :                 p = "database";
    5489           0 :                 break;
    5490           0 :         case SQL_CATALOG_USAGE:
    5491           0 :                 UIVAL = SQL_CU_DML_STATEMENTS | SQL_CU_PROCEDURE_INVOCATION | SQL_CU_TABLE_DEFINITION;
    5492           0 :                 break;
    5493             :                 /* TODO */
    5494             : #if 0
    5495             :         case SQL_COLLATION_SEQ:
    5496             :                 break;
    5497             : #endif
    5498             :         case SQL_COLUMN_ALIAS:
    5499             :                 p = "Y";
    5500             :                 break;
    5501           0 :         case SQL_CONCAT_NULL_BEHAVIOR:
    5502           0 :                 if (is_ms == -1)
    5503             :                         return SQL_ERROR;
    5504             :                 /* TODO a bit more complicate for mssql2k.. */
    5505           0 :                 SIVAL = (!is_ms || smajor < 7) ? SQL_CB_NON_NULL : SQL_CB_NULL;
    5506           0 :                 break;
    5507             :                 /* TODO SQL_CONVERT_BIGINT SQL_CONVERT_GUID SQL_CONVERT_DATE SQL_CONVERT_TIME */
    5508             :                 /* For Sybase/MSSql6.x we return 0 cause NativeSql is not so implemented */
    5509           0 :         case SQL_CONVERT_BINARY:
    5510           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_VARCHAR |
    5511             :                          SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TINYINT | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR |
    5512           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5513           0 :                 break;
    5514           0 :         case SQL_CONVERT_BIT:
    5515           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5516             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5517           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5518           0 :                 break;
    5519           0 :         case SQL_CONVERT_CHAR:
    5520           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5521             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5522             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5523           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5524           0 :                 break;
    5525           0 :         case SQL_CONVERT_DECIMAL:
    5526           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5527             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5528           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5529           0 :                 break;
    5530           0 :         case SQL_CONVERT_FLOAT:
    5531           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5532           0 :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) &
    5533             :                         mssql7plus_mask;
    5534           0 :                 break;
    5535           0 :         case SQL_CONVERT_INTEGER:
    5536           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5537             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5538           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5539           0 :                 break;
    5540           0 :         case SQL_CONVERT_LONGVARCHAR:
    5541           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5542           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5543           0 :                 break;
    5544           0 :         case SQL_CONVERT_NUMERIC:
    5545           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5546             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5547           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5548           0 :                 break;
    5549           0 :         case SQL_CONVERT_REAL:
    5550           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5551           0 :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) &
    5552             :                         mssql7plus_mask;
    5553           0 :                 break;
    5554           0 :         case SQL_CONVERT_SMALLINT:
    5555           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5556             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5557           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5558           0 :                 break;
    5559           0 :         case SQL_CONVERT_TIMESTAMP:
    5560           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TIMESTAMP | SQL_CVT_WCHAR |
    5561           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5562           0 :                 break;
    5563           0 :         case SQL_CONVERT_TINYINT:
    5564           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5565             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5566           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5567           0 :                 break;
    5568           0 :         case SQL_CONVERT_VARBINARY:
    5569           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_VARCHAR |
    5570             :                          SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TINYINT | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR |
    5571           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5572           0 :                 break;
    5573           0 :         case SQL_CONVERT_VARCHAR:
    5574           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5575             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5576             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5577           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5578           0 :                 break;
    5579           0 :         case SQL_CONVERT_LONGVARBINARY:
    5580           0 :                 UIVAL = (SQL_CVT_BINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_VARBINARY) & mssql7plus_mask;
    5581           0 :                 break;
    5582           0 :         case SQL_CONVERT_WLONGVARCHAR:
    5583           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5584           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5585           0 :                 break;
    5586             : #if (ODBCVER >= 0x0300)
    5587           0 :         case SQL_CONVERT_WCHAR:
    5588           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5589             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5590             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5591           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5592           0 :                 break;
    5593           0 :         case SQL_CONVERT_WVARCHAR:
    5594           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5595             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5596             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5597           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5598           0 :                 break;
    5599             : #endif /* ODBCVER >= 0x0300 */
    5600           0 :         case SQL_CONVERT_FUNCTIONS:
    5601             :                 /* TODO no CAST for Sybase ?? */
    5602           0 :                 UIVAL = SQL_FN_CVT_CONVERT | SQL_FN_CVT_CAST;
    5603           0 :                 break;
    5604             : #if (ODBCVER >= 0x0300)
    5605           0 :         case SQL_CREATE_ASSERTION:
    5606             :         case SQL_CREATE_CHARACTER_SET:
    5607             :         case SQL_CREATE_COLLATION:
    5608             :         case SQL_CREATE_DOMAIN:
    5609           0 :                 UIVAL = 0;
    5610           0 :                 break;
    5611           0 :         case SQL_CREATE_SCHEMA:
    5612           0 :                 UIVAL = SQL_CS_AUTHORIZATION | SQL_CS_CREATE_SCHEMA;
    5613           0 :                 break;
    5614           0 :         case SQL_CREATE_TABLE:
    5615           0 :                 UIVAL = SQL_CT_CREATE_TABLE;
    5616           0 :                 break;
    5617           0 :         case SQL_CREATE_TRANSLATION:
    5618           0 :                 UIVAL = 0;
    5619           0 :                 break;
    5620           0 :         case SQL_CREATE_VIEW:
    5621           0 :                 UIVAL = SQL_CV_CHECK_OPTION | SQL_CV_CREATE_VIEW;
    5622           0 :                 break;
    5623             : #endif /* ODBCVER >= 0x0300 */
    5624           0 :         case SQL_CORRELATION_NAME:
    5625           0 :                 USIVAL = SQL_CN_ANY;
    5626           0 :                 break;
    5627           0 :         case SQL_CURSOR_COMMIT_BEHAVIOR:
    5628             :                 /* currently cursors are not supported however sql server close automaticly cursors on commit */
    5629             :                 /* TODO cursors test what happen if rollback, cursors get properly deleted ?? */
    5630           0 :                 USIVAL = SQL_CB_CLOSE;
    5631           0 :                 break;
    5632           0 :         case SQL_CURSOR_ROLLBACK_BEHAVIOR:
    5633           0 :                 USIVAL = SQL_CB_CLOSE;
    5634           0 :                 break;
    5635           0 :         case SQL_CURSOR_SENSITIVITY:
    5636           0 :                 UIVAL = SQL_SENSITIVE;
    5637           0 :                 break;
    5638           0 :         case SQL_DATABASE_NAME:
    5639           0 :                 p = tds_dstr_cstr(&dbc->attr.current_catalog);
    5640           0 :                 break;
    5641           0 :         case SQL_DATA_SOURCE_NAME:
    5642           0 :                 p = tds_dstr_cstr(&dbc->dsn);
    5643           0 :                 break;
    5644           0 :         case SQL_DATA_SOURCE_READ_ONLY:
    5645             :                 /*
    5646             :                  * TODO: determine the right answer from connection
    5647             :                  * attribute SQL_ATTR_ACCESS_MODE
    5648             :                  */
    5649           0 :                 p = "N";      /* false, writable */
    5650           0 :                 break;
    5651             : #if (ODBCVER >= 0x0300)
    5652           0 :         case SQL_DATETIME_LITERALS:
    5653             :                 /* TODO ok ?? */
    5654           0 :                 UIVAL = 0;
    5655           0 :                 break;
    5656             : #endif /* ODBCVER >= 0x0300 */
    5657         268 :         case SQL_DBMS_NAME:
    5658         268 :                 p = tds ? tds->conn->product_name : NULL;
    5659             :                 break;
    5660          86 :         case SQL_DBMS_VER:
    5661          86 :                 if (!dbc->tds_socket)
    5662             :                         return SQL_ERROR;
    5663          86 :                 odbc_rdbms_version(dbc->tds_socket, buf);
    5664          86 :                 p = buf;
    5665          86 :                 break;
    5666             : #if (ODBCVER >= 0x0300)
    5667           0 :         case SQL_DDL_INDEX:
    5668           0 :                 UIVAL = 0;
    5669           0 :                 break;
    5670             : #endif /* ODBCVER >= 0x0300 */
    5671           0 :         case SQL_DEFAULT_TXN_ISOLATION:
    5672           0 :                 UIVAL = SQL_TXN_READ_COMMITTED;
    5673           0 :                 break;
    5674             : #if (ODBCVER >= 0x0300)
    5675           0 :         case SQL_DESCRIBE_PARAMETER:
    5676             :                 /* TODO */
    5677           0 :                 p = "N";
    5678           0 :                 break;
    5679             : #endif /* ODBCVER >= 0x0300 */
    5680          10 :         case SQL_DRIVER_HDBC:
    5681          10 :                 ULVAL = (SQLULEN) dbc;
    5682          10 :                 break;
    5683          10 :         case SQL_DRIVER_HENV:
    5684          10 :                 ULVAL = (SQLULEN) dbc->env;
    5685          10 :                 break;
    5686           0 :         case SQL_DRIVER_HSTMT: {
    5687           0 :                         void *ptr = *((void**) rgbInfoValue);
    5688           0 :                         if (SQL_NULL_HSTMT != ptr && !IS_HSTMT(ptr))
    5689           0 :                                 ULVAL = SQL_NULL_HSTMT;
    5690             :                 }
    5691             :                 break;
    5692           0 :         case SQL_DRIVER_HDESC: {
    5693           0 :                         void *ptr = *((void**) rgbInfoValue);
    5694           0 :                         if (SQL_NULL_HDESC != ptr && !IS_HDESC(ptr))
    5695           0 :                                 ULVAL = SQL_NULL_HDESC;
    5696             :                 }
    5697             :                 break;
    5698         326 :         case SQL_DRIVER_NAME:   /* ODBC 2.0 */
    5699         326 :                 p = "libtdsodbc.so";
    5700         326 :                 break;
    5701           0 :         case SQL_DRIVER_ODBC_VER:
    5702           0 :                 p = "03.50";
    5703           0 :                 break;
    5704           0 :         case SQL_DRIVER_VER:
    5705           0 :                 sprintf(buf, "%02d.%02d.%04d", TDS_VERSION_MAJOR,
    5706             :                         TDS_VERSION_MINOR, TDS_VERSION_SUBVERSION);
    5707           0 :                 p = buf;
    5708           0 :                 break;
    5709             : #if (ODBCVER >= 0x0300)
    5710           0 :         case SQL_DROP_ASSERTION:
    5711             :         case SQL_DROP_CHARACTER_SET:
    5712             :         case SQL_DROP_COLLATION:
    5713             :         case SQL_DROP_DOMAIN:
    5714             :         case SQL_DROP_SCHEMA:
    5715           0 :                 UIVAL = 0;
    5716           0 :                 break;
    5717           0 :         case SQL_DROP_TABLE:
    5718           0 :                 UIVAL = SQL_DT_DROP_TABLE;
    5719           0 :                 break;
    5720           0 :         case SQL_DROP_TRANSLATION:
    5721           0 :                 UIVAL = 0;
    5722           0 :                 break;
    5723           0 :         case SQL_DROP_VIEW:
    5724           0 :                 UIVAL = SQL_DV_DROP_VIEW;
    5725           0 :                 break;
    5726           0 :         case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
    5727           0 :                 if (dbc->cursor_support)
    5728             :                         /* TODO cursor SQL_CA1_BULK_ADD SQL_CA1_POS_REFRESH SQL_CA1_SELECT_FOR_UPDATE */
    5729           0 :                         UIVAL = SQL_CA1_ABSOLUTE | SQL_CA1_NEXT | SQL_CA1_RELATIVE |
    5730             :                                 SQL_CA1_LOCK_NO_CHANGE |
    5731             :                                 SQL_CA1_POS_DELETE | SQL_CA1_POS_POSITION | SQL_CA1_POS_UPDATE |
    5732             :                                 SQL_CA1_POSITIONED_UPDATE | SQL_CA1_POSITIONED_DELETE;
    5733             :                 else
    5734           0 :                         UIVAL = 0;
    5735             :                 break;
    5736           0 :         case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
    5737             :                 /* TODO cursors */
    5738             :                 /* Cursors not supported yet */
    5739             :                 /*
    5740             :                  * Should be SQL_CA2_LOCK_CONCURRENCY SQL_CA2_MAX_ROWS_CATALOG SQL_CA2_MAX_ROWS_DELETE
    5741             :                  * SQL_CA2_MAX_ROWS_INSERT SQL_CA2_MAX_ROWS_SELECT SQL_CA2_MAX_ROWS_UPDATE SQL_CA2_OPT_ROWVER_CONCURRENCY
    5742             :                  * SQL_CA2_OPT_VALUES_CONCURRENCY SQL_CA2_READ_ONLY_CONCURRENCY SQL_CA2_SENSITIVITY_ADDITIONS
    5743             :                  * SQL_CA2_SENSITIVITY_UPDATES SQL_CA2_SIMULATE_UNIQUE
    5744             :                  */
    5745           0 :                 UIVAL = 0;
    5746           0 :                 break;
    5747             : #endif /* ODBCVER >= 0x0300 */
    5748             :         case SQL_EXPRESSIONS_IN_ORDERBY:
    5749             :                 p = "Y";
    5750             :                 break;
    5751           0 :         case SQL_FILE_USAGE:
    5752           0 :                 USIVAL = SQL_FILE_NOT_SUPPORTED;
    5753           0 :                 break;
    5754           0 :         case SQL_FETCH_DIRECTION:
    5755           0 :                 if (dbc->cursor_support)
    5756             :                         /* TODO cursors SQL_FD_FETCH_BOOKMARK */
    5757           0 :                         UIVAL = SQL_FD_FETCH_ABSOLUTE|SQL_FD_FETCH_FIRST|SQL_FD_FETCH_LAST|SQL_FD_FETCH_NEXT
    5758             :                                 |SQL_FD_FETCH_PRIOR|SQL_FD_FETCH_RELATIVE;
    5759             :                 else
    5760           0 :                         UIVAL = 0;
    5761             :                 break;
    5762             : #if (ODBCVER >= 0x0300)
    5763           0 :         case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
    5764           0 :                 if (dbc->cursor_support)
    5765             :                         /* TODO cursors SQL_CA1_SELECT_FOR_UPDATE */
    5766           0 :                         UIVAL = SQL_CA1_NEXT|SQL_CA1_POSITIONED_DELETE|SQL_CA1_POSITIONED_UPDATE;
    5767             :                 else
    5768           0 :                         UIVAL = 0;
    5769             :                 break;
    5770           0 :         case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
    5771             :                 /* TODO cursors */
    5772             :                 /* Cursors not supported yet */
    5773             :                 /*
    5774             :                  * Should be SQL_CA2_LOCK_CONCURRENCY SQL_CA2_MAX_ROWS_CATALOG SQL_CA2_MAX_ROWS_DELETE
    5775             :                  * SQL_CA2_MAX_ROWS_INSERT SQL_CA2_MAX_ROWS_SELECT SQL_CA2_MAX_ROWS_UPDATE SQL_CA2_OPT_ROWVER_CONCURRENCY
    5776             :                  * SQL_CA2_OPT_VALUES_CONCURRENCY SQL_CA2_READ_ONLY_CONCURRENCY
    5777             :                  */
    5778           0 :                 UIVAL = 0;
    5779           0 :                 break;
    5780             : #endif /* ODBCVER >= 0x0300 */
    5781           0 :         case SQL_GETDATA_EXTENSIONS:
    5782             :                 /* TODO FreeTDS support more ?? */
    5783           0 :                 UIVAL = SQL_GD_BLOCK;
    5784           0 :                 break;
    5785           0 :         case SQL_GROUP_BY:
    5786           0 :                 USIVAL = SQL_GB_GROUP_BY_CONTAINS_SELECT;
    5787           0 :                 break;
    5788           0 :         case SQL_IDENTIFIER_CASE:
    5789             :                 /* TODO configuration dependend */
    5790           0 :                 USIVAL = SQL_IC_MIXED;
    5791           0 :                 break;
    5792           0 :         case SQL_IDENTIFIER_QUOTE_CHAR:
    5793           0 :                 p = "\"";
    5794             :                 /* TODO workaround for Sybase, use SET QUOTED_IDENTIFIER ON and fix unwanted quote */
    5795           0 :                 if (!is_ms)
    5796           0 :                         p = "";
    5797             :                 break;
    5798             : #if (ODBCVER >= 0x0300)
    5799           0 :         case SQL_INDEX_KEYWORDS:
    5800           0 :                 UIVAL = SQL_IK_ASC | SQL_IK_DESC;
    5801           0 :                 break;
    5802             : #endif /* ODBCVER >= 0x0300 */
    5803           0 :         case SQL_INFO_SCHEMA_VIEWS:
    5804             :                 /* TODO finish */
    5805           0 :                 UIVAL = 0;
    5806           0 :                 break;
    5807           0 :         case SQL_INSERT_STATEMENT:
    5808           0 :                 UIVAL = 0;
    5809           0 :                 break;
    5810             :                 /* renamed from SQL_ODBC_SQL_OPT_IEF */
    5811             :         case SQL_INTEGRITY:
    5812             :                 p = "Y";
    5813             :                 break;
    5814           0 :         case SQL_KEYSET_CURSOR_ATTRIBUTES1:
    5815             :         case SQL_KEYSET_CURSOR_ATTRIBUTES2:
    5816             :                 /* TODO cursors */
    5817           0 :                 UIVAL = 0;
    5818           0 :                 break;
    5819           0 :         case SQL_KEYWORDS:
    5820             :                 /* TODO ok for Sybase ? */
    5821           0 :                 p = "BREAK,BROWSE,BULK,CHECKPOINT,CLUSTERED,"
    5822             :                         "COMMITTED,COMPUTE,CONFIRM,CONTROLROW,DATABASE,"
    5823             :                         "DBCC,DISK,DISTRIBUTED,DUMMY,DUMP,ERRLVL,"
    5824             :                         "ERROREXIT,EXIT,FILE,FILLFACTOR,FLOPPY,HOLDLOCK,"
    5825             :                         "IDENTITY_INSERT,IDENTITYCOL,IF,KILL,LINENO,"
    5826             :                         "LOAD,MIRROREXIT,NONCLUSTERED,OFF,OFFSETS,ONCE,"
    5827             :                         "OVER,PERCENT,PERM,PERMANENT,PLAN,PRINT,PROC,"
    5828             :                         "PROCESSEXIT,RAISERROR,READ,READTEXT,RECONFIGURE,"
    5829             :                         "REPEATABLE,RETURN,ROWCOUNT,RULE,SAVE,SERIALIZABLE,"
    5830             :                         "SETUSER,SHUTDOWN,STATISTICS,TAPE,TEMP,TEXTSIZE,"
    5831             :                         "TRAN,TRIGGER,TRUNCATE,TSEQUEL,UNCOMMITTED," "UPDATETEXT,USE,WAITFOR,WHILE,WRITETEXT";
    5832           0 :                 break;
    5833             :         case SQL_LIKE_ESCAPE_CLAUSE:
    5834             :                 p = "Y";
    5835             :                 break;
    5836           0 :         case SQL_LOCK_TYPES:
    5837           0 :                 if (dbc->cursor_support)
    5838           0 :                         IVAL = SQL_LCK_NO_CHANGE;
    5839             :                 else
    5840           0 :                         IVAL = 0;
    5841             :                 break;
    5842             : #if (ODBCVER >= 0x0300)
    5843           0 :         case SQL_MAX_ASYNC_CONCURRENT_STATEMENTS:
    5844           0 :                 UIVAL = 1;
    5845           0 :                 break;
    5846             : #endif /* ODBCVER >= 0x0300 */
    5847             :                 /* TODO same limits for Sybase ? */
    5848           0 :         case SQL_MAX_BINARY_LITERAL_LEN:
    5849           0 :                 UIVAL = 131072;
    5850           0 :                 break;
    5851           0 :         case SQL_MAX_CHAR_LITERAL_LEN:
    5852           0 :                 UIVAL = 131072;
    5853           0 :                 break;
    5854           0 :         case SQL_MAX_CONCURRENT_ACTIVITIES:
    5855           0 :                 USIVAL = 1;
    5856           0 :                 break;
    5857           0 :         case SQL_MAX_COLUMNS_IN_GROUP_BY:
    5858             :         case SQL_MAX_COLUMNS_IN_INDEX:
    5859             :         case SQL_MAX_COLUMNS_IN_ORDER_BY:
    5860             :                 /* TODO Sybase ? */
    5861           0 :                 USIVAL = 16;
    5862           0 :                 break;
    5863           0 :         case SQL_MAX_COLUMNS_IN_SELECT:
    5864             :                 /* TODO Sybase ? */
    5865           0 :                 USIVAL = 4000;
    5866           0 :                 break;
    5867           0 :         case SQL_MAX_COLUMNS_IN_TABLE:
    5868             :                 /* TODO Sybase ? */
    5869           0 :                 USIVAL = 250;
    5870           0 :                 break;
    5871           0 :         case SQL_MAX_DRIVER_CONNECTIONS:
    5872           0 :                 USIVAL = 0;
    5873           0 :                 break;
    5874           0 :         case SQL_MAX_IDENTIFIER_LEN:
    5875           0 :                 if (is_ms == -1)
    5876             :                         return SQL_ERROR;
    5877           0 :                 USIVAL = (!is_ms || smajor < 7) ? 30 : 128;
    5878           0 :                 break;
    5879           0 :         case SQL_MAX_INDEX_SIZE:
    5880           0 :                 UIVAL = 127;
    5881           0 :                 break;
    5882           0 :         case SQL_MAX_PROCEDURE_NAME_LEN:
    5883           0 :                 if (is_ms == -1)
    5884             :                         return SQL_ERROR;
    5885             :                 /* TODO Sybase ? */
    5886           0 :                 USIVAL = (is_ms && smajor >= 7) ? 134 : 36;
    5887           0 :                 break;
    5888           0 :         case SQL_MAX_ROW_SIZE:
    5889           0 :                 if (is_ms == -1)
    5890             :                         return SQL_ERROR;
    5891             :                 /* TODO Sybase ? */
    5892           0 :                 UIVAL = (is_ms && smajor >= 7) ? 8062 : 1962;
    5893           0 :                 break;
    5894           0 :         case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
    5895           0 :                 p = "N";
    5896           0 :                 break;
    5897           0 :         case SQL_MAX_STATEMENT_LEN:
    5898             :                 /* TODO Sybase ? */
    5899           0 :                 UIVAL = 131072;
    5900           0 :                 break;
    5901           0 :         case SQL_MAX_TABLES_IN_SELECT:
    5902             :                 /* TODO Sybase ? */
    5903           0 :                 USIVAL = 16;
    5904           0 :                 break;
    5905           0 :         case SQL_MAX_USER_NAME_LEN:
    5906             :                 /* TODO Sybase ? */
    5907           0 :                 if (is_ms == -1)
    5908             :                         return SQL_ERROR;
    5909           0 :                 USIVAL = (is_ms && smajor >= 7) ? 128 : 30;
    5910           0 :                 break;
    5911           0 :         case SQL_MAX_COLUMN_NAME_LEN:
    5912             :         case SQL_MAX_CURSOR_NAME_LEN:
    5913             :         case SQL_MAX_SCHEMA_NAME_LEN:
    5914             :         case SQL_MAX_CATALOG_NAME_LEN:
    5915             :         case SQL_MAX_TABLE_NAME_LEN:
    5916             :                 /* TODO Sybase ? */
    5917           0 :                 if (is_ms == -1)
    5918             :                         return SQL_ERROR;
    5919           0 :                 USIVAL = (is_ms && smajor >= 7) ? 128 : 30;
    5920           0 :                 break;
    5921             :         case SQL_MULT_RESULT_SETS:
    5922             :                 p = "Y";
    5923             :                 break;
    5924             :         case SQL_MULTIPLE_ACTIVE_TXN:
    5925             :                 p = "Y";
    5926             :                 break;
    5927             :         case SQL_NEED_LONG_DATA_LEN:
    5928             :                 /* current implementation do not require length, however future will, so is correct to return yes */
    5929             :                 p = "Y";
    5930             :                 break;
    5931           0 :         case SQL_NON_NULLABLE_COLUMNS:
    5932           0 :                 USIVAL = SQL_NNC_NON_NULL;
    5933           0 :                 break;
    5934           0 :         case SQL_NULL_COLLATION:
    5935           0 :                 USIVAL = SQL_NC_LOW;
    5936           0 :                 break;
    5937           0 :         case SQL_NUMERIC_FUNCTIONS:
    5938           0 :                 UIVAL = (SQL_FN_NUM_ABS | SQL_FN_NUM_ACOS | SQL_FN_NUM_ASIN | SQL_FN_NUM_ATAN | SQL_FN_NUM_ATAN2 |
    5939             :                          SQL_FN_NUM_CEILING | SQL_FN_NUM_COS | SQL_FN_NUM_COT | SQL_FN_NUM_DEGREES | SQL_FN_NUM_EXP |
    5940             :                          SQL_FN_NUM_FLOOR | SQL_FN_NUM_LOG | SQL_FN_NUM_LOG10 | SQL_FN_NUM_MOD | SQL_FN_NUM_PI | SQL_FN_NUM_POWER |
    5941             :                          SQL_FN_NUM_RADIANS | SQL_FN_NUM_RAND | SQL_FN_NUM_ROUND | SQL_FN_NUM_SIGN | SQL_FN_NUM_SIN |
    5942           0 :                          SQL_FN_NUM_SQRT | SQL_FN_NUM_TAN) & mssql7plus_mask;
    5943           0 :                 break;
    5944           0 :         case SQL_ODBC_API_CONFORMANCE:
    5945           0 :                 SIVAL = SQL_OAC_LEVEL2;
    5946           0 :                 break;
    5947             : #if (ODBCVER >= 0x0300)
    5948           0 :         case SQL_ODBC_INTERFACE_CONFORMANCE:
    5949           0 :                 UIVAL = SQL_OAC_LEVEL2;
    5950           0 :                 break;
    5951             : #endif /* ODBCVER >= 0x0300 */
    5952           0 :         case SQL_ODBC_SAG_CLI_CONFORMANCE:
    5953           0 :                 SIVAL = SQL_OSCC_NOT_COMPLIANT;
    5954           0 :                 break;
    5955           0 :         case SQL_ODBC_SQL_CONFORMANCE:
    5956           0 :                 SIVAL = SQL_OSC_CORE;
    5957           0 :                 break;
    5958             : #ifdef TDS_NO_DM
    5959           0 :         case SQL_ODBC_VER:
    5960             :                 /* TODO check format ##.##.0000 */
    5961           0 :                 p = VERSION;
    5962           0 :                 break;
    5963             : #endif
    5964             : #if (ODBCVER >= 0x0300)
    5965           0 :         case SQL_OJ_CAPABILITIES:
    5966           0 :                 UIVAL = SQL_OJ_ALL_COMPARISON_OPS | SQL_OJ_FULL | SQL_OJ_INNER | SQL_OJ_LEFT | SQL_OJ_NESTED | SQL_OJ_NOT_ORDERED |
    5967             :                         SQL_OJ_RIGHT;
    5968           0 :                 break;
    5969             : #endif /* ODBCVER >= 0x0300 */
    5970           0 :         case SQL_ORDER_BY_COLUMNS_IN_SELECT:
    5971           0 :                 p = "N";
    5972           0 :                 break;
    5973             :         case SQL_OUTER_JOINS:
    5974             :                 p = "Y";
    5975             :                 break;
    5976             : #if (ODBCVER >= 0x0300)
    5977           0 :         case SQL_PARAM_ARRAY_ROW_COUNTS:
    5978           0 :                 UIVAL = SQL_PARC_BATCH;
    5979           0 :                 break;
    5980           0 :         case SQL_PARAM_ARRAY_SELECTS:
    5981           0 :                 UIVAL = SQL_PAS_BATCH;
    5982           0 :                 break;
    5983             : #endif /* ODBCVER >= 0x0300 */
    5984           0 :         case SQL_POS_OPERATIONS:
    5985           0 :                 if (dbc->cursor_support)
    5986             :                         /* TODO cursors SQL_POS_ADD SQL_POS_REFRESH */
    5987             :                         /* test REFRESH, ADD under mssql, under Sybase I don't know how to do it but dblib do */
    5988           0 :                         IVAL = SQL_POS_DELETE | SQL_POS_POSITION | SQL_POS_UPDATE;
    5989             :                 else
    5990           0 :                         IVAL = 0;
    5991             :                 break;
    5992           0 :         case SQL_POSITIONED_STATEMENTS:
    5993             :                 /* TODO cursors SQL_PS_SELECT_FOR_UPDATE */
    5994           0 :                 IVAL = SQL_PS_POSITIONED_DELETE | SQL_PS_POSITIONED_UPDATE;
    5995           0 :                 break;
    5996           0 :         case SQL_PROCEDURE_TERM:
    5997           0 :                 p = "stored procedure";
    5998           0 :                 break;
    5999             :         case SQL_PROCEDURES:
    6000             :                 p = "Y";
    6001             :                 break;
    6002           0 :         case SQL_QUOTED_IDENTIFIER_CASE:
    6003             :                 /* TODO usually insensitive */
    6004           0 :                 USIVAL = SQL_IC_MIXED;
    6005           0 :                 break;
    6006           0 :         case SQL_ROW_UPDATES:
    6007           0 :                 p = "N";
    6008           0 :                 break;
    6009             : #if (ODBCVER >= 0x0300)
    6010           0 :         case SQL_SCHEMA_TERM:
    6011           0 :                 p = "owner";
    6012           0 :                 break;
    6013           0 :         case SQL_SCHEMA_USAGE:
    6014           0 :                 UIVAL = SQL_OU_DML_STATEMENTS | SQL_OU_INDEX_DEFINITION | SQL_OU_PRIVILEGE_DEFINITION | SQL_OU_PROCEDURE_INVOCATION
    6015             :                         | SQL_OU_TABLE_DEFINITION;
    6016           0 :                 break;
    6017             : #endif /* ODBCVER >= 0x0300 */
    6018           0 :         case SQL_SCROLL_CONCURRENCY:
    6019           0 :                 if (dbc->cursor_support)
    6020             :                         /* TODO cursors test them, Sybase support all ?  */
    6021           0 :                         IVAL = SQL_SCCO_LOCK | SQL_SCCO_OPT_ROWVER | SQL_SCCO_OPT_VALUES | SQL_SCCO_READ_ONLY;
    6022             :                 else
    6023           0 :                         IVAL = SQL_SCCO_READ_ONLY;
    6024             :                 break;
    6025           0 :         case SQL_SCROLL_OPTIONS:
    6026           0 :                 if (dbc->cursor_support)
    6027             :                         /* TODO cursors test them, Sybase support all ?? */
    6028           0 :                         UIVAL = SQL_SO_DYNAMIC | SQL_SO_FORWARD_ONLY | SQL_SO_KEYSET_DRIVEN | SQL_SO_STATIC;
    6029             :                 else
    6030           0 :                         UIVAL = SQL_SO_FORWARD_ONLY | SQL_SO_STATIC;
    6031             :                 break;
    6032           0 :         case SQL_SEARCH_PATTERN_ESCAPE:
    6033           0 :                 p = "\\";
    6034           0 :                 break;
    6035           0 :         case SQL_SERVER_NAME:
    6036           0 :                 p = dbc->tds_socket->conn->server;
    6037           0 :                 break;
    6038           0 :         case SQL_SPECIAL_CHARACTERS:
    6039             :                 /* TODO others ?? */
    6040           0 :                 p = "\'\"[]{}";
    6041           0 :                 break;
    6042             : #if (ODBCVER >= 0x0300)
    6043           0 :         case SQL_SQL_CONFORMANCE:
    6044           0 :                 UIVAL = SQL_SC_SQL92_ENTRY;
    6045           0 :                 break;
    6046           0 :         case SQL_SQL92_DATETIME_FUNCTIONS:
    6047             :         case SQL_SQL92_FOREIGN_KEY_DELETE_RULE:
    6048             :         case SQL_SQL92_FOREIGN_KEY_UPDATE_RULE:
    6049           0 :                 UIVAL = 0;
    6050           0 :                 break;
    6051           0 :         case SQL_SQL92_GRANT:
    6052           0 :                 UIVAL = SQL_SG_WITH_GRANT_OPTION;
    6053           0 :                 break;
    6054           0 :         case SQL_SQL92_NUMERIC_VALUE_FUNCTIONS:
    6055           0 :                 UIVAL = 0;
    6056           0 :                 break;
    6057           0 :         case SQL_SQL92_PREDICATES:
    6058             :                 /* TODO Sybase ?? */
    6059           0 :                 UIVAL = SQL_SP_EXISTS | SQL_SP_ISNOTNULL | SQL_SP_ISNULL;
    6060           0 :                 break;
    6061           0 :         case SQL_SQL92_RELATIONAL_JOIN_OPERATORS:
    6062             :                 /* TODO Sybase ?? */
    6063           0 :                 UIVAL = SQL_SRJO_CROSS_JOIN | SQL_SRJO_FULL_OUTER_JOIN | SQL_SRJO_INNER_JOIN | SQL_SRJO_LEFT_OUTER_JOIN |
    6064             :                         SQL_SRJO_RIGHT_OUTER_JOIN | SQL_SRJO_UNION_JOIN;
    6065           0 :                 break;
    6066           0 :         case SQL_SQL92_REVOKE:
    6067           0 :                 UIVAL = SQL_SR_GRANT_OPTION_FOR;
    6068           0 :                 break;
    6069           0 :         case SQL_SQL92_ROW_VALUE_CONSTRUCTOR:
    6070           0 :                 UIVAL = SQL_SRVC_DEFAULT | SQL_SRVC_NULL | SQL_SRVC_ROW_SUBQUERY | SQL_SRVC_VALUE_EXPRESSION;
    6071           0 :                 break;
    6072           0 :         case SQL_SQL92_STRING_FUNCTIONS:
    6073           0 :                 UIVAL = SQL_SSF_LOWER | SQL_SSF_UPPER;
    6074           0 :                 break;
    6075           0 :         case SQL_SQL92_VALUE_EXPRESSIONS:
    6076             :                 /* TODO Sybase ? CAST supported ? */
    6077           0 :                 UIVAL = SQL_SVE_CASE | SQL_SVE_CAST | SQL_SVE_COALESCE | SQL_SVE_NULLIF;
    6078           0 :                 break;
    6079           0 :         case SQL_STANDARD_CLI_CONFORMANCE:
    6080           0 :                 UIVAL = SQL_SCC_ISO92_CLI;
    6081           0 :                 break;
    6082           0 :         case SQL_STATIC_SENSITIVITY:
    6083           0 :                 IVAL = 0;
    6084           0 :                 break;
    6085           0 :         case SQL_STATIC_CURSOR_ATTRIBUTES1:
    6086           0 :                 if (dbc->cursor_support)
    6087             :                         /* TODO cursors SQL_CA1_BOOKMARK SQL_CA1_BULK_FETCH_BY_BOOKMARK SQL_CA1_POS_REFRESH */
    6088           0 :                         UIVAL = SQL_CA1_ABSOLUTE | SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_NEXT | SQL_CA1_POS_POSITION | SQL_CA1_RELATIVE;
    6089             :                 else
    6090           0 :                         UIVAL = 0;
    6091             :                 break;
    6092           0 :         case SQL_STATIC_CURSOR_ATTRIBUTES2:
    6093             :                 /* TODO cursors */
    6094           0 :                 UIVAL = 0;
    6095           0 :                 break;
    6096             : #endif /* ODBCVER >= 0x0300 */
    6097           0 :         case SQL_STRING_FUNCTIONS:
    6098           0 :                 UIVAL = (SQL_FN_STR_ASCII | SQL_FN_STR_BIT_LENGTH | SQL_FN_STR_CHAR | SQL_FN_STR_CONCAT | SQL_FN_STR_DIFFERENCE |
    6099             :                          SQL_FN_STR_INSERT | SQL_FN_STR_LCASE | SQL_FN_STR_LEFT | SQL_FN_STR_LENGTH | SQL_FN_STR_LOCATE_2 |
    6100             :                          SQL_FN_STR_LTRIM | SQL_FN_STR_OCTET_LENGTH | SQL_FN_STR_REPEAT | SQL_FN_STR_RIGHT | SQL_FN_STR_RTRIM |
    6101           0 :                          SQL_FN_STR_SOUNDEX | SQL_FN_STR_SPACE | SQL_FN_STR_SUBSTRING | SQL_FN_STR_UCASE) & mssql7plus_mask;
    6102           0 :                 break;
    6103           0 :         case SQL_SUBQUERIES:
    6104           0 :                 UIVAL = SQL_SQ_COMPARISON | SQL_SQ_CORRELATED_SUBQUERIES | SQL_SQ_EXISTS | SQL_SQ_IN | SQL_SQ_QUANTIFIED;
    6105           0 :                 break;
    6106           0 :         case SQL_SYSTEM_FUNCTIONS:
    6107           0 :                 UIVAL = SQL_FN_SYS_DBNAME | SQL_FN_SYS_IFNULL | SQL_FN_SYS_USERNAME;
    6108           0 :                 break;
    6109           0 :         case SQL_TABLE_TERM:
    6110           0 :                 p = "table";
    6111           0 :                 break;
    6112           0 :         case SQL_TIMEDATE_ADD_INTERVALS:
    6113           0 :                 UIVAL = (SQL_FN_TSI_DAY | SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_HOUR | SQL_FN_TSI_MINUTE | SQL_FN_TSI_MONTH |
    6114           0 :                          SQL_FN_TSI_QUARTER | SQL_FN_TSI_SECOND | SQL_FN_TSI_WEEK | SQL_FN_TSI_YEAR) & mssql7plus_mask;
    6115           0 :                 break;
    6116           0 :         case SQL_TIMEDATE_DIFF_INTERVALS:
    6117           0 :                 UIVAL = (SQL_FN_TSI_DAY | SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_HOUR | SQL_FN_TSI_MINUTE | SQL_FN_TSI_MONTH |
    6118           0 :                          SQL_FN_TSI_QUARTER | SQL_FN_TSI_SECOND | SQL_FN_TSI_WEEK | SQL_FN_TSI_YEAR) & mssql7plus_mask;
    6119           0 :                 break;
    6120           0 :         case SQL_TIMEDATE_FUNCTIONS:
    6121           0 :                 UIVAL = (SQL_FN_TD_CURDATE | SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | SQL_FN_TD_CURRENT_TIMESTAMP |
    6122             :                          SQL_FN_TD_CURTIME | SQL_FN_TD_DAYNAME | SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_DAYOFWEEK | SQL_FN_TD_DAYOFYEAR |
    6123             :                          SQL_FN_TD_EXTRACT | SQL_FN_TD_HOUR | SQL_FN_TD_MINUTE | SQL_FN_TD_MONTH | SQL_FN_TD_MONTHNAME |
    6124             :                          SQL_FN_TD_NOW | SQL_FN_TD_QUARTER | SQL_FN_TD_SECOND | SQL_FN_TD_TIMESTAMPADD | SQL_FN_TD_TIMESTAMPDIFF |
    6125           0 :                          SQL_FN_TD_WEEK | SQL_FN_TD_YEAR) & mssql7plus_mask;
    6126           0 :                 break;
    6127           0 :         case SQL_TXN_CAPABLE:
    6128             :                 /* transaction for DML and DDL */
    6129           0 :                 SIVAL = SQL_TC_ALL;
    6130           0 :                 break;
    6131           0 :         case SQL_TXN_ISOLATION_OPTION:
    6132           0 :                 UIVAL = SQL_TXN_READ_COMMITTED | SQL_TXN_READ_UNCOMMITTED | SQL_TXN_REPEATABLE_READ | SQL_TXN_SERIALIZABLE;
    6133           0 :                 break;
    6134           0 :         case SQL_UNION:
    6135           0 :                 UIVAL = SQL_U_UNION | SQL_U_UNION_ALL;
    6136           0 :                 break;
    6137             :                 /* TODO finish */
    6138           0 :         case SQL_USER_NAME:
    6139             :                 /* TODO this is not correct username */
    6140             :                 /* p = tds_dstr_cstr(&dbc->tds_login->user_name); */
    6141             :                 /* make OpenOffice happy :) */
    6142           0 :                 p = "";
    6143           0 :                 break;
    6144           0 :         case SQL_XOPEN_CLI_YEAR:
    6145             :                 /* TODO check specifications */
    6146           0 :                 p = "1995";
    6147           0 :                 break;
    6148         112 :         case SQL_INFO_FREETDS_TDS_VERSION:
    6149         112 :                 if (!dbc->tds_socket)
    6150             :                         return SQL_ERROR;
    6151         112 :                 UIVAL = TDS_MAJOR(dbc->tds_socket->conn) << 16 | TDS_MINOR(dbc->tds_socket->conn);
    6152         112 :                 break;
    6153          80 :         case SQL_INFO_FREETDS_SOCKET:
    6154          80 :                 if (IS_TDSDEAD(dbc->tds_socket))
    6155             :                         return SQL_ERROR;
    6156          80 :                 ULVAL = dbc->tds_socket->conn->s;
    6157          80 :                 break;
    6158           0 :         default:
    6159           0 :                 odbc_log_unimplemented_type("SQLGetInfo", fInfoType);
    6160           0 :                 odbc_errs_add(&dbc->errs, "HY092", "Option not supported");
    6161           0 :                 return SQL_ERROR;
    6162             :         }
    6163             : 
    6164             :         /* char data */
    6165         892 :         if (p) {
    6166         680 :                 return odbc_set_string_oct(dbc, rgbInfoValue, cbInfoValueMax, pcbInfoValue, p, -1);
    6167             :         } else {
    6168         212 :                 if (out_len > 0 && pcbInfoValue)
    6169         192 :                         *pcbInfoValue = out_len;
    6170             :         }
    6171             : 
    6172             :         return SQL_SUCCESS;
    6173             : #undef SIVAL
    6174             : #undef USIVAL
    6175             : #undef IVAL
    6176             : #undef UIVAL
    6177             : }
    6178             : 
    6179             : SQLRETURN ODBC_PUBLIC ODBC_API
    6180             : SQLGetInfo(SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax,
    6181             :            SQLSMALLINT FAR * pcbInfoValue)
    6182             : {
    6183         460 :         ODBC_ENTER_HDBC;
    6184             : 
    6185         460 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetInfo(%p, %d, %p, %d, %p)\n",
    6186             :                         hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
    6187             : 
    6188         460 :         ODBC_EXIT(dbc, odbc_SQLGetInfo(dbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue _wide0));
    6189             : }
    6190             : 
    6191             : #ifdef ENABLE_ODBC_WIDE
    6192             : SQLRETURN ODBC_PUBLIC ODBC_API
    6193             : SQLGetInfoW(SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax,
    6194             :            SQLSMALLINT FAR * pcbInfoValue)
    6195             : {
    6196         432 :         ODBC_ENTER_HDBC;
    6197             : 
    6198         432 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetInfoW(%p, %d, %p, %d, %p)\n",
    6199             :                         hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
    6200             : 
    6201         432 :         ODBC_EXIT(dbc, odbc_SQLGetInfo(dbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue, 1));
    6202             : }
    6203             : #endif
    6204             : 
    6205             : static void
    6206             : tds_ascii_strupr(char *s)
    6207             : {
    6208      168490 :         for (; *s; ++s)
    6209      168490 :                 if ('a' <= *s && *s <= 'z')
    6210       35866 :                         *s = *s & (~0x20);
    6211             : }
    6212             : 
    6213             : static void
    6214         336 : odbc_upper_column_names(TDS_STMT * stmt)
    6215             : {
    6216             : #if ENABLE_EXTRA_CHECKS
    6217             :         TDSSOCKET *tds;
    6218             : #endif
    6219             :         int icol;
    6220             :         TDS_DESC *ird;
    6221             : 
    6222         336 :         IRD_CHECK;
    6223             : 
    6224             : #if ENABLE_EXTRA_CHECKS
    6225         336 :         tds = stmt->dbc->tds_socket;
    6226         336 :         if (tds && tds->current_results) {
    6227             :                 TDSRESULTINFO *const resinfo = tds->current_results;
    6228             : 
    6229        4684 :                 for (icol = 0; icol < resinfo->num_cols; ++icol) {
    6230        4684 :                         TDSCOLUMN *colinfo = resinfo->columns[icol];
    6231             : 
    6232             :                         /* upper case */
    6233       14052 :                         tds_ascii_strupr(tds_dstr_buf(&colinfo->column_name));
    6234             :                 }
    6235             :         }
    6236             : #endif
    6237             : 
    6238         336 :         ird = stmt->ird;
    6239        5356 :         for (icol = ird->header.sql_desc_count; --icol >= 0;) {
    6240        4684 :                 struct _drecord *drec = &ird->records[icol];
    6241             : 
    6242             :                 /* upper case */
    6243       14052 :                 tds_ascii_strupr(tds_dstr_buf(&drec->sql_desc_label));
    6244        9368 :                 tds_ascii_strupr(tds_dstr_buf(&drec->sql_desc_name));
    6245             :         }
    6246         336 : }
    6247             : 
    6248             : /**
    6249             :  * Change sql datatype to a specific version
    6250             :  * \param sql_type sql data type to change (any type)
    6251             :  * \param version  ODBC version to change to, 2 for ODBC 2, 3 for ODBC 3, 0 swap
    6252             :  */
    6253             : static SQLSMALLINT
    6254             : odbc_swap_datetime_sql_type(SQLSMALLINT sql_type, int version)
    6255             : {
    6256         248 :         switch (sql_type) {
    6257             :         case SQL_TYPE_TIMESTAMP:
    6258             :                 if (version != 3)
    6259           2 :                         sql_type = SQL_TIMESTAMP;
    6260             :                 break;
    6261             :         case SQL_TIMESTAMP:
    6262             :                 if (version != 2)
    6263          18 :                         sql_type = SQL_TYPE_TIMESTAMP;
    6264             :                 break;
    6265             :         case SQL_TYPE_DATE:
    6266             :                 if (version != 3)
    6267           2 :                         sql_type = SQL_DATE;
    6268             :                 break;
    6269             :         case SQL_DATE:
    6270             :                 if (version != 2)
    6271           6 :                         sql_type = SQL_TYPE_DATE;
    6272             :                 break;
    6273             :         case SQL_TYPE_TIME:
    6274             :                 if (version != 3)
    6275           2 :                         sql_type = SQL_TIME;
    6276             :                 break;
    6277             :         case SQL_TIME:
    6278             :                 if (version != 2)
    6279           6 :                         sql_type = SQL_TYPE_TIME;
    6280             :                 break;
    6281             :         }
    6282             :         return sql_type;
    6283             : }
    6284             : 
    6285             : SQLRETURN ODBC_PUBLIC ODBC_API
    6286             : SQLGetTypeInfo(SQLHSTMT hstmt, SQLSMALLINT fSqlType)
    6287             : {
    6288             :         SQLRETURN res;
    6289             :         TDSSOCKET *tds;
    6290             :         TDS_INT result_type;
    6291             :         TDS_INT compute_id;
    6292         144 :         int varchar_pos = -1, n;
    6293             :         static const char sql_templ_default[] = "sp_datatype_info %d";
    6294         144 :         const char *sql_templ = sql_templ_default;
    6295             :         char sql[sizeof(sql_templ_default) + 36];
    6296             :         int odbc3;
    6297             : 
    6298         144 :         ODBC_ENTER_HSTMT;
    6299             : 
    6300         144 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetTypeInfo(%p, %d)\n", hstmt, fSqlType);
    6301             : 
    6302         144 :         tds = stmt->dbc->tds_socket;
    6303         144 :         odbc3 = (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3);
    6304             : 
    6305         144 :         if (IS_TDS73_PLUS(tds->conn))
    6306             :                 sql_templ = "sp_datatype_info_100 %d";
    6307          88 :         else if (IS_TDS72_PLUS(tds->conn))
    6308           0 :                 sql_templ = "sp_datatype_info_90 %d";
    6309             : 
    6310             :         /* For MSSQL6.5 and Sybase 11.9 sp_datatype_info work */
    6311             :         /* TODO what about early Sybase products ? */
    6312             :         /* TODO Does Sybase return all ODBC3 columns? Add them if not */
    6313             :         /* TODO ODBC3 convert type to ODBC version 2 (date) */
    6314         144 :         if (odbc3) {
    6315          72 :                 if (TDS_IS_SYBASE(tds)) {
    6316          16 :                         sprintf(sql, sql_templ, odbc_swap_datetime_sql_type(fSqlType, 0));
    6317          16 :                         stmt->special_row = ODBC_SPECIAL_GETTYPEINFO;
    6318             :                 } else {
    6319          56 :                         sprintf(sql, sql_templ, fSqlType);
    6320          56 :                         strcat(sql, ",3");
    6321             :                 }
    6322             :         } else {
    6323             :                 /* MS ODBC translate SQL_TIMESTAMP to SQL_TYPE_TIMESTAMP even for ODBC 2 apps
    6324             :                  * other DM just pass value straight.
    6325             :                  * Convert always to version 2 to make version 2 datatype works with all DMs
    6326             :                  */
    6327          72 :                 sprintf(sql, sql_templ, odbc_swap_datetime_sql_type(fSqlType, 2));
    6328             :         }
    6329         144 :         if (SQL_SUCCESS != odbc_set_stmt_query(stmt, (ODBC_CHAR*) sql, strlen(sql) _wide0))
    6330           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    6331             : 
    6332         148 :       redo:
    6333         148 :         res = odbc_SQLExecute(stmt);
    6334             : 
    6335         148 :         odbc_upper_column_names(stmt);
    6336         148 :         if (odbc3) {
    6337          74 :                 odbc_col_setname(stmt, 3, "COLUMN_SIZE");
    6338          74 :                 odbc_col_setname(stmt, 11, "FIXED_PREC_SCALE");
    6339          74 :                 odbc_col_setname(stmt, 12, "AUTO_UNIQUE_VALUE");
    6340             :         }
    6341             : 
    6342             :         /* workaround for a mispelled column name in Sybase */
    6343         148 :         if (TDS_IS_SYBASE(stmt->dbc->tds_socket) && !odbc3)
    6344          18 :                 odbc_col_setname(stmt, 3, "PRECISION");
    6345             : 
    6346         148 :         if (TDS_IS_MSSQL(stmt->dbc->tds_socket) || fSqlType != SQL_VARCHAR || res != SQL_SUCCESS)
    6347         140 :                 ODBC_EXIT(stmt, res);
    6348             : 
    6349             :         /*
    6350             :          * Sybase return first nvarchar for char... and without length !!!
    6351             :          * Some program use first entry so we discard all entry before varchar
    6352             :          */
    6353             :         n = 0;
    6354          36 :         while (tds->current_results) {
    6355             :                 TDSRESULTINFO *resinfo;
    6356             :                 TDSCOLUMN *colinfo;
    6357             :                 char *name;
    6358             : 
    6359             :                 /* if next is varchar leave next for SQLFetch */
    6360          36 :                 if (n == (varchar_pos - 1))
    6361             :                         break;
    6362             : 
    6363          32 :                 switch (tds_process_tokens(stmt->dbc->tds_socket, &result_type, &compute_id, TDS_STOPAT_ROWFMT|TDS_RETURN_ROW)) {
    6364          28 :                 case TDS_SUCCESS:
    6365          28 :                         if (result_type == TDS_ROW_RESULT)
    6366             :                                 break;
    6367             :                 case TDS_NO_MORE_RESULTS:
    6368             :                         /* discard other tokens */
    6369           4 :                         tds_process_simple_query(tds);
    6370           4 :                         if (n >= varchar_pos && varchar_pos > 0)
    6371             :                                 goto redo;
    6372             :                         break;
    6373           0 :                 case TDS_CANCELLED:
    6374           0 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
    6375           0 :                         res = SQL_ERROR;
    6376           0 :                         break;
    6377             :                 }
    6378          28 :                 if (!tds->current_results)
    6379             :                         break;
    6380          28 :                 ++n;
    6381             : 
    6382          28 :                 resinfo = tds->current_results;
    6383          28 :                 colinfo = resinfo->columns[0];
    6384          28 :                 name = (char *) colinfo->column_data;
    6385          28 :                 if (is_blob_col(colinfo))
    6386           0 :                         name = (char*) ((TDSBLOB *) name)->textvalue;
    6387             :                 /* skip nvarchar and sysname */
    6388          28 :                 if (colinfo->column_cur_size == 7 && memcmp("varchar", name, 7) == 0) {
    6389           4 :                         varchar_pos = n;
    6390             :                 }
    6391             :         }
    6392           4 :         ODBC_EXIT(stmt, res);
    6393             : }
    6394             : 
    6395             : #ifdef ENABLE_ODBC_WIDE
    6396             : SQLRETURN ODBC_PUBLIC ODBC_API
    6397             : SQLGetTypeInfoW(SQLHSTMT hstmt, SQLSMALLINT fSqlType)
    6398             : {
    6399          72 :         return SQLGetTypeInfo(hstmt, fSqlType);
    6400             : }
    6401             : #endif
    6402             : 
    6403             : static SQLRETURN
    6404         608 : odbc_SQLParamData(SQLHSTMT hstmt, SQLPOINTER FAR * prgbValue)
    6405             : {
    6406         608 :         ODBC_ENTER_HSTMT;
    6407             : 
    6408         608 :         tdsdump_log(TDS_DBG_FUNC, "SQLParamData(%p, %p) [param_num %d, param_data_called = %d]\n",
    6409           0 :                                         hstmt, prgbValue, stmt->param_num, stmt->param_data_called);
    6410             : 
    6411         608 :         if (stmt->params && (unsigned int) stmt->param_num <= stmt->param_count) {
    6412             :                 SQLRETURN res;
    6413             : 
    6414         516 :                 if (stmt->param_num <= 0 || stmt->param_num > stmt->apd->header.sql_desc_count) {
    6415           0 :                         tdsdump_log(TDS_DBG_FUNC, "SQLParamData: logic_error: parameter out of bounds: 0 <= %d < %d\n",
    6416           0 :                                                    stmt->param_num, stmt->apd->header.sql_desc_count);
    6417           0 :                         ODBC_EXIT(stmt, SQL_ERROR);
    6418             :                 }
    6419             : 
    6420             :                 /*
    6421             :                  * TODO compute output value with this formula:
    6422             :                  * Bound Address + Binding Offset + ((Row Number - 1) x Element Size)
    6423             :                  * (see SQLParamData documentation)
    6424             :                  * This is needed for updates using SQLBulkOperation (not currently supported)
    6425             :                  */
    6426         516 :                 if (!stmt->param_data_called) {
    6427         184 :                         stmt->param_data_called = 1;
    6428         184 :                         *prgbValue = stmt->apd->records[stmt->param_num - 1].sql_desc_data_ptr;
    6429         184 :                         ODBC_EXIT(stmt, SQL_NEED_DATA);
    6430             :                 }
    6431         332 :                 ++stmt->param_num;
    6432         332 :                 switch (res = parse_prepared_query(stmt, true)) {
    6433         148 :                 case SQL_NEED_DATA:
    6434         148 :                         *prgbValue = stmt->apd->records[stmt->param_num - 1].sql_desc_data_ptr;
    6435         148 :                         ODBC_EXIT(stmt, SQL_NEED_DATA);
    6436         184 :                 case SQL_SUCCESS:
    6437         184 :                         ODBC_EXIT(stmt, odbc_SQLExecute(stmt));
    6438             :                 }
    6439           0 :                 ODBC_EXIT(stmt, res);
    6440             :         }
    6441             : 
    6442          92 :         odbc_errs_add(&stmt->errs, "HY010", NULL);
    6443          92 :         ODBC_EXIT_(stmt);
    6444             : }
    6445             : 
    6446             : SQLRETURN ODBC_PUBLIC ODBC_API
    6447             : SQLParamData(SQLHSTMT hstmt, SQLPOINTER FAR * prgbValue)
    6448             : {
    6449             :         ODBC_PRRET_BUF;
    6450         608 :         SQLRETURN ret = odbc_SQLParamData(hstmt, prgbValue);
    6451             : 
    6452         608 :         tdsdump_log(TDS_DBG_FUNC, "SQLParamData returns %s\n", odbc_prret(ret));
    6453             : 
    6454         608 :         return ret;
    6455             : }
    6456             : 
    6457             : SQLRETURN ODBC_PUBLIC ODBC_API
    6458             : SQLPutData(SQLHSTMT hstmt, SQLPOINTER rgbValue, SQLLEN cbValue)
    6459             : {
    6460             :         ODBC_PRRET_BUF;
    6461         832 :         ODBC_ENTER_HSTMT;
    6462             : 
    6463         832 :         tdsdump_log(TDS_DBG_FUNC, "SQLPutData(%p, %p, %i)\n", hstmt, rgbValue, (int)cbValue);
    6464             : 
    6465         832 :         if (stmt->param_data_called) {
    6466             :                 SQLRETURN ret;
    6467         832 :                 const TDSCOLUMN *curcol = stmt->params->columns[stmt->param_num - (stmt->prepared_query_is_func ? 2 : 1)];
    6468             :                 /* TODO do some more tests before setting this flag */
    6469         832 :                 stmt->param_data_called = 1;
    6470         832 :                 ret = continue_parse_prepared_query(stmt, rgbValue, cbValue);
    6471         832 :                 tdsdump_log(TDS_DBG_FUNC, "SQLPutData returns %s, %d bytes left\n",
    6472           0 :                                           odbc_prret(ret), curcol->column_size - curcol->column_cur_size);
    6473         832 :                 ODBC_EXIT(stmt, ret);
    6474             :         }
    6475             : 
    6476           0 :         odbc_errs_add(&stmt->errs, "HY010", NULL);
    6477           0 :         ODBC_EXIT_(stmt);
    6478             : }
    6479             : 
    6480             : 
    6481        1852 : ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,ValuePtr), P(SQLINTEGER,StringLength) WIDE))
    6482             : {
    6483        1852 :         SQLULEN u_value = (SQLULEN) (TDS_INTPTR) ValuePtr;
    6484             : 
    6485        1852 :         ODBC_ENTER_HDBC;
    6486             : 
    6487        1852 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLSetConnectAttr(%p, %d, %p, %d)\n", hdbc, (int)Attribute, ValuePtr, (int)StringLength);
    6488             : 
    6489        1852 :         switch (Attribute) {
    6490         218 :         case SQL_ATTR_AUTOCOMMIT:
    6491             :                 /* spinellia@acm.org */
    6492         218 :                 change_autocommit(dbc, (int) u_value);
    6493         218 :                 break;
    6494          10 :         case SQL_ATTR_CONNECTION_TIMEOUT:
    6495          10 :                 dbc->attr.connection_timeout = (SQLUINTEGER) u_value;
    6496          10 :                 break;
    6497           0 :         case SQL_ATTR_ACCESS_MODE:
    6498           0 :                 dbc->attr.access_mode = (SQLUINTEGER) u_value;
    6499           0 :                 break;
    6500          80 :         case SQL_ATTR_CURRENT_CATALOG:
    6501          80 :                 if (!IS_VALID_LEN(StringLength)) {
    6502           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6503           0 :                         break;
    6504             :                 }
    6505             :                 {
    6506          80 :                         DSTR s = DSTR_INITIALIZER;
    6507             : 
    6508          80 :                         if (!odbc_dstr_copy_oct(dbc, &s, StringLength, (ODBC_CHAR*) ValuePtr)) {
    6509           0 :                                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    6510           0 :                                 break;
    6511             :                         }
    6512         240 :                         change_database(dbc, tds_dstr_cstr(&s), tds_dstr_len(&s));
    6513          80 :                         tds_dstr_free(&s);
    6514             :                 }
    6515          80 :                 break;
    6516           0 :         case SQL_ATTR_CURSOR_TYPE:
    6517           0 :                 if (dbc->cursor_support)
    6518           0 :                         dbc->attr.cursor_type = (SQLUINTEGER) u_value;
    6519             :                 break;
    6520          10 :         case SQL_ATTR_LOGIN_TIMEOUT:
    6521          10 :                 dbc->attr.login_timeout = (SQLUINTEGER) u_value;
    6522          10 :                 break;
    6523           0 :         case SQL_ATTR_ODBC_CURSORS:
    6524             :                 /* TODO cursors */
    6525           0 :                 dbc->attr.odbc_cursors = (SQLUINTEGER) u_value;
    6526           0 :                 break;
    6527           0 :         case SQL_ATTR_PACKET_SIZE:
    6528           0 :                 dbc->attr.packet_size = (SQLUINTEGER) u_value;
    6529           0 :                 break;
    6530           0 :         case SQL_ATTR_QUIET_MODE:
    6531           0 :                 dbc->attr.quite_mode = (SQLHWND) (TDS_INTPTR) ValuePtr;
    6532           0 :                 break;
    6533             : #ifdef TDS_NO_DM
    6534           0 :         case SQL_ATTR_TRACE:
    6535           0 :                 dbc->attr.trace = (SQLUINTEGER) u_value;
    6536           0 :                 break;
    6537           0 :         case SQL_ATTR_TRACEFILE:
    6538           0 :                 if (!IS_VALID_LEN(StringLength)) {
    6539           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6540           0 :                         break;
    6541             :                 }
    6542           0 :                 if (!odbc_dstr_copy(dbc, &dbc->attr.tracefile, StringLength, (ODBC_CHAR *) ValuePtr))
    6543           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
    6544             :                 break;
    6545             : #endif
    6546         104 :         case SQL_ATTR_TXN_ISOLATION:
    6547         104 :                 if (u_value != dbc->attr.txn_isolation) {
    6548          92 :                         if (change_txn(dbc, (SQLUINTEGER) u_value) == SQL_SUCCESS)
    6549          72 :                                 dbc->attr.txn_isolation = (SQLUINTEGER)u_value;
    6550             :                 }
    6551             :                 break;
    6552         536 :         case SQL_COPT_SS_MARS_ENABLED:
    6553         536 :                 dbc->attr.mars_enabled = (SQLUINTEGER) u_value;
    6554         536 :                 break;
    6555           0 :         case SQL_ATTR_TRANSLATE_LIB:
    6556             :         case SQL_ATTR_TRANSLATE_OPTION:
    6557           0 :                 odbc_errs_add(&dbc->errs, "HYC00", NULL);
    6558           0 :                 break;
    6559           0 :         case SQL_COPT_SS_OLDPWD:
    6560           0 :                 if (!IS_VALID_LEN(StringLength)) {
    6561           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6562           0 :                         break;
    6563             :                 }
    6564           0 :                 if (!odbc_dstr_copy(dbc, &dbc->oldpwd, StringLength, (ODBC_CHAR *) ValuePtr))
    6565           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
    6566             :                 else
    6567           0 :                         dbc->use_oldpwd = 1;
    6568             :                 break;
    6569           0 :         case SQL_COPT_SS_ATTACHDBFILENAME:
    6570           0 :                 if (!IS_VALID_LEN(StringLength)) {
    6571           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6572           0 :                         break;
    6573             :                 }
    6574           0 :                 if (!odbc_dstr_copy(dbc, &dbc->db_filename, StringLength, (ODBC_CHAR *) ValuePtr))
    6575           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
    6576             :                 break;
    6577          10 :         case SQL_COPT_SS_BCP:
    6578          10 :                 dbc->attr.bulk_enabled = (SQLUINTEGER) u_value;
    6579          10 :                 break;
    6580          12 :         case SQL_COPT_TDSODBC_IMPL_BCP_INITA:
    6581          12 :                 if (!ValuePtr)
    6582           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6583             :                 else {
    6584          12 :                         const struct tdsodbc_impl_bcp_init_params *params = (const struct tdsodbc_impl_bcp_init_params*)ValuePtr;
    6585          24 :                         odbc_bcp_init(dbc, (const ODBC_CHAR *) params->tblname, (const ODBC_CHAR *) params->hfile,
    6586          12 :                                       (const ODBC_CHAR *) params->errfile, params->direction _wide0);
    6587             :                 }
    6588             :                 break;
    6589             : #ifdef ENABLE_ODBC_WIDE
    6590          12 :         case SQL_COPT_TDSODBC_IMPL_BCP_INITW:
    6591          12 :                 if (!ValuePtr)
    6592           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6593             :                 else {
    6594          12 :                         const struct tdsodbc_impl_bcp_init_params *params = (const struct tdsodbc_impl_bcp_init_params*)ValuePtr;
    6595          24 :                         odbc_bcp_init(dbc, (const ODBC_CHAR *) params->tblname, (const ODBC_CHAR *) params->hfile,
    6596          12 :                                       (const ODBC_CHAR *) params->errfile, params->direction, 1);
    6597             :                 }
    6598             :                 break;
    6599             : #endif
    6600           0 :         case SQL_COPT_TDSODBC_IMPL_BCP_CONTROL_OLD:
    6601           0 :                 if (!ValuePtr)
    6602           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6603             :                 else {
    6604           0 :                         const struct tdsodbc_impl_bcp_control_params *params =
    6605             :                                 (const struct tdsodbc_impl_bcp_control_params*)ValuePtr;
    6606           0 :                         const int field = params->field == BCPHINTS_OLD ? BCPHINTSA : params->field;
    6607           0 :                         odbc_bcp_control(dbc, field, params->value);
    6608             :                 }
    6609             :                 break;
    6610           4 :         case SQL_COPT_TDSODBC_IMPL_BCP_CONTROL:
    6611           4 :                 if (!ValuePtr)
    6612           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6613             :                 else {
    6614           4 :                         const struct tdsodbc_impl_bcp_control_params *params =
    6615             :                                 (const struct tdsodbc_impl_bcp_control_params*)ValuePtr;
    6616           4 :                         odbc_bcp_control(dbc, params->field, params->value);
    6617             :                 }
    6618             :                 break;
    6619           0 :         case SQL_COPT_TDSODBC_IMPL_BCP_COLPTR:
    6620           0 :                 if (!ValuePtr)
    6621           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6622             :                 else {
    6623           0 :                         const struct tdsodbc_impl_bcp_colptr_params *params =
    6624             :                                 (const struct tdsodbc_impl_bcp_colptr_params*)ValuePtr;
    6625           0 :                         odbc_bcp_colptr(dbc, params->colptr, params->table_column);
    6626             :                 }
    6627             :                 break;
    6628         204 :         case SQL_COPT_TDSODBC_IMPL_BCP_SENDROW:
    6629         204 :                 if (ValuePtr)
    6630           0 :                         odbc_errs_add(&dbc->errs, "HY000", NULL);
    6631             :                 else
    6632         204 :                         odbc_bcp_sendrow(dbc);
    6633             :                 break;
    6634          24 :         case SQL_COPT_TDSODBC_IMPL_BCP_BATCH:
    6635          24 :                 if (!ValuePtr)
    6636           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6637             :                 else {
    6638          24 :                         struct tdsodbc_impl_bcp_batch_params *params = (struct tdsodbc_impl_bcp_batch_params*)ValuePtr;
    6639          24 :                         params->rows = odbc_bcp_batch(dbc);
    6640             :                 }
    6641             :                 break;
    6642          24 :         case SQL_COPT_TDSODBC_IMPL_BCP_DONE:
    6643          24 :                 if (!ValuePtr)
    6644           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6645             :                 else {
    6646          24 :                         struct tdsodbc_impl_bcp_done_params *params = (struct tdsodbc_impl_bcp_done_params*)ValuePtr;
    6647          24 :                         params->rows = odbc_bcp_done(dbc);
    6648             :                 }
    6649             :                 break;
    6650         604 :         case SQL_COPT_TDSODBC_IMPL_BCP_BIND:
    6651         604 :                 if (!ValuePtr)
    6652           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6653             :                 else {
    6654         604 :                         const struct tdsodbc_impl_bcp_bind_params *params = (const struct tdsodbc_impl_bcp_bind_params*)ValuePtr;
    6655        1208 :                         odbc_bcp_bind(dbc, params->varaddr, params->prefixlen, params->varlen,
    6656         604 :                                       params->terminator, params->termlen, params->vartype, params->table_column);
    6657             :                 }
    6658             :                 break;
    6659           0 :         default:
    6660           0 :                 odbc_errs_add(&dbc->errs, "HY092", NULL);
    6661           0 :                 break;
    6662             :         }
    6663        1852 :         ODBC_EXIT_(dbc);
    6664             : }
    6665             : 
    6666             : SQLRETURN ODBC_PUBLIC ODBC_API
    6667             : SQLSetConnectOption(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLULEN vParam)
    6668             : {
    6669           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetConnectOption(%p, %d, %p)\n", hdbc, fOption, (SQLPOINTER) (TDS_INTPTR) vParam);
    6670             : 
    6671           0 :         return odbc_SQLSetConnectAttr(hdbc, (SQLINTEGER) fOption, (SQLPOINTER) (TDS_INTPTR) vParam, SQL_NTS _wide0);
    6672             : }
    6673             : 
    6674             : #ifdef ENABLE_ODBC_WIDE
    6675             : SQLRETURN ODBC_PUBLIC ODBC_API
    6676             : SQLSetConnectOptionW(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLULEN vParam)
    6677             : {
    6678           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetConnectOptionW(%p, %d, %p)\n", hdbc, fOption, (SQLPOINTER) (TDS_INTPTR) vParam);
    6679             : 
    6680           0 :         return odbc_SQLSetConnectAttr(hdbc, (SQLINTEGER) fOption, (SQLPOINTER) (TDS_INTPTR) vParam, SQL_NTS, 1);
    6681             : }
    6682             : #endif
    6683             : 
    6684             : static SQLRETURN
    6685        6512 : odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength WIDE)
    6686             : {
    6687        6512 :         SQLULEN ui = (SQLULEN) (TDS_INTPTR) ValuePtr;
    6688        6512 :         SQLUSMALLINT *usip = (SQLUSMALLINT *) ValuePtr;
    6689        6512 :         SQLLEN *lp = (SQLLEN *) ValuePtr;
    6690        6512 :         SQLULEN *ulp = (SQLULEN *) ValuePtr;
    6691             : 
    6692        6512 :         ODBC_ENTER_HSTMT;
    6693             : 
    6694        6512 :         tdsdump_log(TDS_DBG_FUNC, "odbc_SQLSetStmtAttr(%p, %d, %p, %d)\n", hstmt, (int)Attribute, ValuePtr, (int)StringLength);
    6695             : 
    6696             :         /* TODO - error checking and real functionality :-) */
    6697             :         /* TODO some setting set also other attribute, see documentation */
    6698        6512 :         switch (Attribute) {
    6699             :                 /* TODO check SQLFreeHandle on descriptor. Is possible to free an associated descriptor ? */
    6700           0 :         case SQL_ATTR_APP_PARAM_DESC:
    6701             :         case SQL_ATTR_APP_ROW_DESC:
    6702             :                 {
    6703             :                         TDS_DESC *orig;
    6704             :                         TDS_DESC **curr;
    6705           0 :                         TDS_DESC *val = (TDS_DESC *) ValuePtr;
    6706             : 
    6707           0 :                         if (Attribute == SQL_ATTR_APP_PARAM_DESC) {
    6708           0 :                                 orig = stmt->orig_apd;
    6709           0 :                                 curr = &stmt->apd;
    6710             :                         } else {
    6711           0 :                                 orig = stmt->orig_ard;
    6712           0 :                                 curr = &stmt->ard;
    6713             :                         }
    6714             :                         /* if ValuePtr is NULL or original descriptor set original */
    6715           0 :                         if (!val || val == orig) {
    6716           0 :                                 *curr = orig;
    6717           0 :                                 break;
    6718             :                         }
    6719             : 
    6720             :                         /* must be allocated by user, not implicit ones */
    6721           0 :                         if (val->header.sql_desc_alloc_type != SQL_DESC_ALLOC_USER) {
    6722           0 :                                 odbc_errs_add(&stmt->errs, "HY017", NULL);
    6723           0 :                                 break;
    6724             :                         }
    6725             :                         /* TODO check HDESC (not associated, from DBC HY024) */
    6726           0 :                         *curr = val;
    6727             :                 }
    6728           0 :                 break;
    6729           0 :         case SQL_ATTR_ASYNC_ENABLE:
    6730           0 :                 if (stmt->attr.async_enable != ui) {
    6731           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6732           0 :                         break;
    6733             :                 }
    6734           0 :                 stmt->attr.async_enable = (SQLUINTEGER) ui;
    6735           0 :                 break;
    6736         298 :         case SQL_ATTR_CONCURRENCY:
    6737         298 :                 if (stmt->attr.concurrency != ui && !stmt->dbc->cursor_support) {
    6738          26 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6739          26 :                         break;
    6740             :                 }
    6741             : 
    6742         272 :                 if (stmt->cursor) {
    6743           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6744           0 :                         break;
    6745             :                 }
    6746             : 
    6747         272 :                 switch (ui) {
    6748          72 :                 case SQL_CONCUR_READ_ONLY:
    6749          72 :                         stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    6750          72 :                         break;
    6751         200 :                 case SQL_CONCUR_LOCK:
    6752             :                 case SQL_CONCUR_ROWVER:
    6753             :                 case SQL_CONCUR_VALUES:
    6754         200 :                         stmt->attr.cursor_sensitivity = SQL_SENSITIVE;
    6755         200 :                         break;
    6756           0 :                 default:
    6757           0 :                         odbc_errs_add(&stmt->errs, "HY092", NULL);
    6758           0 :                         ODBC_EXIT_(stmt);
    6759             :                 }
    6760         272 :                 stmt->attr.concurrency = (SQLUINTEGER) ui;
    6761         272 :                 break;
    6762        2098 :         case SQL_ATTR_CURSOR_SCROLLABLE:
    6763        2098 :                 if (stmt->attr.cursor_scrollable != ui && !stmt->dbc->cursor_support) {
    6764           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6765           0 :                         break;
    6766             :                 }
    6767             : 
    6768        2098 :                 switch (ui) {
    6769        2050 :                 case SQL_SCROLLABLE:
    6770        2050 :                         stmt->attr.cursor_type = SQL_CURSOR_KEYSET_DRIVEN;
    6771        2050 :                         break;
    6772          48 :                 case SQL_NONSCROLLABLE:
    6773          48 :                         stmt->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    6774          48 :                         break;
    6775           0 :                 default:
    6776           0 :                         odbc_errs_add(&stmt->errs, "HY092", NULL);
    6777           0 :                         ODBC_EXIT_(stmt);
    6778             :                 }
    6779        2098 :                 stmt->attr.cursor_scrollable = (SQLUINTEGER) ui;
    6780        2098 :                 break;
    6781          72 :         case SQL_ATTR_CURSOR_SENSITIVITY:
    6782             :                 /* don't change anything */
    6783          72 :                 if (ui == SQL_UNSPECIFIED)
    6784             :                         break;
    6785          72 :                 if (stmt->attr.cursor_sensitivity != ui && !stmt->dbc->cursor_support) {
    6786           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6787           0 :                         break;
    6788             :                 }
    6789          72 :                 switch (ui) {
    6790           0 :                 case SQL_INSENSITIVE:
    6791           0 :                         stmt->attr.concurrency = SQL_CONCUR_READ_ONLY;
    6792           0 :                         stmt->attr.cursor_type = SQL_CURSOR_STATIC;
    6793           0 :                         break;
    6794          72 :                 case SQL_SENSITIVE:
    6795          72 :                         stmt->attr.concurrency = SQL_CONCUR_ROWVER;
    6796          72 :                         break;
    6797             :                 }
    6798          72 :                 stmt->attr.cursor_sensitivity = (SQLUINTEGER) ui;
    6799          72 :                 break;
    6800        2218 :         case SQL_ATTR_CURSOR_TYPE:
    6801        2218 :                 if (stmt->attr.cursor_type != ui && !stmt->dbc->cursor_support) {
    6802           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6803           0 :                         break;
    6804             :                 }
    6805             : 
    6806        2218 :                 if (stmt->cursor) {
    6807           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6808           0 :                         break;
    6809             :                 }
    6810             : 
    6811        2218 :                 switch (ui) {
    6812        2138 :                 case SQL_CURSOR_DYNAMIC:
    6813             :                 case SQL_CURSOR_KEYSET_DRIVEN:
    6814        2138 :                         if (stmt->attr.concurrency != SQL_CONCUR_READ_ONLY)
    6815          88 :                                 stmt->attr.cursor_sensitivity = SQL_SENSITIVE;
    6816        2138 :                         stmt->attr.cursor_scrollable = SQL_SCROLLABLE;
    6817        2138 :                         break;
    6818          80 :                 case SQL_CURSOR_STATIC:
    6819          80 :                         if (stmt->attr.concurrency != SQL_CONCUR_READ_ONLY)
    6820           0 :                                 stmt->attr.cursor_sensitivity = SQL_SENSITIVE;
    6821             :                         else
    6822          80 :                                 stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    6823          80 :                         stmt->attr.cursor_scrollable = SQL_SCROLLABLE;
    6824          80 :                         break;
    6825           0 :                 case SQL_CURSOR_FORWARD_ONLY:
    6826           0 :                         stmt->attr.cursor_scrollable = SQL_NONSCROLLABLE;
    6827           0 :                         break;
    6828           0 :                 default:
    6829           0 :                         odbc_errs_add(&stmt->errs, "HY092", NULL);
    6830           0 :                         ODBC_EXIT_(stmt);
    6831             :                 }
    6832        2218 :                 stmt->attr.cursor_type = (SQLUINTEGER) ui;
    6833        2218 :                 break;
    6834           0 :         case SQL_ATTR_ENABLE_AUTO_IPD:
    6835           0 :                 if (stmt->attr.enable_auto_ipd != ui) {
    6836           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6837           0 :                         break;
    6838             :                 }
    6839           0 :                 stmt->attr.enable_auto_ipd = (SQLUINTEGER) ui;
    6840           0 :                 break;
    6841           0 :         case SQL_ATTR_FETCH_BOOKMARK_PTR:
    6842           0 :                 stmt->attr.fetch_bookmark_ptr = ValuePtr;
    6843           0 :                 break;
    6844           0 :         case SQL_ATTR_IMP_ROW_DESC:
    6845             :         case SQL_ATTR_IMP_PARAM_DESC:
    6846           0 :                 odbc_errs_add(&stmt->errs, "HY017", NULL);
    6847           0 :                 break;
    6848             :                 /* TODO what's is this ??? */
    6849           0 :         case SQL_ATTR_KEYSET_SIZE:
    6850           0 :                 stmt->attr.keyset_size = ui;
    6851           0 :                 break;
    6852             :                 /* TODO max length of data returned. Use SQL TEXTSIZE or just truncate ?? */
    6853           0 :         case SQL_ATTR_MAX_LENGTH:
    6854           0 :                 if (stmt->attr.max_length != ui) {
    6855           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6856           0 :                         break;
    6857             :                 }
    6858           0 :                 stmt->attr.max_length = ui;
    6859           0 :                 break;
    6860             :                 /* TODO max row returned. Use SET ROWCOUNT */
    6861           0 :         case SQL_ATTR_MAX_ROWS:
    6862           0 :                 if (stmt->attr.max_rows != ui) {
    6863           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6864           0 :                         break;
    6865             :                 }
    6866           0 :                 stmt->attr.max_rows = ui;
    6867           0 :                 break;
    6868           0 :         case SQL_ATTR_METADATA_ID:
    6869           0 :                 stmt->attr.metadata_id = (SQLUINTEGER) ui;
    6870           0 :                 break;
    6871             :                 /* TODO use it !!! */
    6872           0 :         case SQL_ATTR_NOSCAN:
    6873           0 :                 stmt->attr.noscan = (SQLUINTEGER) ui;
    6874           0 :                 break;
    6875           0 :         case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
    6876           0 :                 stmt->apd->header.sql_desc_bind_offset_ptr = lp;
    6877           0 :                 break;
    6878         114 :         case SQL_ATTR_PARAM_BIND_TYPE:
    6879         114 :                 stmt->apd->header.sql_desc_bind_type = (SQLUINTEGER) ui;
    6880         114 :                 break;
    6881           0 :         case SQL_ATTR_PARAM_OPERATION_PTR:
    6882           0 :                 stmt->apd->header.sql_desc_array_status_ptr = usip;
    6883           0 :                 break;
    6884          82 :         case SQL_ATTR_PARAM_STATUS_PTR:
    6885          82 :                 stmt->ipd->header.sql_desc_array_status_ptr = usip;
    6886          82 :                 break;
    6887         154 :         case SQL_ATTR_PARAMS_PROCESSED_PTR:
    6888         154 :                 stmt->ipd->header.sql_desc_rows_processed_ptr = ulp;
    6889         154 :                 break;
    6890             :                 /* allow to exec procedure multiple time */
    6891         164 :         case SQL_ATTR_PARAMSET_SIZE:
    6892         164 :                 stmt->apd->header.sql_desc_array_size = ui;
    6893         164 :                 break;
    6894         136 :         case SQL_ATTR_QUERY_TIMEOUT:
    6895             :                 /* Microsoft allows a maximum value of 65534 */
    6896         136 :                 if (ui > 65534) {
    6897           8 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6898           8 :                         ui = 65534;
    6899             :                 }
    6900         136 :                 stmt->attr.query_timeout = (SQLUINTEGER) ui;
    6901         136 :                 break;
    6902             :                 /* retrieve data after positioning the cursor */
    6903           0 :         case SQL_ATTR_RETRIEVE_DATA:
    6904             :                 /* TODO cursors */
    6905           0 :                 if (stmt->attr.retrieve_data != ui) {
    6906           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6907           0 :                         break;
    6908             :                 }
    6909           0 :                 stmt->attr.retrieve_data = (SQLUINTEGER) ui;
    6910           0 :                 break;
    6911         292 :         case SQL_ATTR_ROW_ARRAY_SIZE:
    6912         292 :                 stmt->ard->header.sql_desc_array_size = ui;
    6913         292 :                 break;
    6914           0 :         case SQL_ATTR_ROW_BIND_OFFSET_PTR:
    6915             :                 /* TODO test what happen with column-wise and row-wise bindings and SQLGetData */
    6916           0 :                 stmt->ard->header.sql_desc_bind_offset_ptr = lp;
    6917           0 :                 break;
    6918             : #if SQL_BIND_TYPE != SQL_ATTR_ROW_BIND_TYPE
    6919             :         case SQL_BIND_TYPE:     /* although this is ODBC2 we must support this attribute */
    6920             : #endif
    6921         204 :         case SQL_ATTR_ROW_BIND_TYPE:
    6922         204 :                 stmt->ard->header.sql_desc_bind_type = (SQLUINTEGER) ui;
    6923         204 :                 break;
    6924           0 :         case SQL_ATTR_ROW_NUMBER:
    6925           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    6926           0 :                 break;
    6927           0 :         case SQL_ATTR_ROW_OPERATION_PTR:
    6928           0 :                 stmt->ard->header.sql_desc_array_status_ptr = usip;
    6929           0 :                 break;
    6930         264 :         case SQL_ATTR_ROW_STATUS_PTR:
    6931         264 :                 stmt->ird->header.sql_desc_array_status_ptr = usip;
    6932         264 :                 break;
    6933         292 :         case SQL_ATTR_ROWS_FETCHED_PTR:
    6934         292 :                 stmt->ird->header.sql_desc_rows_processed_ptr = ulp;
    6935         292 :                 break;
    6936           0 :         case SQL_ATTR_SIMULATE_CURSOR:
    6937             :                 /* TODO cursors */
    6938           0 :                 if (stmt->cursor) {
    6939           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6940           0 :                         break;
    6941             :                 }
    6942           0 :                 if (stmt->attr.simulate_cursor != ui) {
    6943           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6944           0 :                         break;
    6945             :                 }
    6946           0 :                 stmt->attr.simulate_cursor = (SQLUINTEGER) ui;
    6947           0 :                 break;
    6948           0 :         case SQL_ATTR_USE_BOOKMARKS:
    6949           0 :                 if (stmt->cursor) {
    6950           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6951           0 :                         break;
    6952             :                 }
    6953           0 :                 stmt->attr.use_bookmarks = (SQLUINTEGER) ui;
    6954           0 :                 break;
    6955          56 :         case SQL_ROWSET_SIZE:   /* although this is ODBC2 we must support this attribute */
    6956          56 :                 if (((TDS_INTPTR) ValuePtr) < 1) {
    6957          30 :                         odbc_errs_add(&stmt->errs, "HY024", NULL);
    6958          30 :                         break;
    6959             :                 }
    6960          26 :                 stmt->sql_rowset_size = ui;
    6961          26 :                 break;
    6962           4 :         case SQL_SOPT_SS_QUERYNOTIFICATION_TIMEOUT:
    6963           4 :                 if (ui < 1) {
    6964           0 :                         odbc_errs_add(&stmt->errs, "HY024", NULL);
    6965           0 :                         break;
    6966             :                 }
    6967           4 :                 stmt->attr.qn_timeout = (SQLUINTEGER) ui;
    6968           4 :                 break;
    6969           4 :         case SQL_SOPT_SS_QUERYNOTIFICATION_MSGTEXT:
    6970           4 :                 if (!IS_VALID_LEN(StringLength)) {
    6971           0 :                         odbc_errs_add(&stmt->errs, "HY090", NULL);
    6972           0 :                         break;
    6973             :                 }
    6974           4 :                 if (!odbc_dstr_copy_oct(stmt->dbc, &stmt->attr.qn_msgtext, StringLength, (ODBC_CHAR*) ValuePtr)) {
    6975           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    6976           0 :                         break;
    6977             :                 }
    6978             :                 break;
    6979           4 :         case SQL_SOPT_SS_QUERYNOTIFICATION_OPTIONS:
    6980           4 :                 if (!IS_VALID_LEN(StringLength)) {
    6981           0 :                         odbc_errs_add(&stmt->errs, "HY090", NULL);
    6982           0 :                         break;
    6983             :                 }
    6984           4 :                 if (!odbc_dstr_copy_oct(stmt->dbc, &stmt->attr.qn_options, StringLength, (ODBC_CHAR*) ValuePtr)) {
    6985           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    6986           0 :                         break;
    6987             :                 }
    6988             :                 break;
    6989          56 :         case SQL_SOPT_SS_PARAM_FOCUS:
    6990          56 :                 if (ui > 0 && (ui > stmt->apd->header.sql_desc_count
    6991          32 :                                || stmt->ipd->records[ui - 1].sql_desc_concise_type != SQL_SS_TABLE)) {
    6992           4 :                         odbc_errs_add(&stmt->errs, "IM020", NULL);
    6993           4 :                         break;
    6994             :                 }
    6995          52 :                 stmt->attr.param_focus = (SQLUINTEGER) ui;
    6996          52 :                 stmt->orig_apd->focus = (int) ui;
    6997          52 :                 stmt->ipd->focus = (int) ui;
    6998          52 :                 break;
    6999           0 :         default:
    7000           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    7001           0 :                 break;
    7002             :         }
    7003        6512 :         ODBC_EXIT_(stmt);
    7004             : }
    7005             : 
    7006             : #if (ODBCVER >= 0x0300)
    7007             : SQLRETURN ODBC_PUBLIC ODBC_API
    7008             : SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength)
    7009             : {
    7010        3232 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetStmtAttr(%p, %d, %p, %d)\n",
    7011             :                         hstmt, (int)Attribute, ValuePtr, (int)StringLength);
    7012             : 
    7013        3232 :         return odbc_SQLSetStmtAttr(hstmt, Attribute, ValuePtr, StringLength _wide0);
    7014             : }
    7015             : 
    7016             : #ifdef ENABLE_ODBC_WIDE
    7017             : SQLRETURN ODBC_PUBLIC ODBC_API
    7018             : SQLSetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength)
    7019             : {
    7020        3232 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetStmtAttr(%p, %d, %p, %d)\n",
    7021             :                         hstmt, (int)Attribute, ValuePtr, (int)StringLength);
    7022             : 
    7023        3232 :         return odbc_SQLSetStmtAttr(hstmt, Attribute, ValuePtr, StringLength, 1);
    7024             : }
    7025             : #endif
    7026             : #endif
    7027             : 
    7028             : SQLRETURN ODBC_PUBLIC ODBC_API
    7029             : SQLSetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLULEN vParam)
    7030             : {
    7031           8 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetStmtOption(%p, %u, %u)\n", hstmt, fOption, (unsigned)vParam);
    7032             : 
    7033             :         /* XXX: Lost precision */
    7034           8 :         return odbc_SQLSetStmtAttr(hstmt, (SQLINTEGER) fOption, (SQLPOINTER) (TDS_INTPTR) vParam, SQL_NTS _wide0);
    7035             : }
    7036             : 
    7037           0 : ODBC_FUNC(SQLSpecialColumns, (P(SQLHSTMT,hstmt), P(SQLUSMALLINT,fColType), PCHARIN(CatalogName,SQLSMALLINT),
    7038             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT),
    7039             :         P(SQLUSMALLINT,fScope), P(SQLUSMALLINT,fNullable) WIDE))
    7040             : {
    7041             :         int retcode;
    7042             :         char nullable, scope, col_type;
    7043             : 
    7044           0 :         ODBC_ENTER_HSTMT;
    7045             : 
    7046           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSpecialColumns(%p, %d, %p, %d, %p, %d, %p, %d, %d, %d)\n",
    7047             :                     hstmt, fColType, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName,
    7048             :                     fScope, fNullable);
    7049             : 
    7050             : #ifdef TDS_NO_DM
    7051             :         /* Check column type */
    7052           0 :         if (fColType != SQL_BEST_ROWID && fColType != SQL_ROWVER) {
    7053           0 :                 odbc_errs_add(&stmt->errs, "HY097", NULL);
    7054           0 :                 ODBC_EXIT_(stmt);
    7055             :         }
    7056             : 
    7057             :         /* check our buffer lengths */
    7058           0 :         if (!IS_VALID_LEN(cbCatalogName) || !IS_VALID_LEN(cbSchemaName) || !IS_VALID_LEN(cbTableName)) {
    7059           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    7060           0 :                 ODBC_EXIT_(stmt);
    7061             :         }
    7062             : 
    7063             :         /* Check nullable */
    7064           0 :         if (fNullable != SQL_NO_NULLS && fNullable != SQL_NULLABLE) {
    7065           0 :                 odbc_errs_add(&stmt->errs, "HY099", NULL);
    7066           0 :                 ODBC_EXIT_(stmt);
    7067             :         }
    7068             : 
    7069           0 :         if (!odbc_get_string_size(cbTableName, szTableName _wide)) {
    7070           0 :                 odbc_errs_add(&stmt->errs, "HY009", "SQLSpecialColumns: The table name parameter is required");
    7071           0 :                 ODBC_EXIT_(stmt);
    7072             :         }
    7073             : 
    7074           0 :         switch (fScope) {
    7075             :         case SQL_SCOPE_CURROW:
    7076             :         case SQL_SCOPE_TRANSACTION:
    7077             :         case SQL_SCOPE_SESSION:
    7078             :                 break;
    7079           0 :         default:
    7080           0 :                 odbc_errs_add(&stmt->errs, "HY098", NULL);
    7081           0 :                 ODBC_EXIT_(stmt);
    7082             :         }
    7083             : #endif
    7084             : 
    7085           0 :         if (fNullable == SQL_NO_NULLS)
    7086           0 :                 nullable = 'O';
    7087             :         else
    7088           0 :                 nullable = 'U';
    7089             : 
    7090           0 :         if (fScope == SQL_SCOPE_CURROW)
    7091           0 :                 scope = 'C';
    7092             :         else
    7093           0 :                 scope = 'T';
    7094             : 
    7095           0 :         if (fColType == SQL_BEST_ROWID)
    7096           0 :                 col_type = 'R';
    7097             :         else
    7098           0 :                 col_type = 'V';
    7099             : 
    7100           0 :         retcode =
    7101           0 :                 odbc_stat_execute(stmt _wide, "sp_special_columns", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 7 : 4, "O", szTableName,
    7102             :                                   cbTableName, "O", szSchemaName, cbSchemaName, "O@qualifier", szCatalogName, cbCatalogName,
    7103             :                                   "!@col_type", &col_type, 1, "!@scope", &scope, 1, "!@nullable", &nullable, 1,
    7104             :                                   "V@ODBCVer", (char*) NULL, 0);
    7105           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    7106           0 :                 odbc_col_setname(stmt, 5, "COLUMN_SIZE");
    7107           0 :                 odbc_col_setname(stmt, 6, "BUFFER_LENGTH");
    7108           0 :                 odbc_col_setname(stmt, 7, "DECIMAL_DIGITS");
    7109           0 :                 if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
    7110           0 :                         stmt->special_row = ODBC_SPECIAL_SPECIALCOLUMNS;
    7111             :         }
    7112           0 :         ODBC_EXIT_(stmt);
    7113             : }
    7114             : 
    7115           0 : ODBC_FUNC(SQLStatistics, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    7116             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT), P(SQLUSMALLINT,fUnique),
    7117             :         P(SQLUSMALLINT,fAccuracy) WIDE))
    7118             : {
    7119             :         int retcode;
    7120             :         char unique, accuracy;
    7121             : 
    7122           0 :         ODBC_ENTER_HSTMT;
    7123             : 
    7124           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLStatistics(%p, %p, %d, %p, %d, %p, %d, %d, %d)\n",
    7125             :                     hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName,
    7126             :                     fUnique, fAccuracy);
    7127             : 
    7128             : #ifdef TDS_NO_DM
    7129             :         /* check our buffer lengths */
    7130           0 :         if (!IS_VALID_LEN(cbCatalogName) || !IS_VALID_LEN(cbSchemaName) || !IS_VALID_LEN(cbTableName)) {
    7131           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    7132           0 :                 ODBC_EXIT_(stmt);
    7133             :         }
    7134             : 
    7135             :         /* check our uniqueness value */
    7136           0 :         if (fUnique != SQL_INDEX_UNIQUE && fUnique != SQL_INDEX_ALL) {
    7137           0 :                 odbc_errs_add(&stmt->errs, "HY100", NULL);
    7138           0 :                 ODBC_EXIT_(stmt);
    7139             :         }
    7140             : 
    7141             :         /* check our accuracy value */
    7142           0 :         if (fAccuracy != SQL_QUICK && fAccuracy != SQL_ENSURE) {
    7143           0 :                 odbc_errs_add(&stmt->errs, "HY101", NULL);
    7144           0 :                 ODBC_EXIT_(stmt);
    7145             :         }
    7146             : 
    7147           0 :         if (!odbc_get_string_size(cbTableName, szTableName _wide)) {
    7148           0 :                 odbc_errs_add(&stmt->errs, "HY009", NULL);
    7149           0 :                 ODBC_EXIT_(stmt);
    7150             :         }
    7151             : #endif
    7152             : 
    7153           0 :         if (fAccuracy == SQL_ENSURE)
    7154           0 :                 accuracy = 'E';
    7155             :         else
    7156           0 :                 accuracy = 'Q';
    7157             : 
    7158           0 :         if (fUnique == SQL_INDEX_UNIQUE)
    7159           0 :                 unique = 'Y';
    7160             :         else
    7161           0 :                 unique = 'N';
    7162             : 
    7163           0 :         retcode =
    7164           0 :                 odbc_stat_execute(stmt _wide, "sp_statistics", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4, "O@table_qualifier",
    7165             :                                   szCatalogName, cbCatalogName, "O@table_owner", szSchemaName, cbSchemaName, "O@table_name",
    7166             :                                   szTableName, cbTableName, "!@is_unique", &unique, 1, "!@accuracy", &accuracy, 1);
    7167           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    7168           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    7169           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    7170           0 :                 odbc_col_setname(stmt, 8, "ORDINAL_POSITION");
    7171           0 :                 odbc_col_setname(stmt, 10, "ASC_OR_DESC");
    7172             :         }
    7173           0 :         ODBC_EXIT_(stmt);
    7174             : }
    7175             : 
    7176         128 : ODBC_FUNC(SQLTables, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    7177             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT), PCHARIN(TableType,SQLSMALLINT) WIDE))
    7178             : {
    7179             :         int retcode;
    7180         128 :         const char *proc = NULL;
    7181             :         int wildcards;
    7182             :         TDSSOCKET *tds;
    7183         128 :         DSTR schema_name  = DSTR_INITIALIZER;
    7184         128 :         DSTR catalog_name = DSTR_INITIALIZER;
    7185         128 :         DSTR table_name   = DSTR_INITIALIZER;
    7186         128 :         DSTR table_type   = DSTR_INITIALIZER;
    7187             : 
    7188         128 :         ODBC_ENTER_HSTMT;
    7189             : 
    7190         128 :         tdsdump_log(TDS_DBG_FUNC, "SQLTables(%p, %p, %d, %p, %d, %p, %d, %p, %d)\n",
    7191             :                     hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName,
    7192             :                     szTableType, cbTableType);
    7193             : 
    7194         128 :         tds = stmt->dbc->tds_socket;
    7195             : 
    7196         128 :         if (!odbc_dstr_copy(stmt->dbc, &catalog_name, cbCatalogName, szCatalogName)
    7197         128 :             || !odbc_dstr_copy(stmt->dbc, &schema_name, cbSchemaName, szSchemaName)
    7198         128 :             || !odbc_dstr_copy(stmt->dbc, &table_name, cbTableName, szTableName)
    7199         128 :             || !odbc_dstr_copy(stmt->dbc, &table_type, cbTableType, szTableType))
    7200             :                 goto memory_error;
    7201             : 
    7202         128 :         if (cbTableName == SQL_NTS)
    7203           0 :                 cbTableName = tds_dstr_len(&table_name);
    7204         128 :         if (cbSchemaName == SQL_NTS)
    7205           0 :                 cbSchemaName = tds_dstr_len(&schema_name);
    7206             : 
    7207             :         /* support wildcards on catalog (only odbc 3) */
    7208         128 :         wildcards = 0;
    7209         176 :         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3 && stmt->dbc->attr.metadata_id == SQL_FALSE &&
    7210         126 :             (strchr(tds_dstr_cstr(&catalog_name), '%') || strchr(tds_dstr_cstr(&catalog_name), '_')))
    7211             :                 wildcards = 1;
    7212             : 
    7213         128 :         proc = "sp_tables";
    7214         256 :         if (!tds_dstr_isempty(&catalog_name)) {
    7215          18 :                 if (wildcards) {
    7216             :                         /* if catalog specified and wildcards use sp_tableswc under mssql2k */
    7217          18 :                         if (TDS_IS_MSSQL(tds) && tds->conn->product_version >= TDS_MS_VER(8,0,0)) {
    7218          16 :                                 proc = "sp_tableswc";
    7219          32 :                                 if (tds_dstr_isempty(&schema_name))
    7220          16 :                                         if (!tds_dstr_copy(&schema_name, "%"))
    7221             :                                                 goto memory_error;
    7222             :                         }
    7223             :                         /*
    7224             :                          * TODO support wildcards on catalog even for Sybase
    7225             :                          * first execute a select name from master..sysdatabases where name like catalog quoted
    7226             :                          * build a db1..sp_tables args db2..sp_tables args ... query
    7227             :                          * collapse results in a single recordset (how??)
    7228             :                          */
    7229             :                 } else {
    7230             :                         /* if catalog specified and not wildcards use catatog on name (catalog..sp_tables) */
    7231             :                         proc = "..sp_tables";
    7232             :                 }
    7233             :         }
    7234             : 
    7235             :         /* fix type if needed quoting it */
    7236         256 :         if (!tds_dstr_isempty(&table_type)) {
    7237          80 :                 int to_fix = 0;
    7238          80 :                 int elements = 0;
    7239         160 :                 const char *p = tds_dstr_cstr(&table_type);
    7240          80 :                 const char *const end = p + tds_dstr_len(&table_type);
    7241             : 
    7242          30 :                 for (;;) {
    7243         110 :                         const char *begin = p;
    7244             : 
    7245         110 :                         p = (const char*) memchr(p, ',', end - p);
    7246         110 :                         if (!p)
    7247          80 :                                 p = end;
    7248         110 :                         ++elements;
    7249         110 :                         if ((p - begin) < 2 || begin[0] != '\'' || p[-1] != '\'')
    7250          50 :                                 to_fix = 1;
    7251         110 :                         if (p >= end)
    7252             :                                 break;
    7253          30 :                         ++p;
    7254             :                 }
    7255             :                 /* fix it */
    7256          80 :                 tdsdump_log(TDS_DBG_INFO1, "to_fix %d elements %d\n", to_fix, elements);
    7257          80 :                 if (to_fix) {
    7258             :                         char *dst, *type;
    7259             : 
    7260          40 :                         tdsdump_log(TDS_DBG_INFO1, "fixing type elements\n");
    7261          80 :                         type = tds_new(char, tds_dstr_len(&table_type) + elements * 2 + 3);
    7262          40 :                         if (!type)
    7263             :                                 goto memory_error;
    7264             : 
    7265          80 :                         p = tds_dstr_cstr(&table_type);
    7266          40 :                         dst = type;
    7267          30 :                         for (;;) {
    7268          70 :                                 const char *begin = p;
    7269             : 
    7270          70 :                                 p = (const char*) memchr(p, ',', end - p);
    7271          70 :                                 if (!p)
    7272          40 :                                         p = end;
    7273          70 :                                 if ((p - begin) < 2 || begin[0] != '\'' || p[-1] != '\'') {
    7274          50 :                                         *dst++ = '\'';
    7275          50 :                                         memcpy(dst, begin, p - begin);
    7276          50 :                                         dst += p - begin;
    7277          50 :                                         *dst++ = '\'';
    7278             :                                 } else {
    7279          20 :                                         memcpy(dst, begin, p - begin);
    7280          20 :                                         dst += p - begin;
    7281             :                                 }
    7282          70 :                                 if (p >= end)
    7283             :                                         break;
    7284          30 :                                 *dst++ = *p++;
    7285             :                         }
    7286          40 :                         *dst = 0;
    7287          40 :                         if (!tds_dstr_set(&table_type, type)) {
    7288           0 :                                 free(type);
    7289           0 :                                 goto memory_error;
    7290             :                         }
    7291             :                 }
    7292             :         }
    7293             : 
    7294             :         /* special case for catalog list */
    7295         256 :         if (strcmp(tds_dstr_cstr(&catalog_name), "%") == 0 && cbTableName <= 0 && cbSchemaName <= 0) {
    7296          10 :                 retcode =
    7297          10 :                         odbc_stat_execute(stmt _wide, "sp_tables", 3, "$!P@table_name", "", 0,
    7298             :                                           "$!P@table_owner", "", 0, "!P@table_qualifier", "%", 1);
    7299             :         } else {
    7300         118 :                 retcode =
    7301         944 :                         odbc_stat_execute(stmt _wide, proc, 4,
    7302             :                                 "!P@table_name", tds_dstr_cstr(&table_name), tds_dstr_len(&table_name),
    7303             :                                 "!P@table_owner", tds_dstr_cstr(&schema_name), tds_dstr_len(&schema_name),
    7304             :                                 "!P@table_qualifier", tds_dstr_cstr(&catalog_name), tds_dstr_len(&catalog_name),
    7305             :                                 "!@table_type", tds_dstr_cstr(&table_type), tds_dstr_len(&table_type));
    7306             :         }
    7307         128 :         tds_dstr_free(&schema_name);
    7308         128 :         tds_dstr_free(&catalog_name);
    7309         128 :         tds_dstr_free(&table_name);
    7310         128 :         tds_dstr_free(&table_type);
    7311         128 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    7312          48 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    7313          48 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    7314             :         }
    7315         128 :         ODBC_EXIT_(stmt);
    7316             : 
    7317           0 : memory_error:
    7318           0 :         tds_dstr_free(&schema_name);
    7319           0 :         tds_dstr_free(&catalog_name);
    7320           0 :         tds_dstr_free(&table_name);
    7321           0 :         tds_dstr_free(&table_type);
    7322           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    7323           0 :         ODBC_EXIT_(stmt);
    7324             : }
    7325             : 
    7326             : /**
    7327             :  * Log a useful message about unimplemented options
    7328             :  * Defying belief, Microsoft defines mutually exclusive options that
    7329             :  * some ODBC implementations #define as duplicate values (meaning, of course,
    7330             :  * that they couldn't be implemented in the same function because they're
    7331             :  * indistinguishable.
    7332             :  *
    7333             :  * Those duplicates are commented out below.
    7334             :  */
    7335             : static void
    7336           0 : odbc_log_unimplemented_type(const char function_name[], int fType)
    7337             : {
    7338             :         const char *name, *category;
    7339             : 
    7340           0 :         switch (fType) {
    7341             : #ifdef SQL_ALTER_SCHEMA
    7342             :         case SQL_ALTER_SCHEMA:
    7343             :                 name = "SQL_ALTER_SCHEMA";
    7344             :                 category = "Supported SQL";
    7345             :                 break;
    7346             : #endif
    7347             : #ifdef SQL_ANSI_SQL_DATETIME_LITERALS
    7348             :         case SQL_ANSI_SQL_DATETIME_LITERALS:
    7349             :                 name = "SQL_ANSI_SQL_DATETIME_LITERALS";
    7350             :                 category = "Supported SQL";
    7351             :                 break;
    7352             : #endif
    7353             :         case SQL_COLLATION_SEQ:
    7354             :                 name = "SQL_COLLATION_SEQ";
    7355             :                 category = "Data Source Information";
    7356             :                 break;
    7357           0 :         case SQL_CONVERT_BIGINT:
    7358           0 :                 name = "SQL_CONVERT_BIGINT";
    7359           0 :                 category = "Conversion Information";
    7360           0 :                 break;
    7361           0 :         case SQL_CONVERT_DATE:
    7362           0 :                 name = "SQL_CONVERT_DATE";
    7363           0 :                 category = "Conversion Information";
    7364           0 :                 break;
    7365           0 :         case SQL_CONVERT_DOUBLE:
    7366           0 :                 name = "SQL_CONVERT_DOUBLE";
    7367           0 :                 category = "Conversion Information";
    7368           0 :                 break;
    7369           0 :         case SQL_CONVERT_INTERVAL_DAY_TIME:
    7370           0 :                 name = "SQL_CONVERT_INTERVAL_DAY_TIME";
    7371           0 :                 category = "Conversion Information";
    7372           0 :                 break;
    7373           0 :         case SQL_CONVERT_INTERVAL_YEAR_MONTH:
    7374           0 :                 name = "SQL_CONVERT_INTERVAL_YEAR_MONTH";
    7375           0 :                 category = "Conversion Information";
    7376           0 :                 break;
    7377           0 :         case SQL_DM_VER:
    7378           0 :                 name = "SQL_DM_VER";
    7379           0 :                 category = "Added for ODBC 3.x";
    7380           0 :                 break;
    7381           0 :         case SQL_DRIVER_HLIB:
    7382           0 :                 name = "SQL_DRIVER_HLIB";
    7383           0 :                 category = "Driver Information";
    7384           0 :                 break;
    7385             : #ifdef SQL_ODBC_STANDARD_CLI_CONFORMANCE
    7386             :         case SQL_ODBC_STANDARD_CLI_CONFORMANCE:
    7387             :                 name = "SQL_ODBC_STANDARD_CLI_CONFORMANCE";
    7388             :                 category = "Driver Information";
    7389             :                 break;
    7390             : #endif
    7391           0 :         case SQL_USER_NAME:
    7392           0 :                 name = "SQL_USER_NAME";
    7393           0 :                 category = "Data Source Information";
    7394           0 :                 break;
    7395             :         /* TODO extension SQL_INFO_SS_NETLIB_NAME ?? */
    7396           0 :         default:
    7397           0 :                 name = "unknown";
    7398           0 :                 category = "unknown";
    7399           0 :                 break;
    7400             :         }
    7401             : 
    7402           0 :         tdsdump_log(TDS_DBG_INFO1, "not implemented: %s: option/type %d(%s) [category %s]\n", function_name, fType, name,
    7403             :                     category);
    7404             : 
    7405           0 :         return;
    7406             : }
    7407             : 
    7408             : static size_t
    7409         404 : odbc_quote_metadata(TDS_DBC * dbc, char type, char *dest, DSTR * dstr)
    7410             : {
    7411         404 :         int unquote = 0;
    7412             :         char prev, buf[1200], *dst;
    7413         808 :         const char *s = tds_dstr_cstr(dstr);
    7414         808 :         ptrdiff_t len = tds_dstr_len(dstr);
    7415             : 
    7416             :         /* limit string/id lengths */
    7417         404 :         if (len > 384)
    7418           0 :                 len = 384;
    7419             : 
    7420         404 :         if (!type || (type == 'O' && dbc->attr.metadata_id == SQL_FALSE)) {
    7421         100 :                 if (dest)
    7422         100 :                         memcpy(dest, s, len);
    7423         100 :                 return len;
    7424             :         }
    7425             : 
    7426             :         /* where we can have ID or PV */
    7427         304 :         assert(type == 'P' || (type == 'O' && dbc->attr.metadata_id != SQL_FALSE));
    7428             : 
    7429             :         /* ID ? */
    7430         304 :         if (dbc->attr.metadata_id != SQL_FALSE) {
    7431             :                 /* strip leading and trailing spaces */
    7432           0 :                 while (len > 0 && *s == ' ')
    7433           0 :                         ++s, --len;
    7434           0 :                 while (len > 0 && s[len - 1] == ' ')
    7435           0 :                         --len;
    7436             :                 /* unquote if necessary */
    7437           0 :                 if (len > 2 && *s == '\"' && s[len - 1] == '\"') {
    7438           0 :                         ++s, len -= 2;
    7439           0 :                         unquote = 1;
    7440             :                 }
    7441             :         }
    7442             : 
    7443         304 :         if (!dest)
    7444           0 :                 dest = buf;
    7445         304 :         dst = dest;
    7446             : 
    7447             :         /*
    7448             :          * handle patterns
    7449             :          * "'" -> "''" (normal string quoting)
    7450             :          *
    7451             :          * if metadata_id is FALSE
    7452             :          * "\_" -> "[_]"
    7453             :          * "\%" -> "[%]"
    7454             :          * "[" -> "[[]"
    7455             :          *
    7456             :          * if metadata_id is TRUE
    7457             :          * "\"\"" -> "\"" (if unquote id)
    7458             :          * "_" -> "[_]"
    7459             :          * "%" -> "[%]"
    7460             :          * "[" -> "[[]"
    7461             :          */
    7462         304 :         prev = 0;
    7463        1890 :         for (; --len >= 0; ++s) {
    7464        1586 :                 switch (*s) {
    7465           0 :                 case '\"':
    7466           0 :                         if (unquote && prev == '\"') {
    7467           0 :                                 prev = 0;       /* avoid "\"\"\"" -> "\"" */
    7468           0 :                                 --dst;
    7469           0 :                                 continue;
    7470             :                         }
    7471             :                         break;
    7472         106 :                 case '_':
    7473             :                 case '%':
    7474         106 :                         if (dbc->attr.metadata_id == SQL_FALSE) {
    7475         106 :                                 if (prev != '\\')
    7476             :                                         break;
    7477           0 :                                 --dst;
    7478             :                         }
    7479             :                 case '[':
    7480           0 :                         if (type != 'P')
    7481             :                                 break;
    7482             :                         /* quote search string */
    7483           0 :                         *dst++ = '[';
    7484           0 :                         *dst++ = *s;
    7485           0 :                         *dst++ = ']';
    7486           0 :                         prev = 0;
    7487           0 :                         continue;
    7488             :                 }
    7489        1586 :                 *dst++ = prev = *s;
    7490             :         }
    7491         304 :         return dst - dest;
    7492             : }
    7493             : 
    7494             : static TDSPARAMINFO*
    7495         412 : odbc_add_char_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, const char *value, TDS_INT len)
    7496             : {
    7497             :         TDSCOLUMN *col;
    7498             : 
    7499         412 :         params = tds_alloc_param_result(params);
    7500         412 :         if (!params)
    7501             :                 return NULL;
    7502             : 
    7503         412 :         col = params->columns[params->num_cols-1];
    7504         412 :         if (!tds_dstr_copy(&col->column_name, name))
    7505             :                 return NULL;
    7506         412 :         tds_set_param_type(tds->conn, col, IS_TDS7_PLUS(tds->conn) ? XSYBNVARCHAR : SYBVARCHAR);
    7507             : 
    7508         412 :         col->column_size = len;
    7509         412 :         if (!tds_alloc_param_data(col))
    7510             :                 return NULL;
    7511             : 
    7512         412 :         memcpy(col->column_data, value, len);
    7513         412 :         col->column_cur_size = len;
    7514             : 
    7515         412 :         return params;
    7516             : }
    7517             : 
    7518             : static TDSPARAMINFO*
    7519          48 : odbc_add_int_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, int value)
    7520             : {
    7521             :         TDSCOLUMN *col;
    7522             : 
    7523          48 :         params = tds_alloc_param_result(params);
    7524          48 :         if (!params)
    7525             :                 return NULL;
    7526             : 
    7527          48 :         col = params->columns[params->num_cols-1];
    7528          48 :         if (!tds_dstr_copy(&col->column_name, name))
    7529             :                 return NULL;
    7530          48 :         tds_set_param_type(tds->conn, col, SYBINT4);
    7531             : 
    7532          48 :         if (!tds_alloc_param_data(col))
    7533             :                 return NULL;
    7534             : 
    7535          48 :         *((TDS_INT*) col->column_data) = value;
    7536          48 :         col->column_cur_size = sizeof(TDS_INT);
    7537             : 
    7538          48 :         return params;
    7539             : }
    7540             : 
    7541             : 
    7542             : static SQLRETURN
    7543         188 : odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...)
    7544             : {
    7545         188 :         int i, param_qualifier = -1;
    7546             :         size_t len;
    7547         188 :         char *proc = NULL, *p;
    7548             :         SQLRETURN retcode;
    7549             :         va_list marker;
    7550         188 :         DSTR qualifier = DSTR_INITIALIZER, value = DSTR_INITIALIZER;
    7551             :         TDSPARAMINFO *params;
    7552             : 
    7553             :         /* read all params and calc len required */
    7554         188 :         va_start(marker, nparams);
    7555         188 :         len = strlen(begin) + 3;
    7556         188 :         params = tds_alloc_results(0);
    7557         188 :         if (!params)
    7558             :                 goto mem_error;
    7559         790 :         for (i = 0; i < nparams; ++i) {
    7560             :                 int param_len;
    7561         790 :                 bool convert TDS_UNUSED = true;
    7562         790 :                 bool add_always = false;
    7563             :                 DSTR *out;
    7564             :                 const char *name;
    7565             :                 char type;
    7566             : 
    7567         790 :                 p = va_arg(marker, char *);
    7568             : 
    7569         522 :                 for (; ; ++p) {
    7570        1834 :                         switch (*p) {
    7571          20 :                         case '$':
    7572          20 :                                 add_always = true;
    7573          20 :                                 continue;
    7574         502 :                         case '!':
    7575         502 :                                 convert = false;
    7576         502 :                                 continue;
    7577         672 :                         case 'V':       /* ODBC version */
    7578             :                         case 'O':       /* ordinary arguments */
    7579             :                         case 'P':       /* pattern value arguments */
    7580         672 :                                 type = *p++;
    7581         672 :                                 break;
    7582             :                         default:
    7583             :                                 type = 0;       /* ordinary type */
    7584             :                                 break;
    7585             :                         }
    7586             :                         break;
    7587             :                 }
    7588         790 :                 name = p;
    7589             : 
    7590         790 :                 p = va_arg(marker, char *);
    7591         790 :                 param_len = va_arg(marker, int);
    7592             : 
    7593         790 :                 if (type == 'V') {
    7594          48 :                         int ver = (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) ? 3: 2;
    7595          48 :                         if (!odbc_add_int_param(stmt->dbc->tds_socket, params, name, ver))
    7596             :                                 goto mem_error;
    7597          48 :                         continue;
    7598             :                 }
    7599             : 
    7600             : #ifdef ENABLE_ODBC_WIDE
    7601         742 :                 if (!convert)
    7602         502 :                         out = tds_dstr_copyn(&value, p, param_len);
    7603             :                 else
    7604         240 :                         out = odbc_dstr_copy(stmt->dbc, &value, param_len, (ODBC_CHAR *) p);
    7605             : #else
    7606             :                 out = odbc_dstr_copy(stmt->dbc, &value, param_len, (ODBC_CHAR *) p);
    7607             : #endif
    7608         742 :                 if (!out)
    7609             :                         goto mem_error;
    7610             : 
    7611        1464 :                 if (add_always || !tds_dstr_isempty(&value)) {
    7612             :                         char buf[1200];
    7613             :                         int l;
    7614             : 
    7615         404 :                         l = (int) odbc_quote_metadata(stmt->dbc, type, buf,
    7616             :                                                       &value);
    7617         404 :                         if (!odbc_add_char_param(stmt->dbc->tds_socket, params, name, buf, l))
    7618             :                                 goto mem_error;
    7619             : 
    7620         404 :                         if (begin[0] == '.' && strstr(name, "qualifier")) {
    7621          20 :                                 if (!tds_dstr_dup(&qualifier, &value))
    7622             :                                         goto mem_error;
    7623          40 :                                 len += tds_quote_id_rpc(stmt->dbc->tds_socket, NULL,
    7624          20 :                                                         tds_dstr_cstr(&qualifier), tds_dstr_len(&qualifier));
    7625          20 :                                 param_qualifier = i;
    7626             :                         }
    7627             :                 }
    7628             :         }
    7629         188 :         tds_dstr_free(&value);
    7630             : 
    7631             :         /* proc is neither mb or wide, is always utf encoded */
    7632         188 :         retcode = odbc_set_stmt_query(stmt, (ODBC_CHAR *) "-", 1 _wide0);
    7633         188 :         if (retcode != SQL_SUCCESS)
    7634             :                 goto error;
    7635         188 :         stmt->prepared_query_is_rpc = 1;
    7636             : 
    7637             :         /* set params */
    7638         188 :         tds_free_param_results(stmt->params);
    7639         188 :         stmt->param_count = params->num_cols;
    7640         188 :         stmt->param_num = 1 + stmt->param_count;
    7641         188 :         stmt->params = params;
    7642         188 :         params = NULL;
    7643             : 
    7644             :         /* allocate space for string */
    7645         188 :         if (!tds_dstr_alloc(&stmt->query, len))
    7646             :                 goto mem_error;
    7647         376 :         proc = tds_dstr_buf(&stmt->query);
    7648             : 
    7649             :         /* build query string */
    7650         188 :         p = proc;
    7651         188 :         if (param_qualifier >= 0)
    7652          60 :                 p += tds_quote_id_rpc(stmt->dbc->tds_socket, p, tds_dstr_cstr(&qualifier), tds_dstr_len(&qualifier));
    7653         188 :         tds_dstr_free(&qualifier);
    7654         188 :         strcpy(p, begin);
    7655         188 :         p += strlen(begin);
    7656         188 :         tds_dstr_setlen(&stmt->query, p - proc);
    7657         188 :         assert(p + 1 <= proc + len);
    7658             : 
    7659             :         /* execute it */
    7660         188 :         retcode = odbc_SQLExecute(stmt);
    7661         188 :         if (SQL_SUCCEEDED(retcode))
    7662         188 :                 odbc_upper_column_names(stmt);
    7663             : 
    7664         188 :         va_end(marker);
    7665         188 :         ODBC_RETURN(stmt, retcode);
    7666             : 
    7667           0 : mem_error:
    7668           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    7669             : 
    7670           0 : error:
    7671           0 :         tds_dstr_free(&value);
    7672           0 :         tds_dstr_free(&qualifier);
    7673           0 :         tds_free_results(params);
    7674           0 :         va_end(marker);
    7675           0 :         return SQL_ERROR;
    7676             : }
    7677             : 
    7678             : static SQLRETURN
    7679       21856 : odbc_free_dynamic(TDS_STMT * stmt)
    7680             : {
    7681             :         TDSSOCKET *tds;
    7682             : 
    7683       21856 :         if (!stmt->dyn)
    7684             :                 return TDS_SUCCESS;
    7685             : 
    7686        2176 :         tds = stmt->dbc->tds_socket;
    7687        2176 :         if (!tds_needs_unprepare(tds->conn, stmt->dyn)) {
    7688          80 :                 tds_release_dynamic(&stmt->dyn);
    7689          80 :                 return SQL_SUCCESS;
    7690             :         }
    7691             : 
    7692        2096 :         if (odbc_lock_statement(stmt)) {
    7693        2088 :                 if (TDS_SUCCEED(tds_submit_unprepare(stmt->tds, stmt->dyn))
    7694        2088 :                     && TDS_SUCCEED(tds_process_simple_query(stmt->tds))) {
    7695        2088 :                         odbc_unlock_statement(stmt);
    7696        2088 :                         tds_release_dynamic(&stmt->dyn);
    7697        2088 :                         return SQL_SUCCESS;
    7698             :                 }
    7699             :         }
    7700             : 
    7701           8 :         if (TDS_SUCCEED(tds_deferred_unprepare(tds->conn, stmt->dyn))) {
    7702           8 :                 tds_release_dynamic(&stmt->dyn);
    7703           8 :                 return SQL_SUCCESS;
    7704             :         }
    7705             : 
    7706           0 :         ODBC_SAFE_ERROR(stmt);
    7707             :         return SQL_ERROR;
    7708             : }
    7709             : 
    7710             : /**
    7711             :  * Close server cursors
    7712             :  */
    7713             : static SQLRETURN
    7714       18329 : odbc_free_cursor(TDS_STMT * stmt)
    7715             : {
    7716       18329 :         TDSCURSOR *cursor = stmt->cursor;
    7717             :         TDSSOCKET *tds;
    7718             : 
    7719       18329 :         if (!cursor)
    7720             :                 return SQL_SUCCESS;
    7721             : 
    7722             :         /* if possible deallocate now */
    7723         248 :         if (odbc_lock_statement(stmt)) {
    7724         248 :                 tds = stmt->tds;
    7725             : 
    7726         248 :                 cursor->status.dealloc   = TDS_CURSOR_STATE_REQUESTED;
    7727         248 :                 if (TDS_SUCCEED(tds_cursor_close(tds, cursor))) {
    7728         248 :                         if (TDS_SUCCEED(tds_process_simple_query(tds))) {
    7729             :                                 /* TODO check error */
    7730         248 :                                 tds_cursor_dealloc(tds, cursor);
    7731         248 :                                 tds_release_cursor(&stmt->cursor);
    7732         248 :                                 return SQL_SUCCESS;
    7733             :                         }
    7734             :                 }
    7735             :         }
    7736             : 
    7737           0 :         tds = stmt->dbc->tds_socket;
    7738           0 :         if (TDS_SUCCEED(tds_deferred_cursor_dealloc(tds->conn, cursor))) {
    7739           0 :                 tds_release_cursor(&stmt->cursor);
    7740           0 :                 return SQL_SUCCESS;
    7741             :         }
    7742             : 
    7743           0 :         ODBC_SAFE_ERROR(stmt);
    7744             :         return SQL_ERROR;
    7745             : }
    7746             : 
    7747             : SQLRETURN ODBC_PUBLIC ODBC_API
    7748             : SQLSetScrollOptions(SQLHSTMT hstmt, SQLUSMALLINT fConcurrency, SQLLEN crowKeyset, SQLUSMALLINT crowRowset)
    7749             : {
    7750             :         SQLUSMALLINT info;
    7751             :         SQLUINTEGER value, check;
    7752             :         SQLUINTEGER cursor_type;
    7753             : 
    7754           0 :         ODBC_ENTER_HSTMT;
    7755             : 
    7756           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetScrollOptions(%p, %u, %ld, %u)\n",
    7757             :                         hstmt, fConcurrency, (long int) crowKeyset, crowRowset);
    7758             : 
    7759           0 :         if (!stmt->dbc->cursor_support) {
    7760           0 :                 odbc_errs_add(&stmt->errs, "HYC00", NULL);
    7761           0 :                 ODBC_EXIT_(stmt);
    7762             :         }
    7763             : 
    7764           0 :         if (stmt->cursor) {
    7765           0 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    7766           0 :                 ODBC_EXIT_(stmt);
    7767             :         }
    7768             : 
    7769           0 :         switch (crowKeyset) {
    7770             :         case SQL_SCROLL_FORWARD_ONLY:
    7771             :                 info = SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
    7772             :                 cursor_type = SQL_CURSOR_FORWARD_ONLY;
    7773             :                 break;
    7774           0 :         case SQL_SCROLL_STATIC:
    7775           0 :                 info = SQL_STATIC_CURSOR_ATTRIBUTES2;
    7776           0 :                 cursor_type = SQL_CURSOR_STATIC;
    7777           0 :                 break;
    7778           0 :         case SQL_SCROLL_KEYSET_DRIVEN:
    7779           0 :                 info = SQL_KEYSET_CURSOR_ATTRIBUTES2;
    7780           0 :                 cursor_type = SQL_CURSOR_KEYSET_DRIVEN;
    7781           0 :                 break;
    7782           0 :         case SQL_SCROLL_DYNAMIC:
    7783           0 :                 info = SQL_DYNAMIC_CURSOR_ATTRIBUTES2;
    7784           0 :                 cursor_type = SQL_CURSOR_DYNAMIC;
    7785           0 :                 break;
    7786           0 :         default:
    7787           0 :                 if (crowKeyset > crowRowset) {
    7788             :                         info = SQL_KEYSET_CURSOR_ATTRIBUTES2;
    7789             :                         cursor_type = SQL_CURSOR_KEYSET_DRIVEN;
    7790             :                         break;
    7791             :                 }
    7792             : 
    7793           0 :                 odbc_errs_add(&stmt->errs, "HY107", NULL);
    7794           0 :                 ODBC_EXIT_(stmt);
    7795             :         }
    7796             : 
    7797           0 :         switch (fConcurrency) {
    7798             :         case SQL_CONCUR_READ_ONLY:
    7799             :                 check = SQL_CA2_READ_ONLY_CONCURRENCY;
    7800             :                 break;
    7801           0 :         case SQL_CONCUR_LOCK:
    7802           0 :                 check = SQL_CA2_LOCK_CONCURRENCY;
    7803           0 :                 break;
    7804           0 :         case SQL_CONCUR_ROWVER:
    7805           0 :                 check = SQL_CA2_OPT_ROWVER_CONCURRENCY;
    7806           0 :                 break;
    7807           0 :         case SQL_CONCUR_VALUES:
    7808           0 :                 check = SQL_CA2_OPT_VALUES_CONCURRENCY;
    7809           0 :                 break;
    7810           0 :         default:
    7811           0 :                 odbc_errs_add(&stmt->errs, "HY108", NULL);
    7812           0 :                 ODBC_EXIT_(stmt);
    7813             :         }
    7814             : 
    7815           0 :         value = 0;
    7816           0 :         odbc_SQLGetInfo(stmt->dbc, info, &value, sizeof(value), NULL _wide0);
    7817             : 
    7818           0 :         if ((value & check) == 0) {
    7819           0 :                 odbc_errs_add(&stmt->errs, "HYC00", NULL);
    7820           0 :                 ODBC_EXIT_(stmt);
    7821             :         }
    7822             : 
    7823           0 :         odbc_SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER) (TDS_INTPTR) cursor_type, 0 _wide0);
    7824           0 :         odbc_SQLSetStmtAttr(hstmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) (TDS_INTPTR) fConcurrency, 0 _wide0);
    7825           0 :         odbc_SQLSetStmtAttr(hstmt, SQL_ATTR_KEYSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crowKeyset, 0 _wide0);
    7826           0 :         odbc_SQLSetStmtAttr(hstmt, SQL_ROWSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crowRowset, 0 _wide0);
    7827             : 
    7828           0 :         ODBC_EXIT_(stmt);
    7829             : }
    7830             : 
    7831             : static TDS_INT
    7832          64 : get_int_col(TDSSOCKET *tds, TDSCOLUMN *col, TDS_INT default_value)
    7833             : {
    7834          64 :         int srctype = tds_get_conversion_type(col->on_server.column_type, col->on_server.column_size);
    7835          64 :         TDS_CHAR *src = (TDS_CHAR *) col->column_data;
    7836          64 :         TDS_INT srclen = col->column_cur_size;
    7837             :         CONV_RESULT res;
    7838             : 
    7839          64 :         if (srclen < 0)
    7840             :                 return default_value;
    7841             : 
    7842          64 :         if (is_blob_col(col))
    7843           0 :                 src = ((TDSBLOB *) src)->textvalue;
    7844             : 
    7845          64 :         if (tds_convert(tds_get_ctx(tds), srctype, src, (TDS_UINT) srclen, SYBINT4, &res) < 0)
    7846             :                 return default_value;
    7847             : 
    7848          64 :         return res.i;
    7849             : }
    7850             : 
    7851             : /**
    7852             :  * Replace placeholders ('?') inside query with @PRMxxx name.
    7853             :  * @param is_func Tell if query is a ODBC function call.
    7854             :  * @returns Converted string, NULL on memory error.
    7855             :  */
    7856             : static char *
    7857           8 : prepare_query_describing_params(const char *query, size_t *query_len, bool is_func)
    7858             : {
    7859             : #define PRM_FMT "@PRM%04d"
    7860           8 :         int i = 0;
    7861             :         size_t len, pos;
    7862             :         const char *e, *s;
    7863           8 :         size_t size = *query_len + 30;
    7864             :         char *out;
    7865             : 
    7866           8 :         if (is_func)
    7867           2 :                 size += 10;
    7868             : 
    7869           8 :         out = tds_new(char, size);
    7870           8 :         if (!out)
    7871             :                 goto memory_error;
    7872           8 :         pos = 0;
    7873           8 :         if (is_func)
    7874           2 :                 pos += sprintf(out + pos, "exec " PRM_FMT "=", ++i);
    7875             : 
    7876             :         s = query;
    7877          14 :         for (;; ++i) {
    7878          36 :                 e = tds_next_placeholder(s);
    7879          22 :                 len = e ? e - s : strlen(s);
    7880          22 :                 if (pos + len + 12 >= size) {
    7881           2 :                         size = pos + len + 30;
    7882           2 :                         if (!TDS_RESIZE(out, size))
    7883             :                                 goto memory_error;
    7884             :                 }
    7885          22 :                 memcpy(out + pos, s, len);
    7886          22 :                 pos += len;
    7887          22 :                 if (!e)
    7888             :                         break;
    7889          14 :                 pos += sprintf(out + pos, PRM_FMT, i + 1);
    7890             : 
    7891          14 :                 s = e + 1;
    7892             :         }
    7893           8 :         out[pos] = 0;
    7894           8 :         *query_len = pos;
    7895           8 :         return out;
    7896             : 
    7897           0 : memory_error:
    7898           0 :         free(out);
    7899           0 :         return NULL;
    7900             : #undef PRM_FMT
    7901             : }
    7902             : 
    7903             : /**
    7904             :  * Parse UTF-16 name for parameter name in the form @PRMxxxx.
    7905             :  * @returns xxxx number or -1 if error.
    7906             :  */
    7907             : static int
    7908          16 : param_index_from_name(const TDSCOLUMN *const col)
    7909             : {
    7910          16 :         const unsigned char *data = col->column_data;
    7911             :         int i;
    7912             :         unsigned n;
    7913             :         char name[9];
    7914             : 
    7915             :         /* should be in format @PRMxxxx */
    7916          16 :         if (col->column_cur_size != 8 * 2)
    7917             :                 return -1;
    7918             : 
    7919             :         /* convert to ASCII and lower the case */
    7920         144 :         for (i = 0; i < 8; ++i) {
    7921         128 :                 name[i] = data[i * 2];
    7922         128 :                 if (data[i * 2 + 1])
    7923             :                         return -1;
    7924             :         }
    7925          16 :         name[1] |= 0x20;
    7926          16 :         name[2] |= 0x20;
    7927          16 :         name[3] |= 0x20;
    7928          16 :         name[8] = 0;
    7929             : 
    7930             :         /* parse name */
    7931          16 :         i = -1;
    7932          16 :         if (sscanf(name, "@prm%u%n", &n, &i) < 1 || n < 1 || i != 8)
    7933             :                 return -1;
    7934             : 
    7935          16 :         return (int) (n - 1);
    7936             : }
    7937             : 
    7938             : static bool
    7939           9 : read_params(TDS_STMT *stmt)
    7940             : {
    7941           9 :         bool ret = false;
    7942             :         TDSSOCKET *tds;
    7943           9 :         TDSPARAMINFO *params = NULL;
    7944           9 :         bool in_row = false;
    7945             :         enum {
    7946             :                 COL_NAME,
    7947             :                 COL_PRECISION,
    7948             :                 COL_SCALE,
    7949             :                 COL_TYPE,
    7950             :                 COL_LENGTH,
    7951             :                 NUM_COLUMNS
    7952             :         };
    7953             :         static const char *const column_names[NUM_COLUMNS] = {
    7954             :                 "NAME",
    7955             :                 "SUGGESTED_PRECISION",
    7956             :                 "SUGGESTED_SCALE",
    7957             :                 "SUGGESTED_TDS_TYPE_ID",
    7958             :                 "SUGGESTED_TDS_LENGTH",
    7959             :         };
    7960             :         unsigned column_idx[NUM_COLUMNS];
    7961          18 :         const char *query = tds_dstr_cstr(&stmt->query);
    7962          18 :         size_t query_len = tds_dstr_len(&stmt->query);
    7963           9 :         unsigned num_params = tds_count_placeholders(query);
    7964           9 :         char *new_query = NULL;
    7965             :         TDSCOLUMN col[1];
    7966             : 
    7967             :         /* there should be not so many parameters, avoid client to mess around */
    7968           9 :         if (num_params >= 998) {
    7969           0 :                 stmt->params_queried = 1;
    7970           0 :                 return false;
    7971             :         }
    7972             : 
    7973             :         /* allocate tds */
    7974           9 :         if (!odbc_lock_statement(stmt)) {
    7975           1 :                 odbc_errs_reset(&stmt->errs);
    7976           1 :                 return false;
    7977             :         }
    7978             : 
    7979           8 :         tds = stmt->tds;
    7980           8 :         stmt->params_queried = 1;
    7981             : 
    7982             :         /* currently supported only by MSSQL 2012 */
    7983           8 :         if (!TDS_IS_MSSQL(tds) || tds->conn->product_version < TDS_MS_VER(11,0,0)) {
    7984           0 :                 odbc_unlock_statement(stmt);
    7985           0 :                 return false;
    7986             :         }
    7987             : 
    7988             :         /* replace parameters with names */
    7989           8 :         if (stmt->prepared_query_is_func)
    7990           2 :                 ++num_params;
    7991           8 :         if (num_params) {
    7992           8 :                 new_query = prepare_query_describing_params(query, &query_len, stmt->prepared_query_is_func);
    7993           8 :                 if (!new_query)
    7994             :                         goto memory_error;
    7995             :                 query = new_query;
    7996             :         }
    7997             : 
    7998             :         /* send query */
    7999           8 :         params = odbc_add_char_param(tds, NULL, "", query, query_len);
    8000           8 :         if (!params)
    8001             :                 goto memory_error;
    8002             : 
    8003           8 :         if (TDS_FAILED(tds_submit_rpc(tds, "sp_describe_undeclared_parameters", params, NULL)))
    8004             :                 goto error;
    8005           8 :         tds_free_param_results(params);
    8006           8 :         params = NULL;
    8007             : 
    8008             :         /* clear IPD and APD */
    8009           8 :         desc_alloc_records(stmt->apd, 0);
    8010           8 :         desc_alloc_records(stmt->ipd, 0);
    8011             :         /* set IPD size */
    8012           8 :         desc_alloc_records(stmt->ipd, num_params);
    8013             : 
    8014           8 :         ret = true;
    8015             :         for (;;) {
    8016             :                 TDS_INT result_type;
    8017             :                 int done_flags;
    8018             :                 TDSRESULTINFO *res_info;
    8019             :                 ptrdiff_t i, j, num_cols;
    8020             :                 struct _drecord *drec;
    8021             :                 int idx, scale, precision, len, tds_type;
    8022             : 
    8023          48 :                 switch (tds_process_tokens(tds, &result_type, &done_flags, TDS_RETURN_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW)) {
    8024          40 :                 case TDS_SUCCESS:
    8025          40 :                         switch (result_type) {
    8026          16 :                         case TDS_DONE_RESULT:
    8027             :                         case TDS_DONEPROC_RESULT:
    8028             :                         case TDS_DONEINPROC_RESULT:
    8029          16 :                                 in_row = false;
    8030          16 :                                 break;
    8031             : 
    8032           8 :                         case TDS_ROWFMT_RESULT:
    8033             :                                 /* parse results, scan all columns to find needed ones */
    8034             :                                 /* extract all column indexes */
    8035           8 :                                 res_info = tds->current_results;
    8036           8 :                                 num_cols = res_info->num_cols;
    8037             : 
    8038          48 :                                 for (i = 0; i < NUM_COLUMNS; i++)
    8039          40 :                                         column_idx[i] = ~0u;
    8040         192 :                                 for (i = 0; i < num_cols; i++) {
    8041             :                                         char *name;
    8042             :                                         TDSCOLUMN *col;
    8043             : 
    8044         192 :                                         col = res_info->columns[i];
    8045         384 :                                         name = tds_dstr_buf(&col->column_name);
    8046             :                                         tds_ascii_strupr(name);
    8047         960 :                                         for (j = 0; j < NUM_COLUMNS; j++)
    8048         960 :                                                 if (strcmp(name, column_names[j]) == 0)
    8049          40 :                                                         column_idx[j] = i;
    8050             :                                 }
    8051             :                                 in_row = true;
    8052          40 :                                 for (i = 0; i < NUM_COLUMNS; i++)
    8053          40 :                                         if (column_idx[i] == ~0u)
    8054           0 :                                                 in_row = false;
    8055             :                                 break;
    8056          16 :                         case TDS_ROW_RESULT:
    8057          16 :                                 if (!in_row)
    8058             :                                         break;
    8059             :                                 /*
    8060             :                                  * convert type to SQL.
    8061             :                                  * Set precision (fixed on some types) and scale.
    8062             :                                  * Set length (based on type and fields).
    8063             :                                  */
    8064          16 :                                 res_info = tds->current_results;
    8065             : 
    8066          16 :                                 idx = param_index_from_name(res_info->columns[column_idx[COL_NAME]]);
    8067          16 :                                 if (idx < 0 || idx >= num_params)
    8068             :                                         break;
    8069          16 :                                 drec = &stmt->ipd->records[idx];
    8070          16 :                                 memset(col, 0, sizeof(col));
    8071          16 :                                 tds_type = get_int_col(tds, res_info->columns[column_idx[COL_TYPE]], -2);
    8072          16 :                                 len = get_int_col(tds, res_info->columns[column_idx[COL_LENGTH]], -2);
    8073          16 :                                 precision = get_int_col(tds, res_info->columns[column_idx[COL_PRECISION]], -2);
    8074          16 :                                 scale = get_int_col(tds, res_info->columns[column_idx[COL_SCALE]], -2);
    8075          16 :                                 if (tds_type < -1 || len < -1 || precision < -1 || scale < -1)
    8076             :                                         break;
    8077          16 :                                 tds_set_column_type(tds->conn, col, tds_type);
    8078          16 :                                 col->on_server.column_size = col->column_size = len;
    8079          16 :                                 col->column_prec = precision;
    8080          16 :                                 col->column_scale = scale;
    8081          16 :                                 drec->sql_desc_nullable = SQL_NULLABLE;
    8082          16 :                                 odbc_set_sql_type_info(col, drec, stmt->dbc->env->attr.odbc_version);
    8083          16 :                                 break;
    8084             :                         }
    8085          40 :                         continue;
    8086             :                 case TDS_NO_MORE_RESULTS:
    8087             :                         break;
    8088           0 :                 case TDS_CANCELLED:
    8089           0 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
    8090           0 :                 default:
    8091           0 :                         stmt->errs.lastrc = SQL_ERROR;
    8092           0 :                         ret = false;
    8093           0 :                         break;
    8094             :                 }
    8095           8 :                 break;
    8096             :         }
    8097           8 :         odbc_unlock_statement(stmt);
    8098           8 :         free(new_query);
    8099           8 :         new_query = NULL;
    8100             : 
    8101             :         /* clear IPD on error */
    8102           8 :         if (!ret)
    8103           0 :                 desc_alloc_records(stmt->ipd, 0);
    8104             : 
    8105             :         /* mark we have the information (we need to reset changing query) */
    8106           8 :         stmt->params_queried = 1;
    8107           8 :         return ret;
    8108             : 
    8109           0 : memory_error:
    8110           0 :         free(new_query);
    8111           0 :         tds_free_param_results(params);
    8112           0 :         odbc_unlock_statement(stmt);
    8113           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    8114           0 :         return false;
    8115             : 
    8116           0 : error:
    8117           0 :         free(new_query);
    8118           0 :         tds_free_param_results(params);
    8119           0 :         odbc_unlock_statement(stmt);
    8120           0 :         return false;
    8121             : }
    8122             : 
    8123             : #include "odbc_export.h"
    8124             : 
    8125             : /* Under Windows driver exports functions */
    8126             : /* The win_ prefix is to avoid clash with inline function.
    8127             :  * The prefix is removed from exported functions using definition file.
    8128             :  */
    8129             : #ifdef _WIN32
    8130             : RETCODE SQL_API win_bcp_initA(HDBC hdbc, const char *tblname, const char *hfile,
    8131             :         const char *errfile, int direction);
    8132             : RETCODE SQL_API win_bcp_initW(HDBC hdbc, const SQLWCHAR *tblname, const SQLWCHAR *hfile,
    8133             :         const SQLWCHAR *errfile, int direction);
    8134             : RETCODE SQL_API win_bcp_control(HDBC hdbc, int field, void *value);
    8135             : RETCODE SQL_API win_bcp_colptr(HDBC hdbc, const unsigned char * colptr, int table_column);
    8136             : RETCODE SQL_API win_bcp_sendrow(HDBC hdbc);
    8137             : int SQL_API win_bcp_batch(HDBC hdbc);
    8138             : int SQL_API win_bcp_done(HDBC hdbc);
    8139             : RETCODE SQL_API win_bcp_bind(HDBC hdbc, const unsigned char * varaddr, int prefixlen, int varlen,
    8140             :         const unsigned char * terminator, int termlen, int vartype, int table_column);
    8141             : 
    8142             : RETCODE SQL_API
    8143             : win_bcp_initA(HDBC hdbc, const char *tblname, const char *hfile, const char *errfile, int direction)
    8144             : {
    8145             :         return bcp_initA(hdbc, tblname, hfile, errfile, direction);
    8146             : }
    8147             : 
    8148             : #ifdef ENABLE_ODBC_WIDE
    8149             : RETCODE SQL_API
    8150             : win_bcp_initW(HDBC hdbc, const SQLWCHAR *tblname, const SQLWCHAR *hfile, const SQLWCHAR *errfile, int direction)
    8151             : {
    8152             :         return bcp_initW(hdbc, tblname, hfile, errfile, direction);
    8153             : }
    8154             : #endif
    8155             : 
    8156             : RETCODE SQL_API
    8157             : win_bcp_control(HDBC hdbc, int field, void *value)
    8158             : {
    8159             :         return bcp_control(hdbc, field, value);
    8160             : }
    8161             : 
    8162             : RETCODE SQL_API
    8163             : win_bcp_colptr(HDBC hdbc, const unsigned char * colptr, int table_column)
    8164             : {
    8165             :         return bcp_colptr(hdbc, colptr, table_column);
    8166             : }
    8167             : 
    8168             : RETCODE SQL_API
    8169             : win_bcp_sendrow(HDBC hdbc)
    8170             : {
    8171             :         return bcp_sendrow(hdbc);
    8172             : }
    8173             : 
    8174             : int SQL_API
    8175             : win_bcp_batch(HDBC hdbc)
    8176             : {
    8177             :         return bcp_batch(hdbc);
    8178             : }
    8179             : 
    8180             : int SQL_API
    8181             : win_bcp_done(HDBC hdbc)
    8182             : {
    8183             :         return bcp_done(hdbc);
    8184             : }
    8185             : 
    8186             : RETCODE SQL_API
    8187             : win_bcp_bind(HDBC hdbc, const unsigned char * varaddr, int prefixlen, int varlen,
    8188             :         const unsigned char * terminator, int termlen, int vartype, int table_column)
    8189             : {
    8190             :         return bcp_bind(hdbc, varaddr, prefixlen, varlen, terminator, termlen, vartype, table_column);
    8191             : }
    8192             : #endif
    8193             : 

Generated by: LCOV version 1.13