adding charset-endec support

src/connector/odbc/src/todbc_conv.c

@@ -15,6 +15,8 @@
 
 #include "todbc_conv.h"
 
+#include "todbc_log.h"
+
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
@@ -53,11 +55,13 @@ static void buf_clean(buf_t *buf) {
 const char* tsdb_conv_code_str(TSDB_CONV_CODE code) {
   switch (code) {
     case TSDB_CONV_OK:                 return "TSDB_CONV_OK";
+    case TSDB_CONV_NOT_AVAIL:          return "TSDB_CONV_NOT_AVAIL";
     case TSDB_CONV_OOM:                return "TSDB_CONV_OOM";
     case TSDB_CONV_OOR:                return "TSDB_CONV_OOR";
     case TSDB_CONV_TRUNC_FRACTION:     return "TSDB_CONV_TRUNC_FRACTION";
     case TSDB_CONV_TRUNC:              return "TSDB_CONV_TRUNC";
     case TSDB_CONV_CHAR_NOT_NUM:       return "TSDB_CONV_CHAR_NOT_NUM";
+    case TSDB_CONV_CHAR_NOT_TS:        return "TSDB_CONV_CHAR_NOT_TS";
     case TSDB_CONV_GENERAL:            return "TSDB_CONV_GENERAL";
     case TSDB_CONV_BAD_CHAR:           return "TSDB_CONV_BAD_CHAR";
     default: return "UNKNOWN";
@@ -154,6 +158,7 @@ TSDB_CONV_CODE tsdb_int64_to_double(int64_t src, double *dst) {
 
 TSDB_CONV_CODE tsdb_int64_to_char(int64_t src, char *dst, size_t dlen) {
   int n = snprintf(dst, dlen, "%" PRId64 "", src);
+  DASSERT(n>=0);
 
   if (n<dlen) return TSDB_CONV_OK;
 
@@ -238,6 +243,7 @@ TSDB_CONV_CODE tsdb_double_to_ts(double src, int64_t *dst) {
 
 TSDB_CONV_CODE tsdb_double_to_char(double src, char *dst, size_t dlen) {
   int n = snprintf(dst, dlen, "%lg", src);
+  DASSERT(n>=0);
 
   if (n<dlen) return TSDB_CONV_OK;
 
@@ -250,6 +256,7 @@ TSDB_CONV_CODE tsdb_timestamp_to_char(SQL_TIMESTAMP_STRUCT src, char *dst, size_
                    src.year, src.month, src.day,
                    src.hour, src.minute, src.second,
                    src.fraction / 1000000);
+  DASSERT(n>=0);
   if (n<dlen) return TSDB_CONV_OK;
 
   if (strlen(dst)>=19) return TSDB_CONV_TRUNC_FRACTION;
@@ -374,8 +381,43 @@ TSDB_CONV_CODE tsdb_chars_to_double(const char *src, size_t smax, double *dst) {
   return TSDB_CONV_CHAR_NOT_NUM;
 }
 
+TSDB_CONV_CODE tsdb_chars_to_timestamp(const char *src, size_t smax, SQL_TIMESTAMP_STRUCT *dst) {
+  int64_t v = 0;
+  // why cast to 'char*' ?
+  int r = taosParseTime((char*)src, &v, (int32_t)smax, TSDB_TIME_PRECISION_MILLI, 0);
+
+  if (r) {
+    return TSDB_CONV_CHAR_NOT_TS;
+  }
+
+  time_t t = v/1000;
+  struct tm vtm = {0};
+  localtime_r(&t, &vtm);
+  dst->year     = (SQLSMALLINT)(vtm.tm_year + 1900);
+  dst->month    = (SQLUSMALLINT)(vtm.tm_mon + 1);
+  dst->day      = (SQLUSMALLINT)(vtm.tm_mday);
+  dst->hour     = (SQLUSMALLINT)(vtm.tm_hour);
+  dst->minute   = (SQLUSMALLINT)(vtm.tm_min);
+  dst->second   = (SQLUSMALLINT)(vtm.tm_sec);
+  dst->fraction = (SQLUINTEGER)(v%1000 * 1000000);
+
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_timestamp_ts(const char *src, size_t smax, int64_t *dst) {
+  // why cast to 'char*' ?
+  int r = taosParseTime((char*)src, dst, (int32_t)smax, TSDB_TIME_PRECISION_MILLI, 0);
+
+  if (r) {
+    return TSDB_CONV_CHAR_NOT_TS;
+  }
+
+  return TSDB_CONV_OK;
+}
+
 TSDB_CONV_CODE tsdb_chars_to_char(const char *src, size_t smax, char *dst, size_t dmax) {
   int n = snprintf(dst, dmax, "%s", src);
+  DASSERT(n>=0);
   if (n<dmax) return TSDB_CONV_OK;
 
   return TSDB_CONV_TRUNC;
@@ -524,5 +566,264 @@ TSDB_CONV_CODE tsdb_wchars_to_char(iconv_t cnv, const unsigned char *src, size_t
   return tsdb_iconv_conv(cnv, src, &smax, (unsigned char*)dst, &dmax);
 }
 
+char* stack_buffer_alloc(stack_buffer_t *buffer, size_t bytes) {
+  if (!buffer) return NULL;
+  // align-by-size_of-size_t-bytes
+  if (bytes==0) bytes = sizeof(size_t);
+  bytes = (bytes + sizeof(size_t) - 1) / sizeof(size_t) * sizeof(size_t);
+
+  size_t next = buffer->next + bytes;
+  if (next>sizeof(buffer->buf)) return NULL;
+
+  char *p = buffer->buf + buffer->next;
+  buffer->next = next;
+  return p;
+}
+
+int is_owned_by_stack_buffer(stack_buffer_t *buffer, const char *ptr) {
+  if (!buffer) return 0;
+  if (ptr>=buffer->buf && ptr<buffer->buf+buffer->next) return 1;
+  return 0;
+}
+
+
+struct tsdb_conv_s {
+  iconv_t             cnv;
+  unsigned int        direct:1;
+};
+
+tsdb_conv_t* tsdb_conv_open(const char *from_enc, const char *to_enc) {
+  tsdb_conv_t *cnv = (tsdb_conv_t*)calloc(1, sizeof(*cnv));
+  if (!cnv) return NULL;
+  if (strcmp(from_enc, to_enc)==0) {
+    cnv->cnv = (iconv_t)-1;
+    cnv->direct = 1;
+    return cnv;
+  }
+  cnv->cnv = iconv_open(to_enc, from_enc);
+  if (cnv->cnv == (iconv_t)-1) {
+    free(cnv);
+    return NULL;
+  }
+  cnv->direct = 0;
+  return cnv;
+}
+
+void tsdb_conv_close(tsdb_conv_t *cnv) {
+  if (!cnv) return;
+  if (!cnv->direct) {
+    if (cnv->cnv != (iconv_t)-1) {
+      iconv_close(cnv->cnv);
+    }
+  }
+  cnv->cnv = (iconv_t)-1;
+  cnv->direct = 0;
+  free(cnv);
+}
+
+TSDB_CONV_CODE tsdb_conv_write(tsdb_conv_t *cnv, const char *src, size_t *slen, char *dst, size_t *dlen) {
+  if (!cnv) return TSDB_CONV_NOT_AVAIL;
+  if (cnv->direct) {
+    size_t n = (*slen > *dlen) ? *dlen : *slen;
+    memcpy(dst, src, n);
+    *slen -= n;
+    *dlen -= n;
+    if (*dlen) dst[n] = '\0';
+    return TSDB_CONV_OK;
+  }
+  if (!cnv->cnv) return TSDB_CONV_NOT_AVAIL;
+  size_t r = iconv(cnv->cnv, (char**)&src, slen, &dst, dlen);
+  if (r==(size_t)-1) return TSDB_CONV_BAD_CHAR;
+  if (*slen)         return TSDB_CONV_TRUNC;
+  if (*dlen) *dst = '\0';
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_conv_write_int64(tsdb_conv_t *cnv, int64_t val, char *dst, size_t *dlen) {
+  char utf8[64];
+  int n = snprintf(utf8, sizeof(utf8), "%" PRId64 "", val);
+  DASSERT(n>=0);
+  DASSERT(n<sizeof(utf8));
+  size_t len = (size_t)n;
+  TSDB_CONV_CODE code = tsdb_conv_write(cnv, utf8, &len, dst, dlen);
+  *dlen = (size_t)n+1;
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_write_double(tsdb_conv_t *cnv, double val, char *dst, size_t *dlen) {
+  char utf8[256];
+  int n = snprintf(utf8, sizeof(utf8), "%g", val);
+  DASSERT(n>=0);
+  DASSERT(n<sizeof(utf8));
+  size_t len = (size_t)n;
+  TSDB_CONV_CODE code = tsdb_conv_write(cnv, utf8, &len, dst, dlen);
+  *dlen = (size_t)n+1;
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_write_timestamp(tsdb_conv_t *cnv, SQL_TIMESTAMP_STRUCT val, char *dst, size_t *dlen) {
+  char utf8[256];
+  int n = snprintf(utf8, sizeof(utf8), "%04d-%02d-%02d %02d:%02d:%02d.%03d",
+                   val.year, val.month, val.day,
+                   val.hour, val.minute, val.second,
+                   val.fraction / 1000000);
+  DASSERT(n>=0);
+  DASSERT(n<sizeof(utf8));
+  size_t len = (size_t)n;
+  TSDB_CONV_CODE code = tsdb_conv_write(cnv, utf8, &len, dst, dlen);
+  *dlen = (size_t)n+1;
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_bit(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_bit(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_tinyint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_tinyint(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_smallint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int16_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_smallint(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_int(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int32_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_int(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_bigint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_bigint(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_ts(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_float(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, float *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_float(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_double(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, double *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_double(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
 
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, SQL_TIMESTAMP_STRUCT *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_timestamp(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_timestamp_ts(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, const char **dst, size_t *dlen) {
+  if (!cnv) return TSDB_CONV_NOT_AVAIL;
+
+  char *buf;
+  size_t blen;
+  if (cnv->direct) {
+    if (src[slen]=='\0') { // access violation?
+      *dst = src;
+      if (dlen) *dlen = slen;
+      return TSDB_CONV_OK;
+    }
+    blen = slen + 1;
+  } else {
+    blen = (slen + 1) * 4;
+  }
+
+  buf = stack_buffer_alloc(buffer, blen);
+  if (!buf) {
+    buf = (char*)malloc(blen);
+    if (!buf) return TSDB_CONV_OOM;
+  }
+
+  if (cnv->direct) {
+    size_t n = slen;
+    DASSERT(blen > n);
+    memcpy(buf, src, n);
+    buf[n] = '\0';
+    *dst = buf;
+    if (dlen) *dlen = n;
+    return TSDB_CONV_OK;
+  }
+
+  const char *orig_s = src;
+  char       *orig_d = buf;
+  size_t      orig_blen = blen;
+
+  TSDB_CONV_CODE code;
+  size_t r = iconv(cnv->cnv, (char**)&src, &slen, &buf, &blen);
+  do {
+    if (r==(size_t)-1) {
+      code = TSDB_CONV_BAD_CHAR;
+      break;
+    }
+    if (slen) {
+      code = TSDB_CONV_TRUNC;
+      break;
+    }
+    DASSERT(blen);
+    *buf = '\0';
+    *dst = orig_d;
+    if (dlen) *dlen = orig_blen - blen;
+    return TSDB_CONV_OK;
+  } while (0);
+
+  if (orig_d!=(char*)orig_s && !is_owned_by_stack_buffer(buffer, orig_d)) free(orig_d);
+  return code;
+}
+
+void tsdb_conv_free(tsdb_conv_t *cnv, const char *ptr, stack_buffer_t *buffer, const char *src) {
+  if (ptr!=src && !is_owned_by_stack_buffer(buffer, ptr)) free((char*)ptr);
+}
 

src/connector/odbc/src/todbc_conv.h

@@ -23,17 +23,50 @@
 
 typedef enum {
   TSDB_CONV_OK             = 0,
+  TSDB_CONV_NOT_AVAIL,
   TSDB_CONV_OOM,
   TSDB_CONV_OOR,
   TSDB_CONV_TRUNC_FRACTION,
   TSDB_CONV_TRUNC,
   TSDB_CONV_CHAR_NOT_NUM,
+  TSDB_CONV_CHAR_NOT_TS,
   TSDB_CONV_GENERAL,
   TSDB_CONV_BAD_CHAR,
 } TSDB_CONV_CODE;
 
 const char* tsdb_conv_code_str(TSDB_CONV_CODE code);
 
+typedef struct stack_buffer_s           stack_buffer_t;
+struct stack_buffer_s {
+  char                  buf[1024*16];
+  size_t                next;
+};
+
+char* stack_buffer_alloc(stack_buffer_t *buffer, size_t bytes);
+int is_owned_by_stack_buffer(stack_buffer_t *buffer, const char *ptr);
+
+typedef struct tsdb_conv_s             tsdb_conv_t;
+tsdb_conv_t*   tsdb_conv_open(const char *from_enc, const char *to_enc);
+void           tsdb_conv_close(tsdb_conv_t *cnv);
+TSDB_CONV_CODE tsdb_conv_write(tsdb_conv_t *cnv, const char *src, size_t *slen, char *dst, size_t *dlen);
+TSDB_CONV_CODE tsdb_conv_write_int64(tsdb_conv_t *cnv, int64_t val, char *dst, size_t *dlen);
+TSDB_CONV_CODE tsdb_conv_write_double(tsdb_conv_t *cnv, double val, char *dst, size_t *dlen);
+TSDB_CONV_CODE tsdb_conv_write_timestamp(tsdb_conv_t *cnv, SQL_TIMESTAMP_STRUCT val, char *dst, size_t *dlen);
+
+TSDB_CONV_CODE tsdb_conv_chars_to_bit(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_tinyint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_smallint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int16_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_int(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int32_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_bigint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_float(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, float *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_double(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, double *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, SQL_TIMESTAMP_STRUCT *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst);
+TSDB_CONV_CODE tsdb_conv(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, const char **dst, size_t *dlen);
+void           tsdb_conv_free(tsdb_conv_t *cnv, const char *ptr, stack_buffer_t *buffer, const char *src);
+
+
 TSDB_CONV_CODE tsdb_iconv_conv(iconv_t cnv, const unsigned char *src, size_t *slen, unsigned char *dst, size_t *dlen);
 
 
@@ -66,6 +99,7 @@ TSDB_CONV_CODE tsdb_chars_to_bigint(const char *src, size_t smax, int64_t *dst);
 TSDB_CONV_CODE tsdb_chars_to_ts(const char *src, size_t smax, int64_t *dst);
 TSDB_CONV_CODE tsdb_chars_to_float(const char *src, size_t smax, float *dst);
 TSDB_CONV_CODE tsdb_chars_to_double(const char *src, size_t smax, double *dst);
+TSDB_CONV_CODE tsdb_chars_to_timestamp(const char *src, size_t smax, SQL_TIMESTAMP_STRUCT *dst);
 TSDB_CONV_CODE tsdb_chars_to_char(const char *src, size_t smax, char *dst, size_t dmax);
 
 TSDB_CONV_CODE tsdb_wchars_to_bit(iconv_t cnv, const unsigned char *src, size_t smax, int8_t *dst);

src/connector/odbc/src/todbc_flex.h

@@ -16,7 +16,21 @@
 #ifndef _TODBC_FLEX_H_
 #define _TODBC_FLEX_H_
 
-int todbc_parse_conn_string(const char *conn, char **dsn, char **uid, char **pwd, char **host);
+typedef struct conn_val_s              conn_val_t;
+struct conn_val_s {
+    char                *key;
+    char                *dsn;
+    char                *uid;
+    char                *pwd;
+    char                *db;
+    char                *host;
+    char                *svr_enc;
+    char                *cli_enc;
+};
+
+
+void conn_val_reset(conn_val_t *val);
+int todbc_parse_conn_string(const char *conn, conn_val_t *val);
 
 #endif // _TODBC_FLEX_H_
 

src/connector/odbc/src/todbc_scanner.l

@@ -7,15 +7,6 @@
 #define strcasecmp _stricmp
 #endif
 
-typedef struct params_s              params_t;
-struct params_s {
-    char                *key;
-    char                *dsn;
-    char                *uid;
-    char                *pwd;
-    char                *host;
-};
-
 #define PUSH_STATE(state)      yy_push_state(state, yyscanner)
 #define POP_STATE()            yy_pop_state(yyscanner)
 
@@ -61,17 +52,32 @@ do {                                                 \
         yyextra->pwd = strdup(yytext);               \
         break;                                       \
     }                                                \
+    if (strcasecmp(yyextra->key, "DB")==0) {         \
+        free(yyextra->db);                           \
+        yyextra->pwd = strdup(yytext);               \
+        break;                                       \
+    }                                                \
     if (strcasecmp(yyextra->key, "HOST")==0) {       \
         free(yyextra->host);                         \
         yyextra->host = strdup(yytext);              \
         break;                                       \
     }                                                \
+    if (strcasecmp(yyextra->key, "SERVER_ENC")==0) { \
+        free(yyextra->svr_enc);                      \
+        yyextra->host = strdup(yytext);              \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "CLIENT_ENC")==0) { \
+        free(yyextra->cli_enc);                      \
+        yyextra->host = strdup(yytext);              \
+        break;                                       \
+    }                                                \
 } while (0)
 
 %}
 
 %option prefix="todbc_yy"
-%option extra-type="struct params_s *"
+%option extra-type="conn_val_t *"
 %option nounistd
 %option never-interactive
 %option reentrant
@@ -115,20 +121,45 @@ do {                                                 \
 <VAL>.|\n         { return -1; }
 %%
 
-int todbc_parse_conn_string(const char *conn, char **dsn, char **uid, char **pwd, char **host) {
+int todbc_parse_conn_string(const char *conn, conn_val_t *val) {
   yyscan_t arg = {0};
-  params_t params = {0};
   yylex_init(&arg);
   yyset_debug(0, arg);
-  yyset_extra(&params, arg);
+  yyset_extra(val, arg);
   yy_scan_string(conn, arg);
   int ret =yylex(arg);
   yylex_destroy(arg);
-  *dsn = params.dsn;
-  *uid = params.uid;
-  *pwd = params.pwd;
-  *host = params.host;
+  if (val->key) free(val->key); val->key = NULL;
+  if (ret) {
+    conn_val_reset(val);
+  }
   return ret ? -1 : 0;
 }
 
+void conn_val_reset(conn_val_t *val) {
+  if (val->key) {
+    free(val->key); val->key = NULL;
+  }
+  if (val->dsn) {
+    free(val->dsn); val->dsn = NULL;
+  }
+  if (val->uid) {
+    free(val->uid); val->uid = NULL;
+  }
+  if (val->pwd) {
+    free(val->pwd); val->pwd = NULL;
+  }
+  if (val->db) {
+    free(val->db); val->db = NULL;
+  }
+  if (val->host) {
+    free(val->host); val->host = NULL;
+  }
+  if (val->svr_enc) {
+    free(val->svr_enc); val->svr_enc = NULL;
+  }
+  if (val->cli_enc) {
+    free(val->cli_enc); val->cli_enc = NULL;
+  }
+}