Odd memory leak or crash

I have fairly simple application that calls a stored procedure in
PostgreSQL. I am using a late model PostgreSQL ODBC driver.

When I use the PostgreSQL SQL driver the system goes for ever. When I use
the ODBC driver it fails after about 80K or 90K operations.

The symptoms are SQLExecDirect returns -1 and no status message and the
program crashes.

Could you look over my execute, connect, and disconnect code and tell me
if your see anything obvious I am doing wrong? I can't seem to see
anything.

My execute function looks like this:
DWORD ODBCData::sql_execute (char *c_sql)
{
#ifdef POSIX
vmon_log(VLOG_TRACE,"sql_execute:%s", c_sql);
#endif
#ifdef WIN32
vmon_log(VLOG_TRACE,"sql_execute:%ws", c_sql);
#endif
DWORD dwErrTimeout = 1;
SQLRETURN rc;
DWORD dw = SQL_ERROR;
time_t comm_start = time (0);
int diag = ODBC_DIAG_SUCCESS;

SQLUCHAR * sql = m_sqlbuf;

cvtstrwid (m_sqlbuf, c_sql, MAX_STRING, sizeof (UCHR), sizeof (char));

for (int retries = 0; !test_state (STATE_EXIT); retries++)
{
/*
* If this is not the first time, slow down a bit
*/
if (diag != ODBC_DIAG_SUCCESS)
stopgate.Wait ();
rc = SQLExecDirect (m_ODBC_stmt, sql, SQL_NTS);
diag = odbc_diag ("SQLExecDirect", rc);
if (diag == ODBC_DIAG_SUCCESS)
{
SQLFreeStmt (m_ODBC_stmt, SQL_CLOSE);
dw = SQL_SUCCESS;
break;
}
else if (diag == ODBC_DIAG_RECONN)
{
Disconnect ();
Connect ();
continue;
}
else if (diag == ODBC_DIAG_FAIL)
{
vmon_log(VLOG_ERROR,"Internal Error: Can't execute SQL command");
dw = SQL_SUCCESS;
break;
}
if (!CommTimeout (comm_start))
break;
}
return dw;
vmon_log(VLOG_TRACE,"sql_execute:end");
}

odbc_diag looks like this:
int ODBCDataConnector::odbc_diag (char *fn, int rc)
{
char *notes = "";
int retval = ODBC_DIAG_RETRY;
m_ODBC_Error = 0;
m_ODBC_Message_Len = 0;

if (rc == SQL_SUCCESS) /* It Worked! */
{
vmon_log(VLOG_TRACE,"ODBC: SQL_SUCCESS");
return ODBC_DIAG_SUCCESS;
}
else if (rc == SQL_NO_DATA) /* It worked, but there is no data */
{
vmon_log(VLOG_TRACE,"ODBC: SQL_NO_DATA");
return ODBC_DIAG_SUCCESS;
}
else if (rc == SQL_SUCCESS_WITH_INFO)
{
vmon_log(VLOG_TRACE,"ODBC: SQL_SUCCESS_WITH_INFO");
/*
* It worked, but is a little chatty about it.
*/
get_diag_info ();
if (!m_has_warned++)
{
#ifdef POSIX
vmon_log(VLOG_WARN,"%s SUCCESS_WITH_INFO [%s]", fn, m_ODBC_Message);
#endif
#ifdef WIN32_UNICODE
vmon_log(VLOG_WARN,"%s SUCCESS_WITH_INFO [%ws]", fn, m_ODBC_Message);
#endif
return ODBC_DIAG_SUCCESS;
}
}
else
{
/*
* Well, it failed, lets figure out why and how it failed
*/
get_diag_info ();

if (rc == SQL_STILL_EXECUTING)
{
vmon_log(VLOG_TRACE,"ODBC: SQL_STILL_EXECUTING");
/*
* It thinks it is still executing? Just try again, I guess
*/
retval = ODBC_DIAG_RETRY;
}
else if (rc == SQL_INVALID_HANDLE)
{
vmon_log(VLOG_TRACE,"ODBC: SQL_INVALID_HANDLE");
/*
* Something bad here, probably a programming error, but who
* knows, just disconnect for now
*/
retval = ODBC_DIAG_RECONN;
}
else if (rc == SQL_ERROR)
{
SQLINTEGER nativeError = 0;
SQLSMALLINT msgLen = 0;
vmon_log(VLOG_TRACE,"ODBC: SQL_ERROR");
/*
* Get the SQL Error data beyond Diag
*/
SQLError (m_ODBC_Env, m_ODBC_Conn, m_ODBC_stmt, m_ODBC_Status,
&nativeError, m_ODBC_Message, ODBC_BUF_LEN - 1, &msgLen);

m_ODBC_Message[msgLen] = 0;
vmon_log(VLOG_DEBUG,"SQLError [%ls] [%ls]", m_status, m_errmsg);
/*
* Search list of known codes and handle them as directed
*/
retval = ODBC_DIAG_RECONN;
for (int i = 0; errcodes[i].code; i++)
{
if (chkcode (errcodes[i].code, m_errmsg))
{
notes = errcodes[i].note;
retval = errcodes[i].fail;
break;
}
}
}
else if (rc == SQL_NEED_DATA)
{
vmon_log(VLOG_DEBUG,"ODBC: SQL_NEED_DATA");
/*
* This should never happen, we can only warn about it and punt
*/
retval = ODBC_DIAG_FAIL;
}
if (!m_has_warned++)
{
vmon_log(VLOG_ERROR,"%s SQL Error %d %s [%s] [%s]", fn, rc, notes,
m_status, m_errmsg);
}
}
return retval;
}

