void CRhoFile::deleteFilesInFolder(const char* szFolderPath) { #if defined(WINDOWS_PLATFORM) StringW wFolderName; common::convertToStringW(szFolderPath,wFolderName); StringW wFolderMask = wFolderName + L"/*"; WIN32_FIND_DATAW FindFileData; HANDLE hFind = INVALID_HANDLE_VALUE; #if defined(OS_WP8) hFind = FindFirstFileExW(wFolderMask.c_str(), FindExInfoStandard, &FindFileData, FindExSearchNameMatch, NULL, FIND_FIRST_EX_CASE_SENSITIVE); #else hFind = FindFirstFileW(wFolderMask.c_str(), &FindFileData); #endif if (hFind == INVALID_HANDLE_VALUE) return; do{ if ( FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY ) continue; StringW wFileName = wFolderName + L"/" + FindFileData.cFileName; DeleteFileW(wFileName.c_str()); }while (FindNextFileW(hFind, &FindFileData) != 0); FindClose(hFind); #else rho_file_impl_delete_files_in_folder(szFolderPath); #endif }
int rewinddir(DIR *dp) { /* Re-set to the beginning */ wchar_t *filespecw; HANDLE handle; int index; FindClose(dp->handle); dp->offset = 0; dp->finished = 0; filespecw = (wchar_t *)malloc((wcslen((wchar_t *)dp->dirw) + 2 + 1)*sizeof(wchar_t)); if (filespecw == NULL) { return -1; } wcscpy(filespecw, (wchar_t *)dp->dirw); index = (int)wcslen(filespecw) - 1; if (index >= 0 && (filespecw[index] == L'/' || (filespecw[index] == L'\\' && index == 0))) filespecw[index] = L'\0'; wcscat(filespecw, L"/*"); if ((handle = FindFirstFileExW(filespecw, FindExInfoBasic, &(dp->fileinfo), FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH)) == INVALID_HANDLE_VALUE) { dp->finished = 1; } free(filespecw); dp->handle = handle; return 0; }
DIR *opendir(const char *dir) { DIR *dp; wchar_t *filespecw, *resolvedw; HANDLE handle; int index; char resolved_path_buff[MAXPATHLEN]; size_t resolvedw_len, filespecw_len; if (!VCWD_REALPATH(dir, resolved_path_buff)) { return NULL; } dp = (DIR *) calloc(1, sizeof(DIR)); if (dp == NULL) { return NULL; } resolvedw = php_win32_ioutil_conv_any_to_w(resolved_path_buff, PHP_WIN32_CP_IGNORE_LEN, &resolvedw_len); if (!resolvedw) { free(dp); return NULL; } filespecw_len = resolvedw_len + 2; filespecw = (wchar_t *)malloc((filespecw_len + 1)*sizeof(wchar_t)); if (filespecw == NULL) { free(dp); free(resolvedw); return NULL; } wcscpy(filespecw, resolvedw); index = (int)filespecw_len - 1; if (index >= 0 && filespecw[index] == L'/' || index == 0 && filespecw[index] == L'\\') filespecw[index] = L'\0'; wcscat(filespecw, L"\\*"); if ((handle = FindFirstFileExW(filespecw, FindExInfoBasic, &(dp->fileinfo), FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH)) == INVALID_HANDLE_VALUE) { DWORD err = GetLastError(); if (err == ERROR_NO_MORE_FILES || err == ERROR_FILE_NOT_FOUND) { dp->finished = 1; } else { free(dp); free(filespecw); free(resolvedw); return NULL; } } dp->dirw = _wcsdup(resolvedw); dp->handle = handle; dp->offset = 0; dp->finished = 0; free(filespecw); free(resolvedw); return dp; }
bool DirAccessWindows::list_dir_begin() { _cisdir = false; _cishidden = false; list_dir_end(); p->h = FindFirstFileExW((current_dir + "\\*").c_str(), FindExInfoStandard, &p->fu, FindExSearchNameMatch, NULL, 0); return (p->h == INVALID_HANDLE_VALUE); }
void TDirIterator::start() { Q_ASSERT(m_Status == stNotStarted); #ifdef Q_OS_WIN QString Path = PathToLongWinPath(m_StartPath); if (!Path.endsWith(QDir::separator())) Path += QDir::separator(); Path += '*'; m_hFind = FindFirstFileExW((LPCWSTR)Path.utf16(), FindExInfoStandard, &m_FindData, FindExSearchNameMatch, NULL, 0); if (m_hFind != INVALID_HANDLE_VALUE) { m_FileInfoEx.m_Data->init(m_StartPath, &m_FindData); m_Status = stStarted; } else { DWORD ErrCode = GetLastError(); if (ErrCode != ERROR_FILE_NOT_FOUND) { qWarning("TDirIterator::start. FindFirstFileEx error on \"%s\": %s", qPrintable(m_StartPath), qPrintable(GetSystemErrorString(ErrCode))); } m_Status = stFinished; } #else m_pDir = ::opendir(m_StartPath.toLocal8Bit().data()); if (m_pDir != NULL) { m_Status = stStarted; getNext(); } else { qWarning("TDirIterator::start. opendir error on \"%s\": %s", qPrintable(m_StartPath), qPrintable(GetSystemErrorString())); m_Status = stFinished; } #endif if (m_FileInfoEx.exists()) { if (!m_FileInfoEx.isDir()) { qWarning("TDirIterator::start. Not folder: \"%s\".", qPrintable(m_StartPath)); finish(); } } else { qWarning("TDirIterator::start. Object not exists or insufficient privileges: \"%s\".", qPrintable(m_StartPath)); } }
int rewinddir(DIR *dp) {/*{{{*/ /* Re-set to the beginning */ wchar_t *filespecw; HANDLE handle; size_t dirw_len, filespecw_len, index; zend_bool might_need_prefix; FindClose(dp->handle); dp->offset = 0; dp->finished = 0; /* XXX save the dir len into the struct. */ dirw_len = wcslen((wchar_t *)dp->dirw); might_need_prefix = dirw_len >= 3 && PHP_WIN32_IOUTIL_IS_LETTERW(dp->dirw[0]) && L':' == dp->dirw[1] && PHP_WIN32_IOUTIL_IS_SLASHW(dp->dirw[2]); filespecw_len = dirw_len + 2; if (filespecw_len >= _MAX_PATH && might_need_prefix) { filespecw_len += PHP_WIN32_IOUTIL_LONG_PATH_PREFIX_LENW; } filespecw = (wchar_t *)malloc((filespecw_len + 1)*sizeof(wchar_t)); if (filespecw == NULL) { return -1; } if (filespecw_len >= _MAX_PATH && might_need_prefix) { wcscpy(filespecw, PHP_WIN32_IOUTIL_LONG_PATH_PREFIXW); wcscpy(filespecw + PHP_WIN32_IOUTIL_LONG_PATH_PREFIX_LENW, dp->dirw); index = dirw_len + PHP_WIN32_IOUTIL_LONG_PATH_PREFIX_LENW - 1; } else { wcscpy(filespecw, dp->dirw); index = dirw_len - 1; } if (index >= 0 && (filespecw[index] == L'/' || (filespecw[index] == L'\\' && index == 0))) filespecw[index] = L'\0'; wcscat(filespecw, L"\\*"); if ((handle = FindFirstFileExW(filespecw, FindExInfoBasic, &(dp->fileinfo), FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH)) == INVALID_HANDLE_VALUE) { dp->finished = 1; } free(filespecw); dp->handle = handle; return 0; }/*}}}*/
EbrDirReader* EbrFSDirReader::open(const std::wstring& path) { EbrFSDirReader* ret = new EbrFSDirReader(); ret->path = path + std::wstring(L"\\*"); ret->startPath = path; ret->findHandle = FindFirstFileExW(ret->path.c_str(), FindExInfoStandard, &ret->data, FindExSearchNameMatch, NULL, 0); if (!ret->findHandle || ret->findHandle == INVALID_HANDLE_VALUE) { delete ret; return NULL; } ret->isFirst = true; return ret; }
int git_path_diriter_init( git_path_diriter *diriter, const char *path, unsigned int flags) { git_win32_path path_filter; git_buf hack = {0}; static int is_win7_or_later = -1; if (is_win7_or_later < 0) is_win7_or_later = git_has_win32_version(6, 1, 0); assert(diriter && path); memset(diriter, 0, sizeof(git_path_diriter)); diriter->handle = INVALID_HANDLE_VALUE; if (git_buf_puts(&diriter->path_utf8, path) < 0) return -1; git_path_trim_slashes(&diriter->path_utf8); if (diriter->path_utf8.size == 0) { giterr_set(GITERR_FILESYSTEM, "Could not open directory '%s'", path); return -1; } if ((diriter->parent_len = git_win32_path_from_utf8(diriter->path, diriter->path_utf8.ptr)) < 0 || !git_win32__findfirstfile_filter(path_filter, diriter->path_utf8.ptr)) { giterr_set(GITERR_OS, "Could not parse the directory path '%s'", path); return -1; } diriter->handle = FindFirstFileExW( path_filter, is_win7_or_later ? FindExInfoBasic : FindExInfoStandard, &diriter->current, FindExSearchNameMatch, NULL, is_win7_or_later ? FIND_FIRST_EX_LARGE_FETCH : 0); if (diriter->handle == INVALID_HANDLE_VALUE) { giterr_set(GITERR_OS, "Could not open directory '%s'", path); return -1; } diriter->parent_utf8_len = diriter->path_utf8.size; diriter->flags = flags; return 0; }
HANDLE WINAPI_DECL FindFirstFileW( _In_ LPCWSTR lpFileName, _Out_ LPWIN32_FIND_DATAW lpFindFileData ) { HANDLE hFindFile = FindFirstFileExW( lpFileName, FindExInfoStandard, lpFindFileData, FindExSearchNameMatch, NULL, 0); return hFindFile; }
static unsigned int copyFolder(const StringW& strSrc, const StringW& strDst, boolean bMove) { unsigned int nErr = 0; CRhoFile::createFolder(convertToStringA(strDst).c_str()); StringW wFolderMask = CFilePath::join(strSrc, L"*"); WIN32_FIND_DATAW FindFileData = {0}; HANDLE hFind = INVALID_HANDLE_VALUE; #if defined(OS_WP8) hFind = FindFirstFileExW(wFolderMask.c_str(), FindExInfoStandard, &FindFileData, FindExSearchNameMatch, NULL, FIND_FIRST_EX_CASE_SENSITIVE); #else hFind = FindFirstFileW(wFolderMask.c_str(), &FindFileData); #endif if (hFind == INVALID_HANDLE_VALUE) return GetLastError(); do{ if (!wcscmp(FindFileData.cFileName , L".")) continue ; if (!wcscmp(FindFileData.cFileName , L"..")) continue ; if ( FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY ) { int i = 0; nErr = copyFolder( CFilePath::join(strSrc,FindFileData.cFileName), CFilePath::join(strDst,FindFileData.cFileName), bMove ); } else { if ( bMove ) { CRhoFile::deleteFile(convertToStringA(CFilePath::join(strDst,FindFileData.cFileName)).c_str()); nErr = CRhoFile::renameFile(convertToStringA(CFilePath::join(strSrc,FindFileData.cFileName)).c_str(), convertToStringA(CFilePath::join(strDst,FindFileData.cFileName)).c_str()); } else nErr = CRhoFile::copyFile( convertToStringA(CFilePath::join(strSrc,FindFileData.cFileName)).c_str(), convertToStringA(CFilePath::join(strDst,FindFileData.cFileName)).c_str() ); } if ( nErr != 0 ) return nErr; }while (FindNextFileW(hFind, &FindFileData) != 0); FindClose(hFind); return 0; }
void* FX_OpenFolder(const FX_WCHAR* path) { #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ std::unique_ptr<CFindFileDataW> pData(new CFindFileDataW); pData->m_Handle = FindFirstFileExW((CFX_WideString(path) + L"/*.*").c_str(), FindExInfoStandard, &pData->m_FindData, FindExSearchNameMatch, nullptr, 0); if (pData->m_Handle == INVALID_HANDLE_VALUE) return nullptr; pData->m_bEnd = FALSE; return pData.release(); #else DIR* dir = opendir(CFX_ByteString::FromUnicode(path).c_str()); return dir; #endif }
VOID HOSTFXR_UTILITY::FindDotNetFolders( const std::filesystem::path &path, _Out_ std::vector<std::wstring> &pvFolders ) { WIN32_FIND_DATAW data = {}; const auto searchPattern = std::wstring(path) + L"\\*"; HandleWrapper<FindFileHandleTraits> handle = FindFirstFileExW(searchPattern.c_str(), FindExInfoStandard, &data, FindExSearchNameMatch, nullptr, 0); if (handle == INVALID_HANDLE_VALUE) { LOG_LAST_ERROR(); return; } do { pvFolders.emplace_back(data.cFileName); } while (FindNextFileW(handle, &data)); }
int ms_factory_load_plugins(MSFactory *factory, const char *dir){ int num=0; #if defined(_WIN32) && !defined(_WIN32_WCE) WIN32_FIND_DATA FileData; HANDLE hSearch; char szDirPath[1024]; #ifdef UNICODE wchar_t wszDirPath[1024]; #endif char szPluginFile[1024]; BOOL fFinished = FALSE; const char *tmp = NULL; BOOL debug = FALSE; #ifndef MS2_WINDOWS_UNIVERSAL tmp = getenv("DEBUG"); #endif debug = (tmp != NULL && atoi(tmp) == 1); snprintf(szDirPath, sizeof(szDirPath), "%s", dir); // Start searching for .dll files in the current directory. #ifdef MS2_WINDOWS_DESKTOP snprintf(szDirPath, sizeof(szDirPath), "%s\\*.dll", dir); #else snprintf(szDirPath, sizeof(szDirPath), "%s\\libms*.dll", dir); #endif #ifdef UNICODE mbstowcs(wszDirPath, szDirPath, sizeof(wszDirPath)); hSearch = FindFirstFileExW(wszDirPath, FindExInfoStandard, &FileData, FindExSearchNameMatch, NULL, 0); #else hSearch = FindFirstFileExA(szDirPath, FindExInfoStandard, &FileData, FindExSearchNameMatch, NULL, 0); #endif if (hSearch == INVALID_HANDLE_VALUE) { ms_message("no plugin (*.dll) found in [%s] [%d].", szDirPath, (int)GetLastError()); return 0; } snprintf(szDirPath, sizeof(szDirPath), "%s", dir); while (!fFinished) { /* load library */ #ifdef MS2_WINDOWS_DESKTOP UINT em=0; #endif HINSTANCE os_handle; #ifdef UNICODE wchar_t wszPluginFile[2048]; char filename[512]; wcstombs(filename, FileData.cFileName, sizeof(filename)); snprintf(szPluginFile, sizeof(szPluginFile), "%s\\%s", szDirPath, filename); mbstowcs(wszPluginFile, szPluginFile, sizeof(wszPluginFile)); #else snprintf(szPluginFile, sizeof(szPluginFile), "%s\\%s", szDirPath, FileData.cFileName); #endif #ifdef MS2_WINDOWS_DESKTOP if (!debug) em = SetErrorMode (SEM_FAILCRITICALERRORS); #ifdef UNICODE os_handle = LoadLibraryExW(wszPluginFile, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); #else os_handle = LoadLibraryExA(szPluginFile, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); #endif if (os_handle==NULL) { ms_message("Fail to load plugin %s with altered search path: error %i",szPluginFile,(int)GetLastError()); #ifdef UNICODE os_handle = LoadLibraryExW(wszPluginFile, NULL, 0); #else os_handle = LoadLibraryExA(szPluginFile, NULL, 0); #endif } if (!debug) SetErrorMode (em); #else os_handle = LoadPackagedLibrary(wszPluginFile, 0); #endif if (os_handle==NULL) ms_error("Fail to load plugin %s: error %i", szPluginFile, (int)GetLastError()); else{ init_func_t initroutine; char szPluginName[256]; char szMethodName[256]; char *minus; #ifdef UNICODE snprintf(szPluginName, sizeof(szPluginName), "%s", filename); #else snprintf(szPluginName, sizeof(szPluginName), "%s", FileData.cFileName); #endif /*on mingw, dll names might be libsomething-3.dll. We must skip the -X.dll stuff*/ minus=strchr(szPluginName,'-'); if (minus) *minus='\0'; else szPluginName[strlen(szPluginName)-4]='\0'; /*remove .dll*/ snprintf(szMethodName, sizeof(szMethodName), "%s_init", szPluginName); initroutine = (init_func_t) GetProcAddress (os_handle, szMethodName); if (initroutine!=NULL){ initroutine(factory); ms_message("Plugin loaded (%s)", szPluginFile); // Add this new loaded plugin to the list (useful for FreeLibrary at the end) factory->ms_plugins_loaded_list=ms_list_append(factory->ms_plugins_loaded_list,os_handle); num++; }else{ ms_warning("Could not locate init routine of plugin %s. Should be %s", szPluginFile, szMethodName); } } if (!FindNextFile(hSearch, &FileData)) { if (GetLastError() == ERROR_NO_MORE_FILES){ fFinished = TRUE; } else { ms_error("couldn't find next plugin dll."); fFinished = TRUE; } } } /* Close the search handle. */ FindClose(hSearch); #elif defined(HAVE_DLOPEN) char plugin_name[64]; DIR *ds; MSList *loaded_plugins = NULL; struct dirent *de; char *ext; char *fullpath; ds=opendir(dir); if (ds==NULL){ ms_message("Cannot open directory %s: %s",dir,strerror(errno)); return -1; } while( (de=readdir(ds))!=NULL){ if ( #ifndef __QNX__ (de->d_type==DT_REG || de->d_type==DT_UNKNOWN || de->d_type==DT_LNK) && #endif (ext=strstr(de->d_name,PLUGINS_EXT))!=NULL) { void *handle; snprintf(plugin_name, MIN(sizeof(plugin_name), ext - de->d_name + 1), "%s", de->d_name); if (ms_list_find_custom(loaded_plugins, (MSCompareFunc)strcmp, plugin_name) != NULL) continue; loaded_plugins = ms_list_append(loaded_plugins, ms_strdup(plugin_name)); fullpath=ms_strdup_printf("%s/%s",dir,de->d_name); ms_message("Loading plugin %s...",fullpath); if ( (handle=dlopen(fullpath,RTLD_NOW))==NULL){ ms_warning("Fail to load plugin %s : %s",fullpath,dlerror()); }else { char *initroutine_name=ms_malloc0(strlen(de->d_name)+10); char *p; void *initroutine=NULL; strcpy(initroutine_name,de->d_name); p=strstr(initroutine_name,PLUGINS_EXT); if (p!=NULL){ strcpy(p,"_init"); initroutine=dlsym(handle,initroutine_name); } #ifdef __APPLE__ if (initroutine==NULL){ /* on macosx: library name are libxxxx.1.2.3.dylib */ /* -> MUST remove the .1.2.3 */ p=strstr(initroutine_name,"."); if (p!=NULL) { strcpy(p,"_init"); initroutine=dlsym(handle,initroutine_name); } } #endif if (initroutine!=NULL){ init_func_t func=(init_func_t)initroutine; func(factory); ms_message("Plugin loaded (%s)", fullpath); num++; }else{ ms_warning("Could not locate init routine of plugin %s",de->d_name); } ms_free(initroutine_name); } ms_free(fullpath); } } ms_list_for_each(loaded_plugins, ms_free); ms_list_free(loaded_plugins); closedir(ds); #else ms_warning("no loadable plugin support: plugins cannot be loaded."); num=-1; #endif return num; }
void __PHYSFS_platformEnumerateFiles(const char *dirname, PHYSFS_EnumFilesCallback callback, const char *origdir, void *callbackdata) { HANDLE dir = INVALID_HANDLE_VALUE; WIN32_FIND_DATAW entw; size_t len = strlen(dirname); char *searchPath = NULL; WCHAR *wSearchPath = NULL; /* Allocate a new string for path, maybe '\\', "*", and NULL terminator */ searchPath = (char *)__PHYSFS_smallAlloc(len + 3); if (searchPath == NULL) return; /* Copy current dirname */ strcpy(searchPath, dirname); /* if there's no '\\' at the end of the path, stick one in there. */ if (searchPath[len - 1] != '\\') { searchPath[len++] = '\\'; searchPath[len] = '\0'; } /* if */ /* Append the "*" to the end of the string */ strcat(searchPath, "*"); UTF8_TO_UNICODE_STACK_MACRO(wSearchPath, searchPath); if (!wSearchPath) return; /* oh well. */ //dir = FindFirstFileW(wSearchPath, &entw); dir = FindFirstFileExW(wSearchPath, FindExInfoStandard, &entw, FindExSearchNameMatch, NULL, 0); __PHYSFS_smallFree(wSearchPath); __PHYSFS_smallFree(searchPath); if (dir == INVALID_HANDLE_VALUE) return; do { const DWORD attr = entw.dwFileAttributes; const DWORD tag = entw.dwReserved0; const WCHAR *fn = entw.cFileName; char *utf8; if ((fn[0] == '.') && (fn[1] == '\0')) continue; if ((fn[0] == '.') && (fn[1] == '.') && (fn[2] == '\0')) continue; utf8 = unicodeToUtf8Heap(fn); if (utf8 != NULL) { callback(callbackdata, origdir, utf8); allocator.Free(utf8); } /* if */ } while (FindNextFileW(dir, &entw) != 0); FindClose(dir); } /* __PHYSFS_platformEnumerateFiles */
BOOL DeleteDirectoryW(const WCHAR* sPath) { HANDLE hFind; // file handle WIN32_FIND_DATAW FindFileData; WCHAR DirPath[MAX_PATH+0x200]; WCHAR FileName[MAX_PATH+0x200]; StringCchCopyW(DirPath,MAX_PATH+0x200,sPath); StringCchCatW(DirPath,MAX_PATH+0x200,L"\\*"); // searching all files StringCchCopyW(FileName,MAX_PATH+0x200,sPath); StringCchCatW(FileName,MAX_PATH+0x200,L"\\"); hFind = FindFirstFileExW(DirPath,FindExInfoBasic,&FindFileData,FindExSearchNameMatch,NULL,0); // find the first file if(hFind == INVALID_HANDLE_VALUE) return FALSE; StringCchCopyW(DirPath,MAX_PATH+0x200,FileName); bool bSearch = true; while(bSearch) { // until we finds an entry if(FindNextFileW(hFind,&FindFileData)) { if(IsDotsW(FindFileData.cFileName)) continue; StringCchCatW(FileName,MAX_PATH+0x200,FindFileData.cFileName); //strcat(FileName,FindFileData.cFileName); if((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { // we have found a directory, recurse if(!DeleteDirectoryW(FileName)) { FindClose(hFind); return FALSE; // directory couldn't be deleted } RemoveDirectoryW(FileName); // remove the empty directory //strcpy(FileName,DirPath); StringCchCopyW(FileName,MAX_PATH+0x200,DirPath); } else { if(!DeleteFileW(FileName)) { // delete the file FindClose(hFind); return FALSE; } //strcpy(FileName,DirPath); StringCchCopyW(FileName,MAX_PATH+0x200,DirPath); } } else { if(GetLastError() == ERROR_NO_MORE_FILES) // no more files there bSearch = false; else { // some error occured, close the handle and return FALSE FindClose(hFind); return FALSE; } } } FindClose(hFind); // closing file handle return RemoveDirectoryW(sPath); // remove the empty directory }
DIR *opendir(const char *dir) {/*{{{*/ DIR *dp; wchar_t *filespecw, *resolvedw; HANDLE handle; char resolved_path_buff[MAXPATHLEN]; size_t resolvedw_len, filespecw_len, index; zend_bool might_need_prefix; if (!VCWD_REALPATH(dir, resolved_path_buff)) { return NULL; } resolvedw = php_win32_ioutil_conv_any_to_w(resolved_path_buff, PHP_WIN32_CP_IGNORE_LEN, &resolvedw_len); if (!resolvedw) { return NULL; } might_need_prefix = resolvedw_len >= 3 && PHP_WIN32_IOUTIL_IS_LETTERW(resolvedw[0]) && L':' == resolvedw[1] && PHP_WIN32_IOUTIL_IS_SLASHW(resolvedw[2]); filespecw_len = resolvedw_len + 2; if (filespecw_len >= _MAX_PATH && might_need_prefix) { filespecw_len += PHP_WIN32_IOUTIL_LONG_PATH_PREFIX_LENW; } filespecw = (wchar_t *)malloc((filespecw_len + 1)*sizeof(wchar_t)); if (filespecw == NULL) { free(resolvedw); return NULL; } if (filespecw_len >= _MAX_PATH && might_need_prefix) { wcscpy(filespecw, PHP_WIN32_IOUTIL_LONG_PATH_PREFIXW); wcscpy(filespecw + PHP_WIN32_IOUTIL_LONG_PATH_PREFIX_LENW, resolvedw); index = resolvedw_len + PHP_WIN32_IOUTIL_LONG_PATH_PREFIX_LENW - 1; } else { wcscpy(filespecw, resolvedw); index = resolvedw_len - 1; } if (index >= 0 && filespecw[index] == L'/' || index == 0 && filespecw[index] == L'\\') filespecw[index] = L'\0'; wcscat(filespecw, L"\\*"); dp = (DIR *) calloc(1, sizeof(DIR) + (_MAX_FNAME*5+1)*sizeof(char)); if (dp == NULL) { free(resolvedw); return NULL; } if ((handle = FindFirstFileExW(filespecw, FindExInfoBasic, &(dp->fileinfo), FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH)) == INVALID_HANDLE_VALUE) { DWORD err = GetLastError(); if (err == ERROR_NO_MORE_FILES || err == ERROR_FILE_NOT_FOUND) { dp->finished = 1; } else { free(dp); free(filespecw); free(resolvedw); return NULL; } } dp->dirw = _wcsdup(resolvedw); dp->handle = handle; dp->offset = 0; dp->finished = 0; free(filespecw); free(resolvedw); return dp; }/*}}}*/
/* Lately, dirSpec appears to be (rightfully) unused. */ CF_PRIVATE CFMutableArrayRef _CFCreateContentsOfDirectory(CFAllocatorRef alloc, char *dirPath, void *dirSpec, CFURLRef dirURL, CFStringRef matchingAbstractType) { CFMutableArrayRef files = NULL; Boolean releaseBase = false; CFIndex pathLength = dirPath ? strlen(dirPath) : 0; // MF:!!! Need to use four-letter type codes where appropriate. CFStringRef extension = (matchingAbstractType ? _CFCopyExtensionForAbstractType(matchingAbstractType) : NULL); CFIndex targetExtLen = (extension ? CFStringGetLength(extension) : 0); #if DEPLOYMENT_TARGET_WINDOWS // This is a replacement for 'dirent' below, and also uses wchar_t to support unicode paths wchar_t extBuff[CFMaxPathSize]; int extBuffInteriorDotCount = 0; //people insist on using extensions like ".trace.plist", so we need to know how many dots back to look :( if (targetExtLen > 0) { CFIndex usedBytes = 0; CFStringGetBytes(extension, CFRangeMake(0, targetExtLen), kCFStringEncodingUTF16, 0, false, (uint8_t *)extBuff, CFMaxPathLength, &usedBytes); targetExtLen = usedBytes / sizeof(wchar_t); extBuff[targetExtLen] = '\0'; wchar_t *extBuffStr = (wchar_t *)extBuff; if (extBuffStr[0] == '.') extBuffStr++; //skip the first dot, it's legitimate to have ".plist" for example wchar_t *extBuffDotPtr = extBuffStr; while ((extBuffDotPtr = wcschr(extBuffStr, '.'))) { //find the next . in the extension... extBuffInteriorDotCount++; extBuffStr = extBuffDotPtr + 1; } } wchar_t pathBuf[CFMaxPathSize]; if (!dirPath) { if (!_CFURLGetWideFileSystemRepresentation(dirURL, true, pathBuf, CFMaxPathLength)) { if (extension) CFRelease(extension); return NULL; } pathLength = wcslen(pathBuf); } else { // Convert dirPath to a wide representation and put it into our pathBuf // Get the real length of the string in UTF16 characters CFStringRef dirPathStr = CFStringCreateWithCString(kCFAllocatorSystemDefault, dirPath, kCFStringEncodingUTF8); CFIndex strLen = CFStringGetLength(dirPathStr); // Copy the string into the buffer and terminate CFStringGetCharacters(dirPathStr, CFRangeMake(0, strLen), (UniChar *)pathBuf); pathBuf[strLen] = 0; CFRelease(dirPathStr); } WIN32_FIND_DATAW file; HANDLE handle; if (pathLength + 2 >= CFMaxPathLength) { if (extension) { CFRelease(extension); } return NULL; } pathBuf[pathLength] = '\\'; pathBuf[pathLength + 1] = '*'; pathBuf[pathLength + 2] = '\0'; handle = FindFirstFileExW(pathBuf, FindExInfoStandard, (LPWIN32_FIND_DATAW)&file, FindExSearchNameMatch, NULL, 0); if (INVALID_HANDLE_VALUE == handle) { pathBuf[pathLength] = '\0'; if (extension) { CFRelease(extension); } return NULL; } files = CFArrayCreateMutable(alloc, 0, &kCFTypeArrayCallBacks); do { CFURLRef fileURL; CFIndex namelen = wcslen(file.cFileName); if (file.cFileName[0] == '.' && (namelen == 1 || (namelen == 2 && file.cFileName[1] == '.'))) { continue; } if (targetExtLen > namelen) continue; // if the extension is the same length or longer than the name, it can't possibly match. if (targetExtLen > 0) { if (file.cFileName[namelen - 1] == '.') continue; //filename ends with a dot, no extension wchar_t *fileExt = NULL; if (extBuffInteriorDotCount == 0) { fileExt = wcsrchr(file.cFileName, '.'); } else { //find the Nth occurrence of . from the end of the string, to handle ".foo.bar" wchar_t *save = file.cFileName; while ((save = wcschr(save, '.')) && !fileExt) { wchar_t *temp = save; int moreDots = 0; while ((temp = wcschr(temp, '.'))) { if (++moreDots == extBuffInteriorDotCount) break; } if (moreDots == extBuffInteriorDotCount) { fileExt = save; } } } if (!fileExt) continue; //no extension if (((const wchar_t *)extBuff)[0] != '.') fileExt++; //omit the dot if the target file extension omits the dot CFIndex fileExtLen = wcslen(fileExt); //if the extensions are different lengths, they can't possibly match if (fileExtLen != targetExtLen) continue; // Check to see if it matches the extension we're looking for. if (_wcsicmp(fileExt, (const wchar_t *)extBuff) != 0) { continue; } } if (dirURL == NULL) { CFStringRef dirURLStr = CFStringCreateWithBytes(alloc, (const uint8_t *)pathBuf, pathLength * sizeof(wchar_t), kCFStringEncodingUTF16, NO); dirURL = CFURLCreateWithFileSystemPath(alloc, dirURLStr, kCFURLWindowsPathStyle, true); CFRelease(dirURLStr); releaseBase = true; } // MF:!!! What about the trailing slash? CFStringRef fileURLStr = CFStringCreateWithBytes(alloc, (const uint8_t *)file.cFileName, namelen * sizeof(wchar_t), kCFStringEncodingUTF16, NO); fileURL = CFURLCreateWithFileSystemPathRelativeToBase(alloc, fileURLStr, kCFURLWindowsPathStyle, (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? true : false, dirURL); CFArrayAppendValue(files, fileURL); CFRelease(fileURL); CFRelease(fileURLStr); } while (FindNextFileW(handle, &file)); FindClose(handle); pathBuf[pathLength] = '\0'; #elif DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD uint8_t extBuff[CFMaxPathSize]; int extBuffInteriorDotCount = 0; //people insist on using extensions like ".trace.plist", so we need to know how many dots back to look :( if (targetExtLen > 0) { CFStringGetBytes(extension, CFRangeMake(0, targetExtLen), CFStringFileSystemEncoding(), 0, false, extBuff, CFMaxPathLength, &targetExtLen); extBuff[targetExtLen] = '\0'; char *extBuffStr = (char *)extBuff; if (extBuffStr[0] == '.') extBuffStr++; //skip the first dot, it's legitimate to have ".plist" for example char *extBuffDotPtr = extBuffStr; while ((extBuffDotPtr = strchr(extBuffStr, '.'))) { //find the next . in the extension... extBuffInteriorDotCount++; extBuffStr = extBuffDotPtr + 1; } } uint8_t pathBuf[CFMaxPathSize]; if (!dirPath) { if (!CFURLGetFileSystemRepresentation(dirURL, true, pathBuf, CFMaxPathLength)) { if (extension) CFRelease(extension); return NULL; } else { dirPath = (char *)pathBuf; pathLength = strlen(dirPath); } } struct dirent buffer; struct dirent *dp; int err; int no_hang_fd = __CFProphylacticAutofsAccess ? open("/dev/autofs_nowait", 0) : -1; DIR *dirp = opendir(dirPath); if (!dirp) { if (extension) { CFRelease(extension); } if (-1 != no_hang_fd) close(no_hang_fd); return NULL; // raiseErrno("opendir", path); } files = CFArrayCreateMutable(alloc, 0, & kCFTypeArrayCallBacks); while((0 == readdir_r(dirp, &buffer, &dp)) && dp) { CFURLRef fileURL; unsigned namelen = strlen(dp->d_name); // skip . & ..; they cause descenders to go berserk if (dp->d_name[0] == '.' && (namelen == 1 || (namelen == 2 && dp->d_name[1] == '.'))) { continue; } if (targetExtLen > namelen) continue; // if the extension is the same length or longer than the name, it can't possibly match. if (targetExtLen > 0) { if (dp->d_name[namelen - 1] == '.') continue; //filename ends with a dot, no extension char *fileExt = NULL; if (extBuffInteriorDotCount == 0) { fileExt = strrchr(dp->d_name, '.'); } else { //find the Nth occurrence of . from the end of the string, to handle ".foo.bar" char *save = dp->d_name; while ((save = strchr(save, '.')) && !fileExt) { char *temp = save; int moreDots = 0; while ((temp = strchr(temp, '.'))) { if (++moreDots == extBuffInteriorDotCount) break; } if (moreDots == extBuffInteriorDotCount) { fileExt = save; } } } if (!fileExt) continue; //no extension if (((char *)extBuff)[0] != '.') fileExt++; //omit the dot if the target extension omits the dot; safe, because we checked to make sure it isn't the last character just before size_t fileExtLen = strlen(fileExt); //if the extensions are different lengths, they can't possibly match if (fileExtLen != targetExtLen) continue; // Check to see if it matches the extension we're looking for. if (strncmp(fileExt, (char *)extBuff, fileExtLen) != 0) { continue; } } if (dirURL == NULL) { dirURL = CFURLCreateFromFileSystemRepresentation(alloc, (uint8_t *)dirPath, pathLength, true); releaseBase = true; } if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN || dp->d_type == DT_LNK || dp->d_type == DT_WHT) { Boolean isDir = (dp->d_type == DT_DIR); if (!isDir) { // Ugh; must stat. char subdirPath[CFMaxPathLength]; struct statinfo statBuf; strlcpy(subdirPath, dirPath, sizeof(subdirPath)); strlcat(subdirPath, "/", sizeof(subdirPath)); strlcat(subdirPath, dp->d_name, sizeof(subdirPath)); if (stat(subdirPath, &statBuf) == 0) { isDir = ((statBuf.st_mode & S_IFMT) == S_IFDIR); } } #if DEPLOYMENT_TARGET_LINUX fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase(alloc, (uint8_t *)dp->d_name, namelen, isDir, dirURL); #else fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase(alloc, (uint8_t *)dp->d_name, dp->d_namlen, isDir, dirURL); #endif } else { #if DEPLOYMENT_TARGET_LINUX fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase (alloc, (uint8_t *)dp->d_name, namelen, false, dirURL); #else fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase (alloc, (uint8_t *)dp->d_name, dp->d_namlen, false, dirURL); #endif } CFArrayAppendValue(files, fileURL); CFRelease(fileURL); } err = closedir(dirp); if (-1 != no_hang_fd) close(no_hang_fd); if (err != 0) { CFRelease(files); if (releaseBase) { CFRelease(dirURL); } if (extension) { CFRelease(extension); } return NULL; } #else #error _CFCreateContentsOfDirectory() unknown architecture, not implemented #endif if (extension) { CFRelease(extension); } if (releaseBase) { CFRelease(dirURL); } return files; }
void gfxFT2FontList::FindFonts() { #ifdef XP_WIN nsTArray<nsString> searchPaths(3); nsTArray<nsString> fontPatterns(3); fontPatterns.AppendElement(NS_LITERAL_STRING("\\*.ttf")); fontPatterns.AppendElement(NS_LITERAL_STRING("\\*.ttc")); fontPatterns.AppendElement(NS_LITERAL_STRING("\\*.otf")); wchar_t pathBuf[256]; SHGetSpecialFolderPathW(0, pathBuf, CSIDL_WINDOWS, 0); searchPaths.AppendElement(pathBuf); SHGetSpecialFolderPathW(0, pathBuf, CSIDL_FONTS, 0); searchPaths.AppendElement(pathBuf); nsCOMPtr<nsIFile> resDir; NS_GetSpecialDirectory(NS_APP_RES_DIR, getter_AddRefs(resDir)); if (resDir) { resDir->Append(NS_LITERAL_STRING("fonts")); nsAutoString resPath; resDir->GetPath(resPath); searchPaths.AppendElement(resPath); } WIN32_FIND_DATAW results; for (PRUint32 i = 0; i < searchPaths.Length(); i++) { const nsString& path(searchPaths[i]); for (PRUint32 j = 0; j < fontPatterns.Length(); j++) { nsAutoString pattern(path); pattern.Append(fontPatterns[j]); HANDLE handle = FindFirstFileExW(pattern.get(), FindExInfoStandard, &results, FindExSearchNameMatch, NULL, 0); PRBool moreFiles = handle != INVALID_HANDLE_VALUE; while (moreFiles) { nsAutoString filePath(path); filePath.AppendLiteral("\\"); filePath.Append(results.cFileName); AppendFacesFromFontFile(static_cast<const PRUnichar*>(filePath.get())); moreFiles = FindNextFile(handle, &results); } if (handle != INVALID_HANDLE_VALUE) FindClose(handle); } } #elif defined(ANDROID) gfxFontCache *fc = gfxFontCache::GetCache(); if (fc) fc->AgeAllGenerations(); mPrefFonts.Clear(); mCodepointsWithNoFonts.reset(); DIR *d = opendir("/system/fonts"); struct dirent *ent = NULL; while(d && (ent = readdir(d)) != NULL) { int namelen = strlen(ent->d_name); if (namelen > 4 && strcasecmp(ent->d_name + namelen - 4, ".ttf") == 0) { nsCString s("/system/fonts"); s.Append("/"); s.Append(nsDependentCString(ent->d_name)); AppendFacesFromFontFile(nsPromiseFlatCString(s).get()); } } if (d) { closedir(d); } mCodepointsWithNoFonts.SetRange(0,0x1f); // C0 controls mCodepointsWithNoFonts.SetRange(0x7f,0x9f); // C1 controls #endif // XP_WIN && ANDROID }