diff --git a/include/ctlib.h b/include/ctlib.h
index edba6f492c..5b6dc9fed9 100644
--- a/include/ctlib.h
+++ b/include/ctlib.h
@@ -326,9 +326,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 311daeafdd..347bfdbcac 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 99ba0f6e0f..bc3ae9a586 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);
+ptrdiff_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 424c4d75ae..4a48441131 100644
--- a/include/freetds/odbc.h
+++ b/include/freetds/odbc.h
@@ -585,7 +585,7 @@ typedef struct {
 
 TDS_DESC *desc_alloc(SQLHANDLE parent, int desc_type, SQLSMALLINT alloc_type);
 SQLRETURN desc_free(TDS_DESC * desc);
-SQLRETURN desc_alloc_records(TDS_DESC * desc, unsigned count);
+SQLRETURN desc_alloc_records(TDS_DESC * desc, SQLSMALLINT count);
 SQLRETURN desc_copy(TDS_DESC * dest, TDS_DESC * src);
 SQLRETURN desc_free_records(TDS_DESC * desc);
 TDS_DBC *desc_get_dbc(TDS_DESC *desc);
@@ -641,7 +641,8 @@ typedef union {
 # define _WIDE
 # define ODBC_CHAR SQLCHAR
 #endif
-SQLRETURN odbc_set_stmt_query(struct _hstmt *stmt, const ODBC_CHAR *sql, int sql_len _WIDE);
+SQLRETURN odbc_set_stmt_query(struct _hstmt *stmt, const ODBC_CHAR *sql,
+			      ptrdiff_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);
 
@@ -651,25 +652,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(ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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, \
@@ -709,8 +714,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 3913f1c6bf..05c3d237a4 100644
--- a/include/freetds/tds.h
+++ b/include/freetds/tds.h
@@ -1351,7 +1351,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(bool use_environment);
@@ -1361,7 +1361,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);
@@ -1418,13 +1419,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,
+		    ptrdiff_t idlen);
+size_t tds_quote_id_rpc(TDSSOCKET * tds, char *buffer, const char *id,
+			ptrdiff_t idlen);
+size_t tds_quote_string(TDSSOCKET * tds, char *buffer, const char *str,
+			ptrdiff_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, ptrdiff_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) \
@@ -1553,14 +1558,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);
+ptrdiff_t tds_connection_read(TDSSOCKET * tds, unsigned char *buf,
+			      size_t buflen);
+ptrdiff_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);
+ptrdiff_t tds_goodread(TDSSOCKET * tds, unsigned char *buf, size_t buflen);
+ptrdiff_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);
@@ -1596,7 +1604,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_string(TDSFREEZE *freeze);
diff --git a/include/freetds/utils/des.h b/include/freetds/utils/des.h
index 0919e68bdb..093f8945e6 100644
--- a/include/freetds/utils/des.h
+++ b/include/freetds/utils/des.h
@@ -25,7 +25,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 <freetds/popvis.h>
 
diff --git a/src/ctlib/blk.c b/src/ctlib/blk.c
index 6c8e70aba7..42c45d0cb3 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 3e6bda9d05..3ef419f0f2 100644
--- a/src/ctlib/cs.c
+++ b/src/ctlib/cs.c
@@ -1126,7 +1126,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)
@@ -1141,7 +1142,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)
@@ -1159,8 +1161,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))
 			{
@@ -1174,7 +1178,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;
@@ -1182,7 +1186,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 2a736fe303..f2add7300c 100644
--- a/src/ctlib/ct.c
+++ b/src/ctlib/ct.c
@@ -626,7 +626,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_PRODUCT_NAME:
@@ -874,7 +874,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;
+	ptrdiff_t query_len, current_query_len;
 
 	tdsdump_log(TDS_DBG_FUNC, "ct_command(%p, %d, %p, %d, %d)\n", cmd, type, buffer, buflen, option);
 
@@ -2559,7 +2559,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) {
@@ -2713,7 +2713,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;
@@ -2733,7 +2734,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;
@@ -2851,7 +2853,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;
@@ -3403,7 +3405,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;
+	ptrdiff_t query_len;
 	CS_CONNECTION *con;
 	CS_DYNAMIC *dyn;
 
diff --git a/src/ctlib/ctutil.c b/src/ctlib/ctutil.c
index 505c0cf8d1..ed6ec21393 100644
--- a/src/ctlib/ctutil.c
+++ b/src/ctlib/ctutil.c
@@ -128,7 +128,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->oserr) {
 #ifdef _WIN32
@@ -214,18 +214,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)
@@ -239,7 +239,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 */
@@ -303,7 +303,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;
 }
