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"); }