/* * Copyright (C) 2024 Linux Studio Plugins Project * (C) 2024 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 18 мар. 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #ifdef PLATFORM_WINDOWS #include #include #include #else #include #include #include #include #include #endif /* PLATFORM_WINDOWS */ namespace lsp { namespace io { #ifdef PLATFORM_WINDOWS typedef struct dirhandle_t { HANDLE hHandle; // Directory handle WIN32_FIND_DATAW sData; // Last data read status_t nPending; // Pending error code } dirhandle_t; #endif /* PLATFORM_WINDOWS */ static inline bool check_closed(dirhandle_t *dir) { return dir == NULL; } Dir::Dir() { nErrorCode = STATUS_OK; hDir = NULL; } Dir::~Dir() { close(); } status_t Dir::open(const char *path) { if (!check_closed(hDir)) return set_error(STATUS_BAD_STATE); else if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); LSPString spath; if (!spath.set_utf8(path)) return set_error(STATUS_NO_MEM); return open (&spath); } status_t Dir::open(const LSPString *path) { if (!check_closed(hDir)) return set_error(STATUS_BAD_STATE); else if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); if (sPath.set(path) != STATUS_OK) return set_error(STATUS_NO_MEM); #ifdef PLATFORM_WINDOWS // Create dir handle dirhandle_t *dir = reinterpret_cast(malloc(sizeof(dirhandle_t))); if (dir == NULL) return STATUS_NO_MEM; lsp_finally { if (dir != NULL) free(dir); }; bzero(dir, sizeof(dirhandle_t)); // Create search mask Path mask; status_t res = mask.set(path); if (res == STATUS_OK) res = mask.append_child("*"); if (res != STATUS_OK) { sPath.clear(); return set_error(res); } // Call API for FindFirst status_t pending = STATUS_OK; HANDLE dh = ::FindFirstFileW(mask.as_string()->get_utf16(), &dir->sData); if (dh == INVALID_HANDLE_VALUE) { DWORD err = ::GetLastError(); switch (err) { case ERROR_NO_MORE_FILES: case ERROR_FILE_NOT_FOUND: pending = STATUS_EOF; break; case ERROR_PATH_NOT_FOUND: case ERROR_INVALID_DRIVE: return set_error(STATUS_NOT_DIRECTORY); case ERROR_NOT_READY: return set_error(STATUS_NO_DATA); case ERROR_TOO_MANY_OPEN_FILES: return set_error(STATUS_OVERFLOW); case ERROR_OUTOFMEMORY: case ERROR_NOT_ENOUGH_MEMORY: return set_error(STATUS_NO_MEM); case ERROR_INVALID_ACCESS: case ERROR_ACCESS_DENIED: return set_error(STATUS_PERMISSION_DENIED); default: return set_error(STATUS_UNKNOWN_ERR); } } // Commit state dir->nPending = pending; dir->hHandle = dh; lsp::swap(hDir, dir); #else DIR *dh = ::opendir(path->get_native()); if (dh == NULL) { sPath.clear(); int error = errno; switch (error) { case EACCES: return set_error(STATUS_PERMISSION_DENIED); case EMFILE: case ENFILE: return set_error(STATUS_TOO_BIG); case ENOENT: return set_error(STATUS_NOT_FOUND); case ENOMEM: return set_error(STATUS_NO_MEM); case ENOTDIR: return set_error(STATUS_BAD_TYPE); default: return set_error(STATUS_UNKNOWN_ERR); } } hDir = dh; #endif /* PLATFORM_WINDOWS */ return set_error(STATUS_OK); } status_t Dir::open(const Path *path) { if (!check_closed(hDir)) return set_error(STATUS_BAD_STATE); else if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); return open(path->as_string()); } status_t Dir::rewind() { if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); #ifdef PLATFORM_WINDOWS // Create search mask Path mask; status_t res = mask.set(&sPath); if (res == STATUS_OK) res = mask.append_child("*"); if (res != STATUS_OK) { sPath.clear(); return set_error(res); } // Call API for FindFirst status_t pending = STATUS_OK; HANDLE dh = ::FindFirstFileW(mask.as_string()->get_utf16(), &hDir->sData); if (dh == INVALID_HANDLE_VALUE) { DWORD err = ::GetLastError(); switch (err) { case ERROR_NO_MORE_FILES: case ERROR_FILE_NOT_FOUND: pending = STATUS_EOF; break; case ERROR_PATH_NOT_FOUND: case ERROR_INVALID_DRIVE: return set_error(STATUS_NOT_DIRECTORY); case ERROR_NOT_READY: return set_error(STATUS_NO_DATA); case ERROR_TOO_MANY_OPEN_FILES: return set_error(STATUS_OVERFLOW); case ERROR_OUTOFMEMORY: case ERROR_NOT_ENOUGH_MEMORY: return set_error(STATUS_NO_MEM); case ERROR_INVALID_ACCESS: case ERROR_ACCESS_DENIED: return set_error(STATUS_PERMISSION_DENIED); default: return set_error(STATUS_UNKNOWN_ERR); } } // Close current handle if ((hDir->hHandle != INVALID_HANDLE_VALUE)) ::FindClose(hDir->hHandle); // Replace closed handle by new handle hDir->hHandle = dh; hDir->nPending = pending; #else ::rewinddir(hDir); #endif /* PLATFORM_WINDOWS */ return set_error(STATUS_OK); } status_t Dir::read(LSPString *path, bool full) { if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); else if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); LSPString out; #ifdef PLATFORM_WINDOWS if (hDir->nPending != STATUS_OK) return set_error(hDir->nPending); else if (hDir->hHandle == INVALID_HANDLE_VALUE) return set_error(STATUS_BAD_STATE); // Set result if (!out.set_utf16(hDir->sData.cFileName)) return set_error(STATUS_NO_MEM); // Perform next iteration if (!::FindNextFileW(hDir->hHandle, &hDir->sData)) { DWORD err = ::GetLastError(); switch (err) { case ERROR_NO_MORE_FILES: case ERROR_FILE_NOT_FOUND: hDir->nPending = STATUS_EOF; break; case ERROR_OUTOFMEMORY: case ERROR_NOT_ENOUGH_MEMORY: return set_error(STATUS_NO_MEM); default: hDir->nPending = STATUS_UNKNOWN_ERR; break; } } #else // Read directory errno = 0; struct dirent *dent = ::readdir(hDir); if (dent == NULL) { if (errno == 0) return set_error(STATUS_EOF); return set_error(STATUS_UNKNOWN_ERR); } // Return value if (!out.set_native(dent->d_name)) return set_error(STATUS_NO_MEM); #endif /* PLATFORM_WINDOWS */ if (full) { Path tmp; status_t res = tmp.set(&sPath); if (res == STATUS_OK) res = tmp.append_child(&out); if (res == STATUS_OK) res = (out.set(tmp.as_string())) ? STATUS_OK : STATUS_NO_MEM; if (res != STATUS_OK) set_error(res); } path->swap(&out); return set_error(STATUS_OK); } status_t Dir::read(Path *path, bool full) { if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); LSPString xpath; status_t res = read(&xpath, false); if (res == STATUS_OK) { if (full) { Path tmp; res = tmp.set(&sPath); if (res == STATUS_OK) res = tmp.append_child(&xpath); if (res == STATUS_OK) path->take(&tmp); } else res = path->set(&xpath); } return set_error(res); } status_t Dir::reads(LSPString *path, fattr_t *attr, bool full) { if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); else if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); LSPString out; #ifdef PLATFORM_WINDOWS if (hDir->nPending != STATUS_OK) return set_error(hDir->nPending); else if (hDir->hHandle == INVALID_HANDLE_VALUE) return set_error(STATUS_BAD_STATE); // Set result if (!out.set_utf16(hDir->sData.cFileName)) return set_error(STATUS_NO_MEM); // Decode file state // Decode file type attr->type = fattr_t::FT_REGULAR; if (hDir->sData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) attr->type = fattr_t::FT_DIRECTORY; else if (hDir->sData.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) attr->type = fattr_t::FT_BLOCK; attr->blk_size = 4096; attr->size = (wsize_t(hDir->sData.nFileSizeHigh) << 32) | hDir->sData.nFileSizeLow; attr->inode = 0; attr->ctime = ((wsize_t(hDir->sData.ftCreationTime.dwHighDateTime) << 32) | hDir->sData.ftCreationTime.dwLowDateTime) / 10000; attr->mtime = ((wsize_t(hDir->sData.ftLastWriteTime.dwHighDateTime) << 32) | hDir->sData.ftLastWriteTime.dwLowDateTime) / 10000; attr->atime = ((wsize_t(hDir->sData.ftLastAccessTime.dwHighDateTime) << 32) | hDir->sData.ftLastAccessTime.dwLowDateTime) / 10000; // Perform next iteration if (!::FindNextFileW(hDir->hHandle, &hDir->sData)) { DWORD err = ::GetLastError(); switch (err) { case ERROR_NO_MORE_FILES: case ERROR_FILE_NOT_FOUND: hDir->nPending = STATUS_EOF; break; default: hDir->nPending = STATUS_UNKNOWN_ERR; break; } } #else // Read directory errno = 0; struct dirent *dent = ::readdir(hDir); if (dent == NULL) { if (errno == 0) return set_error(STATUS_EOF); return set_error(STATUS_UNKNOWN_ERR); } // Stat the record struct stat sb; #if ((_POSIX_C_SOURCE >= 200809L) || defined(_ATFILE_SOURCE)) int code = ::fstatat(::dirfd(hDir), dent->d_name, &sb, AT_SYMLINK_NOFOLLOW); #else LSPString xpath, xname; if (!xname.set_native(dent->d_name)) return set_error(STATUS_NO_MEM); if (!xpath.set(sPath.as_string())) return set_error(STATUS_NO_MEM); if (!xpath.append(FILE_SEPARATOR_C)) return set_error(STATUS_NO_MEM); if (!xpath.append(&xname)) return set_error(STATUS_NO_MEM); int code = ::lstat(xpath.get_native(), &sb); #endif if (code != 0) { code = errno; switch (code) { case EACCES: return set_error(STATUS_PERMISSION_DENIED); case EBADF: return set_error(STATUS_INVALID_VALUE); case ENAMETOOLONG: return set_error(STATUS_OVERFLOW); case EOVERFLOW: return set_error(STATUS_OVERFLOW); case ENOENT: return set_error(STATUS_NOT_FOUND); case ENOMEM: return set_error(STATUS_NO_MEM); default: break; } return set_error(STATUS_IO_ERROR); } // Return value if (!out.set_native(dent->d_name)) return set_error(STATUS_NO_MEM); // Decode file type switch (sb.st_mode & S_IFMT) { case S_IFBLK: attr->type = fattr_t::FT_BLOCK; break; case S_IFCHR: attr->type = fattr_t::FT_CHARACTER; break; case S_IFDIR: attr->type = fattr_t::FT_DIRECTORY; break; case S_IFIFO: attr->type = fattr_t::FT_FIFO; break; case S_IFLNK: attr->type = fattr_t::FT_SYMLINK; break; case S_IFREG: attr->type = fattr_t::FT_REGULAR; break; case S_IFSOCK: attr->type = fattr_t::FT_SOCKET; break; default: attr->type = fattr_t::FT_UNKNOWN; break; } attr->blk_size = sb.st_blksize; attr->size = sb.st_size; attr->inode = sb.st_ino; // In C headers st_atime, st_mtime and st_ctime macros are defined for backward comparibility // to provide access to field tv_sec of st_atim, st_mtim and st_ctim structures. // In MacOS, these fields have another names: st_atimespec, st_ctimespec and st_mtimespec #if defined(PLATFORM_MACOSX) attr->ctime = (sb.st_ctimespec.tv_sec * 1000LL) + (sb.st_ctimespec.tv_nsec / 1000000); attr->mtime = (sb.st_mtimespec.tv_sec * 1000LL) + (sb.st_mtimespec.tv_nsec / 1000000); attr->atime = (sb.st_atimespec.tv_sec * 1000LL) + (sb.st_atimespec.tv_nsec / 1000000); #elif defined(st_ctime) || defined(st_mtime) || defined(st_atime) attr->ctime = (sb.st_ctim.tv_sec * 1000LL) + (sb.st_ctim.tv_nsec / 1000000); attr->mtime = (sb.st_mtim.tv_sec * 1000LL) + (sb.st_mtim.tv_nsec / 1000000); attr->atime = (sb.st_atim.tv_sec * 1000LL) + (sb.st_atim.tv_nsec / 1000000); #else attr->ctime = sb.st_ctime * 1000LL; attr->mtime = sb.st_mtime * 1000LL; attr->atime = sb.st_atime * 1000LL; #endif #endif /* PLATFORM_WINDOWS */ if (full) { Path tmp; status_t res = tmp.set(&sPath); if (res == STATUS_OK) res = tmp.append_child(&out); if (res == STATUS_OK) res = (out.set(tmp.as_string())) ? STATUS_OK : STATUS_NO_MEM; if (res != STATUS_OK) set_error(res); } path->swap(&out); return set_error(STATUS_OK); } status_t Dir::reads(Path *path, fattr_t *attr, bool full) { if (path == NULL) return set_error(STATUS_BAD_ARGUMENTS); LSPString xpath; fattr_t xattr; status_t res = reads(&xpath, &xattr, false); if (res == STATUS_OK) { if (full) { Path tmp; res = tmp.set(&sPath); if (res == STATUS_OK) res = tmp.append_child(&xpath); if (res == STATUS_OK) path->take(&tmp); } else res = path->set(&xpath); if (res == STATUS_OK) *attr = xattr; } return set_error(res); } status_t Dir::close() { if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); status_t res = STATUS_OK; #ifdef PLATFORM_WINDOWS if (hDir != NULL) { if ((hDir->hHandle != NULL) && (hDir->hHandle != INVALID_HANDLE_VALUE)) { if (!::FindClose(hDir->hHandle)) res = STATUS_UNKNOWN_ERR; hDir->hHandle = NULL; } free(hDir); hDir = NULL; } #else if (::closedir(hDir) != 0) { int error = errno; res = (error == EBADF) ? STATUS_BAD_STATE : STATUS_IO_ERROR; } hDir = NULL; #endif /* PLATFORM_WINDOWS */ return set_error(res); } status_t Dir::stat(const char *path, fattr_t *attr) { if ((path == NULL) || (attr == NULL)) return set_error(STATUS_BAD_ARGUMENTS); if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); Path xpath; status_t res = xpath.set(&sPath); if (res == STATUS_OK) res = xpath.append_child(path); if (res != STATUS_OK) return set_error(res); return set_error(File::stat(xpath.as_string(), attr)); } status_t Dir::stat(const LSPString *path, fattr_t *attr) { if ((path == NULL) || (attr == NULL)) return set_error(STATUS_BAD_ARGUMENTS); if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); Path xpath; status_t res = xpath.set(&sPath); if (res == STATUS_OK) res = xpath.append_child(path); if (res != STATUS_OK) return set_error(res); return set_error(File::stat(&xpath, attr)); } status_t Dir::stat(const Path *path, fattr_t *attr) { if ((path == NULL) || (attr == NULL)) return set_error(STATUS_BAD_ARGUMENTS); if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); Path xpath; status_t res = xpath.set(&sPath); if (res == STATUS_OK) res = xpath.append_child(path); if (res != STATUS_OK) return set_error(res); return set_error(File::stat(xpath.as_string(), attr)); } status_t Dir::sym_stat(const char *path, fattr_t *attr) { if ((path == NULL) || (attr == NULL)) return set_error(STATUS_BAD_ARGUMENTS); if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); Path xpath; status_t res = xpath.set(&sPath); if (res == STATUS_OK) res = xpath.append_child(path); if (res != STATUS_OK) return set_error(res); return set_error(File::sym_stat(xpath.as_string(), attr)); } status_t Dir::sym_stat(const LSPString *path, fattr_t *attr) { if ((path == NULL) || (attr == NULL)) return set_error(STATUS_BAD_ARGUMENTS); if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); Path xpath; status_t res = xpath.set(&sPath); if (res == STATUS_OK) res = xpath.append_child(path); if (res != STATUS_OK) return set_error(res); return set_error(File::sym_stat(xpath.as_string(), attr)); } status_t Dir::sym_stat(const Path *path, fattr_t *attr) { if ((path == NULL) || (attr == NULL)) return set_error(STATUS_BAD_ARGUMENTS); if (check_closed(hDir)) return set_error(STATUS_BAD_STATE); Path xpath; status_t res = xpath.set(&sPath); if (res == STATUS_OK) res = xpath.append_child(path); if (res != STATUS_OK) return set_error(res); return set_error(File::sym_stat(xpath.as_string(), attr)); } status_t Dir::create(const char *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; LSPString spath; if (!spath.set_utf8(path)) return STATUS_NO_MEM; return create(&spath); } status_t Dir::create(const Path *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; return create(path->as_string()); } status_t Dir::create(const LSPString *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; #ifdef PLATFORM_WINDOWS const WCHAR *xp = path->get_utf16(); if (::CreateDirectoryW(xp, NULL)) return STATUS_OK; // Analyze error code DWORD code = ::GetLastError(); switch (code) { case ERROR_ALREADY_EXISTS: return STATUS_OK; case ERROR_PATH_NOT_FOUND: return STATUS_NOT_FOUND; default: return STATUS_IO_ERROR; } #else // Try to create directory if (::mkdir(path->get_native(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0) return STATUS_OK; // Analyze error code int code = errno; switch (code) { case EACCES: case EPERM: return STATUS_PERMISSION_DENIED; case EDQUOT: case ENOSPC: return STATUS_OVERFLOW; case ENOTDIR: return STATUS_BAD_HIERARCHY; case EFAULT: case EINVAL: case ENAMETOOLONG: return STATUS_BAD_ARGUMENTS; case EEXIST: // pathname already exists (not necessarily as a directory). This includes the case where pathname is a symbolic link, dangling or not. { fattr_t attr; File::sym_stat(path, &attr); if (attr.type == fattr_t::FT_DIRECTORY) return STATUS_OK; return STATUS_ALREADY_EXISTS; } case ENOENT: // A directory component in pathname does not exist or is a dangling symbolic link. return STATUS_NOT_FOUND; default: return STATUS_IO_ERROR; } #endif /* PLATFORM_WINDOWS */ return STATUS_OK; } status_t Dir::remove(const char *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; LSPString spath; if (!spath.set_utf8(path)) return STATUS_NO_MEM; return remove(&spath); } status_t Dir::remove(const Path *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; return remove(path->as_string()); } status_t Dir::remove(const LSPString *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; #ifdef PLATFORM_WINDOWS if (::RemoveDirectoryW(path->get_utf16())) return STATUS_OK; // Analyze error code DWORD code = ::GetLastError(); switch (code) { case ERROR_PATH_NOT_FOUND: return STATUS_NOT_FOUND; case ERROR_DIR_NOT_EMPTY: return STATUS_NOT_EMPTY; case ERROR_SHARING_VIOLATION: return STATUS_PERMISSION_DENIED; default: return STATUS_IO_ERROR; } #else // Try to remove directory if (::rmdir(path->get_native()) == 0) return STATUS_OK; // Analyze error code int code = errno; switch (code) { case EACCES: case EPERM: return STATUS_PERMISSION_DENIED; case EDQUOT: case ENOSPC: return STATUS_OVERFLOW; case EFAULT: case EINVAL: case ENAMETOOLONG: return STATUS_BAD_ARGUMENTS; case ENOTDIR: return STATUS_NOT_DIRECTORY; case ENOENT: return STATUS_NOT_FOUND; case ENOTEMPTY: return STATUS_NOT_EMPTY; default: return STATUS_IO_ERROR; } #endif /* PLATFORM_WINDOWS */ return STATUS_OK; } status_t Dir::get_current(LSPString *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; #ifdef PLATFORM_WINDOWS DWORD len = ::GetCurrentDirectoryW(0, NULL); if (len == 0) return STATUS_UNKNOWN_ERR; WCHAR *buf = reinterpret_cast(::malloc(sizeof(WCHAR) * (len + 1))); if (buf == NULL) return STATUS_NO_MEM; len = ::GetCurrentDirectoryW(len, buf); if (len == 0) { ::free(buf); return STATUS_UNKNOWN_ERR; } status_t res = (path->set_utf16(buf, len)) ? STATUS_OK : STATUS_NO_MEM; ::free(buf); return res; #else char *spath = reinterpret_cast(malloc(PATH_MAX * sizeof(char))); if (spath == NULL) return STATUS_NO_MEM; lsp_finally { free(spath); }; char *p = ::getcwd(spath, PATH_MAX); if (p == NULL) { int code = errno; switch (code) { case EACCES: case EPERM: return STATUS_PERMISSION_DENIED; case ENOENT: return STATUS_REMOVED; case ENAMETOOLONG: return STATUS_OVERFLOW; case ENOMEM: return STATUS_NO_MEM; default: return STATUS_IO_ERROR; } } return (path->set_native(p)) ? STATUS_OK : STATUS_NO_MEM; #endif /* PLATFORM_WINDOWS */ } status_t Dir::get_current(Path *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; LSPString tmp; status_t res = get_current(&tmp); if (res == STATUS_OK) path->take(&tmp); return res; } } /* namespace io */ } /* namespace lsp */