std::string ResolveIgniteHome(const std::string& path)
{
// 1. Check passed argument.
if (IsValidDirectory(path))
return path;
// 2. Check environment variable.
std::string home = GetEnv(IGNITE_HOME);
if (IsValidDirectory(home))
return home;
// 3. Check current work dir.
DWORD curDirLen = GetCurrentDirectoryA(0, NULL);
if (!curDirLen)
return std::string();
FixedSizeArray<char> curDir(curDirLen);
curDirLen = GetCurrentDirectoryA(curDir.GetSize(), curDir.GetData());
if (!curDirLen)
return std::string();
std::string curDirStr(curDir.GetData());
return ResolveIgniteHome0(curDirStr);
}
/// Switches you into a working directory
void Window::cd( char *path )
{
if( !path )
{
error( "You can't change directory to NULL, nothing done" ) ;
return ;
}
// Save the current directory to the stack
char *cwd = (char*)malloc( MAX_PATH ) ;
GetCurrentDirectoryA( MAX_PATH, cwd ) ;
directories.push( cwd ) ;
if( !SetCurrentDirectoryA( path ) )
{
error( "Couldn't switch directory to %s", path ) ;
}
else
{
// This verifies the cd command worked
char nowDir[MAX_PATH];
GetCurrentDirectoryA( MAX_PATH, nowDir ) ;
info( "Current working directory is '%s'", nowDir ) ;
}
}
cv::String getcwd()
{
CV_INSTRUMENT_REGION();
cv::AutoBuffer<char, 4096> buf;
#if defined WIN32 || defined _WIN32 || defined WINCE
#ifdef WINRT
return cv::String();
#else
DWORD sz = GetCurrentDirectoryA(0, NULL);
buf.allocate((size_t)sz);
sz = GetCurrentDirectoryA((DWORD)buf.size(), buf.data());
return cv::String(buf.data(), (size_t)sz);
#endif
#elif defined __linux__ || defined __APPLE__ || defined __HAIKU__ || defined __FreeBSD__
for(;;)
{
char* p = ::getcwd(buf.data(), buf.size());
if (p == NULL)
{
if (errno == ERANGE)
{
buf.allocate(buf.size() * 2);
continue;
}
return cv::String();
}
break;
}
return cv::String(buf.data(), (size_t)strlen(buf.data()));
#else
return cv::String();
#endif
}
static ULONG_ADDR CALLBACK GetModuleBase(HANDLE hProcess, ULONG_ADDR dwAddress)
{
MEMORY_BASIC_INFORMATION memoryInfo;
ULONG_ADDR dwAddrBase = SymGetModuleBase(hProcess, dwAddress);
if (dwAddrBase) {
return dwAddrBase;
}
if (VirtualQueryEx(hProcess, (void*)(GC_ULONG_PTR)dwAddress, &memoryInfo,
sizeof(memoryInfo))) {
char filePath[_MAX_PATH];
char curDir[_MAX_PATH];
char exePath[_MAX_PATH];
DWORD size = GetModuleFileNameA((HINSTANCE)memoryInfo.AllocationBase,
filePath, sizeof(filePath));
/* Save and restore current directory around SymLoadModule, see KB */
/* article Q189780. */
GetCurrentDirectoryA(sizeof(curDir), curDir);
GetModuleFileNameA(NULL, exePath, sizeof(exePath));
#if defined(_MSC_VER) && _MSC_VER == 1200
/* use strcat for VC6 */
strcat(exePath, "\\..");
#else
strcat_s(exePath, sizeof(exePath), "\\..");
#endif /* _MSC_VER >= 1200 */
SetCurrentDirectoryA(exePath);
#ifdef _DEBUG
GetCurrentDirectoryA(sizeof(exePath), exePath);
#endif
SymLoadModule(hProcess, NULL, size ? filePath : NULL, NULL,
(ULONG_ADDR)(GC_ULONG_PTR)memoryInfo.AllocationBase, 0);
SetCurrentDirectoryA(curDir);
}
return (ULONG_ADDR)(GC_ULONG_PTR)memoryInfo.AllocationBase;
}
/* take a path with a drive letter, possibly relative, and return a full path
* without the drive letter. This is the full path relative to the working
* dir for that drive letter. The input and output paths can be the same.
*/
long fs_GetFullPath(char *pathp, char *outPathp, long outSize)
{
char tpath[1000];
char origPath[1000];
char *firstp;
long code;
int pathHasDrive;
int doSwitch;
char newPath[3];
if (pathp[0] != 0 && pathp[1] == ':') {
/* there's a drive letter there */
firstp = pathp+2;
pathHasDrive = 1;
} else {
firstp = pathp;
pathHasDrive = 0;
}
if (*firstp == '\\' || *firstp == '/') {
/* already an absolute pathname, just copy it back */
strcpy(outPathp, firstp);
return 0;
}
GetCurrentDirectoryA(sizeof(origPath), origPath);
doSwitch = 0;
if (pathHasDrive && (*pathp & ~0x20) != (origPath[0] & ~0x20)) {
/* a drive has been specified and it isn't our current drive.
* to get path, switch to it first. Must case-fold drive letters
* for user convenience.
*/
doSwitch = 1;
newPath[0] = *pathp;
newPath[1] = ':';
newPath[2] = 0;
if (!SetCurrentDirectoryA(newPath)) {
code = GetLastError();
return code;
}
}
/* now get the absolute path to the current wdir in this drive */
GetCurrentDirectoryA(sizeof(tpath), tpath);
strcpy(outPathp, tpath+2); /* skip drive letter */
/* if there is a non-null name after the drive, append it */
if (*firstp != 0) {
strcat(outPathp, "\\");
strcat(outPathp, firstp);
}
/* finally, if necessary, switch back to our home drive letter */
if (doSwitch) {
SetCurrentDirectoryA(origPath);
}
return 0;
}
path current_path() {
std::vector<char> buffer(GetCurrentDirectoryA(0, NULL));
DWORD length = GetCurrentDirectoryA(buffer.size(), &buffer.front());
if(length == 0 || length + 1 >= buffer.size()) {
buffer[0] = '\0';
}
return path(&buffer.front());
}
/*
* Get local current directory. Returns a string which must be
* freed.
*/
char *psftp_getcwd(void)
{
char *ret = snewn(256, char);
int len = GetCurrentDirectoryA(256, ret);
if (len > 256)
ret = sresize(ret, len, char);
GetCurrentDirectoryA(len, ret);
return ret;
}
std::string CurrentDirectory(void) {
DWORD bufferLength = 0;
bufferLength = GetCurrentDirectoryA(0, NULL);
CHECK_WIN_ERROR;
assert(bufferLength);
std::string buffer(bufferLength - 1, '0');
bufferLength = GetCurrentDirectoryA(bufferLength, &buffer[0]);
CHECK_WIN_ERROR;
assert(bufferLength);
return buffer;
}
char* iupdrvGetCurrentDirectory(void)
{
char* cur_dir = NULL;
int len = GetCurrentDirectoryA(0, NULL);
if (len == 0) return NULL;
cur_dir = iupStrGetMemory(len + 2);
GetCurrentDirectoryA(len + 1, cur_dir);
cur_dir[len] = '\\';
cur_dir[len + 1] = 0;
return cur_dir;
}
/** Implement the Lua function GetCurrentDirectory().
*
* Discover the current directory name and return it to the caller.
*
* \todo There is a low-probability memory leak here. The buffer used
* to hold the current directory string came from malloc() and is held
* across a call to lua_pushlstring() which can potentially throw an
* error, which will leak the allocated buffer. The other bits of Win32
* API wrappers could have similar issues, and should be inspected.
*
* \param L Lua state context for the function.
* \returns The number of values on the Lua stack to be returned
* to the Lua caller.
*/
static int dbgGetCurrentDirectory(lua_State *L)
{
char *buf = 0;
DWORD len = 0;
len = GetCurrentDirectoryA(0,NULL);
if (!len)
return luaL_error(L, "GetCurrentDirectory failed (%d)", GetLastError());
buf = malloc(len+1);
if (!buf)
return luaL_error(L,"GetCurrentDirectory can't allocate %ld chars", len);
GetCurrentDirectoryA(len+1, buf);
lua_pushlstring(L, buf, len);
free(buf);
return 1;
}
void CWE785_Path_Manipulation_Function_Without_Max_Sized_Buffer__w32_04_bad()
{
if(STATIC_CONST_TRUE)
{
{
char path[BAD_PATH_SIZE];
DWORD length;
length = GetCurrentDirectoryA(BAD_PATH_SIZE, path);
if (length == 0 || length >= BAD_PATH_SIZE) /* failure conditions for this API call */
{
exit(1);
}
/* FLAW: PathAppend assumes the 'path' parameter is MAX_PATH */
/* INCIDENTAL: CWE 121 stack based buffer overflow, which is intrinsic to
* this example identified on the CWE webpage */
if (!PathAppendA(path, "AAAAAAAAAAAA"))
{
exit(1);
}
printSizeTLine(strlen(path));
printIntLine(BAD_PATH_SIZE);
printLine(path);
}
}
}
int
is_a_valid_directory(char* pcszDirectory){
#ifndef WIN32
struct stat statbuf;
if ( pcszDirectory[0] == '\0' )
return 0;
lstat(pcszDirectory, &statbuf);
if (S_ISDIR(statbuf.st_mode) == 1){
return 1;
}
write_log(LT_BOTH, "Error: %s is not a valid path!\n", pcszDirectory);
return 0;
#else
char szPath[MAX_PATH];
int nRet = 0;
GetCurrentDirectoryA(MAX_PATH, szPath);
if ( SetCurrentDirectoryA(pcszDirectory) )
nRet = 1;
SetCurrentDirectoryA(szPath);
if ( nRet == 0 )
write_log(LT_BOTH, "Error: %s is not a valid path!\n",
pcszDirectory);
return nRet;
#endif //WIN32
}
/* Routine to test that SetCurrentDirectory behaves as expected. */
static void test_setdir(CHAR *olddir,CHAR *newdir,
CHAR *cmprstr, INT pass, const CHAR *errstr)
{
CHAR tmppath[MAX_PATH], *dirptr;
DWORD val,len,chklen;
val=SetCurrentDirectoryA(newdir);
len=GetCurrentDirectoryA(MAX_PATH,tmppath);
/* if 'pass' then the SetDirectoryA was supposed to pass */
if(pass) {
dirptr=(cmprstr==NULL) ? newdir : cmprstr;
chklen=lstrlenA(dirptr);
ok(val,"%s: SetCurrentDirectoryA failed\n",errstr);
ok(len==chklen,
"%s: SetCurrentDirectory did not change the directory, though it passed\n",
errstr);
ok(lstrcmpiA(dirptr,tmppath)==0,
"%s: SetCurrentDirectory did not change the directory, though it passed\n",
errstr);
ok(SetCurrentDirectoryA(olddir),
"%s: Couldn't set directory to it's original value\n",errstr);
} else {
/* else thest that it fails correctly */
chklen=lstrlenA(olddir);
ok(val==0,
"%s: SetCurrentDirectoryA passed when it should have failed\n",errstr);
ok(len==chklen,
"%s: SetCurrentDirectory changed the directory, though it failed\n",
errstr);
ok(lstrcmpiA(olddir,tmppath)==0,
"%s: SetCurrentDirectory changed the directory, though it failed\n",
errstr);
}
}
// Get current drive prefix "a:", if any
// This is the same method as used in VC++ CRT.
FXString FXSystem::getCurrentDrive(){
#ifdef WIN32
FXchar buffer[MAXPATHLEN];
if(GetCurrentDirectoryA(MAXPATHLEN,buffer) && Ascii::isLetter((FXuchar)buffer[0]) && buffer[1]==':') return FXString(buffer,2);
#endif
return FXString::null;
}
bool getIniValue(string filename,string section,string key,string defultValue,string& value){
char lpBuffer[PATH_BUFFER_LENGTH];
ZeroMemory(lpBuffer,PATH_BUFFER_LENGTH);
DWORD nBufferLength = GetCurrentDirectoryA(
PATH_BUFFER_LENGTH,
lpBuffer
);
string path = "";
if (!nBufferLength) return false;
path=lpBuffer;
path+="\\";
path+=filename;
ZeroMemory(lpBuffer,PATH_BUFFER_LENGTH);
nBufferLength= GetPrivateProfileStringA(
section.c_str(),
key.c_str(),
defultValue.c_str(),
lpBuffer,
PATH_BUFFER_LENGTH,
path.c_str()
);
if (!nBufferLength) return false;
value = lpBuffer;
return true;
}
static void
win32_add_one_solib (const char *name, CORE_ADDR load_addr)
{
char buf[MAX_PATH + 1];
char buf2[MAX_PATH + 1];
#ifdef _WIN32_WCE
WIN32_FIND_DATA w32_fd;
WCHAR wname[MAX_PATH + 1];
mbstowcs (wname, name, MAX_PATH);
HANDLE h = FindFirstFile (wname, &w32_fd);
#else
WIN32_FIND_DATAA w32_fd;
HANDLE h = FindFirstFileA (name, &w32_fd);
#endif
/* The symbols in a dll are offset by 0x1000, which is the
offset from 0 of the first byte in an image - because
of the file header and the section alignment. */
load_addr += 0x1000;
if (h == INVALID_HANDLE_VALUE)
strcpy (buf, name);
else
{
FindClose (h);
strcpy (buf, name);
#ifndef _WIN32_WCE
{
char cwd[MAX_PATH + 1];
char *p;
if (GetCurrentDirectoryA (MAX_PATH + 1, cwd))
{
p = strrchr (buf, '\\');
if (p)
p[1] = '\0';
SetCurrentDirectoryA (buf);
GetFullPathNameA (w32_fd.cFileName, MAX_PATH, buf, &p);
SetCurrentDirectoryA (cwd);
}
}
#endif
}
#ifndef _WIN32_WCE
if (strcasecmp (buf, "ntdll.dll") == 0)
{
GetSystemDirectoryA (buf, sizeof (buf));
strcat (buf, "\\ntdll.dll");
}
#endif
#ifdef __CYGWIN__
cygwin_conv_path (CCP_WIN_A_TO_POSIX, buf, buf2, sizeof (buf2));
#else
strcpy (buf2, buf);
#endif
loaded_dll (buf2, load_addr);
}
bool ShowOpenFileDialog(char* FileName, int FileNameLength, char* filter)
// Open a dialog for selecting a file and returns true if succeeded with the name of the file in the preallocated buffer <FileName>
{
OPENFILENAMEA ofn ;
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = GetActiveWindow();
ofn.lpstrDefExt = 0;
FileName[0] = '\0';
ofn.lpstrFile = FileName;
ofn.nMaxFile = FileNameLength;
ofn.lpstrFilter = filter;
ofn.nFilterIndex = 1;
char strAux[MAX_PATH];
GetCurrentDirectoryA(MAX_PATH, strAux);
ofn.lpstrInitialDir = strAux;
ofn.lpstrTitle = LPSTR("Open File");
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_ENABLESIZING;
GetOpenFileNameA(&ofn);
if (strlen(ofn.lpstrFile) == 0) return false;
return true;
} // ShowOpenFileDialog
void injectThread(const wchar_t *processName) {
while (true) {
// Wait for process to load.
wprintf(L"Waiting for %s to load...\n", processName);
DWORD dwProcessId = NULL;
do {
Sleep(10);
dwProcessId = getProcessId(processName);
} while (dwProcessId == NULL);
// Attempt to inject DLL.
char dllFile[MAX_PATH];
GetCurrentDirectoryA(sizeof(dllFile), dllFile);
sprintf(dllFile, "%s\\..\\Hook\\bin\\Hook.dll", dllFile);
printf("Found PID %d, attempting to inject DLL... ", dwProcessId);
if (injectDll(dwProcessId, dllFile)) {
printf("done!\n");
}
// Now wait for it to unload.
do {
Sleep(10);
dwProcessId = getProcessId(processName);
} while (dwProcessId != NULL);
}
}
void PlatformChangeDirectoryToResources()
{
char buffer[MAX_PATH];
GetCurrentDirectoryA(MAX_PATH, buffer);
lstrcatA(buffer, TEXT("\\.."));
SetCurrentDirectoryA(buffer);
}
static void test_define_dos_deviceA(void)
{
char drivestr[3];
char buf[MAX_PATH];
DWORD ret;
/* Find an unused drive letter */
drivestr[1] = ':';
drivestr[2] = 0;
for (drivestr[0] = 'a'; drivestr[0] <= 'z'; drivestr[0]++) {
ret = QueryDosDeviceA( drivestr, buf, sizeof(buf));
if (!ret) break;
}
if (drivestr[0] > 'z') {
skip("can't test creating a dos drive, none available\n");
return;
}
/* Map it to point to the current directory */
ret = GetCurrentDirectoryA(sizeof(buf), buf);
ok(ret, "GetCurrentDir\n");
ret = DefineDosDeviceA(0, drivestr, buf);
todo_wine
ok(ret, "Could not make drive %s point to %s!\n", drivestr, buf);
if (!ret) {
skip("can't test removing fake drive\n");
} else {
ret = DefineDosDeviceA(DDD_REMOVE_DEFINITION, drivestr, NULL);
ok(ret, "Could not remove fake drive %s!\n", drivestr);
}
}
/* good1() uses if(STATIC_CONST_FALSE) instead of if(STATIC_CONST_TRUE) */
static void good1()
{
if(STATIC_CONST_FALSE)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
}
else
{
{
/* FIX: ensure MAX_PATH allocated in 'path' */
char path[MAX_PATH];
DWORD length;
length = GetCurrentDirectoryA(MAX_PATH, path);
if (length == 0 || length >= MAX_PATH)
{
exit(1); /* failure conditions for this API call */
}
if (!PathAppendA(path, "AAAAAAAAAAAA"))
{
exit(1);
}
printLine(path);
}
}
}
void BotCfg_OnSave( HWND hDlg, BotCfgDlgSt *st )
{
// change subdir to '.\configs'
char curDir[256] = {0};
char newDir[256] = {0};
GetCurrentDirectoryA( 200, curDir );
wsprintfA( newDir, "%s\\configs", curDir );
SetCurrentDirectoryA( newDir );
//
char fileName[256] = {0};
OPENFILENAMEA ofn;
memset( &ofn, 0, sizeof(ofn) );
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hDlg;
ofn.hInstance = g_hInst;
ofn.lpstrFilter = "Config files\0*.config\0All files\0*.*\0\0";
ofn.lpstrFile = fileName;
ofn.nMaxFile = 255;
ofn.lpstrTitle = "Куда сохранять?";
ofn.lpstrInitialDir = newDir;
ofn.Flags = OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
if( GetSaveFileNameA( &ofn ) )
{
if( strstr( fileName, ".config" ) == NULL ) strcat( fileName, ".config" );
if( !st->myCfg.saveConfig( fileName ) )
{
MessageBox( hDlg, TEXT("Конфиг не сохранился!"), TEXT("Ашыпка!"), MB_ICONSTOP );
}
}
// restore cur dir (required to load maps, for example)
SetCurrentDirectoryA( curDir );
}
KeziaResourceManager::KeziaResourceManager(ResourceManagerMode mode)
: m_Mode(mode),
m_PreferredResourceManager(nullptr),
m_SecondaryResourceManager(nullptr)
{
char tmp[255];
GetCurrentDirectoryA(255, tmp);
std::string currentDirectory(tmp);
switch(m_Mode)
{
case PreferData:
m_SecondaryResourceManager = new zlib_ResourceManager();
m_SecondaryResourceManager->AddSourceDirectory(currentDirectory + "\\Data.zip");
case DataOnly:
m_PreferredResourceManager = new Windows_ResourceManager();
m_PreferredResourceManager->AddSourceDirectory(currentDirectory + "\\Data");
break;
case PreferArchive:
m_SecondaryResourceManager = new Windows_ResourceManager();
m_SecondaryResourceManager->AddSourceDirectory(currentDirectory + "\\Data");
case ArchiveOnly:
m_PreferredResourceManager = new zlib_ResourceManager();
m_PreferredResourceManager->AddSourceDirectory(currentDirectory + "\\Data.zip");
break;
}
}
int main(int argc, char *argv[])
{
#ifdef __WIN32
// Create the application's console
if ( AllocConsole() == 0 ) {
::MessageBox( 0, L"Can't allocate console!\n", L"** FCS_analyzer **", MB_OK | MB_ICONSTOP );
return false;
}
//(?) add better error handling code later... freopen( "CON", "w", stderr);
freopen( "CON", "w", stdout);
// std::ios::sync_with_stdio();
// This is often nifty to know...
char* cwd = new char[ MAX_PATH + 1 ];
GetCurrentDirectoryA( MAX_PATH, cwd );
std::cout << "CWD = " << cwd << std::endl;
delete [] cwd;
#endif //__WIN32
//QApplication a(argc, argv);
QApplication app(argc, argv);
Program * okno = new Program;
okno->show();
app.connect( &app, SIGNAL( lastWindowClosed() ), &app, SLOT( quit() ) );
int app_rv = app.exec();
return app_rv;
}
std::string ResolveIgniteHome(const std::string* path, bool* found)
{
if (path)
// 1. Check passed argument.
return ResolveIgniteHome0(*path, false, found);
else
{
// 2. Check environment variable.
bool envFound;
std::string env = GetEnv(IGNITE_HOME, &envFound);
if (envFound)
return ResolveIgniteHome0(env, false, found);
// 3. Check current work dir.
const DWORD curDirLen = GetCurrentDirectory(0, NULL);
char* curDir = new char[curDirLen];
GetCurrentDirectoryA(curDirLen, curDir);
std::string curDirStr = curDir;
delete[] curDir;
return ResolveIgniteHome0(curDirStr, true, found);
}
}
static void create_test_files(void)
{
int len;
GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
len = lstrlenA(CURR_DIR);
if(len && (CURR_DIR[len-1] == '\\'))
CURR_DIR[len - 1] = 0;
get_program_files_dir(PROG_FILES_DIR);
CreateDirectoryA("msitest", NULL);
create_file("msitest\\one.txt");
CreateDirectoryA("msitest\\first", NULL);
create_file("msitest\\first\\two.txt");
CreateDirectoryA("msitest\\second", NULL);
create_file("msitest\\second\\three.txt");
create_file("four.txt");
create_file("five.txt");
create_cab_file("msitest.cab");
DeleteFileA("four.txt");
DeleteFileA("five.txt");
}
/*
AddPackagePath().
*/
static int c_AddPackagePath( lua_State *_pState )
{
const char *packagePath = luaL_checkstring( _pState, 1 );
bool bRelative = true;
if( lua_isboolean( _pState, 2 ) )
if( lua_toboolean( _pState, 2 ) == 0 )
bRelative = false;
char dirBuf[ MAX_PATH + 1];
#if defined(WIN32) && defined(_MSC_VER)
std::string dir;
if (GetCurrentDirectoryA(sizeof(dirBuf) - 1, dirBuf))
dir = dirBuf;
#else
std::string dir = getcwd( &dirBuf[0], MAX_PATH + 1 );
#endif
if( bRelative )
dir += packagePath;
else
dir = packagePath;
Call( _pState, "AddInstallation", "s", (const char *)dir.c_str() );
return( 0 );
}
void readIniFile()
{
char Buffer[128];
char iniFilePath[MAX_PATH];
GetCurrentDirectoryA(sizeof(iniFilePath), iniFilePath);
lstrcatA(iniFilePath, "\\multidisk_speed.ini");
IPC_getPrivateProfileString("Option", "DriveCnt", "1", Buffer, sizeof(Buffer), iniFilePath);
driveCnt = atoi(Buffer);
for (int i = 0; i < driveCnt; i++)
{
sprintf(Buffer, "DriveName%d", i);
IPC_getPrivateProfileString("Option", Buffer, "\\\\.\\H:", driveName[i], sizeof(driveName[i]), iniFilePath);
}
IPC_getPrivateProfileString("Option", "DriveFlag", "0", Buffer, sizeof(Buffer), iniFilePath);
drvFlg = atoi(Buffer);
for (int i = 0; i < driveCnt; i++)
{
sprintf(Buffer, "FullFileName%d", i);
IPC_getPrivateProfileString("Option", Buffer, "data.bin", fileName[i], sizeof(fileName[i]), iniFilePath);
}
IPC_getPrivateProfileString("Option", "BufferSizeInMb", "1", Buffer, sizeof(Buffer), iniFilePath);
bBufSize = atoi(Buffer) * 1024 * 1024;
IPC_getPrivateProfileString("Option", "BufferNum", "1", Buffer, sizeof(Buffer), iniFilePath);
bufCnt = atoi(Buffer);
IPC_getPrivateProfileString("Option", "BufferStatistic", "0", Buffer, sizeof(Buffer), iniFilePath);
bufStat = atoi(Buffer);
}
string_t SaveFileDialog(const char *title, const char *filter) {
OPENFILENAMEA ofn;
char szPath[MAX_PATH];
char szFile[MAX_PATH];
memset(&ofn, 0, sizeof(ofn));
memset(szPath, 0, sizeof(szPath));
memset(szFile, 0, sizeof(szFile));
GetCurrentDirectoryA(MAX_PATH, szPath);
char *fixuped_filter = fixup_filter(filter);
ofn.lStructSize = sizeof(OPENFILENAMEA);
ofn.hwndOwner = NULL;
ofn.lpstrInitialDir = szPath;
ofn.lpstrFile = szFile;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFilter = fixuped_filter;
ofn.lpstrTitle = title;
ofn.Flags = OFN_EXPLORER | OFN_OVERWRITEPROMPT;
if (GetSaveFileNameA(&ofn)) {
free(fixuped_filter);
return String.Create(szFile);
} else {
free(fixuped_filter);
return String.Create(NULL);
}
}
Options::Options() {
char directory[MAX_PATH];
configPath = "";
GetCurrentDirectoryA(MAX_PATH, directory);
configPath.append(directory).append("\\config.ini");
}
