*** sqliteodbc-0.83-orig/sqlite3odbc.c	Sun May 17 18:48:03 2009
--- sqliteodbc-0.83/sqlite3odbc.c	Sun Aug 23 22:52:38 2009
***************
*** 3806,3837 ****
  		      )) {
  		char *dp = data;
  
  #ifdef WINTERFACE
! 		if (type == SQL_C_WCHAR) {
  		    dp = uc_to_utf(data, len);
  		    if (!dp) {
  			return nomem(s);
  		    }
- 		}
  #endif
  		dlen = strlen(dp);
  		freep(&p->parbuf);
  		p->parbuf = xmalloc(dlen + 1);
  		if (!p->parbuf) {
- #ifdef WINTERFACE
  		    if (dp != data) {
  			uc_free(dp);
  		    }
- #endif
  		    return nomem(s);
  		}
  		p->param = p->parbuf;
  		strcpy(p->param, dp);
- #ifdef WINTERFACE
  		if (dp != data) {
  		    uc_free(dp);
  		}
- #endif
  		p->len = dlen;
  		p->need = -1;
  	    } else if (len < 0) {
--- 3806,3838 ----
  		      )) {
  		char *dp = data;
  
+ 		if (type == SQL_C_CHAR) {
+ 		    dp = wmb_to_utf(data, len);
+ 		    if (!dp) {
+ 			return nomem(s);
+ 		    }
  #ifdef WINTERFACE
! 		} else if (type == SQL_C_WCHAR) {
  		    dp = uc_to_utf(data, len);
  		    if (!dp) {
  			return nomem(s);
  		    }
  #endif
+ 		}
  		dlen = strlen(dp);
  		freep(&p->parbuf);
  		p->parbuf = xmalloc(dlen + 1);
  		if (!p->parbuf) {
  		    if (dp != data) {
  			uc_free(dp);
  		    }
  		    return nomem(s);
  		}
  		p->param = p->parbuf;
  		strcpy(p->param, dp);
  		if (dp != data) {
  		    uc_free(dp);
  		}
  		p->len = dlen;
  		p->need = -1;
  	    } else if (len < 0) {
***************
*** 3846,3853 ****
  		memcpy((char *) p->param + p->offs, data, dlen);
  		p->offs += dlen;
  		if (p->offs >= p->len) {
  #ifdef WINTERFACE
! 		    if (type == SQL_C_WCHAR) {
  			char *dp = uc_to_utf(p->param, p->len);
  			char *np;
  			int nlen;
--- 3847,3875 ----
  		memcpy((char *) p->param + p->offs, data, dlen);
  		p->offs += dlen;
  		if (p->offs >= p->len) {
+ 		    if (type == SQL_C_CHAR) {
+ 			char *dp = wmb_to_utf(p->param, p->len);
+ 			char *np;
+ 			int nlen;
+ 
+ 			if (!dp) {
+ 			    return nomem(s);
+ 			}
+ 			nlen = strlen(dp);
+ 			np = xmalloc(nlen + 1);
+ 			if (!np) {
+ 			    uc_free(dp);
+ 			    return nomem(s);
+ 			}
+ 			strcpy(np, dp);
+ 			uc_free(dp);
+ 			if (p->param == p->parbuf) {
+ 			    freep(&p->parbuf);
+ 			}
+ 			p->parbuf = p->param = np;
+ 			p->len = nlen;
  #ifdef WINTERFACE
! 		    } else if (type == SQL_C_WCHAR) {
  			char *dp = uc_to_utf(p->param, p->len);
  			char *np;
  			int nlen;
***************
*** 3874,3879 ****
--- 3896,3904 ----
  		    p->need = (type == SQL_C_CHAR || type == SQL_C_WCHAR)
  			    ? -1 : 0;
  #else
+ 		    } else {
+ 			*((char *) p->param + p->len) = '\0';
+ 		    }
  		    *((char *) p->param + p->len) = '\0';
  		    p->need = (type == SQL_C_CHAR) ? -1 : 0;
  #endif
***************
*** 3950,3956 ****
  static SQLRETURN
  setupparam(STMT *s, char *sql, int pnum)
  {
!     int type, len = 0, needalloc = 0;
      BINDPARM *p;
  
      if (!s->bindparms || pnum < 0 || pnum >= s->nbindparms) {
--- 3975,3981 ----
  static SQLRETURN
  setupparam(STMT *s, char *sql, int pnum)
  {
!     int type, len = 0;
      BINDPARM *p;
  
      if (!s->bindparms || pnum < 0 || pnum >= s->nbindparms) {
***************
*** 4014,4020 ****
  		    p->len = p->max = strlen(p->param);
  		} else if (*p->lenp >= 0) {
  		    p->len = p->max = *p->lenp;
- 		    needalloc = 1;
  		}
  	    }
  	}
--- 4039,4044 ----
***************
*** 4038,4058 ****
  	} else
  #endif
  	if (type == SQL_C_CHAR) {
! 	    p->s3val = p->param;
! 	    if (needalloc) {
! 		char *dp;
  
  		freep(&p->parbuf);
- 		dp = xmalloc(p->len + 1);
- 		if (!dp) {
- 		    return nomem(s);
- 		}
- 		memcpy(dp, p->param, p->len);
- 		dp[p->len] = '\0';
- 		p->parbuf = p->param = dp;
- 		p->s3val = p->param;
- 		p->s3size = p->len;
  	    }
  	}
  	break;
      case SQL_C_UTINYINT:
--- 4062,4080 ----
  	} else
  #endif
  	if (type == SQL_C_CHAR) {
! 	    char *dp = wmb_to_utf(p->param, p->max);
  
+ 	    if (!dp) {
+ 		return nomem(s);
+ 	    }
+ 	    if (p->param == p->parbuf) {
  		freep(&p->parbuf);
  	    }
+ 	    p->parbuf = p->param = dp;
+ 	    p->len = strlen(p->param);
+ 	    p->s3val = p->param;
+ 	    p->s3size = p->len;
+ 	    p->s3val = p->param;
  	}
  	break;
      case SQL_C_UTINYINT:
***************
*** 5144,5155 ****
  	       SQLCHAR *schema, SQLSMALLINT schemaLen,
  	       SQLCHAR *table, SQLSMALLINT tableLen)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvprimarykeys(stmt, cat, catLen, schema, schemaLen,
! 			 table, tableLen);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 5166,5203 ----
  	       SQLCHAR *schema, SQLSMALLINT schemaLen,
  	       SQLCHAR *table, SQLSMALLINT tableLen)
  {
+     char *c = NULL, *s = NULL, *t = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (cat) {
! 	c = wmb_to_utf(cat, catLen);
! 	if (!c) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (schema) {
! 	s = wmb_to_utf(schema, schemaLen);
! 	if (!s) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (table) {
! 	t = wmb_to_utf(table, tableLen);
! 	if (!t) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvprimarykeys(stmt, (SQLCHAR *) c, SQL_NTS,
! 			 (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(t);
+     uc_free(s);
+     uc_free(c);
      return ret;
  }
  #endif
***************
*** 5535,5546 ****
  		  SQLCHAR *table, SQLSMALLINT tableLen,
  		  SQLUSMALLINT scope, SQLUSMALLINT nullable)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvspecialcolumns(stmt, id, cat, catLen, schema, schemaLen,
! 			    table, tableLen, scope, nullable);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 5583,5621 ----
  		  SQLCHAR *table, SQLSMALLINT tableLen,
  		  SQLUSMALLINT scope, SQLUSMALLINT nullable)
  {
+     char *c = NULL, *s = NULL, *t = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (cat) {
! 	c = wmb_to_utf(cat, catLen);
! 	if (!c) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (schema) {
! 	s = wmb_to_utf(schema, schemaLen);
! 	if (!s) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (table) {
! 	t = wmb_to_utf(table, tableLen);
! 	if (!t) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvspecialcolumns(stmt, id, (SQLCHAR *) c, SQL_NTS,
! 			    (SQLCHAR *) s, SQL_NTS, (SQLCHAR *) t, SQL_NTS,
! 			    scope, nullable);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(t);
+     uc_free(s);
+     uc_free(c);
      return ret;
  }
  #endif
***************
*** 5996,6011 ****
  	       SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
  	       SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvforeignkeys(stmt,
! 			 PKcatalog, PKcatalogLen,
! 			 PKschema, PKschemaLen, PKtable, PKtableLen,
! 			 FKcatalog, FKcatalogLen,
! 			 FKschema, FKschemaLen,
! 			 FKtable, FKtableLen);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 6071,6135 ----
  	       SQLCHAR *FKschema, SQLSMALLINT FKschemaLen,
  	       SQLCHAR *FKtable, SQLSMALLINT FKtableLen)
  {
+     char *pc = NULL, *ps = NULL, *pt = NULL;
+     char *fc = NULL, *fs = NULL, *ft = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (PKcatalog) {
! 	pc = wmb_to_utf(PKcatalog, PKcatalogLen);
! 	if (!pc) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (PKschema) {
! 	ps = wmb_to_utf(PKschema, PKschemaLen);
! 	if (!ps) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (PKtable) {
! 	pt = wmb_to_utf(PKtable, PKtableLen);
! 	if (!pt) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (FKcatalog) {
! 	fc = wmb_to_utf(FKcatalog, FKcatalogLen);
! 	if (!fc) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (FKschema) {
! 	fs = wmb_to_utf(FKschema, FKschemaLen);
! 	if (!fs) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (FKtable) {
! 	ft = wmb_to_utf(FKtable, FKtableLen);
! 	if (!ft) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvforeignkeys(stmt, (SQLCHAR *) pc, SQL_NTS,
! 			 (SQLCHAR *) ps, SQL_NTS, (SQLCHAR *) pt, SQL_NTS,
! 			 (SQLCHAR *) fc, SQL_NTS, (SQLCHAR *) fs, SQL_NTS,
! 			 (SQLCHAR *) ft, SQL_NTS);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(ft);
+     uc_free(fs);
+     uc_free(fc);
+     uc_free(pt);
+     uc_free(ps);
+     uc_free(pc);
      return ret;
  }
  #endif
***************
*** 6837,6844 ****
  	      SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
  	      SQLSMALLINT buflen, SQLSMALLINT *msglen)
  {
!     return drvgetdiagrec(htype, handle, recno, sqlstate,
! 			 nativeerr, msg, buflen, msglen);
  }
  #endif
  
--- 6961,7014 ----
  	      SQLCHAR *sqlstate, SQLINTEGER *nativeerr, SQLCHAR *msg,
  	      SQLSMALLINT buflen, SQLSMALLINT *msglen)
  {
!     SQLSMALLINT len;
!     SQLRETURN ret;
!     
!     ret = drvgetdiagrec(htype, handle, recno, (SQLCHAR *) sqlstate,
! 			nativeerr, (SQLCHAR *) msg, buflen, &len);
!     if (ret == SQL_SUCCESS) {
! 	if (msg) {
! 	    if (len > 0) {
! 		SQLCHAR *m = NULL;
! 
! 		m = utf_to_wmb((unsigned char *) msg, len);
! 		if (m) {
! 		    if (buflen) {
! 			strncpy(msg, m, buflen);
! 			m[len] = 0;
! 			len = min(buflen, strlen(m));
! 		    } else {
! 			len = strlen(m);
! 		    }
! 		    uc_free(m);
! 		} else {
! 		    len = 0;
! 		}
! 	    }
! 	    if (len <= 0) {
! 		len = 0;
! 		if (buflen > 0) {
! 		    msg[0] = 0;
! 		}
! 	    }
! 	}
! 	if (msglen) {
! 	    *msglen = len;
! 	}
!     } else if (ret == SQL_NO_DATA) {
! 	if (sqlstate) {
! 	    sqlstate[0] = 0;
! 	}
! 	if (msg) {
! 	    if (buflen > 0) {
! 		msg[0] = 0;
! 	    }
! 	}
! 	if (msglen) {
! 	    *msglen = 0;
! 	}
!     }
!     return ret;
  }
  #endif
  
***************
*** 7082,7088 ****
  		SQLSMALLINT id, SQLPOINTER info, 
  		SQLSMALLINT buflen, SQLSMALLINT *stringlen)
  {
!     return drvgetdiagfield(htype, handle, recno, id, info, buflen, stringlen);
  }
  #endif
  
--- 7252,7300 ----
  		SQLSMALLINT id, SQLPOINTER info, 
  		SQLSMALLINT buflen, SQLSMALLINT *stringlen)
  {
!     SQLSMALLINT len;
!     SQLRETURN ret;
!     
!     ret = drvgetdiagfield(htype, handle, recno, id, info, buflen, &len);
!     if (ret == SQL_SUCCESS) {
! 	if (info) {
! 	    switch (id) {
! 	    case SQL_DIAG_CLASS_ORIGIN:
! 	    case SQL_DIAG_SUBCLASS_ORIGIN:
! 	    case SQL_DIAG_CONNECTION_NAME:
! 	    case SQL_DIAG_SERVER_NAME:
! 	    case SQL_DIAG_SQLSTATE:
! 	    case SQL_DIAG_MESSAGE_TEXT:
! 		if (len > 0) {
! 		    SQLCHAR *m = NULL;
! 
! 		    m = utf_to_wmb((unsigned char *) info, len);
! 		    if (m) {
! 			if (buflen) {
! 			    strncpy(info, m, buflen);
! 			    m[len] = 0;
! 			    len = min(buflen, strlen(m));
! 			} else {
! 			    len = strlen(m);
! 			}
! 			uc_free(m);
! 		    } else {
! 			len = 0;
! 		    }
! 		}
! 		if (len <= 0) {
! 		    len = 0;
! 		    if (buflen > 0) {
! 			((SQLCHAR *) info)[0] = 0;
! 		    }
! 		}
! 	    }
! 	}
! 	if (stringlen) {
! 	    *stringlen = len;
! 	}
!     }
!     return ret;
  }
  #endif
  
***************
*** 8267,8303 ****
  	   SQLSMALLINT *valLen)
  {
      SQLRETURN ret;
- 
-     HDBC_LOCK(dbc);
-     ret = drvgetinfo(dbc, type, val, valMax, valLen);
-     HDBC_UNLOCK(dbc);
-     return ret;
- }
- #endif
- 
- #ifdef WINTERFACE
- /**
-  * Return information about what this ODBC driver supports.
-  * @param dbc database connection handle
-  * @param type type of information to be retrieved
-  * @param val output buffer
-  * @param valMax length of output buffer
-  * @param valLen output length
-  * @result ODBC error code
-  */
- 
- SQLRETURN SQL_API
- SQLGetInfoW(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
- 	    SQLSMALLINT *valLen)
- {
-     SQLRETURN ret;
      SQLSMALLINT len = 0;
  
      HDBC_LOCK(dbc);
      ret = drvgetinfo(dbc, type, val, valMax, &len);
      HDBC_UNLOCK(dbc);
      if (ret == SQL_SUCCESS) {
! 	SQLWCHAR *v = NULL;
  
  	switch (type) {
  	case SQL_USER_NAME:
--- 8479,8491 ----
  	   SQLSMALLINT *valLen)
  {
      SQLRETURN ret;
      SQLSMALLINT len = 0;
  
      HDBC_LOCK(dbc);
      ret = drvgetinfo(dbc, type, val, valMax, &len);
      HDBC_UNLOCK(dbc);
      if (ret == SQL_SUCCESS) {
! 	SQLCHAR *v = NULL;
  
  	switch (type) {
  	case SQL_USER_NAME:
***************
*** 8345,8367 ****
  #endif
  	    if (val) {
  		if (len > 0) {
! 		    v = uc_from_utf((SQLCHAR *) val, len);
  		    if (v) {
! 			int vmax = valMax / sizeof (SQLWCHAR);
  
! 			uc_strncpy(val, v, vmax);
  			v[len] = 0;
! 			len = min(vmax, uc_strlen(v));
  			uc_free(v);
- 			len *= sizeof (SQLWCHAR);
  		    } else {
  			len = 0;
  		    }
  		}
  		if (len <= 0) {
  		    len = 0;
! 		    if (valMax >= sizeof (SQLWCHAR)) {
! 			*((SQLWCHAR *)val) = 0;
  		    }
  		}
  	    } else {
--- 8533,8656 ----
  #endif
  	    if (val) {
  		if (len > 0) {
! 		    v = utf_to_wmb((SQLCHAR *) val, len);
  		    if (v) {
! 			int vmax = valMax;
  
! 			strncpy(val, v, vmax);
  			v[len] = 0;
! 			len = min(vmax, strlen(v));
  			uc_free(v);
  		    } else {
  			len = 0;
  		    }
  		}
  		if (len <= 0) {
  		    len = 0;
! 		    if (valMax >= sizeof (SQLCHAR)) {
! 			*((SQLCHAR *)val) = 0;
! 		    }
! 		}
! 	    } else {
! 		len = 0;
! 	    }
! 	    break;
! 	}
! 	if (valLen) {
! 	    *valLen = len;
! 	}
!     }
!     return ret;
! }
! #endif
! 
! #ifdef WINTERFACE
! /**
!  * Return information about what this ODBC driver supports.
!  * @param dbc database connection handle
!  * @param type type of information to be retrieved
!  * @param val output buffer
!  * @param valMax length of output buffer
!  * @param valLen output length
!  * @result ODBC error code
!  */
! 
! SQLRETURN SQL_API
! SQLGetInfoW(SQLHDBC dbc, SQLUSMALLINT type, SQLPOINTER val, SQLSMALLINT valMax,
! 	    SQLSMALLINT *valLen)
! {
!     SQLRETURN ret;
!     SQLSMALLINT len = 0;
! 
!     HDBC_LOCK(dbc);
!     ret = drvgetinfo(dbc, type, val, valMax, &len);
!     HDBC_UNLOCK(dbc);
!     if (ret == SQL_SUCCESS) {
! 	SQLWCHAR *v = NULL;
! 
! 	switch (type) {
! 	case SQL_USER_NAME:
! 	case SQL_DRIVER_ODBC_VER:
! 	case SQL_DATA_SOURCE_NAME:
! 	case SQL_DRIVER_NAME:
! 	case SQL_DRIVER_VER:
! 	case SQL_ODBC_VER:
! 	case SQL_SERVER_NAME:
! 	case SQL_DATABASE_NAME:
! 	case SQL_SEARCH_PATTERN_ESCAPE:
! 	case SQL_DBMS_NAME:
! 	case SQL_DBMS_VER:
! 	case SQL_NEED_LONG_DATA_LEN:
! 	case SQL_ROW_UPDATES:
! 	case SQL_ACCESSIBLE_PROCEDURES:
! 	case SQL_PROCEDURES:
! 	case SQL_EXPRESSIONS_IN_ORDERBY:
! 	case SQL_ODBC_SQL_OPT_IEF:
! 	case SQL_LIKE_ESCAPE_CLAUSE:
! 	case SQL_ORDER_BY_COLUMNS_IN_SELECT:
! 	case SQL_OUTER_JOINS:
! 	case SQL_COLUMN_ALIAS:
! 	case SQL_ACCESSIBLE_TABLES:
! 	case SQL_MULT_RESULT_SETS:
! 	case SQL_MULTIPLE_ACTIVE_TXN:
! 	case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
! 	case SQL_DATA_SOURCE_READ_ONLY:
! #ifdef SQL_DESCRIBE_PARAMETER
! 	case SQL_DESCRIBE_PARAMETER:
! #endif
! 	case SQL_IDENTIFIER_QUOTE_CHAR:
! 	case SQL_OWNER_TERM:
! 	case SQL_PROCEDURE_TERM:
! 	case SQL_QUALIFIER_NAME_SEPARATOR:
! 	case SQL_QUALIFIER_TERM:
! 	case SQL_TABLE_TERM:
! 	case SQL_KEYWORDS:
! 	case SQL_SPECIAL_CHARACTERS:
! #ifdef SQL_CATALOG_NAME
! 	case SQL_CATALOG_NAME:
! #endif
! #ifdef SQL_COLLATION_SEQ
! 	case SQL_COLLATION_SEQ:
! #endif
! 	    if (val) {
! 		if (len > 0) {
! 		    v = uc_from_utf((SQLCHAR *) val, len);
! 		    if (v) {
! 			int vmax = valMax / sizeof (SQLWCHAR);
! 
! 			uc_strncpy(val, v, vmax);
! 			v[len] = 0;
! 			len = min(vmax, uc_strlen(v));
! 			uc_free(v);
! 			len *= sizeof (SQLWCHAR);
! 		    } else {
! 			len = 0;
! 		    }
! 		}
! 		if (len <= 0) {
! 		    len = 0;
! 		    if (valMax >= sizeof (SQLWCHAR)) {
! 			*((SQLWCHAR *)val) = 0;
  		    }
  		}
  	    } else {
***************
*** 8933,8938 ****
--- 9222,9238 ----
  
      HDBC_LOCK(dbc);
      ret = drvgetconnectattr(dbc, attr, val, bufmax, buflen);
+     if (SQL_SUCCEEDED(ret)) {
+ 	switch (attr) {
+ 	case SQL_ATTR_TRACEFILE:
+ 	case SQL_ATTR_CURRENT_CATALOG:
+ 	case SQL_ATTR_TRANSLATE_LIB:
+ 	    if (val && bufmax >= sizeof (SQLCHAR)) {
+ 		*(SQLCHAR *) val = 0;
+ 	    }
+ 	    break;
+ 	}
+     }
      HDBC_UNLOCK(dbc);
      return ret;
  }
***************
*** 9175,9180 ****
--- 9475,9491 ----
  
      HDBC_LOCK(dbc);
      ret = drvgetconnectoption(dbc, opt, param);
+     if (SQL_SUCCEEDED(ret)) {
+ 	switch (opt) {
+ 	case SQL_OPT_TRACEFILE:
+ 	case SQL_CURRENT_QUALIFIER:
+ 	case SQL_TRANSLATE_DLL:
+ 	    if (param) {
+ 		*(SQLCHAR *) param = 0;
+ 	    }
+ 	    break;
+ 	}
+     }
      HDBC_UNLOCK(dbc);
      return ret;
  }
***************
*** 9483,9493 ****
  	   SQLCHAR *uid, SQLSMALLINT uidLen,
  	   SQLCHAR *pass, SQLSMALLINT passLen)
  {
      SQLRETURN ret;
  
      HDBC_LOCK(dbc);
!     ret = drvconnect(dbc, dsn, dsnLen, 0);
      HDBC_UNLOCK(dbc);
      return ret;
  }
  #endif
--- 9794,9817 ----
  	   SQLCHAR *uid, SQLSMALLINT uidLen,
  	   SQLCHAR *pass, SQLSMALLINT passLen)
  {
+     char *dsna = NULL;
      SQLRETURN ret;
  
      HDBC_LOCK(dbc);
!     if (dsn) {
! 	dsna = wmb_to_utf(dsn, dsnLen);
! 	if (!dsna) {
! 	    DBC *d = (DBC *) dbc;
! 
! 	    setstatd(d, -1, "out of memory", (*d->ov3) ? "HY000" : "S1000");
! 	    ret = SQL_ERROR;
! 	    goto done;
! 	}
!     }
!     ret = drvconnect(dbc, (SQLCHAR *) dsna, SQL_NTS, 1);
! done:
      HDBC_UNLOCK(dbc);
+     uc_free(dsna);
      return ret;
  }
  #endif
***************
*** 10059,10067 ****
  		 SQLSMALLINT *lenp)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvgetcursorname(stmt, cursor, buflen, lenp);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
--- 10383,10414 ----
  		 SQLSMALLINT *lenp)
  {
      SQLRETURN ret;
+     SQLSMALLINT len = 0;
  
      HSTMT_LOCK(stmt);
!     ret = drvgetcursorname(stmt, (SQLCHAR *) cursor, buflen, &len);
!     if (ret == SQL_SUCCESS) {
! 	SQLCHAR *c = NULL;
! 
! 	if (cursor) {
! 	    c = utf_to_wmb((SQLCHAR *) cursor, len);
! 	    if (!c) {
! 		ret = nomem((STMT *) stmt);
! 		goto done;
! 	    }
! 	    c[len] = 0;
! 	    len = strlen(c);
! 	    if (buflen > 0) {
! 		strncpy(cursor, c, buflen - 1);
! 		cursor[buflen - 1] = 0;
! 	    }
! 	    uc_free(c);
! 	}
! 	if (lenp) {
! 	    *lenp = min(len, buflen - 1);
! 	}
!     }
! done:
      HSTMT_UNLOCK(stmt);
      return ret;
  }
***************
*** 10158,10168 ****
  SQLRETURN SQL_API
  SQLSetCursorName(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvsetcursorname(stmt, cursor, len);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 10505,10525 ----
  SQLRETURN SQL_API
  SQLSetCursorName(SQLHSTMT stmt, SQLCHAR *cursor, SQLSMALLINT len)
  {
+     char *c = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (cursor) {
! 	c = wmb_to_utf(cursor, len);
! 	if (!c) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvsetcursorname(stmt, (SQLCHAR *) c, SQL_NTS);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(c);
      return ret;
  }
  #endif
***************
*** 10727,10732 ****
--- 11084,11090 ----
  #ifdef WINTERFACE
  	    SQLWCHAR *ucdata = NULL;
  #endif
+ 	    SQLCHAR *wmbdata = NULL;
  
  #if (defined(_WIN32) || defined(_WIN64)) && defined(WINTERFACE)
  	    /* MS Access hack part 2 (reserved error -7748) */
***************
*** 10764,10774 ****
--- 11122,11140 ----
  #else
  	    doz = (type == SQL_C_CHAR) ? 1 : 0;
  #endif
+ 	    if (type == SQL_C_CHAR) {
+ 		wmbdata = utf_to_wmb((SQLCHAR *) *data, dlen);
+ 		if (!wmbdata) {
+ 		    return nomem(s);
+ 		}
+ 		dlen = strlen(wmbdata);
+ 	    }
  	    if (partial && len && s->bindcols) {
  		if (s->bindcols[col].offs >= dlen) {
  #ifdef WINTERFACE
  		    uc_free(ucdata);
  #endif
+ 		    if (wmbdata) uc_free(wmbdata);
  		    *lenp = 0;
  		    if (doz && val) {
  #ifdef WINTERFACE
***************
*** 10792,10807 ****
  		dlen -= offs;
  	    }
  	    if (val && !valnull && len) {
  #ifdef WINTERFACE
! 		if (type == SQL_C_WCHAR) {
  		    uc_strncpy(val, ucdata + offs / sizeof (SQLWCHAR),
  			       (len - doz) / sizeof (SQLWCHAR));
  		} else {
  		    strncpy(val, *data + offs, len - doz);
  		}
- #else
- 		strncpy(val, *data + offs, len - doz);
- #endif
  	    }
  	    if (valnull || len < 1) {
  		*lenp = dlen;
--- 11158,11173 ----
  		dlen -= offs;
  	    }
  	    if (val && !valnull && len) {
+ 		if (type == SQL_C_CHAR) {
+ 		    strncpy(val, wmbdata + offs, len - doz);
  #ifdef WINTERFACE
! 		} else if (type == SQL_C_WCHAR) {
  		    uc_strncpy(val, ucdata + offs / sizeof (SQLWCHAR),
  			       (len - doz) / sizeof (SQLWCHAR));
+ #endif
  		} else {
  		    strncpy(val, *data + offs, len - doz);
  		}
  	    }
  	    if (valnull || len < 1) {
  		*lenp = dlen;
***************
*** 10827,10832 ****
--- 11193,11199 ----
  #ifdef WINTERFACE
  	    uc_free(ucdata);
  #endif
+ 	    if (wmbdata) uc_free(wmbdata);
  	    if (partial && len && s->bindcols) {
  		if (*lenp == SQL_NO_TOTAL) {
  		    s->bindcols[col].offs += len - doz;
***************
*** 11274,11285 ****
  	  SQLCHAR *table, SQLSMALLINT tableLen,
  	  SQLCHAR *type, SQLSMALLINT typeLen)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvtables(stmt, cat, catLen, schema, schemaLen,
! 		    table, tableLen, type, typeLen);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 11641,11686 ----
  	  SQLCHAR *table, SQLSMALLINT tableLen,
  	  SQLCHAR *type, SQLSMALLINT typeLen)
  {
+     char *c = NULL, *s = NULL, *t = NULL, *y = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (cat) {
! 	c = wmb_to_utf(cat, catLen);
! 	if (!c) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (schema) {
! 	s = wmb_to_utf(schema, schemaLen);
! 	if (!s) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (table) {
! 	t = wmb_to_utf(table, tableLen);
! 	if (!t) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (type) {
! 	y = wmb_to_utf(type, typeLen);
! 	if (!y) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvtables(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
! 		    (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) y, SQL_NTS);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(y);
+     uc_free(t);
+     uc_free(s);
+     uc_free(c);
      return ret;
  }
  #endif
***************
*** 11741,11752 ****
  	   SQLCHAR *table, SQLSMALLINT tableLen,
  	   SQLCHAR *col, SQLSMALLINT colLen)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvcolumns(stmt, cat, catLen, schema, schemaLen,
! 		     table, tableLen, col, colLen);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 12142,12187 ----
  	   SQLCHAR *table, SQLSMALLINT tableLen,
  	   SQLCHAR *col, SQLSMALLINT colLen)
  {
+     char *c = NULL, *s = NULL, *t = NULL, *k = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (cat) {
! 	c = wmb_to_utf(cat, catLen);
! 	if (!c) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (schema) {
! 	s = wmb_to_utf(schema, schemaLen);
! 	if (!s) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (table) {
! 	t = wmb_to_utf(table, tableLen);
! 	if (!t) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (col) {
! 	k = wmb_to_utf(col, colLen);
! 	if (!k) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvcolumns(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
! 		     (SQLCHAR *) t, SQL_NTS, (SQLCHAR *) k, SQL_NTS);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(k);
+     uc_free(t);
+     uc_free(s);
+     uc_free(c);
      return ret;
  }
  #endif
***************
*** 12547,12558 ****
  	      SQLCHAR *table, SQLSMALLINT tableLen,
  	      SQLUSMALLINT itype, SQLUSMALLINT resv)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvstatistics(stmt, cat, catLen, schema, schemaLen,
! 			table, tableLen, itype, resv);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
  #endif
--- 12982,13019 ----
  	      SQLCHAR *table, SQLSMALLINT tableLen,
  	      SQLUSMALLINT itype, SQLUSMALLINT resv)
  {
+     char *c = NULL, *s = NULL, *t = NULL;
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     if (cat) {
! 	c = wmb_to_utf(cat, catLen);
! 	if (!c) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (schema) {
! 	s = wmb_to_utf(schema, schemaLen);
! 	if (!s) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     if (table) {
! 	t = wmb_to_utf(table, tableLen);
! 	if (!t) {
! 	    ret = nomem((STMT *) stmt);
! 	    goto done;
! 	}
!     }
!     ret = drvstatistics(stmt, (SQLCHAR *) c, SQL_NTS, (SQLCHAR *) s, SQL_NTS,
! 			(SQLCHAR *) t, SQL_NTS, itype, resv);
! done:
      HSTMT_UNLOCK(stmt);
+     uc_free(t);
+     uc_free(s);
+     uc_free(c);
      return ret;
  }
  #endif
***************
*** 13160,13169 ****
  	       SQLSMALLINT *digits, SQLSMALLINT *nullable)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvdescribecol(stmt, col, name, nameMax, nameLen,
! 			 type, size, digits, nullable);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
--- 13621,13666 ----
  	       SQLSMALLINT *digits, SQLSMALLINT *nullable)
  {
      SQLRETURN ret;
+     SQLSMALLINT len = 0;
  
      HSTMT_LOCK(stmt);
!     ret = drvdescribecol(stmt, col, (SQLCHAR *) name,
! 			 (SQLSMALLINT) (nameMax * sizeof (SQLWCHAR)),
! 			 &len, type, size, digits, nullable);
!     if (ret == SQL_SUCCESS) {
! 	if (name) {
! 	    if (len > 0) {
! 		SQLCHAR *n = NULL;
! 
! 		n = utf_to_wmb((SQLCHAR *) name, len);
! 		if (n) {
! 		    strncpy(name, n, nameMax);
! 		    n[len] = 0;
! 		    len = min(nameMax, strlen(n));
! 		    uc_free(n);
! 		} else {
! 		    len = 0;
! 		}
! 	    }
! 	    if (len <= 0) {
! 		len = 0;
! 		if (nameMax > 0) {
! 		    name[0] = 0;
! 		}
! 	    }
! 	} else {
! 	    STMT *s = (STMT *) stmt;
! 	    COL *c = s->cols + col - 1;
! 
! 	    len = 0;
! 	    if (c->column) {
! 		len = strlen(c->column);
! 	    }
! 	}
! 	if (nameLen) {
! 	    *nameLen = len;
! 	}
!     }
      HSTMT_UNLOCK(stmt);
      return ret;
  }
***************
*** 13579,13587 ****
  		 SQLLEN *val2)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvcolattributes(stmt, col, id, val, valMax, valLen, val2);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
--- 14076,14128 ----
  		 SQLLEN *val2)
  {
      SQLRETURN ret;
+     SQLSMALLINT len = 0;
  
      HSTMT_LOCK(stmt);
!     ret = drvcolattributes(stmt, col, id, val, valMax, &len, val2);
!     if (SQL_SUCCEEDED(ret)) {
! 	SQLCHAR *v = NULL;
! 
! 	switch (id) {
! 	case SQL_COLUMN_LABEL:
! 	case SQL_COLUMN_NAME:
! 	case SQL_DESC_NAME:
! 	case SQL_COLUMN_TYPE_NAME:
! 	case SQL_COLUMN_OWNER_NAME:
! 	case SQL_COLUMN_QUALIFIER_NAME:
! 	case SQL_COLUMN_TABLE_NAME:
! #if (SQL_COLUMN_TABLE_NAME != SQL_DESC_TABLE_NAME)
! 	case SQL_DESC_TABLE_NAME:
! #endif
! #ifdef SQL_DESC_BASE_COLUMN_NAME
! 	case SQL_DESC_BASE_COLUMN_NAME:
! #endif
! #ifdef SQL_DESC_BASE_TABLE_NAME
!     case SQL_DESC_BASE_TABLE_NAME:
! #endif
! 	    if (val && valMax > 0) {
! 		int vmax = valMax;
! 
! 		v = utf_to_wmb((SQLCHAR *) val, SQL_NTS);
! 		if (v) {
! 		    strncpy(val, v, vmax);
! 		    len = min(vmax, strlen(v));
! 		    uc_free(v);
! 		}
! 		if (vmax > 0) {
! 		    v = (SQLCHAR *) val;
! 		    v[vmax - 1] = '\0';
! 		}
! 	    }
! 	    if (len <= 0) {
! 		len = 0;
! 	    }
! 	    break;
! 	}
! 	if (valLen) {
! 	    *valLen = len;
! 	}
!     }
      HSTMT_UNLOCK(stmt);
      return ret;
  }
***************
*** 14008,14017 ****
  		COLATTRIBUTE_LAST_ARG_TYPE val2)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvcolattribute(stmt, col, id, val, valMax, valLen,
  			  (SQLPOINTER) val2);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
--- 14549,14598 ----
  		COLATTRIBUTE_LAST_ARG_TYPE val2)
  {
      SQLRETURN ret;
+     SQLSMALLINT len = 0;
  
      HSTMT_LOCK(stmt);
!     ret = drvcolattribute(stmt, col, id, val, valMax, &len,
  			  (SQLPOINTER) val2);
+     if (SQL_SUCCEEDED(ret)) {
+ 	SQLCHAR *v = NULL;
+ 
+ 	switch (id) {
+ 	case SQL_DESC_SCHEMA_NAME:
+ 	case SQL_DESC_CATALOG_NAME:
+ 	case SQL_COLUMN_LABEL:
+ 	case SQL_DESC_NAME:
+ 	case SQL_DESC_TABLE_NAME:
+ #ifdef SQL_DESC_BASE_TABLE_NAME
+ 	case SQL_DESC_BASE_TABLE_NAME:
+ #endif
+ #ifdef SQL_DESC_BASE_COLUMN_NAME
+ 	case SQL_DESC_BASE_COLUMN_NAME:
+ #endif
+ 	case SQL_DESC_TYPE_NAME:
+ 	    if (val && valMax > 0) {
+ 		int vmax = valMax;
+ 
+ 		v = utf_to_wmb((SQLCHAR *) val, SQL_NTS);
+ 		if (v) {
+ 		    strncpy(val, v, vmax);
+ 		    len = min(vmax, strlen(v));
+ 		    uc_free(v);
+ 		}
+ 		if (vmax > 0) {
+ 		    v = (SQLCHAR *) val;
+ 		    v[vmax - 1] = '\0';
+ 		}
+ 	    }
+ 	    if (len <= 0) {
+ 		len = 0;
+ 	    }
+ 	    break;
+ 	}
+ 	if (valLen) {
+ 	    *valLen = len;
+ 	}
+     }
      HSTMT_UNLOCK(stmt);
      return ret;
  }
***************
*** 14211,14218 ****
  	 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
  	 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
  {
!     return drverror(env, dbc, stmt, sqlState, nativeErr,
! 		    errmsg, errmax, errlen);
  }
  #endif
  
--- 14792,14848 ----
  	 SQLCHAR *sqlState, SQLINTEGER *nativeErr,
  	 SQLCHAR *errmsg, SQLSMALLINT errmax, SQLSMALLINT *errlen)
  {
!     char state[16];
!     SQLSMALLINT len = 0;
!     SQLRETURN ret;
!     
!     ret = drverror(env, dbc, stmt, (SQLCHAR *) state, nativeErr,
! 		   (SQLCHAR *) errmsg, errmax, &len);
!     if (ret == SQL_SUCCESS) {
! 	if (errmsg) {
! 	    if (len > 0) {
! 		SQLCHAR *e = NULL;
! 
! 		e = utf_to_wmb((SQLCHAR *) errmsg, len);
! 		if (e) {
! 		    if (errmax > 0) {
! 			strncpy(errmsg, e, errmax);
! 			e[len] = 0;
! 			len = min(errmax, strlen(e));
! 		    } else {
! 			len = strlen(e);
! 		    }
! 		    uc_free(e);
! 		} else {
! 		    len = 0;
! 		}
! 	    }
! 	    if (len <= 0) {
! 		len = 0;
! 		if (errmax > 0) {
! 		    errmsg[0] = 0;
! 		}
! 	    }
! 	} else {
! 	    len = 0;
! 	}
! 	if (errlen) {
! 	    *errlen = len;
! 	}
!     } else if (ret == SQL_NO_DATA) {
! 	if (sqlState) {
! 	    sqlState[0] = 0;
! 	}
! 	if (errmsg) {
! 	    if (errmax > 0) {
! 		errmsg[0] = 0;
! 	    }
! 	}
! 	if (errlen) {
! 	    *errlen = 0;
! 	}
!     }
!     return ret;
  }
  #endif
  
***************
*** 14761,14769 ****
  SQLPrepare(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvprepare(stmt, query, queryLen);
      HSTMT_UNLOCK(stmt);
      return ret;
  }
--- 15391,15406 ----
  SQLPrepare(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
  {
      SQLRETURN ret;
+     char *q = wmb_to_utf(query, queryLen);
  
      HSTMT_LOCK(stmt);
!     if (!q) {
! 	ret = nomem((STMT *) stmt);
! 	goto done;
!     }
!     ret = drvprepare(stmt, (SQLCHAR *) q, SQL_NTS);
!     uc_free(q);
! done:
      HSTMT_UNLOCK(stmt);
      return ret;
  }
***************
*** 14827,14838 ****
  SQLExecDirect(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
  {
      SQLRETURN ret;
  
      HSTMT_LOCK(stmt);
!     ret = drvprepare(stmt, query, queryLen);
      if (ret == SQL_SUCCESS) {
  	ret = drvexecute(stmt, 1);
      }
      HSTMT_UNLOCK(stmt);
      return ret;
  }
--- 15464,15482 ----
  SQLExecDirect(SQLHSTMT stmt, SQLCHAR *query, SQLINTEGER queryLen)
  {
      SQLRETURN ret;
+     char *q = wmb_to_utf(query, queryLen);
  
      HSTMT_LOCK(stmt);
!     if (!q) {
! 	ret = nomem((STMT *) stmt);
! 	goto done;
!     }
!     ret = drvprepare(stmt, (SQLCHAR *) q, SQL_NTS);
!     uc_free(q);
      if (ret == SQL_SUCCESS) {
  	ret = drvexecute(stmt, 1);
      }
+ done:
      HSTMT_UNLOCK(stmt);
      return ret;
  }
***************
*** 15688,15698 ****
  		 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
  {
      SQLRETURN ret;
  
      HDBC_LOCK(dbc);
!     ret = drvdriverconnect(dbc, hwnd, connIn, connInLen,
! 			   connOut, connOutMax, connOutLen, drvcompl);
      HDBC_UNLOCK(dbc);
      return ret;
  }
  #endif
--- 16332,16381 ----
  		 SQLSMALLINT *connOutLen, SQLUSMALLINT drvcompl)
  {
      SQLRETURN ret;
+     char *ci = NULL;
+     SQLSMALLINT len = 0;
  
      HDBC_LOCK(dbc);
!     if (connIn) {
! 	ci = wmb_to_utf(connIn, connInLen);
! 	if (!ci) {
! 	    DBC *d = (DBC *) dbc;
! 
! 	    setstatd(d, -1, "out of memory", (*d->ov3) ? "HY000" : "S1000");
! 	    HDBC_UNLOCK(dbc);
! 	    return SQL_ERROR;
! 	}
!     }
!     ret = drvdriverconnect(dbc, hwnd, (SQLCHAR *) ci, SQL_NTS,
! 			   (SQLCHAR *) connOut, connOutMax, &len, drvcompl);
      HDBC_UNLOCK(dbc);
+     uc_free(ci);
+     if (ret == SQL_SUCCESS) {
+ 	SQLCHAR *co = NULL;
+ 
+ 	if (connOut) {
+ 	    if (len > 0) {
+ 		co = utf_to_wmb((char *) connOut, len);
+ 		if (co) {
+ 		    strncpy(connOut, co, connOutMax);
+ 		    co[len] = 0;
+ 		    len = min(connOutMax, strlen(co));
+ 		    uc_free(co);
+ 		} else {
+ 		    len = 0;
+ 		}
+ 	    }
+ 	    if (len <= 0) {
+ 		len = 0;
+ 		connOut[0] = 0;
+ 	    }
+ 	} else {
+ 	    len = 0;
+ 	}
+ 	if (connOutLen) {
+ 	    *connOutLen = len;
+ 	}
+     }
      return ret;
  }
  #endif