/*static*/ OsPath Paths::Root(const OsPath& argv0)
{
#if OS_ANDROID
return OsPath("/sdcard/0ad"); // TODO: this is kind of bogus
#else
// get full path to executable
OsPath pathname = sys_ExecutablePathname(); // safe, but requires OS-specific implementation
if(pathname.empty()) // failed, use argv[0] instead
{
errno = 0;
pathname = wrealpath(argv0);
if(pathname.empty())
WARN_IF_ERR(StatusFromErrno());
}
// make sure it's valid
if(!FileExists(pathname))
{
LOGERROR(L"Cannot find executable (expected at '%ls')", pathname.string().c_str());
WARN_IF_ERR(StatusFromErrno());
}
for(size_t i = 0; i < 2; i++) // remove "system/name.exe"
pathname = pathname.Parent();
return pathname;
#endif
}
Status WaitUntilComplete(aiocb& cb, size_t queueDepth)
{
#if CONFIG2_FILE_ENABLE_AIO
if(queueDepth > 1)
{
aiocb* const cbs = &cb;
timespec* const timeout = 0; // infinite
SUSPEND_AGAIN:
errno = 0;
const int ret = aio_suspend(&cbs, 1, timeout);
if(ret != 0)
{
if(errno == EINTR) // interrupted by signal
goto SUSPEND_AGAIN;
WARN_RETURN(StatusFromErrno());
}
const int err = aio_error(&cb);
ENSURE(err != EINPROGRESS); // else aio_return is undefined
ssize_t bytesTransferred = aio_return(&cb);
if(bytesTransferred == -1) // transfer failed
{
errno = err;
WARN_RETURN(StatusFromErrno());
}
cb.aio_nbytes = (size_t)bytesTransferred;
}
#else
UNUSED2(cb);
UNUSED2(queueDepth);
#endif
return INFO::OK;
}
Status DeleteDirectory(const OsPath& path)
{
// note: we have to recursively empty the directory before it can
// be deleted (required by Windows and POSIX rmdir()).
CFileInfos files; DirectoryNames subdirectoryNames;
RETURN_STATUS_IF_ERR(GetDirectoryEntries(path, &files, &subdirectoryNames));
// delete files
for(size_t i = 0; i < files.size(); i++)
{
const OsPath pathname = path / files[i].Name();
errno = 0;
if(wunlink(pathname) != 0)
WARN_RETURN(StatusFromErrno());
}
// recurse over subdirectoryNames
for(size_t i = 0; i < subdirectoryNames.size(); i++)
RETURN_STATUS_IF_ERR(DeleteDirectory(path / subdirectoryNames[i]));
errno = 0;
if(wrmdir(path) != 0)
WARN_RETURN(StatusFromErrno());
return INFO::OK;
}
Status Issue(aiocb& cb, size_t queueDepth)
{
#if CONFIG2_FILE_ENABLE_AIO
if(queueDepth > 1)
{
const int ret = (cb.aio_lio_opcode == LIO_WRITE)? aio_write(&cb): aio_read(&cb);
if(ret != 0)
WARN_RETURN(StatusFromErrno());
}
else
#else
UNUSED2(queueDepth);
#endif
{
ENSURE(lseek(cb.aio_fildes, cb.aio_offset, SEEK_SET) == cb.aio_offset);
void* buf = (void*)cb.aio_buf; // cast from volatile void*
const ssize_t bytesTransferred = (cb.aio_lio_opcode == LIO_WRITE)? write(cb.aio_fildes, buf, cb.aio_nbytes) : read(cb.aio_fildes, buf, cb.aio_nbytes);
if(bytesTransferred < 0)
WARN_RETURN(StatusFromErrno());
cb.aio_nbytes = (size_t)bytesTransferred;
}
return INFO::OK;
}
Status CreateDirectories(const OsPath& path, mode_t mode, bool breakpoint)
{
if(path.empty())
return INFO::OK;
struct stat s;
if(wstat(path, &s) == 0)
{
if(!S_ISDIR(s.st_mode)) // encountered a file
WARN_RETURN(ERR::FAIL);
return INFO::OK;
}
// If we were passed a path ending with '/', strip the '/' now so that
// we can consistently use Parent to find parent directory names
if(path.IsDirectory())
return CreateDirectories(path.Parent(), mode, breakpoint);
RETURN_STATUS_IF_ERR(CreateDirectories(path.Parent(), mode));
errno = 0;
if(wmkdir(path, mode) != 0)
{
debug_printf("CreateDirectories: failed to mkdir %s (mode %d)\n", path.string8().c_str(), mode);
if (breakpoint)
WARN_RETURN(StatusFromErrno());
else
return StatusFromErrno();
}
return INFO::OK;
}
Status dir_watch_Add(const OsPath& path, PDirWatch& dirWatch)
{
char resolved[PATH_MAX + 1];
// init already failed; don't try again or complain
if(initialized == -1)
return ERR::FAIL; // NOWARN
if(!initialized)
{
errno = 0;
if((inotifyfd = inotify_init()) < 0)
{
// Check for error ?
int err = errno;
initialized = -1;
LOGERROR("Error initializing inotify file descriptor; hotloading will be disabled, errno=%d", err);
errno = err;
return StatusFromErrno(); // NOWARN
}
errno = 0;
int ret = pthread_create(&g_event_loop_thread, NULL, &inotify_event_loop, NULL);
if (ret != 0)
{
initialized = -1;
LOGERROR("Error creating inotify event loop thread; hotloading will be disabled, err=%d", ret);
errno = ret;
return StatusFromErrno(); // NOWARN
}
initialized = 1;
atexit(inotify_deinit);
}
PDirWatch tmpDirWatch(new DirWatch);
errno = 0;
int wd = inotify_add_watch(inotifyfd, realpath(OsString(path).c_str(), resolved), IN_CREATE | IN_DELETE | IN_CLOSE_WRITE);
if (wd < 0)
WARN_RETURN(StatusFromErrno());
dirWatch.swap(tmpDirWatch);
dirWatch->path = path;
dirWatch->reqnum = wd;
g_paths.insert(std::make_pair(wd, dirWatch));
return INFO::OK;
}
Status mem_Release(u8* p, size_t size)
{
errno = 0;
if(munmap(p, size) != 0)
WARN_RETURN(StatusFromErrno());
return 0;
}
Status mem_Protect(u8* p, size_t size, int prot)
{
errno = 0;
if(mprotect(p, size, prot) != 0)
WARN_RETURN(StatusFromErrno());
return 0;
}
Status GetDirectoryEntries(const OsPath& path, CFileInfos* files, DirectoryNames* subdirectoryNames)
{
// open directory
errno = 0;
WDIR* pDir = wopendir(path);
if(!pDir)
return StatusFromErrno(); // NOWARN
shared_ptr<WDIR> osDir(pDir, DirDeleter());
for(;;)
{
errno = 0;
struct wdirent* osEnt = wreaddir(osDir.get());
if(!osEnt)
{
// no error, just no more entries to return
if(!errno)
return INFO::OK;
WARN_RETURN(StatusFromErrno());
}
for(size_t i = 0; osEnt->d_name[i] != '\0'; i++)
RETURN_STATUS_IF_ERR(Path::Validate(osEnt->d_name[i]));
const OsPath name(osEnt->d_name);
// get file information (mode, size, mtime)
struct stat s;
#if OS_WIN
// .. return wdirent directly (much faster than calling stat).
RETURN_STATUS_IF_ERR(wreaddir_stat_np(osDir.get(), &s));
#else
// .. call regular stat().
errno = 0;
const OsPath pathname = path / name;
if(wstat(pathname, &s) != 0)
WARN_RETURN(StatusFromErrno());
#endif
if(files && S_ISREG(s.st_mode))
files->push_back(CFileInfo(name, s.st_size, s.st_mtime));
else if(subdirectoryNames && S_ISDIR(s.st_mode) && name != L"." && name != L"..")
subdirectoryNames->push_back(name);
}
}
Status GetFileInfo(const OsPath& pathname, CFileInfo* pPtrInfo)
{
errno = 0;
struct stat s;
memset(&s, 0, sizeof(s));
if(wstat(pathname, &s) != 0)
WARN_RETURN(StatusFromErrno());
*pPtrInfo = CFileInfo(pathname.Filename(), s.st_size, s.st_mtime);
return INFO::OK;
}
/*static*/ OsPath Paths::Root(const OsPath& argv0)
{
// get full path to executable
OsPath pathname = sys_ExecutablePathname(); // safe, but requires OS-specific implementation
if(pathname.empty()) // failed, use argv[0] instead
{
errno = 0;
pathname = wrealpath(argv0);
if(pathname.empty())
WARN_IF_ERR(StatusFromErrno());
}
// make sure it's valid
if(!FileExists(pathname))
WARN_IF_ERR(StatusFromErrno());
for(size_t i = 0; i < 2; i++) // remove "system/name.exe"
pathname = pathname.Parent();
return pathname;
}
static inline Status StatusFromMap(void* ret)
{
if(ret != MAP_FAILED)
return INFO::OK;
WARN_RETURN(StatusFromErrno());
}