/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 17 мар. 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 #include #include #include #include #include #include #include #include #ifdef PLATFORM_WINDOWS #include #include #include #include #include #include #include #endif /* PLATFORM_WINDOWS */ #ifdef PLATFORM_POSIX #include #include #include #include #include #include #include #include #include #endif /* PLATFORM_POSIX */ #ifdef PLATFORM_LINUX #include #endif /* PLATFORM_LINUX */ #if defined(PLATFORM_BSD) || defined (PLATFORM_MACOSX) #include #include #include #endif /* PLATFORM_BSD || PLATFORM_MACOSX */ #ifdef PLATFORM_HAIKU #include #include #include #include #include #include #endif /* PLATFORM_HAIKU */ #ifdef PLATFORM_POSIX #ifndef _GNU_SOURCE extern char **environ; // Define environment variables #endif /* _GNU_SOURCE */ #endif /* PLATFORM_POSIX */ namespace lsp { namespace system { status_t get_env_var(const LSPString *name, LSPString *dst) { if (name == NULL) return STATUS_BAD_ARGUMENTS; #ifdef PLATFORM_WINDOWS const lsp_utf16_t *nname = name->get_utf16(); if (nname == NULL) return STATUS_NO_MEM; DWORD bufsize = ::GetEnvironmentVariableW(nname, NULL, 0); if (bufsize == 0) { if (::GetLastError() == ERROR_ENVVAR_NOT_FOUND) return STATUS_NOT_FOUND; return STATUS_UNKNOWN_ERR; } else if (dst == NULL) return STATUS_OK; lsp_utf16_t *buf = reinterpret_cast(::malloc(bufsize * sizeof(lsp_utf16_t))); if (buf == NULL) return STATUS_NO_MEM; bufsize = ::GetEnvironmentVariableW(nname, buf, bufsize); if (bufsize == 0) { ::free(buf); return STATUS_UNKNOWN_ERR; } bool res = dst->set_utf16(buf, bufsize); ::free(buf); return (res) ? STATUS_OK : STATUS_NO_MEM; #else const char *nname = name->get_native(); if (nname == NULL) return STATUS_NO_MEM; #if defined(_GNU_SOURCE) && !defined(PLATFORM_HAIKU) char *var = secure_getenv(nname); #else char *var = getenv(nname); #endif if (var == NULL) return STATUS_NOT_FOUND; if (dst != NULL) { if (!dst->set_native(var)) return STATUS_NO_MEM; } return STATUS_OK; #endif /* PLATFORM_WINDOWS */ } status_t get_env_var(const char *name, LSPString *dst) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString sname; if (!sname.set_utf8(name)) return STATUS_NO_MEM; return get_env_var(&sname, dst); } status_t set_env_var(const LSPString *name, const LSPString *value) { #ifdef PLATFORM_WINDOWS const lsp_utf16_t *nname = name->get_utf16(); if (nname == NULL) return STATUS_NO_MEM; if (value != NULL) { const lsp_utf16_t *nvalue = value->get_utf16(); if (nvalue == NULL) return STATUS_NO_MEM; if (::SetEnvironmentVariableW(nname, nvalue)) return STATUS_OK; } else { if (::SetEnvironmentVariableW(nname, NULL)) return STATUS_OK; } return STATUS_UNKNOWN_ERR; #else const char *nname = name->get_native(); if (nname == NULL) return STATUS_NO_MEM; int res; if (value != NULL) { const char *nvalue = value->get_native(); if (nvalue == NULL) return STATUS_NO_MEM; res = ::setenv(nname, nvalue, 1); } else res = ::unsetenv(nname); if (res == 0) return STATUS_OK; switch (res) { case EINVAL: return STATUS_INVALID_VALUE; case ENOMEM: return STATUS_NO_MEM; default: break; } return STATUS_UNKNOWN_ERR; #endif /* PLATFORM_WINDOWS */ } status_t set_env_var(const char *name, const char *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString sname; if (!sname.set_utf8(name)) return STATUS_NO_MEM; if (value == NULL) return set_env_var(&sname, NULL); LSPString svalue; if (!svalue.set_utf8(value)) return STATUS_NO_MEM; return set_env_var(&sname, &svalue); } status_t set_env_var(const char *name, const LSPString *value) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString sname; if (!sname.set_utf8(name)) return STATUS_NO_MEM; return set_env_var(&sname, value); } status_t remove_env_var(const LSPString *name) { const char *nname = name->get_native(); if (nname == NULL) return STATUS_NO_MEM; #ifdef PLATFORM_WINDOWS if (SetEnvironmentVariable(nname, NULL)) return STATUS_OK; return STATUS_UNKNOWN_ERR; #else int res = ::unsetenv(nname); if (res == 0) return STATUS_OK; switch (res) { case EINVAL: return STATUS_INVALID_VALUE; case ENOMEM: return STATUS_NO_MEM; default: break; } return STATUS_UNKNOWN_ERR; #endif /* PLATFORM_WINDOWS */ } status_t remove_env_var(const char *name) { if (name == NULL) return STATUS_BAD_ARGUMENTS; LSPString sname; if (!sname.set_utf8(name)) return STATUS_NO_MEM; return remove_env_var(&sname); } status_t get_home_directory(LSPString *homedir) { if (homedir == NULL) return STATUS_BAD_ARGUMENTS; #ifdef PLATFORM_WINDOWS LSPString drv, path; status_t res = get_env_var("HOMEDRIVE", &drv); if (res != STATUS_OK) return res; res = get_env_var("HOMEPATH", &path); if (res != STATUS_OK) return res; if (!drv.append(&path)) return STATUS_NO_MEM; homedir->take(&drv); return STATUS_OK; #else return get_env_var("HOME", homedir); #endif /* PLATFORM_WINDOWS */ } status_t get_home_directory(io::Path *homedir) { if (homedir == NULL) return STATUS_BAD_ARGUMENTS; LSPString path; status_t res = get_home_directory(&path); if (res != STATUS_OK) return res; return homedir->set(&path); } status_t get_user_config_path(LSPString *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; LSPString upath; #ifdef PLATFORM_WINDOWS status_t res = get_env_var("LOCALAPPDATA", &upath); if (res != STATUS_OK) { res = get_env_var("APPDATA", &upath); if (res != STATUS_OK) { res = get_home_directory(&upath); if (res != STATUS_OK) return res; if (!upath.append_ascii(FILE_SEPARATOR_S ".config")) return STATUS_NO_MEM; } } #elif defined(PLATFORM_HAIKU) status_t res = get_env_var("HOME", &upath); if (res != STATUS_OK) return res; if (!upath.append_ascii( FILE_SEPARATOR_S "config" FILE_SEPARATOR_S "settings")) return STATUS_NO_MEM; #else status_t res = get_env_var("XDG_CONFIG_HOME", &upath); if (res != STATUS_OK) { res = get_env_var("HOME", &upath); if (res != STATUS_OK) return res; if (!upath.append_ascii(FILE_SEPARATOR_S ".config")) return STATUS_NO_MEM; } #endif /* PLATFORM_WINDOWS */ path->swap(&upath); return STATUS_OK; } status_t get_user_config_path(io::Path *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; LSPString upath; status_t res = get_user_config_path(&upath); if (res != STATUS_OK) return res; return path->set(&upath); } #ifdef PLATFORM_WINDOWS void get_time(time_t *time) { FILETIME t; ::GetSystemTimeAsFileTime(&t); uint64_t itime = (uint64_t(t.dwHighDateTime) << 32) | t.dwLowDateTime; time->seconds = itime / 10000000; time->nanos = (itime % 10000000) * 100; } time_millis_t get_time_millis() { FILETIME t; ::GetSystemTimeAsFileTime(&t); uint64_t itime = (uint64_t(t.dwHighDateTime) << 32) | t.dwLowDateTime; return itime / 10000; } void get_localtime(localtime_t *local, const time_t *time) { SYSTEMTIME t; // Get system file time into tmp if (time != NULL) { FILETIME tmp, stime; uint64_t itime = (time->seconds * 10000000) | (time->nanos / 100); tmp.dwHighDateTime = DWORD(itime >> 32); tmp.dwLowDateTime = DWORD(itime); ::FileTimeToLocalFileTime(&tmp, &stime); ::FileTimeToSystemTime(&stime, &t); } else ::GetLocalTime(&t); // Decode local->year = t.wYear; local->month = t.wMonth; local->mday = t.wDay; local->wday = t.wDayOfWeek; local->hour = t.wHour; local->min = t.wMinute; local->sec = t.wSecond; local->nanos = time->nanos; } status_t sleep_msec(size_t delay) { HANDLE timer; LARGE_INTEGER li; timer = CreateWaitableTimerW(NULL, TRUE, NULL); if (timer == NULL) return STATUS_UNKNOWN_ERR; while (delay > 0) { // Relative time, computed with precision of 100 ns size_t period = lsp_min(0x10000000U, delay); li.QuadPart = - LONGLONG(period) * 10000; if (!SetWaitableTimer(timer, &li, 0, NULL, NULL, FALSE)) { CloseHandle(timer); return STATUS_UNKNOWN_ERR; } WaitForSingleObject(timer, INFINITE); delay -= period; } CloseHandle(timer); return STATUS_OK; } #else void get_time(time_t *time) { struct timespec t; ::clock_gettime(CLOCK_REALTIME, &t); time->seconds = t.tv_sec; time->nanos = uint32_t(t.tv_nsec); } time_millis_t get_time_millis() { struct timespec t; ::clock_gettime(CLOCK_REALTIME, &t); return time_millis_t(t.tv_sec) * 1000 + time_millis_t(t.tv_nsec) / 1000000; } void get_localtime(localtime_t *local, const time_t *time) { // Store actual time to timespec struct struct timespec stime; if (time != NULL) { stime.tv_sec = time->seconds; stime.tv_nsec = time->nanos; } else ::clock_gettime(CLOCK_REALTIME, &stime); // Now convert the struct to local time struct tm *t; #if defined(_POSIX_C_SOURCE) || defined(_BSD_SOURCE) || defined(_SVID_SOURCE) struct tm ctime; t = localtime_r(&stime.tv_sec, &ctime); #else t = localtime(&stime.tv_sec); #endif local->year = t->tm_year + 1900; local->month = t->tm_mon + 1; local->mday = t->tm_mday + 1; local->wday = t->tm_wday + 1; local->hour = t->tm_hour; local->min = t->tm_min; local->sec = t->tm_sec; local->nanos = uint32_t(stime.tv_nsec); } status_t sleep_msec(size_t delay) { if (delay <= 0) return STATUS_OK; time_millis_t ctime = get_time_millis(); const time_millis_t dtime = ctime + delay; while (ctime < dtime) { struct timespec req, rem; size_t delta = dtime - ctime; req.tv_nsec = (delta % 1000) * 1000000; req.tv_sec = delta / 1000; rem.tv_nsec = 0; rem.tv_sec = 0; // Perform nanosleep for the specific period of time. // If function succeeded and waited the whole desired period // of time, it should return 0. if (::nanosleep(&req, &rem) == 0) break; // If the sleep was interrupted, we need to update // the remained number of time to sleep. switch (errno) { case EINTR: req = rem; break; default: return STATUS_UNKNOWN_ERR; } // Update current time ctime = get_time_millis(); } return STATUS_OK; } #endif /* PLATFORM_WINDOWS */ #ifdef PLATFORM_WINDOWS status_t get_system_temporary_dir(LSPString *path) { LSPString tmp; if (get_env_var("SYSTEMROOT", &tmp) != STATUS_OK) return STATUS_NOT_FOUND; if (!tmp.append(FILE_SEPARATOR_C)) return STATUS_NO_MEM; if (!tmp.append_ascii("Temp")) return STATUS_NO_MEM; tmp.swap(path); return STATUS_OK; } status_t get_system_temporary_dir(io::Path *path) { LSPString tmp; status_t res = get_system_temporary_dir(&tmp); return (res == STATUS_OK) ? path->set(&tmp) : res; } status_t get_temporary_dir(LSPString *path) { if (get_env_var("TEMP", path) == STATUS_OK) return STATUS_OK; if (get_env_var("TMP", path) == STATUS_OK) return STATUS_OK; return get_system_temporary_dir(path); } status_t get_temporary_dir(io::Path *path) { LSPString tmp; status_t res = get_temporary_dir(&tmp); return (res == STATUS_OK) ? path->set(&tmp) : res; } status_t get_user_login(LSPString *user) { size_t capacity = 0x40; WCHAR *buf = reinterpret_cast(malloc(capacity * sizeof(WCHAR))); if (buf == NULL) return STATUS_NO_MEM; lsp_finally { free(buf); }; while (true) { DWORD buf_size = capacity; if (GetUserNameW(buf, &buf_size)) { return (user->set_utf16(buf)) ? STATUS_OK : STATUS_NO_MEM; } DWORD error = GetLastError(); switch (error) { case ERROR_INSUFFICIENT_BUFFER: break; case ERROR_NOT_ENOUGH_MEMORY: return STATUS_NO_MEM; default: return STATUS_UNKNOWN_ERR; } // Re-allocate data capacity = lsp_max(capacity << 1, buf_size + 1); WCHAR *new_buf = reinterpret_cast(realloc(buf, capacity * sizeof(WCHAR))); if (new_buf == NULL) return STATUS_NO_MEM; buf = new_buf; } } #else status_t get_user_login(LSPString *user) { size_t capacity = 0x400; char *buf = reinterpret_cast(malloc(capacity)); if (buf == NULL) return STATUS_NO_MEM; lsp_finally { free(buf); }; int error; struct passwd pwd, *rpwd = NULL; while (true) { error = getpwuid_r(geteuid(), &pwd, buf, capacity, &rpwd); if (rpwd != NULL) return (user->set_native(rpwd->pw_name)) ? STATUS_OK : STATUS_NO_MEM; switch (error) { case 0: case ENOENT: case ESRCH: case EBADF: case EPERM: return STATUS_NOT_FOUND; case EINTR: case EIO: case EMFILE: case ENFILE: return STATUS_IO_ERROR; case ENOMEM: return STATUS_NO_MEM; case ERANGE: break; default: return STATUS_UNKNOWN_ERR; } // Re-allocate data capacity <<= 1; if (capacity > 0x10000) break; char *new_buf = reinterpret_cast(realloc(buf, capacity)); if (new_buf == NULL) return STATUS_NO_MEM; buf = new_buf; } while (true) { error = getlogin_r(buf, capacity); switch (error) { case 0: return (user->set_native(buf)) ? STATUS_OK : STATUS_NO_MEM; case ERANGE: break; case EMFILE: case ENFILE: case ENXIO: case ENOTTY: return STATUS_IO_ERROR; case ENOENT: return STATUS_NOT_FOUND; case ENOMEM: return STATUS_NO_MEM; default: return STATUS_UNKNOWN_ERR; } // Re-allocate data capacity <<= 1; char *new_buf = reinterpret_cast(realloc(buf, capacity)); if (new_buf == NULL) return STATUS_NO_MEM; buf = new_buf; } } status_t get_system_temporary_dir(LSPString *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; return (path->set_ascii("/tmp")) ? STATUS_OK : STATUS_NO_MEM; } status_t get_system_temporary_dir(io::Path *path) { if (path == NULL) return STATUS_BAD_ARGUMENTS; return path->set("/tmp"); } status_t get_temporary_dir(LSPString *path) { return get_system_temporary_dir(path); } status_t get_temporary_dir(io::Path *path) { return get_system_temporary_dir(path); } #endif /* PLATFORM_WINDOWS */ status_t get_current_dir(LSPString *path) { return io::Dir::get_current(path); } status_t get_current_dir(io::Path *path) { return io::Dir::get_current(path); } status_t follow_url(const char *url) { LSPString turl; if (!turl.set_utf8(url)) return STATUS_NO_MEM; return follow_url(&turl); } status_t follow_url(const LSPString *url) { #if defined(PLATFORM_WINDOWS) const HINSTANCE hInst = ::ShellExecuteW( NULL, // Not associated with window L"open", // Open hyperlink url->get_utf16(), // The file to execute NULL, // Parameters NULL, // Directory SW_SHOWNORMAL // Show command ); if ((INT_PTR)hInst <= 32) return STATUS_UNKNOWN_ERR; #elif defined(PLATFORM_HAIKU) status_t res; ipc::Process p; if ((res = p.set_command("open")) != STATUS_OK) return STATUS_OK; if ((res = p.add_arg(url)) != STATUS_OK) return STATUS_OK; if ((res = p.launch()) != STATUS_OK) return STATUS_OK; p.wait(); #else status_t res; ipc::Process p; if ((res = p.set_command("xdg-open")) != STATUS_OK) return STATUS_OK; if ((res = p.add_arg(url)) != STATUS_OK) return STATUS_OK; if ((res = p.launch()) != STATUS_OK) return STATUS_OK; p.wait(); #endif /* PLATFORM_WINDOWS */ return STATUS_OK; } static inline bool match_string(const LSPString *s, const char **list) { for (; *list != NULL; ++list) if (s->equals_ascii(*list)) return true; return false; } static inline bool is_dummy_fs(const LSPString *fs_type, bool bind) { static const char *dummy_fs_types[] = { "autofs", "proc", "debugfs", "devpts", "fusectl", "fuse.portal", "mqueue", "rpc_pipefs", "sysfs", "devfs", "kernfs", "ignore", NULL }; if ((fs_type->equals_ascii("bind")) && (!bind)) return true; return match_string(fs_type, dummy_fs_types); } static inline bool is_remote_fs(const LSPString *fs_type, const LSPString *fs_name) { #ifdef PLATFORM_WINDOWS // TODO #endif /* PLATFORM_WINDOWS */ static const char *network_fs_types[] = { "smbfs", "smb3", "cifs", "nfs", NULL }; static const char *network_fs_names[] = { "acfs", "afs", "coda", "auristorfs", "fhgfs", "gpfs", "ibrix", "ocfs2", "vxfs", "nfs", "-hosts", NULL }; if (fs_name->index_of(':') >= 0) return true; if (fs_name->starts_with_ascii("\\\\")) return match_string(fs_type, network_fs_types); return match_string(fs_name, network_fs_names); } #ifdef PLATFORM_POSIX bool is_posix_drive(const LSPString *path) { if (!path->starts_with(FILE_SEPARATOR_C)) return false; struct stat st; if (::stat(path->get_native(), &st) != 0) return false; int mode = st.st_mode & S_IFMT; return (mode == S_IFBLK) || (mode == S_IFCHR); } #endif /* PLATFORM_POSIX */ #ifdef PLATFORM_LINUX static inline char *move_forward(char *s, char *end, size_t n) { while (n--) { s = static_cast(memchr(s, ' ', end - s)); if (s == NULL) break; ++s; } return s; } static inline status_t read_field(LSPString *dst, char *s, char *end) { char *e = static_cast(memchr(s, ' ', end - s)); if (e == NULL) return STATUS_BAD_FORMAT; // Process string in-place to remove some escapings size_t v = 0; size_t l = e - s; for (size_t i = 0; i < l; i++) { if ((s[i] == '\\') && ((i + 4) < l) && (s[i + 1] >= '0') && (s[i + 1] <= '3') && (s[i + 2] >= '0') && (s[i + 2] <= '7') && (s[i + 3] >= '0') && (s[i + 3] <= '7')) { s[v++] = (s[i + 1] - '0') * 64 + (s[i + 2] - '0') * 8 + (s[i + 3] - '0'); i += 3; } else s[v++] = s[i]; } return (dst->set_utf8(s, v)) ? STATUS_OK : STATUS_NO_MEM; } static status_t read_linux_mountinfo(lltl::parray *volumes) { status_t res; lltl::parray list; lsp_finally { free_volume_info(&list); }; // Open the file FILE *fd = fopen("/proc/self/mountinfo", "r"); if (fd == NULL) return STATUS_NOT_SUPPORTED; lsp_finally { fclose(fd); }; // Line char *line = NULL; size_t line_cap = 0; lsp_finally { if (line != NULL) free(line); }; // Read the mountinfo file // 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue // (1)(2)(3) (4) (5) (6) (7) (8) (9) (10) (11) // // (1) mount ID: unique identifier of the mount (may be reused after umount) // (2) parent ID: ID of parent (or of self for the top of the mount tree) // (3) major:minor: value of st_dev for files on filesystem // (4) root: root of the mount within the filesystem // (5) mount point: mount point relative to the process's root // (6) mount options: per mount options // (7) optional fields: zero or more fields of the form "tag[:value]" // (8) separator: marks the end of the optional fields // (9) filesystem type: name of filesystem of the form "type[.subtype]" // (10) mount source: filesystem specific information or "none" // (11) super options: per super block options // // Parsers should ignore all unrecognised optional fields. Currently the // possible optional fields are: // // shared:X mount is shared in peer group X // master:X mount is slave to peer group X // propagate_from:X mount is slave and receives propagation from peer group X (*) // unbindable mount is unbindable ssize_t len; char *end, *s; while ((len = getline(&line, &line_cap, fd)) >= 0) { // Create record volume_info_t *info = new volume_info_t(); if (info == NULL) return STATUS_NO_MEM; else if (!list.add(info)) { delete info; return STATUS_NO_MEM; } // Parse the line end = &line[len]; // root if ((s = move_forward(line, end, 3)) == NULL) return STATUS_BAD_FORMAT; if ((res = read_field(&info->root, s, end)) != STATUS_OK) return res; // mount point if ((s = move_forward(s, end, 1)) == NULL) return STATUS_BAD_FORMAT; if ((res = read_field(&info->target, s, end)) != STATUS_OK) return res; // end of the optional fields if ((s = strstr(s, " - ")) == NULL) return STATUS_BAD_FORMAT; s += 3; // filesystem type if ((res = read_field(&info->name, s, end)) != STATUS_OK) return res; // mount source if ((s = move_forward(s, end, 1)) == NULL) return STATUS_BAD_FORMAT; if ((res = read_field(&info->device, s, end)) != STATUS_OK) return res; // Produce final record info->flags = 0; if (is_dummy_fs(&info->name, false)) info->flags |= VF_DUMMY; if (is_remote_fs(&info->device, &info->name)) info->flags |= VF_REMOTE; if (is_posix_drive(&info->device)) info->flags |= VF_DRIVE; } if (!feof(fd)) return STATUS_IO_ERROR; // Commit and return list.swap(volumes); return STATUS_OK; } static status_t read_linux_mntent(const char *path, lltl::parray *volumes) { struct mntent *mnt; lltl::parray list; lsp_finally { free_volume_info(&list); }; // Open the file FILE *fd = setmntent(path, "r"); if (fd == NULL) return STATUS_NOT_SUPPORTED; lsp_finally { endmntent(fd); }; // Parse records while ((mnt = getmntent(fd)) != NULL) { // Create record volume_info_t *info = new volume_info_t(); if (info == NULL) return STATUS_NO_MEM; else if (!list.add(info)) { delete info; return STATUS_NO_MEM; } // Fill fields bool bind = hasmntopt (mnt, "bind"); if (!info->device.set_utf8(mnt->mnt_fsname)) return STATUS_NO_MEM; if (!info->target.set_utf8(mnt->mnt_dir)) return STATUS_NO_MEM; if (!info->root.set_ascii(FILE_SEPARATOR_S)) return STATUS_NO_MEM; if (!info->name.set_utf8(mnt->mnt_type)) return STATUS_NO_MEM; // Produce final record info->flags = 0; if (is_dummy_fs(&info->name, bind)) info->flags |= VF_DUMMY; if (is_remote_fs(&info->device, &info->name)) info->flags |= VF_REMOTE; if (is_posix_drive(&info->device)) info->flags |= VF_DRIVE; } // Commit and return list.swap(volumes); return STATUS_OK; } #endif /* PLATFORM_LINUX */ #if defined(PLATFORM_BSD) || defined(PLATFORM_MACOSX) static status_t read_fsstat(lltl::darray *list) { if (!list->add_n(32)) return STATUS_NO_MEM; while (true) { int res = getfsstat(list->array(), int(list->size() * sizeof(struct statfs)), MNT_WAIT); if (res < 0) { int error = errno; switch (error) { case EFAULT: return STATUS_INVALID_VALUE; case EIO: return STATUS_IO_ERROR; default: return STATUS_UNKNOWN_ERR; } } else if (size_t(res) < list->size()) { list->pop_n(list->size() - size_t(res)); return STATUS_OK; } // Grow the size of the list if (!list->add_n(list->size() >> 1)) return STATUS_NO_MEM; } } static status_t read_fsstat_mntinfo(lltl::parray *volumes) { // Read fsstat data lltl::darray fspl; status_t res = read_fsstat(&fspl); if (res != STATUS_OK) return res; // Parse fsstat data lltl::parray list; lsp_finally { free_volume_info(&list); }; for (size_t i=0, n=fspl.size(); idevice.set_utf8(fsp->f_mntfromname)) return STATUS_NO_MEM; if (!info->target.set_utf8(fsp->f_mntonname)) return STATUS_NO_MEM; if (!info->root.set_ascii(FILE_SEPARATOR_S)) return STATUS_NO_MEM; if (!info->name.set_utf8(fsp->f_fstypename)) return STATUS_NO_MEM; // Produce final record info->flags = 0; if (is_dummy_fs(&info->name, false)) info->flags |= VF_DUMMY; if (is_remote_fs(&info->device, &info->name)) info->flags |= VF_REMOTE; if (is_posix_drive(&info->device)) info->flags |= VF_DRIVE; } // Commit and return list.swap(volumes); return STATUS_OK; } #endif /* PLATFORM_BSD || PLATFORM_MACOSX */ #ifdef PLATFORM_HAIKU static status_t read_haiku_mntinfo(lltl::parray *volumes) { lltl::parray list; lsp_finally { free_volume_info(&list); }; BVolumeRoster roster; BVolume bvol; while (roster.GetNextVolume(&bvol) == B_OK) { fs_info info; if (fs_stat_dev(bvol.Device(), &info) != B_OK) continue; volume_info_t *vi = new volume_info_t(); if (vi == NULL) return STATUS_NO_MEM; if (!list.add(vi)) { delete vi; return STATUS_NO_MEM; } if (!vi->device.set_utf8(info.device_name)) return STATUS_NO_MEM; if (!vi->name.set_utf8(info.fsh_name)) return STATUS_NO_MEM; if (!vi->root.set_ascii(FILE_SEPARATOR_S)) return STATUS_NO_MEM; BDirectory bdir; if (bvol.GetRootDirectory(&bdir) == B_OK) { BPath bpath(&bdir, NULL); if (bpath.InitCheck() == B_OK && bpath.Path() != NULL) if (!vi->target.set_utf8(bpath.Path())) return STATUS_NO_MEM; } vi->flags = 0; if ((info.flags & B_FS_IS_PERSISTENT) == 0) vi->flags |= VF_DUMMY; if ((info.flags & B_FS_IS_SHARED) || is_remote_fs(&vi->device, &vi->name)) vi->flags |= VF_REMOTE; if ((info.flags & B_FS_IS_REMOVABLE) || is_posix_drive(&vi->device)) vi->flags |= VF_DRIVE; } list.swap(volumes); return STATUS_OK; } #endif /* PLATFORM_HAIKU */ #ifdef PLATFORM_WINDOWS status_t read_pathnames(const WCHAR *volume, WCHAR **list, size_t *cap) { DWORD cap_req = 0; // Obtain volume information while (true) { if (GetVolumePathNamesForVolumeNameW(volume, *list, *cap, &cap_req)) return STATUS_OK; if (GetLastError() != ERROR_MORE_DATA) return STATUS_UNKNOWN_ERR; // Allocate the desired chunk of memory cap_req = lsp::align_size(cap_req, 0x20); WCHAR *buf = static_cast(realloc(*list, (cap_req + 1) * sizeof(WCHAR))); if (buf == NULL) return STATUS_NO_MEM; *list = buf; *cap = cap_req; } } status_t read_windows_mntinfo(lltl::parray *volumes) { status_t res; lltl::parray list; lsp_finally { free_volume_info(&list); }; // Read the value WCHAR *vol_name = static_cast(malloc((MAX_PATH + 4) * 3 * sizeof(WCHAR))); if (vol_name == NULL) return STATUS_NO_MEM; lsp_finally { free(vol_name); }; WCHAR *dev_name = &vol_name[MAX_PATH + 4]; WCHAR *fs_name = &dev_name[MAX_PATH + 4]; HANDLE h = INVALID_HANDLE_VALUE; // Allocate place for the volume names size_t pth_cap = 0; WCHAR *pth_name = NULL; lsp_finally { if (pth_name != NULL) free(pth_name); }; // Start volume scanning if ((h = FindFirstVolumeW(vol_name, MAX_PATH + 4)) == INVALID_HANDLE_VALUE) return STATUS_NOT_SUPPORTED; lsp_finally { FindVolumeClose(h); }; do { // Skip the \\?\ prefix and remove the trailing backslash. WCHAR idx = wcslen(vol_name) - 1; if ((vol_name[0] != L'\\') || (vol_name[1] != L'\\') || (vol_name[2] != L'?') || (vol_name[3] != L'\\') || (vol_name[idx] != L'\\')) continue; // Obtain the device name vol_name[idx] = '\0'; DWORD chars = QueryDosDeviceW(&vol_name[4], dev_name, MAX_PATH); vol_name[idx] = '\\'; if (chars == 0) continue; // Obtain the list of path names if ((res = read_pathnames(vol_name, &pth_name, &pth_cap)) != STATUS_OK) return res; // Do simple stuff if path names have been not obtained if (*pth_name == '\0') { // Create record volume_info_t *info = new volume_info_t(); if (info == NULL) return STATUS_NO_MEM; else if (!list.add(info)) { delete info; return STATUS_NO_MEM; } // Fill volume name field if (!info->device.set_utf16(vol_name)) return STATUS_NO_MEM; if (!info->root.set_utf16(dev_name)) return STATUS_NO_MEM; if (!info->target.set_ascii("")) return STATUS_NO_MEM; if (!info->name.set_ascii("")) return STATUS_NO_MEM; // Obtain flags UINT drv_type = GetDriveTypeW(dev_name); switch (drv_type) { case DRIVE_REMOVABLE: case DRIVE_FIXED: case DRIVE_CDROM: case DRIVE_RAMDISK: info->flags = VF_DRIVE; break; case DRIVE_REMOTE: info->flags = VF_REMOTE; break; default: info->flags = 0; break; } continue; } for (WCHAR *vol_drive = pth_name; *vol_drive != '\0';) { size_t len = wcslen(vol_drive); lsp_finally { vol_drive = &vol_drive[len + 1]; }; // Obtain the volume information if (!GetVolumeInformationW(vol_drive, NULL, 0, NULL, NULL, NULL, fs_name, MAX_PATH + 4)) fs_name[0] = '\0'; // Create record volume_info_t *info = new volume_info_t(); if (info == NULL) return STATUS_NO_MEM; else if (!list.add(info)) { delete info; return STATUS_NO_MEM; } // Fill volume name field if (!info->device.set_utf16(vol_name)) return STATUS_NO_MEM; if (!info->root.set_utf16(dev_name)) return STATUS_NO_MEM; if (!info->target.set_utf16(vol_drive)) return STATUS_NO_MEM; if (!info->name.set_utf16(fs_name)) return STATUS_NO_MEM; // Obtain flags UINT drv_type = GetDriveTypeW(vol_drive); switch (drv_type) { case DRIVE_REMOVABLE: case DRIVE_FIXED: case DRIVE_CDROM: case DRIVE_RAMDISK: info->flags = VF_DRIVE; break; case DRIVE_REMOTE: info->flags = VF_REMOTE; break; default: info->flags = 0; break; } } } while (FindNextVolumeW(h, vol_name, MAX_PATH)); // Commit and return list.swap(volumes); return STATUS_OK; } status_t read_windows_netinfo(lltl::parray *volumes) { lltl::parray list; lsp_finally { free_volume_info(&list); }; // Open the enumeration NETRESOURCEW *local = NULL; HANDLE hEnum = NULL; DWORD dwResult = WNetOpenEnumW(RESOURCE_CONNECTED, RESOURCETYPE_DISK, 0, local, &hEnum); if (dwResult != NO_ERROR) return STATUS_NOT_SUPPORTED; lsp_finally { WNetCloseEnum(hEnum); }; // Iterate over resources DWORD cEntries = -1; DWORD cbBuffer = 16384; local = static_cast(GlobalAlloc(GPTR, cbBuffer)); if (local == NULL) return STATUS_NO_MEM; lsp_finally { GlobalFree(local); }; // Perform enumeration while (true) { dwResult = WNetEnumResourceW(hEnum, &cEntries, local, &cbBuffer); if (dwResult == ERROR_NO_MORE_ITEMS) break; if (dwResult == ERROR_MORE_DATA) { NETRESOURCEW *pnew = static_cast(GlobalReAlloc(local, cbBuffer, GPTR)); if (pnew == NULL) return STATUS_NO_MEM; local = pnew; continue; } if (dwResult != NO_ERROR) return STATUS_UNKNOWN_ERR; // Process each entry for (DWORD i = 0; i < cEntries; i++) { NETRESOURCEW *item = &local[i]; if (item->dwScope != RESOURCE_CONNECTED) continue; if (item->dwType != RESOURCETYPE_DISK) continue; if ((item->dwDisplayType != RESOURCEDISPLAYTYPE_SHARE) && (item->dwDisplayType != RESOURCEDISPLAYTYPE_DIRECTORY)) continue; // Create record volume_info_t *info = new volume_info_t(); if (info == NULL) return STATUS_NO_MEM; else if (!list.add(info)) { delete info; return STATUS_NO_MEM; } // Fill volume name field if (!info->device.set_utf16(item->lpProvider)) return STATUS_NO_MEM; if (!info->root.set_utf16(item->lpRemoteName)) return STATUS_NO_MEM; if (!info->target.set_utf16(item->lpLocalName)) return STATUS_NO_MEM; if (!info->target.ends_with(FILE_SEPARATOR_C)) { if (!info->target.append(FILE_SEPARATOR_C)) return STATUS_NO_MEM; } if ((item->lpComment != NULL) && (!info->name.set_utf16(item->lpComment))) return STATUS_NO_MEM; info->flags = VF_REMOTE; } } // Commit and return if (!volumes->add(&list)) return STATUS_NO_MEM; list.flush(); return STATUS_OK; } #endif /* PLATFORM_WINDOWS */ static status_t get_volume_info_impl(lltl::parray *volumes) { status_t res = STATUS_NOT_IMPLEMENTED; #if defined(PLATFORM_LINUX) if ((res = read_linux_mountinfo(volumes)) != STATUS_NOT_SUPPORTED) return res; if ((res = read_linux_mntent("/proc/self/mounts", volumes)) != STATUS_NOT_SUPPORTED) return res; if ((res = read_linux_mntent("/proc/mounts", volumes)) != STATUS_NOT_SUPPORTED) return res; if ((res = read_linux_mntent("/etc/mtab", volumes)) != STATUS_NOT_SUPPORTED) return res; #elif defined(PLATFORM_BSD) || defined(PLATFORM_MACOSX) if ((res = read_fsstat_mntinfo(volumes)) != STATUS_NOT_SUPPORTED) return res; #elif defined(PLATFORM_HAIKU) res = read_haiku_mntinfo(volumes); #elif defined(PLATFORM_WINDOWS) res = read_windows_mntinfo(volumes); if (res == STATUS_OK) res = read_windows_netinfo(volumes); #endif return res; } status_t get_volume_info(lltl::parray *volumes) { // Verify input if (volumes == NULL) return STATUS_BAD_ARGUMENTS; // Read volumes to temporary array lltl::parray temp; lsp_finally { free_volume_info(&temp); }; status_t res = get_volume_info_impl(&temp); // Commit changes if operation succeeded if (res == STATUS_OK) temp.swap(volumes); return res; } void free_volume_info(lltl::parray *volumes) { if (volumes == NULL) return; for (size_t i=0, n=volumes->size(); iuget(i); if (p != NULL) delete p; } volumes->flush(); } size_t page_size() { #ifdef PLATFORM_WINDOWS SYSTEM_INFO os_sysinfo; GetSystemInfo(&os_sysinfo); return os_sysinfo.dwPageSize; #else return sysconf(_SC_PAGESIZE); #endif /* PLATFORM_WINDOWS */ } size_t system_cores() { #ifdef PLATFORM_WINDOWS SYSTEM_INFO os_sysinfo; GetSystemInfo(&os_sysinfo); return os_sysinfo.dwNumberOfProcessors;; #else return sysconf(_SC_NPROCESSORS_ONLN); #endif /* PLATFORM_WINDOWS */ } #ifdef PLATFORM_WINDOWS static status_t append_arg_escaped(LSPString *dst, const LSPString *value) { if (value->is_empty()) return (dst->append_ascii("\"\"")) ? STATUS_OK : STATUS_NO_MEM; for (size_t i=0, n=value->length(); ichar_at(i); switch (ch) { case ' ': if (!dst->append_ascii("\" \"", 3)) return STATUS_NO_MEM; break; case '"': if (!dst->append_ascii("\\\"", 2)) return STATUS_NO_MEM; break; default: if (!dst->append(ch)) return STATUS_NO_MEM; break; } } return STATUS_OK; } static status_t run_program(const LSPString *path, const LSPString *args) { // Check that executable file exists LSPString xpath; LPCWSTR ppath = path->get_utf16(); if (!PathFileExistsW(ppath)) { // Try .EXE and .COM extensions if (path->ends_with_ascii_nocase(".exe")) return STATUS_NOT_FOUND; if (path->ends_with_ascii_nocase(".com")) return STATUS_NOT_FOUND; // Try ".EXE" if (!xpath.set(path)) return STATUS_NO_MEM; if (!xpath.append_ascii(".exe")) return STATUS_NO_MEM; ppath = xpath.get_utf16(); if (!PathFileExistsW(ppath)) { xpath.set_length(xpath.length() - 4); if (!xpath.append_ascii(".com")) return STATUS_NO_MEM; ppath = xpath.get_utf16(); if (!PathFileExistsW(ppath)) return STATUS_NOT_FOUND; } } // Launch child process STARTUPINFOW si; PROCESS_INFORMATION pi; ZeroMemory( &si, sizeof(STARTUPINFOW) ); ZeroMemory( &pi, sizeof(PROCESS_INFORMATION) ); si.cb = sizeof(si); // Start the child process. LPWSTR str_args = args->clone_utf16(); if (str_args == NULL) return STATUS_NO_MEM; lsp_finally { free(str_args); }; // Create process if(!::CreateProcessW( ppath, // Module name (use command line) str_args, // Command line NULL, // Process handle not inheritable NULL, // Thread handle not inheritable FALSE, // Set handle inheritance to FALSE DETACHED_PROCESS | CREATE_UNICODE_ENVIRONMENT, // Flags NULL, // Set-up environment block NULL, // Use parent's starting directory &si, // Pointer to STARTUPINFO structure &pi // Pointer to PROCESS_INFORMATION structure )) { const DWORD error = ::GetLastError(); lsp_warn("Failed to create child process (%d)\n", int(error)); switch (error) { case ERROR_FILE_NOT_FOUND: case ERROR_PATH_NOT_FOUND: return STATUS_NOT_FOUND; default: return STATUS_UNKNOWN_ERR; } } CloseHandle(pi.hProcess); CloseHandle(pi.hThread); return STATUS_OK; } static status_t shell_execute(const LSPString *cmd, const LSPString *args) { // If path contains separator, do not lookup PATH if (cmd->index_of(FILE_SEPARATOR_C) >= 0) return run_program(cmd, args); // Lookup PATH LSPString path, program; status_t res = get_env_var("PATH", &path); if (res != STATUS_OK) return res; ssize_t start = 0, count = path.length(), found = 0; do { // Lookup for separator found = path.index_of(start, ';'); const ssize_t next = (found >= 0) ? found : count; if (start < next) { if (!program.set(&path, start, found)) return STATUS_NO_MEM; if (!program.ends_with(FILE_SEPARATOR_C)) { if (!program.append(FILE_SEPARATOR_C)) return STATUS_NO_MEM; } if (!program.append(cmd)) return STATUS_NO_MEM; lsp_trace("%s", program.get_utf8()); if ((res = run_program(&program, args)) == STATUS_OK) return res; } start = found + 1; } while (found >= 0); return STATUS_NOT_FOUND; } status_t exec_detached(const char *program, const char * const *argv) { status_t res; LSPString args, arg; for (; (argv != NULL) && (*argv != NULL); ++argv) { // Add separator if (!args.is_empty()) { if (!args.append(' ')) return STATUS_NO_MEM; } if (!arg.set_native(*argv)) return STATUS_NO_MEM; if ((res = append_arg_escaped(&args, &arg)) != STATUS_OK) return res; } if (!arg.set_native(program)) return STATUS_NO_MEM; return shell_execute(&arg, &args); } status_t exec_detached(const LSPString *program, const LSPString * const *argv) { status_t res; LSPString args; for (; (argv != NULL) && (*argv != NULL); ++argv) { // Add separator if (!args.is_empty()) { if (!args.append(' ')) return STATUS_NO_MEM; } if ((res = append_arg_escaped(&args, *argv)) != STATUS_OK) return res; } return shell_execute(program, &args); } #else static void execvp_process(const char *cmd, char * const *argv, bool soft_exit) { fprintf(stderr, "Executing process...\n"); // Detach the process setsid(); // Launch the process if (strchr(cmd, FILE_SEPARATOR_C) != NULL) ::execv(cmd, argv); else ::execvp(cmd, argv); lsp_trace("execve failed for pid=%d, code=%d\n", int(getpid())); // Return error only if ::execvp failed if (soft_exit) ::_exit(STATUS_UNKNOWN_ERR); else ::exit(STATUS_UNKNOWN_ERR); } #ifdef POSIX_SPAWN_SETSID static status_t spawn_process(const char *cmd, char * const *argv, char * const *envp) { lsp_trace("Creating child process using posix_spawn..."); // Initialize spawn routines posix_spawnattr_t attr; if (::posix_spawnattr_init(&attr)) return STATUS_UNKNOWN_ERR; int flags = POSIX_SPAWN_SETSID; #if defined(__USE_GNU) || (defined(POSIX_SPAWN_USEVFORK)) flags |= POSIX_SPAWN_USEVFORK; // Prefer vfork over fork #endif // Prever vfork() over fork() if (::posix_spawnattr_setflags(&attr, flags)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } posix_spawn_file_actions_t actions; if (::posix_spawn_file_actions_init(&actions)) { ::posix_spawnattr_destroy(&attr); return STATUS_UNKNOWN_ERR; } // Perform posix_spawn() pid_t pid; status_t res = STATUS_OK; while (true) { int x = ::posix_spawnp(&pid, cmd, &actions, &attr, argv, envp); switch (x) { case 0: break; case EAGAIN: continue; case ENOMEM: res = STATUS_NO_MEM; break; default: res = STATUS_UNKNOWN_ERR; break; } break; } ::posix_spawn_file_actions_destroy(&actions); ::posix_spawnattr_destroy(&attr); return res; } #endif /* POSIX_SPAWN_SETSID */ static status_t vfork_process(const char *cmd, char * const *argv) { fprintf(stderr, "Creating child process using vfork()...\n"); errno = 0; #ifdef PLATFORM_MACOSX #if defined(COMPILER_CLANG) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" #elif defined(COMPILER_GCC) #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" #endif #endif /* PLATFORM_MACOSX */ // vfork() is deprecated in MacOS, we'll hide deprectation warning for that as // vfork() is a fallback case for posix_spawn. pid_t pid = ::vfork(); #ifdef PLATFORM_MACOSX #if defined(COMPILER_CLANG) #pragma clang diagnostic pop #elif defined(COMPILER_GCC) #pragma GCC diagnostic pop #endif #endif /* PLATFORM_MACOSX */ if (pid < 0) { // Failed to vfork()? int code = errno; switch (code) { case ENOMEM: return STATUS_NO_MEM; case EAGAIN: return STATUS_NO_MEM; default: return STATUS_UNKNOWN_ERR; } } else if (pid == 0) // The child process stuff execvp_process(cmd, argv, true); return STATUS_OK; } static status_t fork_process(const char *cmd, char * const *argv) { lsp_trace("Creating child process using fork()..."); errno = 0; pid_t pid = ::fork(); if (pid < 0) { // Failed to fork()? int code = errno; switch (code) { case ENOMEM: return STATUS_NO_MEM; case EAGAIN: return STATUS_NO_MEM; default: return STATUS_UNKNOWN_ERR; } } else if (pid == 0) // The child process stuff execvp_process(cmd, argv, false); return STATUS_OK; } static inline status_t do_exec_detached(const char *program, char **argv) { status_t res = STATUS_UNKNOWN_ERR; // Different behaviour, depending on POSIX_SPAWN_USEVFORK presence #ifdef POSIX_SPAWN_SETSID if (res != STATUS_OK) res = spawn_process(program, argv, environ); #endif /* POSIX_SPAWN_SETSID */ if (res != STATUS_OK) res = vfork_process(program, argv); if (res != STATUS_OK) res = fork_process(program, argv); return res; } status_t exec_detached(const char *program, const char * const *args) { if (program == NULL) return STATUS_BAD_ARGUMENTS; // Fill list of arguments lltl::parray vargs; lsp_finally { for (lltl::iterator it = vargs.values(); it; ++it) free(it.get()); }; // Put first name of program to the list char *arg = strdup(program); if (arg == NULL) return STATUS_NO_MEM; if (!vargs.add(arg)) { free(arg); return STATUS_NO_MEM; } // Put program arguments to the list for (; (args != NULL) && (*args != NULL); ++args) { arg = strdup(*args); if (arg == NULL) return STATUS_NO_MEM; if (!vargs.add(arg)) { free(arg); return STATUS_NO_MEM; } } // Put terminating NULL pointer if (!vargs.add(static_cast(NULL))) return STATUS_NO_MEM; return do_exec_detached(program, vargs.array()); } status_t exec_detached(const LSPString *program, const LSPString * const *args) { if (program == NULL) return STATUS_BAD_ARGUMENTS; // Fill list of arguments lltl::parray vargs; lsp_finally { for (lltl::iterator it = vargs.values(); it; ++it) free(it.get()); }; // Put first name of program to the list char *arg = program->clone_native(); if (arg == NULL) return STATUS_NO_MEM; if (!vargs.add(arg)) { free(arg); return STATUS_NO_MEM; } // Put program arguments to the list for (; (args != NULL) && (*args != NULL); ++args) { arg = (*args)->clone_native(); if (arg == NULL) return STATUS_NO_MEM; if (!vargs.add(arg)) { free(arg); return STATUS_NO_MEM; } } // Put terminating NULL pointer if (!vargs.add(static_cast(NULL))) return STATUS_NO_MEM; return do_exec_detached(program->get_native(), vargs.array()); } #endif /* PLATFORM_WINDOWS */ } /* namespace system */ } /* namespace lsp */