SQLRETURN SQLCancelHandle( SQLSMALLINT handle_type, SQLHANDLE handle )
{
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
if ( handle_type == SQL_HANDLE_DBC )
{
DMHDBC connection = ( DMHDBC ) handle;
if ( !__validate_dbc( connection ))
{
return SQL_INVALID_HANDLE;
}
thread_protect( SQL_HANDLE_DBC, connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tEntry:\
\n\t\t\tConnection = %p",
connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLBrowseConnect(
SQLHDBC hdbc,
SQLCHAR *conn_str_in,
SQLSMALLINT len_conn_str_in,
SQLCHAR *conn_str_out,
SQLSMALLINT conn_str_out_max,
SQLSMALLINT *ptr_conn_str_out )
{
DMHDBC connection = (DMHDBC) hdbc;
struct con_struct con_struct;
char *driver, *dsn;
char lib_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char driver_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char in_str[ BUFFER_LEN ];
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN];
SQLWCHAR *uc_in_str;
int warnings;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tStr In = %s\
\n\t\t\tStr Out = %p\
\n\t\t\tStr Out Max = %d\
\n\t\t\tPtr Conn Str Out = %p",
connection,
__string_with_length( s1, conn_str_in, len_conn_str_in ),
conn_str_out,
conn_str_out_max,
ptr_conn_str_out );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLGetInfo( SQLHDBC connection_handle,
SQLUSMALLINT info_type,
SQLPOINTER info_value,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret = SQL_SUCCESS;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tInfo Type = %s (%d)\
\n\t\t\tInfo Value = %p\
\n\t\t\tBuffer Length = %d\
\n\t\t\tStrLen = %p",
connection,
__info_as_string( s1, info_type ),
info_type,
info_value,
(int)buffer_length,
(void*)string_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN __SQLFreeHandle( SQLSMALLINT handle_type,
SQLHANDLE handle )
{
switch( handle_type )
{
case SQL_HANDLE_ENV:
{
DMHENV environment = (DMHENV)handle;
/*
* check environment
*/
if ( !__validate_env( environment ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( environment );
if ( log_info.log_flag )
{
sprintf( environment -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
thread_protect( SQL_HANDLE_ENV, environment );
/*
* check states
*/
if ( environment -> state != STATE_E1 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &environment -> error,
ERROR_HY010, NULL,
environment -> requested_version );
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
thread_release( SQL_HANDLE_ENV, environment );
__release_env( environment );
return SQL_SUCCESS;
}
break;
case SQL_HANDLE_DBC:
{
DMHDBC connection = (DMHDBC)handle;
DMHENV environment;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
environment = connection -> environment;
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
thread_protect( SQL_HANDLE_ENV, environment );
/*
* check states
*/
if ( connection -> state != STATE_C2 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &connection -> error,
ERROR_HY010, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
environment -> connection_count --;
if ( environment -> connection_count == 0 )
{
environment -> state = STATE_E1;
}
environment = connection -> environment;
__release_attr_str( &connection -> env_attribute );
__release_attr_str( &connection -> dbc_attribute );
__release_attr_str( &connection -> stmt_attribute );
__disconnect_part_one( connection );
__release_dbc( connection );
if ( log_info.log_flag )
{
sprintf( environment -> msg,
"\n\t\tExit:[SQL_SUCCESS]" );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(environment->sh, UODBC_STATS_TYPE_HDBC,
(void *)-1);
#endif
thread_release( SQL_HANDLE_ENV, environment );
return SQL_SUCCESS;
}
break;
case SQL_HANDLE_STMT:
{
DMHSTMT statement = (DMHSTMT)handle;
DMHDBC connection;
SQLRETURN ret;
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( statement );
connection = statement -> connection;
if ( log_info.log_flag )
{
sprintf( statement -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
thread_protect( SQL_HANDLE_STMT, statement );
/*
* check states
*/
if ( statement -> state == STATE_S8 ||
statement -> state == STATE_S9 ||
statement -> state == STATE_S10 ||
statement -> state == STATE_S11 ||
statement -> state == STATE_S12 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &statement -> error,
ERROR_HY010, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
if ( !CHECK_SQLFREEHANDLE( statement -> connection ))
{
if ( !CHECK_SQLFREESTMT( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else
{
ret = SQLFREESTMT( statement -> connection,
statement -> driver_stmt,
SQL_DROP );
}
}
else
{
ret = SQLFREEHANDLE( statement -> connection,
handle_type,
statement -> driver_stmt );
}
if ( SQL_SUCCEEDED( ret ))
{
/*
* break any association
*/
if ( statement -> ard ) {
statement -> ard -> associated_with = NULL;
}
if ( statement -> apd ) {
statement -> apd -> associated_with = NULL;
}
/*
* release the implicit descriptors,
* this matches the tests in SQLAllocHandle
*/
if (( statement -> connection -> driver_act_ver == 3 &&
CHECK_SQLGETSTMTATTR( connection )) ||
CHECK_SQLGETSTMTATTRW( connection ))
{
if ( statement -> implicit_ard )
__release_desc( statement -> implicit_ard );
if ( statement -> implicit_apd )
__release_desc( statement -> implicit_apd );
if ( statement -> implicit_ird )
__release_desc( statement -> implicit_ird );
if ( statement -> implicit_ipd )
__release_desc( statement -> implicit_ipd );
}
statement -> connection -> statement_count --;
thread_release( SQL_HANDLE_STMT, statement );
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(connection->environment->sh,
UODBC_STATS_TYPE_HSTMT, (void *)-1);
#endif
__release_stmt( statement );
}
else
{
thread_release( SQL_HANDLE_STMT, statement );
}
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[SQL_SUCCESS]" );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
return function_return( IGNORE_THREAD, connection, ret );
}
break;
case SQL_HANDLE_DESC:
{
DMHDESC descriptor = (DMHDESC)handle;
DMHDBC connection;
SQLRETURN ret;
/*
* check descriptor
*/
if ( !__validate_desc( descriptor ))
{
return SQL_INVALID_HANDLE;
}
function_entry( descriptor );
connection = descriptor -> connection;
if ( log_info.log_flag )
{
sprintf( descriptor -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
descriptor -> msg );
}
if ( descriptor -> implicit )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY017" );
__post_internal_error( &descriptor -> error,
ERROR_HY017, NULL,
connection -> environment -> requested_version );
return function_return( IGNORE_THREAD, descriptor, SQL_ERROR );
}
thread_protect( SQL_HANDLE_DESC, descriptor );
if ( !CHECK_SQLFREEHANDLE( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &descriptor -> error,
ERROR_IM001, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
else
{
ret = SQLFREEHANDLE( connection,
handle_type,
descriptor -> driver_desc );
}
/*
* check status of statements associated with this descriptor
*/
if( __check_stmt_from_desc( descriptor, STATE_S8 ) ||
__check_stmt_from_desc( descriptor, STATE_S9 ) ||
__check_stmt_from_desc( descriptor, STATE_S10 ) ||
__check_stmt_from_desc( descriptor, STATE_S11 ) ||
__check_stmt_from_desc( descriptor, STATE_S12 )) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &descriptor -> error,
ERROR_HY010, NULL,
descriptor -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
thread_release( SQL_HANDLE_DESC, descriptor );
__release_desc( descriptor );
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[SQL_SUCCESS]" );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(connection->environment->sh,
UODBC_STATS_TYPE_HDESC, (void *)-1);
#endif
return function_return( IGNORE_THREAD, connection, SQL_SUCCESS );
}
break;
default:
/*
* there is nothing to report a error on
*/
return SQL_ERROR;
}
}
SQLRETURN SQLGetInfoW( SQLHDBC connection_handle,
SQLUSMALLINT info_type,
SQLPOINTER info_value,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret = SQL_SUCCESS;
int type;
char txt[ 30 ], *cptr;
SQLPOINTER *ptr;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
SQLUSMALLINT sval;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLGETINFOW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLGETINFOW( parent_connection,
connection_handle,
info_type,
info_value,
buffer_length,
string_length );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tInfo Type = %s\
\n\t\t\tInfo Value = %p\
\n\t\t\tBuffer Length = %d\
\n\t\t\tStrLen = %p",
connection,
__info_as_string( s1, info_type ),
info_value,
(int)buffer_length,
(void*)string_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLSetConnectOptionW( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLULEN value )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
SQLWCHAR buffer[ 512 ];
/*
* doesn't require a handle
*/
if ( option == SQL_ATTR_TRACE )
{
if ((SQLLEN) value != SQL_OPT_TRACE_OFF &&
(SQLLEN) value != SQL_OPT_TRACE_ON )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
if ( value == SQL_OPT_TRACE_OFF )
{
log_info.log_flag = 0;
}
else
{
log_info.log_flag = 1;
}
return SQL_SUCCESS;
}
else if ( option == SQL_ATTR_TRACEFILE )
{
if ( value )
{
if (((SQLWCHAR*)value)[ 0 ] == 0 )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
else
{
if ( log_info.log_file_name )
{
free( log_info.log_file_name );
}
log_info.log_file_name = unicode_to_ansi_alloc((SQLWCHAR *) value, SQL_NTS, connection );
}
}
else
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
return SQL_SUCCESS;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLSETCONNECTOPTIONW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLSETCONNECTOPTIONW( parent_connection,
connection_handle,
option,
value );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tOption = %s\
\n\t\t\tValue = %d",
connection,
__con_attr_as_string( s1, option ),
(int)value );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLGetConnectOptionW( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLPOINTER value )
{
DMHDBC connection = (DMHDBC)connection_handle;
int type = 0;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* doesn't require a handle
*/
if ( option == SQL_ATTR_TRACE )
{
if ( value )
{
if ( log_info.log_flag )
{
*((SQLINTEGER*)value) = SQL_OPT_TRACE_ON;
}
else
{
*((SQLINTEGER*)value) = SQL_OPT_TRACE_ON;
}
}
return SQL_SUCCESS;
}
else if ( option == SQL_ATTR_TRACEFILE )
{
SQLRETURN ret = SQL_SUCCESS;
if ( log_info.log_file_name )
{
ansi_to_unicode_copy( value, log_info.log_file_name, SQL_NTS, connection );
}
else
{
ansi_to_unicode_copy( value, "", SQL_NTS, connection );
}
return ret;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLGETCONNECTOPTIONW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLGETCONNECTOPTIONW( parent_connection,
connection,
option,
value );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tOption = %s\
\n\t\t\tValue = %p",
connection,
__con_attr_as_string( s1, option ),
value );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLSetConnectOption( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLULEN value )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* doesn't require a handle
*/
if ( option == SQL_ATTR_TRACE )
{
if ( value == SQL_OPT_TRACE_OFF )
{
log_info.log_flag = 0;
}
else
{
log_info.log_flag = 1;
}
return SQL_SUCCESS;
}
else if ( option == SQL_ATTR_TRACEFILE )
{
if ( value )
{
if ( log_info.log_file_name )
{
free( log_info.log_file_name );
}
log_info.log_file_name = (char*)strdup((char*)(void*) value );
}
return SQL_SUCCESS;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tOption = %s\
\n\t\t\tValue = %d",
connection,
__con_attr_as_string( s1, option ),
(int)value );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN __SQLAllocHandle( SQLSMALLINT handle_type,
SQLHANDLE input_handle,
SQLHANDLE *output_handle,
SQLINTEGER requested_version )
{
switch( handle_type )
{
case SQL_HANDLE_ENV:
{
DMHENV environment;
char pooling_string[ 128 ];
if ( !output_handle )
{
return SQL_ERROR;
}
if ( input_handle )
{
return SQL_INVALID_HANDLE;
}
/*
* check connection pooling attributes
*/
SQLGetPrivateProfileString( "ODBC", "Pooling", "0",
pooling_string, sizeof( pooling_string ),
"ODBCINST.INI" );
if ( pooling_string[ 0 ] == '1' ||
toupper( pooling_string[ 0 ] ) == 'Y' ||
( toupper( pooling_string[ 0 ] ) == 'O' &&
toupper( pooling_string[ 1 ] ) == 'N' ))
{
pooling_enabled = 1;
}
else
{
pooling_enabled = 0;
}
if ( !( environment = __alloc_env()))
{
*output_handle = SQL_NULL_HENV;
return SQL_ERROR;
}
*output_handle = (SQLHANDLE) environment;
/*
* setup environment state
*/
environment -> state = STATE_E1;
environment -> requested_version = requested_version;
environment -> sql_driver_count = -1;
/*
* if SQLAllocEnv is called then it's probable that
* the application wants ODBC2.X type behaviour
*
* In this case we don't need to set the version via
* SQLSetEnvAttr()
*
*/
environment -> connection_count = 0;
return SQL_SUCCESS;
}
break;
case SQL_HANDLE_DBC:
{
DMHENV environment = (DMHENV) input_handle;
DMHDBC connection;
if ( !__validate_env( environment ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
if ( output_handle )
*output_handle = SQL_NULL_HDBC;
thread_protect( SQL_HANDLE_ENV, environment );
function_entry(( void * ) input_handle );
if ( log_info.log_flag )
{
/*
* log that we are here
*/
sprintf( environment -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)input_handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
if ( !output_handle )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &environment -> error,
ERROR_HY009, NULL,
SQL_OV_ODBC3 );
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
/*
* check that a version has been requested
*/
if ( environment -> requested_version == 0 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &environment -> error,
ERROR_HY010, NULL,
SQL_OV_ODBC3 );
*output_handle = SQL_NULL_HDBC;
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
connection = __alloc_dbc();
if ( !connection )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &environment -> error,
ERROR_HY013, NULL,
environment -> requested_version );
*output_handle = SQL_NULL_HDBC;
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
/*
* sort out the states
*/
connection -> state = STATE_C2;
if ( environment -> state == STATE_E1 )
{
environment -> state = STATE_E2;
}
environment -> connection_count ++;
connection -> environment = environment;
connection -> cursors = SQL_CUR_DEFAULT;
connection -> login_timeout = SQL_LOGIN_TIMEOUT_DEFAULT;
connection -> login_timeout_set = 0;
connection -> auto_commit = 0;
connection -> auto_commit_set = 0;
connection -> auto_commit = 0;
connection -> auto_commit_set = 0;
connection -> async_enable = 0;
connection -> async_enable_set = 0;
connection -> auto_ipd = 0;
connection -> auto_ipd_set = 0;
connection -> connection_timeout = 0;
connection -> connection_timeout_set = 0;
connection -> metadata_id = 0;
connection -> metadata_id_set = 0;
connection -> packet_size = 0;
connection -> packet_size_set = 0;
connection -> quite_mode = 0;
connection -> quite_mode_set = 0;
connection -> txn_isolation = 0;
connection -> txn_isolation_set = 0;
strcpy( connection -> cli_year, "1995" );
connection -> env_attribute.count = 0;
connection -> env_attribute.list = NULL;
connection -> dbc_attribute.count = 0;
connection -> dbc_attribute.list = NULL;
connection -> stmt_attribute.count = 0;
connection -> stmt_attribute.list = NULL;
connection -> save_attr = NULL;
#ifdef HAVE_ICONV
connection -> iconv_cd_uc_to_ascii = (iconv_t)-1;
connection -> iconv_cd_ascii_to_uc = (iconv_t)-1;
strcpy( connection -> unicode_string, DEFAULT_ICONV_ENCODING );
#endif
*output_handle = (SQLHANDLE) connection;
if ( log_info.log_flag )
{
sprintf( environment -> msg,
"\n\t\tExit:[SQL_SUCCESS]\n\t\t\tOutput Handle = %p",
connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(environment->sh, UODBC_STATS_TYPE_HDBC,
(void *)1);
#endif
thread_release( SQL_HANDLE_ENV, environment );
return SQL_SUCCESS;
}
break;
case SQL_HANDLE_STMT:
{
SQLRETURN ret, ret1;
DMHDBC connection = (DMHDBC) input_handle;
DMHSTMT statement;
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
if ( output_handle )
*output_handle = SQL_NULL_HSTMT;
thread_protect( SQL_HANDLE_DBC, connection );
function_entry(( void * ) input_handle );
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)input_handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
if ( !output_handle )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection , SQL_ERROR );
}
if ( connection -> state == STATE_C1 ||
connection -> state == STATE_C2 ||
connection -> state == STATE_C3 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: 08003" );
__post_internal_error( &connection -> error,
ERROR_08003, NULL,
connection -> environment -> requested_version );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement = __alloc_stmt();
if ( !statement )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
/*
* pass the call on
*/
if ( requested_version >= SQL_OV_ODBC3 )
{
if ( CHECK_SQLALLOCHANDLE( connection ))
{
ret = SQLALLOCHANDLE( connection,
SQL_HANDLE_STMT,
connection -> driver_dbc,
&statement -> driver_stmt,
statement );
if ( !SQL_SUCCEEDED( ret ))
__release_stmt( statement );
}
else if ( CHECK_SQLALLOCSTMT( connection ))
{
ret = SQLALLOCSTMT( connection,
connection -> driver_dbc,
&statement -> driver_stmt,
statement );
if ( !SQL_SUCCEEDED( ret ))
__release_stmt( statement );
}
else
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM003" );
__post_internal_error( &connection -> error,
ERROR_IM003, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
}
else
{
if ( CHECK_SQLALLOCSTMT( connection ))
{
ret = SQLALLOCSTMT( connection,
connection -> driver_dbc,
&statement -> driver_stmt,
statement );
if ( !SQL_SUCCEEDED( ret ))
__release_stmt( statement );
}
else if ( CHECK_SQLALLOCHANDLE( connection ))
{
ret = SQLALLOCHANDLE( connection,
SQL_HANDLE_STMT,
connection -> driver_dbc,
&statement -> driver_stmt,
statement );
if ( !SQL_SUCCEEDED( ret ))
__release_stmt( statement );
}
else
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM003" );
__post_internal_error( &connection -> error,
ERROR_IM003, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
}
if ( SQL_SUCCEEDED( ret ))
{
/*
* sort out the states
*/
statement -> state = STATE_S1;
if ( connection -> state == STATE_C4 )
connection -> state = STATE_C5;
__register_stmt ( connection, statement );
*output_handle = (SQLHANDLE) statement;
statement -> metadata_id = SQL_FALSE;
/*
* if we are connected to a 3 driver then
* we need to get the 4 implicit descriptors
* so we know that they are valid
*/
if ( connection -> driver_act_ver == 3 &&
CHECK_SQLGETSTMTATTR( connection ))
{
DRV_SQLHDESC desc;
/*
* ARD
*/
ret1 = SQLGETSTMTATTR( connection,
statement -> driver_stmt,
SQL_ATTR_APP_ROW_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> ard = __alloc_desc();
if ( !statement -> ard )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_ard = statement -> ard;
statement -> ard -> implicit = 1;
statement -> ard -> associated_with = statement;
statement -> ard -> state = STATE_D1i;
statement -> ard -> driver_desc = desc;
statement -> ard -> connection = connection;
}
/*
* APD
*/
ret1 = SQLGETSTMTATTR( connection,
statement -> driver_stmt,
SQL_ATTR_APP_PARAM_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> apd = __alloc_desc();
if ( !statement -> apd )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_apd = statement -> apd;
statement -> apd -> implicit = 1;
statement -> apd -> associated_with = statement;
statement -> apd -> state = STATE_D1i;
statement -> apd -> driver_desc = desc;
statement -> apd -> connection = connection;
}
/*
* IRD
*/
ret1 = SQLGETSTMTATTR( connection,
statement -> driver_stmt,
SQL_ATTR_IMP_ROW_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> ird = __alloc_desc();
if ( !statement -> ird )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_ird = statement -> ird;
statement -> ird -> implicit = 1;
statement -> ird -> associated_with = statement;
statement -> ird -> state = STATE_D1i;
statement -> ird -> driver_desc = desc;
statement -> ird -> connection = connection;
}
/*
* IPD
*/
ret1 = SQLGETSTMTATTR( connection,
statement -> driver_stmt,
SQL_ATTR_IMP_PARAM_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> ipd = __alloc_desc();
if ( !statement -> ipd )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_ipd = statement -> ipd;
statement -> ipd -> implicit = 1;
statement -> ipd -> associated_with = statement;
statement -> ipd -> state = STATE_D1i;
statement -> ipd -> driver_desc = desc;
statement -> ipd -> connection = connection;
}
}
/* Driver may only have unicode API's */
else if ( CHECK_SQLGETSTMTATTRW( connection ))
{
DRV_SQLHDESC desc;
/*
* ARD
*/
ret1 = SQLGETSTMTATTRW( connection,
statement -> driver_stmt,
SQL_ATTR_APP_ROW_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> ard = __alloc_desc();
if ( !statement -> ard )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_ard = statement -> ard;
statement -> ard -> implicit = 1;
statement -> ard -> associated_with = statement;
statement -> ard -> state = STATE_D1i;
statement -> ard -> driver_desc = desc;
statement -> ard -> connection = connection;
}
/*
* APD
*/
ret1 = SQLGETSTMTATTRW( connection,
statement -> driver_stmt,
SQL_ATTR_APP_PARAM_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> apd = __alloc_desc();
if ( !statement -> apd )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_apd = statement -> apd;
statement -> apd -> implicit = 1;
statement -> apd -> associated_with = statement;
statement -> apd -> state = STATE_D1i;
statement -> apd -> driver_desc = desc;
statement -> apd -> connection = connection;
}
/*
* IRD
*/
ret1 = SQLGETSTMTATTRW( connection,
statement -> driver_stmt,
SQL_ATTR_IMP_ROW_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> ird = __alloc_desc();
if ( !statement -> ird )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
__release_stmt( statement );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_ird = statement -> ird;
statement -> ird -> implicit = 1;
statement -> ird -> associated_with = statement;
statement -> ird -> state = STATE_D1i;
statement -> ird -> driver_desc = desc;
statement -> ird -> connection = connection;
}
/*
* IPD
*/
ret1 = SQLGETSTMTATTRW( connection,
statement -> driver_stmt,
SQL_ATTR_IMP_PARAM_DESC,
&desc,
sizeof( desc ),
NULL );
if ( SQL_SUCCEEDED( ret1 ))
{
/*
* allocate one of our descriptors
* to wrap around this
*/
statement -> ipd = __alloc_desc();
if ( !statement -> ipd )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
*output_handle = SQL_NULL_HSTMT;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
statement -> implicit_ipd = statement -> ipd;
statement -> ipd -> implicit = 1;
statement -> ipd -> associated_with = statement;
statement -> ipd -> state = STATE_D1i;
statement -> ipd -> driver_desc = desc;
statement -> ipd -> connection = connection;
}
}
}
/*
* set any preset statement attributes
*/
if ( SQL_SUCCEEDED( ret ))
{
__set_attributes( statement, SQL_HANDLE_STMT );
}
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[SQL_SUCCESS]\n\t\t\tOutput Handle = %p",
statement );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(connection->environment->sh,
UODBC_STATS_TYPE_HSTMT, (void *)1);
#endif
return function_return( SQL_HANDLE_DBC, connection, ret );
}
break;
case SQL_HANDLE_DESC:
{
SQLRETURN ret;
DMHDBC connection = (DMHDBC) input_handle;
DMHDESC descriptor;
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
if ( output_handle )
*output_handle = SQL_NULL_HDESC;
thread_protect( SQL_HANDLE_DBC, connection );
function_entry(( void * ) input_handle );
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)input_handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
if ( !output_handle )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection , SQL_ERROR );
}
if ( connection -> state == STATE_C1 ||
connection -> state == STATE_C2 ||
connection -> state == STATE_C3 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: 08003" );
__post_internal_error( &connection -> error,
ERROR_08003, NULL,
connection -> environment -> requested_version );
*output_handle = SQL_NULL_HDESC;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
descriptor = __alloc_desc();
if ( !descriptor )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY013" );
__post_internal_error( &connection -> error,
ERROR_HY013, NULL,
connection -> environment -> requested_version );
*output_handle = SQL_NULL_HDESC;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
/*
* pass the call on
*/
if ( CHECK_SQLALLOCHANDLE( connection ))
{
ret = SQLALLOCHANDLE( connection,
SQL_HANDLE_DESC,
connection -> driver_dbc,
&descriptor -> driver_desc,
NULL );
if ( !SQL_SUCCEEDED( ret ))
__release_desc( descriptor );
}
else
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM003" );
__post_internal_error( &connection -> error,
ERROR_IM003, NULL,
connection -> environment -> requested_version );
__release_desc( descriptor );
*output_handle = SQL_NULL_HDESC;
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
if ( SQL_SUCCEEDED( ret ))
{
/*
* sort out the states
*/
descriptor -> state = STATE_D1e;
descriptor -> implicit = 0;
descriptor -> associated_with = NULL;
connection -> statement_count ++;
descriptor -> connection = connection;
*output_handle = (SQLHANDLE) descriptor;
}
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[SQL_SUCCESS]\n\t\t\tOutput Handle = %p",
descriptor );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(connection->environment->sh, UODBC_STATS_TYPE_HDESC,
(void *)1);
#endif
return function_return( SQL_HANDLE_DBC, connection, ret );
}
break;
default:
if ( __validate_env( (DMHENV) input_handle ))
{
DMHENV environment = (DMHENV) input_handle;
thread_protect( SQL_HANDLE_ENV, environment );
__post_internal_error( &environment -> error,
ERROR_HY092, NULL,
environment -> requested_version );
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
else if ( __validate_dbc( (DMHDBC) input_handle ))
{
DMHDBC connection = (DMHDBC) input_handle;
thread_protect( SQL_HANDLE_DBC, connection );
__post_internal_error( &connection -> error,
ERROR_HY092, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_ERROR;
}
break;
}
}
SQLRETURN SQLTransact( SQLHENV environment_handle,
SQLHDBC connection_handle,
SQLUSMALLINT completion_type )
{
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* check either handle first
*/
if ( connection_handle != SQL_NULL_HDBC )
{
DMHDBC connection = (DMHDBC) connection_handle;
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
}
if ( environment_handle != SQL_NULL_HENV )
{
DMHENV environment = (DMHENV) environment_handle;
if ( !__validate_env( environment ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
}
if ( connection_handle != SQL_NULL_HDBC )
{
DMHDBC connection = (DMHDBC) connection_handle;
SQLRETURN ret;
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tEnvironment = %p\
\n\t\t\tConnection = %p\
\n\t\t\tCompletion Type = %d",
(void*)environment_handle,
(void*)connection_handle,
(int)completion_type );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLSetConnectOption( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLULEN value )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* doesn't require a handle
*/
if ( option == SQL_ATTR_TRACE )
{
if ((SQLLEN) value != SQL_OPT_TRACE_OFF &&
(SQLLEN) value != SQL_OPT_TRACE_ON )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
if ( value == SQL_OPT_TRACE_OFF )
{
log_info.log_flag = 0;
}
else
{
log_info.log_flag = 1;
}
return SQL_SUCCESS;
}
else if ( option == SQL_ATTR_TRACEFILE )
{
if ( value )
{
if (((SQLCHAR*)value)[ 0 ] == '\0' )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
else
{
if ( log_info.log_file_name )
{
free( log_info.log_file_name );
}
log_info.log_file_name = strdup((char*) value );
}
}
else
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tOption = %s\
\n\t\t\tValue = %d",
connection,
__con_attr_as_string( s1, option ),
(int)value );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLCancelHandle( SQLSMALLINT HandleType, SQLHANDLE Handle )
{
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
switch ( HandleType ) {
case SQL_HANDLE_STMT:
{
DMHSTMT statement = (DMHSTMT) Handle;
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\n\t\t\tStatement = %p",
statement );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
#if defined( HAVE_LIBPTH ) || defined( HAVE_LIBPTHREAD ) || defined( HAVE_LIBTHREAD )
/*
* Allow this past the thread checks if the driver is at all thread safe, as SQLCancel can
* be called across threads
*/
if ( statement -> connection -> protection_level == 3 )
{
thread_protect( SQL_HANDLE_STMT, statement );
}
#endif
/*
* check states
*/
if ( !CHECK_SQLCANCEL( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
#if defined( HAVE_LIBPTH ) || defined( HAVE_LIBPTHREAD ) || defined( HAVE_LIBTHREAD )
if ( statement -> connection -> protection_level == 3 )
{
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else
{
return function_return( IGNORE_THREAD, statement, SQL_ERROR );
}
#else
return function_return( IGNORE_THREAD, statement, SQL_ERROR );
#endif
}
ret = SQLCANCEL( statement -> connection,
statement -> driver_stmt );
if ( SQL_SUCCEEDED( ret ))
{
if ( statement -> state == STATE_S8 ||
statement -> state == STATE_S9 ||
statement -> state == STATE_S10 ||
statement -> state == STATE_S13 ||
statement -> state == STATE_S14 ||
statement -> state == STATE_S10 )
{
if ( statement -> interupted_func == SQL_API_SQLEXECDIRECT )
{
statement -> state = STATE_S1;
}
else if ( statement -> interupted_func == SQL_API_SQLEXECUTE )
{
if ( statement -> hascols )
{
statement -> state = STATE_S3;
}
else
{
statement -> state = STATE_S2;
}
}
else if ( statement -> interupted_func ==
SQL_API_SQLBULKOPERATIONS )
{
if ( statement -> interupted_state == STATE_S5 ||
statement -> interupted_state == STATE_S6 ||
statement -> interupted_state == STATE_S7 )
{
statement -> state = STATE_S6;
statement -> eod = 0;
}
else
{
statement -> state = STATE_S6;
statement -> eod = 0;
}
}
else if ( statement -> interupted_func ==
SQL_API_SQLSETPOS )
{
if ( statement -> interupted_state == STATE_S5 ||
statement -> interupted_state == STATE_S6 )
{
statement -> state = STATE_S6;
statement -> eod = 0;
}
else if ( statement -> interupted_state == STATE_S7 )
{
statement -> state = STATE_S7;
}
}
}
else if ( statement -> state == STATE_S11 ||
statement -> state == STATE_S12 )
{
statement -> state = STATE_S12;
}
else { /* Same action as SQLFreeStmt( SQL_CLOSE ) */
if ( statement -> state == STATE_S4 )
{
if ( statement -> prepared )
statement -> state = STATE_S2;
else
statement -> state = STATE_S1;
}
else
{
if ( statement -> prepared )
statement -> state = STATE_S3;
else
statement -> state = STATE_S1;
}
statement -> hascols = 0;
}
}
if ( log_info.log_flag )
{
sprintf( statement -> msg,
"\n\t\tExit:[%s]",
__get_return_status( ret, s1 ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
#if defined( HAVE_LIBPTH ) || defined( HAVE_LIBPTHREAD ) || defined( HAVE_LIBTHREAD )
if ( statement -> connection -> protection_level == 3 )
{
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else
{
return function_return( IGNORE_THREAD, statement, ret );
}
#else
return function_return( IGNORE_THREAD, statement, ret );
#endif
}
break;
case SQL_HANDLE_DBC:
{
DMHDBC connection = (DMHDBC) Handle;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\n\t\t\tConnection = %p",
connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
/*
* check states
*/
if ( !CHECK_SQLCANCELHANDLE( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &connection -> error,
ERROR_IM001, NULL,
connection -> environment -> requested_version );
return function_return( IGNORE_THREAD, connection, SQL_ERROR );
}
ret = SQLCANCELHANDLE( connection, SQL_HANDLE_DBC,
connection -> driver_dbc );
/*
* The effect this has on connection states is not defined AFAIKS
*/
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[%s]",
__get_return_status( ret, s1 ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
return function_return( IGNORE_THREAD, connection, ret );
}
break;
default:
return SQL_INVALID_HANDLE;
break;
}
}
SQLRETURN SQLConnectW( SQLHDBC connection_handle,
SQLWCHAR *server_name,
SQLSMALLINT name_length1,
SQLWCHAR *user_name,
SQLSMALLINT name_length2,
SQLWCHAR *authentication,
SQLSMALLINT name_length3 )
{
DMHDBC connection = (DMHDBC)connection_handle;
int len, ret_from_connect;
SQLWCHAR dsn[ SQL_MAX_DSN_LENGTH + 1 ];
char lib_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char driver_name[ INI_MAX_PROPERTY_VALUE + 1 ];
SQLCHAR ansi_dsn[ SQL_MAX_DSN_LENGTH + 1 ];
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ], s3[ 100 + LOG_MESSAGE_LEN ], ansi_user[ SQL_MAX_DSN_LENGTH + 1 ], ansi_pwd[ SQL_MAX_DSN_LENGTH + 1 ];
int warnings;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLCONNECTW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLCONNECTW( parent_connection,
connection_handle,
server_name,
name_length1,
user_name,
name_length2,
authentication,
name_length3 );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tServer Name = %s\
\n\t\t\tUser Name = %s\
\n\t\t\tAuthentication = %s",
connection,
__wstring_with_length( s1, server_name, name_length1 ),
__wstring_with_length( s2, user_name, name_length2 ),
__wstring_with_length_pass( s3, authentication, name_length3 ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLSetConnectAttrW( SQLHDBC connection_handle,
SQLINTEGER attribute,
SQLPOINTER value,
SQLINTEGER string_length )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
SQLWCHAR buffer[ 512 ];
/*
* doesn't require a handle
*/
if ( attribute == SQL_ATTR_TRACE )
{
if ((SQLLEN) value != SQL_OPT_TRACE_OFF &&
(SQLLEN) value != SQL_OPT_TRACE_ON )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
if ((SQLLEN) value == SQL_OPT_TRACE_OFF )
{
char force_string[ 30 ];
SQLGetPrivateProfileString( "ODBC", "ForceTrace", "0",
force_string, sizeof( force_string ),
"ODBCINST.INI" );
if ( force_string[ 0 ] == '1' ||
toupper( force_string[ 0 ] ) == 'Y' ||
( toupper( force_string[ 0 ] ) == 'O' &&
toupper( force_string[ 1 ] ) == 'N' ))
{
if ( log_info.log_flag )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Application tried to turn logging off" );
}
}
else
{
if ( log_info.log_flag )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Application turning logging off" );
}
log_info.log_flag = 0;
}
}
else
{
log_info.log_flag = 1;
}
return SQL_SUCCESS;
}
else if ( attribute == SQL_ATTR_TRACEFILE )
{
if ( value )
{
if (((SQLWCHAR*)value)[ 0 ] == 0 )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
else
{
if ( log_info.log_file_name )
{
free( log_info.log_file_name );
}
log_info.log_file_name = unicode_to_ansi_alloc((SQLWCHAR *) value, SQL_NTS, connection );
}
}
else
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
return SQL_SUCCESS;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLSETCONNECTATTRW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLSETCONNECTATTRW( parent_connection,
connection_handle,
attribute,
value,
string_length );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tAttribute = %s\
\n\t\t\tValue = %p\
\n\t\t\tStrLen = %d",
connection,
__con_attr_as_string( s1, attribute ),
value,
(int)string_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLDriverConnectW(
SQLHDBC hdbc,
SQLHWND hwnd,
SQLWCHAR *conn_str_in,
SQLSMALLINT len_conn_str_in,
SQLWCHAR *conn_str_out,
SQLSMALLINT conn_str_out_max,
SQLSMALLINT *ptr_conn_str_out,
SQLUSMALLINT driver_completion )
{
DMHDBC connection = (DMHDBC)hdbc;
struct con_struct con_struct;
char *driver = NULL, *dsn = NULL;
char lib_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char driver_name[ INI_MAX_PROPERTY_VALUE + 1 ];
SQLRETURN ret_from_connect;
SQLCHAR s1[ 2048 ];
int warnings;
/*
* check connection
*/
strcpy( driver_name, "" );
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLDRIVERCONNECTW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLDRIVERCONNECTW( parent_connection,
connection,
hwnd,
conn_str_in,
len_conn_str_in,
conn_str_out,
conn_str_out_max,
ptr_conn_str_out,
driver_completion );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tWindow Hdl = %p\
\n\t\t\tStr In = %s\
\n\t\t\tStr Out = %p\
\n\t\t\tStr Out Max = %d\
\n\t\t\tStr Out Ptr = %p\
\n\t\t\tCompletion = %d",
connection,
hwnd,
__wstring_with_length_hide_pwd( s1, conn_str_in,
len_conn_str_in ),
conn_str_out,
conn_str_out_max,
ptr_conn_str_out,
driver_completion );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLBrowseConnectW(
SQLHDBC hdbc,
SQLWCHAR *conn_str_in,
SQLSMALLINT len_conn_str_in,
SQLWCHAR *conn_str_out,
SQLSMALLINT conn_str_out_max,
SQLSMALLINT *ptr_conn_str_out )
{
DMHDBC connection = (DMHDBC) hdbc;
struct con_struct con_struct;
char *driver, *dsn;
char lib_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char driver_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char in_str[ BUFFER_LEN ];
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ];
SQLWCHAR *uc_in_str;
int warnings;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLBROWSECONNECTW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLBROWSECONNECTW( parent_connection,
connection,
conn_str_in,
len_conn_str_in,
conn_str_out,
conn_str_out_max,
ptr_conn_str_out );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tStr In = %s\
\n\t\t\tStr Out = %s\
\n\t\t\tPtr Conn Str Out = %p",
connection,
__wstring_with_length( s1, conn_str_in, len_conn_str_in ),
__wstring_with_length( s2, conn_str_out, conn_str_out_max ),
ptr_conn_str_out );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLGetConnectAttrW( SQLHDBC connection_handle,
SQLINTEGER attribute,
SQLPOINTER value,
SQLINTEGER buffer_length,
SQLINTEGER *string_length )
{
DMHDBC connection = (DMHDBC)connection_handle;
int type = 0;
char *ptr;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* doesn't require a handle
*/
if ( attribute == SQL_ATTR_TRACE )
{
if ( value )
{
if ( log_info.log_flag )
{
*((SQLINTEGER*)value) = SQL_OPT_TRACE_ON;
}
else
{
*((SQLINTEGER*)value) = SQL_OPT_TRACE_ON;
}
}
return SQL_SUCCESS;
}
else if ( attribute == SQL_ATTR_TRACEFILE )
{
SQLRETURN ret = SQL_SUCCESS;
ptr = log_info.log_file_name;
if ( ptr )
{
int len = strlen( ptr ) * sizeof( SQLWCHAR );
if ( string_length )
{
*string_length = len;
}
if ( value )
{
if ( buffer_length > len + sizeof( SQLWCHAR ))
{
ansi_to_unicode_copy( value, ptr, SQL_NTS, connection );
}
else
{
ansi_to_unicode_copy( value, ptr, buffer_length - 1, connection );
((SQLWCHAR*)value)[( buffer_length - 1 ) / sizeof( SQLWCHAR )] = 0;
ret = SQL_SUCCESS_WITH_INFO;
}
}
}
else
{
if ( string_length )
{
*string_length = 0;
}
if ( value )
{
if ( buffer_length > 0 )
{
((SQLWCHAR*)value)[ 0 ] = 0;
}
else
{
ret = SQL_SUCCESS_WITH_INFO;
}
}
}
return ret;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tAttribute = %s\
\n\t\t\tValue = %p\
\n\t\t\tBuffer Length = %d\
\n\t\t\tStrLen = %p",
connection,
__con_attr_as_string( s1, attribute ),
value,
(int)buffer_length,
(void*)string_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLDriverConnect(
SQLHDBC hdbc,
SQLHWND hwnd,
SQLCHAR *conn_str_in,
SQLSMALLINT len_conn_str_in,
SQLCHAR *conn_str_out,
SQLSMALLINT conn_str_out_max,
SQLSMALLINT *ptr_conn_str_out,
SQLUSMALLINT driver_completion )
{
DMHDBC connection = (DMHDBC)hdbc;
struct con_struct con_struct;
char *driver, *dsn = NULL, *filedsn, *tsavefile, savefile[ INI_MAX_PROPERTY_VALUE + 1 ];
char lib_name[ INI_MAX_PROPERTY_VALUE + 1 ];
char driver_name[ INI_MAX_PROPERTY_VALUE + 1 ];
SQLRETURN ret_from_connect;
SQLCHAR s1[ 2048 ];
SQLCHAR local_conn_str_in[ 2048 ];
SQLCHAR local_out_conection[ 2048 ];
char save_filedsn[ 128 ];
int warnings;
/*
* check connection
*/
strcpy( driver_name, "" );
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
/*
* replace this if not set for use by SAVEFILE
*/
if ( !conn_str_out )
{
conn_str_out = local_out_conection;
conn_str_out_max = sizeof( local_out_conection );
}
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tWindow Hdl = %p\
\n\t\t\tStr In = %s\
\n\t\t\tStr Out = %p\
\n\t\t\tStr Out Max = %d\
\n\t\t\tStr Out Ptr = %p\
\n\t\t\tCompletion = %d",
connection,
hwnd,
__string_with_length_hide_pwd( s1, conn_str_in,
len_conn_str_in ),
conn_str_out,
conn_str_out_max,
ptr_conn_str_out,
driver_completion );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
