479 lines
14 KiB
C
479 lines
14 KiB
C
|
|
/* Module: environ.c
|
|
*
|
|
* Description: This module contains routines related to
|
|
* the environment, such as storing connection handles,
|
|
* and returning errors.
|
|
*
|
|
* Classes: EnvironmentClass (Functions prefix: "EN_")
|
|
*
|
|
* API functions: SQLAllocEnv, SQLFreeEnv, SQLError
|
|
*
|
|
* Comments: See "notice.txt" for copyright and license information.
|
|
*
|
|
*/
|
|
|
|
#include "environ.h"
|
|
#include "connection.h"
|
|
#include "statement.h"
|
|
#include <stdlib.h>
|
|
#include <malloc.h>
|
|
|
|
/* The one instance of the handles */
|
|
ConnectionClass *conns[MAX_CONNECTIONS];
|
|
|
|
|
|
RETCODE SQL_API SQLAllocEnv(HENV FAR *phenv)
|
|
{
|
|
static char *func = "SQLAllocEnv";
|
|
|
|
mylog("**** in SQLAllocEnv ** \n");
|
|
|
|
*phenv = (HENV) EN_Constructor();
|
|
if ( ! *phenv) {
|
|
*phenv = SQL_NULL_HENV;
|
|
EN_log_error(func, "Error allocating environment", NULL);
|
|
return SQL_ERROR;
|
|
}
|
|
|
|
mylog("** exit SQLAllocEnv: phenv = %u **\n", *phenv);
|
|
return SQL_SUCCESS;
|
|
}
|
|
|
|
RETCODE SQL_API SQLFreeEnv(HENV henv)
|
|
{
|
|
static char *func = "SQLFreeEnv";
|
|
EnvironmentClass *env = (EnvironmentClass *) henv;
|
|
|
|
mylog("**** in SQLFreeEnv: env = %u ** \n", env);
|
|
|
|
if (env && EN_Destructor(env)) {
|
|
mylog(" ok\n");
|
|
return SQL_SUCCESS;
|
|
}
|
|
|
|
mylog(" error\n");
|
|
EN_log_error(func, "Error freeing environment", env);
|
|
return SQL_ERROR;
|
|
}
|
|
|
|
/* Returns the next SQL error information. */
|
|
|
|
RETCODE SQL_API SQLError(
|
|
HENV henv,
|
|
HDBC hdbc,
|
|
HSTMT hstmt,
|
|
UCHAR FAR *szSqlState,
|
|
SDWORD FAR *pfNativeError,
|
|
UCHAR FAR *szErrorMsg,
|
|
SWORD cbErrorMsgMax,
|
|
SWORD FAR *pcbErrorMsg)
|
|
{
|
|
char *msg;
|
|
int status;
|
|
|
|
mylog("**** SQLError: henv=%u, hdbc=%u, hstmt=%u\n", henv, hdbc, hstmt);
|
|
|
|
if (SQL_NULL_HSTMT != hstmt) {
|
|
/* CC: return an error of a hstmt */
|
|
StatementClass *stmt = (StatementClass *) hstmt;
|
|
|
|
if (SC_get_error(stmt, &status, &msg)) {
|
|
mylog("SC_get_error: status = %d, msg = #%s#\n", status, msg);
|
|
if (NULL == msg) {
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = (SWORD)strlen(msg);
|
|
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
strncpy_null(szErrorMsg, msg, cbErrorMsgMax);
|
|
|
|
if (NULL != pfNativeError)
|
|
*pfNativeError = status;
|
|
|
|
if (NULL != szSqlState)
|
|
|
|
switch (status) {
|
|
/* now determine the SQLSTATE to be returned */
|
|
case STMT_TRUNCATED:
|
|
strcpy(szSqlState, "01004");
|
|
/* data truncated */
|
|
break;
|
|
case STMT_INFO_ONLY:
|
|
strcpy(szSqlState, "00000");
|
|
/* just information that is returned, no error */
|
|
break;
|
|
case STMT_BAD_ERROR:
|
|
strcpy(szSqlState, "08S01");
|
|
/* communication link failure */
|
|
break;
|
|
case STMT_CREATE_TABLE_ERROR:
|
|
strcpy(szSqlState, "S0001");
|
|
/* table already exists */
|
|
break;
|
|
case STMT_STATUS_ERROR:
|
|
case STMT_SEQUENCE_ERROR:
|
|
strcpy(szSqlState, "S1010");
|
|
/* Function sequence error */
|
|
break;
|
|
case STMT_NO_MEMORY_ERROR:
|
|
strcpy(szSqlState, "S1001");
|
|
/* memory allocation failure */
|
|
break;
|
|
case STMT_COLNUM_ERROR:
|
|
strcpy(szSqlState, "S1002");
|
|
/* invalid column number */
|
|
break;
|
|
case STMT_NO_STMTSTRING:
|
|
strcpy(szSqlState, "S1001");
|
|
/* having no stmtstring is also a malloc problem */
|
|
break;
|
|
case STMT_ERROR_TAKEN_FROM_BACKEND:
|
|
strcpy(szSqlState, "S1000");
|
|
/* general error */
|
|
break;
|
|
case STMT_INTERNAL_ERROR:
|
|
strcpy(szSqlState, "S1000");
|
|
/* general error */
|
|
break;
|
|
case STMT_ROW_OUT_OF_RANGE:
|
|
strcpy(szSqlState, "S1107");
|
|
break;
|
|
|
|
case STMT_OPERATION_CANCELLED:
|
|
strcpy(szSqlState, "S1008");
|
|
break;
|
|
|
|
case STMT_NOT_IMPLEMENTED_ERROR:
|
|
strcpy(szSqlState, "S1C00"); /* == 'driver not capable' */
|
|
break;
|
|
case STMT_OPTION_OUT_OF_RANGE_ERROR:
|
|
strcpy(szSqlState, "S1092");
|
|
break;
|
|
case STMT_BAD_PARAMETER_NUMBER_ERROR:
|
|
strcpy(szSqlState, "S1093");
|
|
break;
|
|
case STMT_INVALID_COLUMN_NUMBER_ERROR:
|
|
strcpy(szSqlState, "S1002");
|
|
break;
|
|
case STMT_RESTRICTED_DATA_TYPE_ERROR:
|
|
strcpy(szSqlState, "07006");
|
|
break;
|
|
case STMT_INVALID_CURSOR_STATE_ERROR:
|
|
strcpy(szSqlState, "24000");
|
|
break;
|
|
case STMT_OPTION_VALUE_CHANGED:
|
|
strcpy(szSqlState, "01S02");
|
|
break;
|
|
case STMT_INVALID_CURSOR_NAME:
|
|
strcpy(szSqlState, "34000");
|
|
break;
|
|
case STMT_NO_CURSOR_NAME:
|
|
strcpy(szSqlState, "S1015");
|
|
break;
|
|
case STMT_INVALID_ARGUMENT_NO:
|
|
strcpy(szSqlState, "S1009");
|
|
/* invalid argument value */
|
|
break;
|
|
case STMT_INVALID_CURSOR_POSITION:
|
|
strcpy(szSqlState, "S1109");
|
|
break;
|
|
|
|
case STMT_VALUE_OUT_OF_RANGE:
|
|
strcpy(szSqlState, "22003");
|
|
break;
|
|
|
|
case STMT_OPERATION_INVALID:
|
|
strcpy(szSqlState, "S1011");
|
|
break;
|
|
|
|
case STMT_EXEC_ERROR:
|
|
default:
|
|
strcpy(szSqlState, "S1000");
|
|
/* also a general error */
|
|
break;
|
|
}
|
|
|
|
mylog(" szSqlState = '%s', szError='%s'\n", szSqlState, szErrorMsg);
|
|
|
|
} else {
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
mylog(" returning NO_DATA_FOUND\n");
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
return SQL_SUCCESS;
|
|
|
|
} else if (SQL_NULL_HDBC != hdbc) {
|
|
ConnectionClass *conn = (ConnectionClass *) hdbc;
|
|
|
|
mylog("calling CC_get_error\n");
|
|
if (CC_get_error(conn, &status, &msg)) {
|
|
mylog("CC_get_error: status = %d, msg = #%s#\n", status, msg);
|
|
if (NULL == msg) {
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = (SWORD)strlen(msg);
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
strncpy_null(szErrorMsg, msg, cbErrorMsgMax);
|
|
if (NULL != pfNativeError)
|
|
*pfNativeError = status;
|
|
|
|
if (NULL != szSqlState)
|
|
switch(status) {
|
|
case STMT_OPTION_VALUE_CHANGED:
|
|
case CONN_OPTION_VALUE_CHANGED:
|
|
strcpy(szSqlState, "01S02");
|
|
break;
|
|
case STMT_TRUNCATED:
|
|
case CONN_TRUNCATED:
|
|
strcpy(szSqlState, "01004");
|
|
/* data truncated */
|
|
break;
|
|
case CONN_INIREAD_ERROR:
|
|
strcpy(szSqlState, "IM002");
|
|
/* data source not found */
|
|
break;
|
|
case CONN_OPENDB_ERROR:
|
|
strcpy(szSqlState, "08001");
|
|
/* unable to connect to data source */
|
|
break;
|
|
case CONN_INVALID_AUTHENTICATION:
|
|
case CONN_AUTH_TYPE_UNSUPPORTED:
|
|
strcpy(szSqlState, "28000");
|
|
break;
|
|
case CONN_STMT_ALLOC_ERROR:
|
|
strcpy(szSqlState, "S1001");
|
|
/* memory allocation failure */
|
|
break;
|
|
case CONN_IN_USE:
|
|
strcpy(szSqlState, "S1000");
|
|
/* general error */
|
|
break;
|
|
case CONN_UNSUPPORTED_OPTION:
|
|
strcpy(szSqlState, "IM001");
|
|
/* driver does not support this function */
|
|
case CONN_INVALID_ARGUMENT_NO:
|
|
strcpy(szSqlState, "S1009");
|
|
/* invalid argument value */
|
|
break;
|
|
case CONN_TRANSACT_IN_PROGRES:
|
|
strcpy(szSqlState, "S1010");
|
|
/* when the user tries to switch commit mode in a transaction */
|
|
/* -> function sequence error */
|
|
break;
|
|
case CONN_NO_MEMORY_ERROR:
|
|
strcpy(szSqlState, "S1001");
|
|
break;
|
|
case CONN_NOT_IMPLEMENTED_ERROR:
|
|
case STMT_NOT_IMPLEMENTED_ERROR:
|
|
strcpy(szSqlState, "S1C00");
|
|
break;
|
|
|
|
case CONN_VALUE_OUT_OF_RANGE:
|
|
case STMT_VALUE_OUT_OF_RANGE:
|
|
strcpy(szSqlState, "22003");
|
|
break;
|
|
|
|
default:
|
|
strcpy(szSqlState, "S1000");
|
|
/* general error */
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
mylog("CC_Get_error returned nothing.\n");
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
return SQL_SUCCESS;
|
|
|
|
} else if (SQL_NULL_HENV != henv) {
|
|
EnvironmentClass *env = (EnvironmentClass *)henv;
|
|
if(EN_get_error(env, &status, &msg)) {
|
|
mylog("EN_get_error: status = %d, msg = #%s#\n", status, msg);
|
|
if (NULL == msg) {
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = (SWORD)strlen(msg);
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
strncpy_null(szErrorMsg, msg, cbErrorMsgMax);
|
|
if (NULL != pfNativeError)
|
|
*pfNativeError = status;
|
|
|
|
if(szSqlState) {
|
|
switch(status) {
|
|
case ENV_ALLOC_ERROR:
|
|
/* memory allocation failure */
|
|
strcpy(szSqlState, "S1001");
|
|
break;
|
|
default:
|
|
strcpy(szSqlState, "S1000");
|
|
/* general error */
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
|
|
return SQL_SUCCESS;
|
|
}
|
|
|
|
if (NULL != szSqlState)
|
|
strcpy(szSqlState, "00000");
|
|
if (NULL != pcbErrorMsg)
|
|
*pcbErrorMsg = 0;
|
|
if ((NULL != szErrorMsg) && (cbErrorMsgMax > 0))
|
|
szErrorMsg[0] = '\0';
|
|
|
|
return SQL_NO_DATA_FOUND;
|
|
}
|
|
|
|
|
|
/*********************************************************************/
|
|
/*
|
|
* EnvironmentClass implementation
|
|
*/
|
|
|
|
|
|
|
|
EnvironmentClass
|
|
*EN_Constructor(void)
|
|
{
|
|
EnvironmentClass *rv;
|
|
|
|
rv = (EnvironmentClass *) malloc(sizeof(EnvironmentClass));
|
|
if( rv) {
|
|
rv->errormsg = 0;
|
|
rv->errornumber = 0;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
char
|
|
EN_Destructor(EnvironmentClass *self)
|
|
{
|
|
int lf;
|
|
char rv = 1;
|
|
|
|
mylog("in EN_Destructor, self=%u\n", self);
|
|
|
|
/* the error messages are static strings distributed throughout */
|
|
/* the source--they should not be freed */
|
|
|
|
/* Free any connections belonging to this environment */
|
|
for (lf = 0; lf < MAX_CONNECTIONS; lf++) {
|
|
if (conns[lf] && conns[lf]->henv == self)
|
|
rv = rv && CC_Destructor(conns[lf]);
|
|
}
|
|
|
|
mylog("exit EN_Destructor: rv = %d\n", rv);
|
|
return rv;
|
|
}
|
|
|
|
char
|
|
EN_get_error(EnvironmentClass *self, int *number, char **message)
|
|
{
|
|
if(self && self->errormsg && self->errornumber) {
|
|
*message = self->errormsg;
|
|
*number = self->errornumber;
|
|
self->errormsg = 0;
|
|
self->errornumber = 0;
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
char
|
|
EN_add_connection(EnvironmentClass *self, ConnectionClass *conn)
|
|
{
|
|
int i;
|
|
|
|
mylog("EN_add_connection: self = %u, conn = %u\n", self, conn);
|
|
|
|
for (i = 0; i < MAX_CONNECTIONS; i++) {
|
|
if ( ! conns[i]) {
|
|
conn->henv = self;
|
|
conns[i] = conn;
|
|
|
|
mylog(" added at i =%d, conn->henv = %u, conns[i]->henv = %u\n", i, conn->henv, conns[i]->henv);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
char
|
|
EN_remove_connection(EnvironmentClass *self, ConnectionClass *conn)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_CONNECTIONS; i++)
|
|
if (conns[i] == conn && conns[i]->status != CONN_EXECUTING) {
|
|
conns[i] = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
EN_log_error(char *func, char *desc, EnvironmentClass *self)
|
|
{
|
|
if (self) {
|
|
qlog("ENVIRON ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->errornumber, self->errormsg);
|
|
}
|
|
else
|
|
qlog("INVALID ENVIRON HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
|
|
}
|