421 lines
9.9 KiB
C++
421 lines
9.9 KiB
C++
/*
|
|
** findfile.cpp
|
|
** Wrapper around the native directory scanning APIs
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 1998-2016 Randy Heit
|
|
** Copyright 2005-2020 Christoph Oelckers
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
*/
|
|
|
|
#include "fs_findfile.h"
|
|
#include <string.h>
|
|
#include <vector>
|
|
|
|
namespace FileSys {
|
|
|
|
enum
|
|
{
|
|
ZPATH_MAX = 260
|
|
};
|
|
|
|
#ifndef _WIN32
|
|
|
|
|
|
#else
|
|
|
|
|
|
enum
|
|
{
|
|
FA_RDONLY = 1,
|
|
FA_HIDDEN = 2,
|
|
FA_SYSTEM = 4,
|
|
FA_DIREC = 16,
|
|
FA_ARCH = 32,
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <fnmatch.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
struct findstate_t
|
|
{
|
|
std::string path;
|
|
struct dirent** namelist;
|
|
int current;
|
|
int count;
|
|
};
|
|
|
|
static const char* FS_FindName(findstate_t* fileinfo)
|
|
{
|
|
return (fileinfo->namelist[fileinfo->current]->d_name);
|
|
}
|
|
|
|
enum
|
|
{
|
|
FA_RDONLY = 1,
|
|
FA_HIDDEN = 2,
|
|
FA_SYSTEM = 4,
|
|
FA_DIREC = 8,
|
|
FA_ARCH = 16,
|
|
};
|
|
|
|
|
|
static const char *pattern;
|
|
|
|
static int matchfile(const struct dirent *ent)
|
|
{
|
|
return fnmatch(pattern, ent->d_name, FNM_NOESCAPE) == 0;
|
|
}
|
|
|
|
static void *FS_FindFirst(const char *const filespec, findstate_t *const fileinfo)
|
|
{
|
|
const char* dir;
|
|
|
|
const char *const slash = strrchr(filespec, '/');
|
|
|
|
if (slash)
|
|
{
|
|
pattern = slash + 1;
|
|
fileinfo->path = std::string(filespec, 0, slash - filespec + 1);
|
|
dir = fileinfo->path.c_str();
|
|
}
|
|
else
|
|
{
|
|
pattern = filespec;
|
|
dir = ".";
|
|
}
|
|
|
|
fileinfo->current = 0;
|
|
fileinfo->count = scandir(dir, &fileinfo->namelist, matchfile, alphasort);
|
|
|
|
if (fileinfo->count > 0)
|
|
{
|
|
return fileinfo;
|
|
}
|
|
|
|
return (void *)-1;
|
|
}
|
|
|
|
static int FS_FindNext(void *const handle, findstate_t *const fileinfo)
|
|
{
|
|
findstate_t *const state = static_cast<findstate_t *>(handle);
|
|
|
|
if (state->current < fileinfo->count)
|
|
{
|
|
return ++state->current < fileinfo->count ? 0 : -1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int FS_FindClose(void *const handle)
|
|
{
|
|
findstate_t *const state = static_cast<findstate_t *>(handle);
|
|
|
|
if (handle != (void *)-1 && state->count > 0)
|
|
{
|
|
for (int i = 0; i < state->count; ++i)
|
|
{
|
|
free(state->namelist[i]);
|
|
}
|
|
|
|
free(state->namelist);
|
|
state->namelist = nullptr;
|
|
state->count = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FS_FindAttr(findstate_t *const fileinfo)
|
|
{
|
|
dirent *const ent = fileinfo->namelist[fileinfo->current];
|
|
const std::string path = fileinfo->path + ent->d_name;
|
|
bool isdir;
|
|
|
|
if (FS_DirEntryExists(path.c_str(), &isdir))
|
|
{
|
|
return isdir ? FA_DIREC : 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
std::string FS_FullPath(const char* directory)
|
|
{
|
|
char fullpath[PATH_MAX];
|
|
|
|
if (realpath(directory, fullpath) != nullptr)
|
|
return fullpath;
|
|
|
|
return directory;
|
|
}
|
|
|
|
static size_t FS_GetFileSize(findstate_t* handle, const char* pathname)
|
|
{
|
|
struct stat info;
|
|
bool res = stat(pathname, &info) == 0;
|
|
if (!res || (info.st_mode & S_IFDIR)) return 0;
|
|
return (size_t)info.st_size;
|
|
}
|
|
|
|
|
|
#else
|
|
|
|
#include <windows.h>
|
|
#include <direct.h>
|
|
|
|
std::wstring toWide(const char* str)
|
|
{
|
|
int len = (int)strlen(str);
|
|
std::wstring wide;
|
|
if (len > 0)
|
|
{
|
|
int size_needed = MultiByteToWideChar(CP_UTF8, 0, str, len, nullptr, 0);
|
|
wide.resize(size_needed);
|
|
MultiByteToWideChar(CP_UTF8, 0, str, len, &wide.front(), size_needed);
|
|
}
|
|
return wide;
|
|
}
|
|
|
|
static std::string toUtf8(const wchar_t* str)
|
|
{
|
|
auto len = wcslen(str);
|
|
std::string utf8;
|
|
if (len > 0)
|
|
{
|
|
int size_needed = WideCharToMultiByte(CP_UTF8, 0, str, (int)len, nullptr, 0, nullptr, nullptr);
|
|
utf8.resize(size_needed);
|
|
WideCharToMultiByte(CP_UTF8, 0, str, (int)len, &utf8.front(), size_needed, nullptr, nullptr);
|
|
}
|
|
return utf8;
|
|
}
|
|
|
|
struct findstate_t
|
|
{
|
|
struct FileTime
|
|
{
|
|
uint32_t lo, hi;
|
|
};
|
|
// Mirror WIN32_FIND_DATAW in <winbase.h>. We cannot pull in the Windows header here as it would pollute all consumers' symbol space.
|
|
struct WinData
|
|
{
|
|
uint32_t Attribs;
|
|
FileTime Times[3];
|
|
uint32_t Size[2];
|
|
uint32_t Reserved[2];
|
|
wchar_t Name[ZPATH_MAX];
|
|
wchar_t AltName[14];
|
|
};
|
|
WinData FindData;
|
|
std::string UTF8Name;
|
|
};
|
|
|
|
|
|
static int FS_FindAttr(findstate_t* fileinfo)
|
|
{
|
|
return fileinfo->FindData.Attribs;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// FS_FindFirst
|
|
//
|
|
// Start a pattern matching sequence.
|
|
//
|
|
//==========================================================================
|
|
|
|
|
|
static void *FS_FindFirst(const char *filespec, findstate_t *fileinfo)
|
|
{
|
|
static_assert(sizeof(WIN32_FIND_DATAW) == sizeof(fileinfo->FindData), "FindData size mismatch");
|
|
return FindFirstFileW(toWide(filespec).c_str(), (LPWIN32_FIND_DATAW)&fileinfo->FindData);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// FS_FindNext
|
|
//
|
|
// Return the next file in a pattern matching sequence.
|
|
//
|
|
//==========================================================================
|
|
|
|
static int FS_FindNext(void *handle, findstate_t *fileinfo)
|
|
{
|
|
return FindNextFileW((HANDLE)handle, (LPWIN32_FIND_DATAW)&fileinfo->FindData) == 0;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// FS_FindClose
|
|
//
|
|
// Finish a pattern matching sequence.
|
|
//
|
|
//==========================================================================
|
|
|
|
static int FS_FindClose(void *handle)
|
|
{
|
|
return FindClose((HANDLE)handle);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// FS_FindName
|
|
//
|
|
// Returns the name for an entry
|
|
//
|
|
//==========================================================================
|
|
|
|
static const char *FS_FindName(findstate_t *fileinfo)
|
|
{
|
|
fileinfo->UTF8Name = toUtf8(fileinfo->FindData.Name);
|
|
return fileinfo->UTF8Name.c_str();
|
|
}
|
|
|
|
std::string FS_FullPath(const char* directory)
|
|
{
|
|
auto wdirectory = _wfullpath(nullptr, toWide(directory).c_str(), _MAX_PATH);
|
|
std::string sdirectory = toUtf8(wdirectory);
|
|
free((void*)wdirectory);
|
|
for (auto& c : sdirectory) if (c == '\\') c = '/';
|
|
return sdirectory;
|
|
}
|
|
|
|
static size_t FS_GetFileSize(findstate_t* handle, const char* pathname)
|
|
{
|
|
return handle->FindData.Size[1] + ((uint64_t)handle->FindData.Size[0] << 32);
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// ScanDirectory
|
|
//
|
|
//==========================================================================
|
|
|
|
static bool DoScanDirectory(FileList& list, const char* dirpath, const char* match, const char* relpath, bool nosubdir, bool readhidden)
|
|
{
|
|
findstate_t find;
|
|
|
|
std::string dirpathn = dirpath;
|
|
FixPathSeparator(&dirpathn.front());
|
|
if (dirpathn[dirpathn.length() - 1] != '/') dirpathn += '/';
|
|
|
|
std::string dirmatch = dirpathn;
|
|
dirmatch += match;
|
|
|
|
auto handle = FS_FindFirst(dirmatch.c_str(), &find);
|
|
if (handle == ((void*)(-1))) return false;
|
|
FileListEntry fl;
|
|
do
|
|
{
|
|
auto attr = FS_FindAttr(&find);
|
|
if (!readhidden && (attr & FA_HIDDEN))
|
|
{
|
|
// Skip hidden files and directories. (Prevents SVN/git bookkeeping info from being included.)
|
|
continue;
|
|
}
|
|
auto fn = FS_FindName(&find);
|
|
|
|
if (attr & FA_DIREC)
|
|
{
|
|
if (fn[0] == '.' &&
|
|
(fn[1] == '\0' ||
|
|
(fn[1] == '.' && fn[2] == '\0')))
|
|
{
|
|
// Do not record . and .. directories.
|
|
continue;
|
|
}
|
|
}
|
|
|
|
fl.FileName = fn;
|
|
fl.FilePath = dirpathn + fn;
|
|
fl.FilePathRel = relpath;
|
|
if (fl.FilePathRel.length() > 0) fl.FilePathRel += '/';
|
|
fl.FilePathRel += fn;
|
|
fl.isDirectory = !!(attr & FA_DIREC);
|
|
fl.isReadonly = !!(attr & FA_RDONLY);
|
|
fl.isHidden = !!(attr & FA_HIDDEN);
|
|
fl.isSystem = !!(attr & FA_SYSTEM);
|
|
fl.Length = FS_GetFileSize(&find, fl.FilePath.c_str());
|
|
list.push_back(fl);
|
|
if (!nosubdir && (attr & FA_DIREC))
|
|
{
|
|
DoScanDirectory(list, fl.FilePath.c_str(), match, fl.FilePathRel.c_str(), false, readhidden);
|
|
fl.Length = 0;
|
|
}
|
|
} while (FS_FindNext(handle, &find) == 0);
|
|
FS_FindClose(handle);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool ScanDirectory(std::vector<FileListEntry>& list, const char* dirpath, const char* match, bool nosubdir, bool readhidden)
|
|
{
|
|
return DoScanDirectory(list, dirpath, match, "", nosubdir, readhidden);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// DirEntryExists
|
|
//
|
|
// Returns true if the given path exists, be it a directory or a file.
|
|
//
|
|
//==========================================================================
|
|
|
|
bool FS_DirEntryExists(const char* pathname, bool* isdir)
|
|
{
|
|
if (isdir) *isdir = false;
|
|
if (pathname == NULL || *pathname == 0)
|
|
return false;
|
|
|
|
#ifndef _WIN32
|
|
struct stat info;
|
|
bool res = stat(pathname, &info) == 0;
|
|
#else
|
|
// Windows must use the wide version of stat to preserve non-standard paths.
|
|
auto wstr = toWide(pathname);
|
|
struct _stat64 info;
|
|
bool res = _wstat64(wstr.c_str(), &info) == 0;
|
|
#endif
|
|
if (isdir) *isdir = !!(info.st_mode & S_IFDIR);
|
|
return res;
|
|
}
|
|
|
|
}
|