My connect and disconnect code look like this:

void ODBCDataConnector::Disconnect (void)
{
if (m_ODBC_stmt)
{
SQLFreeHandle (SQL_HANDLE_STMT, m_ODBC_stmt);
m_ODBC_stmt = NULL;
}
if (m_ODBC_Conn)
{
SQLDisconnect (m_ODBC_Conn);
SQLFreeHandle (SQL_HANDLE_DBC, m_ODBC_Conn);
m_ODBC_Conn = NULL;
}
if (m_ODBC_Env)
{

SQLFreeHandle (SQL_HANDLE_ENV, m_ODBC_Env);
m_ODBC_Env = NULL;
}
}
int ODBCDataConnector::Connect ()
{
vmon_log(VLOG_TRACE,"ODBC:Connect");
SQLRETURN rc;
/*
* Allocate an environment handle. This should not fail. It is not
* recoverable
*/
rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_ODBC_Env);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
if (!m_has_warned++)
vmon_log(VLOG_WARN,"Can not create ODBC environment handle");
return DCN_ERROR; /* What else can we do? */
}

rc = SQLSetEnvAttr (m_ODBC_Env, SQL_ATTR_ODBC_VERSION, (void *)
SQL_OV_ODBC3, 0);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
if (!m_has_warned++)
vmon_log(VLOG_WARN,"Can not set ODBC environment attribute");
Disconnect ();
return DCN_ERROR;
}
/*
* Allocate a database connection handle. This should not fail. It is not
* recoverable
*/
rc = SQLAllocHandle (SQL_HANDLE_DBC, m_ODBC_Env, &m_ODBC_Conn);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
if (!m_has_warned++)
vmon_log(VLOG_WARN,"Can not allocate ODBC connection handle");
Disconnect ();
return DCN_ERROR;
}
SQLSetConnectAttr (m_ODBC_Conn, SQL_LOGIN_TIMEOUT, (SQLPOINTER *) 5, 0);

/*
* This can fail
*/
rc = SQLConnect (m_ODBC_Conn, (SQLUCHAR*)m_target, SQL_NTS, 0, 0, 0, 0);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
if (!m_has_warned++)
vmon_log(VLOG_WARN,"Can not connect to ODBC database");
Disconnect ();

return DCN_ERROR;
}

/*
* This should not fail
*/
rc = SQLAllocHandle (SQL_HANDLE_STMT, m_ODBC_Conn, &m_ODBC_stmt);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
if (!m_has_warned++)
vmon_log(VLOG_WARN,"Can not allocate ODBC statement handle");
Disconnect ();
return DCN_ERROR;
}

SQLSMALLINT len;
rc = SQLGetInfo (m_ODBC_Conn, SQL_DBMS_NAME, (SQLPOINTER) m_type_str,
ODBC_BUF_LEN, &len);

if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
{
if (!m_has_warned++)
vmon_log(VLOG_WARN,"Can not get information about connection");
Disconnect ();
return DCN_ERROR;
}

m_type_str[len] = 0;

#ifdef UNICODE
wcslwr (m_type_str);
if (wcsstr (m_type_str, L"oracle"))
m_type = SQLDCN_DBTYPE_ORACLE;
else if (wcsstr (m_type_str, L"postgres"))
m_type = SQLDCN_DBTYPE_POSTGRES;
else if (wcsstr (m_type_str, L"sqlite"))
m_type = SQLDCN_DBTYPE_SQLITE;
else
m_type = SQLDCN_DBTYPE_UNKNOWN;
#else
vstrlwr ((char *) m_type_str);
if (strstr ((char *) m_type_str, "oracle"))
m_type = SQLDCN_DBTYPE_ORACLE;
else if (strstr ((char *) m_type_str, "postgres"))
m_type = SQLDCN_DBTYPE_POSTGRES;
else if (strstr ((char *) m_type_str, "sqlite"))
m_type = SQLDCN_DBTYPE_SQLITE;
else
m_type = SQLDCN_DBTYPE_UNKNOWN;

#endif
return DCN_SUCCESS;
}