@@ -347,7 +347,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 e769f4c4ff..3d429493b6 100644
--- a/src/ctlib/unittests/common.h
+++ b/src/ctlib/unittests/common.h
@@ -37,7 +37,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 a653b0b4af..645c28f188 100644
--- a/src/ctlib/unittests/cs_convert.c
+++ b/src/ctlib/unittests/cs_convert.c
@@ -16,7 +16,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 */
@@ -43,7 +43,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 e77f61e97d..a08086c583 100644
--- a/src/ctlib/unittests/lang_ct_param.c
+++ b/src/ctlib/unittests/lang_ct_param.c
@@ -96,7 +96,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;
@@ -130,7 +130,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");
@@ -155,7 +155,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;
@@ -170,7 +171,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 42149edca7..40fec6013b 100644
--- a/src/ctlib/unittests/rpc_ct_param.c
+++ b/src/ctlib/unittests/rpc_ct_param.c
@@ -99,7 +99,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;
@@ -539,7 +539,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 1baf582345..81edd3d291 100644
--- a/src/ctlib/unittests/rpc_ct_setparam.c
+++ b/src/ctlib/unittests/rpc_ct_setparam.c
@@ -90,7 +90,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;
@@ -574,7 +574,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 3970323276..5515469a36 100644
--- a/src/ctlib/unittests/variant.c
+++ b/src/ctlib/unittests/variant.c
@@ -22,7 +22,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 c0c758cac9..cfef9c70d4 100644
--- a/src/dblib/bcp.c
+++ b/src/dblib/bcp.c
@@ -1527,7 +1527,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 cb7fa1f6f3..af2dc60f15 100644
--- a/src/dblib/dblib.c
+++ b/src/dblib/dblib.c
@@ -842,7 +842,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);
@@ -1062,7 +1062,7 @@ dbstring_length(DBSTRING * dbstr)
 }
 
 static int
-dbstring_getchar(DBSTRING * dbstr, int i)
+dbstring_getchar(DBSTRING * dbstr, ptrdiff_t i)
 {
 
 	/* tdsdump_log(TDS_DBG_FUNC, "dbstring_getchar(%p, %d)\n", dbstr, i); */
@@ -3448,7 +3448,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;
 		
@@ -3489,7 +3489,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;
@@ -3560,17 +3560,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;
+	ptrdiff_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;
@@ -3616,7 +3617,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;
@@ -3646,7 +3649,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;
 				}
@@ -3683,7 +3686,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); 
 				}
@@ -3761,7 +3767,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;
@@ -3880,7 +3888,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);
@@ -3938,7 +3946,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;
 
@@ -3952,7 +3961,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;
@@ -4002,8 +4011,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);
@@ -4983,7 +4992,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);
@@ -5041,7 +5050,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);
@@ -8178,7 +8187,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 */
@@ -8253,7 +8263,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 f9a50c18bc..67580b4665 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);
 	
