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

Generated by: LCOV version 1.13