LCOV - code coverage report
Current view: top level - src/odbc/unittests - common.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 288 453 63.6 %
Date: 2024-03-23 09:12:27 Functions: 33 36 91.7 %

          Line data    Source code
       1             : #include "common.h"
       2             : 
       3             : #include <stdarg.h>
       4             : #include <assert.h>
       5             : #include <ctype.h>
       6             : 
       7             : #if HAVE_SYS_SOCKET_H
       8             : #include <sys/socket.h>
       9             : #endif /* HAVE_SYS_SOCKET_H */
      10             : 
      11             : #if HAVE_SYS_STAT_H
      12             : #include <sys/stat.h>
      13             : #endif /* HAVE_SYS_STAT_H */
      14             : 
      15             : #if HAVE_NETINET_IN_H
      16             : #include <netinet/in.h>
      17             : #endif /* HAVE_NETINET_IN_H */
      18             : 
      19             : #if defined(UNIXODBC) || defined(_WIN32)
      20             : #include <odbcinst.h>
      21             : #endif
      22             : 
      23             : #ifndef _WIN32
      24             : #include <freetds/sysdep_private.h>
      25             : #else
      26             : #define TDS_SDIR_SEPARATOR "\\"
      27             : #endif
      28             : 
      29             : #include <freetds/replacements.h>
      30             : 
      31             : HENV odbc_env;
      32             : HDBC odbc_conn;
      33             : HSTMT odbc_stmt;
      34             : int odbc_use_version3 = 0;
      35             : void (*odbc_set_conn_attr)(void) = NULL;
      36             : const char *odbc_conn_additional_params = NULL;
      37             : 
      38             : char odbc_user[512];
      39             : char odbc_server[512];
      40             : char odbc_password[512];
      41             : char odbc_database[512];
      42             : char odbc_driver[1024];
      43             : 
      44             : static int freetds_driver = -1;
      45             : static int tds_version = -1;
      46             : static char db_str_version[32];
      47             : 
      48             : static int
      49         846 : check_lib(char *path, const char *file)
      50             : {
      51         846 :         int len = strlen(path);
      52             :         FILE *f;
      53             : 
      54         846 :         strcat(path, file);
      55         846 :         f = fopen(path, "rb");
      56         846 :         if (f) {
      57         846 :                 fclose(f);
      58         846 :                 return 1;
      59             :         }
      60           0 :         path[len] = 0;
      61           0 :         return 0;
      62             : }
      63             : 
      64             : /* this should be extended with all possible systems... */
      65             : static const char *const search_driver[] = {
      66             :         ".libs/libtdsodbc.so",
      67             :         ".libs/libtdsodbc.sl",
      68             :         ".libs/libtdsodbc.dylib",
      69             :         ".libs/libtdsodbc.dll",
      70             :         "_libs/libtdsodbc.dll",
      71             :         "debug/tdsodbc.dll",
      72             :         "release/tdsodbc.dll",
      73             :         "libtdsodbc.so",
      74             :         "tdsodbc.dll",
      75             :         NULL
      76             : };
      77             : 
      78             : int
      79         846 : odbc_read_login_info(void)
      80             : {
      81             :         static const char *PWD = "../../../PWD";
      82         846 :         FILE *in = NULL;
      83             :         char line[512];
      84             :         char *s1, *s2;
      85             :         const char *const *search_p;
      86             :         char path[1024];
      87             :         int len;
      88         846 :         int ini_override = 1;
      89             : #if defined(_WIN32) && !defined(TDS_NO_DM)
      90             :         UWORD old_config_mode;
      91             : #endif
      92             : 
      93         846 :         setbuf(stdout, NULL);
      94         846 :         setbuf(stderr, NULL);
      95             : 
      96         846 :         s1 = getenv("TDSPWDFILE");
      97         846 :         if (s1 && s1[0])
      98           0 :                 in = fopen(s1, "r");
      99           0 :         if (!in)
     100         846 :                 in = fopen(PWD, "r");
     101         846 :         if (!in)
     102           0 :                 in = fopen("PWD", "r");
     103             : 
     104         846 :         if (!in) {
     105           0 :                 fprintf(stderr, "Can not open PWD file\n\n");
     106           0 :                 return 1;
     107             :         }
     108       16066 :         while (fgets(line, 512, in)) {
     109       15220 :                 s1 = strtok(line, "=");
     110       15220 :                 s2 = strtok(NULL, "\n");
     111       15220 :                 if (!s1 || !s2)
     112        9088 :                         continue;
     113        6132 :                 if (!strcmp(s1, "UID")) {
     114         846 :                         strcpy(odbc_user, s2);
     115        5286 :                 } else if (!strcmp(s1, "SRV")) {
     116         846 :                         strcpy(odbc_server, s2);
     117        4440 :                 } else if (!strcmp(s1, "PWD")) {
     118         846 :                         strcpy(odbc_password, s2);
     119        3594 :                 } else if (!strcmp(s1, "DB")) {
     120         846 :                         strcpy(odbc_database, s2);
     121             :                 }
     122             :         }
     123         846 :         fclose(in);
     124             : 
     125             :         /* find our driver */
     126             : #ifndef _WIN32
     127         846 :         if (!getcwd(path, sizeof(path)))
     128             : #else
     129             :         if (!_getcwd(path, sizeof(path)))
     130             : #endif
     131             :                 return 0;
     132             : #ifdef __VMS
     133             :         {
     134             :             /* A hard-coded driver path has to be in unix syntax to be recognized as such. */
     135             :             const char *unixspec = decc$translate_vms(path);
     136             :             if ( (int)unixspec != 0 && (int)unixspec != -1 ) strcpy(path, unixspec);
     137             :         }
     138             : #endif
     139         846 :         len = strlen(path);
     140         846 :         if (len < 10 || (strcasecmp(path + len - 10, "/unittests") != 0
     141             : #ifdef _WIN32
     142             :             && strcasecmp(path + len - 10, "\\unittests") != 0
     143             : #endif
     144             :             ))
     145             :                 return 0;
     146         846 :         path[len - 9] = 0;
     147         846 :         for (search_p = search_driver; *search_p; ++search_p) {
     148         846 :                 if (check_lib(path, *search_p))
     149             :                         break;
     150             :         }
     151         846 :         if (!*search_p)
     152             :                 return 0;
     153         846 :         strcpy(odbc_driver, path);
     154             : 
     155         846 :         s1 = getenv("TDSINIOVERRIDE");
     156         846 :         if (s1 && atoi(s1) == 0)
     157           0 :                 ini_override = 0;
     158             : 
     159             : #if !defined(_WIN32) || defined(TDS_NO_DM)
     160             :         /* craft out odbc.ini, avoid to read wrong one */
     161         846 :         sprintf(path, "odbc.ini.%d", (int) getpid());
     162         846 :         in = fopen(path, "w");
     163         846 :         if (in) {
     164         846 :                 fprintf(in, "[%s]\nDriver = %s\nDatabase = %s\nServername = %s\n", odbc_server, odbc_driver, odbc_database, odbc_server);
     165         846 :                 fclose(in);
     166         846 :                 if (ini_override) {
     167         846 :                         setenv("ODBCINI", "./odbc.ini", 1);
     168         846 :                         setenv("SYSODBCINI", "./odbc.ini", 1);
     169         846 :                         rename(path, "odbc.ini");
     170             :                 }
     171         846 :                 unlink(path);
     172             :         }
     173             : #else
     174             :         if (ini_override && SQLGetConfigMode(&old_config_mode)) {
     175             :                 ODBC_BUF *odbc_buf = NULL;
     176             :                 SQLSetConfigMode(ODBC_USER_DSN);
     177             :                 SQLWritePrivateProfileString(T(odbc_server), T("Driver"), T(odbc_driver), T("odbc.ini"));
     178             :                 SQLWritePrivateProfileString(T(odbc_server), T("Database"), T(odbc_database), T("odbc.ini"));
     179             :                 SQLWritePrivateProfileString(T(odbc_server), T("Servername"), T(odbc_server), T("odbc.ini"));
     180             :                 SQLSetConfigMode(old_config_mode);
     181             :                 ODBC_FREE();
     182             :         }
     183             : #endif
     184             :         return 0;
     185             : }
     186             : 
     187             : void
     188           0 : odbc_report_error(const char *errmsg, int line, const char *file)
     189             : {
     190             :         SQLSMALLINT handletype;
     191             :         SQLHANDLE handle;
     192             :         SQLRETURN ret;
     193             :         SQLTCHAR sqlstate[6];
     194             :         SQLTCHAR msg[256];
     195           0 :         ODBC_BUF *odbc_buf = NULL;
     196             : 
     197           0 :         if (odbc_stmt) {
     198             :                 handletype = SQL_HANDLE_STMT;
     199             :                 handle = odbc_stmt;
     200           0 :         } else if (odbc_conn) {
     201             :                 handletype = SQL_HANDLE_DBC;
     202             :                 handle = odbc_conn;
     203             :         } else {
     204           0 :                 handletype = SQL_HANDLE_ENV;
     205           0 :                 handle = odbc_env;
     206             :         }
     207           0 :         if (errmsg[0]) {
     208           0 :                 if (line)
     209           0 :                         fprintf(stderr, "%s:%d %s\n", file, line, errmsg);
     210             :                 else
     211           0 :                         fprintf(stderr, "%s\n", errmsg);
     212             :         }
     213           0 :         ret = SQLGetDiagRec(handletype, handle, 1, sqlstate, NULL, msg, TDS_VECTOR_SIZE(msg), NULL);
     214           0 :         if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
     215           0 :                 fprintf(stderr, "SQL error %s -- %s\n", C(sqlstate), C(msg));
     216           0 :         odbc_disconnect();
     217           0 :         ODBC_FREE();
     218           0 :         exit(1);
     219             : }
     220             : 
     221             : static void
     222           0 : ReportODBCError(const char *errmsg, SQLSMALLINT handletype, SQLHANDLE handle, SQLRETURN rc, int line, const char *file)
     223             : {
     224             :         SQLRETURN ret;
     225             :         SQLTCHAR sqlstate[6];
     226             :         SQLTCHAR msg[256];
     227           0 :         ODBC_BUF *odbc_buf = NULL;
     228             : 
     229           0 :         if (errmsg[0]) {
     230           0 :                 if (line)
     231           0 :                         fprintf(stderr, "%s:%d rc=%d %s\n", file, line, (int) rc, errmsg);
     232             :                 else
     233           0 :                         fprintf(stderr, "rc=%d %s\n", (int) rc, errmsg);
     234             :         }
     235           0 :         ret = SQLGetDiagRec(handletype, handle, 1, sqlstate, NULL, msg, TDS_VECTOR_SIZE(msg), NULL);
     236           0 :         if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO)
     237           0 :                 fprintf(stderr, "SQL error %s -- %s\n", C(sqlstate), C(msg));
     238           0 :         odbc_disconnect();
     239           0 :         ODBC_FREE();
     240           0 :         exit(1);
     241             : }
     242             : 
     243             : int
     244         814 : odbc_connect(void)
     245             : {
     246         814 :         ODBC_BUF *odbc_buf = NULL;
     247             :         char command[512+10];
     248             :         const char *p;
     249             : 
     250         814 :         if (odbc_read_login_info())
     251           0 :                 exit(1);
     252             : 
     253         814 :         if (odbc_use_version3) {
     254         416 :                 CHKAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &odbc_env, "S");
     255         416 :                 SQLSetEnvAttr(odbc_env, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) (SQL_OV_ODBC3), SQL_IS_UINTEGER);
     256         416 :                 CHKAllocHandle(SQL_HANDLE_DBC, odbc_env, &odbc_conn, "S");
     257             :         } else {
     258         398 :                 CHKAllocEnv(&odbc_env, "S");
     259         398 :                 CHKAllocConnect(&odbc_conn, "S");
     260             :         }
     261             : 
     262         814 :         printf("odbctest\n--------\n\n");
     263         814 :         printf("connection parameters:\nserver:   '%s'\nuser:     '%s'\npassword: '%s'\ndatabase: '%s'\n",
     264             :                odbc_server, odbc_user, "????" /* odbc_password */ , odbc_database);
     265             : 
     266         814 :         p = getenv("ODBC_MARS");
     267        1221 :         if (p && atoi(p) != 0)
     268         407 :                 SQLSetConnectAttr(odbc_conn, 1224 /*SQL_COPT_SS_MARS_ENABLED*/, (SQLPOINTER) 1 /*SQL_MARS_ENABLED_YES*/, SQL_IS_UINTEGER);
     269         814 :         if (odbc_set_conn_attr)
     270          50 :                 (*odbc_set_conn_attr)();
     271             : 
     272         814 :         if (!odbc_conn_additional_params) {
     273         774 :                 CHKConnect(T(odbc_server), SQL_NTS, T(odbc_user), SQL_NTS, T(odbc_password), SQL_NTS, "SI");
     274             :         } else {
     275             :                 char *params;
     276             :                 SQLSMALLINT len;
     277             : 
     278          40 :                 assert(asprintf(&params, "DSN=%s;UID=%s;PWD=%s;DATABASE=%s;%s",
     279             :                                 odbc_server, odbc_user, odbc_password, odbc_database, odbc_conn_additional_params) >= 0);
     280          40 :                 assert(params);
     281          40 :                 CHKDriverConnect(NULL, T(params), SQL_NTS, (SQLTCHAR *) command, sizeof(command)/sizeof(SQLTCHAR),
     282             :                                  &len, SQL_DRIVER_NOPROMPT, "SI");
     283          40 :                 free(params);
     284             :         }
     285             : 
     286         814 :         CHKAllocStmt(&odbc_stmt, "S");
     287             : 
     288         814 :         sprintf(command, "use %s", odbc_database);
     289         814 :         printf("%s\n", command);
     290             : 
     291         814 :         CHKExecDirect(T(command), SQL_NTS, "SI");
     292             : 
     293             : #ifndef TDS_NO_DM
     294             :         /* unixODBC seems to require it */
     295             :         SQLMoreResults(odbc_stmt);
     296             : #endif
     297         814 :         ODBC_FREE();
     298         814 :         return 0;
     299             : }
     300             : 
     301             : int
     302         900 : odbc_disconnect(void)
     303             : {
     304         900 :         if (odbc_stmt) {
     305         816 :                 SQLFreeStmt(odbc_stmt, SQL_DROP);
     306         816 :                 odbc_stmt = SQL_NULL_HSTMT;
     307             :         }
     308             : 
     309         900 :         if (odbc_conn) {
     310         900 :                 SQLDisconnect(odbc_conn);
     311         900 :                 SQLFreeConnect(odbc_conn);
     312         900 :                 odbc_conn = SQL_NULL_HDBC;
     313             :         }
     314             : 
     315         900 :         if (odbc_env) {
     316         900 :                 SQLFreeEnv(odbc_env);
     317         900 :                 odbc_env = SQL_NULL_HENV;
     318             :         }
     319         900 :         ODBC_FREE();
     320             : 
     321         900 :         freetds_driver = -1;
     322         900 :         tds_version = -1;
     323         900 :         db_str_version[0] = 0;
     324         900 :         return 0;
     325             : }
     326             : 
     327             : SQLRETURN
     328         778 : odbc_command_with_result(HSTMT stmt, const char *command)
     329             : {
     330             :         SQLRETURN ret;
     331         778 :         ODBC_BUF *odbc_buf = NULL;
     332             : 
     333         778 :         printf("%s\n", command);
     334         778 :         ret = SQLExecDirect(stmt, T(command), SQL_NTS);
     335         778 :         ODBC_FREE();
     336         778 :         return ret;
     337             : }
     338             : 
     339             : static int ms_db = -1;
     340             : bool
     341        2156 : odbc_db_is_microsoft(void)
     342             : {
     343        2156 :         ODBC_BUF *odbc_buf = NULL;
     344             :         SQLTCHAR buf[64];
     345             :         SQLSMALLINT len;
     346             :         int i;
     347             : 
     348        2156 :         if (ms_db < 0) {
     349         198 :                 buf[0] = 0;
     350         198 :                 SQLGetInfo(odbc_conn, SQL_DBMS_NAME, buf, sizeof(buf), &len);
     351        3678 :                 for (i = 0; buf[i]; ++i)
     352        5150 :                         buf[i] = tolower(buf[i]);
     353         198 :                 ms_db = (strstr(C(buf), "microsoft") != NULL);
     354             :         }
     355        2156 :         ODBC_FREE();
     356        2156 :         return !!ms_db;
     357             : }
     358             : 
     359             : bool
     360         920 : odbc_driver_is_freetds(void)
     361             : {
     362         920 :         ODBC_BUF *odbc_buf = NULL;
     363             :         SQLTCHAR buf[64];
     364             :         SQLSMALLINT len;
     365             :         int i;
     366             : 
     367         920 :         if (freetds_driver < 0) {
     368         234 :                 buf[0] = 0;
     369         234 :                 SQLGetInfo(odbc_conn, SQL_DRIVER_NAME, buf, sizeof(buf), &len);
     370        3276 :                 for (i = 0; buf[i]; ++i)
     371        4511 :                         buf[i] = tolower(buf[i]);
     372         234 :                 freetds_driver = (strstr(C(buf), "tds") != NULL);
     373             :         }
     374         920 :         ODBC_FREE();
     375         920 :         return !!freetds_driver;
     376             : }
     377             : 
     378             : /* Detect protocol version using queries
     379             :  * This to make possible protocol discovery on drivers like MS
     380             :  */
     381             : static int
     382           0 : odbc_tds_version_long(void)
     383             : {
     384             :         SQLRETURN ret;
     385             :         SQLSMALLINT scale, nullable, type;
     386             :         SQLULEN prec;
     387           0 :         ODBC_BUF *odbc_buf = NULL;
     388             : 
     389             :         /* statement must be in a consistent state to do the check */
     390           0 :         CHKExecDirect(T("select 1"), SQL_NTS, "S");
     391           0 :         odbc_reset_statement();
     392             : 
     393             :         /* select cast(123 as sql_variant) -> nvarchar('123') is 7.0 failure query is 5.0 ?? */
     394           0 :         ret = CHKExecDirect(T("select cast('123' as sql_variant)"), SQL_NTS, "SNoE");
     395           0 :         odbc_reset_statement();
     396           0 :         if (ret == SQL_ERROR) {
     397           0 :                 ODBC_FREE();
     398           0 :                 return 0x500;
     399             :         }
     400             : 
     401             :         /* see how bigint is returned, numeric means 7.0 */
     402           0 :         CHKExecDirect(T("select cast('123' as bigint)"), SQL_NTS, "S");
     403           0 :         CHKDescribeCol(1, NULL, 0, NULL, &type, &prec, &scale, &nullable, "S");
     404           0 :         odbc_reset_statement();
     405           0 :         if (type == SQL_NUMERIC || type == SQL_DECIMAL) {
     406           0 :                 ODBC_FREE();
     407           0 :                 return 0x700;
     408             :         }
     409           0 :         if (type != SQL_BIGINT) {
     410           0 :                 fprintf(stderr, "Strange type returned trying to detect protocol version\n");
     411           0 :                 odbc_disconnect();
     412           0 :                 ODBC_FREE();
     413           0 :                 exit(1);
     414             :         }
     415             : 
     416             :         /* select cast('123' as varchar(max)) -> ??? SQL_VARCHAR is 7.2 ?? */
     417           0 :         ret = CHKExecDirect(T("select cast('123' as varchar(max))"), SQL_NTS, "SE");
     418           0 :         if (ret == SQL_ERROR) {
     419           0 :                 odbc_reset_statement();
     420           0 :                 ODBC_FREE();
     421           0 :                 return 0x701;
     422             :         }
     423           0 :         CHKDescribeCol(1, NULL, 0, NULL, &type, &prec, &scale, &nullable, "S");
     424           0 :         odbc_reset_statement();
     425           0 :         if (type == SQL_LONGVARCHAR) {
     426           0 :                 ODBC_FREE();
     427           0 :                 return 0x701;
     428             :         }
     429           0 :         if (type != SQL_VARCHAR) {
     430           0 :                 fprintf(stderr, "Strange type returned trying to detect protocol version\n");
     431           0 :                 odbc_disconnect();
     432           0 :                 ODBC_FREE();
     433           0 :                 exit(1);
     434             :         }
     435             : 
     436             :         /* select cast('12:13:14.1234' as time(4)) -> NVARCHAR('12:13:14.1234') is 7.2 else 7.3 */
     437           0 :         ret = CHKExecDirect(T("select cast('12:13:14.1234' as time(4))"), SQL_NTS, "SE");
     438           0 :         if (ret == SQL_ERROR) {
     439           0 :                 odbc_reset_statement();
     440           0 :                 ODBC_FREE();
     441           0 :                 return 0x702;
     442             :         }
     443           0 :         CHKDescribeCol(1, NULL, 0, NULL, &type, &prec, &scale, &nullable, "S");
     444           0 :         odbc_reset_statement();
     445           0 :         if (scale == 4)
     446             :                 return 0x703;
     447           0 :         if (scale != 0 || type != SQL_WVARCHAR) {
     448           0 :                 fprintf(stderr, "Strange type or scale returned trying to detect protocol version\n");
     449           0 :                 odbc_disconnect();
     450           0 :                 ODBC_FREE();
     451           0 :                 exit(1);
     452             :         }
     453             : 
     454           0 :         ODBC_FREE();
     455           0 :         return 0x702;
     456             : }
     457             : 
     458             : int
     459         198 : odbc_tds_version(void)
     460             : {
     461         198 :         ODBC_BUF *odbc_buf = NULL;
     462             :         SQLUINTEGER version;
     463             :         SQLSMALLINT len;
     464             : 
     465         198 :         if (odbc_driver_is_freetds() && tds_version < 0) {
     466          86 :                 version = 0;
     467          86 :                 len = 0;
     468          86 :                 SQLGetInfo(odbc_conn, 1300 /* SQL_INFO_FREETDS_TDS_VERSION */, &version, sizeof(version), &len);
     469          86 :                 if (len == sizeof(version))
     470          86 :                         tds_version = (version >> 16) << 8 | (version & 0xff);
     471             :         }
     472         198 :         if (tds_version < 0) {
     473           0 :                 tds_version = odbc_tds_version_long();
     474             :         }
     475         198 :         ODBC_FREE();
     476         198 :         return tds_version;
     477             : }
     478             : 
     479         258 : const char *odbc_db_version(void)
     480             : {
     481         258 :         if (!db_str_version[0]) {
     482          62 :                 ODBC_BUF *odbc_buf = NULL;
     483             :                 SQLTCHAR buf[32];
     484             :                 SQLSMALLINT version_len;
     485             : 
     486          62 :                 CHKGetInfo(SQL_DBMS_VER, buf, sizeof(buf), &version_len, "S");
     487          62 :                 strcpy(db_str_version, C(buf));
     488          62 :                 ODBC_FREE();
     489             :         }
     490             : 
     491         258 :         return db_str_version;
     492             : }
     493             : 
     494         248 : unsigned int odbc_db_version_int(void)
     495             : {
     496             :         unsigned int h, l;
     497         248 :         if (sscanf(odbc_db_version(), "%u.%u.", &h, &l) != 2) {
     498           0 :                 fprintf(stderr, "Wrong db version: %s\n", odbc_db_version());
     499           0 :                 odbc_disconnect();
     500           0 :                 exit(1);
     501             :         }
     502             : 
     503         248 :         return (h << 24) | ((l & 0xFFu) << 16);
     504             : }
     505             : 
     506             : void
     507         214 : odbc_check_cols(int n, int line, const char * file)
     508             : {
     509             :         SQLSMALLINT cols;
     510             : 
     511         214 :         if (n < 0) {
     512           0 :                 CHKNumResultCols(&cols, "E");
     513           0 :                 return;
     514             :         }
     515         214 :         CHKNumResultCols(&cols, "S");
     516         214 :         if (cols != n) {
     517           0 :                 fprintf(stderr, "%s:%d: Expected %d columns returned %d\n", file, line, n, (int) cols);
     518           0 :                 odbc_disconnect();
     519           0 :                 exit(1);
     520             :         }
     521             : }
     522             : 
     523             : void
     524         192 : odbc_check_rows(int n, int line, const char * file)
     525             : {
     526             :         SQLLEN rows;
     527             : 
     528         192 :         if (n < -1) {
     529           0 :                 CHKRowCount(&rows, "E");
     530           0 :                 return;
     531             :         }
     532             : 
     533         192 :         CHKRowCount(&rows, "S");
     534         192 :         if (rows != n) {
     535           0 :                 fprintf(stderr, "%s:%d: Expected %d rows returned %d\n", file, line, n, (int) rows);
     536           0 :                 odbc_disconnect();
     537           0 :                 exit(1);
     538             :         }
     539             : }
     540             : 
     541             : void
     542       12126 : odbc_reset_statement_proc(SQLHSTMT *stmt, const char *file, int line)
     543             : {
     544       12126 :         SQLFreeStmt(*stmt, SQL_DROP);
     545       12126 :         *stmt = SQL_NULL_HSTMT;
     546       12126 :         odbc_check_res(file, line, SQLAllocStmt(odbc_conn, stmt), SQL_HANDLE_DBC, odbc_conn, "SQLAllocStmt", "S");
     547       12126 : }
     548             : 
     549             : void
     550          51 : odbc_test_skipped(void)
     551             : {
     552          51 :         const char *p = getenv("TDS_SKIP_SUCCESS");
     553          53 :         if (p && atoi(p) != 0)
     554           2 :                 exit(0);
     555          49 :         exit(77);
     556             : }
     557             : 
     558             : void
     559         104 : odbc_check_cursor(void)
     560             : {
     561             :         SQLRETURN retcode;
     562         104 :         ODBC_BUF *odbc_buf = NULL;
     563             : 
     564         104 :         retcode = SQLSetStmtAttr(odbc_stmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) SQL_CONCUR_ROWVER, 0);
     565         104 :         if (retcode != SQL_SUCCESS) {
     566             :                 SQLTCHAR output[256];
     567             :                 SQLTCHAR sqlstate[6];
     568             : 
     569          26 :                 CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, sqlstate, NULL, output, TDS_VECTOR_SIZE(output), NULL, "S");
     570          26 :                 sqlstate[5] = 0;
     571          26 :                 if (strcmp(C(sqlstate), "01S02") == 0) {
     572          26 :                         printf("Your connection seems to not support cursors, probably you are using wrong protocol version or Sybase\n");
     573          26 :                         odbc_disconnect();
     574          26 :                         ODBC_FREE();
     575          26 :                         odbc_test_skipped();
     576             :                 }
     577           0 :                 ReportODBCError("SQLSetStmtAttr", SQL_HANDLE_STMT, odbc_stmt, retcode, __LINE__, __FILE__);
     578             :         }
     579          78 :         odbc_reset_statement();
     580          78 :         ODBC_FREE();
     581          78 : }
     582             : 
     583             : SQLRETURN
     584      132862 : odbc_check_res(const char *file, int line, SQLRETURN rc, SQLSMALLINT handle_type, SQLHANDLE handle, const char *func, const char *res)
     585             : {
     586      132862 :         const char *p = res;
     587             :         for (;;) {
     588      145233 :                 if (*p == 'S') {
     589      119197 :                         if (rc == SQL_SUCCESS)
     590             :                                 return rc;
     591       11784 :                         ++p;
     592       26036 :                 } else if (*p == 'I') {
     593        3002 :                         if (rc == SQL_SUCCESS_WITH_INFO)
     594             :                                 return rc;
     595         580 :                         ++p;
     596       23034 :                 } else if (*p == 'E') {
     597         941 :                         if (rc == SQL_ERROR)
     598             :                                 return rc;
     599           6 :                         ++p;
     600       22093 :                 } else if (strncmp(p, "No", 2) == 0) {
     601       21713 :                         if (rc == SQL_NO_DATA)
     602             :                                 return rc;
     603           1 :                         p += 2;
     604         380 :                 } else if (strncmp(p, "Ne", 2) == 0) {
     605         348 :                         if (rc == SQL_NEED_DATA)
     606             :                                 return rc;
     607           0 :                         p += 2;
     608          32 :                 } else if (*p == 'V') {
     609          32 :                         if (rc == SQL_INVALID_HANDLE)
     610             :                                 return rc;
     611           0 :                         ++p;
     612           0 :                 } else if (!*p) {
     613             :                         break;
     614             :                 } else {
     615           0 :                         odbc_report_error("Wrong results specified", line, file);
     616             :                         return rc;
     617             :                 }
     618             :         }
     619           0 :         ReportODBCError(func, handle_type, handle, rc, line, file);
     620             :         return rc;
     621             : }
     622             : 
     623             : SQLSMALLINT
     624         142 : odbc_alloc_handle_err_type(SQLSMALLINT type)
     625             : {
     626         142 :         switch (type) {
     627             :         case SQL_HANDLE_DESC:
     628             :                 return SQL_HANDLE_STMT;
     629             :         case SQL_HANDLE_STMT:
     630             :                 return SQL_HANDLE_DBC;
     631             :         case SQL_HANDLE_DBC:
     632             :                 return SQL_HANDLE_ENV;
     633             :         }
     634             :         return 0;
     635             : }
     636             : 
     637             : SQLRETURN
     638       17200 : odbc_command_proc(HSTMT stmt, const char *command, const char *file, int line, const char *res)
     639             : {
     640             :         SQLRETURN ret;
     641       17200 :         ODBC_BUF *odbc_buf = NULL;
     642             : 
     643       17200 :         printf("%s\n", command);
     644       17200 :         ret = odbc_check_res(file, line, SQLExecDirect(stmt, T(command), SQL_NTS), SQL_HANDLE_STMT, stmt, "odbc_command", res);
     645       17200 :         ODBC_FREE();
     646       17200 :         return ret;
     647             : }
     648             : 
     649             : char odbc_err[512];
     650             : char odbc_sqlstate[6];
     651             : 
     652             : void
     653         187 : odbc_read_error(void)
     654             : {
     655         187 :         ODBC_BUF *odbc_buf = NULL;
     656         187 :         SQLTCHAR *err = (SQLTCHAR *) ODBC_GET(sizeof(odbc_err)*sizeof(SQLTCHAR));
     657         187 :         SQLTCHAR *state = (SQLTCHAR *) ODBC_GET(sizeof(odbc_sqlstate)*sizeof(SQLTCHAR));
     658             : 
     659         187 :         memset(odbc_err, 0, sizeof(odbc_err));
     660         187 :         memset(odbc_sqlstate, 0, sizeof(odbc_sqlstate));
     661         187 :         CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, 1, state, NULL, err, sizeof(odbc_err), NULL, "SI");
     662         187 :         strcpy(odbc_err, C(err));
     663         187 :         strcpy(odbc_sqlstate, C(state));
     664         187 :         ODBC_FREE();
     665         187 :         printf("Message: '%s' %s\n", odbc_sqlstate, odbc_err);
     666         187 : }
     667             : 
     668             : int
     669          44 : odbc_to_sqlwchar(SQLWCHAR *dst, const char *src, int n)
     670             : {
     671          44 :         int i = n;
     672     1492688 :         while (--i >= 0)
     673     1479309 :                 dst[i] = (unsigned char) src[i];
     674          44 :         return n * sizeof(SQLWCHAR);
     675             : }
     676             : 
     677             : int
     678        3371 : odbc_from_sqlwchar(char *dst, const SQLWCHAR *src, int n)
     679             : {
     680             :         int i;
     681        3371 :         if (n < 0) {
     682             :                 const SQLWCHAR *p = src;
     683           0 :                 for (n=1; *p++ != 0; ++n)
     684           0 :                         continue;
     685             :         }
     686     1826247 :         for (i = 0; i < n; ++i) {
     687     1822876 :                 assert(src[i] < 256);
     688     1822876 :                 dst[i] = (char) src[i];
     689             :         }
     690        3371 :         return n;
     691             : }
     692             : 
     693             : ODBC_BUF *odbc_buf = NULL;
     694             : 
     695             : void *
     696       17634 : odbc_buf_add(ODBC_BUF** buf, void *ptr)
     697             : {
     698       17634 :         ODBC_BUF *p = (ODBC_BUF*) calloc(1, sizeof(ODBC_BUF));
     699       17634 :         assert(ptr);
     700       17634 :         assert(p);
     701       17634 :         p->buf = ptr;
     702       17634 :         p->next = *buf;
     703       17634 :         *buf = p;
     704       17634 :         return p->buf;
     705             : }
     706             : 
     707             : void *
     708         864 : odbc_buf_get(ODBC_BUF** buf, size_t s)
     709             : {
     710       17460 :         return odbc_buf_add(buf, malloc(s));
     711             : }
     712             : 
     713             : void
     714       32967 : odbc_buf_free(ODBC_BUF** buf)
     715             : {
     716       32967 :         ODBC_BUF *cur = *buf;
     717       32967 :         *buf = NULL;
     718       83568 :         while (cur) {
     719       17634 :                 ODBC_BUF *next = cur->next;
     720       17634 :                 free(cur->buf);
     721       17634 :                 free(cur);
     722       17634 :                 cur = next;
     723             :         }
     724       32967 : }
     725             : 
     726             : SQLWCHAR *
     727       13425 : odbc_get_sqlwchar(ODBC_BUF** buf, const char *s)
     728             : {
     729             :         size_t l;
     730             :         SQLWCHAR *buffer;
     731             : 
     732       13425 :         if (!s) return NULL;
     733       13291 :         l = strlen(s) + 1;
     734       26582 :         buffer = (SQLWCHAR*) odbc_buf_get(buf, l * sizeof(SQLWCHAR));
     735       13291 :         odbc_to_sqlwchar(buffer, s, l);
     736             :         return buffer;
     737             : }
     738             : 
     739             : char*
     740        2931 : odbc_get_sqlchar(ODBC_BUF** buf, SQLWCHAR *s)
     741             : {
     742             :         int n;
     743        2931 :         const SQLWCHAR *p = s;
     744             :         char *out;
     745             : 
     746       62436 :         for (n=1; *p++ != 0; ++n)
     747       59505 :                 continue;
     748        5862 :         out = (char *) odbc_buf_get(buf, n);
     749        2931 :         odbc_from_sqlwchar(out, s, n);
     750        2931 :         return out;
     751             : }
     752             : 
     753             : char *
     754         174 : odbc_buf_asprintf(ODBC_BUF** buf, const char *fmt, ...)
     755             : {
     756             :         va_list ap;
     757         174 :         char *ret = NULL;
     758             : 
     759         174 :         va_start(ap, fmt);
     760         174 :         assert(vasprintf(&ret, fmt, ap) >= 0);
     761         174 :         va_end(ap);
     762             : 
     763         174 :         return (char *) odbc_buf_add(buf, ret);
     764             : }
     765             : 
     766             : typedef union {
     767             :         struct sockaddr sa;
     768             :         struct sockaddr_in sin;
     769             :         char dummy[256];
     770             : } long_sockaddr;
     771             : 
     772             : static int
     773       65344 : fd_is_socket(int fd)
     774             : {
     775             :         long_sockaddr addr;
     776             :         socklen_t addr_len;
     777             : 
     778             : #ifndef _WIN32
     779             :         struct stat file_stat;
     780             : 
     781       65344 :         if (fstat(fd, &file_stat))
     782             :                 return 0;
     783          80 :         if ((file_stat.st_mode & S_IFSOCK) != S_IFSOCK)
     784             :                 return 0;
     785             : #endif
     786             : 
     787           0 :         addr_len = sizeof(addr);
     788           0 :         if (tds_getpeername((TDS_SYS_SOCKET) fd, &addr.sa, &addr_len))
     789             :                 return 0;
     790             : 
     791           0 :         addr_len = sizeof(addr);
     792           0 :         if (tds_getsockname((TDS_SYS_SOCKET) fd, &addr.sa, &addr_len))
     793             :                 return 0;
     794             : 
     795           0 :         return 1;
     796             : }
     797             : 
     798             : enum {NUM_FDS = 4096*4};
     799             : static unsigned char fd_bitmask[NUM_FDS / 8];
     800             : 
     801             : static int
     802             : mark_fd(int fd)
     803             : {
     804             :         unsigned shift;
     805             :         unsigned char mask;
     806             : 
     807           0 :         if (fd < 0 || fd >= NUM_FDS)
     808             :                 return 0;
     809             : 
     810           0 :         shift = fd & 7;
     811           0 :         mask = fd_bitmask[fd >> 3];
     812           0 :         fd_bitmask[fd >> 3] = mask | (1 << shift);
     813             : 
     814           0 :         return (mask >> shift) & 1;
     815             : }
     816             : 
     817             : #ifdef _WIN32
     818             : #define FOR_ALL_SOCKETS(i) for (i = 4; i <= (4096*4); i += 4)
     819             : #else
     820             : #define FOR_ALL_SOCKETS(i) for (i = 3; i < 1024; ++i)
     821             : #endif
     822             : 
     823             : void
     824          64 : odbc_mark_sockets_opened(void)
     825             : {
     826             :         int i;
     827             : 
     828          64 :         memset(fd_bitmask, 0, sizeof(fd_bitmask));
     829       65408 :         FOR_ALL_SOCKETS(i) {
     830       65344 :                 if (fd_is_socket(i))
     831             :                         mark_fd(i);
     832             :         }
     833          64 : }
     834             : 
     835             : TDS_SYS_SOCKET
     836          64 : odbc_find_last_socket(void)
     837             : {
     838             :         typedef struct {
     839             :                 TDS_SYS_SOCKET sock;
     840             :                 int local_port;
     841             :                 int remote_port;
     842             :         } sock_info;
     843             :         sock_info found[8];
     844          64 :         unsigned num_found = 0, n;
     845             :         int i;
     846             : 
     847          64 :         SQLULEN sock = 0;
     848             :         SQLSMALLINT len;
     849          64 :         if (odbc_driver_is_freetds()
     850          64 :             && SQLGetInfo(odbc_conn, 1301 /* SQL_INFO_FREETDS_SOCKET */, &sock, sizeof(sock), &len) == SQL_SUCCESS
     851          64 :             && len == sizeof(sock))
     852          64 :                 return (TDS_SYS_SOCKET) sock;
     853             : 
     854           0 :         FOR_ALL_SOCKETS(i) {
     855             :                 long_sockaddr remote_addr, local_addr;
     856             :                 struct sockaddr_in *in;
     857             :                 socklen_t remote_addr_len, local_addr_len;
     858             :                 sock_info *info;
     859             : 
     860             :                 /* check if is a socket */
     861           0 :                 if (!fd_is_socket(i))
     862           0 :                         continue;
     863           0 :                 if (mark_fd(i))
     864           0 :                         continue;
     865             : 
     866           0 :                 remote_addr_len = sizeof(remote_addr);
     867           0 :                 if (tds_getpeername((TDS_SYS_SOCKET) i, &remote_addr.sa, &remote_addr_len))
     868           0 :                         continue;
     869           0 :                 if (remote_addr.sa.sa_family != AF_INET
     870             : #ifdef AF_INET6
     871           0 :                     && remote_addr.sa.sa_family != AF_INET6
     872             : #endif
     873             :                     )
     874           0 :                         continue;
     875           0 :                 local_addr_len = sizeof(local_addr);
     876           0 :                 if (tds_getsockname((TDS_SYS_SOCKET) i, &local_addr.sa, &local_addr_len))
     877           0 :                         continue;
     878             : 
     879             :                 /* save in the array */
     880           0 :                 if (num_found >= 8) {
     881           0 :                         memmove(found, found+1, sizeof(found) - sizeof(found[0]));
     882           0 :                         num_found = 7;
     883             :                 }
     884           0 :                 info = &found[num_found++];
     885           0 :                 info->sock = (TDS_SYS_SOCKET) i;
     886           0 :                 info->local_port = -1;
     887           0 :                 info->remote_port = -1;
     888             : 
     889             :                 /* now check if is a socketpair */
     890           0 :                 in = &remote_addr.sin;
     891           0 :                 if (in->sin_family != AF_INET)
     892           0 :                         continue;
     893           0 :                 if (in->sin_addr.s_addr != htonl(INADDR_LOOPBACK))
     894           0 :                         continue;
     895           0 :                 info->remote_port = ntohs(in->sin_port);
     896           0 :                 in = &local_addr.sin;
     897           0 :                 if (in->sin_family != AF_INET)
     898           0 :                         continue;
     899           0 :                 if (in->sin_addr.s_addr != htonl(INADDR_LOOPBACK))
     900           0 :                         continue;
     901           0 :                 info->local_port = ntohs(in->sin_port);
     902           0 :                 for (n = 0; n < num_found - 1; ++n) {
     903           0 :                         if (found[n].remote_port != info->local_port
     904           0 :                             || found[n].local_port != info->remote_port)
     905           0 :                                 continue;
     906           0 :                         --num_found;
     907           0 :                         memmove(found+n, found+n+1, num_found-n-1);
     908           0 :                         --num_found;
     909           0 :                         break;
     910             :                 }
     911             :         }
     912             : 
     913             :         /* return last */
     914           0 :         if (num_found == 0)
     915             :                 return INVALID_SOCKET;
     916           0 :         return found[num_found-1].sock;
     917             : }
     918             : 
     919             : void
     920         454 : odbc_check_no_row(const char *query)
     921             : {
     922             :         SQLRETURN rc;
     923             : 
     924         454 :         rc = CHKExecDirect(T(query), SQL_NTS, "SINo");
     925         454 :         if (rc == SQL_NO_DATA)
     926             :                 return;
     927             : 
     928             :         do {
     929             :                 SQLSMALLINT cols;
     930             : 
     931         380 :                 CHKNumResultCols(&cols, "S");
     932         380 :                 if (cols != 0) {
     933           0 :                         fprintf(stderr, "Data not expected here, query:\n\t%s\n", query);
     934           0 :                         odbc_disconnect();
     935           0 :                         exit(1);
     936             :                 }
     937         380 :         } while (CHKMoreResults("SNo") == SQL_SUCCESS);
     938             : }
     939             : 
     940             : int
     941        1088 : odbc_lookup(const char *name, const struct odbc_lookup_int *table, int def)
     942             : {
     943        3032 :         for (; table->name; ++table)
     944        3032 :                 if (strcmp(table->name, name) == 0)
     945        1088 :                         return table->value;
     946             : 
     947             :         return def;
     948             : }
     949             : 
     950             : const char*
     951         200 : odbc_lookup_value(int value, const struct odbc_lookup_int *table, const char *def)
     952             : {
     953        3760 :         for (; table->name; ++table)
     954        3760 :                 if (table->value == value)
     955             :                         return table->name;
     956             : 
     957             :         return def;
     958             : }
     959             : 
     960             : struct odbc_lookup_int odbc_sql_c_types[] = {
     961             : #define TYPE(s) { #s, s }
     962             :         TYPE(SQL_C_NUMERIC),
     963             :         TYPE(SQL_C_BINARY),
     964             :         TYPE(SQL_C_CHAR),
     965             :         TYPE(SQL_C_WCHAR),
     966             :         TYPE(SQL_C_LONG),
     967             :         TYPE(SQL_C_SBIGINT),
     968             :         TYPE(SQL_C_SHORT),
     969             :         TYPE(SQL_C_TIMESTAMP),
     970             :         TYPE(SQL_C_FLOAT),
     971             :         TYPE(SQL_C_DOUBLE),
     972             :         TYPE(SQL_C_DEFAULT),
     973             :         TYPE(SQL_C_DATE),
     974             :         TYPE(SQL_C_TIME),
     975             :         TYPE(SQL_C_TYPE_DATE),
     976             :         TYPE(SQL_C_TYPE_TIME),
     977             :         TYPE(SQL_C_TYPE_TIMESTAMP),
     978             :         TYPE(SQL_C_INTERVAL_YEAR),
     979             :         TYPE(SQL_C_INTERVAL_MONTH),
     980             :         TYPE(SQL_C_INTERVAL_DAY),
     981             :         TYPE(SQL_C_INTERVAL_HOUR),
     982             :         TYPE(SQL_C_INTERVAL_MINUTE),
     983             :         TYPE(SQL_C_INTERVAL_SECOND),
     984             :         TYPE(SQL_C_INTERVAL_YEAR_TO_MONTH),
     985             :         TYPE(SQL_C_INTERVAL_DAY_TO_HOUR),
     986             :         TYPE(SQL_C_INTERVAL_DAY_TO_MINUTE),
     987             :         TYPE(SQL_C_INTERVAL_DAY_TO_SECOND),
     988             :         TYPE(SQL_C_INTERVAL_HOUR_TO_MINUTE),
     989             :         TYPE(SQL_C_INTERVAL_HOUR_TO_SECOND),
     990             :         TYPE(SQL_C_INTERVAL_MINUTE_TO_SECOND),
     991             :         TYPE(SQL_C_BIT),
     992             :         TYPE(SQL_C_UBIGINT),
     993             :         TYPE(SQL_C_TINYINT),
     994             :         TYPE(SQL_C_SLONG),
     995             :         TYPE(SQL_C_SSHORT),
     996             :         TYPE(SQL_C_STINYINT),
     997             :         TYPE(SQL_C_ULONG),
     998             :         TYPE(SQL_C_USHORT),
     999             :         TYPE(SQL_C_UTINYINT),
    1000             :         TYPE(SQL_C_GUID),
    1001             : #undef TYPE
    1002             :         { NULL, 0 }
    1003             : };

Generated by: LCOV version 1.13