@@ -721,7 +721,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;
@@ -784,7 +784,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;
@@ -846,7 +847,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
@@ -919,8 +921,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;
@@ -935,11 +939,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,
@@ -977,7 +981,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) {
@@ -1002,8 +1007,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++;
@@ -1023,7 +1030,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;
@@ -1039,7 +1048,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;
@@ -1052,7 +1063,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;
@@ -1060,7 +1073,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 3644fa5fb2..7e4d34815a 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 dd25e75149..395e846901 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 c3049d096b..c7d62573d0 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 9e200277c2..6518927d43 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 69d9ed88e6..c118b922c2 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;
+	ptrdiff_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 0c494155df..4d5406d4ae 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;
+	ptrdiff_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 10a0d4fd18..42ec23b3ed 100644
--- a/src/dblib/unittests/timeout.c
+++ b/src/dblib/unittests/timeout.c
@@ -205,7 +205,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 da472ad922..17cfb08d28 100644
--- a/src/odbc/bcp.c
+++ b/src/odbc/bcp.c
@@ -435,14 +435,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;
@@ -486,9 +486,11 @@ _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;
@@ -541,7 +543,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 ff7d5479c9..847e71d000 100644
--- a/src/odbc/connectparams.c
+++ b/src/odbc/connectparams.c
@@ -609,7 +609,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;
@@ -665,7 +665,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 4e65c93117..0f18a04590 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);
@@ -114,12 +114,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);
 	}
@@ -175,7 +177,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
@@ -206,7 +208,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;
 
@@ -240,7 +242,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;
@@ -288,7 +290,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];
 
@@ -322,7 +325,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;
@@ -414,8 +418,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);
@@ -433,7 +437,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 
@@ -457,7 +461,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 4d6777ef7f..19f3783f38 100644
--- a/src/odbc/descriptor.c
+++ b/src/odbc/descriptor.c
@@ -84,7 +84,7 @@ desc_alloc(SQLHANDLE parent, int desc_type, SQLSMALLINT alloc_type)
 	STR_OP(sql_desc_table_name)
 
 SQLRETURN
-desc_alloc_records(TDS_DESC * desc, unsigned count)
+desc_alloc_records(TDS_DESC * desc, SQLSMALLINT count)
 {
 	struct _drecord *drec;
 	int i;
@@ -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;  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 611397b95c..f0a851c283 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);
@@ -1190,9 +1190,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;
 
@@ -1369,7 +1369,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;
@@ -1462,7 +1462,7 @@ odbc_SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType,
 			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);
 		}
@@ -1573,7 +1573,7 @@ odbc_SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType,
 		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;
@@ -1831,7 +1831,8 @@ odbc_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);
@@ -2418,7 +2419,8 @@ SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
 	)
 {
 
-	return odbc_SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc _wide0);
+	return odbc_SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax,
+				    pcbDesc, (SQLLEN*) pfDesc _wide0);
 }
 
 #ifdef ENABLE_ODBC_WIDE
@@ -3441,7 +3443,7 @@ odbc_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;
@@ -4079,7 +4081,7 @@ odbc_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;
 	}
@@ -4501,7 +4503,7 @@ odbc_SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value,
 		    SQLINTEGER BufferLength, SQLINTEGER * StringLength WIDE)
 {
 	void *src;
-	size_t size;
+	SQLINTEGER size;
 
 	ODBC_ENTER_HSTMT;
 
@@ -6175,7 +6177,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 */
@@ -6358,7 +6360,8 @@ odbc_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) {
@@ -6439,13 +6442,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)) {
@@ -6465,24 +6468,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)) {
@@ -6495,12 +6498,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:
@@ -6517,7 +6521,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)
@@ -6673,7 +6677,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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) {
@@ -6699,7 +6703,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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) {
@@ -6718,7 +6722,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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 */
@@ -6737,7 +6741,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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) {
@@ -6771,14 +6775,14 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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;
@@ -6808,17 +6812,17 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 		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;
@@ -6839,7 +6843,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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:
@@ -6848,7 +6852,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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;
@@ -6861,7 +6865,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 	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);
@@ -6885,14 +6889,14 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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) {
@@ -6906,7 +6910,7 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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)) {
@@ -6934,9 +6938,9 @@ odbc_SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, S
 			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);
