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 SQLSpecialColumnsW( SQLHSTMT statement_handle,
SQLUSMALLINT identifier_type,
SQLWCHAR *catalog_name,
SQLSMALLINT name_length1,
SQLWCHAR *schema_name,
SQLSMALLINT name_length2,
SQLWCHAR *table_name,
SQLSMALLINT name_length3,
SQLUSMALLINT scope,
SQLUSMALLINT nullable )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ], s3[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLSPECIALCOLUMNSW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLSPECIALCOLUMNSW( parent_statement -> connection,
statement_handle,
identifier_type,
catalog_name,
name_length1,
schema_name,
name_length2,
table_name,
name_length3,
scope,
nullable );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tIdentifier Type = %d\
\n\t\t\tCatalog Name = %s\
\n\t\t\tSchema Name = %s\
\n\t\t\tTable Name = %s\
\n\t\t\tScope = %d\
\n\t\t\tNullable = %d",
statement,
identifier_type,
__wstring_with_length( s1, catalog_name, name_length1 ),
__wstring_with_length( s2, schema_name, name_length2 ),
__wstring_with_length( s3, table_name, name_length3 ),
scope,
nullable );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
SQLRETURN SQLGetTypeInfoW( SQLHSTMT statement_handle,
SQLSMALLINT data_type )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLGETTYPEINFOW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLGETTYPEINFOW( parent_statement -> connection,
statement_handle,
data_type );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tData Type = %s",
statement,
__type_as_string( s1, data_type ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
SQLRETURN SQLSetStmtOptionW( SQLHSTMT statement_handle,
SQLUSMALLINT option,
SQLULEN value )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
SQLWCHAR buffer[ 512 ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLSETSTMTOPTIONW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLSETSTMTOPTIONW( parent_statement -> connection,
statement_handle,
option,
value );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tOption = %s\
\n\t\t\tValue = %d",
statement,
__stmt_attr_as_string( s1, option ),
(int)value );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
SQLRETURN SQLExecDirectW( SQLHSTMT statement_handle,
SQLWCHAR *statement_text,
SQLINTEGER text_length )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR *s1;
SQLCHAR s2[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLEXECDIRECTW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLEXECDIRECTW( parent_statement -> connection,
statement,
statement_text,
text_length );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
/*
* allocate some space for the buffer
*/
if ( statement_text && text_length == SQL_NTS )
{
s1 = malloc( wide_strlen( statement_text ) * 2 + LOG_MESSAGE_LEN * 2 );
}
else if ( statement_text )
{
s1 = malloc( text_length + LOG_MESSAGE_LEN * 2 );
}
else
{
s1 = malloc( LOG_MESSAGE_LEN * 2 );
}
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tSQL = %s",
statement,
__wstring_with_length( s1, statement_text, text_length ));
free( s1 );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
thread_protect( SQL_HANDLE_STMT, statement );
if ( !statement_text )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &statement -> error,
ERROR_HY009, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
if ( text_length <= 0 && text_length != SQL_NTS )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY090" );
__post_internal_error( &statement -> error,
ERROR_HY090, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
/*
* check states
*/
#ifdef NR_PROBE
if ( statement -> state == STATE_S5 ||
statement -> state == STATE_S6 ||
statement -> state == STATE_S7 )
#else
if (( statement -> state == STATE_S6 && statement -> eod == 0 ) ||
statement -> state == STATE_S7 )
#endif
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: 24000" );
__post_internal_error( &statement -> error,
ERROR_24000, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else if ( statement -> state == STATE_S8 ||
statement -> state == STATE_S9 ||
statement -> state == STATE_S10 )
{
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 ( statement -> state == STATE_S11 ||
statement -> state == STATE_S12 )
{
if ( statement -> interupted_func != SQL_API_SQLEXECDIRECT )
{
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 ( statement -> connection -> unicode_driver ||
CHECK_SQLEXECDIRECTW( statement -> connection ))
{
#ifdef NR_PROBE
if ( !CHECK_SQLEXECDIRECTW( statement -> connection ) ||
!CHECK_SQLNUMRESULTCOLS( 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
if ( !CHECK_SQLEXECDIRECTW( 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 );
}
#endif
ret = SQLEXECDIRECTW( statement -> connection,
statement -> driver_stmt,
statement_text,
text_length );
}
else
{
SQLCHAR *as1 = NULL;
int clen;
#ifdef NR_PROBE
if ( !CHECK_SQLEXECDIRECT( statement -> connection ) ||
!CHECK_SQLNUMRESULTCOLS( 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
if ( !CHECK_SQLEXECDIRECT( 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 );
}
#endif
as1 = (SQLCHAR*) unicode_to_ansi_alloc( statement_text, text_length, statement -> connection, &clen );
text_length = clen;
ret = SQLEXECDIRECT( statement -> connection,
statement -> driver_stmt,
as1,
text_length );
if ( as1 )
free( as1 );
}
if ( SQL_SUCCEEDED( ret ))
{
#ifdef NR_PROBE
SQLRETURN local_ret;
/*
* grab any errors
*/
if ( ret == SQL_SUCCESS_WITH_INFO )
{
function_return_ex( IGNORE_THREAD, statement, ret, TRUE );
}
local_ret = SQLNUMRESULTCOLS( statement -> connection,
statement -> driver_stmt, &statement -> numcols );
if ( statement -> numcols > 0 )
{
statement -> state = STATE_S5;
}
else
{
statement -> state = STATE_S4;
}
#else
/*
* We don't know for sure
*/
statement -> hascols = 1;
statement -> state = STATE_S5;
#endif
statement -> prepared = 0;
/*
* there is a issue here with transactions, but for the
* moment
*
statement -> connection -> state = STATE_C6;
*/
}
else if ( ret == SQL_NEED_DATA )
{
statement -> interupted_func = SQL_API_SQLEXECDIRECT;
statement -> interupted_state = statement -> state;
statement -> state = STATE_S8;
statement -> prepared = 0;
}
else if ( ret == SQL_PARAM_DATA_AVAILABLE )
{
statement -> interupted_func = SQL_API_SQLEXECDIRECT;
statement -> interupted_state = statement -> state;
statement -> state = STATE_S13;
}
else if ( ret == SQL_STILL_EXECUTING )
{
statement -> interupted_func = SQL_API_SQLEXECDIRECT;
if ( statement -> state != STATE_S11 &&
statement -> state != STATE_S12 )
statement -> state = STATE_S11;
statement -> prepared = 0;
}
else
{
statement -> state = STATE_S1;
}
if ( log_info.log_flag )
{
sprintf( statement -> msg,
"\n\t\tExit:[%s]",
__get_return_status( ret, s2 ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
return function_return( SQL_HANDLE_STMT, statement, ret );
}
SQLRETURN SQLGetDescRecW( SQLHDESC descriptor_handle,
SQLSMALLINT rec_number,
SQLWCHAR *name,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length,
SQLSMALLINT *type,
SQLSMALLINT *sub_type,
SQLLEN *length,
SQLSMALLINT *precision,
SQLSMALLINT *scale,
SQLSMALLINT *nullable )
{
/*
* not quite sure how the descriptor can be
* allocated to a statement, all the documentation talks
* about state transitions on statement states, but the
* descriptor may be allocated with more than one statement
* at one time. Which one should I check ?
*/
DMHDESC descriptor = (DMHDESC) descriptor_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ], s3[ 100 + LOG_MESSAGE_LEN ], s4[ 100 + LOG_MESSAGE_LEN ];
SQLCHAR s5[ 100 + LOG_MESSAGE_LEN ], s6[ 100 + LOG_MESSAGE_LEN ], s7[ 100 + LOG_MESSAGE_LEN ];
SQLCHAR s8[ 100 + LOG_MESSAGE_LEN ];
/*
* check descriptor
*/
if ( !__validate_desc( descriptor ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDESC parent_desc;
parent_desc = find_parent_handle( descriptor, SQL_HANDLE_DESC );
if ( parent_desc ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLGETDESCRECW( parent_desc -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLGETDESCRECW( parent_desc -> connection,
descriptor,
rec_number,
name,
buffer_length,
string_length,
type,
sub_type,
length,
precision,
scale,
nullable );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( descriptor );
if ( log_info.log_flag )
{
sprintf( descriptor -> msg, "\n\t\tEntry:\
\n\t\t\tDescriptor = %p\
\n\t\t\tRec Number = %d\
\n\t\t\tName = %p\
\n\t\t\tBuffer length = %d\
\n\t\t\tString Length = %p\
\n\t\t\tType = %p\
\n\t\t\tSub Type = %p\
\n\t\t\tLength = %p\
\n\t\t\tPrecision = %p\
\n\t\t\tScale = %p\
\n\t\t\tNullable = %p",
descriptor,
rec_number,
name,
buffer_length,
string_length,
type,
sub_type,
length,
precision,
scale,
nullable );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
descriptor -> msg );
}
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 SQLPrimaryKeysW(
SQLHSTMT statement_handle,
SQLWCHAR *sz_catalog_name,
SQLSMALLINT cb_catalog_name,
SQLWCHAR *sz_schema_name,
SQLSMALLINT cb_schema_name,
SQLWCHAR *sz_table_name,
SQLSMALLINT cb_table_name )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ], s3[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLPRIMARYKEYSW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLPRIMARYKEYSW( parent_statement -> connection,
statement_handle,
sz_catalog_name,
cb_catalog_name,
sz_schema_name,
cb_schema_name,
sz_table_name,
cb_table_name );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tCatalog Name = %s\
\n\t\t\tSchema Name = %s\
\n\t\t\tTable Type = %s",
statement,
__wstring_with_length( s1, sz_catalog_name, cb_catalog_name ),
__wstring_with_length( s2, sz_schema_name, cb_schema_name ),
__wstring_with_length( s3, sz_table_name, cb_table_name ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> 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 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 SQLDescribeColW( SQLHSTMT statement_handle,
SQLUSMALLINT column_number,
SQLWCHAR *column_name,
SQLSMALLINT buffer_length,
SQLSMALLINT *name_length,
SQLSMALLINT *data_type,
SQLULEN *column_size,
SQLSMALLINT *decimal_digits,
SQLSMALLINT *nullable )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ], s3[ 100 + LOG_MESSAGE_LEN ], s4[ 100 + LOG_MESSAGE_LEN ];
SQLCHAR s5[ 100 + LOG_MESSAGE_LEN ];
SQLCHAR s6[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLDESCRIBECOLW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLDESCRIBECOLW( parent_statement -> connection,
statement_handle,
column_number,
column_name,
buffer_length,
name_length,
data_type,
column_size,
decimal_digits,
nullable );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tColumn Number = %d\
\n\t\t\tColumn Name = %p\
\n\t\t\tBuffer Length = %d\
\n\t\t\tName Length = %p\
\n\t\t\tData Type = %p\
\n\t\t\tColumn Size = %p\
\n\t\t\tDecimal Digits = %p\
\n\t\t\tNullable = %p",
statement,
column_number,
column_name,
buffer_length,
name_length,
data_type,
column_size,
decimal_digits,
nullable );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> 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 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 SQLGetStmtAttrW( SQLHSTMT statement_handle,
SQLINTEGER attribute,
SQLPOINTER value,
SQLINTEGER buffer_length,
SQLINTEGER *string_length )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLGETSTMTATTRW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLGETSTMTATTRW( parent_statement -> connection,
statement_handle,
attribute,
value,
buffer_length,
string_length );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tAttribute = %s\
\n\t\t\tValue = %p\
\n\t\t\tBuffer Length = %d\
\n\t\t\tStrLen = %p",
statement,
__stmt_attr_as_string( s1, attribute ),
value,
(int)buffer_length,
(void*)string_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
