From 7d448745f2536b99807bd844ae9684ad9644c43d Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Thu, 9 May 2024 11:32:51 -0400 Subject: [PATCH 1/7] Predefine _FREETDS_LIBRARY_SOURCE for all library code. This distinction will initially be useful only for ctlib and dblib, but applying it across the board may avoid possible confusion if it turns out to be useful elsewhere too. Signed-off-by: Aaron M. Ucko --- src/ctlib/CMakeLists.txt | 2 ++ src/ctlib/Makefile.am | 2 +- src/dblib/CMakeLists.txt | 2 ++ src/dblib/Makefile.am | 2 +- src/odbc/CMakeLists.txt | 2 ++ src/odbc/Makefile.am | 3 ++- src/replacements/CMakeLists.txt | 1 + src/replacements/Makefile.am | 3 ++- src/tds/CMakeLists.txt | 1 + src/tds/Makefile.am | 3 ++- src/utils/CMakeLists.txt | 1 + src/utils/Makefile.am | 2 +- 12 files changed, 18 insertions(+), 6 deletions(-) diff --git a/src/ctlib/CMakeLists.txt b/src/ctlib/CMakeLists.txt index e83b0b1a4..b775b849c 100644 --- a/src/ctlib/CMakeLists.txt +++ b/src/ctlib/CMakeLists.txt @@ -12,11 +12,13 @@ add_library(ct SHARED ) target_compile_definitions(ct PUBLIC DLL_EXPORT=1) +target_compile_definitions(ct PRIVATE _FREETDS_LIBRARY_SOURCE) target_link_libraries(ct tds replacements tdsutils ${lib_NETWORK} ${lib_BASE}) add_library(ct-static STATIC ct.c cs.c blk.c ctutil.c ) +target_compile_definitions(ct-static PRIVATE _FREETDS_LIBRARY_SOURCE) # See http://www.cmake.org/Wiki/CMake_FAQ#How_do_I_make_my_shared_and_static_libraries_have_the_same_root_name.2C_but_different_suffixes.3F SET_TARGET_PROPERTIES(ct-static PROPERTIES OUTPUT_NAME ${static_lib_name}) SET_TARGET_PROPERTIES(ct PROPERTIES CLEAN_DIRECT_OUTPUT 1) diff --git a/src/ctlib/Makefile.am b/src/ctlib/Makefile.am index 0db8f67a2..57a4c65e8 100644 --- a/src/ctlib/Makefile.am +++ b/src/ctlib/Makefile.am @@ -1,5 +1,5 @@ SUBDIRS = . unittests -AM_CPPFLAGS = -I$(top_srcdir)/include +AM_CPPFLAGS = -I$(top_srcdir)/include -D_FREETDS_LIBRARY_SOURCE lib_LTLIBRARIES = libct.la libct_la_SOURCES= ct.c cs.c blk.c ctutil.c ct_small_checks.c ct_large_checks.c ct_checks.h diff --git a/src/dblib/CMakeLists.txt b/src/dblib/CMakeLists.txt index 5f1766f45..2888c071a 100644 --- a/src/dblib/CMakeLists.txt +++ b/src/dblib/CMakeLists.txt @@ -10,12 +10,14 @@ add_library(sybdb SHARED ${win_SRCS} ) target_compile_definitions(sybdb PUBLIC DLL_EXPORT=1) +target_compile_definitions(sybdb PRIVATE _FREETDS_LIBRARY_SOURCE) add_dependencies(sybdb encodings_h) target_link_libraries(sybdb tds replacements tdsutils ${lib_NETWORK} ${lib_BASE}) add_library(db-lib STATIC dblib.c dbutil.c rpc.c bcp.c xact.c dbpivot.c buffering.h ) +target_compile_definitions(db-lib PRIVATE _FREETDS_LIBRARY_SOURCE) add_dependencies(db-lib encodings_h) target_link_libraries(db-lib tds replacements tdsutils ${lib_NETWORK} ${lib_BASE}) diff --git a/src/dblib/Makefile.am b/src/dblib/Makefile.am index fb454f31a..3fd31634e 100644 --- a/src/dblib/Makefile.am +++ b/src/dblib/Makefile.am @@ -1,5 +1,5 @@ SUBDIRS = . unittests -AM_CPPFLAGS = -I$(top_srcdir)/include +AM_CPPFLAGS = -I$(top_srcdir)/include -D_FREETDS_LIBRARY_SOURCE lib_LTLIBRARIES = libsybdb.la libsybdb_la_SOURCES= dblib.c dbutil.c rpc.c bcp.c xact.c dbpivot.c diff --git a/src/odbc/CMakeLists.txt b/src/odbc/CMakeLists.txt index ec8eaadd0..de656b94c 100644 --- a/src/odbc/CMakeLists.txt +++ b/src/odbc/CMakeLists.txt @@ -37,6 +37,7 @@ add_library(tdsodbc SHARED target_include_directories(tdsodbc PUBLIC "${CMAKE_CURRENT_BINARY_DIR}") add_dependencies(tdsodbc odbc_exports_h encodings_h) target_compile_definitions(tdsodbc PUBLIC DLL_EXPORT=1) +target_compile_definitions(tdsodbc PRIVATE _FREETDS_LIBRARY_SOURCE) # TODO libiconv, odbcinstlib and other dynamics target_link_libraries(tdsodbc tds replacements tdsutils ${libs} ${lib_NETWORK} ${lib_BASE}) @@ -52,6 +53,7 @@ add_library(tdsodbc_static STATIC ) target_include_directories(tdsodbc_static PUBLIC "${CMAKE_CURRENT_BINARY_DIR}") add_dependencies(tdsodbc_static odbc_exports_h encodings_h) +target_compile_definitions(tdsodbc_static PRIVATE _FREETDS_LIBRARY_SOURCE) if (NOT WIN32) set_target_properties(tdsodbc_static PROPERTIES POSITION_INDEPENDENT_CODE ON) endif() diff --git a/src/odbc/Makefile.am b/src/odbc/Makefile.am index 8a1a00702..7e7443a2f 100644 --- a/src/odbc/Makefile.am +++ b/src/odbc/Makefile.am @@ -1,5 +1,6 @@ SUBDIRS = . unittests -AM_CPPFLAGS = -I$(top_srcdir)/include $(ODBC_INC) +AM_CPPFLAGS = -I$(top_srcdir)/include $(ODBC_INC) \ + -D_FREETDS_LIBRARY_SOURCE lib_LTLIBRARIES = libtdsodbc.la ##EXTRA_LTLIBRARIES = libtdsodbc.la diff --git a/src/replacements/CMakeLists.txt b/src/replacements/CMakeLists.txt index 48d7e5363..6223495d0 100644 --- a/src/replacements/CMakeLists.txt +++ b/src/replacements/CMakeLists.txt @@ -35,6 +35,7 @@ add_library(replacements STATIC getaddrinfo.c ${add_SRCS} ) +target_compile_definitions(replacements PRIVATE _FREETDS_LIBRARY_SOURCE) target_include_directories(replacements PUBLIC "${CMAKE_CURRENT_BINARY_DIR}") add_dependencies(replacements iconv_charsets_h) if (NOT WIN32) diff --git a/src/replacements/Makefile.am b/src/replacements/Makefile.am index 467c147c3..56fceeadf 100644 --- a/src/replacements/Makefile.am +++ b/src/replacements/Makefile.am @@ -1,6 +1,7 @@ NULL = SUBDIRS = . unittests -AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/src/replacements +AM_CPPFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/src/replacements \ + -D_FREETDS_LIBRARY_SOURCE noinst_LTLIBRARIES = libreplacements.la libreplacements_la_SOURCES = \ iconv.c \ diff --git a/src/tds/CMakeLists.txt b/src/tds/CMakeLists.txt index 134a30cb8..d36c87d44 100644 --- a/src/tds/CMakeLists.txt +++ b/src/tds/CMakeLists.txt @@ -60,6 +60,7 @@ add_library(tds STATIC ${add_SRCS} ) target_include_directories(tds PUBLIC "${CMAKE_CURRENT_BINARY_DIR}") +target_compile_definitions(tds PRIVATE _FREETDS_LIBRARY_SOURCE) add_dependencies(tds encodings_h) if (NOT WIN32) set_target_properties(tds PROPERTIES POSITION_INDEPENDENT_CODE ON) diff --git a/src/tds/Makefile.am b/src/tds/Makefile.am index ab55a7874..e8acb8e66 100644 --- a/src/tds/Makefile.am +++ b/src/tds/Makefile.am @@ -1,6 +1,7 @@ NULL= SUBDIRS = . unittests -AM_CPPFLAGS = -I$(top_srcdir)/include +AM_CPPFLAGS = -I$(top_srcdir)/include \ + -D_FREETDS_LIBRARY_SOURCE noinst_LTLIBRARIES = libtds.la libtds_la_SOURCES = \ diff --git a/src/utils/CMakeLists.txt b/src/utils/CMakeLists.txt index c91650740..3c1ef20e0 100644 --- a/src/utils/CMakeLists.txt +++ b/src/utils/CMakeLists.txt @@ -21,6 +21,7 @@ add_library(tdsutils STATIC path.c ${add_SRCS} ) +target_compile_definitions(tdsutils PRIVATE _FREETDS_LIBRARY_SOURCE) if (NOT WIN32) set_target_properties(tdsutils PROPERTIES POSITION_INDEPENDENT_CODE ON) endif() diff --git a/src/utils/Makefile.am b/src/utils/Makefile.am index 48329c746..58137ff14 100644 --- a/src/utils/Makefile.am +++ b/src/utils/Makefile.am @@ -1,6 +1,6 @@ NULL = SUBDIRS = . unittests -AM_CPPFLAGS = -I$(top_srcdir)/include +AM_CPPFLAGS = -I$(top_srcdir)/include -D_FREETDS_LIBRARY_SOURCE noinst_LTLIBRARIES = libtdsutils.la libtdsutils_la_SOURCES = \ md4.c \ From 56097d950e54dfd54b6cf1937327f9d4083fb590 Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Thu, 9 May 2024 11:55:40 -0400 Subject: [PATCH 2/7] Accommodate potential mass renaming of non-ODBC symbols. * #include from several more internal headers to facilitate injecting most renaming through there; some of these headers consult HAVE_* macros anyway. * Account for possible renaming of cs_dt_crack (not just aliasing it to ..._v2), dbopen, tdsdump_dump_buf, and tdsdump_log; for the latter two, change the underlying functions' names to tdsdump_do_... modulo possible mass renaming. Signed-off-by: Aaron M. Ucko --- include/cspublic.h | 9 +++++++-- include/freetds/bool.h | 2 ++ include/freetds/sysdep_private.h | 2 ++ include/freetds/tds.h | 10 ++++++---- include/freetds/utils/des.h | 2 ++ include/freetds/utils/dlist.h | 2 ++ include/freetds/utils/hmac_md5.h | 2 ++ include/freetds/utils/md4.h | 2 ++ include/freetds/utils/md5.h | 2 ++ include/sybdb.h | 3 +++ src/ctlib/cs.c | 2 -- src/dblib/dbopen.c | 4 ---- src/odbc/odbc_export.pl | 6 +++--- src/tds/log.c | 4 ++-- 14 files changed, 35 insertions(+), 17 deletions(-) diff --git a/include/cspublic.h b/include/cspublic.h index 38d6fb7fa..17ec3cb5f 100644 --- a/include/cspublic.h +++ b/include/cspublic.h @@ -770,10 +770,15 @@ CS_RETCODE cs_ctx_drop(CS_CONTEXT * ctx); CS_RETCODE cs_config(CS_CONTEXT * ctx, CS_INT action, CS_INT property, CS_VOID * buffer, CS_INT buflen, CS_INT * outlen); CS_RETCODE cs_strbuild(CS_CONTEXT * ctx, CS_CHAR * buffer, CS_INT buflen, CS_INT * resultlen, CS_CHAR * text, CS_INT textlen, CS_CHAR * formats, CS_INT formatlen, ...); -#undef cs_dt_crack +#ifndef cs_dt_crack_v2 +# undef cs_dt_crack +#endif CS_RETCODE cs_dt_crack(CS_CONTEXT * ctx, CS_INT datetype, CS_VOID * dateval, CS_DATEREC * daterec); CS_RETCODE cs_dt_crack_v2(CS_CONTEXT * ctx, CS_INT datetype, CS_VOID * dateval, CS_DATEREC * daterec); -#define cs_dt_crack cs_dt_crack_v2 +#ifndef _FREETDS_LIBRARY_SOURCE +# undef cs_dt_crack +# define cs_dt_crack cs_dt_crack_v2 +#endif CS_RETCODE cs_loc_alloc(CS_CONTEXT * ctx, CS_LOCALE ** locptr); CS_RETCODE cs_loc_drop(CS_CONTEXT * ctx, CS_LOCALE * locale); CS_RETCODE cs_locale(CS_CONTEXT * ctx, CS_INT action, CS_LOCALE * locale, CS_INT type, CS_VOID * buffer, CS_INT buflen, diff --git a/include/freetds/bool.h b/include/freetds/bool.h index 59ff11dfc..53468dd07 100644 --- a/include/freetds/bool.h +++ b/include/freetds/bool.h @@ -20,6 +20,8 @@ #ifndef freetds_bool_h_ #define freetds_bool_h_ +#include + #ifndef __cplusplus #ifdef HAVE_STDBOOL_H diff --git a/include/freetds/sysdep_private.h b/include/freetds/sysdep_private.h index 422d7efa0..ea6b72e03 100644 --- a/include/freetds/sysdep_private.h +++ b/include/freetds/sysdep_private.h @@ -21,6 +21,8 @@ #ifndef _tds_sysdep_private_h_ #define _tds_sysdep_private_h_ +#include + #define TDS_ADDITIONAL_SPACE 16 #ifdef MSG_NOSIGNAL diff --git a/include/freetds/tds.h b/include/freetds/tds.h index deb6321e3..7d5becb88 100644 --- a/include/freetds/tds.h +++ b/include/freetds/tds.h @@ -1536,10 +1536,12 @@ int tdsdump_isopen(void); int tdsdump_open(const tds_dir_char *filename); #include void tdsdump_close(void); -void tdsdump_dump_buf(const char* file, unsigned int level_line, const char *msg, const void *buf, size_t length); +void tdsdump_do_dump_buf(const char* file, unsigned int level_line, + const char *msg, const void *buf, size_t length); void tdsdump_col(const TDSCOLUMN *col); #undef tdsdump_log -void tdsdump_log(const char* file, unsigned int level_line, const char *fmt, ...) +void tdsdump_do_log(const char* file, unsigned int level_line, + const char *fmt, ...) #if defined(__GNUC__) && __GNUC__ >= 2 #if defined(__MINGW32__) __attribute__ ((__format__ (ms_printf, 3, 4))) @@ -1548,9 +1550,9 @@ void tdsdump_log(const char* file, unsigned int level_line, const char *fmt, ... #endif #endif ; -#define TDSDUMP_LOG_FAST if (TDS_UNLIKELY(tds_write_dump)) tdsdump_log +#define TDSDUMP_LOG_FAST if (TDS_UNLIKELY(tds_write_dump)) tdsdump_do_log #define tdsdump_log TDSDUMP_LOG_FAST -#define TDSDUMP_BUF_FAST if (TDS_UNLIKELY(tds_write_dump)) tdsdump_dump_buf +#define TDSDUMP_BUF_FAST if (TDS_UNLIKELY(tds_write_dump)) tdsdump_do_dump_buf #define tdsdump_dump_buf TDSDUMP_BUF_FAST extern int tds_write_dump; diff --git a/include/freetds/utils/des.h b/include/freetds/utils/des.h index a05a20765..cf63ae6b8 100644 --- a/include/freetds/utils/des.h +++ b/include/freetds/utils/des.h @@ -1,6 +1,8 @@ #ifndef DES_H #define DES_H +#include + #ifdef HAVE_NETTLE #include diff --git a/include/freetds/utils/dlist.h b/include/freetds/utils/dlist.h index 3a4eb7a9b..2a9c87aa8 100644 --- a/include/freetds/utils/dlist.h +++ b/include/freetds/utils/dlist.h @@ -20,6 +20,8 @@ #ifndef TDS_DLIST_H #define TDS_DLIST_H +#include + typedef struct dlist_ring { struct dlist_ring *next; struct dlist_ring *prev; diff --git a/include/freetds/utils/hmac_md5.h b/include/freetds/utils/hmac_md5.h index 26196ecde..e4be2b5f2 100644 --- a/include/freetds/utils/hmac_md5.h +++ b/include/freetds/utils/hmac_md5.h @@ -20,6 +20,8 @@ #ifndef _hmac_md5_h_ #define _hmac_md5_h_ +#include + #include void hmac_md5(const unsigned char key[16], const unsigned char* data, size_t data_len, diff --git a/include/freetds/utils/md4.h b/include/freetds/utils/md4.h index 23bce5304..91d52e6fa 100644 --- a/include/freetds/utils/md4.h +++ b/include/freetds/utils/md4.h @@ -1,6 +1,8 @@ #ifndef MD4_H #define MD4_H +#include + #ifndef HAVE_NETTLE #include diff --git a/include/freetds/utils/md5.h b/include/freetds/utils/md5.h index 4fb908cbf..31d16d909 100644 --- a/include/freetds/utils/md5.h +++ b/include/freetds/utils/md5.h @@ -1,6 +1,8 @@ #ifndef MD5_H #define MD5_H +#include + #ifndef HAVE_NETTLE #include diff --git a/include/sybdb.h b/include/sybdb.h index c9c83674f..155da4717 100644 --- a/include/sybdb.h +++ b/include/sybdb.h @@ -845,11 +845,14 @@ RETCODE dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, D DBPIVOT_FUNC dbpivot_lookup_name( const char name[] ); +#ifndef _FREETDS_LIBRARY_SOURCE +#undef dbopen #ifdef MSDBLIB #define dbopen(x,y) tdsdbopen((x),(y), 1) #else #define dbopen(x,y) tdsdbopen((x),(y), 0) #endif +#endif /* fix PHP problem */ #ifdef PHP_SYBASE_DBOPEN diff --git a/src/ctlib/cs.c b/src/ctlib/cs.c index ad89d6130..8a29bbcba 100644 --- a/src/ctlib/cs.c +++ b/src/ctlib/cs.c @@ -41,8 +41,6 @@ #include "cspublic.h" #include "ctlib.h" -#undef cs_dt_crack - static CS_INT cs_diag_storemsg(CS_CONTEXT *context, CS_CLIENTMSG *message); static CS_INT cs_diag_clearmsg(CS_CONTEXT *context, CS_INT type); static CS_INT cs_diag_getmsg(CS_CONTEXT *context, CS_INT idx, CS_CLIENTMSG *message); diff --git a/src/dblib/dbopen.c b/src/dblib/dbopen.c index e98dd4617..36b7ddf5d 100644 --- a/src/dblib/dbopen.c +++ b/src/dblib/dbopen.c @@ -23,10 +23,6 @@ #include #include -#ifdef dbopen -#undef dbopen -#endif - /** * Normally not used. * The function is linked in only if the --enable-sybase-compat configure option is used. diff --git a/src/odbc/odbc_export.pl b/src/odbc/odbc_export.pl index 5e470d5bb..9a2347ab7 100644 --- a/src/odbc/odbc_export.pl +++ b/src/odbc/odbc_export.pl @@ -35,7 +35,7 @@ my $params_all = ''; my $pass_aw = ''; my $sep = ''; - my $log = "tdsdump_log(TDS_DBG_FUNC, \"$func("; + my $log = "tdsdump_do_log(TDS_DBG_FUNC, \"$func("; my $log_p = ''; $wide = 1 if $args =~ / WIDE ?$/; $args =~ s/ WIDE ?$//; @@ -104,13 +104,13 @@ SQLWSTR_FREE(); }"; } else { - $log_w =~ s/\btdsdump_log\b/TDSDUMP_LOG_FAST/g; + $log_w =~ s/\btdsdump_do_log\b/TDSDUMP_LOG_FAST/g; } $log =~ s/%ls/%s/g; $log =~ s/STRING\((.*?),(.*?)\)/(const char*) $1/g; - $log =~ s/\btdsdump_log\b/TDSDUMP_LOG_FAST/g; + $log =~ s/\btdsdump_do_log\b/TDSDUMP_LOG_FAST/g; print "#ifdef ENABLE_ODBC_WIDE static SQLRETURN _$func($params_all, int wide); diff --git a/src/tds/log.c b/src/tds/log.c index f54cdedf0..fa6eb6c71 100644 --- a/src/tds/log.c +++ b/src/tds/log.c @@ -290,7 +290,7 @@ current_thread_is_excluded(void) * \param length number of bytes in the buffer */ void -tdsdump_dump_buf(const char* file, unsigned int level_line, const char *msg, const void *buf, size_t length) +tdsdump_do_dump_buf(const char* file, unsigned int level_line, const char *msg, const void *buf, size_t length) { size_t i, j; #define BYTES_PER_LINE 16 @@ -393,7 +393,7 @@ tdsdump_dump_buf(const char* file, unsigned int level_line, const char *msg, con * \param fmt printf-like format string */ void -tdsdump_log(const char* file, unsigned int level_line, const char *fmt, ...) +tdsdump_do_log(const char* file, unsigned int level_line, const char *fmt, ...) { const int debug_lvl = level_line & 15; const int line = level_line >> 4; From 0d055ad17bb05e592cf3642198f638e58c228d6e Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Thu, 9 May 2024 16:20:17 -0400 Subject: [PATCH 3/7] Improve type handling, at least for Sybase. * odbc_sql2tds: Treat SYB5INT8 like other numeric types. * tds_generic_get: Handle non-blob types with four-byte sizes (e.g., XSYBCHAR at least some of the time). * tds_generic_put_info: Send size 255 (0xff) for NULL short character types in output columns. Signed-off-by: Aaron M. Ucko --- src/odbc/sql2tds.c | 1 + src/tds/data.c | 13 +++++++++++++ 2 files changed, 14 insertions(+) diff --git a/src/odbc/sql2tds.c b/src/odbc/sql2tds.c index 50db6e06b..a1b7b709a 100644 --- a/src/odbc/sql2tds.c +++ b/src/odbc/sql2tds.c @@ -571,6 +571,7 @@ odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _dre case SYBINT2: case SYBINT4: case SYBINT8: + case SYB5INT8: case SYBFLT8: case SYBDATETIME: case SYBBIT: diff --git a/src/tds/data.c b/src/tds/data.c index aaab739db..fe5ca4b8c 100644 --- a/src/tds/data.c +++ b/src/tds/data.c @@ -723,6 +723,15 @@ tds_generic_get(TDSSOCKET * tds, TDSCOLUMN * curcol) tdsdump_log(TDS_DBG_INFO1, "tds_get_data: type %d, varint size %d\n", curcol->column_type, curcol->column_varint_size); switch (curcol->column_varint_size) { case 4: + if (!is_blob_type(curcol->column_type)) { + /* Any other non-BLOB type (e.g., XSYBCHAR) */ + colsize = tds_get_int(tds); + if (colsize == 0) { + colsize = -1; + } + break; + } + /* It's a BLOB... */ len = tds_get_byte(tds); blob = (TDSBLOB *) curcol->column_data; @@ -884,6 +893,10 @@ tds_generic_put_info(TDSSOCKET * tds, TDSCOLUMN * col) case 0: break; case 1: + if (col->column_output && col->column_size <= 0 + && is_char_type(col->column_type)) { + size = 255; + } tds_put_byte(tds, size); break; case 2: From 64ac68e45feb2c807d97727325c6e5e67012defd Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Fri, 10 May 2024 09:59:19 -0400 Subject: [PATCH 4/7] Improve TDS 5 (Sybase) LONGBINARY and LONGCHAR handling. * tds.h (is_blob_col): Consider column_type in addition to column_varint_size. * Retire 5 as a nominal column_varint_size value in favor of unified logic. Signed-off-by: Aaron M. Ucko --- include/freetds/tds.h | 5 ++++- misc/types.csv | 4 ++-- src/tds/data.c | 37 +++++++++++++++++++++---------------- src/tds/tds_checks.c | 3 ++- 4 files changed, 29 insertions(+), 20 deletions(-) diff --git a/include/freetds/tds.h b/include/freetds/tds.h index 7d5becb88..079f7c777 100644 --- a/include/freetds/tds.h +++ b/include/freetds/tds.h @@ -384,7 +384,10 @@ extern const char *const tds_type_names[256]; #define is_blob_type(x) ((x)==SYBTEXT || (x)==SYBIMAGE || (x)==SYBNTEXT) -#define is_blob_col(x) ((x)->column_varint_size > 2) +#define is_blob_col(x) (is_blob_type((x)->column_type) \ + || ((x)->column_varint_size == 8) \ + || ((x)->column_type == SYBVARIANT \ + && (x)->column_varint_size == 4)) /* large type means it has a two byte size field */ /* define is_large_type(x) (x>128) */ #define is_numeric_type(x) ((x)==SYBNUMERIC || (x)==SYBDECIMAL) diff --git a/misc/types.csv b/misc/types.csv index afbba982a..e2a3ac94c 100644 --- a/misc/types.csv +++ b/misc/types.csv @@ -27,8 +27,8 @@ SYBINT4;ALL;0;1;0;0;0;0;0;0;0;0;4;SYBINTN;11;0;1; SYBINT8;MS;0;1;0;0;0;0;0;0;0;0;8;SYBINTN;20;0;1; SYBINTERVAL;SYB;0;1;0;0;0;0;0;0;0;0;8;0;;0;0; SYBINTN;ALL;1;0;1;0;0;0;0;0;0;0;-1;0;;0;1; -SYBLONGBINARY;SYB;5;0;1;1;1;0;0;Depend;Depend;0;-1;0;2*S;1;0; -SYBLONGCHAR;SYB;5;0;1;1;1;0;0;??;1;0;-1;0;S;0;0; +SYBLONGBINARY;SYB;4;0;1;1;1;0;0;Depend;Depend;0;-1;0;2*S;1;0; +SYBLONGCHAR;SYB;4;0;1;1;1;0;0;??;1;0;-1;0;S;0;0; SYBMONEY;ALL;0;1;0;0;0;0;0;0;0;0;8;SYBMONEYN;21;0;1; SYBMONEY4;ALL;0;1;0;0;0;0;0;0;0;0;4;SYBMONEYN;12;0;1; SYBMONEYN;ALL;1;0;1;0;0;0;0;0;0;0;-1;0;;0;1; diff --git a/src/tds/data.c b/src/tds/data.c index fe5ca4b8c..ba9ae3596 100644 --- a/src/tds/data.c +++ b/src/tds/data.c @@ -387,7 +387,6 @@ tds_generic_get_info(TDSSOCKET *tds, TDSCOLUMN *col) case 8: col->column_size = 0x7ffffffflu; break; - case 5: case 4: col->column_size = tds_get_int(tds); if (col->column_size < 0) @@ -730,6 +729,13 @@ tds_generic_get(TDSSOCKET * tds, TDSCOLUMN * curcol) colsize = -1; } break; + } else if (curcol->on_server.column_type == SYBLONGBINARY) { + blob = (TDSBLOB *) curcol->column_data; + colsize = tds_get_int(tds); + if (colsize == 0) { + colsize = -1; + } + break; } /* It's a BLOB... */ @@ -747,11 +753,6 @@ tds_generic_get(TDSSOCKET * tds, TDSCOLUMN * curcol) colsize = -1; } break; - case 5: - colsize = tds_get_int(tds); - if (colsize == 0) - colsize = -1; - break; case 8: return tds72_get_varmax(tds, curcol); case 2: @@ -902,7 +903,6 @@ tds_generic_put_info(TDSSOCKET * tds, TDSCOLUMN * col) case 2: tds_put_smallint(tds, size); break; - case 5: case 4: tds_put_int(tds, size); break; @@ -947,9 +947,6 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) if (curcol->column_cur_size < 0) { tdsdump_log(TDS_DBG_INFO1, "tds_generic_put: null param\n"); switch (curcol->column_varint_size) { - case 5: - tds_put_int(tds, 0); - break; case 4: if ((bcp7 || !IS_TDS7_PLUS(tds->conn)) && is_blob_type(curcol->on_server.column_type)) tds_put_byte(tds, 0); @@ -1024,7 +1021,13 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) tds_put_int8(tds, bcp7 ? (TDS_INT8) -2 : (TDS_INT8) colsize); tds_put_int(tds, colsize); break; - case 4: /* It's a BLOB... */ + case 4: + if ( !is_blob_col(curcol) ) { + colsize = MAX(MIN(colsize, 0x7fffffff), 1); + TDS_PUT_INT(tds, colsize); + break; + } + /* It's a BLOB... */ colsize = MIN(colsize, size); /* mssql require only size */ if (bcp7 && is_blob_type(curcol->on_server.column_type)) { @@ -1080,11 +1083,13 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) /* TODO ICONV handle charset conversions for data */ /* put size of data */ switch (curcol->column_varint_size) { - case 5: /* It's a LONGBINARY */ - colsize = MIN(colsize, 0x7fffffff); - tds_put_int(tds, colsize); - break; - case 4: /* It's a BLOB... */ + case 4: + if ( !is_blob_col(curcol) ) { + colsize = MAX(MIN(colsize, 0x7fffffff), 1); + tds_put_int(tds, colsize); + break; + } + /* It's a BLOB... */ tds_put_byte(tds, 16); tds_put_n(tds, blob->textptr, 16); tds_put_n(tds, blob->timestamp, 8); diff --git a/src/tds/tds_checks.c b/src/tds/tds_checks.c index c02766603..c1a609f38 100644 --- a/src/tds/tds_checks.c +++ b/src/tds/tds_checks.c @@ -192,7 +192,8 @@ tds_check_column_extra(const TDSCOLUMN * column) column_varint_size = column->column_varint_size; /* 8 is for varchar(max) or similar */ - assert(column_varint_size == 8 || (column_varint_size <= 5 && column_varint_size != 3)); + assert(column_varint_size == 8 || + (column_varint_size < 5 && column_varint_size != 3)); assert(column->column_scale <= column->column_prec); assert(column->column_prec <= MAXPRECISION); From ca137cc82a8774b2af8b2d801a7d677666b687df Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Fri, 10 May 2024 16:50:24 -0400 Subject: [PATCH 5/7] Report system errors' descriptions to ctlib clients. * tds.h (TDSMESSAGE): Add an osstr field. * ctutil.c (_ct_handle_client_message): Propagate it to osstring(len). * tds/login.c (tds_save): Clear osstr to avoid invalid reads when trying to connect to a dead server. * tds/ncbi_strerror.c: New. * tds/util.c: ** #include ncbi_strerror.c, whose definitions are all static. ** tdserror: Populate the osstr field; clean it when done. Signed-off-by: Aaron M. Ucko --- include/freetds/tds.h | 1 + src/ctlib/ctutil.c | 7 +- src/tds/login.c | 1 + src/tds/ncbi_strerror.c | 351 ++++++++++++++++++++++++++++++++++++++++ src/tds/util.c | 12 ++ 5 files changed, 370 insertions(+), 2 deletions(-) create mode 100644 src/tds/ncbi_strerror.c diff --git a/include/freetds/tds.h b/include/freetds/tds.h index 079f7c777..2be538bc3 100644 --- a/include/freetds/tds.h +++ b/include/freetds/tds.h @@ -893,6 +893,7 @@ typedef struct tds_message TDS_TINYINT severity; /* for library-generated errors */ int oserr; + TDS_CHAR *osstr; } TDSMESSAGE; typedef struct tds_upd_col diff --git a/src/ctlib/ctutil.c b/src/ctlib/ctutil.c index bae42588d..3853d0f7f 100644 --- a/src/ctlib/ctutil.c +++ b/src/ctlib/ctutil.c @@ -126,8 +126,11 @@ _ct_handle_client_message(const TDSCONTEXT * ctx_tds, TDSSOCKET * tds, TDSMESSAG errmsg.severity = _ct_translate_severity(msg->severity); strlcpy(errmsg.msgstring, msg->message, sizeof(errmsg.msgstring)); errmsg.msgstringlen = strlen(errmsg.msgstring); - errmsg.osstring[0] = '\0'; - errmsg.osstringlen = 0; + if (msg->osstr) { + errmsg.osstringlen = (CS_INT) strlen(msg->osstr); + strlcpy(errmsg.osstring, msg->osstr, CS_MAX_MSG); + } + /* if there is no connection, attempt to call the context handler */ if (!con) { ctx = (CS_CONTEXT *) ctx_tds->parent; diff --git a/src/tds/login.c b/src/tds/login.c index 1cfb88c06..6257ef493 100644 --- a/src/tds/login.c +++ b/src/tds/login.c @@ -206,6 +206,7 @@ tds_save(TDSSAVECONTEXT *ctx, char type, TDSMESSAGE *msg) dest_msg = &ctx->msgs[ctx->num_msg]; dest_msg->type = type; dest_msg->msg = *msg; + dest_msg->msg.osstr = NULL; #define COPY(name) if (msg->name) dest_msg->msg.name = strdup(msg->name); COPY(server); COPY(message); diff --git a/src/tds/ncbi_strerror.c b/src/tds/ncbi_strerror.c new file mode 100644 index 000000000..f36429bd6 --- /dev/null +++ b/src/tds/ncbi_strerror.c @@ -0,0 +1,351 @@ +/* $Id$ + * =========================================================================== + * + * PUBLIC DOMAIN NOTICE + * National Center for Biotechnology Information + * + * This software/database is a "United States Government Work" under the + * terms of the United States Copyright Act. It was written as part of + * the author's official duties as a United States Government employee and + * thus cannot be copyrighted. This software/database is freely available + * to the public for use. The National Library of Medicine and the U.S. + * Government have not placed any restriction on its use or reproduction. + * + * Although all reasonable efforts have been taken to ensure the accuracy + * and reliability of the software and data, the NLM and the U.S. + * Government do not and cannot warrant the performance or results that + * may be obtained by using this software or data. The NLM and the U.S. + * Government disclaim all warranties, express or implied, including + * warranties of performance, merchantability or fitness for any particular + * purpose. + * + * Please cite the author in any work or product based on this material. + * + * =========================================================================== + * + * Authors: Pavel Ivanov, Anton Lavrentiev, Denis Vakatov + * + * File Description: + * errno->text conversion helper + */ + + +#ifdef NCBI_INCLUDE_STRERROR_C + + +# ifdef _FREETDS_LIBRARY_SOURCE +# define s_StrError s_StrErrorInternal +# endif /*_FREETDS_LIBRARY_SOURCE*/ + + +# if defined(NCBI_OS_MSWIN) && defined(_UNICODE) + +static const char* s_WinStrdup(const char* str) +{ + size_t n = strlen(str); + char* s = (char*) LocalAlloc(LMEM_FIXED, ++n * sizeof(*s)); + return s ? (const char*) memcpy(s, str, n) : 0; +} +# define ERR_STRDUP(s) s_WinStrdup(s) + +extern const char* UTIL_TcharToUtf8(const TCHAR* str) +{ + char* s = NULL; + if (str) { + /* Note "-1" means to consume all input including the trailing NUL */ + int n = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL); + if (n > 0) { + s = (char*) LocalAlloc(LMEM_FIXED, n * sizeof(*s)); + if (s) + WideCharToMultiByte(CP_UTF8, 0, str, -1, s, n, NULL, NULL); + } + } + return s; +} + +# ifndef UTIL_ReleaseBuffer +# define UTIL_ReleaseBuffer(x) UTIL_ReleaseBufferOnHeap(x) +# endif + +# else /*NCBI_OS_MSWIN && _UNICODE*/ + +# define ERR_STRDUP(s) strdup(s) + +# ifdef UTIL_TcharToUtf8 +# undef UTIL_TcharToUtf8 +# endif +# define UTIL_TcharToUtf8(x) strdup(x) + +# ifdef UTIL_ReleaseBuffer +# undef UTIL_ReleaseBuffer +# endif +# define UTIL_ReleaseBuffer(x) free((void*)(x)) + +# endif /*NCBI_OS_MSWIN && _UNICODE*/ + + +# ifdef NCBI_OS_MSWIN + +extern void UTIL_ReleaseBufferOnHeap(const void* ptr) +{ + if (ptr) + LocalFree((HLOCAL) ptr); +} + +# endif /*NCBI_OS_MSWIN*/ + + +static const char* s_StrErrorInternal(int error) +{ + static const struct { + int errnum; + const char* errstr; + } errmap[] = { +# ifdef NCBI_OS_MSWIN + {WSAEINTR, "Interrupted system call"}, + {WSAEBADF, "Bad file number"}, + {WSAEACCES, "Access denied"}, + {WSAEFAULT, "Segmentation fault"}, + {WSAEINVAL, "Invalid agrument"}, + {WSAEMFILE, "Too many open files"}, + /* + * Windows Sockets definitions of regular Berkeley error constants + */ + {WSAEWOULDBLOCK, "Resource temporarily unavailable"}, + {WSAEINPROGRESS, "Operation now in progress"}, + {WSAEALREADY, "Operation already in progress"}, + {WSAENOTSOCK, "Not a socket"}, + {WSAEDESTADDRREQ, "Destination address required"}, + {WSAEMSGSIZE, "Invalid message size"}, + {WSAEPROTOTYPE, "Wrong protocol type"}, + {WSAENOPROTOOPT, "Bad protocol option"}, + {WSAEPROTONOSUPPORT, "Protocol not supported"}, + {WSAESOCKTNOSUPPORT, "Socket type not supported"}, + {WSAEOPNOTSUPP, "Operation not supported"}, + {WSAEPFNOSUPPORT, "Protocol family not supported"}, + {WSAEAFNOSUPPORT, "Address family not supported"}, + {WSAEADDRINUSE, "Address already in use"}, + {WSAEADDRNOTAVAIL, "Cannot assign requested address"}, + {WSAENETDOWN, "Network is down"}, + {WSAENETUNREACH, "Network is unreachable"}, + {WSAENETRESET, "Connection dropped on network reset"}, + {WSAECONNABORTED, "Software caused connection abort"}, + {WSAECONNRESET, "Connection reset by peer"}, + {WSAENOBUFS, "No buffer space available"}, + {WSAEISCONN, "Socket is already connected"}, + {WSAENOTCONN, "Socket is not connected"}, + {WSAESHUTDOWN, "Cannot send after socket shutdown"}, + {WSAETOOMANYREFS, "Too many references"}, + {WSAETIMEDOUT, "Operation timed out"}, + {WSAECONNREFUSED, "Connection refused"}, + {WSAELOOP, "Infinite loop"}, + {WSAENAMETOOLONG, "Name too long"}, + {WSAEHOSTDOWN, "Host is down"}, + {WSAEHOSTUNREACH, "Host unreachable"}, + {WSAENOTEMPTY, "Not empty"}, + {WSAEPROCLIM, "Too many processes"}, + {WSAEUSERS, "Too many users"}, + {WSAEDQUOT, "Quota exceeded"}, + {WSAESTALE, "Stale descriptor"}, + {WSAEREMOTE, "Remote error"}, + /* + * Extended Windows Sockets error constant definitions + */ + {WSASYSNOTREADY, "Network subsystem is unavailable"}, + {WSAVERNOTSUPPORTED, "Winsock.dll version out of range"}, + {WSANOTINITIALISED, "Not yet initialized"}, + {WSAEDISCON, "Graceful shutdown in progress"}, +# ifdef WSAENOMORE + /*NB: replaced with WSA_E_NO_MORE*/ + {WSAENOMORE, "No more data available"}, +# endif /*WSAENOMORE*/ +# ifdef WSA_E_NO_MORE + {WSA_E_NO_MORE, "No more data available"}, +# endif /*WSA_E_NO_MORE*/ +# ifdef WSAECANCELLED + /*NB: replaced with WSA_E_CANCELLED*/ + {WSAECANCELLED, "Call has been cancelled"}, +# endif /*WSAECANCELLED*/ +# ifdef WSA_E_CANCELLED + {WSA_E_CANCELLED, "Call has been cancelled"}, +# endif /*WSA_E_CANCELLED*/ + {WSAEINVALIDPROCTABLE, "Invalid procedure table"}, + {WSAEINVALIDPROVIDER, "Invalid provider version number"}, + {WSAEPROVIDERFAILEDINIT,"Cannot init provider"}, + {WSASYSCALLFAILURE, "System call failed"}, + {WSASERVICE_NOT_FOUND, "Service not found"}, + {WSATYPE_NOT_FOUND, "Class type not found"}, + {WSAEREFUSED, "Query refused"}, + /* + * WinSock 2 extension + */ +# ifdef WSA_IO_PENDING + {WSA_IO_PENDING, "Operation has been queued"}, +# endif /*WSA_IO_PENDING*/ +# ifdef WSA_IO_INCOMPLETE + {WSA_IO_INCOMPLETE, "Operation still in progress"}, +# endif /*WSA_IO_INCOMPLETE*/ +# ifdef WSA_INVALID_HANDLE + {WSA_INVALID_HANDLE, "Invalid handle"}, +# endif /*WSA_INVALID_HANDLE*/ +# ifdef WSA_INVALID_PARAMETER + {WSA_INVALID_PARAMETER, "Invalid parameter"}, +# endif /*WSA_INVALID_PARAMETER*/ +# ifdef WSA_NOT_ENOUGH_MEMORY + {WSA_NOT_ENOUGH_MEMORY, "Out of memory"}, +# endif /*WSA_NOT_ENOUGH_MEMORY*/ +# ifdef WSA_OPERATION_ABORTED + {WSA_OPERATION_ABORTED, "Operation aborted"}, +# endif /*WSA_OPERATION_ABORTED*/ +# endif /*NCBI_OS_MSWIN*/ +# ifdef NCBI_OS_MSWIN +# define EAI_BASE 0 +# else +# define EAI_BASE 100000 +# endif /*NCBI_OS_MSWIN*/ +# ifdef EAI_ADDRFAMILY + {EAI_ADDRFAMILY + EAI_BASE, + "Address family not supported"}, +# endif /*EAI_ADDRFAMILY*/ +# ifdef EAI_AGAIN + {EAI_AGAIN + EAI_BASE, + "Temporary failure in name resolution"}, +# endif /*EAI_AGAIN*/ +# ifdef EAI_BADFLAGS + {EAI_BADFLAGS + EAI_BASE, + "Invalid value for lookup flags"}, +# endif /*EAI_BADFLAGS*/ +# ifdef EAI_FAIL + {EAI_FAIL + EAI_BASE, + "Non-recoverable failure in name resolution"}, +# endif /*EAI_FAIL*/ +# ifdef EAI_FAMILY + {EAI_FAMILY + EAI_BASE, + "Address family not supported"}, +# endif /*EAI_FAMILY*/ +# ifdef EAI_MEMORY + {EAI_MEMORY + EAI_BASE, + "Memory allocation failure"}, +# endif /*EAI_MEMORY*/ +# ifdef EAI_NODATA +# if EAI_NODATA != EAI_NONAME + {EAI_NODATA + EAI_BASE, + "No address associated with nodename"}, +# endif /*EAI_NODATA!=EAI_NONAME*/ +# endif /*EAI_NODATA*/ +# ifdef EAI_NONAME + {EAI_NONAME + EAI_BASE, + "Host and/or service name unknown"}, +# endif /*EAI_NONAME*/ +# ifdef EAI_OVERFLOW + {EAI_OVERFLOW + EAI_BASE, + "Argument buffer overflow"}, +# endif /*EAI_OVERFLOW*/ +# ifdef EAI_SERVICE + {EAI_SERVICE + EAI_BASE, + "Service name not supported for socket type"}, +# endif /*EAI_SERVICE*/ +# ifdef EAI_SOCKTYPE + {EAI_SOCKTYPE + EAI_BASE, + "Socket type not supported"}, +# endif /*EAI_SOCKTYPE*/ + /* GNU extensions */ +# ifdef EAI_ALLDONE + {EAI_ALLDONE + EAI_BASE, + "All requests done"}, +# endif /*EAI_ALLDONE*/ +# ifdef EAI_CANCELED + {EAI_CANCELED + EAI_BASE, + "Request canceled"}, +# endif /*EAI_BADFLAGS*/ +# ifdef EAI_INPROGRESS + {EAI_INPROGRESS + EAI_BASE, + "Processing request in progress"}, +# endif /*EAI_INPROGRESS*/ +# ifdef EAI_INTR + {EAI_INTR + EAI_BASE, + "Interrupted by a signal"}, +# endif /*EAI_INTR*/ +# ifdef EAI_NOTCANCELED + {EAI_NOTCANCELED + EAI_BASE, + "Request not canceled"}, +# endif /*EAI_NOTCANCELED*/ +# ifdef EAI_IDN_ENCODE + {EAI_IDN_ENCODE + EAI_BASE, + "IDN encoding failed"}, +# endif /*EAI_IDN_ENCODE*/ +# ifdef NCBI_OS_MSWIN +# define DNS_BASE 0 +# else +# define DNS_BASE 200000 +# endif /*NCBI_OS_MSWIN*/ +# ifdef HOST_NOT_FOUND + {HOST_NOT_FOUND + DNS_BASE, + "Host not found"}, +# endif /*HOST_NOT_FOUND*/ +# ifdef TRY_AGAIN + {TRY_AGAIN + DNS_BASE, + "DNS server failure"}, +# endif /*TRY_AGAIN*/ +# ifdef NO_RECOVERY + {NO_RECOVERY + DNS_BASE, + "Unrecoverable DNS error"}, +# endif /*NO_RECOVERY*/ +# ifdef NO_ADDRESS + {NO_ADDRESS + DNS_BASE, + "No address record found in DNS"}, +# endif /*NO_ADDRESS*/ +# ifdef NO_DATA + {NO_DATA + DNS_BASE, + "No DNS data of requested type"}, +# endif /*NO_DATA*/ + + /* Last dummy entry - must be present */ + {0, 0} + }; +#if defined(NCBI_OS_LINUX) || defined(NCBI_OS_CYGWIN) + /* To work correctly, descending order of offsets is required here */ + static const struct { + int erroff; + const char* (*errfun)(int errnum); + } errsup[] = { +# ifdef __GLIBC__ + { DNS_BASE, hstrerror }, +# endif /*__GLIBC__*/ +# if defined(HAVE_GETADDRINFO) || defined(HAVE_GETNAMEINFO) + { EAI_BASE, gai_strerror }, +# endif /*HAVE_GETADDRINFO || HAVE_GETNAMEINFO*/ + /* Last dummy entry - must present */ + { 0, 0 } + }; +#endif /*NCBI_OS_LINUX || NCBI_OS_CYGWIN*/ + size_t i; + + if (!error) + return 0; + +#if defined(NCBI_OS_LINUX) || defined(NCBI_OS_CYGWIN) + for (i = 0; i < sizeof(errsup) / sizeof(errsup[0]) - 1/*dummy*/; ++i) { + if (errsup[i].erroff - 10000 < error + && error < errsup[i].erroff + 10000) { + const char* errstr = errsup[i].errfun(error - errsup[i].erroff); + if (errstr && *errstr && strncasecmp(errstr, "Unknown ", 8)!=0) + return ERR_STRDUP(errstr); + } + } +#endif /*NCBI_OS_LINUX || NCBI_OS_CYGWIN*/ + + for (i = 0; i < sizeof(errmap) / sizeof(errmap[0]) - 1/*dummy*/; ++i) { + if (errmap[i].errnum == error) + return ERR_STRDUP(errmap[i].errstr); + } + +# if defined(NCBI_OS_MSWIN) && defined(_UNICODE) + return UTIL_TcharToUtf8(_wcserror(error)); +# else + return ERR_STRDUP(strerror(error)); +# endif /*NCBI_OS_MSWIN && _UNICODE*/ +} + + +#endif /*NCBI_INCLUDE_STRERROR_C*/ diff --git a/src/tds/util.c b/src/tds/util.c index 5d26c7c54..2404a59fd 100644 --- a/src/tds/util.c +++ b/src/tds/util.c @@ -40,6 +40,10 @@ #include #endif /* HAVE_UNISTD_H */ +#if HAVE_NETDB_H +#include +#endif /* HAVE_NETDB_H */ + #ifdef _WIN32 #include #endif @@ -48,6 +52,9 @@ #include #include +#define NCBI_INCLUDE_STRERROR_C +#include "ncbi_strerror.c" + /** * Set state of TDS connection, with logging and checking. * \param tds state information for the socket and the TDS protocol @@ -354,6 +361,7 @@ tdserror (const TDSCONTEXT * tds_ctx, TDSSOCKET * tds, int msgno, int errnum) msg.sql_state = tds_alloc_client_sqlstate(msgno); msg.oserr = errnum; + msg.osstr = errnum ? (char*) s_StrError(errnum) : NULL; /* * Call client library handler. @@ -363,6 +371,10 @@ tdserror (const TDSCONTEXT * tds_ctx, TDSSOCKET * tds, int msgno, int errnum) tdsdump_log(TDS_DBG_FUNC, "tdserror: client library returned %s(%d)\n", retname(rc), rc); TDS_ZERO_FREE(msg.sql_state); + if (errnum) { + UTIL_ReleaseBuffer(msg.osstr); + msg.osstr = NULL; + } } else { static const char msg[] = "tdserror: client library not called because either " "tds_ctx (%p) or tds_ctx->err_handler is NULL\n"; From b6ab56f8405c886255e7bbff12742ff4da5803b4 Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Tue, 28 May 2024 15:16:52 -0400 Subject: [PATCH 6/7] Address most implicit conversion warnings. - Harmonize variable, parameter, etc. data types more fully. - Adjust system API usage accordingly: -- For some string constants, use sizeof() - 1 in lieu of strlen, taking care to ensure they come from array variables. -- Keep format specifiers for printf et al. in sync with argument types. -- dbprrow: Account for the fact that printf always uses int for dynamic widths by substituting memchr + fwrite. -- odbc/prepare_query.c (prepared_rpc): Substitute atoi for strtol (already used with no endptr) when populating TDSINT4. - Cast away some remaining discrepancies where safe, in some cases by taking advantage of TDS_PUT_* macros. - ctlib.h: Explicitly define _CS_CURS_TYPE_* in terms of TDS_CURSOR_STATE_* rather than duplicating their values. - tds_parse_conf_section: To legitimize a cast, tighten debug_flags' range check on systems where int is narrower than long. - odbc_util.c: #include for ptrdiff_t (now used in odbc_set_string_flag). Signed-off-by: Aaron M. Ucko --- include/ctlib.h | 6 +- include/dblib.h | 2 +- include/freetds/convert.h | 3 +- include/freetds/odbc.h | 26 ++++-- include/freetds/tds.h | 30 ++++--- include/freetds/utils/des.h | 3 +- src/ctlib/blk.c | 2 +- src/ctlib/cs.c | 17 ++-- src/ctlib/ct.c | 16 ++-- src/ctlib/ctutil.c | 14 ++-- src/ctlib/unittests/common.h | 2 +- src/ctlib/unittests/cs_convert.c | 4 +- src/ctlib/unittests/lang_ct_param.c | 10 ++- src/ctlib/unittests/rpc_ct_param.c | 4 +- src/ctlib/unittests/rpc_ct_setparam.c | 4 +- src/ctlib/unittests/variant.c | 2 +- src/dblib/bcp.c | 5 +- src/dblib/dblib.c | 51 +++++++----- src/dblib/dbpivot.c | 46 +++++++---- src/dblib/unittests/bcp.c | 3 +- src/dblib/unittests/dbsafestr.c | 4 +- src/dblib/unittests/setnull.c | 3 +- src/dblib/unittests/string_bind.c | 2 +- src/dblib/unittests/t0013.c | 7 +- src/dblib/unittests/t0014.c | 9 ++- src/dblib/unittests/timeout.c | 3 +- src/odbc/bcp.c | 17 ++-- src/odbc/connectparams.c | 4 +- src/odbc/convert_tds2sql.c | 28 ++++--- src/odbc/descriptor.c | 4 +- src/odbc/odbc.c | 109 ++++++++++++++------------ src/odbc/odbc_checks.c | 2 +- src/odbc/odbc_util.c | 51 ++++++------ src/odbc/prepare_query.c | 20 +++-- src/odbc/sql2tds.c | 22 +++--- src/odbc/unittests/bcp.c | 5 +- src/odbc/unittests/blob1.c | 10 +-- src/odbc/unittests/c2string.c | 6 +- src/odbc/unittests/cancel.c | 2 +- src/odbc/unittests/common.c | 16 ++-- src/odbc/unittests/common.h | 4 +- src/odbc/unittests/connect2.c | 6 +- src/odbc/unittests/convert_error.c | 2 +- src/odbc/unittests/cursor7.c | 2 +- src/odbc/unittests/describecol.c | 4 +- src/odbc/unittests/freeclose.c | 2 +- src/odbc/unittests/getdata.c | 2 +- src/odbc/unittests/long_error.c | 2 +- src/odbc/unittests/params.c | 6 +- src/odbc/unittests/putdata.c | 6 +- src/odbc/unittests/raiserror.c | 3 +- src/odbc/unittests/rebindpar.c | 2 +- src/odbc/unittests/rpc.c | 2 +- src/odbc/unittests/stats.c | 2 +- src/odbc/unittests/tables.c | 6 +- src/odbc/unittests/tvp.c | 7 +- src/odbc/unittests/utf8.c | 7 +- src/odbc/winsetup.c | 2 +- src/replacements/iconv.c | 6 +- src/tds/config.c | 5 +- src/tds/convert.c | 18 +++-- src/tds/data.c | 28 +++---- src/tds/gssapi.c | 2 +- src/tds/login.c | 12 +-- src/tds/mem.c | 5 +- src/tds/net.c | 46 ++++++----- src/tds/packet.c | 10 +-- src/tds/query.c | 49 +++++++----- src/tds/read.c | 6 +- src/tds/sspi.c | 6 +- src/tds/tds_checks.c | 2 +- src/tds/token.c | 3 +- src/tds/unittests/allcolumns.c | 2 +- src/tds/unittests/charconv.c | 4 +- src/tds/unittests/convert.c | 2 +- src/tds/unittests/convert_bounds.c | 3 +- src/tds/unittests/corrupt.c | 2 +- src/tds/unittests/freeze.c | 3 +- src/tds/unittests/iconv_fread.c | 4 +- src/tds/unittests/t0007.c | 8 +- src/tds/unittests/t0008.c | 4 +- src/tds/unittests/utf8_1.c | 2 +- src/tds/vstrbuild.c | 2 +- src/tds/write.c | 2 +- src/utils/des.c | 5 +- 85 files changed, 507 insertions(+), 375 deletions(-) diff --git a/include/ctlib.h b/include/ctlib.h index 1009b4e34..f06f6d4bd 100644 --- a/include/ctlib.h +++ b/include/ctlib.h @@ -323,9 +323,9 @@ struct _cs_locale /* internal defines for cursor processing */ -#define _CS_CURS_TYPE_UNACTIONED 0 -#define _CS_CURS_TYPE_REQUESTED 1 -#define _CS_CURS_TYPE_SENT 2 +#define _CS_CURS_TYPE_UNACTIONED TDS_CURSOR_STATE_UNACTIONED +#define _CS_CURS_TYPE_REQUESTED TDS_CURSOR_STATE_REQUESTED +#define _CS_CURS_TYPE_SENT TDS_CURSOR_STATE_SENT typedef struct { CS_CHAR name[132]; diff --git a/include/dblib.h b/include/dblib.h index 60c66bbd3..ef860d9fa 100644 --- a/include/dblib.h +++ b/include/dblib.h @@ -116,7 +116,7 @@ typedef struct dboption typedef struct { const BYTE *bindval; - size_t len; + unsigned int len; } NULLREP; struct tds_dblib_dbprocess diff --git a/include/freetds/convert.h b/include/freetds/convert.h index 28ac488c6..8b7f18950 100644 --- a/include/freetds/convert.h +++ b/include/freetds/convert.h @@ -86,7 +86,8 @@ CONV_RESULT; unsigned char tds_willconvert(int srctype, int desttype); TDS_SERVER_TYPE tds_get_null_type(TDS_SERVER_TYPE srctype); -TDS_INT tds_char2hex(TDS_CHAR *dest, TDS_UINT destlen, const TDS_CHAR * src, TDS_UINT srclen); +ssize_t tds_char2hex(TDS_CHAR *dest, size_t destlen, + const TDS_CHAR * src, size_t srclen); TDS_INT tds_convert(const TDSCONTEXT *context, int srctype, const void *src, TDS_UINT srclen, int desttype, CONV_RESULT *cr); size_t tds_strftime(char *buf, size_t maxsize, const char *format, const TDSDATEREC * timeptr, int prec); diff --git a/include/freetds/odbc.h b/include/freetds/odbc.h index b17dd80cd..f7e49786e 100644 --- a/include/freetds/odbc.h +++ b/include/freetds/odbc.h @@ -152,7 +152,7 @@ struct _dheader { SQLSMALLINT sql_desc_alloc_type; /* TODO SQLLEN ?? see http://support.microsoft.com/default.aspx?scid=kb;en-us;298678 */ - SQLSMALLINT sql_desc_count; + SQLUSMALLINT sql_desc_count; SQLINTEGER sql_desc_bind_type; SQLULEN sql_desc_array_size; SQLUSMALLINT *sql_desc_array_status_ptr; @@ -632,7 +632,8 @@ typedef union { # define _WIDE # define ODBC_CHAR SQLCHAR #endif -int odbc_set_stmt_query(struct _hstmt *stmt, const ODBC_CHAR *sql, int sql_len _WIDE); +int odbc_set_stmt_query(struct _hstmt *stmt, const ODBC_CHAR *sql, + ssize_t sql_len _WIDE); void odbc_set_return_status(struct _hstmt *stmt, unsigned int n_row); void odbc_set_return_params(struct _hstmt *stmt, unsigned int n_row); @@ -642,23 +643,29 @@ int odbc_sql_to_c_type_default(int sql_type); TDS_SERVER_TYPE odbc_sql_to_server_type(TDSCONNECTION * conn, int sql_type, int sql_unsigned); TDS_SERVER_TYPE odbc_c_to_server_type(int c_type); -unsigned int odbc_get_string_size(int size, const ODBC_CHAR * str _WIDE); +size_t odbc_get_string_size(ssize_t size, const ODBC_CHAR * str _WIDE); void odbc_rdbms_version(TDSSOCKET * tds_socket, char *pversion_string); -SQLINTEGER odbc_get_param_len(const struct _drecord *drec_axd, const struct _drecord *drec_ixd, const TDS_DESC* axd, unsigned int n_row); +SQLLEN odbc_get_param_len(const struct _drecord *drec_axd, + const struct _drecord *drec_ixd, + const TDS_DESC* axd, SQLSETPOSIROW n_row); #ifdef ENABLE_ODBC_WIDE -DSTR* odbc_dstr_copy_flag(TDS_DBC *dbc, DSTR *s, int size, const ODBC_CHAR * str, int flag); +DSTR* odbc_dstr_copy_flag(TDS_DBC *dbc, DSTR *s, ssize_t size, + const ODBC_CHAR * str, int flag); #define odbc_dstr_copy(dbc, s, len, out) \ odbc_dstr_copy_flag(dbc, s, len, sizeof((out)->mb) ? (out) : (out), wide) #define odbc_dstr_copy_oct(dbc, s, len, out) \ odbc_dstr_copy_flag(dbc, s, len, out, wide|0x20) #else -DSTR* odbc_dstr_copy(TDS_DBC *dbc, DSTR *s, int size, const ODBC_CHAR * str); +DSTR* odbc_dstr_copy(TDS_DBC *dbc, DSTR *s, ssize_t size, + const ODBC_CHAR * str); #define odbc_dstr_copy_oct odbc_dstr_copy #endif -SQLRETURN odbc_set_string_flag(TDS_DBC *dbc, SQLPOINTER buffer, SQLINTEGER cbBuffer, void FAR * pcbBuffer, const char *s, int len, int flag); +SQLRETURN odbc_set_string_flag(TDS_DBC *dbc, SQLPOINTER buffer, + SQLINTEGER cbBuffer, void FAR * pcbBuffer, + const char *s, ssize_t len, int flag); #ifdef ENABLE_ODBC_WIDE #define odbc_set_string(dbc, buf, buf_len, out_len, s, s_len) \ odbc_set_string_flag(dbc, sizeof((buf)->mb) ? (buf) : (buf), buf_len, out_len, s, s_len, (wide) | (sizeof(*(out_len)) == sizeof(SQLSMALLINT)?0:0x10)) @@ -696,7 +703,10 @@ const char *odbc_skip_rpc_name(const char *s); /* * sql2tds.c */ -SQLRETURN odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _drecord *drec_axd, TDSCOLUMN *curcol, bool compute_row, const TDS_DESC* axd, unsigned int n_row); +SQLRETURN odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, + const struct _drecord *drec_axd, TDSCOLUMN *curcol, + bool compute_row, const TDS_DESC* axd, + SQLSETPOSIROW n_row); TDS_INT convert_datetime2server(int bindtype, const void *src, TDS_DATETIMEALL * dta); /* diff --git a/include/freetds/tds.h b/include/freetds/tds.h index 2be538bc3..ec21a57de 100644 --- a/include/freetds/tds.h +++ b/include/freetds/tds.h @@ -1369,7 +1369,7 @@ tds_release_cur_dyn(TDSSOCKET * tds) } void tds_dynamic_deallocated(TDSCONNECTION *conn, TDSDYNAMIC *dyn); void tds_set_cur_dyn(TDSSOCKET *tds, TDSDYNAMIC *dyn); -TDSSOCKET *tds_realloc_socket(TDSSOCKET * tds, size_t bufsize); +TDSSOCKET *tds_realloc_socket(TDSSOCKET * tds, unsigned int bufsize); char *tds_alloc_client_sqlstate(int msgno); char *tds_alloc_lookup_sqlstate(TDSSOCKET * tds, int msgno); TDSLOGIN *tds_alloc_login(int use_environment); @@ -1379,7 +1379,8 @@ TDSLOGIN *tds_init_login(TDSLOGIN * login, TDSLOCALE * locale); TDSLOCALE *tds_alloc_locale(void); void *tds_alloc_param_data(TDSCOLUMN * curparam); void tds_free_locale(TDSLOCALE * locale); -TDSCURSOR * tds_alloc_cursor(TDSSOCKET * tds, const char *name, TDS_INT namelen, const char *query, TDS_INT querylen); +TDSCURSOR * tds_alloc_cursor(TDSSOCKET * tds, const char *name, size_t namelen, + const char *query, size_t querylen); void tds_free_row(TDSRESULTINFO * res_info, unsigned char *row); TDSSOCKET *tds_alloc_socket(TDSCONTEXT * context, unsigned int bufsize); TDSSOCKET *tds_alloc_additional_socket(TDSCONNECTION *conn); @@ -1436,13 +1437,17 @@ TDSRET tds_submit_begin_tran(TDSSOCKET *tds); TDSRET tds_submit_rollback(TDSSOCKET *tds, bool cont); TDSRET tds_submit_commit(TDSSOCKET *tds, bool cont); TDSRET tds_disconnect(TDSSOCKET * tds); -size_t tds_quote_id(TDSSOCKET * tds, char *buffer, const char *id, int idlen); -size_t tds_quote_id_rpc(TDSSOCKET * tds, char *buffer, const char *id, int idlen); -size_t tds_quote_string(TDSSOCKET * tds, char *buffer, const char *str, int len); +size_t tds_quote_id(TDSSOCKET * tds, char *buffer, const char *id, + ssize_t idlen); +size_t tds_quote_id_rpc(TDSSOCKET * tds, char *buffer, const char *id, + ssize_t idlen); +size_t tds_quote_string(TDSSOCKET * tds, char *buffer, const char *str, + ssize_t len); const char *tds_skip_comment(const char *s); const char *tds_skip_quoted(const char *s); size_t tds_fix_column_size(TDSSOCKET * tds, TDSCOLUMN * curcol); -const char *tds_convert_string(TDSSOCKET * tds, TDSICONV * char_conv, const char *s, int len, size_t *out_len); +const char *tds_convert_string(TDSSOCKET * tds, TDSICONV * char_conv, + const char *s, ssize_t len, size_t *out_len); void tds_convert_string_free(const char *original, const char *converted); #if !ENABLE_EXTRA_CHECKS #define tds_convert_string_free(original, converted) \ @@ -1571,14 +1576,17 @@ int tds7_get_instance_ports(FILE *output, struct addrinfo *addr); int tds7_get_instance_port(struct addrinfo *addr, const char *instance); char *tds_prwsaerror(int erc); void tds_prwsaerror_free(char *s); -int tds_connection_read(TDSSOCKET * tds, unsigned char *buf, int buflen); -int tds_connection_write(TDSSOCKET *tds, const unsigned char *buf, int buflen, int final); +ssize_t tds_connection_read(TDSSOCKET * tds, unsigned char *buf, + size_t buflen); +ssize_t tds_connection_write(TDSSOCKET *tds, const unsigned char *buf, + size_t buflen, int final); #define TDSSELREAD POLLIN #define TDSSELWRITE POLLOUT int tds_select(TDSSOCKET * tds, unsigned tds_sel, int timeout_seconds); void tds_connection_close(TDSCONNECTION *conn); -int tds_goodread(TDSSOCKET * tds, unsigned char *buf, int buflen); -int tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, size_t buflen); +ssize_t tds_goodread(TDSSOCKET * tds, unsigned char *buf, size_t buflen); +ssize_t tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, + size_t buflen); void tds_socket_flush(TDS_SYS_SOCKET sock); int tds_socket_set_nonblocking(TDS_SYS_SOCKET sock); int tds_wakeup_init(TDSPOLLWAKEUP *wakeup); @@ -1614,7 +1622,7 @@ typedef struct tds_freeze { } TDSFREEZE; void tds_freeze(TDSSOCKET *tds, TDSFREEZE *freeze, unsigned size_len); -size_t tds_freeze_written(TDSFREEZE *freeze); +unsigned int tds_freeze_written(TDSFREEZE *freeze); TDSRET tds_freeze_abort(TDSFREEZE *freeze); TDSRET tds_freeze_close(TDSFREEZE *freeze); TDSRET tds_freeze_close_len(TDSFREEZE *freeze, int32_t size); diff --git a/include/freetds/utils/des.h b/include/freetds/utils/des.h index cf63ae6b8..a90315a9f 100644 --- a/include/freetds/utils/des.h +++ b/include/freetds/utils/des.h @@ -27,7 +27,8 @@ void tds_des_encrypt(const DES_KEY * key, des_cblock block); #endif void tds_des_set_odd_parity(des_cblock key); -int tds_des_ecb_encrypt(const void *plaintext, int len, DES_KEY * akey, uint8_t *output); +int tds_des_ecb_encrypt(const void *plaintext, size_t len, DES_KEY * akey, + uint8_t *output); #include diff --git a/src/ctlib/blk.c b/src/ctlib/blk.c index 34aeaccdd..7540e9809 100644 --- a/src/ctlib/blk.c +++ b/src/ctlib/blk.c @@ -214,7 +214,7 @@ blk_describe(CS_BLKDESC * blkdesc, CS_INT item, CS_DATAFMT * datafmt_arg) curcol = blkdesc->bcpinfo.bindinfo->columns[item - 1]; /* name is always null terminated */ strlcpy(datafmt->name, tds_dstr_cstr(&curcol->column_name), sizeof(datafmt->name)); - datafmt->namelen = strlen(datafmt->name); + datafmt->namelen = (CS_INT) strlen(datafmt->name); /* need to turn the SYBxxx into a CS_xxx_TYPE */ datatype = _ct_get_client_type(curcol, true); if (datatype == CS_ILLEGAL_TYPE) diff --git a/src/ctlib/cs.c b/src/ctlib/cs.c index 8a29bbcba..0de81965c 100644 --- a/src/ctlib/cs.c +++ b/src/ctlib/cs.c @@ -1114,7 +1114,8 @@ cs_locale(CS_CONTEXT * ctx, CS_INT action, CS_LOCALE * locale, CS_INT type, CS_V switch (type) { case CS_SYB_CHARSET: - tlen = (locale->charset ? strlen(locale->charset) : 0) + 1; + tlen = (locale->charset ? (int) strlen(locale->charset) + : 0) + 1; if (buflen < tlen) { if (outlen) @@ -1129,7 +1130,8 @@ cs_locale(CS_CONTEXT * ctx, CS_INT action, CS_LOCALE * locale, CS_INT type, CS_V break; case CS_SYB_LANG: - tlen = (locale->language ? strlen(locale->language) : 0) + 1; + tlen = (locale->language ? + (int) strlen(locale->language) : 0) + 1; if (buflen < tlen) { if (outlen) @@ -1147,8 +1149,10 @@ cs_locale(CS_CONTEXT * ctx, CS_INT action, CS_LOCALE * locale, CS_INT type, CS_V { int clen; - tlen = (locale->language ? strlen(locale->language) : 0) + 1; - clen = (locale->charset ? strlen(locale->charset) : 0) + 1; + tlen = (locale->language ? + (int) strlen(locale->language) : 0) + 1; + clen = (locale->charset ? + (int) strlen(locale->charset) : 0) + 1; if (buflen < (tlen + clen)) { @@ -1162,7 +1166,7 @@ cs_locale(CS_CONTEXT * ctx, CS_INT action, CS_LOCALE * locale, CS_INT type, CS_V ((char *)buffer)[0] = '\0'; strcat((char *)buffer, "."); if (locale->charset) { - tlen = strlen((char *)buffer); + tlen = (int) strlen((char *)buffer); strcpy((char *)buffer + tlen, locale->charset); } code = CS_SUCCEED; @@ -1170,7 +1174,8 @@ cs_locale(CS_CONTEXT * ctx, CS_INT action, CS_LOCALE * locale, CS_INT type, CS_V } case CS_SYB_SORTORDER: - tlen = (locale->collate ? strlen(locale->collate) : 0) + 1; + tlen = (locale->collate ? (int) strlen(locale->collate) + : 0) + 1; if (buflen < tlen) { if (outlen) diff --git a/src/ctlib/ct.c b/src/ctlib/ct.c index 396048e84..d6da7e55d 100644 --- a/src/ctlib/ct.c +++ b/src/ctlib/ct.c @@ -609,7 +609,7 @@ ct_con_props(CS_CONNECTION * con, CS_INT action, CS_INT property, CS_VOID * buff s = &tds_login->database; str_copy: if (out_len) - *out_len = tds_dstr_len(s); + *out_len = (CS_INT) tds_dstr_len(s); strlcpy((char *) buffer, tds_dstr_cstr(s), buflen); break; case CS_LOC_PROP: @@ -843,7 +843,7 @@ ct_cmd_alloc(CS_CONNECTION * con, CS_COMMAND ** pcmd) CS_RETCODE ct_command(CS_COMMAND * cmd, CS_INT type, const CS_VOID * buffer, CS_INT buflen, CS_INT option) { - int query_len, current_query_len; + ssize_t query_len, current_query_len; tdsdump_log(TDS_DBG_FUNC, "ct_command(%p, %d, %p, %d, %d)\n", cmd, type, buffer, buflen, option); @@ -2495,7 +2495,7 @@ ct_describe(CS_COMMAND * cmd, CS_INT item, CS_DATAFMT * datafmt_arg) curcol = resinfo->columns[item - 1]; /* name is always null terminated */ strlcpy(datafmt->name, tds_dstr_cstr(&curcol->column_name), sizeof(datafmt->name)); - datafmt->namelen = strlen(datafmt->name); + datafmt->namelen = (TDS_INT) strlen(datafmt->name); /* need to turn the SYBxxx into a CS_xxx_TYPE */ datafmt->datatype = _ct_get_client_type(curcol, true); if (datafmt->datatype == CS_ILLEGAL_TYPE) @@ -2636,7 +2636,8 @@ ct_config(CS_CONTEXT * ctx, CS_INT action, CS_INT property, CS_VOID * buffer, CS ); ((char*)buffer)[buflen - 1]= 0; if (*outlen < 0) - *outlen = strlen((char*) buffer); + *outlen = (CS_INT) + strlen((char*) buffer); ret = CS_SUCCEED; } break; @@ -2656,7 +2657,8 @@ ct_config(CS_CONTEXT * ctx, CS_INT action, CS_INT property, CS_VOID * buffer, CS *outlen= snprintf((char*) buffer, buflen, "%s", settings->freetds_version); ((char*)buffer)[buflen - 1]= 0; if (*outlen < 0) - *outlen = strlen((char*) buffer); + *outlen = (CS_INT) + strlen((char*) buffer); ret = CS_SUCCEED; } break; @@ -2771,7 +2773,7 @@ ct_cmd_props(CS_COMMAND * cmd, CS_INT action, CS_INT property, CS_VOID * buffer, if ((CS_INT) len >= buflen) return CS_FAIL; strcpy((char*) buffer, cursor->cursor_name); - if (outlen) *outlen = len; + if (outlen) *outlen = (CS_INT) len; } if (property == CS_CUR_ROWCOUNT) { *(CS_INT *)buffer = cursor->cursor_rows; @@ -3312,7 +3314,7 @@ ct_capability(CS_CONNECTION * con, CS_INT action, CS_INT type, CS_INT capability CS_RETCODE ct_dynamic(CS_COMMAND * cmd, CS_INT type, CS_CHAR * id, CS_INT idlen, CS_CHAR * buffer, CS_INT buflen) { - int query_len; + size_t query_len; CS_CONNECTION *con; CS_DYNAMIC *dyn; diff --git a/src/ctlib/ctutil.c b/src/ctlib/ctutil.c index 3853d0f7f..f0adde041 100644 --- a/src/ctlib/ctutil.c +++ b/src/ctlib/ctutil.c @@ -125,7 +125,7 @@ _ct_handle_client_message(const TDSCONTEXT * ctx_tds, TDSSOCKET * tds, TDSMESSAG errmsg.msgnumber = msg->msgno; errmsg.severity = _ct_translate_severity(msg->severity); strlcpy(errmsg.msgstring, msg->message, sizeof(errmsg.msgstring)); - errmsg.msgstringlen = strlen(errmsg.msgstring); + errmsg.msgstringlen = (CS_INT) strlen(errmsg.msgstring); if (msg->osstr) { errmsg.osstringlen = (CS_INT) strlen(msg->osstr); strlcpy(errmsg.osstring, msg->osstr, CS_MAX_MSG); @@ -184,18 +184,18 @@ _ct_handle_server_message(const TDSCONTEXT * ctx_tds, TDSSOCKET * tds, TDSMESSAG memset(&errmsg, '\0', sizeof(errmsg)); errmsg.common.msgnumber = msg->msgno; strlcpy(errmsg.common.text, msg->message, sizeof(errmsg.common.text)); - errmsg.common.textlen = strlen(errmsg.common.text); + errmsg.common.textlen = (CS_INT) strlen(errmsg.common.text); errmsg.common.state = msg->state; errmsg.common.severity = msg->severity; #define MIDDLE_PART(part) do { \ common2 = (CS_SERVERMSG_COMMON2 *) &(errmsg.part.line); \ if (msg->server) { \ - errmsg.part.svrnlen = strlen(msg->server); \ + errmsg.part.svrnlen = (CS_INT) strlen(msg->server); \ strlcpy(errmsg.part.svrname, msg->server, sizeof(errmsg.part.svrname)); \ } \ if (msg->proc_name) { \ - errmsg.part.proclen = strlen(msg->proc_name); \ + errmsg.part.proclen = (CS_INT) strlen(msg->proc_name); \ strlcpy(errmsg.part.proc, msg->proc_name, sizeof(errmsg.part.proc)); \ } \ } while(0) @@ -209,7 +209,7 @@ _ct_handle_server_message(const TDSCONTEXT * ctx_tds, TDSSOCKET * tds, TDSMESSAG common2->sqlstate[0] = 0; if (msg->sql_state) strlcpy((char *) common2->sqlstate, msg->sql_state, sizeof(common2->sqlstate)); - common2->sqlstatelen = strlen((char *) common2->sqlstate); + common2->sqlstatelen = (CS_INT) strlen((char *) common2->sqlstate); common2->line = msg->line_number; /* if there is no connection, attempt to call the context handler */ @@ -273,7 +273,7 @@ _ct_datafmt_conv_in(CS_CONTEXT * ctx, const CS_DATAFMT * datafmt, CS_DATAFMT_LAR small = (const CS_DATAFMT_SMALL *) datafmt; strlcpy(fmtbuf->name, small->name, sizeof(fmtbuf->name)); - fmtbuf->namelen = strlen(fmtbuf->name); + fmtbuf->namelen = (CS_INT) strlen(fmtbuf->name); *((CS_DATAFMT_COMMON *) &fmtbuf->datatype) = *((CS_DATAFMT_COMMON *) &small->datatype); return fmtbuf; } @@ -317,7 +317,7 @@ _ct_datafmt_conv_back(CS_DATAFMT * datafmt, CS_DATAFMT_LARGE *fmtbuf) small = (CS_DATAFMT_SMALL *) datafmt; strlcpy(small->name, fmtbuf->name, sizeof(small->name)); - small->namelen = strlen(small->name); + small->namelen = (CS_INT) strlen(small->name); *((CS_DATAFMT_COMMON *) &small->datatype) = *((CS_DATAFMT_COMMON *) &fmtbuf->datatype); } diff --git a/src/ctlib/unittests/common.h b/src/ctlib/unittests/common.h index 9f6a72cb5..22dffe10e 100644 --- a/src/ctlib/unittests/common.h +++ b/src/ctlib/unittests/common.h @@ -17,7 +17,7 @@ typedef struct char USER[512]; char PASSWORD[512]; char fverbose; - int maxlength; + long maxlength; } COMMON_PWD; extern COMMON_PWD common_pwd; diff --git a/src/ctlib/unittests/cs_convert.c b/src/ctlib/unittests/cs_convert.c index c782518ce..eedaeb6df 100644 --- a/src/ctlib/unittests/cs_convert.c +++ b/src/ctlib/unittests/cs_convert.c @@ -19,7 +19,7 @@ static CS_INT dest_format = CS_FMT_UNUSED; static int DoTest( /* source information */ - CS_INT fromtype, void *fromdata, CS_INT fromlen, + CS_INT fromtype, void *fromdata, size_t fromlen, /* to information */ CS_INT totype, CS_INT tomaxlen, /* expected result */ @@ -46,7 +46,7 @@ DoTest( memset(&srcfmt, 0, sizeof(srcfmt)); srcfmt.datatype = fromtype; - srcfmt.maxlength = fromlen; + srcfmt.maxlength = (CS_INT) fromlen; /* * FIXME this fix some thing but if error cs_convert should return diff --git a/src/ctlib/unittests/lang_ct_param.c b/src/ctlib/unittests/lang_ct_param.c index 4478428a4..89e765a2c 100644 --- a/src/ctlib/unittests/lang_ct_param.c +++ b/src/ctlib/unittests/lang_ct_param.c @@ -108,7 +108,7 @@ insert_test(CS_CONNECTION *conn, CS_COMMAND *cmd, int useNames) memset(&srcfmt, 0, sizeof(CS_DATAFMT)); srcfmt.datatype = CS_CHAR_TYPE; - srcfmt.maxlength = strlen(moneystring); + srcfmt.maxlength = (CS_INT) strlen(moneystring); srcfmt.precision = 5; srcfmt.scale = 2; srcfmt.locale = NULL; @@ -142,7 +142,7 @@ insert_test(CS_CONNECTION *conn, CS_COMMAND *cmd, int useNames) /* * create the command */ - if ((ret = ct_command(cmd, CS_LANG_CMD, query, strlen(query), + if ((ret = ct_command(cmd, CS_LANG_CMD, query, (CS_INT) strlen(query), CS_UNUSED)) != CS_SUCCEED) { fprintf(stderr, "ct_command(CS_LANG_CMD) failed\n"); @@ -167,7 +167,8 @@ insert_test(CS_CONNECTION *conn, CS_COMMAND *cmd, int useNames) * The character string variable is filled in by the RPC so pass NULL * for the data 0 for data length, and -1 for the indicator arguments. */ - ret = ct_param(cmd, &datafmt, dummy_name, strlen(dummy_name), 0); + ret = ct_param(cmd, &datafmt, dummy_name, (CS_INT) strlen(dummy_name), + 0); if (CS_SUCCEED != ret) { fprintf(stderr, "ct_param(char) failed\n"); return 1; @@ -182,7 +183,8 @@ insert_test(CS_CONNECTION *conn, CS_COMMAND *cmd, int useNames) datafmt.datatype = CS_CHAR_TYPE; datafmt.status = CS_INPUTVALUE; - ret = ct_param(cmd, &datafmt, dummy_name2, strlen(dummy_name2), 0); + ret = ct_param(cmd, &datafmt, dummy_name2, + (CS_INT) strlen(dummy_name2), 0); if (CS_SUCCEED != ret) { fprintf(stderr, "ct_param(char) failed\n"); return 1; diff --git a/src/ctlib/unittests/rpc_ct_param.c b/src/ctlib/unittests/rpc_ct_param.c index 9ae1e8984..e016c7be6 100644 --- a/src/ctlib/unittests/rpc_ct_param.c +++ b/src/ctlib/unittests/rpc_ct_param.c @@ -112,7 +112,7 @@ main(void) memset(&srcfmt, 0, sizeof(CS_DATAFMT)); srcfmt.datatype = CS_CHAR_TYPE; - srcfmt.maxlength = strlen(moneystring); + srcfmt.maxlength = (CS_INT) strlen(moneystring); srcfmt.precision = 5; srcfmt.scale = 2; srcfmt.locale = NULL; @@ -552,7 +552,7 @@ CS_INT disp_len; disp_len = ex_display_dlen(&columns[i]); printf("%s", columns[i].name); fflush(stdout); - l = disp_len - strlen(columns[i].name); + l = disp_len - (CS_INT) strlen(columns[i].name); for (j = 0; j < l; j++) { fputc(' ', stdout); fflush(stdout); diff --git a/src/ctlib/unittests/rpc_ct_setparam.c b/src/ctlib/unittests/rpc_ct_setparam.c index 883cb7ceb..c96fb63b0 100644 --- a/src/ctlib/unittests/rpc_ct_setparam.c +++ b/src/ctlib/unittests/rpc_ct_setparam.c @@ -103,7 +103,7 @@ main(void) memset(&srcfmt, 0, sizeof(CS_DATAFMT)); srcfmt.datatype = CS_CHAR_TYPE; - srcfmt.maxlength = strlen(moneystring); + srcfmt.maxlength = (CS_INT) strlen(moneystring); srcfmt.precision = 5; srcfmt.scale = 2; srcfmt.locale = NULL; @@ -587,7 +587,7 @@ CS_INT disp_len; disp_len = ex_display_dlen(&columns[i]); printf("%s", columns[i].name); fflush(stdout); - l = disp_len - strlen(columns[i].name); + l = disp_len - (CS_INT) strlen(columns[i].name); for (j = 0; j < l; j++) { fputc(' ', stdout); fflush(stdout); diff --git a/src/ctlib/unittests/variant.c b/src/ctlib/unittests/variant.c index 66e8be8c5..ab616708f 100644 --- a/src/ctlib/unittests/variant.c +++ b/src/ctlib/unittests/variant.c @@ -32,7 +32,7 @@ main(void) CS_CHAR select[1024]; CS_CHAR col1[128]; - const char *expected[10]; + char *expected[10]; unsigned num_expected = 0; unsigned rows = 0; diff --git a/src/dblib/bcp.c b/src/dblib/bcp.c index 350934145..d4a18f289 100644 --- a/src/dblib/bcp.c +++ b/src/dblib/bcp.c @@ -1526,7 +1526,10 @@ _bcp_exec_in(DBPROCESS * dbproc, DBINT * rows_copied) fseeko(hostfile, row_start, SEEK_SET); while (error_row_size > 0) { - size_t chunk = error_row_size > chunk_size ? chunk_size : (size_t) error_row_size; + size_t chunk = ((size_t) error_row_size + > chunk_size) + ? chunk_size + : (size_t) error_row_size; if (!row_in_error) { if ((row_in_error = tds_new(char, chunk)) == NULL) { diff --git a/src/dblib/dblib.c b/src/dblib/dblib.c index 966cb0acd..f701f49cb 100644 --- a/src/dblib/dblib.c +++ b/src/dblib/dblib.c @@ -841,7 +841,7 @@ dbsetllong(LOGINREC * login, long value, int which) switch (which) { case DBSETPACKET: if (0 <= value && value <= 999999) { - tds_set_packet(login->tds_login, value); + tds_set_packet(login->tds_login, (int) value); return SUCCEED; } dbperror(0, SYBEBADPK, 0, (int) value, (int) login->tds_login->block_size); @@ -1061,7 +1061,7 @@ dbstring_length(DBSTRING * dbstr) } static int -dbstring_getchar(DBSTRING * dbstr, int i) +dbstring_getchar(DBSTRING * dbstr, ssize_t i) { /* tdsdump_log(TDS_DBG_FUNC, "dbstring_getchar(%p, %d)\n", dbstr, i); */ @@ -3447,7 +3447,7 @@ dbspr1rowlen(DBPROCESS * dbproc) for (col = 0; col < tds->res_info->num_cols; col++) { TDSCOLUMN *colinfo = tds->res_info->columns[col]; int collen = _get_printable_size(colinfo); - int namlen = tds_dstr_len(&colinfo->column_name); + int namlen = (int) tds_dstr_len(&colinfo->column_name); len += collen > namlen ? collen : namlen; @@ -3488,7 +3488,7 @@ dbspr1row(DBPROCESS * dbproc, char *buffer, DBINT buf_len) tds = dbproc->tds_socket; for (col = 0; col < tds->res_info->num_cols; col++) { - int padlen, collen, namlen; + size_t padlen, collen, namlen; TDSCOLUMN *colinfo = tds->res_info->columns[col]; if (colinfo->column_cur_size < 0) { len = 4; @@ -3559,17 +3559,18 @@ dbprrow(DBPROCESS * dbproc) TDSCOLUMN *colinfo; TDSRESULTINFO *resinfo; TDSSOCKET *tds; - int i, col, collen, namlen, len; + int i, col; + size_t collen, namlen, len; char dest[8192]; int desttype, srctype; TDSDATEREC when; STATUS status; - int padlen; + ssize_t padlen; int c; int selcol; int linechar; int op; - const char *opname; + const char *opname, *p; /* these are for compute rows */ DBINT computeid, num_cols, colid; @@ -3615,7 +3616,9 @@ dbprrow(DBPROCESS * dbproc) } } - printf("%.*s", len, dest); + p = memchr(dest, '\0', len); + fwrite(dest, 1, p == NULL ? len : (p - dest), + stdout); collen = _get_printable_size(colinfo); namlen = tds_dstr_len(&colinfo->column_name); padlen = (collen > namlen ? collen : namlen) - len; @@ -3645,7 +3648,7 @@ dbprrow(DBPROCESS * dbproc) computeid = status; for (i = 0;; ++i) { - if (i >= tds->num_comp_info) { + if ((TDS_UINT) i >= tds->num_comp_info) { free(col_printlens); return FAIL; } @@ -3682,7 +3685,10 @@ dbprrow(DBPROCESS * dbproc) op = dbaltop(dbproc, computeid, col); opname = dbprtype(op); printf("%s", opname); - for (i = 0; i < ((long) col_printlens[selcol - 1] - (long) strlen(opname)); i++) { + for (i = 0; + i < (col_printlens[selcol - 1] + - (int) strlen(opname)); + i++) { if ((c = dbstring_getchar(dbproc->dbopts[DBPRPAD].param, 0)) >= 0) putchar(c); } @@ -3760,7 +3766,9 @@ dbprrow(DBPROCESS * dbproc) putchar(c); } } - printf("%.*s", len, dest); + p = memchr(dest, '\0', len); + fwrite(dest, 1, p == NULL ? len : (p - dest), + stdout); collen = _get_printable_size(colinfo); namlen = tds_dstr_len(&colinfo->column_name); padlen = (collen > namlen ? collen : namlen) - len; @@ -3879,7 +3887,7 @@ dbsprline(DBPROCESS * dbproc, char *buffer, DBINT buf_len, DBCHAR line_char) TDSCOLUMN *colinfo; TDSRESULTINFO *resinfo; TDSSOCKET *tds; - int i, col, len, collen, namlen; + size_t i, col, len, collen, namlen; int c; tdsdump_log(TDS_DBG_FUNC, "dbsprline(%p, %s, %d, '%c')\n", dbproc, buffer, buf_len, line_char); @@ -3937,7 +3945,8 @@ dbsprhead(DBPROCESS * dbproc, char *buffer, DBINT buf_len) TDSCOLUMN *colinfo; TDSRESULTINFO *resinfo; TDSSOCKET *tds; - int i, col, collen, namlen; + int i, collen, namlen; + TDS_USMALLINT col; int padlen; int c; @@ -3951,7 +3960,7 @@ dbsprhead(DBPROCESS * dbproc, char *buffer, DBINT buf_len) for (col = 0; col < resinfo->num_cols; col++) { colinfo = resinfo->columns[col]; collen = _get_printable_size(colinfo); - namlen = tds_dstr_len(&colinfo->column_name); + namlen = (int) tds_dstr_len(&colinfo->column_name); padlen = (collen > namlen ? collen : namlen) - namlen; if (buf_len < namlen) { return FAIL; @@ -4001,8 +4010,8 @@ dbprhead(DBPROCESS * dbproc) TDSCOLUMN *colinfo; TDSRESULTINFO *resinfo; TDSSOCKET *tds; - int i, col, len, collen, namlen; - int padlen; + size_t i, col, len, collen, namlen; + size_t padlen; int c; tdsdump_log(TDS_DBG_FUNC, "dbprhead(%p)\n", dbproc); @@ -4982,7 +4991,7 @@ dbnumalts(DBPROCESS * dbproc, int computeid) TDSSOCKET *tds; TDSCOMPUTEINFO *info; TDS_SMALLINT compute_id; - int i; + TDS_UINT i; tdsdump_log(TDS_DBG_FUNC, "dbnumalts(%p, %d)\n", dbproc, computeid); CHECK_PARAMETER(dbproc, SYBENULL, -1); @@ -5040,7 +5049,7 @@ dbbylist(DBPROCESS * dbproc, int computeid, int *size) { TDSSOCKET *tds; TDSCOMPUTEINFO *info; - int i; + TDS_UINT i; const TDS_SMALLINT byte_flag = -0x8000; tdsdump_log(TDS_DBG_FUNC, "dbbylist(%p, %d, %p)\n", dbproc, computeid, size); @@ -8175,7 +8184,8 @@ dbperror(DBPROCESS *dbproc, DBINT msgno, long errnum, ...) const DBLIB_ERROR_MESSAGE *msg = &default_message; int i, rc = INT_CANCEL; - const char *os_msgtext = strerror(errnum), *rc_name = "logic error"; + const char *os_msgtext = strerror((int) errnum), + *rc_name = "logic error"; char rc_buf[16]; tdsdump_log(TDS_DBG_FUNC, "dbperror(%p, %d, %ld)\n", dbproc, msgno, errnum); /* dbproc can be NULL */ @@ -8250,7 +8260,8 @@ dbperror(DBPROCESS *dbproc, DBINT msgno, long errnum, ...) msgno, msg->msgtext); /* call the error handler */ - rc = (*_dblib_err_handler)(dbproc, msg->severity, msgno, errnum, (char*) msg->msgtext, (char*) os_msgtext); + rc = (*_dblib_err_handler)(dbproc, msg->severity, msgno, (int) errnum, + (char*) msg->msgtext, (char*) os_msgtext); switch (rc) { case INT_EXIT: rc_name = "INT_EXIT"; diff --git a/src/dblib/dbpivot.c b/src/dblib/dbpivot.c index 5b59dea59..52a0ad7ae 100644 --- a/src/dblib/dbpivot.c +++ b/src/dblib/dbpivot.c @@ -91,7 +91,7 @@ struct col_t static TDS_SERVER_TYPE infer_col_type(int sybtype); static struct col_t * -col_init(struct col_t *pcol, int sybtype, int collen) +col_init(struct col_t *pcol, int sybtype, size_t collen) { assert(pcol); @@ -653,7 +653,7 @@ agg_equal(const AGG_T *p1, const AGG_T *p2) #define tds_alloc_column() ((TDSCOLUMN*) calloc(1, sizeof(TDSCOLUMN))) static TDSRESULTINFO * -alloc_results(size_t num_cols) +alloc_results(TDS_USMALLINT num_cols) { TDSRESULTINFO *res_info; TDSCOLUMN **ppcol; @@ -716,7 +716,8 @@ struct metadata_t { KEY_T *pacross; char *name; struct col_t col; }; static bool -reinit_results(TDSSOCKET * tds, size_t num_cols, const struct metadata_t meta[]) +reinit_results(TDSSOCKET * tds, TDS_USMALLINT num_cols, + const struct metadata_t meta[]) { TDSRESULTINFO *info; int i; @@ -778,7 +779,8 @@ typedef struct pivot_t AGG_T *output; KEY_T *across; - size_t nout, nacross; + size_t nout; + TDS_USMALLINT nacross; } PIVOT_T; static bool @@ -851,8 +853,10 @@ dbnextrow_pivoted(DBPROCESS *dbproc, PIVOT_T *pp) } else { AGG_T *pcan; key_cpy(&candidate.col_key, (KEY_T *) pcol->bcp_terminator); - if ((pcan = tds_find(&candidate, pout, pp->output + pp->nout - pout, - sizeof(*pp->output), (compare_func) agg_next)) != NULL) { + if ((pcan = (AGG_T *) tds_find + (&candidate, pout, pp->output + pp->nout - pout, + sizeof(*pp->output), (compare_func) agg_next)) + != NULL) { /* flag this output as used */ pout->row_key.keys = NULL; pval = &pcan->value; @@ -867,11 +871,11 @@ dbnextrow_pivoted(DBPROCESS *dbproc, PIVOT_T *pp) assert(pval); pcol->column_size = pval->len; - pcol->column_data = col_buffer(pval); + pcol->column_data = (unsigned char *) col_buffer(pval); copy_data_to_host_var( dbproc, pval->type, - col_buffer(pval), + (BYTE *) col_buffer(pval), pval->len, (BYTE *) pcol->column_varaddr, pcol->column_bindlen, @@ -909,7 +913,8 @@ dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, DBPIVOT_F PIVOT_T P, *pp; AGG_T input, *pout = NULL; struct metadata_t *metadata, *pmeta; - size_t i, nmeta = 0; + int i; + TDS_USMALLINT nmeta = 0; tdsdump_log(TDS_DBG_FUNC, "dbpivot(%p, %d,%p, %d,%p, %p, %d)\n", dbproc, nkeys, keys, ncols, cols, func, val); if (logalot) { @@ -934,8 +939,10 @@ dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, DBPIVOT_F memset(&input, 0, sizeof(input)); P.dbproc = dbproc; - if ((pp = tds_find(&P, pivots, npivots, sizeof(*pivots), (compare_func) pivot_key_equal)) == NULL ) { - pp = TDS_RESIZE(pivots, 1 + npivots); + if ((pp = (PIVOT_T *) tds_find(&P, pivots, npivots, sizeof(*pivots), + (compare_func) pivot_key_equal)) + == NULL) { + pp = (PIVOT_T *) TDS_RESIZE(pivots, 1 + npivots); if (!pp) return FAIL; pp += npivots++; @@ -955,7 +962,9 @@ dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, DBPIVOT_F if (!col_init(input.row_key.keys+i, type, len)) return FAIL; - if (FAIL == dbbind(dbproc, keys[i], bind_type(type), input.row_key.keys[i].len, col_buffer(input.row_key.keys+i))) + if (FAIL == dbbind(dbproc, keys[i], bind_type(type), + (DBINT) input.row_key.keys[i].len, + (BYTE *) col_buffer(input.row_key.keys+i))) return FAIL; if (FAIL == dbnullbind(dbproc, keys[i], &input.row_key.keys[i].null_indicator)) return FAIL; @@ -971,7 +980,9 @@ dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, DBPIVOT_F if (!col_init(input.col_key.keys+i, type, len)) return FAIL; - if (FAIL == dbbind(dbproc, cols[i], bind_type(type), input.col_key.keys[i].len, col_buffer(input.col_key.keys+i))) + if (FAIL == dbbind(dbproc, cols[i], bind_type(type), + (DBINT) input.col_key.keys[i].len, + (BYTE *) col_buffer(input.col_key.keys+i))) return FAIL; if (FAIL == dbnullbind(dbproc, cols[i], &input.col_key.keys[i].null_indicator)) return FAIL; @@ -984,7 +995,9 @@ dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, DBPIVOT_F if (!col_init(&input.value, type, len)) return FAIL; - if (FAIL == dbbind(dbproc, val, bind_type(type), input.value.len, col_buffer(&input.value))) + if (FAIL == dbbind(dbproc, val, bind_type(type), + input.value.len, + (BYTE *) col_buffer(&input.value))) return FAIL; if (FAIL == dbnullbind(dbproc, val, &input.value.null_indicator)) return FAIL; @@ -992,7 +1005,10 @@ dbpivot(DBPROCESS *dbproc, int nkeys, int *keys, int ncols, int *cols, DBPIVOT_F while ((pp->status = dbnextrow(dbproc)) == REG_ROW) { /* add to unique list of crosstab columns */ - if (tds_find(&input.col_key, pp->across, pp->nacross, sizeof(*pp->across), (compare_func) key_equal) == NULL) { + if ((AGG_T *) tds_find(&input.col_key, pp->across, pp->nacross, + sizeof(*pp->across), + (compare_func) key_equal) + == NULL) { if (!TDS_RESIZE(pp->across, 1 + pp->nacross)) return FAIL; key_cpy(pp->across + pp->nacross, &input.col_key); diff --git a/src/dblib/unittests/bcp.c b/src/dblib/unittests/bcp.c index 3644fa5fb..7e4d34815 100644 --- a/src/dblib/unittests/bcp.c +++ b/src/dblib/unittests/bcp.c @@ -72,7 +72,8 @@ init(DBPROCESS * dbproc, const char *name) } #define VARCHAR_BIND(x) \ - bcp_bind( dbproc, (unsigned char *) &x, prefixlen, strlen(x), NULL, termlen, SYBVARCHAR, col++ ) + bcp_bind( dbproc, (unsigned char *) &x, prefixlen, (DBINT) strlen(x), \ + NULL, termlen, SYBVARCHAR, col++ ) #define INT_BIND(x) \ bcp_bind( dbproc, (unsigned char *) &x, prefixlen, -1, NULL, termlen, SYBINT4, col++ ) diff --git a/src/dblib/unittests/dbsafestr.c b/src/dblib/unittests/dbsafestr.c index dd25e7514..395e84690 100644 --- a/src/dblib/unittests/dbsafestr.c +++ b/src/dblib/unittests/dbsafestr.c @@ -10,7 +10,7 @@ static int failed = 0; /* unsafestr must contain one quote of each type */ -static const char *unsafestr = "This is a string with ' and \" in it."; +static const char unsafestr[] = "This is a string with ' and \" in it."; /* safestr must be at least strlen(unsafestr) + 3 */ static char safestr[100]; @@ -28,7 +28,7 @@ main(int argc TDS_UNUSED, char **argv) dbinit(); - len = strlen(unsafestr); + len = sizeof(unsafestr) - 1; ret = dbsafestr(NULL, unsafestr, -1, safestr, len, DBSINGLE); if (ret != FAIL) failed++; diff --git a/src/dblib/unittests/setnull.c b/src/dblib/unittests/setnull.c index c3049d096..c7d62573d 100644 --- a/src/dblib/unittests/setnull.c +++ b/src/dblib/unittests/setnull.c @@ -16,7 +16,8 @@ char_test(const char *null, int bindlen, const char *expected) if (null) { fprintf(stderr, "\tdbsetnull(CHARBIND, %u, '%s').\n", (unsigned int) strlen(null), null); - ret = dbsetnull(dbproc, CHARBIND, strlen(null), (BYTE *) null); + ret = dbsetnull(dbproc, CHARBIND, (int) strlen(null), + (BYTE *) null); if (ret != SUCCEED) { fprintf(stderr, "dbsetnull returned error %d\n", (int) ret); failed = 1; diff --git a/src/dblib/unittests/string_bind.c b/src/dblib/unittests/string_bind.c index 9e200277c..6518927d4 100644 --- a/src/dblib/unittests/string_bind.c +++ b/src/dblib/unittests/string_bind.c @@ -14,7 +14,7 @@ static void test_row(int vartype, const char *vartype_name, const char *expected, int line) { char str[11]; - int i; + size_t i; printf("%d: row type %s bind len %d\n", line, vartype_name, bind_len); diff --git a/src/dblib/unittests/t0013.c b/src/dblib/unittests/t0013.c index 69d9ed88e..0256737c0 100644 --- a/src/dblib/unittests/t0013.c +++ b/src/dblib/unittests/t0013.c @@ -37,12 +37,13 @@ test(int argc, char **argv, int over4k) int i; DBINT testint; FILE *fp; - long result, isiz; + ssize_t result; + long isiz; char *blob, *rblob; DBBINARY *textPtr = NULL, *timeStamp = NULL; char objname[256]; char rbuf[BLOB_BLOCK_SIZE]; - long numread; + size_t numread; int data_ok; int numtowrite, numwritten; set_malloc_options(); @@ -263,7 +264,7 @@ test(int argc, char **argv, int over4k) data_ok = 0; } - printf("Read blob data row %d --> %s %ld byte comparison\n", + printf("Read blob data row %d --> %s %zu byte comparison\n", (int) testint, data_ok ? "PASSED" : "failed", numread); free(rblob); diff --git a/src/dblib/unittests/t0014.c b/src/dblib/unittests/t0014.c index 0c494155d..c3b4e8add 100644 --- a/src/dblib/unittests/t0014.c +++ b/src/dblib/unittests/t0014.c @@ -19,13 +19,14 @@ test(int argc, char **argv, int over4k) int i; DBINT testint; FILE *fp; - long result, isiz; + ssize_t result; + long isiz; char *blob, *rblob; unsigned char *textPtr, *timeStamp; char objname[256]; char sqlCmd[256]; char rbuf[BLOB_BLOCK_SIZE]; - long numread; + size_t numread; int numtowrite, numwritten; set_malloc_options(); @@ -224,11 +225,11 @@ test(int argc, char **argv, int over4k) return 3; } - result = fwrite((void *) rblob, numread, 1, fp); + result = (long) fwrite((void *) rblob, numread, 1, fp); fclose(fp); } - printf("Read blob data row %d --> %s %ld byte comparison\n", + printf("Read blob data row %d --> %s %zu byte comparison\n", (int) testint, (memcmp(blob, rblob, numread)) ? "failed" : "PASSED", numread); free(rblob); } diff --git a/src/dblib/unittests/timeout.c b/src/dblib/unittests/timeout.c index cc4b8ca4b..e37944197 100644 --- a/src/dblib/unittests/timeout.c +++ b/src/dblib/unittests/timeout.c @@ -206,7 +206,8 @@ test(int per_process) start_time = time(NULL); /* keep track of when we started for reporting purposes */ ntimeouts = 0; - dbsetinterrupt(dbproc, (void*)chkintr, (void*)hndlintr); + dbsetinterrupt(dbproc, (DB_DBCHKINTR_FUNC)chkintr, + (DB_DBHNDLINTR_FUNC)hndlintr); if (FAIL == dbsqlsend(dbproc)) { fprintf(stderr, "Failed: dbsend\n"); diff --git a/src/odbc/bcp.c b/src/odbc/bcp.c index 9d71fb457..d57d6e600 100644 --- a/src/odbc/bcp.c +++ b/src/odbc/bcp.c @@ -422,14 +422,14 @@ _bcp_iconv_helper(const TDS_DBC *dbc, const TDSCOLUMN *bindcol, const TDS_CHAR * return destlen; } -static SQLLEN +static TDS_INT _tdsodbc_dbconvert(TDS_DBC *dbc, int srctype, const TDS_CHAR * src, SQLLEN src_len, int desttype, unsigned char * dest, TDSCOLUMN *bindcol) { CONV_RESULT dres; - SQLLEN ret; - SQLLEN len; - SQLLEN destlen = bindcol->column_size; + TDS_INT ret; + TDS_INT len; + TDS_INT destlen = bindcol->column_size; TDS_DATETIMEALL dta; TDS_NUMERIC num; SQL_NUMERIC_STRUCT * sql_num; @@ -473,10 +473,12 @@ _tdsodbc_dbconvert(TDS_DBC *dbc, int srctype, const TDS_CHAR * src, SQLLEN src_l /* oft times we are asked to convert a data type to itself */ if ((srctype == desttype || is_similar_type(srctype, desttype)) && !always_convert) { if (is_char_type(desttype)) { - ret = _bcp_iconv_helper(dbc, bindcol, src, src_len, (char *)dest, destlen); + ret = (TDS_INT) _bcp_iconv_helper + (dbc, bindcol, src, src_len, + (char *)dest, destlen); } else { - ret = destlen < src_len ? destlen : src_len; + ret = destlen < src_len ? destlen : (TDS_INT) src_len; memcpy(dest, src, ret); } return ret; @@ -529,7 +531,8 @@ _tdsodbc_dbconvert(TDS_DBC *dbc, int srctype, const TDS_CHAR * src, SQLLEN src_l case SYBCHAR: case SYBVARCHAR: case SYBTEXT: - ret = _bcp_iconv_helper(dbc, bindcol, dres.c, len, (char *)dest, destlen); + ret = (TDS_INT) _bcp_iconv_helper(dbc, bindcol, dres.c, len, + (char *) dest, destlen); free(dres.c); break; default: diff --git a/src/odbc/connectparams.c b/src/odbc/connectparams.c index 46e2ce20c..28e09755f 100644 --- a/src/odbc/connectparams.c +++ b/src/odbc/connectparams.c @@ -578,7 +578,7 @@ tdoParseProfile(const char *option, const char *value, void *param) if (strcasecmp(p->entry, option) == 0) { strlcpy(p->buffer, value, p->buffer_len); - p->ret_val = strlen(p->buffer); + p->ret_val = (int) strlen(p->buffer); p->found = 1; } return true; @@ -631,7 +631,7 @@ SQLGetPrivateProfileString(LPCSTR pszSection, LPCSTR pszEntry, LPCSTR pszDefault if (pszDefault && !param.found) { strlcpy(pRetBuffer, pszDefault, nRetBuffer); - param.ret_val = strlen(pRetBuffer); + param.ret_val = (int) strlen(pRetBuffer); } fclose(hFile); diff --git a/src/odbc/convert_tds2sql.c b/src/odbc/convert_tds2sql.c index efaa82e01..842872aef 100644 --- a/src/odbc/convert_tds2sql.c +++ b/src/odbc/convert_tds2sql.c @@ -48,7 +48,7 @@ static void eat_iconv_left(TDSCOLUMN * curcol, char **pbuf, size_t *plen) { - unsigned cp = ODBC_MIN(*plen, curcol->column_iconv_left); + unsigned cp = (unsigned) ODBC_MIN(*plen, curcol->column_iconv_left); memcpy(*pbuf, curcol->column_iconv_buf, cp); if (cp < curcol->column_iconv_left) memmove(curcol->column_iconv_buf, curcol->column_iconv_buf + cp, curcol->column_iconv_left - cp); @@ -113,12 +113,14 @@ odbc_convert_char(TDS_STMT * stmt, TDSCOLUMN * curcol, TDS_CHAR * src, TDS_UINT conv->suppress.einval = 1; conv->suppress.e2big = 1; tds_iconv(tds, conv, to_client, &ib, &il, &left_ob, &left_ol); - curcol->column_iconv_left = sizeof(curcol->column_iconv_buf) - left_ol; + curcol->column_iconv_left + = (sizeof(curcol->column_iconv_buf) + - (unsigned char) left_ol); /* copy part to fill buffer */ eat_iconv_left(curcol, &ob, &ol); } ol = ob - dest; /* bytes written */ - curcol->column_text_sqlgetdatapos += ib - src; + curcol->column_text_sqlgetdatapos += (TDS_INT) (ib - src); /* terminate string */ memset(ob, 0, char_size); } @@ -174,7 +176,7 @@ odbc_tds_convert_wide_iso(TDS_CHAR *src, TDS_UINT srclen, TDS_CHAR *buf, TDS_UIN return -1; *p = 0; - return p - buf; + return (int) (p - buf); } /* The following function is going to write in these structure not using them @@ -205,7 +207,7 @@ TDS_COMPILE_CHECK(timestamp_struct, sizeof(TIMESTAMP_STRUCT) == 16 static SQLLEN odbc_convert_datetime_to_binary(TDSCOLUMN *curcol, int srctype, TDS_DATETIMEALL * dta, TDS_CHAR * dest, SQLULEN destlen) { - size_t len, cplen; + TDS_INT len, cplen; TDS_USMALLINT buf[10]; TDSDATEREC when; @@ -239,7 +241,7 @@ odbc_convert_datetime_to_binary(TDSCOLUMN *curcol, int srctype, TDS_DATETIMEALL if (destlen == 0) return len; - cplen = ODBC_MIN(destlen, len); + cplen = ODBC_MIN((TDS_INT) destlen, len); memcpy(dest, buf, cplen); if (curcol) curcol->column_text_sqlgetdatapos += cplen; @@ -286,7 +288,8 @@ odbc_tds2sql(TDS_STMT * stmt, TDSCOLUMN *curcol, int srctype, TDS_CHAR * src, TD CONV_RESULT ores; SQLLEN ret = SQL_NULL_DATA; - int i, cplen; + int i; + SQLULEN cplen; int binary_conversion = 0; TDS_CHAR conv_buf[256]; @@ -320,7 +323,8 @@ odbc_tds2sql(TDS_STMT * stmt, TDSCOLUMN *curcol, int srctype, TDS_CHAR * src, TD } else if (is_numeric_type(nDestSybType)) { /* TODO use descriptor information (APD) ?? However APD can contain SQL_C_DEFAULT... */ if (drec_ixd) - ores.n.precision = drec_ixd->sql_desc_precision; + ores.n.precision + = (unsigned char) drec_ixd->sql_desc_precision; else ores.n.precision = 38; ores.n.scale = 0; @@ -412,8 +416,8 @@ odbc_tds2sql(TDS_STMT * stmt, TDSCOLUMN *curcol, int srctype, TDS_CHAR * src, TD sprintf(buf + strlen(buf), " %c%02d:%02d", sign, off / 60, off % 60); } - nRetVal = strlen(buf); - memcpy(dest, buf, ODBC_MIN(destlen, nRetVal)); + nRetVal = (TDS_INT) strlen(buf); + memcpy(dest, buf, ODBC_MIN(destlen, (SQLULEN) nRetVal)); } else { normal_conversion: nRetVal = tds_convert(context, srctype, src, srclen, nDestSybType, &ores); @@ -431,7 +435,7 @@ odbc_tds2sql(TDS_STMT * stmt, TDSCOLUMN *curcol, int srctype, TDS_CHAR * src, TD ret = nRetVal; /* TODO handle not terminated configuration */ if (destlen > 0) { - cplen = ODBC_MIN(destlen - 1, nRetVal); + cplen = ODBC_MIN(destlen - 1, (SQLULEN) nRetVal); assert(cplen >= 0); /* * odbc always terminate but do not overwrite @@ -455,7 +459,7 @@ odbc_tds2sql(TDS_STMT * stmt, TDSCOLUMN *curcol, int srctype, TDS_CHAR * src, TD SQLWCHAR *wp = (SQLWCHAR *) dest; SQLCHAR *p = (SQLCHAR *) dest; - cplen = ODBC_MIN(destlen - 1, nRetVal); + cplen = ODBC_MIN(destlen - 1, (SQLULEN) nRetVal); assert(cplen >= 0); /* * odbc always terminate but do not overwrite diff --git a/src/odbc/descriptor.c b/src/odbc/descriptor.c index 4d6777ef7..4725a72bc 100644 --- a/src/odbc/descriptor.c +++ b/src/odbc/descriptor.c @@ -90,7 +90,7 @@ desc_alloc_records(TDS_DESC * desc, unsigned count) int i; /* shrink records */ - if (desc->header.sql_desc_count >= count) { + if ((unsigned) desc->header.sql_desc_count >= count) { for (i = count; i < desc->header.sql_desc_count; ++i) desc_free_record(&desc->records[i]); desc->header.sql_desc_count = count; @@ -101,7 +101,7 @@ desc_alloc_records(TDS_DESC * desc, unsigned count) return SQL_ERROR; memset(desc->records + desc->header.sql_desc_count, 0, sizeof(struct _drecord) * (count - desc->header.sql_desc_count)); - for (i = desc->header.sql_desc_count; i < count; ++i) { + for (i = desc->header.sql_desc_count; (unsigned) i < count; ++i) { drec = &desc->records[i]; #define STR_OP(name) tds_dstr_init(&drec->name) diff --git a/src/odbc/odbc.c b/src/odbc/odbc.c index c9369df19..d6d2ea126 100644 --- a/src/odbc/odbc.c +++ b/src/odbc/odbc.c @@ -220,7 +220,7 @@ change_autocommit(TDS_DBC * dbc, int state) } static SQLRETURN -change_database(TDS_DBC * dbc, const char *database, int database_len) +change_database(TDS_DBC * dbc, const char *database, size_t database_len) { TDSSOCKET *tds = dbc->tds_socket; tds_mutex_check_owned(&dbc->mtx); @@ -1182,9 +1182,9 @@ ODBC_FUNC(SQLProcedures, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT), } static TDSPARAMINFO* -odbc_build_update_params(TDS_STMT * stmt, unsigned int n_row) +odbc_build_update_params(TDS_STMT * stmt, SQLSETPOSIROW n_row) { - unsigned int n; + SQLSMALLINT n; TDSPARAMINFO * params = NULL; struct _drecord *drec_ird; @@ -1361,7 +1361,7 @@ SQLSetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER S SQLRETURN ODBC_PUBLIC ODBC_API SQLGetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength) { - size_t size; + SQLINTEGER size; void *src; ODBC_ENTER_HENV; @@ -1454,7 +1454,7 @@ _SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQL odbc_errs_add(&stmt->errs, "HY104", "Invalid precision value"); ODBC_EXIT_(stmt); } - if (ibScale < 0 || ibScale > cbColDef) { + if (ibScale < 0 || (SQLULEN) ibScale > cbColDef) { odbc_errs_add(&stmt->errs, "HY104", "Invalid scale value"); ODBC_EXIT_(stmt); } @@ -1565,7 +1565,7 @@ _SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQL ODBC_EXIT_(stmt); } if (is_numeric) { - drec->sql_desc_precision = cbColDef; + drec->sql_desc_precision = (SQLSMALLINT) cbColDef; drec->sql_desc_scale = ibScale; } else { drec->sql_desc_length = cbColDef; @@ -1822,7 +1822,8 @@ _SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt) stmt->num_param_rows = 1; pstr = NULL; /* TODO test initial cursor ... */ - if (asprintf(&pstr, "SQL_CUR%lx", (unsigned long) (TDS_UINTPTR) stmt) < 0 || !tds_dstr_set(&stmt->cursor_name, pstr)) { + if (asprintf(&pstr, "SQL_CUR%p", stmt) < 0 + || !tds_dstr_set(&stmt->cursor_name, pstr)) { free(stmt); free(pstr); odbc_errs_add(&dbc->errs, "HY001", NULL); @@ -2199,7 +2200,7 @@ _SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLP case SQL_COLUMN_COUNT: #endif case SQL_DESC_COUNT: - IOUT(SQLSMALLINT, ird->header.sql_desc_count); + IOUT(SQLUSMALLINT, ird->header.sql_desc_count); ODBC_EXIT(stmt, SQL_SUCCESS); break; } @@ -2408,7 +2409,8 @@ SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, ) { - return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc _wide0); + return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, + pcbDesc, (SQLLEN*) pfDesc _wide0); } #ifdef ENABLE_ODBC_WIDE @@ -2725,7 +2727,7 @@ ODBC_FUNC(SQLGetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLIN break; case SQL_DESC_COUNT: IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR)); - IOUT(SQLSMALLINT, fdesc->header.sql_desc_count); + IOUT(SQLUSMALLINT, fdesc->header.sql_desc_count); ODBC_EXIT_(desc); break; case SQL_DESC_ROWS_PROCESSED_PTR: @@ -3430,7 +3432,7 @@ _SQLExecute(TDS_STMT * stmt) /* check parameters are all OK */ - if (stmt->params && stmt->param_num <= stmt->param_count) { + if (stmt->params && stmt->param_num <= (int) stmt->param_count) { /* TODO what error ?? */ ODBC_SAFE_ERROR(stmt); return SQL_ERROR; @@ -3891,7 +3893,7 @@ _SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset) TDSCOLUMN *colinfo; int i; SQLULEN curr_row, num_rows; - SQLINTEGER len = 0; + SQLLEN len = 0; struct _drecord *drec_ard; TDS_DESC *ard; SQLULEN dummy, *fetched_ptr; @@ -3994,7 +3996,7 @@ _SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset) status_ptr = stmt->ird->header.sql_desc_array_status_ptr; if (status_ptr) { - for (i = 0; i < num_rows; ++i) + for (i = 0; (SQLULEN) i < num_rows; ++i) *status_ptr++ = SQL_ROW_NOROW; status_ptr = stmt->ird->header.sql_desc_array_status_ptr; } @@ -4463,7 +4465,7 @@ static SQLRETURN _SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength WIDE) { void *src; - size_t size; + SQLINTEGER size; ODBC_ENTER_HSTMT; @@ -6125,7 +6127,7 @@ odbc_upper_column_names(TDS_STMT * stmt) for (icol = 0; icol < resinfo->num_cols; ++icol) { TDSCOLUMN *colinfo = resinfo->columns[icol]; char *p = tds_dstr_buf(&colinfo->column_name); - unsigned n, len = tds_dstr_len(&colinfo->column_name); + size_t n, len = tds_dstr_len(&colinfo->column_name); /* upper case */ /* TODO procedure */ @@ -6308,7 +6310,8 @@ _SQLParamData(SQLHSTMT hstmt, SQLPOINTER FAR * prgbValue) tdsdump_log(TDS_DBG_FUNC, "SQLParamData(%p, %p) [param_num %d, param_data_called = %d]\n", hstmt, prgbValue, stmt->param_num, stmt->param_data_called); - if (stmt->params && stmt->param_num <= stmt->param_count) { + if (stmt->params + && (unsigned int) stmt->param_num <= stmt->param_count) { SQLRETURN res; if (stmt->param_num <= 0 || stmt->param_num > stmt->apd->header.sql_desc_count) { @@ -6389,13 +6392,13 @@ ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOI switch (Attribute) { case SQL_ATTR_AUTOCOMMIT: /* spinellia@acm.org */ - change_autocommit(dbc, u_value); + change_autocommit(dbc, (int) u_value); break; case SQL_ATTR_CONNECTION_TIMEOUT: - dbc->attr.connection_timeout = u_value; + dbc->attr.connection_timeout = (SQLUINTEGER) u_value; break; case SQL_ATTR_ACCESS_MODE: - dbc->attr.access_mode = u_value; + dbc->attr.access_mode = (SQLUINTEGER) u_value; break; case SQL_ATTR_CURRENT_CATALOG: if (!IS_VALID_LEN(StringLength)) { @@ -6415,24 +6418,24 @@ ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOI break; case SQL_ATTR_CURSOR_TYPE: if (dbc->cursor_support) - dbc->attr.cursor_type = u_value; + dbc->attr.cursor_type = (SQLUINTEGER) u_value; break; case SQL_ATTR_LOGIN_TIMEOUT: - dbc->attr.login_timeout = u_value; + dbc->attr.login_timeout = (SQLUINTEGER) u_value; break; case SQL_ATTR_ODBC_CURSORS: /* TODO cursors */ - dbc->attr.odbc_cursors = u_value; + dbc->attr.odbc_cursors = (SQLUINTEGER) u_value; break; case SQL_ATTR_PACKET_SIZE: - dbc->attr.packet_size = u_value; + dbc->attr.packet_size = (SQLUINTEGER) u_value; break; case SQL_ATTR_QUIET_MODE: dbc->attr.quite_mode = (SQLHWND) (TDS_INTPTR) ValuePtr; break; #ifdef TDS_NO_DM case SQL_ATTR_TRACE: - dbc->attr.trace = u_value; + dbc->attr.trace = (SQLUINTEGER) u_value; break; case SQL_ATTR_TRACEFILE: if (!IS_VALID_LEN(StringLength)) { @@ -6445,12 +6448,13 @@ ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOI #endif case SQL_ATTR_TXN_ISOLATION: if (u_value != dbc->attr.txn_isolation) { - if (change_txn(dbc, u_value) == SQL_SUCCESS) - dbc->attr.txn_isolation = u_value; + if (change_txn(dbc, (SQLUINTEGER) u_value) + == SQL_SUCCESS) + dbc->attr.txn_isolation = (SQLUINTEGER)u_value; } break; case SQL_COPT_SS_MARS_ENABLED: - dbc->attr.mars_enabled = u_value; + dbc->attr.mars_enabled = (SQLUINTEGER) u_value; break; case SQL_ATTR_TRANSLATE_LIB: case SQL_ATTR_TRANSLATE_OPTION: @@ -6467,7 +6471,7 @@ ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOI dbc->use_oldpwd = 1; break; case SQL_COPT_SS_BCP: - dbc->attr.bulk_enabled = u_value; + dbc->attr.bulk_enabled = (SQLUINTEGER) u_value; break; case SQL_COPT_TDSODBC_IMPL_BCP_INITA: if (!ValuePtr) @@ -6610,7 +6614,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "HYC00", NULL); break; } - stmt->attr.async_enable = ui; + stmt->attr.async_enable = (SQLUINTEGER) ui; break; case SQL_ATTR_CONCURRENCY: if (stmt->attr.concurrency != ui && !stmt->dbc->cursor_support) { @@ -6636,7 +6640,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "HY092", NULL); ODBC_EXIT_(stmt); } - stmt->attr.concurrency = ui; + stmt->attr.concurrency = (SQLUINTEGER) ui; break; case SQL_ATTR_CURSOR_SCROLLABLE: if (stmt->attr.cursor_scrollable != ui && !stmt->dbc->cursor_support) { @@ -6655,7 +6659,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "HY092", NULL); ODBC_EXIT_(stmt); } - stmt->attr.cursor_scrollable = ui; + stmt->attr.cursor_scrollable = (SQLUINTEGER) ui; break; case SQL_ATTR_CURSOR_SENSITIVITY: /* don't change anything */ @@ -6674,7 +6678,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN stmt->attr.concurrency = SQL_CONCUR_ROWVER; break; } - stmt->attr.cursor_sensitivity = ui; + stmt->attr.cursor_sensitivity = (SQLUINTEGER) ui; break; case SQL_ATTR_CURSOR_TYPE: if (stmt->attr.cursor_type != ui && !stmt->dbc->cursor_support) { @@ -6708,14 +6712,14 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "HY092", NULL); ODBC_EXIT_(stmt); } - stmt->attr.cursor_type = ui; + stmt->attr.cursor_type = (SQLUINTEGER) ui; break; case SQL_ATTR_ENABLE_AUTO_IPD: if (stmt->attr.enable_auto_ipd != ui) { odbc_errs_add(&stmt->errs, "HYC00", NULL); break; } - stmt->attr.enable_auto_ipd = ui; + stmt->attr.enable_auto_ipd = (SQLUINTEGER) ui; break; case SQL_ATTR_FETCH_BOOKMARK_PTR: stmt->attr.fetch_bookmark_ptr = ValuePtr; @@ -6745,17 +6749,17 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN stmt->attr.max_rows = ui; break; case SQL_ATTR_METADATA_ID: - stmt->attr.metadata_id = ui; + stmt->attr.metadata_id = (SQLUINTEGER) ui; break; /* TODO use it !!! */ case SQL_ATTR_NOSCAN: - stmt->attr.noscan = ui; + stmt->attr.noscan = (SQLUINTEGER) ui; break; case SQL_ATTR_PARAM_BIND_OFFSET_PTR: stmt->apd->header.sql_desc_bind_offset_ptr = lp; break; case SQL_ATTR_PARAM_BIND_TYPE: - stmt->apd->header.sql_desc_bind_type = ui; + stmt->apd->header.sql_desc_bind_type = (SQLUINTEGER) ui; break; case SQL_ATTR_PARAM_OPERATION_PTR: stmt->apd->header.sql_desc_array_status_ptr = usip; @@ -6776,7 +6780,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "01S02", NULL); ui = 65534; } - stmt->attr.query_timeout = ui; + stmt->attr.query_timeout = (SQLUINTEGER) ui; break; /* retrieve data after positioning the cursor */ case SQL_ATTR_RETRIEVE_DATA: @@ -6785,7 +6789,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "01S02", NULL); break; } - stmt->attr.retrieve_data = ui; + stmt->attr.retrieve_data = (SQLUINTEGER) ui; break; case SQL_ATTR_ROW_ARRAY_SIZE: stmt->ard->header.sql_desc_array_size = ui; @@ -6798,7 +6802,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN case SQL_BIND_TYPE: /* although this is ODBC2 we must support this attribute */ #endif case SQL_ATTR_ROW_BIND_TYPE: - stmt->ard->header.sql_desc_bind_type = ui; + stmt->ard->header.sql_desc_bind_type = (SQLUINTEGER) ui; break; case SQL_ATTR_ROW_NUMBER: odbc_errs_add(&stmt->errs, "HY092", NULL); @@ -6822,14 +6826,14 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "01S02", NULL); break; } - stmt->attr.simulate_cursor = ui; + stmt->attr.simulate_cursor = (SQLUINTEGER) ui; break; case SQL_ATTR_USE_BOOKMARKS: if (stmt->cursor) { odbc_errs_add(&stmt->errs, "24000", NULL); break; } - stmt->attr.use_bookmarks = ui; + stmt->attr.use_bookmarks = (SQLUINTEGER) ui; break; case SQL_ROWSET_SIZE: /* although this is ODBC2 we must support this attribute */ if (((TDS_INTPTR) ValuePtr) < 1) { @@ -6843,7 +6847,7 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "HY024", NULL); break; } - stmt->attr.qn_timeout = ui; + stmt->attr.qn_timeout = (SQLUINTEGER) ui; break; case SQL_SOPT_SS_QUERYNOTIFICATION_MSGTEXT: if (!IS_VALID_LEN(StringLength)) { @@ -6871,9 +6875,9 @@ _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLIN odbc_errs_add(&stmt->errs, "IM020", NULL); break; } - stmt->attr.param_focus = ui; - stmt->orig_apd->focus = ui; - stmt->ipd->focus = ui; + stmt->attr.param_focus = (SQLUINTEGER) ui; + stmt->orig_apd->focus = (int) ui; + stmt->ipd->focus = (int) ui; break; default: odbc_errs_add(&stmt->errs, "HY092", NULL); @@ -7285,13 +7289,13 @@ odbc_log_unimplemented_type(const char function_name[], int fType) return; } -static int +static size_t odbc_quote_metadata(TDS_DBC * dbc, char type, char *dest, DSTR * dstr) { int unquote = 0; char prev, buf[1200], *dst; const char *s = tds_dstr_cstr(dstr); - int len = tds_dstr_len(dstr); + ssize_t len = tds_dstr_len(dstr); /* limit string/id lengths */ if (len > 384) @@ -7372,7 +7376,8 @@ odbc_quote_metadata(TDS_DBC * dbc, char type, char *dest, DSTR * dstr) } static TDSPARAMINFO* -odbc_add_char_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, const char *value, size_t len) +odbc_add_char_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, + const char *value, TDS_INT len) { TDSCOLUMN *col; @@ -7422,7 +7427,8 @@ odbc_add_int_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, int v static SQLRETURN odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...) { - int i, len, param_qualifier = -1; + int i, param_qualifier = -1; + size_t len; char *proc = NULL, *p; SQLRETURN retcode; va_list marker; @@ -7491,7 +7497,8 @@ odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...) char buf[1200]; int l; - l = odbc_quote_metadata(stmt->dbc, type, buf, &value); + l = (int) odbc_quote_metadata(stmt->dbc, type, buf, + &value); if (!odbc_add_char_param(stmt->dbc->tds_socket, params, name, buf, l)) goto mem_error; diff --git a/src/odbc/odbc_checks.c b/src/odbc/odbc_checks.c index a01d4ba6a..88b7856df 100644 --- a/src/odbc/odbc_checks.c +++ b/src/odbc/odbc_checks.c @@ -74,7 +74,7 @@ odbc_check_stmt_extra(TDS_STMT * stmt) odbc_check_desc_extra(stmt->apd); odbc_check_desc_extra(stmt->ipd); assert(!stmt->prepared_query_is_func || stmt->prepared_query_is_rpc); - assert(stmt->param_num <= stmt->param_count + 1); + assert(stmt->param_num <= (int) stmt->param_count + 1); assert(stmt->num_param_rows >= 1); assert(stmt->curr_param_row >= 0); assert(stmt->curr_param_row <= stmt->num_param_rows); diff --git a/src/odbc/odbc_util.c b/src/odbc/odbc_util.c index 5153a459a..62a2ff429 100644 --- a/src/odbc/odbc_util.c +++ b/src/odbc/odbc_util.c @@ -24,6 +24,8 @@ #include #endif /* HAVE_STDLIB_H */ +#include + #if HAVE_STRING_H #include #endif /* HAVE_STRING_H */ @@ -50,13 +52,14 @@ */ #ifdef ENABLE_ODBC_WIDE -static DSTR *odbc_iso2utf(DSTR *res, const char *s, unsigned int len); -static DSTR *odbc_mb2utf(TDS_DBC *dbc, DSTR *res, const char *s, unsigned int len); -static DSTR *odbc_wide2utf(DSTR *res, const SQLWCHAR *s, unsigned int len); +static DSTR *odbc_iso2utf(DSTR *res, const char *s, size_t len); +static DSTR *odbc_mb2utf(TDS_DBC *dbc, DSTR *res, const char *s, size_t len); +static DSTR *odbc_wide2utf(DSTR *res, const SQLWCHAR *s, size_t len); #endif int -odbc_set_stmt_query(TDS_STMT * stmt, const ODBC_CHAR *sql, int sql_len _WIDE) +odbc_set_stmt_query(TDS_STMT * stmt, const ODBC_CHAR *sql, ssize_t sql_len + _WIDE) { if (sql_len == SQL_NTS) #ifdef ENABLE_ODBC_WIDE @@ -86,8 +89,8 @@ odbc_set_stmt_query(TDS_STMT * stmt, const ODBC_CHAR *sql, int sql_len _WIDE) return SQL_SUCCESS; } -unsigned int -odbc_get_string_size(int size, const ODBC_CHAR * str _WIDE) +size_t +odbc_get_string_size(ssize_t size, const ODBC_CHAR * str _WIDE) { if (str) { if (size == SQL_NTS) @@ -105,9 +108,9 @@ odbc_get_string_size(int size, const ODBC_CHAR * str _WIDE) #ifdef ENABLE_ODBC_WIDE static DSTR* -odbc_iso2utf(DSTR *res, const char *s, unsigned int len) +odbc_iso2utf(DSTR *res, const char *s, size_t len) { - unsigned int i, o_len = len + 1; + size_t i, o_len = len + 1; char *out, *p; assert(s); @@ -133,9 +136,9 @@ odbc_iso2utf(DSTR *res, const char *s, unsigned int len) } static DSTR* -odbc_wide2utf(DSTR *res, const SQLWCHAR *s, unsigned int len) +odbc_wide2utf(DSTR *res, const SQLWCHAR *s, size_t len) { - unsigned int i, o_len = len + 1; + size_t i, o_len = len + 1; char *out, *p; #if SIZEOF_SQLWCHAR > 2 @@ -216,7 +219,7 @@ odbc_wide2utf(DSTR *res, const SQLWCHAR *s, unsigned int len) } static DSTR* -odbc_mb2utf(TDS_DBC *dbc, DSTR *res, const char *s, unsigned int len) +odbc_mb2utf(TDS_DBC *dbc, DSTR *res, const char *s, size_t len) { char *buf; @@ -265,10 +268,10 @@ odbc_mb2utf(TDS_DBC *dbc, DSTR *res, const char *s, unsigned int len) * 0x20 size is in bytes, not characters */ DSTR* -odbc_dstr_copy_flag(TDS_DBC *dbc, DSTR *s, int size, const ODBC_CHAR * str, int flag) +odbc_dstr_copy_flag(TDS_DBC *dbc, DSTR *s, ssize_t size, const ODBC_CHAR * str, int flag) { int wide = flag&1; - unsigned int len; + size_t len; len = odbc_get_string_size((flag&0x21) == 0x21 && size >= 0 ? size/SIZEOF_SQLWCHAR : size, str, wide); if (wide) @@ -278,7 +281,7 @@ odbc_dstr_copy_flag(TDS_DBC *dbc, DSTR *s, int size, const ODBC_CHAR * str, int } #else DSTR* -odbc_dstr_copy(TDS_DBC *dbc, DSTR *s, int size, const ODBC_CHAR * str) +odbc_dstr_copy(TDS_DBC *dbc, DSTR *s, ssize_t size, const ODBC_CHAR * str) { return tds_dstr_copyn(s, (const char *) str, odbc_get_string_size(size, str)); } @@ -298,12 +301,14 @@ odbc_dstr_copy(TDS_DBC *dbc, DSTR *s, int size, const ODBC_CHAR * str) * 0x20 size is in bytes, not characters */ SQLRETURN -odbc_set_string_flag(TDS_DBC *dbc, SQLPOINTER buffer, SQLINTEGER cbBuffer, void FAR * pcbBuffer, const char *s, int len, int flag) +odbc_set_string_flag(TDS_DBC *dbc, SQLPOINTER buffer, SQLINTEGER cbBuffer, + void FAR * pcbBuffer, const char *s, ssize_t len, + int flag) { SQLRETURN result = SQL_SUCCESS; int out_len = 0; #if !defined(NDEBUG) && defined(ENABLE_ODBC_WIDE) - size_t initial_size; + ptrdiff_t initial_size; #endif if (len < 0) @@ -428,7 +433,7 @@ odbc_set_string_flag(TDS_DBC *dbc, SQLPOINTER buffer, SQLINTEGER cbBuffer, void char_conv->suppress.e2big = 1; if (cbBuffer && tds_iconv(dbc->tds_socket, char_conv, to_client, &ib, &il, &ob, &ol) == (size_t)-1 && errno != E2BIG) result = SQL_ERROR; - out_len = cbBuffer - ol; + out_len = cbBuffer - (int) ol; while (result != SQL_ERROR && il) { char discard[128]; ol = sizeof(discard); @@ -483,7 +488,7 @@ odbc_set_return_status(struct _hstmt *stmt, unsigned int n_row) /* TODO handle different type results (functions) on mssql2k */ if (stmt->prepared_query_is_func && tds->has_status) { struct _drecord *drec; - int len; + SQLLEN len; const TDS_DESC* axd = stmt->apd; TDS_INTPTR len_offset; char *data_ptr; @@ -535,7 +540,7 @@ odbc_set_return_params(struct _hstmt *stmt, unsigned int n_row) const TDS_DESC* axd = stmt->apd; const struct _drecord *drec_apd, *drec_ipd; TDSCOLUMN *colinfo = info->columns[i]; - SQLINTEGER len; + SQLLEN len; int c_type; char *data_ptr; TDS_INTPTR len_offset; @@ -861,10 +866,12 @@ odbc_rdbms_version(TDSSOCKET * tds, char *pversion_string) } /** Return length of parameter from parameter information */ -SQLINTEGER -odbc_get_param_len(const struct _drecord *drec_axd, const struct _drecord *drec_ixd, const TDS_DESC* axd, unsigned int n_row) +SQLLEN +odbc_get_param_len(const struct _drecord *drec_axd, + const struct _drecord *drec_ixd, const TDS_DESC* axd, + SQLSETPOSIROW n_row) { - SQLINTEGER len; + SQLLEN len; int size; TDS_INTPTR len_offset; diff --git a/src/odbc/prepare_query.c b/src/odbc/prepare_query.c index 6504ae394..4b2c709f3 100644 --- a/src/odbc/prepare_query.c +++ b/src/odbc/prepare_query.c @@ -151,7 +151,7 @@ prepared_rpc(struct _hstmt *stmt, bool compute_row) curcol->column_cur_size = len; break; case SYBINT4: - *((TDS_INT *) dest) = strtol(start, NULL, 10); + *((TDS_INT *) dest) = atoi(start); break; case SYBINT8: *((TDS_INT8 *) dest) = tds_strtoll(start, NULL, 10); @@ -207,7 +207,8 @@ parse_prepared_query(struct _hstmt *stmt, bool compute_row) tdsdump_log(TDS_DBG_FUNC, "parsing %d parameters\n", nparam); - for (; stmt->param_num <= stmt->param_count; ++nparam, ++stmt->param_num) { + for (; stmt->param_num <= (int) stmt->param_count; + ++nparam, ++stmt->param_num) { /* find bound parameter */ if (stmt->param_num > stmt->apd->header.sql_desc_count || stmt->param_num > stmt->ipd->header.sql_desc_count) { tdsdump_log(TDS_DBG_FUNC, "parse_prepared_query: logic_error: parameter out of bounds: " @@ -247,10 +248,11 @@ start_parse_prepared_query(struct _hstmt *stmt, bool compute_row) return parse_prepared_query(stmt, compute_row); } -static TDS_INT -odbc_wchar2hex(TDS_CHAR *dest, TDS_UINT destlen, const SQLWCHAR * src, TDS_UINT srclen) +static ssize_t +odbc_wchar2hex(TDS_CHAR *dest, size_t destlen, const SQLWCHAR * src, + size_t srclen) { - unsigned int i; + size_t i; SQLWCHAR hex1, c = 0; /* if srclen if odd we must add a "0" before ... */ @@ -403,7 +405,7 @@ continue_parse_prepared_query(struct _hstmt *stmt, SQLPOINTER DataPtr, SQLLEN St p += curcol->column_cur_size; if (binary_convert) { - int res; + ssize_t res; len = orig_len; @@ -415,7 +417,8 @@ continue_parse_prepared_query(struct _hstmt *stmt, SQLPOINTER DataPtr, SQLLEN St res = odbc_wchar2hex(p, 1, data, 2); if (res < 0) { - odbc_convert_err_set(&stmt->errs, res); + odbc_convert_err_set(&stmt->errs, + (TDS_INT) res); return SQL_ERROR; } p += res; @@ -434,7 +437,8 @@ continue_parse_prepared_query(struct _hstmt *stmt, SQLPOINTER DataPtr, SQLLEN St tds_char2hex(p, len / 2u, (const TDS_CHAR*) DataPtr, len): odbc_wchar2hex(p, len / 2u, (const SQLWCHAR*) DataPtr, len); if (res < 0) { - odbc_convert_err_set(&stmt->errs, res); + odbc_convert_err_set(&stmt->errs, + (TDS_INT) res); return SQL_ERROR; } p += res; diff --git a/src/odbc/sql2tds.c b/src/odbc/sql2tds.c index a1b7b709a..8b192514d 100644 --- a/src/odbc/sql2tds.c +++ b/src/odbc/sql2tds.c @@ -136,7 +136,7 @@ odbc_wstr2str(TDS_STMT * stmt, const char *src, int* len) return NULL; } - *len = p - out; + *len = (int) (p - out); return out; } @@ -253,7 +253,7 @@ odbc_convert_table(TDS_STMT *stmt, SQLTVP *src, TDS_TVP *dest, SQLLEN num_rows) */ SQLRETURN odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _drecord *drec_axd, TDSCOLUMN *curcol, - bool compute_row, const TDS_DESC* axd, unsigned int n_row) + bool compute_row, const TDS_DESC* axd, SQLSETPOSIROW n_row) { TDS_DBC * dbc = stmt->dbc; TDSCONNECTION * conn = dbc->tds_socket->conn; @@ -267,7 +267,7 @@ odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _dre TDS_DATETIMEALL dta; TDS_NUMERIC num; SQL_NUMERIC_STRUCT *sql_num; - SQLINTEGER sql_len; + SQLLEN sql_len; bool need_data = false; int i; @@ -308,8 +308,9 @@ odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _dre } } if (is_numeric_type(curcol->column_type)) { - curcol->column_prec = drec_ixd->sql_desc_precision; - curcol->column_scale = drec_ixd->sql_desc_scale; + curcol->column_prec + = (TDS_TINYINT) drec_ixd->sql_desc_precision; + curcol->column_scale = (TDS_TINYINT) drec_ixd->sql_desc_scale; } if (drec_ixd->sql_desc_parameter_type != SQL_PARAM_INPUT) @@ -400,9 +401,10 @@ odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _dre return SQL_ERROR; } if (sql_src_type == SQL_C_WCHAR) - len = sqlwcslen((const SQLWCHAR *) src) * sizeof(SQLWCHAR); + len = (int) sqlwcslen((const SQLWCHAR *) src) + * sizeof(SQLWCHAR); else - len = strlen(src); + len = (int) strlen(src); break; case SQL_DEFAULT_PARAM: odbc_errs_add(&stmt->errs, "07S01", NULL); /* Invalid use of default parameter */ @@ -564,8 +566,10 @@ odbc_sql2tds(TDS_STMT * stmt, const struct _drecord *drec_ixd, const struct _dre break; case SYBNUMERIC: case SYBDECIMAL: - ((TDS_NUMERIC *) dest)->precision = drec_ixd->sql_desc_precision; - ((TDS_NUMERIC *) dest)->scale = drec_ixd->sql_desc_scale; + ((TDS_NUMERIC *) dest)->precision + = (unsigned char) drec_ixd->sql_desc_precision; + ((TDS_NUMERIC *) dest)->scale + = (unsigned char) drec_ixd->sql_desc_scale; case SYBINTN: case SYBINT1: case SYBINT2: diff --git a/src/odbc/unittests/bcp.c b/src/odbc/unittests/bcp.c index fbc387a1d..10c1a7205 100644 --- a/src/odbc/unittests/bcp.c +++ b/src/odbc/unittests/bcp.c @@ -138,7 +138,10 @@ init(void) } #define VARCHAR_BIND(x) \ - bcp_bind( odbc_conn, (prefixlen == 0 ? (void*)&x.value : (void*)&x.prefix), prefixlen, strlen(x.value), NULL, termlen, BCP_TYPE_SQLVARCHAR, col++ ) + bcp_bind( odbc_conn, \ + (prefixlen == 0 ? (void*)&x.value : (void*)&x.prefix), \ + prefixlen, (SQLINTEGER) strlen(x.value), NULL, termlen, \ + BCP_TYPE_SQLVARCHAR, col++ ) #define INT_BIND(x) \ bcp_bind( odbc_conn, (prefixlen == 0 ? (void*)&x.value : (void*)&x.prefix), prefixlen, SQL_VARLEN_DATA, NULL, termlen, BCP_TYPE_SQLINT4, col++ ) diff --git a/src/odbc/unittests/blob1.c b/src/odbc/unittests/blob1.c index e9196f421..fd5d693f6 100644 --- a/src/odbc/unittests/blob1.c +++ b/src/odbc/unittests/blob1.c @@ -29,7 +29,7 @@ fill_hex(char *buf, size_t len, unsigned int start, unsigned int step) static int -check_chars(const char *buf, size_t len, unsigned int start, unsigned int step) +check_chars(const char *buf, size_t len, SQLLEN start, unsigned int step) { size_t n; @@ -41,7 +41,7 @@ check_chars(const char *buf, size_t len, unsigned int start, unsigned int step) } static int -check_hex(const char *buf, size_t len, unsigned int start, unsigned int step) +check_hex(const char *buf, size_t len, SQLLEN start, unsigned int step) { size_t n; char symbol[3]; @@ -69,9 +69,9 @@ static test_info test_infos[MAX_TESTS]; static unsigned num_tests = 0; static void -dump(FILE* out, const char* start, void* buf, unsigned len) +dump(FILE* out, const char* start, void* buf, SQLULEN len) { - unsigned n; + SQLULEN n; char s[17]; if (len >= 16) len = 16; @@ -182,7 +182,7 @@ static void add_test(SQLSMALLINT c_type, SQLSMALLINT sql_type, const char *db_type, unsigned gen1, unsigned gen2) { test_info *t = NULL; - size_t buf_len; + int buf_len; if (num_tests >= MAX_TESTS) { fprintf(stderr, "too max tests\n"); diff --git a/src/odbc/unittests/c2string.c b/src/odbc/unittests/c2string.c index 6c11cf41f..18f019f49 100644 --- a/src/odbc/unittests/c2string.c +++ b/src/odbc/unittests/c2string.c @@ -36,7 +36,7 @@ odbc_c2string(char *out, SQLSMALLINT out_c_type, const void *in, size_t in_len) } buf_t; #undef IN #define IN (*((const buf_t*) in)) - int i; + size_t i; const SQL_NUMERIC_STRUCT *num; char *s; @@ -49,7 +49,7 @@ odbc_c2string(char *out, SQLSMALLINT out_c_type, const void *in, size_t in_len) i = SQL_MAX_NUMERIC_LEN; for (; i > 0 && !num->val[--i];) continue; - for (; i >= 0; --i) + for (; (int) i >= 0; --i) s += sprintf(s, "%02X", num->val[i]); break; case SQL_C_BINARY: @@ -77,7 +77,7 @@ odbc_c2string(char *out, SQLSMALLINT out_c_type, const void *in, size_t in_len) break; case SQL_C_SBIGINT: assert(in_len == sizeof(SQLBIGINT)); - sprintf(s, "%" PRId64, IN.bi); + sprintf(s, "%" PRId64, (int64_t) IN.bi); break; case SQL_C_SHORT: assert(in_len == sizeof(SQLSMALLINT)); diff --git a/src/odbc/unittests/cancel.c b/src/odbc/unittests/cancel.c index b76d4e32e..9bed787c9 100644 --- a/src/odbc/unittests/cancel.c +++ b/src/odbc/unittests/cancel.c @@ -72,7 +72,7 @@ static HANDLE alarm_cond = NULL; static DWORD WINAPI alarm_thread_proc(LPVOID arg) { - unsigned int timeout = (uintptr_t) arg; + unsigned int timeout = (unsigned int) (uintptr_t) arg; switch (WaitForSingleObject(alarm_cond, timeout * 1000)) { case WAIT_OBJECT_0: return 0; diff --git a/src/odbc/unittests/common.c b/src/odbc/unittests/common.c index 724553dd6..450f56595 100644 --- a/src/odbc/unittests/common.c +++ b/src/odbc/unittests/common.c @@ -48,7 +48,7 @@ static char db_str_version[32]; static int check_lib(char *path, const char *file) { - int len = strlen(path); + size_t len = strlen(path); FILE *f; strcat(path, file); @@ -84,7 +84,7 @@ odbc_read_login_info(void) char *s1, *s2; const char *const *search_p; char path[1024]; - int len; + size_t len; int ini_override = 1; #if defined(_WIN32) && !defined(TDS_NO_DM) UWORD old_config_mode; @@ -667,19 +667,19 @@ odbc_read_error(void) printf("Message: '%s' %s\n", odbc_sqlstate, odbc_err); } -int -odbc_to_sqlwchar(SQLWCHAR *dst, const char *src, int n) +SQLLEN +odbc_to_sqlwchar(SQLWCHAR *dst, const char *src, SQLLEN n) { - int i = n; + SQLLEN i = n; while (--i >= 0) dst[i] = (unsigned char) src[i]; return n * sizeof(SQLWCHAR); } -int -odbc_from_sqlwchar(char *dst, const SQLWCHAR *src, int n) +SQLLEN +odbc_from_sqlwchar(char *dst, const SQLWCHAR *src, SQLLEN n) { - int i; + SQLLEN i; if (n < 0) { const SQLWCHAR *p = src; for (n=1; *p++ != 0; ++n) diff --git a/src/odbc/unittests/common.h b/src/odbc/unittests/common.h index e3f88434c..6cf372b61 100644 --- a/src/odbc/unittests/common.h +++ b/src/odbc/unittests/common.h @@ -196,8 +196,8 @@ TDS_SYS_SOCKET odbc_find_last_socket(void); */ void odbc_c2string(char *out, SQLSMALLINT out_c_type, const void *in, size_t in_len); -int odbc_to_sqlwchar(SQLWCHAR *dst, const char *src, int n); -int odbc_from_sqlwchar(char *dst, const SQLWCHAR *src, int n); +SQLLEN odbc_to_sqlwchar(SQLWCHAR *dst, const char *src, SQLLEN n); +SQLLEN odbc_from_sqlwchar(char *dst, const SQLWCHAR *src, SQLLEN n); typedef struct odbc_buf ODBC_BUF; extern ODBC_BUF *odbc_buf; diff --git a/src/odbc/unittests/connect2.c b/src/odbc/unittests/connect2.c index 8befd72ca..4b2af27a2 100644 --- a/src/odbc/unittests/connect2.c +++ b/src/odbc/unittests/connect2.c @@ -56,7 +56,8 @@ check_dbname(const char *dbname) static void set_dbname(const char *dbname) { - CHKSetConnectAttr(SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER) T(dbname), strlen(dbname)*sizeof(SQLTCHAR), "SI"); + CHKSetConnectAttr(SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER) T(dbname), + (SQLINTEGER) strlen(dbname)*sizeof(SQLTCHAR), "SI"); } int @@ -81,7 +82,8 @@ main(void) printf("SQLConnect after not existing..\n"); strcpy(tmp, "IDontExist"); - CHKSetConnectAttr(SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER) tmp, strlen(tmp), "E"); + CHKSetConnectAttr(SQL_ATTR_CURRENT_CATALOG, (SQLPOINTER) tmp, + (SQLINTEGER) strlen(tmp), "E"); check_dbname("tempdb"); odbc_disconnect(); diff --git a/src/odbc/unittests/convert_error.c b/src/odbc/unittests/convert_error.c index 117eafc5a..d60588555 100644 --- a/src/odbc/unittests/convert_error.c +++ b/src/odbc/unittests/convert_error.c @@ -20,7 +20,7 @@ Test(const char *bind1, SQLSMALLINT type1, const char *bind2, SQLSMALLINT type2) ++test_num; sprintf(sql, "insert into #test_output values (%s, %s)", bind1, bind2); - CHKPrepare(T(sql), strlen(sql), "S"); + CHKPrepare(T(sql), (SQLINTEGER) strlen(sql), "S"); if (bind1[0] == '?') CHKBindParameter(id++, SQL_PARAM_INPUT, SQL_C_LONG, type1, 3, 0, &test_num, 0, &ind, "S"); if (bind2[0] == '?') diff --git a/src/odbc/unittests/cursor7.c b/src/odbc/unittests/cursor7.c index e3e7f4fa9..0d1d9c368 100644 --- a/src/odbc/unittests/cursor7.c +++ b/src/odbc/unittests/cursor7.c @@ -15,7 +15,7 @@ Test(void) SQLUSMALLINT statuses[ROWS]; SQLULEN num_row; - int i; + SQLLEN i; SQLRETURN RetCode; odbc_reset_statement(); diff --git a/src/odbc/unittests/describecol.c b/src/odbc/unittests/describecol.c index b602403e0..f21164695 100644 --- a/src/odbc/unittests/describecol.c +++ b/src/odbc/unittests/describecol.c @@ -45,11 +45,11 @@ lookup(const char *name, const struct lookup_int *table) } static const char* -unlookup(long int value, const struct lookup_int *table) +unlookup(SQLLEN value, const struct lookup_int *table) { static char buf[32]; - sprintf(buf, "%ld", value); + sprintf(buf, "%ld", (long) value); if (!table) return buf; diff --git a/src/odbc/unittests/freeclose.c b/src/odbc/unittests/freeclose.c index b60b2b984..5736b1163 100644 --- a/src/odbc/unittests/freeclose.c +++ b/src/odbc/unittests/freeclose.c @@ -91,7 +91,7 @@ init_fake_server(int ip_port) } static void -write_all(TDS_SYS_SOCKET s, const void *buf, size_t len) +write_all(TDS_SYS_SOCKET s, const void *buf, int len) { int res, l; fd_set fds_write; diff --git a/src/odbc/unittests/getdata.c b/src/odbc/unittests/getdata.c index d55665179..ce042d103 100644 --- a/src/odbc/unittests/getdata.c +++ b/src/odbc/unittests/getdata.c @@ -33,7 +33,7 @@ static int mycmp(const char *s1, const char *s2) { SQLWCHAR buf[128], *wp; - unsigned l; + size_t l; if (type == SQL_C_CHAR) return strcmp(s1, s2); diff --git a/src/odbc/unittests/long_error.c b/src/odbc/unittests/long_error.c index 542295dab..711f82856 100644 --- a/src/odbc/unittests/long_error.c +++ b/src/odbc/unittests/long_error.c @@ -48,7 +48,7 @@ main(void) static void extract_error(SQLHANDLE handle, SQLSMALLINT type) { - SQLINTEGER i = 0; + SQLSMALLINT i = 0; SQLINTEGER native; SQLTCHAR state[7]; SQLTCHAR text[256]; diff --git a/src/odbc/unittests/params.c b/src/odbc/unittests/params.c index 8db70f2ea..5fbec93af 100644 --- a/src/odbc/unittests/params.c +++ b/src/odbc/unittests/params.c @@ -14,7 +14,7 @@ static const char sp_define[] = "CREATE PROCEDURE spTestProc\n" " SELECT @OutString = 'This is cool!'\n" " IF @InParam < 10\n" " RETURN (0)\n" " ELSE\n" " RETURN (1)\n"; -#define SP_TEXT "{?=call spTestProc(?,?,?)}" +static char sp_text[] = "{?=call spTestProc(?,?,?)}"; #define OUTSTRING_LEN 20 static int @@ -36,7 +36,7 @@ Test(int bind_before) odbc_command(sp_define); if (!bind_before) - CHKPrepare(T(SP_TEXT), strlen(SP_TEXT), "S"); + CHKPrepare(T(sp_text), sizeof(sp_text) - 1, "S"); CHKBindParameter(1, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &ReturnCode, 0, &cbReturnCode, "S"); CHKBindParameter(2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &InParam, 0, &cbInParam, "S"); @@ -48,7 +48,7 @@ Test(int bind_before) OUTSTRING_LEN, &cbOutString, "S"); if (bind_before) - CHKPrepare(T(SP_TEXT), strlen(SP_TEXT), "S"); + CHKPrepare(T(sp_text), sizeof(sp_text) - 1, "S"); CHKExecute("S"); diff --git a/src/odbc/unittests/putdata.c b/src/odbc/unittests/putdata.c index 5bf128d1e..6a8a52f89 100644 --- a/src/odbc/unittests/putdata.c +++ b/src/odbc/unittests/putdata.c @@ -22,7 +22,7 @@ static void Test(int direct) { SQLLEN ind; - int len = strlen(test_text), n, i; + int len = sizeof(test_text) - 1, n, i; const char *p; char *pp; SQLPOINTER ptr; @@ -63,7 +63,7 @@ Test(int direct) ODBC_REPORT_ERROR("Wrong pointer from SQLParamData"); } while (*p) { - int l = strlen(p); + int l = (int) strlen(p); if (l < n) n = l; @@ -117,7 +117,7 @@ Test(int direct) if (ptr != (SQLPOINTER) 4567) ODBC_REPORT_ERROR("Wrong pointer from SQLParamData"); while (pb != (buf + 254)) { - int l = buf + 254 - pb; + int l = (int) (buf + 254 - pb); if (l < n) n = l; diff --git a/src/odbc/unittests/raiserror.c b/src/odbc/unittests/raiserror.c index 7a4ffce94..af42bfb27 100644 --- a/src/odbc/unittests/raiserror.c +++ b/src/odbc/unittests/raiserror.c @@ -132,7 +132,8 @@ Test(int level) TestResult(result, level, "SQLExecDirect"); /* test with SQLPrepare/SQLExecute */ - if (!SQL_SUCCEEDED(SQLPrepare(odbc_stmt, T(SP_TEXT), strlen(SP_TEXT)))) { + if ( !SQL_SUCCEEDED(SQLPrepare(odbc_stmt, T(SP_TEXT), + (SQLINTEGER) strlen(SP_TEXT))) ) { fprintf(stderr, "SQLPrepare failure!\n"); exit(1); } diff --git a/src/odbc/unittests/rebindpar.c b/src/odbc/unittests/rebindpar.c index 8611a578a..585ff4281 100644 --- a/src/odbc/unittests/rebindpar.c +++ b/src/odbc/unittests/rebindpar.c @@ -10,7 +10,7 @@ static void TestInsert(char *buf) { SQLLEN ind; - int l = strlen(buf); + int l = (int) strlen(buf); char sql[200]; /* insert some data and test success */ diff --git a/src/odbc/unittests/rpc.c b/src/odbc/unittests/rpc.c index 1f1a84b9f..b3200700f 100644 --- a/src/odbc/unittests/rpc.c +++ b/src/odbc/unittests/rpc.c @@ -139,7 +139,7 @@ Test(const char *name) printf("executing SQLFetch...\n"); printf("\t%-30s\n\t%s\n", C(name), dashes); for (nrows=0; CHKFetch("SNo") == SQL_SUCCESS; nrows++) { - const SQLINTEGER icol = 1; + const SQLUSMALLINT icol = 1; char buf[60]; SQLLEN len; CHKGetData( icol diff --git a/src/odbc/unittests/stats.c b/src/odbc/unittests/stats.c index 942536dc7..695a7c407 100644 --- a/src/odbc/unittests/stats.c +++ b/src/odbc/unittests/stats.c @@ -15,7 +15,7 @@ static const char *proc = "stat_proc"; static const char *table = "stat_proc"; static const char *column = "@t"; -#define LEN(x) (x) ? strlen(x) : 0 +#define LEN(x) (x) ? (SQLSMALLINT) strlen(x) : 0 static void TestProc(const char *catalog, const char *type, const char *expected) diff --git a/src/odbc/unittests/tables.c b/src/odbc/unittests/tables.c index 647e576ab..f847fbfbf 100644 --- a/src/odbc/unittests/tables.c +++ b/src/odbc/unittests/tables.c @@ -53,16 +53,16 @@ static char expected_type[20] = "SYSTEM TABLE"; static void DoTest(const char *type, int row_returned, int line) { - int table_len = SQL_NULL_DATA; + SQLSMALLINT table_len = SQL_NULL_DATA; char table_buf[80]; int found = 0; -#define LEN(x) (x) ? strlen(x) : SQL_NULL_DATA +#define LEN(x) (x) ? (SQLSMALLINT) strlen(x) : SQL_NULL_DATA if (table) { strcpy(table_buf, table); strcat(table_buf, "garbage"); - table_len = strlen(table); + table_len = LEN(table); } printf("Test type '%s' %s row at line %d\n", type ? type : "", row_returned ? "with" : "without", line); diff --git a/src/odbc/unittests/tvp.c b/src/odbc/unittests/tvp.c index ccf2b331c..dbac55a68 100644 --- a/src/odbc/unittests/tvp.c +++ b/src/odbc/unittests/tvp.c @@ -60,7 +60,8 @@ get_desc_field(SQLINTEGER desc_type, SQLSMALLINT icol, SQLSMALLINT fDescType, si memset(&buf, 0x5a, sizeof(buf)); ind = 1234; - CHKGetDescField(desc, icol, fDescType, &buf, size, &ind, "S"); + CHKGetDescField(desc, icol, fDescType, &buf, (SQLINTEGER) size, &ind, + "S"); assert(ind == size); return buf; @@ -387,8 +388,8 @@ TestDescriptorValues(void) SQLWCHAR *tableName; SQLLEN numRows; SQLPOINTER ptr; - SQLSMALLINT count, type; - SQLLEN len; + SQLSMALLINT type; + SQLLEN count, len; bool failed = false; tableName = odbc_get_sqlwchar(&odbc_buf, "TVPType"); diff --git a/src/odbc/unittests/utf8.c b/src/odbc/unittests/utf8.c index 71f75459b..ee92214bc 100644 --- a/src/odbc/unittests/utf8.c +++ b/src/odbc/unittests/utf8.c @@ -50,10 +50,13 @@ TestBinding(int minimun) SQLLEN s1_len, s2_len; unsigned int len; - len = minimun ? (strlen(strings_hex[p-strings]) - 2) /4 : 40; + len = minimun ? ((int) strlen(strings_hex[p-strings]) - 2) / 4 + : 40; CHKBindParameter(2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_WCHAR, len, 0, (void *) p[0], 0, &s1_len, "S"); - len = minimun ? (strlen(strings_hex[p+1-strings]) - 2) /4 : 40; + len = minimun + ? ((int) strlen(strings_hex[p+1-strings]) - 2) / 4 + : 40; /* FIXME this with SQL_VARCHAR produce wrong protocol data */ CHKBindParameter(3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_WVARCHAR, len, 0, (void *) p[1], 0, &s2_len, "S"); diff --git a/src/odbc/winsetup.c b/src/odbc/winsetup.c index d711ffe6c..40f05eed3 100644 --- a/src/odbc/winsetup.c +++ b/src/odbc/winsetup.c @@ -321,7 +321,7 @@ ConfigDSN(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver, LPCSTR lpszAttribut result = DialogBoxParam(hinstFreeTDS, MAKEINTRESOURCE(IDD_DSN), hwndParent, (DLGPROC) DSNDlgProc, (LPARAM) di); if (result < 0) { DWORD errorcode = GetLastError(); - char buf[1000]; + TCHAR buf[1000]; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, errorcode, 0, buf, 1000, NULL); } diff --git a/src/replacements/iconv.c b/src/replacements/iconv.c index 132302f0d..98ce157de 100644 --- a/src/replacements/iconv.c +++ b/src/replacements/iconv.c @@ -76,7 +76,7 @@ static int get_utf8(const unsigned char *p, size_t len, ICONV_CHAR *out) { uint32_t uc, state = UTF8_ACCEPT; - size_t l = 1; + unsigned int l = 1; do { switch (decode_utf8(&state, &uc, *p++)) { @@ -94,7 +94,7 @@ static int put_utf8(unsigned char *buf, size_t buf_len, ICONV_CHAR c) { #define MASK(n) ((0xffffffffu << (n)) & 0xffffffffu) - size_t o_len; + int o_len; if ((c & MASK(7)) == 0) { if (buf_len < 1) @@ -130,7 +130,7 @@ put_utf8(unsigned char *buf, size_t buf_len, ICONV_CHAR c) c >>= 6; } while (--buf_len); *--buf = (0xff00u >> o_len) | c; - return o_len; + return (int) o_len; } static int diff --git a/src/tds/config.c b/src/tds/config.c index 277795d01..87748cd9e 100644 --- a/src/tds/config.c +++ b/src/tds/config.c @@ -618,8 +618,9 @@ tds_parse_conf_section(const char *option, const char *value, void *param) char *end; long flags; flags = strtol(value, &end, 0); - if (*value != '\0' && *end == '\0' && flags != LONG_MIN && flags != LONG_MAX) - login->debug_flags = flags; + if (*value != '\0' && *end == '\0' && flags > INT_MIN + && flags < INT_MAX) + login->debug_flags = (int) flags; } else if (!strcmp(option, TDS_STR_TIMEOUT) || !strcmp(option, TDS_STR_QUERY_TIMEOUT)) { if (atoi(value)) login->query_timeout = atoi(value); diff --git a/src/tds/convert.c b/src/tds/convert.c index 320c5efda..1866cc539 100644 --- a/src/tds/convert.c +++ b/src/tds/convert.c @@ -298,10 +298,11 @@ tds_convert_binary(const TDS_UCHAR * src, TDS_INT srclen, int desttype, CONV_RES return TDS_CONVERT_NOAVAIL; } -TDS_INT -tds_char2hex(TDS_CHAR *dest, TDS_UINT destlen, const TDS_CHAR * src, TDS_UINT srclen) +ssize_t +tds_char2hex(TDS_CHAR *dest, size_t destlen, + const TDS_CHAR * src, size_t srclen) { - unsigned int i; + size_t i; unsigned char hex1, c = 0; /* if srclen if odd we must add a "0" before ... */ @@ -1115,7 +1116,7 @@ tds_convert_money4(const TDSCONTEXT * tds_ctx, const TDS_MONEY4 * src, int destt dollars = mny.mny4 / 10000; if (!IS_UINT(dollars)) return TDS_CONVERT_OVERFLOW; - cr->ui = dollars; + cr->ui = (TDS_UINT) dollars; return sizeof(TDS_UINT); break; case SYBINT8: @@ -1504,7 +1505,7 @@ tds_convert_bigdatetime(const TDSCONTEXT * tds_ctx, const TDS_BIGDATETIME * bigd dta.time = bdt % (UINT64_C(86400) * 1000000u) * 10u; bdt /= UINT64_C(86400) * 1000000u; dta.has_date = 1; - dta.date = bdt - BIGDATETIME_BIAS; + dta.date = (TDS_INT) (bdt - BIGDATETIME_BIAS); return tds_convert_datetimeall(tds_ctx, SYBMSDATETIME2, &dta, desttype, cr); } @@ -1866,7 +1867,10 @@ tds_convert_to_binary(int srctype, const TDS_CHAR * src, TDS_UINT srclen, int de test_alloc(cr->ib); ib = cr->ib; } - return tds_char2hex(ib, desttype == TDS_CONVERT_BINARY ? cr->cb.len : 0xffffffffu, src, srclen); + return (TDS_INT) tds_char2hex(ib, + desttype == TDS_CONVERT_BINARY + ? cr->cb.len : 0xffffffffu, + src, srclen); default: return TDS_CONVERT_NOAVAIL; @@ -3247,7 +3251,7 @@ tds_datecrack(TDS_INT datetype, const void *di, TDSDATEREC * dr) secs = bigdatetime % 60u; bigdatetime /= 60u; dt_time = bigdatetime % (24u*60u); - dt_days = bigdatetime / (24u*60u) - BIGDATETIME_BIAS; + dt_days = (int) (bigdatetime / (24u*60u) - BIGDATETIME_BIAS); } else { return TDS_FAIL; } diff --git a/src/tds/data.c b/src/tds/data.c index ba9ae3596..93a8bc034 100644 --- a/src/tds/data.c +++ b/src/tds/data.c @@ -511,7 +511,7 @@ tds_varmax_stream_read(TDSINSTREAM *stream, void *ptr, size_t len) /* read part of data */ if (len > s->chunk_left) len = s->chunk_left; - s->chunk_left -= len; + s->chunk_left -= (TDS_INT) len; if (tds_get_n(s->tds, ptr, len)) return len; return -1; @@ -793,7 +793,7 @@ tds_generic_get(TDSSOCKET * tds, TDSCOLUMN * curcol) dest = curcol->column_data; if (is_blob_col(curcol)) { TDSDATAINSTREAM r; - size_t allocated; + int allocated; TDSRET ret; blob = (TDSBLOB *) dest; /* cf. column_varint_size case 4, above */ @@ -898,13 +898,13 @@ tds_generic_put_info(TDSSOCKET * tds, TDSCOLUMN * col) && is_char_type(col->column_type)) { size = 255; } - tds_put_byte(tds, size); + TDS_PUT_BYTE(tds, size); break; case 2: - tds_put_smallint(tds, size); + TDS_PUT_SMALLINT(tds, size); break; case 4: - tds_put_int(tds, size); + TDS_PUT_INT(tds, size); break; case 8: tds_put_smallint(tds, 0xffff); @@ -1039,15 +1039,15 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) tds_put_n(tds, textptr, 16); tds_put_n(tds, textptr, 8); } - tds_put_int(tds, colsize); + TDS_PUT_INT(tds, colsize); break; case 2: colsize = MIN(colsize, size); - tds_put_smallint(tds, colsize); + TDS_PUT_SMALLINT(tds, colsize); break; case 1: colsize = MIN(colsize, size); - tds_put_byte(tds, colsize); + TDS_PUT_BYTE(tds, colsize); break; case 0: /* TODO should be column_size */ @@ -1086,7 +1086,7 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) case 4: if ( !is_blob_col(curcol) ) { colsize = MAX(MIN(colsize, 0x7fffffff), 1); - tds_put_int(tds, colsize); + TDS_PUT_INT(tds, colsize); break; } /* It's a BLOB... */ @@ -1094,11 +1094,11 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) tds_put_n(tds, blob->textptr, 16); tds_put_n(tds, blob->timestamp, 8); colsize = MIN(colsize, 0x7fffffff); - tds_put_int(tds, colsize); + TDS_PUT_INT(tds, colsize); break; case 2: colsize = MIN(colsize, 8000); - tds_put_smallint(tds, colsize); + TDS_PUT_SMALLINT(tds, colsize); break; case 1: if (!colsize) { @@ -1112,7 +1112,7 @@ tds_generic_put(TDSSOCKET * tds, TDSCOLUMN * curcol, int bcp7) return TDS_SUCCESS; } colsize = MIN(colsize, 255); - tds_put_byte(tds, colsize); + TDS_PUT_BYTE(tds, colsize); break; case 0: /* TODO should be column_size */ @@ -1385,7 +1385,7 @@ tds_msdatetime_put(TDSSOCKET *tds, TDSCOLUMN *col, int bcp7 TDS_UNUSED) TDS_PUT_UA2LE(p, dta->offset); p += 2; } - buf[0] = p - buf - 1; + buf[0] = (unsigned char) (p - buf - 1); tds_put_n(tds, buf, p - buf); return TDS_SUCCESS; @@ -1519,7 +1519,7 @@ tds_mstabletype_put_info(TDSSOCKET *tds, TDSCOLUMN *col) { TDS_TVP *table = (TDS_TVP *) col->column_data; TDSFREEZE current_freeze[1]; - size_t written; + unsigned int written; /* TVP_TYPENAME */ tds_put_byte(tds, 0); /* Empty DB name */ diff --git a/src/tds/gssapi.c b/src/tds/gssapi.c index f4c018bf3..9611e3c02 100644 --- a/src/tds/gssapi.c +++ b/src/tds/gssapi.c @@ -459,7 +459,7 @@ tds_gss_continue(TDSSOCKET * tds, struct tds_gss_auth *auth, gss_buffer_desc *to } auth->tds_auth.packet = (uint8_t *) send_tok.value; - auth->tds_auth.packet_len = send_tok.length; + auth->tds_auth.packet_len = (int) send_tok.length; return TDS_SUCCESS; } diff --git a/src/tds/login.c b/src/tds/login.c index 6257ef493..cdecdc573 100644 --- a/src/tds/login.c +++ b/src/tds/login.c @@ -417,7 +417,7 @@ tds_setup_connection(TDSSOCKET *tds, TDSLOGIN *login, bool set_db, bool set_spid { TDSRET erc; char *str; - int len; + size_t len; bool parse_results = false; len = 192 + tds_quote_id(tds, NULL, tds_dstr_cstr(&login->database),-1); @@ -970,7 +970,7 @@ tds7_send_login(TDSSOCKET * tds, const TDSLOGIN * login) TDS_INT time_zone = -120; TDS_INT tds7version = tds70Version; - TDS_INT block_size = 4096; + unsigned int block_size = 4096; unsigned char option_flag1 = TDS_SET_LANG_ON | TDS_USE_DB_NOTIFY | TDS_INIT_DB_FATAL; unsigned char option_flag2 = login->option_flag2; @@ -987,9 +987,9 @@ tds7_send_login(TDSSOCKET * tds, const TDSLOGIN * login) const char *user_name = tds_dstr_cstr(&login->user_name); unsigned char *pwd; - /* FIXME: These are defined as size_t, but should be TDS_SMALLINT. */ + /* FIXME: These should be TDS_SMALLINT. */ size_t user_name_len = strlen(user_name); - size_t auth_len = 0; + unsigned int auth_len = 0; static const char ext_data[] = "\x0a\x01\x00\x00\x00\x01" /* Enable UTF-8 */ @@ -1013,7 +1013,7 @@ tds7_send_login(TDSSOCKET * tds, const TDSLOGIN * login) }; struct { const void *ptr; - unsigned pos, len, limit; + size_t pos, len, limit; } data_fields[NUM_DATA_FIELDS], *field; tds->out_flag = TDS7_LOGIN; @@ -1276,7 +1276,7 @@ tds71_do_login(TDSSOCKET * tds, TDSLOGIN* login) { int i, pkt_len; const char *instance_name = tds_dstr_isempty(&login->instance_name) ? "MSSQLServer" : tds_dstr_cstr(&login->instance_name); - int instance_name_len = strlen(instance_name) + 1; + TDS_USMALLINT instance_name_len = strlen(instance_name) + 1; TDS_CHAR crypt_flag; unsigned int start_pos = 21; TDSRET ret; diff --git a/src/tds/mem.c b/src/tds/mem.c index c487f7d08..f55203a97 100644 --- a/src/tds/mem.c +++ b/src/tds/mem.c @@ -883,7 +883,8 @@ tds_init_login(TDSLOGIN *login, TDSLOCALE * locale) } TDSCURSOR * -tds_alloc_cursor(TDSSOCKET *tds, const char *name, TDS_INT namelen, const char *query, TDS_INT querylen) +tds_alloc_cursor(TDSSOCKET *tds, const char *name, size_t namelen, + const char *query, size_t querylen) { TDSCURSOR *cursor; TDSCURSOR *pcursor; @@ -1344,7 +1345,7 @@ tds_alloc_socket(TDSCONTEXT * context, unsigned int bufsize) #endif /* !ENABLE_ODBC_MARS */ TDSSOCKET * -tds_realloc_socket(TDSSOCKET * tds, size_t bufsize) +tds_realloc_socket(TDSSOCKET * tds, unsigned int bufsize) { TDSPACKET *packet; #if ENABLE_ODBC_MARS diff --git a/src/tds/net.c b/src/tds/net.c index 466776c0b..f18b0ff29 100644 --- a/src/tds/net.c +++ b/src/tds/net.c @@ -723,10 +723,12 @@ tds_select(TDSSOCKET * tds, unsigned tds_sel, int timeout_seconds) * @TODO remove tds, save error somewhere, report error in another way * @returns 0 if blocking, <0 error >0 bytes read */ -static int -tds_socket_read(TDSCONNECTION * conn, TDSSOCKET *tds, unsigned char *buf, int buflen) +static ssize_t +tds_socket_read(TDSCONNECTION * conn, TDSSOCKET *tds, unsigned char *buf, + size_t buflen) { - int len, err; + ssize_t len; + int err; #if ENABLE_EXTRA_CHECKS /* this simulate the fact that recv can return less bytes */ @@ -758,10 +760,12 @@ tds_socket_read(TDSCONNECTION * conn, TDSSOCKET *tds, unsigned char *buf, int bu * Write to an OS socket * @returns 0 if blocking, <0 error >0 bytes readed */ -static int -tds_socket_write(TDSCONNECTION *conn, TDSSOCKET *tds, const unsigned char *buf, int buflen) +static ssize_t +tds_socket_write(TDSCONNECTION *conn, TDSSOCKET *tds, const unsigned char *buf, + size_t buflen) { - int err, len; + int err; + ssize_t len; char *errstr; #if ENABLE_EXTRA_CHECKS @@ -855,7 +859,7 @@ tds_wakeup_send(TDSPOLLWAKEUP *wakeup, char cancel) static int tds_connection_signaled(TDSCONNECTION *conn) { - int len; + ssize_t len; char to_cancel[16]; #if defined(__linux__) && HAVE_EVENTFD @@ -912,14 +916,15 @@ tds_check_cancel(TDSCONNECTION *conn) * Loops until we have received some characters * return -1 on failure */ -int -tds_goodread(TDSSOCKET * tds, unsigned char *buf, int buflen) +ssize_t +tds_goodread(TDSSOCKET * tds, unsigned char *buf, size_t buflen) { if (tds == NULL || buf == NULL || buflen < 1) return -1; for (;;) { - int len, err; + ssize_t len; + int err; /* FIXME this block writing from other sessions */ len = tds_select(tds, TDSSELREAD, tds->query_timeout); @@ -961,8 +966,8 @@ tds_goodread(TDSSOCKET * tds, unsigned char *buf, int buflen) } } -int -tds_connection_read(TDSSOCKET * tds, unsigned char *buf, int buflen) +ssize_t +tds_connection_read(TDSSOCKET * tds, unsigned char *buf, size_t buflen) { TDSCONNECTION *conn = tds->conn; @@ -983,10 +988,10 @@ tds_connection_read(TDSSOCKET * tds, unsigned char *buf, int buflen) * \param last 1 if this is the last packet, else 0 * \return length written (>0), <0 on failure */ -int +ssize_t tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, size_t buflen) { - int len; + ssize_t len; size_t sent = 0; assert(tds && buffer); @@ -1048,10 +1053,11 @@ tds_socket_flush(TDS_SYS_SOCKET sock TDS_UNUSED) #endif } -int -tds_connection_write(TDSSOCKET *tds, const unsigned char *buf, int buflen, int final) +ssize_t +tds_connection_write(TDSSOCKET *tds, const unsigned char *buf, size_t buflen, + int final) { - int sent; + ssize_t sent; TDSCONNECTION *conn = tds->conn; #if !defined(_WIN32) && !defined(MSG_NOSIGNAL) && !defined(DOS32X) && !defined(SO_NOSIGPIPE) @@ -1097,7 +1103,7 @@ tds7_get_instance_ports(FILE *output, struct addrinfo *addr) int retval; TDS_SYS_SOCKET s; char msg[16*1024]; - int msg_len = 0; + ssize_t msg_len = 0; int port = 0; char ipaddr[128]; @@ -1233,7 +1239,7 @@ tds7_get_instance_port(struct addrinfo *addr, const char *instance) int retval; TDS_SYS_SOCKET s; char msg[1024]; - int msg_len; + ssize_t msg_len; int port = 0; char ipaddr[128]; @@ -1350,7 +1356,7 @@ tds7_get_instance_port(struct addrinfo *addr, const char *instance) } } if (port_ok && instance_ok) { - port = l; + port = (int) l; break; } } diff --git a/src/tds/packet.c b/src/tds/packet.c index e257adfca..fb32ae041 100644 --- a/src/tds/packet.c +++ b/src/tds/packet.c @@ -599,7 +599,7 @@ tds_read_packet(TDSSOCKET * tds) tds->in_len = 0; tds->in_pos = 0; for (p = pkt, end = p+8; p < end;) { - int len = tds_connection_read(tds, p, end - p); + ssize_t len = tds_connection_read(tds, p, end - p); if (len <= 0) { tds_close_socket(tds); return -1; @@ -632,7 +632,7 @@ tds_read_packet(TDSSOCKET * tds) tds->in_flag = pkt[0]; /* Set the length and pos (not sure what pos is used for now */ - tds->in_len = p - pkt; + tds->in_len = (unsigned int) (p - pkt); tds->in_pos = 8; tdsdump_dump_buf(TDS_DBG_NETWORK, "Received packet", tds->in_buf, tds->in_len); @@ -815,7 +815,7 @@ int tds_put_cancel(TDSSOCKET * tds) { unsigned char out_buf[8]; - int sent; + ssize_t sent; out_buf[0] = TDS_CANCEL; /* out_flag */ out_buf[1] = 1; /* final */ @@ -931,12 +931,12 @@ tds_freeze(TDSSOCKET *tds, TDSFREEZE *freeze, unsigned size_len) * * @return bytes written since ::tds_freeze call */ -size_t +unsigned int tds_freeze_written(TDSFREEZE *freeze) { TDSSOCKET *tds = freeze->tds; TDSPACKET *pkt = freeze->pkt; - size_t size; + unsigned int size; CHECK_FREEZE_EXTRA(freeze); diff --git a/src/tds/query.c b/src/tds/query.c index 089750c77..7244b8e57 100644 --- a/src/tds/query.c +++ b/src/tds/query.c @@ -123,7 +123,8 @@ tds_ascii_to_ucs2(char *buffer, const char *buf) * \return string allocated (or input pointer if no conversion required) or NULL if error */ const char * -tds_convert_string(TDSSOCKET * tds, TDSICONV * char_conv, const char *s, int len, size_t *out_len) +tds_convert_string(TDSSOCKET * tds, TDSICONV * char_conv, const char *s, + ssize_t len, size_t *out_len) { char *buf; @@ -399,7 +400,9 @@ tds_submit_query_params(TDSSOCKET * tds, const char *query, TDSPARAMINFO * param TDSFREEZE outer; TDSRET rc; - converted_query = tds_convert_string(tds, tds->conn->char_convs[client2ucs2], query, (int)query_len, &converted_query_len); + converted_query = tds_convert_string + (tds, tds->conn->char_convs[client2ucs2], + query, query_len, &converted_query_len); if (!converted_query) { tds_set_state(tds, TDS_IDLE); return TDS_FAIL; @@ -745,7 +748,7 @@ tds_get_column_declaration(TDSSOCKET * tds, TDSCOLUMN * curcol, char *out) CHECK_TDS_EXTRA(tds); CHECK_COLUMN_EXTRA(curcol); - size = tds_fix_column_size(tds, curcol); + size = (unsigned int) tds_fix_column_size(tds, curcol); switch (tds_get_conversion_type(curcol->on_server.column_type, curcol->on_server.column_size)) { case XSYBCHAR: @@ -954,7 +957,7 @@ tds7_write_param_def_from_query(TDSSOCKET * tds, const char* converted_query, si { char declaration[128], *p; int i, count; - size_t written; + unsigned int written; TDSFREEZE outer, inner; assert(IS_TDS7_PLUS(tds->conn)); @@ -1020,7 +1023,7 @@ tds7_write_param_def_from_params(TDSSOCKET * tds, const char* query, size_t quer size_t len; } *ids = NULL; TDSFREEZE outer, inner; - size_t written; + unsigned int written; assert(IS_TDS7_PLUS(tds->conn)); @@ -1077,8 +1080,9 @@ tds7_write_param_def_from_params(TDSSOCKET * tds, const char* query, size_t quer if (ids[i].p) { tds_put_n(tds, ids[i].p, ids[i].len); } else { - tds_put_string(tds, tds_dstr_cstr(¶ms->columns[i]->column_name), - tds_dstr_len(¶ms->columns[i]->column_name)); + const DSTR *name = ¶ms->columns[i]->column_name; + tds_put_string(tds, tds_dstr_cstr(name), + (int) tds_dstr_len(name)); } tds_put_smallint(tds, ' '); @@ -1308,7 +1312,7 @@ tds_submit_execdirect(TDSSOCKET * tds, const char *query, TDSPARAMINFO * params, size_t query_len; TDSCOLUMN *param; TDSDYNAMIC *dyn; - size_t id_len; + unsigned int id_len; TDSFREEZE outer; CHECK_TDS_EXTRA(tds); @@ -1415,7 +1419,7 @@ tds_submit_execdirect(TDSSOCKET * tds, const char *query, TDSPARAMINFO * params, tds->out_flag = TDS_NORMAL; - id_len = strlen(dyn->id); + id_len = (unsigned int) strlen(dyn->id); tds_put_byte(tds, TDS5_DYNAMIC_TOKEN); tds_freeze(tds, &outer, 2); tds_put_byte(tds, TDS_DYN_EXEC_IMMED); @@ -1588,12 +1592,12 @@ tds_put_data_info(TDSSOCKET * tds, TDSCOLUMN * curcol, int flags) CHECK_COLUMN_EXTRA(curcol); if (flags & TDS_PUT_DATA_USE_NAME) { - len = tds_dstr_len(&curcol->column_name); + len = (int) tds_dstr_len(&curcol->column_name); tdsdump_log(TDS_DBG_ERROR, "tds_put_data_info putting param_name \n"); if (IS_TDS7_PLUS(tds->conn)) { TDSFREEZE outer; - size_t written; + unsigned int written; tds_freeze(tds, &outer, 1); if ((flags & TDS_PUT_DATA_PREFIX_NAME) != 0) @@ -1622,7 +1626,7 @@ tds_put_data_info(TDSSOCKET * tds, TDSCOLUMN * curcol, int flags) tds_put_byte(tds, curcol->column_output); /* status (input) */ if (!IS_TDS7_PLUS(tds->conn)) tds_put_int(tds, curcol->column_usertype); /* usertype */ - tds_put_byte(tds, curcol->on_server.column_type); + TDS_PUT_BYTE(tds, curcol->on_server.column_type); if (curcol->funcs->put_info(tds, curcol) != TDS_SUCCESS) return TDS_FAIL; @@ -1953,7 +1957,8 @@ tds4_send_emulated_rpc(TDSSOCKET * tds, const char *rpc_name, TDSPARAMINFO * par param = params->columns[i]; tds_put_string(tds, sep, -1); if (!tds_dstr_isempty(¶m->column_name)) { - tds_put_string(tds, tds_dstr_cstr(¶m->column_name), tds_dstr_len(¶m->column_name)); + tds_put_string(tds, tds_dstr_cstr(¶m->column_name), + (int)tds_dstr_len(¶m->column_name)); tds_put_string(tds, "=", 1); } if (param->column_output) { @@ -1998,7 +2003,7 @@ tds_submit_rpc(TDSSOCKET * tds, const char *rpc_name, TDSPARAMINFO * params, TDS rpc_name_len = (int)strlen(rpc_name); if (IS_TDS7_PLUS(tds->conn)) { TDSFREEZE outer; - size_t written; + unsigned int written; if (tds_start_query_head(tds, TDS_RPC, head) != TDS_SUCCESS) return TDS_FAIL; @@ -2215,7 +2220,7 @@ tds_quote(char *buffer, char quoting, const char *id, size_t len) * \see tds_quote_id_rpc */ size_t -tds_quote_id(TDSSOCKET * tds, char *buffer, const char *id, int idlen) +tds_quote_id(TDSSOCKET * tds, char *buffer, const char *id, ssize_t idlen) { size_t i, len; @@ -2260,7 +2265,7 @@ tds_quote_id(TDSSOCKET * tds, char *buffer, const char *id, int idlen) * \see tds_quote_id */ size_t -tds_quote_id_rpc(TDSSOCKET * tds, char *buffer, const char *id, int idlen) +tds_quote_id_rpc(TDSSOCKET * tds, char *buffer, const char *id, ssize_t idlen) { size_t len; /* We are quoting for RPC calls, not base language queries. For RPC calls Sybase @@ -2285,7 +2290,8 @@ tds_quote_id_rpc(TDSSOCKET * tds, char *buffer, const char *id, int idlen) * \result written chars (not including needed terminator) */ size_t -tds_quote_string(TDSSOCKET * tds TDS_UNUSED, char *buffer, const char *str, int len) +tds_quote_string(TDSSOCKET * tds TDS_UNUSED, char *buffer, const char *str, + ssize_t len) { return tds_quote(buffer, '\'', str, len < 0 ? strlen(str) : (size_t) len); } @@ -2393,8 +2399,9 @@ tds_cursor_open(TDSSOCKET * tds, TDSCURSOR * cursor, TDSPARAMINFO *params, bool TDSRET rc = TDS_SUCCESS; /* cursor statement */ - converted_query = tds_convert_string(tds, tds->conn->char_convs[client2ucs2], - cursor->query, (int)strlen(cursor->query), &converted_query_len); + converted_query = tds_convert_string + (tds, tds->conn->char_convs[client2ucs2], cursor->query, + strlen(cursor->query), &converted_query_len); if (!converted_query) { if (!*something_to_send) tds_set_state(tds, TDS_IDLE); @@ -2855,7 +2862,7 @@ TDSRET tds_cursor_setname(TDSSOCKET * tds, TDSCURSOR * cursor) { TDSFREEZE outer; - size_t written; + unsigned int written; CHECK_TDS_EXTRA(tds); @@ -2988,7 +2995,7 @@ tds_cursor_update(TDSSOCKET * tds, TDSCURSOR * cursor, TDS_CURSOR_OPERATION op, unsigned int n, num_params; const char *table_name = NULL; TDSFREEZE outer; - size_t written; + unsigned int written; /* empty table name */ tds_put_byte(tds, 0); diff --git a/src/tds/read.c b/src/tds/read.c index 1403c6348..170329c86 100644 --- a/src/tds/read.c +++ b/src/tds/read.c @@ -210,7 +210,9 @@ tds_get_char_data(TDSSOCKET * tds, char *row_buffer, size_t wire_size, TDSCOLUMN } in_left = curcol->column_size; - curcol->column_cur_size = read_and_convert(tds, curcol->char_conv, &wire_size, row_buffer, in_left); + curcol->column_cur_size + = (TDS_INT) read_and_convert(tds, curcol->char_conv, &wire_size, + row_buffer, in_left); if (TDS_UNLIKELY(wire_size > 0)) { tds_get_n(tds, NULL, wire_size); tdsdump_log(TDS_DBG_NETWORK, "error: tds_get_char_data: discarded %u on wire while reading %d into client. \n", @@ -248,7 +250,7 @@ tds_get_n(TDSSOCKET * tds, void *dest, size_t need) if (dest != NULL) { memcpy((char *) dest, tds->in_buf + tds->in_pos, need); } - tds->in_pos += need; + tds->in_pos += (unsigned int) need; } return true; } diff --git a/src/tds/sspi.c b/src/tds/sspi.c index b1e5ddc30..e3196022d 100644 --- a/src/tds/sspi.c +++ b/src/tds/sspi.c @@ -279,12 +279,12 @@ tds_sspi_get_auth(TDSSOCKET * tds) #else identity.Flags = SEC_WINNT_AUTH_IDENTITY_ANSI; #endif - identity.Password = (void *) passwd; + identity.Password = (_TUCHAR *) passwd; identity.PasswordLength = (unsigned long) _tcslen(passwd); - identity.Domain = (void *) user_name; + identity.Domain = (_TUCHAR *) user_name; identity.DomainLength = (unsigned long) (p - user_name); user_name = p + 1; - identity.User = (void *) user_name; + identity.User = (_TUCHAR *) user_name; identity.UserLength = (unsigned long) _tcslen(user_name); } diff --git a/src/tds/tds_checks.c b/src/tds/tds_checks.c index c1a609f38..e227b7aea 100644 --- a/src/tds/tds_checks.c +++ b/src/tds/tds_checks.c @@ -53,7 +53,7 @@ void tds_check_tds_extra(const TDSSOCKET * tds) { const int invalid_state = 0; - int i; + TDS_UINT i; TDSDYNAMIC *cur_dyn = NULL; TDSCURSOR *cur_cursor = NULL; diff --git a/src/tds/token.c b/src/tds/token.c index 1cafae71c..ffaeb220f 100644 --- a/src/tds/token.c +++ b/src/tds/token.c @@ -2627,7 +2627,8 @@ tds_process_dynamic(TDSSOCKET * tds) drain = id_len - TDS_MAX_DYNID_LEN; id_len = TDS_MAX_DYNID_LEN; } - id_len = tds_get_string(tds, id_len, id, TDS_MAX_DYNID_LEN); + id_len = (TDS_TINYINT) tds_get_string(tds, id_len, id, + TDS_MAX_DYNID_LEN); id[id_len] = '\0'; if (drain) { tds_get_n(tds, NULL, drain); diff --git a/src/tds/unittests/allcolumns.c b/src/tds/unittests/allcolumns.c index abf9c0017..7f0dc8480 100644 --- a/src/tds/unittests/allcolumns.c +++ b/src/tds/unittests/allcolumns.c @@ -231,7 +231,7 @@ static void create_type(TDSSOCKET *tds, int desttype, int server_type, tds_any_t break; } assert(src); - srclen = strlen(src); + srclen = (TDS_UINT) strlen(src); /* * Now at last do the conversion diff --git a/src/tds/unittests/charconv.c b/src/tds/unittests/charconv.c index d8f901be2..e38d1c38a 100644 --- a/src/tds/unittests/charconv.c +++ b/src/tds/unittests/charconv.c @@ -102,9 +102,9 @@ add_odd(char *buf, int *pos, enum Odd type) return 0; case ODD_NORMAL: - buf[*pos] = 0xC0 + (x >> 6); + buf[*pos] = (char) (0xC0 + (x >> 6)); ++*pos; - buf[*pos] = 0x80 + (x & 0x3f); + buf[*pos] = (char) (0x80 + (x & 0x3f)); ++*pos; return 0; diff --git a/src/tds/unittests/convert.c b/src/tds/unittests/convert.c index 6e8482706..815e1107d 100644 --- a/src/tds/unittests/convert.c +++ b/src/tds/unittests/convert.c @@ -214,7 +214,7 @@ main(int argc, char **argv) break; } assert(src); - srclen = strlen(src); + srclen = (TDS_UINT) strlen(src); break; case SYBINT1: case SYBUINT1: diff --git a/src/tds/unittests/convert_bounds.c b/src/tds/unittests/convert_bounds.c index 48bbb099e..191fd7db5 100644 --- a/src/tds/unittests/convert_bounds.c +++ b/src/tds/unittests/convert_bounds.c @@ -215,7 +215,8 @@ is_valid(const char *num, int type, CONV_RESULT *cr) if (!cr) cr = &dummy_cr; - return convert_and_free(SYBVARCHAR, num, strlen(num), type, cr) >= 0; + return convert_and_free(SYBVARCHAR, num, (TDS_UINT) strlen(num), type, + cr) >= 0; } /* convert multiple precision to a floating number of a specific type */ diff --git a/src/tds/unittests/corrupt.c b/src/tds/unittests/corrupt.c index 317a5ce23..677661cce 100644 --- a/src/tds/unittests/corrupt.c +++ b/src/tds/unittests/corrupt.c @@ -54,7 +54,7 @@ unfinished_query_test(TDSSOCKET *tds) memset(strchr(buf, 0), 0, 16); /* convert if needed */ - len = strlen(buf); + len = (int) strlen(buf); for (i = len; --i >= 0; ) { char c = buf[i]; buf[i * char_len + 0] = c; diff --git a/src/tds/unittests/freeze.c b/src/tds/unittests/freeze.c index d64e9063c..2dc1040f2 100644 --- a/src/tds/unittests/freeze.c +++ b/src/tds/unittests/freeze.c @@ -192,8 +192,7 @@ static void test1(void) { TDSFREEZE outer, inner; - size_t written; - unsigned left; + unsigned written, left; /* just to not start at 0 */ append("test", 4); diff --git a/src/tds/unittests/iconv_fread.c b/src/tds/unittests/iconv_fread.c index 4911dc63d..8f6c925e2 100644 --- a/src/tds/unittests/iconv_fread.c +++ b/src/tds/unittests/iconv_fread.c @@ -84,8 +84,8 @@ main(void) return 1; } memset(buf, 'a', i); - buf[i] = 0xC0 + (x >> 6); - buf[i+1] = 0x80 + (x & 0x3f); + buf[i] = (char) (0xC0 + (x >> 6)); + buf[i+1] = (char) (0x80 + (x & 0x3f)); buf[i+2] = '!'; buf[i+3] = '!'; diff --git a/src/tds/unittests/t0007.c b/src/tds/unittests/t0007.c index 3f25f2475..37b4f4da7 100644 --- a/src/tds/unittests/t0007.c +++ b/src/tds/unittests/t0007.c @@ -397,9 +397,13 @@ main(void) /* try conversion from char (already tested above) */ cr_src.n.precision = 20; cr_src.n.scale = 0; - len_src = tds_convert(&ctx, SYBVARCHAR, *value, strlen(*value), *type1, &cr_src); + len_src = tds_convert(&ctx, SYBVARCHAR, *value, + (TDS_UINT) strlen(*value), *type1, + &cr_src); cr_dst.n.precision = 20; cr_dst.n.scale = 0; - len_dst = tds_convert(&ctx, SYBVARCHAR, *value, strlen(*value), *type2, &cr_dst); + len_dst = tds_convert(&ctx, SYBVARCHAR, *value, + (TDS_UINT) strlen(*value), *type2, + &cr_dst); if (len_src <= 0 || len_dst <= 0) continue; cr_dst.n.precision = 20; cr_dst.n.scale = 0; diff --git a/src/tds/unittests/t0008.c b/src/tds/unittests/t0008.c index fe15d787c..d759d701c 100644 --- a/src/tds/unittests/t0008.c +++ b/src/tds/unittests/t0008.c @@ -43,7 +43,9 @@ test(const char *src, const char *intro, const char *cont, int prec, int scale, memset(&cr.n, 0, sizeof(cr.n)); cr.n.precision = prec; cr.n.scale = scale; - if (tds_convert(&ctx, SYBVARCHAR, src, strlen(src), SYBNUMERIC, &cr) < 0) + if (tds_convert(&ctx, SYBVARCHAR, src, (TDS_UINT) strlen(src), + SYBNUMERIC, &cr) + < 0) strcpy(buf, "error"); else { sprintf(buf, "prec=%d scale=%d", cr.n.precision, cr.n.scale); diff --git a/src/tds/unittests/utf8_1.c b/src/tds/unittests/utf8_1.c index 5a7bdd235..558e7ae04 100644 --- a/src/tds/unittests/utf8_1.c +++ b/src/tds/unittests/utf8_1.c @@ -196,7 +196,7 @@ main(void) if (IS_TDS7_PLUS(tds->conn)) { char type[32]; char buf[1024]; - int i, len; + size_t i, len; strcpy(buf, "aaa"); len = 0; diff --git a/src/tds/vstrbuild.c b/src/tds/vstrbuild.c index 32274e941..00561bc9c 100644 --- a/src/tds/vstrbuild.c +++ b/src/tds/vstrbuild.c @@ -45,7 +45,7 @@ struct string_linked_list */ static char * -norm_fmt(const char *fmt, int fmtlen) +norm_fmt(const char *fmt, ssize_t fmtlen) { char *newfmt; char *cp; diff --git a/src/tds/write.c b/src/tds/write.c index 7cc4a041a..0b2fffeb1 100644 --- a/src/tds/write.c +++ b/src/tds/write.c @@ -141,7 +141,7 @@ tds_put_string(TDSSOCKET * tds, const char *s, int len) tds_dataout_stream_init(&w, tds); res = tds_convert_stream(tds, tds->conn->char_convs[iconv_entry], to_server, &r.stream, &w.stream); - return w.written; + return (int) w.written; } int diff --git a/src/utils/des.c b/src/utils/des.c index f1520bf14..f53339269 100644 --- a/src/utils/des.c +++ b/src/utils/des.c @@ -623,9 +623,10 @@ spinit(DES_KEY * key) /* ECB MODE */ int -tds_des_ecb_encrypt(const void *plaintext, int len, DES_KEY * akey, unsigned char *output) +tds_des_ecb_encrypt(const void *plaintext, size_t len, DES_KEY * akey, + unsigned char *output) { - int j; + size_t j; const unsigned char *plain = (const unsigned char *) plaintext; for (j = 0; j < len / 8; j++) { From 58c9ae5adf817d7025fc19610f4663076a437f86 Mon Sep 17 00:00:00 2001 From: "Aaron M. Ucko" Date: Tue, 21 May 2024 14:46:04 -0400 Subject: [PATCH 7/7] Comment out or fully retire unread variables. All could at least potentially receive updates, but they were never consulted or even logged. Leave some commented out rather than fully retired for ease of reinstatement if they're helpful to examine in a debugger. Signed-off-by: Aaron M. Ucko --- src/dblib/bcp.c | 3 +-- src/dblib/unittests/numeric.c | 3 +-- src/dblib/unittests/timeout.c | 4 ++-- src/odbc/unittests/testodbc.c | 8 ++++---- src/tds/read.c | 3 +-- src/tds/unittests/t0006.c | 6 +++--- src/tds/unittests/utf8_1.c | 4 ++-- src/tds/unittests/utf8_3.c | 6 +++--- src/tds/write.c | 4 ++-- 9 files changed, 19 insertions(+), 22 deletions(-) diff --git a/src/dblib/bcp.c b/src/dblib/bcp.c index d4a18f289..125cdb5ea 100644 --- a/src/dblib/bcp.c +++ b/src/dblib/bcp.c @@ -1686,7 +1686,6 @@ bcp_readfmt(DBPROCESS * dbproc, const char filename[]) BCP_HOSTCOLINFO hostcol[1]; FILE *ffile; char buffer[1024]; - float lf_version = 0.0; int li_numcols = 0; int colinfo_count = 0; @@ -1703,7 +1702,7 @@ bcp_readfmt(DBPROCESS * dbproc, const char filename[]) } if ((_bcp_fgets(buffer, sizeof(buffer), ffile)) != NULL) { - lf_version = (float)atof(buffer); + /* version (float), ignored */ } else if (ferror(ffile)) { dbperror(dbproc, SYBEBRFF, errno); goto Cleanup; diff --git a/src/dblib/unittests/numeric.c b/src/dblib/unittests/numeric.c index 9f9e7fba4..cd67bbc5b 100644 --- a/src/dblib/unittests/numeric.c +++ b/src/dblib/unittests/numeric.c @@ -43,7 +43,6 @@ test(int bind_type, const char *bind_name, int override_prec, int override_scale DBNUMERIC *num = NULL, *num2 = NULL; RETCODE ret; DBTYPEINFO ti; - int i; printf("*** Starting test msdblib %d bind %s prec %d scale %d out prec %d out scale %d line %d\n", msdblib, bind_name, override_prec, override_scale, out_prec, out_scale, line); @@ -116,7 +115,7 @@ test(int bind_type, const char *bind_name, int override_prec, int override_scale ret = dbconvert_ps(dbproc, SYBVARCHAR, (const BYTE *) "246.9", -1, SYBDECIMAL, (BYTE *) num2, sizeof(*num2), &ti); chk(ret > 0, "dbconvert_ps"); - for (i=0; (ret = dbresults(dbproc)) != NO_MORE_RESULTS; ++i) { + while ((ret = dbresults(dbproc)) != NO_MORE_RESULTS) { RETCODE row_code; switch (ret) { diff --git a/src/dblib/unittests/timeout.c b/src/dblib/unittests/timeout.c index e37944197..27258a01c 100644 --- a/src/dblib/unittests/timeout.c +++ b/src/dblib/unittests/timeout.c @@ -100,7 +100,7 @@ test(int per_process) DBPROCESS *dbproc; int i, r; RETCODE erc, row_code; - int num_resultset = 0; + /* int num_resultset = 0; */ char teststr[1024]; char timeout[32]; @@ -236,7 +236,7 @@ test(int per_process) printf("dbrows() returned SUCCEED, processing rows\n"); ncols = dbnumcols(dbproc); - ++num_resultset; + /* ++num_resultset; */ printf("bound 1 of %d columns ('%s') in result %d.\n", ncols, dbcolname(dbproc, 1), ++r); dbbind(dbproc, 1, STRINGBIND, 0, (BYTE *) teststr); diff --git a/src/odbc/unittests/testodbc.c b/src/odbc/unittests/testodbc.c index c16fb2299..5b5d378cd 100644 --- a/src/odbc/unittests/testodbc.c +++ b/src/odbc/unittests/testodbc.c @@ -188,7 +188,7 @@ TestRawODBCGuid(void) SQLCHAR name[20]; SQLGUID sqlguid; - int count = 0; + /* int count = 0; */ AB_FUNCT(("TestRawODBCGuid (in)")); @@ -297,7 +297,7 @@ TestRawODBCGuid(void) queryString = "SELECT name, guid FROM #pet"; CHKExecDirect(T(queryString), SQL_NTS, "S"); while (SQLFetch(odbc_stmt) == SQL_SUCCESS) { - count++; + /* count++; */ CHKGetData(1, SQL_CHAR, name, 20, 0, "S"); CHKGetData(2, SQL_CHAR, guid, 37, 0, "S"); @@ -319,7 +319,7 @@ TestRawODBCGuid(void) queryString = "SELECT name, guid FROM #pet"; CHKExecDirect(T(queryString), SQL_NTS, "S"); while (CHKFetch("SNo") == SQL_SUCCESS) { - count++; + /* count++; */ CHKGetData(1, SQL_CHAR, name, 20, 0, "S"); CHKGetData(2, SQL_GUID, &sqlguid, 16, 0, "S"); @@ -349,7 +349,7 @@ TestRawODBCGuid(void) CHKBindParameter(1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_GUID, 0, 0, guid, 0, &lenOrInd, "S"); CHKExecDirect(T(queryString), SQL_NTS, "S"); while (SQLFetch(odbc_stmt) == SQL_SUCCESS) { - count++; + /* count++; */ CHKGetData(1, SQL_CHAR, name, 20, 0, "S"); CHKGetData(2, SQL_CHAR, guid, 37, 0, "S"); diff --git a/src/tds/read.c b/src/tds/read.c index 170329c86..306b8bb5d 100644 --- a/src/tds/read.c +++ b/src/tds/read.c @@ -271,14 +271,13 @@ static size_t read_and_convert(TDSSOCKET * tds, TDSICONV * char_conv, size_t * wire_size, char *outbuf, size_t outbytesleft) { - int res; TDSDATAINSTREAM r; TDSSTATICOUTSTREAM w; tds_datain_stream_init(&r, tds, *wire_size); tds_staticout_stream_init(&w, outbuf, outbytesleft); - res = tds_convert_stream(tds, char_conv, to_client, &r.stream, &w.stream); + tds_convert_stream(tds, char_conv, to_client, &r.stream, &w.stream); *wire_size = r.wire_size; return (char *) w.stream.buffer - outbuf; } diff --git a/src/tds/unittests/t0006.c b/src/tds/unittests/t0006.c index 59a1e6ab5..2c84357fb 100644 --- a/src/tds/unittests/t0006.c +++ b/src/tds/unittests/t0006.c @@ -28,7 +28,7 @@ main(void) TDSSOCKET *tds; int verbose = 0; int rc; - int row_count, i; + int /* row_count, */ i; /* variables for conversions */ TDSCOLUMN *curcol; @@ -100,7 +100,7 @@ main(void) rc = tds_submit_query(tds, "SELECT * FROM #test_table"); - row_count = 0; + /* row_count = 0; */ while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCESS) { switch (result_type) { case TDS_ROW_RESULT: @@ -130,7 +130,7 @@ main(void) } } } - row_count++; + /* row_count++; */ case TDS_COMPUTE_RESULT: break; default: diff --git a/src/tds/unittests/utf8_1.c b/src/tds/unittests/utf8_1.c index 558e7ae04..69c7ff067 100644 --- a/src/tds/unittests/utf8_1.c +++ b/src/tds/unittests/utf8_1.c @@ -196,11 +196,11 @@ main(void) if (IS_TDS7_PLUS(tds->conn)) { char type[32]; char buf[1024]; - size_t i, len; + size_t len; strcpy(buf, "aaa"); len = 0; - for (i = 0; strlen(buf) < 980 && len < 200; ++i) { + while (strlen(buf) < 980 && len < 200) { char tmp[256]; strcat(buf, japanese); diff --git a/src/tds/unittests/utf8_3.c b/src/tds/unittests/utf8_3.c index 3bfa76970..e17dec107 100644 --- a/src/tds/unittests/utf8_3.c +++ b/src/tds/unittests/utf8_3.c @@ -31,7 +31,7 @@ test(const char *buf) { char query[1024]; char tmp[129 * 3]; - int i; + /* int i; */ int rc; TDS_INT result_type; int done_flags; @@ -66,7 +66,7 @@ test(const char *buf) exit(1); } - i = 0; + /* i = 0; */ while ((rc = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_STOPAT_DONE|TDS_RETURN_ROW|TDS_RETURN_COMPUTE)) == TDS_SUCCESS) { TDSCOLUMN *curcol; @@ -82,7 +82,7 @@ test(const char *buf) (unsigned) tds_dstr_len(&curcol->column_name), tmp, (unsigned int) strlen(tmp)); exit(1); } - ++i; + /* ++i; */ } if (rc != TDS_SUCCESS || result_type == TDS_ROW_RESULT || result_type == TDS_COMPUTE_RESULT) { diff --git a/src/tds/write.c b/src/tds/write.c index 0b2fffeb1..170608648 100644 --- a/src/tds/write.c +++ b/src/tds/write.c @@ -96,7 +96,6 @@ tds_put_n(TDSSOCKET * tds, const void *buf, size_t n) int tds_put_string(TDSSOCKET * tds, const char *s, int len) { - int res; TDSSTATICINSTREAM r; TDSDATAOUTSTREAM w; enum TDS_ICONV_ENTRY iconv_entry; @@ -140,7 +139,8 @@ tds_put_string(TDSSOCKET * tds, const char *s, int len) tds_staticin_stream_init(&r, s, len); tds_dataout_stream_init(&w, tds); - res = tds_convert_stream(tds, tds->conn->char_convs[iconv_entry], to_server, &r.stream, &w.stream); + tds_convert_stream(tds, tds->conn->char_convs[iconv_entry], to_server, + &r.stream, &w.stream); return (int) w.written; }