@@ -7347,13 +7351,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);
+	ptrdiff_t len = tds_dstr_len(dstr);
 
 	/* limit string/id lengths */
 	if (len > 384)
@@ -7434,7 +7438,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;
 
@@ -7484,7 +7489,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;
@@ -7553,7 +7559,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 aadfe1a425..ad4423f090 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 a9a37ff66a..fb50e8459b 100644
--- a/src/odbc/odbc_util.c
+++ b/src/odbc/odbc_util.c
@@ -24,6 +24,8 @@
 #include <stdlib.h>
 #endif /* HAVE_STDLIB_H */
 
+#include <stddef.h>
+
 #if HAVE_STRING_H
 #include <string.h>
 #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
 
 SQLRETURN
-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, ptrdiff_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(ptrdiff_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, ptrdiff_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, ptrdiff_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, ptrdiff_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;
@@ -862,10 +867,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 6504ae394b..f55fe5b60e 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 ptrdiff_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;
+			ptrdiff_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 a1b7b709ae..8b192514db 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 6ff2471fad..de1490ed6e 100644
--- a/src/odbc/unittests/bcp.c
+++ b/src/odbc/unittests/bcp.c
@@ -138,8 +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, \
diff --git a/src/odbc/unittests/blob1.c b/src/odbc/unittests/blob1.c
index e9196f421b..fd5d693f6a 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 1cb986dff8..18f019f493 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:
diff --git a/src/odbc/unittests/cancel.c b/src/odbc/unittests/cancel.c
index 7bc89f08e7..f6eb546f2b 100644
--- a/src/odbc/unittests/cancel.c
+++ b/src/odbc/unittests/cancel.c
@@ -73,7 +73,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 bdaf364c97..920a60b8c0 100644
--- a/src/odbc/unittests/common.c
+++ b/src/odbc/unittests/common.c
@@ -85,7 +85,7 @@ odbc_read_login_info(void)
 	char *s1, *s2;
 	const char *const *search_p;
 	char path[1024];
-	int len;
+	size_t len;
 	bool ini_override = true;
 #if defined(_WIN32) && !defined(TDS_NO_DM)
 	UWORD old_config_mode;
@@ -671,19 +671,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 4db6d3e343..e76a7d7e98 100644
--- a/src/odbc/unittests/common.h
+++ b/src/odbc/unittests/common.h
@@ -203,8 +203,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 8befd72ca2..4b2af27a2a 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 117eafc5a6..d60588555b 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 e3e7f4fa9e..0d1d9c3686 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 e2994d2458..bdf42ca350 100644
--- a/src/odbc/unittests/describecol.c
+++ b/src/odbc/unittests/describecol.c
@@ -38,11 +38,11 @@ lookup(const char *name, const struct odbc_lookup_int *table, odbc_parser *parse
 }
 
 static const char*
-unlookup(long int value, const struct odbc_lookup_int *table)
+unlookup(SQLLEN value, const struct odbc_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 4d11be2d39..b249ed8bc1 100644
--- a/src/odbc/unittests/freeclose.c
+++ b/src/odbc/unittests/freeclose.c
@@ -57,7 +57,7 @@ static socklen_t remote_addr_len;
 #endif
 
 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 d556651791..ce042d1039 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 542295dab0..711f828564 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 8db70f2ea7..5fbec93af6 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 5bf128d1eb..6a8a52f890 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 6000ce79a2..a97754ed2f 100644
--- a/src/odbc/unittests/raiserror.c
+++ b/src/odbc/unittests/raiserror.c
@@ -138,7 +138,7 @@ Test(int level)
 
 	/* test with SQLPrepare/SQLExecute */
 	printf("Preparing: %s\n", SP_TEXT);
-	CHKPrepare(T(SP_TEXT), strlen(SP_TEXT), "SI");
+	CHKPrepare(T(SP_TEXT), (SQLINTEGER) strlen(SP_TEXT), "SI");
 
 	SQLBindParameter(odbc_stmt, 1, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &ReturnCode, 0, &cbReturnCode);
 	SQLBindParameter(odbc_stmt, 2, SQL_PARAM_INPUT, SQL_C_SSHORT, SQL_INTEGER, 0, 0, &InParam, 0, &cbInParam);
diff --git a/src/odbc/unittests/rebindpar.c b/src/odbc/unittests/rebindpar.c
index a471347eba..017c5c2859 100644
--- a/src/odbc/unittests/rebindpar.c
+++ b/src/odbc/unittests/rebindpar.c
@@ -8,7 +8,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 1f1a84b9fb..b3200700ff 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 2e7b584b90..1f1b4403ab 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 647e576abc..f847fbfbf4 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 ccf2b331ce..dbac55a681 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 71f75459bd..ee92214bc8 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 10223f1996..709155e5f6 100644
--- a/src/odbc/winsetup.c
+++ b/src/odbc/winsetup.c
@@ -334,7 +334,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 132302f0db..98ce157dea 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 80924b31d4..0e7ac93889 100644
--- a/src/tds/config.c
+++ b/src/tds/config.c
@@ -621,8 +621,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 60cffa0c4d..fdd39f8bf6 100644
--- a/src/tds/convert.c
+++ b/src/tds/convert.c
@@ -300,10 +300,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)
+ptrdiff_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 ... */
@@ -1161,7 +1162,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:
@@ -1558,7 +1559,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);
 }
 
