static void test_SQLWritePrivateProfileString(void)
{
static const WCHAR odbc_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','O','D','B','C','.','I','N','I','\\','w','i','n','e','o','d','b','c',0};
static const WCHAR abcd_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','a','b','c','d','.','I','N','I','\\','w','i','n','e','o','d','b','c',0};
static const WCHAR abcdini_key[] = {'S','o','f','t','w','a','r','e','\\','O','D','B','C','\\','a','b','c','d','.','I','N','I',0 };
BOOL ret;
LONG reg_ret;
DWORD error_code;
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", "");
ok(!ret, "SQLWritePrivateProfileString passed\n");
SQLInstallerErrorW(1, &error_code, NULL, 0, NULL);
ok(error_code == ODBC_ERROR_INVALID_STR, "SQLInstallerErrorW ret: %d\n", error_code);
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", NULL);
ok(!ret, "SQLWritePrivateProfileString passed\n");
SQLInstallerErrorW(1, &error_code, NULL, 0, NULL);
ok(error_code == ODBC_ERROR_INVALID_STR, "SQLInstallerErrorW ret: %d\n", error_code);
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", "odbc.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
if(ret)
{
HKEY hkey;
reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, odbc_key, 0, KEY_READ, &hkey);
ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n");
if(reg_ret == ERROR_SUCCESS)
{
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, odbc_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
RegCloseKey(hkey);
}
}
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
if(ret)
{
HKEY hkey;
reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, abcd_key, 0, KEY_READ, &hkey);
ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n");
if(reg_ret == ERROR_SUCCESS)
{
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcd_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
RegCloseKey(hkey);
}
/* Cleanup key */
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcdini_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
}
}
pascal OSStatus
filedsn_setdir_clicked (EventHandlerCallRef inHandlerRef,
EventRef inEvent, void *inUserData)
{
TDSNCHOOSER *choose_t = (TDSNCHOOSER *) inUserData;
char msg[4096];
if (!choose_t)
return noErr;
/* confirm setting a directory */
snprintf (msg, sizeof (msg),
"Are you sure that you want to make '%s' the default file DSN directory?",
choose_t->curr_dir);
if (!create_confirm (choose_t->mainwnd, NULL, msg))
return noErr;
/* write FileDSNPath value */
if (!SQLWritePrivateProfileString ("ODBC", "FileDSNPath",
choose_t->curr_dir, "odbcinst.ini"))
{
create_error (choose_t->mainwnd, NULL,
"Error setting default file DSN directory", NULL);
return noErr;
}
return noErr;
}
BOOL INSTAPI
SQLSetKeywordValue (LPCSTR lpszSection,
LPCSTR lpszEntry, LPSTR lpszString, int cbString)
{
return SQLWritePrivateProfileString (lpszSection,
lpszEntry, lpszString, "odbc.ini");
}
BOOL INSTAPI SQLWritePrivateProfileStringW(LPCWSTR lpszSection,
LPCWSTR lpszEntry,
LPCWSTR lpszString,
LPCWSTR lpszFilename)
{
char *sect;
char *entry;
char *string;
char *file;
BOOL ret;
sect = lpszSection ? _single_string_alloc_and_copy( lpszSection ) : (char*)NULL;
entry = lpszEntry ? _single_string_alloc_and_copy( lpszEntry ) : (char*)NULL;
string = lpszString ? _single_string_alloc_and_copy( lpszString ) : (char*)NULL;
file = lpszFilename ? _single_string_alloc_and_copy( lpszFilename ) : (char*)NULL;
ret = SQLWritePrivateProfileString( sect, entry, string, file );
if ( sect )
free( sect );
if ( entry )
free( entry );
if ( string )
free( string );
if ( file )
free( file );
return ret;
}
void COdbcDS::UpdateDS(const char* pNewDriverName, int iType, CDSList& DSList)
{
int count = DSList.getCount();
int length = sizeof(PRIV_PROFILE) / MAXKEYLEN;
char* DSName = NULL;
char* DSAttVal = NULL;
// Set the config mode to the desired type.
UWORD oldMode, newMode;
if (iType == COdbcDS::DS_TYPE_SYS)
{
newMode = ODBC_SYSTEM_DSN;
}
else
{
newMode = ODBC_USER_DSN;
}
SQLGetConfigMode(&oldMode);
SQLSetConfigMode(newMode);
for (int i = 0; i < count; i++)
{
DSName = DSList.getAt(i);
// Remove the old data sources
SQLRemoveDSNFromIni(DSName);
// Add the new data source
if (TRUE != SQLWriteDSNToIni(DSName, pNewDriverName))
{
// Restore old config mode.
SQLSetConfigMode(oldMode);
throw -1;
}
// Configure the new data source using previous information.
for (int index = 0; index < length; index++)
{
DSAttVal = DSList.getAttribValue(i, PRIV_PROFILE[index]);
if (TRUE != SQLWritePrivateProfileString(DSName,
PRIV_PROFILE[index], DSAttVal, ODBC_INI))
{
// Restore old config mode.
SQLSetConfigMode(oldMode);
throw -2;
}
delete [] DSAttVal;
}
delete [] DSName;
}
// Restore old config mode.
SQLSetConfigMode(oldMode);
}
void
TKVList::WriteODBCIni (LPCTSTR section, LPCTSTR names)
{
LPCTSTR key;
for (key = names; *key; key += _tcslen (key) + 1)
{
SQLWritePrivateProfileString (section,
key, Value (key), _T("odbc.ini"));
}
}
/*--------
* SetDriverAttributes
*
* Description: Write driver information attributes to ODBCINST.INI
* Input : lpszDriver - The driver name
* Output : TRUE if successful, FALSE otherwise
*--------
*/
static BOOL
SetDriverAttributes(LPCSTR lpszDriver, DWORD *pErrorCode, LPSTR message, WORD cbMessage)
{
BOOL ret = FALSE;
char ver_string[8];
/* Validate arguments */
if (!lpszDriver || !lpszDriver[0])
{
if (pErrorCode)
*pErrorCode = ODBC_ERROR_INVALID_NAME;
strncpy_null(message, "Driver name not specified", cbMessage);
return FALSE;
}
if (!SQLWritePrivateProfileString(lpszDriver, "APILevel", "1", ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "ConnectFunctions", "YYN", ODBCINST_INI))
goto cleanup;
snprintf(ver_string, sizeof(ver_string), "%02x.%02x",
ODBCVER / 256,
ODBCVER % 256);
if (!SQLWritePrivateProfileString(lpszDriver, "DriverODBCVer",
ver_string,
ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "FileUsage", "0", ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "SQLLevel", "1", ODBCINST_INI))
goto cleanup;
ret = TRUE;
cleanup:
if (!ret)
{
if (pErrorCode)
*pErrorCode = ODBC_ERROR_REQUEST_FAILED;
strncpy_null(message, "Failed to WritePrivateProfileString", cbMessage);
}
return ret;
}
/*--------
* SetDriverAttributes
*
* Description: Write driver information attributes to ODBCINST.INI
* Input : lpszDriver - The driver name
* Output : TRUE if successful, FALSE otherwise
*--------
*/
static BOOL
SetDriverAttributes(LPCSTR lpszDriver, DWORD *pErrorCode, LPSTR message, WORD cbMessage)
{
BOOL ret = FALSE;
/* Validate arguments */
if (!lpszDriver || !lpszDriver[0])
{
if (pErrorCode)
*pErrorCode = ODBC_ERROR_INVALID_NAME;
strncpy_null(message, "Driver name not specified", cbMessage);
return FALSE;
}
if (!SQLWritePrivateProfileString(lpszDriver, "APILevel", "1", ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "ConnectFunctions", "YYN", ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "DriverODBCVer",
#ifdef UNICODE_SUPPORT
"03.51",
#else
"03.00",
#endif
ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "FileUsage", "0", ODBCINST_INI))
goto cleanup;
if (!SQLWritePrivateProfileString(lpszDriver, "SQLLevel", "1", ODBCINST_INI))
goto cleanup;
ret = TRUE;
cleanup:
if (!ret)
{
if (pErrorCode)
*pErrorCode = ODBC_ERROR_REQUEST_FAILED;
strncpy_null(message, "Failed to WritePrivateProfileString", cbMessage);
}
return ret;
}
void CTracing::apply()
{
char szTracing[10];
char szForce[10];
char szTracingFile[FILENAME_MAX+1];
char szPooling[10];
if ( pTracing->isChecked() )
strcpy( szTracing, "Yes" );
else
strcpy( szTracing, "No" );
if ( pForce->isChecked() )
strcpy( szForce, "Yes" );
else
strcpy( szForce, "No" );
if ( pPooling->isChecked() )
strcpy( szPooling, "Yes" );
else
strcpy( szPooling, "No" );
if ( !SQLWritePrivateProfileString( "ODBC", "Trace", szTracing, "odbcinst.ini" ) )
{
QMessageBox::warning( this, "ODBC Config", "Could not apply. Ensure that you are operating as 'root' user." );
return;
}
else
{
strncpy( szTracingFile, pTraceFile->pLineEdit->text().ascii(), FILENAME_MAX );
SQLWritePrivateProfileString( "ODBC", "TraceFile", szTracingFile, "odbcinst.ini" );
SQLWritePrivateProfileString( "ODBC", "ForceTrace", szForce, "odbcinst.ini" );
SQLWritePrivateProfileString( "ODBC", "Pooling", szPooling, "odbcinst.ini" );
}
if ( pTracing->isChecked() )
QMessageBox::information( this, "ODBC Config", "Tracing is turned on.\n\nTracing uses up a lot of disk space as all calls are logged. Ensure that you turn it off as soon as possible." );
if ( pPooling->isChecked() )
QMessageBox::information( this, "ODBC Config", "Connection Pooling is turned on.\n\nMost likely you are intending to use ODBC from a server (such as Apache). If you do not need it; turn it off... it may pose a small security risk." );
}
BOOL INSTAPI
SQLWritePrivateProfileStringW (LPCWSTR lpszSection, LPCWSTR lpszEntry,
LPCWSTR lpszString, LPCWSTR lpszFilename)
{
char *_section_u8 = NULL;
char *_entry_u8 = NULL;
char *_string_u8 = NULL;
char *_filename_u8 = NULL;
BOOL retcode = FALSE;
_section_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszSection, SQL_NTS);
if (_section_u8 == NULL && lpszSection)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_entry_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszEntry, SQL_NTS);
if (_entry_u8 == NULL && lpszEntry)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_string_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszString, SQL_NTS);
if (_string_u8 == NULL && lpszString)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
_filename_u8 = (char *) dm_SQL_WtoU8 ((SQLWCHAR *) lpszFilename, SQL_NTS);
if (_filename_u8 == NULL && lpszFilename)
{
PUSH_ERROR (ODBC_ERROR_OUT_OF_MEM);
goto done;
}
retcode =
SQLWritePrivateProfileString (_section_u8, _entry_u8, _string_u8,
_filename_u8);
done:
MEM_FREE (_section_u8);
MEM_FREE (_entry_u8);
MEM_FREE (_string_u8);
MEM_FREE (_filename_u8);
return retcode;
}
/* This is for datasource based options only */
void
writeDSNinfo(const ConnInfo *ci)
{
const char *DSN = ci->dsn;
char encoded_item[LARGE_REGISTRY_LEN],
temp[SMALL_REGISTRY_LEN];
SQLWritePrivateProfileString(DSN,
INI_KDESC,
ci->desc,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_DATABASE,
ci->database,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SERVER,
ci->server,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_PORT,
ci->port,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_USERNAME,
ci->username,
ODBC_INI);
SQLWritePrivateProfileString(DSN, INI_UID, ci->username, ODBC_INI);
encode(ci->password, encoded_item, sizeof(encoded_item));
SQLWritePrivateProfileString(DSN,
INI_PASSWORD,
encoded_item,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_READONLY,
ci->onlyread,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SHOWOIDCOLUMN,
ci->show_oid_column,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_FAKEOIDINDEX,
ci->fake_oid_index,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_ROWVERSIONING,
ci->row_versioning,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SHOWSYSTEMTABLES,
ci->show_system_tables,
ODBC_INI);
if (ci->rollback_on_error >= 0)
sprintf(temp, "%s-%d", ci->protocol, ci->rollback_on_error);
else
strncpy_null(temp, ci->protocol, sizeof(temp));
SQLWritePrivateProfileString(DSN,
INI_PROTOCOL,
temp,
ODBC_INI);
encode(ci->conn_settings, encoded_item, sizeof(encoded_item));
SQLWritePrivateProfileString(DSN,
INI_CONNSETTINGS,
encoded_item,
ODBC_INI);
sprintf(temp, "%d", ci->disallow_premature);
SQLWritePrivateProfileString(DSN,
INI_DISALLOWPREMATURE,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->allow_keyset);
SQLWritePrivateProfileString(DSN,
INI_UPDATABLECURSORS,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->lf_conversion);
SQLWritePrivateProfileString(DSN,
INI_LFCONVERSION,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->true_is_minus1);
SQLWritePrivateProfileString(DSN,
INI_TRUEISMINUS1,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->int8_as);
SQLWritePrivateProfileString(DSN,
INI_INT8AS,
temp,
ODBC_INI);
sprintf(temp, "%x", getExtraOptions(ci));
SQLWritePrivateProfileString(DSN,
INI_EXTRAOPTIONS,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->bytea_as_longvarbinary);
SQLWritePrivateProfileString(DSN,
INI_BYTEAASLONGVARBINARY,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->use_server_side_prepare);
SQLWritePrivateProfileString(DSN,
INI_USESERVERSIDEPREPARE,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->lower_case_identifier);
SQLWritePrivateProfileString(DSN,
INI_LOWERCASEIDENTIFIER,
temp,
ODBC_INI);
sprintf(temp, "%d", ci->greenplum);
SQLWritePrivateProfileString(DSN,
INI_GREENPLUM,
temp,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SSLMODE,
ci->sslmode,
ODBC_INI);
sprintf(temp, "%d", ci->gssauth_use_gssapi);
SQLWritePrivateProfileString(DSN,
INI_GSSAUTHUSEGSSAPI,
temp,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SSLMODE,
ci->sslmode,
ODBC_INI);
#ifdef _HANDLE_ENLIST_IN_DTC_
sprintf(temp, "%d", ci->xa_opt);
SQLWritePrivateProfileString(DSN, INI_XAOPT, temp, ODBC_INI);
#endif /* _HANDLE_ENLIST_IN_DTC_ */
}
int
setLogDir(const char *dir)
{
return SQLWritePrivateProfileString(DBMS_NAME, INI_LOGDIR, dir, ODBCINST_INI);
}
/* This is for datasource based options only */
void
writeDSNinfo(ConnInfo *ci)
{
char *DSN = ci->dsn;
char encoded_conn_settings[LARGE_REGISTRY_LEN];
encode(ci->conn_settings, encoded_conn_settings);
SQLWritePrivateProfileString(DSN,
INI_KDESC,
ci->desc,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_DATABASE,
ci->database,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SERVER,
ci->server,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_PORT,
ci->port,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_UDS,
ci->uds,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_USER,
ci->username,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_PASSWORD,
ci->password,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_READONLY,
ci->readonly,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SHOWOIDCOLUMN,
ci->show_oid_column,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_FAKEOIDINDEX,
ci->fake_oid_index,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_ROWVERSIONING,
ci->row_versioning,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_SHOWSYSTEMTABLES,
ci->show_system_tables,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_PROTOCOL,
ci->protocol,
ODBC_INI);
SQLWritePrivateProfileString(DSN,
INI_CONNSETTINGS,
encoded_conn_settings,
ODBC_INI);
}
/*
* This function writes any global parameters (that can be manipulated)
* to the ODBCINST.INI portion of the registry
*/
int
writeDriverCommoninfo(const char *fileName, const char *sectionName,
const GLOBAL_VALUES *comval)
{
char tmp[128];
int errc = 0;
if (stricmp(ODBCINST_INI, fileName) == 0 && NULL == sectionName)
sectionName = DBMS_NAME;
sprintf(tmp, "%d", comval->commlog);
if (!SQLWritePrivateProfileString(sectionName, INI_COMMLOG, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->debug);
if (!SQLWritePrivateProfileString(sectionName, INI_DEBUG, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->fetch_max);
if (!SQLWritePrivateProfileString(sectionName, INI_FETCH, tmp, fileName))
errc--;
if (stricmp(ODBCINST_INI, fileName) == 0)
return errc;
sprintf(tmp, "%d", comval->fetch_max);
if (!SQLWritePrivateProfileString(sectionName, INI_FETCH, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->disable_optimizer);
if (!SQLWritePrivateProfileString(sectionName, INI_OPTIMIZER, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->ksqo);
if (!SQLWritePrivateProfileString(sectionName, INI_KSQO, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->unique_index);
if (!SQLWritePrivateProfileString(sectionName, INI_UNIQUEINDEX, tmp, fileName))
errc--;
/*
* Never update the onlyread from this module.
*/
if (stricmp(ODBCINST_INI, fileName) == 0)
{
sprintf(tmp, "%d", comval->onlyread);
SQLWritePrivateProfileString(sectionName, INI_READONLY, tmp,
fileName);
}
sprintf(tmp, "%d", comval->use_declarefetch);
if (!SQLWritePrivateProfileString(sectionName, INI_USEDECLAREFETCH, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->unknown_sizes);
if (!SQLWritePrivateProfileString(sectionName, INI_UNKNOWNSIZES, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->text_as_longvarchar);
if (!SQLWritePrivateProfileString(sectionName, INI_TEXTASLONGVARCHAR, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->unknowns_as_longvarchar);
if (!SQLWritePrivateProfileString(sectionName, INI_UNKNOWNSASLONGVARCHAR, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->bools_as_char);
if (!SQLWritePrivateProfileString(sectionName, INI_BOOLSASCHAR, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->parse);
if (!SQLWritePrivateProfileString(sectionName, INI_PARSE, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->cancel_as_freestmt);
if (!SQLWritePrivateProfileString(sectionName, INI_CANCELASFREESTMT, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->max_varchar_size);
if (!SQLWritePrivateProfileString(sectionName, INI_MAXVARCHARSIZE, tmp, fileName))
errc--;
sprintf(tmp, "%d", comval->max_longvarchar_size);
if (!SQLWritePrivateProfileString(sectionName, INI_MAXLONGVARCHARSIZE, tmp, fileName))
errc--;
if (!SQLWritePrivateProfileString(sectionName, INI_EXTRASYSTABLEPREFIXES, comval->extra_systable_prefixes, fileName))
errc--;
/*
* Never update the conn_setting from this module
* SQLWritePrivateProfileString(sectionName, INI_CONNSETTINGS,
* comval->conn_settings, fileName);
*/
return errc;
}
/*!
* \brief Save Data Source Name.
*
* Call this to save User, System and File DSN's based upon a property list.
*
* \param pwidgetParent Input. Widget to use as parent for messages. Null is ok.
* \param hFirstProperty Input. First property in NULL terminated property list.
* \param nType Input. Type of DSN.
* \param stringIni Input. Default is QString::null.
*
* \li User and System DSN. This can be a QString::null to use
* default location or it can be a fully qualified path and name.
* \li File DSN. This can be a QString::null to use default
* location or it can be an abs directory. In either case the file
* name itself will be derived from the Name property.
*
* \return bool
* \retval true Hey - it worked :)
* \retval false Call failed for some reason. Error message(s) is shown in message dialog.
*/
bool CODBCInst::saveDataSourceName( QWidget *pwidgetParent, HODBCINSTPROPERTY hFirstProperty, CDSNWizardData::Type nType, const QString &stringIni )
{
// sanity checks...
if ( !hFirstProperty )
{
QMessageBox::critical( pwidgetParent, QObject::tr( "ODBC Administrator" ), QObject::tr( "Programmer error: Uninitialized property list." ) );
return false;
}
if ( (QString( hFirstProperty->szValue )).simplified().isEmpty() )
{
QMessageBox::critical( pwidgetParent, QObject::tr( "ODBC Administrator" ), QObject::tr( "Missing 'Name' property value." ) );
return false;
}
// init
UWORD nConfigMode = ODBC_BOTH_DSN;
bool bReturn = false;
QString stringFileName = stringIni;
switch ( nType )
{
case CDSNWizardData::TypeUser:
SQLGetConfigMode( &nConfigMode );
SQLSetConfigMode( ODBC_USER_DSN );
if ( stringFileName.isEmpty() ) stringFileName = "odbc.ini";
break;
case CDSNWizardData::TypeSystem:
SQLGetConfigMode( &nConfigMode );
SQLSetConfigMode( ODBC_SYSTEM_DSN );
if ( stringFileName.isEmpty() ) stringFileName = "odbc.ini";
break;
case CDSNWizardData::TypeFile:
// should we calc the dir and file name (do not allow the special purpose names)...
if ( stringFileName.isEmpty() || stringFileName.at( 0 ) != QChar( '/' ) )
{
char szDirectory[FILENAME_MAX];
szDirectory[0] = '\0';
_odbcinst_FileINI( szDirectory );
stringFileName = QString( "%1/%2.dsn" ).arg( szDirectory ).arg( hFirstProperty->szValue );
}
else if ( stringFileName.at( 0 ) == QChar( '/' ) )
stringFileName = QString( "%1/%2.dsn" ).arg( stringFileName ).arg( hFirstProperty->szValue );
else
{
QMessageBox::critical( pwidgetParent, QObject::tr( "ODBC Administrator" ), QObject::tr( "File DSN directory expected but seems to be a name or file name." ) );
return false;
}
break;
default:
QMessageBox::critical( pwidgetParent, QObject::tr( "ODBC Administrator" ), QObject::tr( "Unhandled Data Source Name Type" ) );
return false;
}
// save...
if ( nType == CDSNWizardData::TypeFile )
{
// create the file with a section called "ODBC"...
if ( !SQLWriteFileDSN( stringFileName.toAscii().data(), "ODBC", NULL, NULL ) )
{
showErrors( 0, QString( "Could not write to (%1)" ).arg( stringFileName ) );
goto CODBCInstExit1;
}
// add all of the properties...
for ( HODBCINSTPROPERTY hCurProperty = hFirstProperty->pNext; hCurProperty != NULL; hCurProperty = hCurProperty->pNext )
{
if ( !SQLWriteFileDSN( stringFileName.toAscii().data(), "ODBC", hCurProperty->szName, hCurProperty->szValue ) )
{
showErrors( 0, QString( "Could not write to (%1)" ).arg( stringFileName ) );
goto CODBCInstExit1;
}
}
}
else
{
// create a section called using Name property (always 1st property)...
if ( SQLWritePrivateProfileString( hFirstProperty->szValue, NULL, NULL, stringFileName.toAscii().data() ) == FALSE )
{
showErrors( pwidgetParent, QString( QObject::tr( "Could not write to (%1). You may need additional system privileges." ) ).arg( stringFileName ) );
goto CODBCInstExit1;
}
// add all of the properties...
for ( HODBCINSTPROPERTY hCurProperty = hFirstProperty->pNext; hCurProperty != NULL; hCurProperty = hCurProperty->pNext )
{
SQLWritePrivateProfileString( hFirstProperty->szValue, hCurProperty->szName, hCurProperty->szValue, stringFileName.toAscii().data() );
}
}
bReturn = true;
// fini
CODBCInstExit1:
if ( nType != CDSNWizardData::TypeFile )
SQLSetConfigMode( nConfigMode );
return bReturn;
}
void WriteDsnString(const char* dsn, const char* key, const char* value)
{
if (!SQLWritePrivateProfileString(dsn, key, value, CONFIG_FILE))
ThrowLastSetupError();
}
BOOL INSTAPI
ConfigDSN (
HWND hwndParent,
WORD fRequest,
LPCSTR lpszDriver,
LPCSTR lpszAttributes)
{
char *dsn = NULL, *connstr = NULL, *curr, *cour = NULL;
char dsnread[4096] = { 0 };
char prov[4096] = { 0 };
int driver_type = -1, flags = 0;
BOOL retcode = FALSE;
UWORD confMode = ODBC_USER_DSN;
/* Map the request User/System */
if (fRequest < ODBC_ADD_DSN || fRequest > ODBC_REMOVE_DSN)
{
SQLPostInstallerError (ODBC_ERROR_INVALID_REQUEST_TYPE, NULL);
goto done;
}
if (!lpszDriver || !STRLEN (lpszDriver))
{
SQLPostInstallerError (ODBC_ERROR_INVALID_NAME, NULL);
goto done;
}
/* Retrieve the config mode */
SQLGetConfigMode (&confMode);
/* Retrieve the DSN if one exist */
for (curr = (LPSTR) lpszAttributes; curr && *curr;
curr += (STRLEN (curr) + 1))
{
if (!strncmp (curr, "DSN=", STRLEN ("DSN=")))
{
dsn = curr + STRLEN ("DSN=");
break;
}
}
/* Retrieve the corresponding driver */
if (strstr (lpszDriver, "OpenLink") || strstr (lpszDriver, "Openlink")
|| strstr (lpszDriver, "oplodbc"))
{
driver_type = 0;
for (curr = (LPSTR) lpszAttributes, cour = prov; curr && *curr;
curr += (STRLEN (curr) + 1), cour += (STRLEN (cour) + 1))
{
if (!strncasecmp (curr, "Host=", STRLEN ("Host="))
&& STRLEN (curr + STRLEN ("Host=")))
{
STRCPY (cour, curr);
flags |= 0x1;
continue;
}
if (!strncasecmp (curr, "ServerType=", STRLEN ("ServerType="))
&& STRLEN (curr + STRLEN ("ServerType=")))
{
STRCPY (cour, curr);
flags |= 0x2;
continue;
}
STRCPY (cour, curr);
}
if (cour && !(flags & 1))
{
STRCPY (cour, "Host=localhost\0");
cour += (STRLEN (cour) + 1);
}
if (cour && !(flags & 2))
{
STRCPY (cour, "ServerType=Proxy\0");
cour += (STRLEN (cour) + 1);
}
if (cour)
*cour = 0;
}
else if ((strstr (lpszDriver, "Virtuoso")
|| strstr (lpszDriver, "virtodbc")))
driver_type = 1;
/* For each request */
switch (fRequest)
{
case ODBC_ADD_DSN:
/* Check if the DSN with this name already exists */
SQLSetConfigMode (confMode);
#ifdef WIN32
if (hwndParent && dsn
&& SQLGetPrivateProfileString ("ODBC 32 bit Data Sources", dsn, "",
dsnread, sizeof (dsnread), NULL)
&& !create_confirm (hwndParent, dsn,
"Are you sure you want to overwrite this DSN ?"))
#else
if (hwndParent && dsn
&& SQLGetPrivateProfileString ("ODBC Data Sources", dsn, "",
dsnread, sizeof (dsnread), NULL)
&& !create_confirm (hwndParent, dsn,
"Are you sure you want to overwrite this DSN ?"))
#endif
goto done;
/* Call the right setup function */
connstr =
create_gensetup (hwndParent, dsn,
STRLEN (prov) ? prov : lpszAttributes, TRUE);
/* Check output parameters */
if (!connstr)
{
SQLPostInstallerError (ODBC_ERROR_OUT_OF_MEM, NULL);
goto done;
}
if (connstr == (LPSTR) - 1L)
goto done;
/* Add the DSN to the ODBC Data Sources */
SQLSetConfigMode (confMode);
if (!SQLWriteDSNToIni (dsn = connstr + STRLEN ("DSN="), lpszDriver))
goto done;
/* Add each keyword and values */
for (curr = connstr; *curr; curr += (STRLEN (curr) + 1))
{
if (strncmp (curr, "DSN=", STRLEN ("DSN=")))
{
STRCPY (dsnread, curr);
cour = strchr (dsnread, '=');
if (cour)
*cour = 0;
SQLSetConfigMode (confMode);
if (!SQLWritePrivateProfileString (dsn, dsnread, (cour
&& STRLEN (cour + 1)) ? cour + 1 : NULL, NULL))
goto done;
}
}
break;
case ODBC_CONFIG_DSN:
if (!dsn || !STRLEN (dsn))
{
SQLPostInstallerError (ODBC_ERROR_INVALID_KEYWORD_VALUE, NULL);
goto done;
}
/* Call the right setup function */
connstr = create_gensetup (hwndParent, dsn,
STRLEN (prov) ? prov : lpszAttributes, FALSE);
/* Check output parameters */
if (!connstr)
{
SQLPostInstallerError (ODBC_ERROR_OUT_OF_MEM, NULL);
goto done;
}
if (connstr == (LPSTR) - 1L)
goto done;
/* Compare if the DSN changed */
if (strcmp (connstr + STRLEN ("DSN="), dsn))
{
/* Remove the previous DSN */
SQLSetConfigMode (confMode);
if (!SQLRemoveDSNFromIni (dsn))
goto done;
/* Add the new DSN section */
SQLSetConfigMode (confMode);
if (!SQLWriteDSNToIni (dsn = connstr + STRLEN ("DSN="), lpszDriver))
goto done;
}
/* Add each keyword and values */
for (curr = connstr; *curr; curr += (STRLEN (curr) + 1))
{
if (strncmp (curr, "DSN=", STRLEN ("DSN=")))
{
STRCPY (dsnread, curr);
cour = strchr (dsnread, '=');
if (cour)
*cour = 0;
SQLSetConfigMode (confMode);
if (!SQLWritePrivateProfileString (dsn, dsnread, (cour
&& STRLEN (cour + 1)) ? cour + 1 : NULL, NULL))
goto done;
}
}
break;
case ODBC_REMOVE_DSN:
if (!dsn || !STRLEN (dsn))
{
SQLPostInstallerError (ODBC_ERROR_INVALID_KEYWORD_VALUE, NULL);
goto done;
}
/* Just remove the DSN */
SQLSetConfigMode (confMode);
if (!SQLRemoveDSNFromIni (dsn))
goto done;
break;
};
quit:
retcode = TRUE;
done:
if (connstr && connstr != (LPSTR) - 1L && connstr != lpszAttributes
&& connstr != prov)
free (connstr);
return retcode;
}
BOOL INSTAPI
ConfigDriver (
HWND hwndParent,
WORD fRequest,
LPCSTR lpszDriver,
LPCSTR lpszArgs,
LPSTR lpszMsg,
WORD cbMsgMax,
WORD * pcbMsgOut)
{
char *curr, *cour;
char driverread[4096] = { 0 };
BOOL retcode = FALSE;
UWORD confMode = ODBC_USER_DSN;
/* Map the request User/System */
if (fRequest < ODBC_INSTALL_DRIVER || fRequest > ODBC_CONFIG_DRIVER_MAX)
{
SQLPostInstallerError (ODBC_ERROR_INVALID_REQUEST_TYPE, NULL);
goto done;
}
if (!lpszDriver || !STRLEN (lpszDriver))
{
SQLPostInstallerError (ODBC_ERROR_INVALID_NAME, NULL);
goto done;
}
/* Retrieve the config mode */
SQLGetConfigMode (&confMode);
/* Treat corresponding to the request */
switch (fRequest)
{
case ODBC_INSTALL_DRIVER:
/* Check if the DRIVER with this name already exists */
SQLSetConfigMode (confMode);
#ifdef WIN32
if (hwndParent
&& SQLGetPrivateProfileString ("ODBC 32 bit Drivers", lpszDriver,
"", driverread, sizeof (driverread), "odbcinst.ini")
&& !create_confirm (hwndParent, NULL,
"Are you sure you want to overwrite this driver ?"))
#else
# ifdef _MACX
if (hwndParent
&& SQLGetPrivateProfileString ("ODBC Drivers", lpszDriver, "",
driverread, sizeof (driverread), "odbcinst.ini")
&& !create_confirm (hwndParent, NULL,
"Are you sure you want to overwrite this driver ?"))
# else
if (hwndParent
&& SQLGetPrivateProfileString ("ODBC Drivers", lpszDriver, "",
driverread, sizeof (driverread), "odbcinst.ini")
&& !create_confirm (hwndParent, NULL,
"Are you sure you want to overwrite this driver ?"))
# endif
#endif
{
SQLPostInstallerError (ODBC_ERROR_DRIVER_SPECIFIC,
"Driver already installed previously.");
goto done;
}
/* Add the Driver to the ODBC Drivers */
SQLSetConfigMode (confMode);
if (!SQLInstallDriverEx (lpszArgs, NULL, driverread,
sizeof (driverread), NULL, ODBC_INSTALL_COMPLETE, NULL))
{
SQLPostInstallerError (ODBC_ERROR_DRIVER_SPECIFIC,
"Could not add the driver information.");
goto done;
}
break;
case ODBC_CONFIG_DRIVER:
if (!lpszArgs || !STRLEN (lpszArgs))
{
SQLPostInstallerError (ODBC_ERROR_DRIVER_SPECIFIC,
"No enough parameters for configururation.");
goto done;
}
/* Add each keyword and values */
for (curr = (LPSTR) lpszArgs; *curr; curr += (STRLEN (curr) + 1))
{
STRCPY (driverread, curr);
cour = strchr (driverread, '=');
if (cour)
*cour = 0;
SQLSetConfigMode (confMode);
if (!SQLWritePrivateProfileString (lpszDriver, driverread, (cour
&& STRLEN (cour + 1)) ? cour + 1 : NULL,
"odbcinst.ini"))
goto done;
}
break;
case ODBC_REMOVE_DRIVER:
/* Remove the Driver to the ODBC Drivers */
SQLSetConfigMode (confMode);
if (!SQLRemoveDriver (lpszDriver, TRUE, NULL))
{
SQLPostInstallerError (ODBC_ERROR_DRIVER_SPECIFIC,
"Could not remove driver information.");
goto done;
}
break;
default:
SQLPostInstallerError (ODBC_ERROR_REQUEST_FAILED, NULL);
goto done;
};
quit:
retcode = TRUE;
done:
if (pcbMsgOut)
*pcbMsgOut = 0;
return retcode;
}
static void test_SQLGetPrivateProfileStringW(void)
{
static WCHAR testing[] = {'t','e','s','t','i','n','g',0};
static WCHAR wineodbc[] = {'w','i','n','e','o','d','b','c',0};
static WCHAR defaultval[] = {'d','e','f','a','u','l','t',0};
static WCHAR odbcini[] = {'O','D','B','C','.','I','N','I',0};
static WCHAR abcdini[] = {'a','b','c','d','.','I','N','I',0};
static WCHAR wine[] = {'w','i','n','e',0};
static WCHAR value[] = {'v','a','l','u','e',0};
static WCHAR empty[] = {0};
static WCHAR defaultX[] = {'d','e','f','a','u','l','t',0};
static WCHAR def[] = {'d','e','f',0};
static WCHAR value0[] = {'v','a','l','u','e','0','1','2','3','4','5','6','7','8','9',0};
static WCHAR testingvalue[] = {'t','e','s','t','i','n','g',0,'v','a','l','u','e',0};
int ret;
WCHAR buffer[256] = {0};
LONG reg_ret;
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(NULL, testing , defaultval, buffer, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, wine), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , defaultval, buffer, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, empty), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, testing , NULL, buffer, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, empty), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 256, odbcini);
ok(ret == lstrlenW(defaultX), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, defaultX), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 4, odbcini);
ok(ret == lstrlenW(def), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, def), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 8, odbcini);
ok(ret == lstrlenW(defaultX), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, defaultX), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, NULL, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 0, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, value), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value0123456789", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
if(ret)
{
HKEY hkey;
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 256, abcdini);
ok(ret == lstrlenW(value0), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, value0), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, NULL, 0, abcdini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 7, abcdini);
ok(ret == 6, "SQLGetPrivateProfileStringW returned %d\n", ret);
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 10, abcdini);
ok(ret == lstrlenW(testing)+1, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, testing), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLWritePrivateProfileString("wineodbc", "value" , "0", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 256, abcdini);
ok(ret == (lstrlenW(testing) + lstrlenW(value)+2), "SQLGetPrivateProfileStringW returned %d\n", ret);
if(ret == (lstrlenW(testing) + lstrlenW(value)+2))
{
ok(!memcmp(buffer, testingvalue, sizeof(testingvalue)),
"incorrect string '%s'\n", wine_dbgstr_wn(buffer, ret));
}
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 10, abcdini);
ok(ret == lstrlenW(testing)+1, "SQLGetPrivateProfileStringW returned %d\n", ret);
if(ret >= lstrlenW(testing)+1)
{
ok(!lstrcmpW(buffer, testing), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
}
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 2, abcdini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, abcd_key, 0, KEY_READ, &hkey);
ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n");
if(reg_ret == ERROR_SUCCESS)
{
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcd_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
RegCloseKey(hkey);
}
/* Cleanup key */
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcdini_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
}
}
static void test_SQLGetPrivateProfileString(void)
{
int ret;
char buffer[256] = {0};
LONG reg_ret;
strcpy(buffer, "wine");
ret = SQLGetPrivateProfileString(NULL, "testing" , "default", buffer, 256, "ODBC.INI");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, ""), "incorrect string '%s'\n", buffer);
strcpy(buffer, "wine");
ret = SQLGetPrivateProfileString("wineodbc", NULL , "default", buffer, 256, "ODBC.INI");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, ""), "incorrect string '%s'\n", buffer);
strcpy(buffer, "value");
ret = SQLGetPrivateProfileString("wineodbc", "testing" , NULL, buffer, 256, "ODBC.INI");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, ""), "incorrect string '%s'\n", buffer);
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultX", buffer, 256, "ODBC.INI");
ok(ret == strlen("defaultX"), "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, "defaultX"), "incorrect string '%s'\n", buffer);
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultX", buffer, 4, "ODBC.INI");
ok(ret == strlen("def"), "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, "def"), "incorrect string '%s'\n", buffer);
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultX", buffer, 8, "ODBC.INI");
ok(ret == strlen("default"), "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, "default"), "incorrect string '%s'\n", buffer);
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultX", NULL, 256, "ODBC.INI");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
strcpy(buffer, "value");
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultX", buffer, 0, "ODBC.INI");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, "value"), "incorrect string '%s'\n", buffer);
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value0123456789", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
if(ret)
{
HKEY hkey;
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultY", buffer, 256, "abcd.ini");
ok(ret == strlen("value0123456789"), "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, "value0123456789"), "incorrect string '%s'\n", buffer);
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultY", NULL, 0, "abcd.ini");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
ret = SQLGetPrivateProfileString("wineodbc", "testing" , "defaultY", buffer, 7, "abcd.ini");
ok(ret == 6, "SQLGetPrivateProfileString returned %d\n", ret);
strcpy(buffer, "wine");
ret = SQLGetPrivateProfileString("wineodbc", NULL , "", buffer, 10, "abcd.ini");
ok(ret == (strlen("testing")+1), "SQLGetPrivateProfileString returned %d\n", ret);
ok(!strcmp(buffer, "testing"), "incorrect string '%s'\n", buffer);
ret = SQLWritePrivateProfileString("wineodbc", "value" , "0", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
strcpy(buffer, "wine");
ret = SQLGetPrivateProfileString("wineodbc", NULL , "", buffer, 256, "abcd.ini");
ok(ret == (strlen("testing") + strlen("value")+2), "SQLGetPrivateProfileString returned %d\n", ret);
if(ret >= (strlen("testing") + strlen("value")+2))
{
ok(memcmp(buffer, "testing\0value\0", 14) == 0, "incorrect string '%s'\n", buffer);
}
strcpy(buffer, "XXXXXXXXXXXXXXX");
ret = SQLGetPrivateProfileString("wineodbc", NULL , "", buffer, 10, "abcd.ini");
ok(ret == (strlen("testing")+1), "SQLGetPrivateProfileString returned %d\n", ret);
if(ret >= (strlen("testing")+1))
{
ok(!strcmp(buffer, "testing"), "incorrect string '%s'\n", buffer);
/* Show that the buffer is cleared and partial enteries aren't added */
ok(memcmp(buffer, "testing\0X", 9) != 0, "incorrect string '%s'\n", buffer);
}
strcpy(buffer, "wine");
ret = SQLGetPrivateProfileString("wineodbc", NULL , "", buffer, 2, "abcd.ini");
ok(ret == 0, "SQLGetPrivateProfileString returned %d\n", ret);
reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, abcd_key, 0, KEY_READ, &hkey);
ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n");
if(reg_ret == ERROR_SUCCESS)
{
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcd_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
RegCloseKey(hkey);
}
/* Cleanup key */
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcdini_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
}
}
/* {{{ MADB_SaveDSN */
my_bool MADB_SaveDSN(MADB_Dsn *Dsn)
{
int i= 1;
char Value[32];
my_bool ret;
DWORD ErrNum;
if (!SQLValidDSN(Dsn->DSNName))
{
strcpy_s(Dsn->ErrorMsg, SQL_MAX_MESSAGE_LENGTH, "Invalid Data Source Name");
return FALSE;
}
if (!SQLRemoveDSNFromIni(Dsn->DSNName))
{
SQLInstallerError(1,&ErrNum, Dsn->ErrorMsg, SQL_MAX_MESSAGE_LENGTH, NULL);
return FALSE;
}
if (!SQLWriteDSNToIni(Dsn->DSNName, Dsn->Driver))
{
SQLInstallerError(1,&ErrNum, Dsn->ErrorMsg, SQL_MAX_MESSAGE_LENGTH, NULL);
return FALSE;
}
while(DsnKeys[i].DsnKey)
{
ret= TRUE;
switch(DsnKeys[i].Type){
case DSN_TYPE_BOOL:
ret= SQLWritePrivateProfileString(Dsn->DSNName, DsnKeys[i].DsnKey,
*(my_bool *)((char *)Dsn + DsnKeys[i].DsnOffset) ? "1" : "0", "ODBC.INI");
break;
case DSN_TYPE_INT:
{
my_snprintf(Value ,32, "%d", *(int *)((char *)Dsn + DsnKeys[i].DsnOffset));
ret= SQLWritePrivateProfileString(Dsn->DSNName, DsnKeys[i].DsnKey, Value, "ODBC.INI");
}
break;
case DSN_TYPE_STRING:
case DSN_TYPE_COMBO:
{
char *Val= *(char **)((char *)Dsn + DsnKeys[i].DsnOffset);
if (Val && Val[0])
ret= SQLWritePrivateProfileString(Dsn->DSNName, DsnKeys[i].DsnKey, Val, "ODBC.INI");
}
break;
}
if (!ret)
{
SQLInstallerError(1,&ErrNum, Dsn->ErrorMsg, SQL_MAX_MESSAGE_LENGTH, NULL);
return FALSE;
}
i++;
}
/* Save Options */
my_snprintf(Value ,32, "%d", Dsn->Options);
if (!(ret= SQLWritePrivateProfileString(Dsn->DSNName, "OPTIONS", Value, "ODBC.INI")))
{
SQLInstallerError(1,&ErrNum, Dsn->ErrorMsg, SQL_MAX_MESSAGE_LENGTH, NULL);
return FALSE;
}
return TRUE;
}
int
odbc_read_login_info(void)
{
static const char *PWD = "../../../PWD";
FILE *in = NULL;
char line[512];
char *s1, *s2;
const char *const *search_p;
char path[1024];
int len;
#ifdef _WIN32
UWORD old_config_mode;
#endif
setbuf(stdout, NULL);
setbuf(stderr, NULL);
s1 = getenv("TDSPWDFILE");
if (s1 && s1[0])
in = fopen(s1, "r");
if (!in)
in = fopen(PWD, "r");
if (!in)
in = fopen("PWD", "r");
if (!in) {
fprintf(stderr, "Can not open PWD file\n\n");
return 1;
}
while (fgets(line, 512, in)) {
s1 = strtok(line, "=");
s2 = strtok(NULL, "\n");
if (!s1 || !s2)
continue;
if (!strcmp(s1, "UID")) {
strcpy(odbc_user, s2);
} else if (!strcmp(s1, "SRV")) {
strcpy(odbc_server, s2);
} else if (!strcmp(s1, "PWD")) {
strcpy(odbc_password, s2);
} else if (!strcmp(s1, "DB")) {
strcpy(odbc_database, s2);
}
}
fclose(in);
/* find our driver */
#ifndef _WIN32
if (!getcwd(path, sizeof(path)))
#else
if (!_getcwd(path, sizeof(path)))
#endif
return 0;
#ifdef __VMS
{
/* A hard-coded driver path has to be in unix syntax to be recognized as such. */
const char *unixspec = decc$translate_vms(path);
if ( (int)unixspec != 0 && (int)unixspec != -1 ) strcpy(path, unixspec);
}
#endif
len = strlen(path);
if (len < 10 || (strcasecmp(path + len - 10, "/unittests") != 0
#ifdef _WIN32
&& strcasecmp(path + len - 10, "\\unittests") != 0
#endif
))
return 0;
path[len - 9] = 0;
for (search_p = search_driver; *search_p; ++search_p) {
if (check_lib(path, *search_p))
break;
}
if (!*search_p)
return 0;
strcpy(odbc_driver, path);
#ifndef _WIN32
/* craft out odbc.ini, avoid to read wrong one */
snprintf(path, sizeof(path), "odbc.ini.%d", (int) getpid());
in = fopen(path, "w");
if (in) {
fprintf(in, "[%s]\nDriver = %s\nDatabase = %s\nServername = %s\n", odbc_server, odbc_driver, odbc_database, odbc_server);
fclose(in);
setenv("ODBCINI", "./odbc.ini", 1);
setenv("SYSODBCINI", "./odbc.ini", 1);
rename(path, "odbc.ini");
unlink(path);
}
#else
if (SQLGetConfigMode(&old_config_mode)) {
SQLSetConfigMode(ODBC_USER_DSN);
SQLWritePrivateProfileString(odbc_server, "Driver", odbc_driver, "odbc.ini");
SQLWritePrivateProfileString(odbc_server, "Database", odbc_database, "odbc.ini");
SQLWritePrivateProfileString(odbc_server, "Servername", odbc_server, "odbc.ini");
SQLSetConfigMode(old_config_mode);
}
#endif
return 0;
}
bool CPropSheet::UpdateDSN( void )
{
char* lpszDSN;
char szBuf[ _MAX_PATH];
lpszDSN = aAttr[ KEY_DSN].szAttr;
// if the data source name has changed, remove the old name
if( !bNewDSN && strcmp( szDSN, lpszDSN) != 0)
{
SQLRemoveDSNFromIni( szDSN);
// remove File Data Source Name
DeleteFileDSN( szDSN );
}
if(strcmp( szDSN, lpszDSN )!=0)
{
WritePrivateProfileString( lpszDSN, INI_KDESC, aAttr[ KEY_DESC].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_KSN, aAttr[ KEY_SERVICE_NAME].szAttr, ODBC_INI);
// update File DSN
lstrcpy(szBuf, lpszDSN );
lstrcat(szBuf, " (not sharable)");
SQLWriteFileDSN( szBuf, "ODBC", "DSN", lpszDSN );
SQLWritePrivateProfileString( lpszDSN, INI_KDESC, aAttr[ KEY_DESC].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_KSN, aAttr[ KEY_SERVICE_NAME].szAttr, ODBC_INI);
}
// write data source name
if( !SQLWriteDSNToIni( lpszDSN, lpszDrvr))
{
char szMsg[ MAXPATHLEN];
CString szBuf;
szBuf.LoadString(IDS_BADDSN);
wsprintf( szMsg, szBuf, lpszDSN);
AfxMessageBox( szMsg);
return FALSE;
}
// update ODBC.INI
// save the value if the data source is new, edited, or explicitly supplied
WritePrivateProfileString( lpszDSN, INI_KDESC, aAttr[ KEY_DESC].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_KSN, aAttr[ KEY_SERVICE_NAME].szAttr, ODBC_INI);
// update File DSN
lstrcpy(szBuf, lpszDSN );
lstrcat(szBuf, " (not sharable)");
SQLWriteFileDSN( szBuf, "ODBC", "DSN", lpszDSN );
SQLWritePrivateProfileString( lpszDSN, INI_KDESC, aAttr[ KEY_DESC].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_KSN, aAttr[ KEY_SERVICE_NAME].szAttr, ODBC_INI);
// the following are the localization (internationalization) attributes
WritePrivateProfileString( lpszDSN, INI_ERRORLANG, aAttr[ KEY_ERRORLANG].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_ERRORLANG, aAttr[ KEY_ERRORLANG].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_DATALANG, aAttr[ KEY_DATALANG].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_DATALANG, aAttr[ KEY_DATALANG].szAttr, ODBC_INI);
// Association Service (IP Address and Port Number)
wsprintf(szBuf, "%s%s/%s", TCP_STR, aAttr[ KEY_IPADDRESS].szAttr, aAttr[ KEY_PORTNUM].szAttr);
WritePrivateProfileString( lpszDSN, INI_NETWORK, szBuf, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_NETWORK, szBuf, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_LOGIN, aAttr[ KEY_LOGIN].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_LOGIN, aAttr[ KEY_LOGIN].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_CONNECTION, aAttr[ KEY_CONNECTION].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_CONNECTION, aAttr[ KEY_CONNECTION].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_QUERY, aAttr[ KEY_QUERY].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_QUERY, aAttr[ KEY_QUERY].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_CATALOG, aAttr[ KEY_CATALOG].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_CATALOG, aAttr[ KEY_CATALOG].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_SCHEMA, aAttr[ KEY_SCHEMA].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_SCHEMA, aAttr[ KEY_SCHEMA].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_TRANSLATION_DLL, aAttr[ KEY_TRANSLATION_DLL].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_TRANSLATION_DLL, aAttr[ KEY_TRANSLATION_DLL].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_TRANSLATION_OPTION, aAttr[ KEY_TRANSLATION_OPTION].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_TRANSLATION_OPTION, aAttr[ KEY_TRANSLATION_OPTION].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_FETCH_BUFFER_SIZE, aAttr[ KEY_FETCH_BUFFER_SIZE].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_FETCH_BUFFER_SIZE, aAttr[ KEY_FETCH_BUFFER_SIZE].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_REPLACEMENT_CHAR, aAttr[ KEY_REPLACEMENT_CHAR].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_REPLACEMENT_CHAR, aAttr[ KEY_REPLACEMENT_CHAR].szAttr, ODBC_INI);
WritePrivateProfileString( lpszDSN, INI_COMPRESSION, aAttr[ KEY_COMPRESSION].szAttr, ODBC_INI);
SQLWritePrivateProfileString( lpszDSN, INI_COMPRESSION, aAttr[ KEY_COMPRESSION].szAttr, ODBC_INI);
WriteTraceRegistry( INI_TRACE_FILE,aAttr[ KEY_TRACE_FILE].szAttr);
WriteTraceRegistry( INI_TRACE_FLAGS,aAttr[ KEY_TRACE_FLAGS].szAttr);
return TRUE;
}