@@ -1940,7 +1941,7 @@ tds_convert_to_binary(int srctype, const TDS_CHAR * src, TDS_UINT srclen, int de
 				TDS_ZERO_FREE(cr->ib);
 			return destlen;
 		}
-		return tds_char2hex(ib, cr->cb.len, src, srclen);
+		return (TDS_INT) tds_char2hex(ib, cr->cb.len, src, srclen);
 
 	default:
 		return TDS_CONVERT_NOAVAIL;
@@ -3325,7 +3326,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 ba2926943c..2790737b8d 100644
--- a/src/tds/data.c
+++ b/src/tds/data.c
@@ -509,7 +509,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;
@@ -781,7 +781,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 */
@@ -885,13 +885,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);
@@ -1026,15 +1026,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 */
@@ -1073,7 +1073,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... */
@@ -1081,11 +1081,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) {
@@ -1099,7 +1099,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 */
@@ -1372,7 +1372,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;
@@ -1506,7 +1506,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 e1de925dbd..2364c2eae3 100644
--- a/src/tds/gssapi.c
+++ b/src/tds/gssapi.c
@@ -461,7 +461,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 57786ce356..b0ec7d2f3e 100644
--- a/src/tds/login.c
+++ b/src/tds/login.c
@@ -441,7 +441,7 @@ tds_setup_connection(TDSSOCKET *tds, TDSLOGIN *login, bool set_db, bool single_q
 {
 	TDSRET erc;
 	char *str;
-	int len;
+	size_t len;
 	const char *const product_name = (tds->conn->product_name != NULL ? tds->conn->product_name : "");
 	const bool is_sql_anywhere = (strcasecmp(product_name, "SQL Anywhere") == 0);
 	const bool is_openserver = (strcasecmp(product_name, "OpenServer") == 0);
@@ -999,7 +999,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;
@@ -1016,9 +1016,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 */
@@ -1042,7 +1042,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;
@@ -1329,7 +1329,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 a79d6ffa87..60d14dd1fd 100644
--- a/src/tds/mem.c
+++ b/src/tds/mem.c
@@ -884,7 +884,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;
@@ -1347,7 +1348,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 b2fe03327d..4f643ce8eb 100644
--- a/src/tds/net.c
+++ b/src/tds/net.c
@@ -705,10 +705,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 ptrdiff_t
+tds_socket_read(TDSCONNECTION * conn, TDSSOCKET *tds, unsigned char *buf,
+		size_t buflen)
 {
-	int len, err;
+	ptrdiff_t len;
+	int err;
 
 #if ENABLE_EXTRA_CHECKS
 	/* this simulate the fact that recv can return less bytes */
@@ -740,10 +742,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 ptrdiff_t
+tds_socket_write(TDSCONNECTION *conn, TDSSOCKET *tds, const unsigned char *buf,
+		 size_t buflen)
 {
-	int err, len;
+	int err;
+	ptrdiff_t len;
 	char *errstr;
 
 #if ENABLE_EXTRA_CHECKS
@@ -837,7 +841,7 @@ tds_wakeup_send(TDSPOLLWAKEUP *wakeup, char cancel)
 static int
 tds_connection_signaled(TDSCONNECTION *conn)
 {
-	int len;
+	ptrdiff_t len;
 	char to_cancel[16];
 
 #if defined(__linux__) && HAVE_EVENTFD
@@ -894,14 +898,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)
+ptrdiff_t
+tds_goodread(TDSSOCKET * tds, unsigned char *buf, size_t buflen)
 {
 	if (tds == NULL || buf == NULL || buflen < 1)
 		return -1;
 
 	for (;;) {
-		int len, err;
+		ptrdiff_t len;
+		int err;
 
 		/* FIXME this block writing from other sessions */
 		len = tds_select(tds, TDSSELREAD, tds->query_timeout);
@@ -943,8 +948,8 @@ tds_goodread(TDSSOCKET * tds, unsigned char *buf, int buflen)
 	}
 }
 
-int
-tds_connection_read(TDSSOCKET * tds, unsigned char *buf, int buflen)
+ptrdiff_t
+tds_connection_read(TDSSOCKET * tds, unsigned char *buf, size_t buflen)
 {
 	TDSCONNECTION *conn = tds->conn;
 
@@ -965,10 +970,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
+ptrdiff_t
 tds_goodwrite(TDSSOCKET * tds, const unsigned char *buffer, size_t buflen)
 {
-	int len;
+	ptrdiff_t len;
 	size_t sent = 0;
 
 	assert(tds && buffer);
@@ -1030,10 +1035,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)
+ptrdiff_t
+tds_connection_write(TDSSOCKET *tds, const unsigned char *buf, size_t buflen,
+		     int final)
 {
-	int sent;
+	ptrdiff_t sent;
 	TDSCONNECTION *conn = tds->conn;
 
 #if !defined(_WIN32) && !defined(MSG_NOSIGNAL) && !defined(DOS32X) && !defined(SO_NOSIGPIPE)
@@ -1079,7 +1085,7 @@ tds7_get_instance_ports(FILE *output, struct addrinfo *addr)
 	int retval;
 	TDS_SYS_SOCKET s;
 	char msg[16*1024];
-	int msg_len = 0;
+	ptrdiff_t msg_len = 0;
 	int port = 0;
 	char ipaddr[128];
 
@@ -1215,7 +1221,7 @@ tds7_get_instance_port(struct addrinfo *addr, const char *instance)
 	int retval;
 	TDS_SYS_SOCKET s;
 	char msg[1024];
-	int msg_len;
+	ptrdiff_t msg_len;
 	int port = 0;
 	char ipaddr[128];
 
@@ -1332,7 +1338,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 57386c6099..c3c8d45bc1 100644
--- a/src/tds/packet.c
+++ b/src/tds/packet.c
@@ -595,7 +595,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);
+		ptrdiff_t len = tds_connection_read(tds, p, end - p);
 		if (len <= 0) {
 			tds_close_socket(tds);
 			return -1;
@@ -628,7 +628,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);
 
@@ -811,7 +811,7 @@ int
 tds_put_cancel(TDSSOCKET * tds)
 {
 	unsigned char out_buf[8];
-	int sent;
+	ptrdiff_t sent;
 
 	out_buf[0] = TDS_CANCEL;	/* out_flag */
 	out_buf[1] = 1;	/* final */
@@ -927,12 +927,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 da1fa2c978..d8c6920f91 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,
+		   ptrdiff_t len, size_t *out_len)
 {
 	char *buf;
 
@@ -401,7 +402,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;
@@ -747,7 +750,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:
@@ -956,7 +959,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));
@@ -1022,7 +1025,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));
 
@@ -1079,8 +1082,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(&params->columns[i]->column_name),
-				       tds_dstr_len(&params->columns[i]->column_name));
+			const DSTR *name = &params->columns[i]->column_name;
+			tds_put_string(tds, tds_dstr_cstr(name),
+				       (int) tds_dstr_len(name));
 		}
 		tds_put_smallint(tds, ' ');
 
@@ -1310,7 +1314,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);
@@ -1417,7 +1421,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);
@@ -1590,7 +1594,7 @@ 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)) {
@@ -1620,7 +1624,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;
@@ -1951,7 +1955,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(&param->column_name)) {
-			tds_put_string(tds, tds_dstr_cstr(&param->column_name), tds_dstr_len(&param->column_name));
+			tds_put_string(tds, tds_dstr_cstr(&param->column_name),
+				       (int)tds_dstr_len(&param->column_name));
 			tds_put_string(tds, "=", 1);
 		}
 		if (param->column_output) {
@@ -2208,7 +2213,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, ptrdiff_t idlen)
 {
 	size_t i, len;
 
@@ -2253,7 +2258,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, ptrdiff_t idlen)
 {
 	size_t len;
 	/* We are quoting for RPC calls, not base language queries. For RPC calls Sybase
@@ -2278,7 +2283,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,
+		 ptrdiff_t len)
 {
 	return tds_quote(buffer, '\'', str, len < 0 ? strlen(str) : (size_t) len);
 }
@@ -2386,8 +2392,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);
@@ -2848,7 +2855,7 @@ TDSRET
 tds_cursor_setname(TDSSOCKET * tds, TDSCURSOR * cursor)
 {
 	TDSFREEZE outer;
-	size_t written;
+	unsigned int written;
 
 	CHECK_TDS_EXTRA(tds);
 
@@ -2981,7 +2988,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 72998f4baa..664776b176 100644
--- a/src/tds/read.c
+++ b/src/tds/read.c
@@ -208,7 +208,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",
@@ -249,7 +251,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/tds_checks.c b/src/tds/tds_checks.c
index 74f063008e..7f36078c82 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 c915208c72..c78353f06b 100644
--- a/src/tds/token.c
+++ b/src/tds/token.c
@@ -2632,7 +2632,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 abf9c00178..7f0dc84807 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 8eb5c65591..5c33bf26dd 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 6bbf0e3a39..a3311fbd0b 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 SYBSINT1:
diff --git a/src/tds/unittests/convert_bounds.c b/src/tds/unittests/convert_bounds.c
index 5731ee6e16..51e5b23d7b 100644
--- a/src/tds/unittests/convert_bounds.c
+++ b/src/tds/unittests/convert_bounds.c
@@ -216,7 +216,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 317a5ce23d..677661ccee 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 d25b111df8..cafe309aec 100644
--- a/src/tds/unittests/freeze.c
+++ b/src/tds/unittests/freeze.c
@@ -193,8 +193,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 4911dc63d6..8f6c925e2b 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 3f25f24753..37b4f4da72 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 fe15d787c1..d759d701cb 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 9f57759370..69c7ff0675 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 len;
+		size_t len;
 
 		strcpy(buf, "aaa");
 		len = 0;
diff --git a/src/tds/vstrbuild.c b/src/tds/vstrbuild.c
index 32274e941d..8f68e9167b 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, ptrdiff_t fmtlen)
 {
 	char *newfmt;
 	char *cp;
diff --git a/src/tds/write.c b/src/tds/write.c
index a2df9aad09..75fc6c0f71 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 f1520bf142..f53339269a 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++) {