#include "dir_access_unix.h"

#include "core/os/memory.h"

#include "core/string/print_string.h"

#include "core/templates/list.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/statvfs.h>

#ifdef HAVE_MNTENT

#include <mntent.h>

#endif

Error DirAccessUnix::list_dir_begin() {

list_dir_end(); //close any previous dir opening!

GLOBAL_LOCK_FUNCTION

if (p_file.is_relative_path()) {

}

p_file = fix_path(p_file);

bool success = (stat(p_file.utf8().get_data(), &flags) == 0);

if (success && S_ISDIR(flags.st_mode)) {

GLOBAL_LOCK_FUNCTION

if (p_dir.is_relative_path()) {

}

p_dir = fix_path(p_dir);

bool success = (stat(p_dir.utf8().get_data(), &flags) == 0);

return (success && S_ISDIR(flags.st_mode));

GLOBAL_LOCK_FUNCTION

if (p_dir.is_relative_path()) {

}

p_dir = fix_path(p_dir);

GLOBAL_LOCK_FUNCTION

if (p_dir.is_relative_path()) {

}

p_dir = fix_path(p_dir);

uint64_t DirAccessUnix::get_modified_time(String p_file) {

if (p_file.is_relative_path()) {

}

p_file = fix_path(p_file);

bool success = (stat(p_file.utf8().get_data(), &flags) == 0);

if (success) {

// known if it points to a directory. stat() will resolve the link

// for us.

if (entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK) {

if (stat(f.utf8().get_data(), &flags) == 0) {

_cisdir = S_ISDIR(flags.st_mode);

} else {

#endif

static void _get_drives(List<String> *list) {

list->push_back("/");

#if defined(HAVE_MNTENT) && defined(X11_ENABLED)

FILE *mtab = setmntent("/etc/mtab", "r");

if (mtab) {

struct mntent mnt;

}

#endif

const char *home = getenv("HOME");

if (home) {

// Only add if it's not a duplicate

list->push_back(home_name);

}

char path[1024];

snprintf(path, 1024, "%s/.config/gtk-3.0/bookmarks", home);

FILE *fd = fopen(path, "r");

while (fgets(string, 1024, fd)) {

// Parse only file:// links

if (strncmp(string, "file://", 7) == 0) {

String fpath = String::utf8(string + 7).strip_edges().split_spaces()[0].uri_decode();

if (!list->find(fpath)) {

list->push_back(fpath);

fclose(fd);

}

}

list->sort();

GLOBAL_LOCK_FUNCTION

if (p_dir.is_relative_path()) {

}

p_dir = fix_path(p_dir);

String prev_dir;

char real_current_dir_name[2048];

ERR_FAIL_COND_V(getcwd(real_current_dir_name, 2048) == nullptr, ERR_BUG);

prev_dir = real_current_dir_name; //no utf8, maybe latin?

}

// try_dir is the directory we are trying to change into

String try_dir = "";

if (p_dir.is_relative_path()) {

next_dir = next_dir.simplify_path();

try_dir = next_dir;

} else {

Error DirAccessUnix::rename(String p_path, String p_new_path) {

if (p_path.is_relative_path()) {

}

p_path = fix_path(p_path);

if (p_new_path.is_relative_path()) {

}

p_new_path = fix_path(p_new_path);

Error DirAccessUnix::remove(String p_path) {

if (p_path.is_relative_path()) {

}

p_path = fix_path(p_path);

if ((stat(p_path.utf8().get_data(), &flags) != 0)) {

return FAILED;

}

bool DirAccessUnix::is_link(String p_file) {

if (p_file.is_relative_path()) {

}

p_file = fix_path(p_file);

if ((lstat(p_file.utf8().get_data(), &flags) != 0)) {

return FAILED;

}

String DirAccessUnix::read_link(String p_file) {

if (p_file.is_relative_path()) {

}

p_file = fix_path(p_file);

Error DirAccessUnix::create_link(String p_source, String p_target) {

if (p_target.is_relative_path()) {

}

p_source = fix_path(p_source);

}

uint64_t DirAccessUnix::get_space_left() {

struct statvfs vfs;

if (statvfs(current_dir.utf8().get_data(), &vfs) != 0) {

return 0;

}

return (uint64_t)vfs.f_bavail * (uint64_t)vfs.f_frsize;

}

String DirAccessUnix::get_filesystem_type() const {

// set current directory to an absolute path of the current directory

char real_current_dir_name[2048];

ERR_FAIL_COND(getcwd(real_current_dir_name, 2048) == nullptr);

current_dir = real_current_dir_name;

}

list_dir_end();

}

#ifndef DIR_ACCESS_UNIX_H

#define DIR_ACCESS_UNIX_H

#include "core/io/dir_access.h"

class DirAccessUnix : public DirAccess {

DIR *dir_stream = nullptr;

bool _cisdir = false;

bool _cishidden = false;

protected:

virtual String fix_unicode_name(const char *p_name) const { return String::utf8(p_name); }

virtual bool is_hidden(const String &p_name);

public:

virtual uint64_t get_modified_time(String p_file);

DirAccessUnix();

~DirAccessUnix();

};

#include "file_access_unix.h"

#include "core/os/os.h"

#include "core/string/print_string.h"

#include <sys/stat.h>

#include <sys/types.h>

#if defined(UNIX_ENABLED)

#include <unistd.h>

#endif

#ifdef MSVC

#define S_ISREG(m) ((m)&_S_IFREG)

#include <io.h>

#define S_ISREG(m) ((m)&S_IFREG)

#endif

void FileAccessUnix::check_errors() const {

ERR_FAIL_COND_MSG(!f, "File must be opened before use.");

}

}

_close();

path_src = p_path;

backend (unix-compatible mostly) supports utf8 encoding */

//printf("opening %s as %s\n", p_path.utf8().get_data(), path.utf8().get_data());

int err = stat(path.utf8().get_data(), &st);

if (!err) {

switch (st.st_mode & S_IFMT) {

int fd = fileno(f);

if (fd != -1) {

int opts = fcntl(fd, F_GETFD);

fcntl(fd, F_SETFD, opts | FD_CLOEXEC);

}

last_error = OK;

bool FileAccessUnix::file_exists(const String &p_path) {

int err;

String filename = fix_path(p_path);

// Does the name exist at all?

uint64_t FileAccessUnix::_get_modified_time(const String &p_file) {

String file = fix_path(p_file);

int err = stat(file.utf8().get_data(), &flags);

if (!err) {

uint32_t FileAccessUnix::_get_unix_permissions(const String &p_file) {

String file = fix_path(p_file);

int err = stat(file.utf8().get_data(), &flags);

if (!err) {

return FAILED;

}

CloseNotificationFunc FileAccessUnix::close_notification_func = nullptr;

FileAccessUnix::~FileAccessUnix() {

_close();

}

#include <stdio.h>

typedef void (*CloseNotificationFunc)(const String &p_file, int p_flags);

String path;

String path_src;

void _close();

public:

static CloseNotificationFunc close_notification_func;

FileAccessUnix() {}

virtual ~FileAccessUnix();

};

int s = getaddrinfo(p_hostname.utf8().get_data(), nullptr, &hints, &result);

if (s != 0) {

return;

}

if (result == nullptr || result->ai_addr == nullptr) {

if (result) {

freeaddrinfo(result);

}

};

#endif

#endif // IP_UNIX_H

#include "net_socket_posix.h"

#ifndef UNIX_SOCKET_UNAVAILABLE

#if defined(UNIX_ENABLED)

#include <errno.h>

#include <netdb.h>

#include <poll.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include <unistd.h>

#include <arpa/inet.h>

#endif

// BSD calls this flag IPV6_JOIN_GROUP

#if !defined(IPV6_ADD_MEMBERSHIP) && defined(IPV6_JOIN_GROUP)

#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP

#define SIO_UDP_NETRESET _WSAIOW(IOC_VENDOR, 15)

#endif

size_t NetSocketPosix::_set_addr_storage(struct sockaddr_storage *p_addr, const IPAddress &p_ip, uint16_t p_port, IP::Type p_ip_type) {

memset(p_addr, 0, sizeof(struct sockaddr_storage));

close();

}

#if defined(__GNUC__) && !defined(__clang__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wlogical-op"

void NetSocketPosix::_set_close_exec_enabled(bool p_enabled) {

#ifndef WINDOWS_ENABLED

// Enable close on exec to avoid sharing with subprocesses. Off by default on Windows.

int opts = fcntl(_sock, F_GETFD);

fcntl(_sock, F_SETFD, opts | FD_CLOEXEC);

#endif

}

Error NetSocketPosix::open(Type p_sock_type, IP::Type &ip_type) {

ERR_FAIL_COND(!is_open());

int ret = 0;

unsigned long par = p_enabled ? 0 : 1;

ret = SOCK_IOCTL(_sock, FIONBIO, &par);

#else

Error NetSocketPosix::leave_multicast_group(const IPAddress &p_multi_address, String p_if_name) {

return _change_multicast_group(p_multi_address, p_if_name, false);

}

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

#include "core/io/net_socket.h"

~NetSocketPosix();

};

#include <sys/sysctl.h>

#endif

#include <dlfcn.h>

#include <errno.h>

#include <poll.h>

#include <time.h>

#include <unistd.h>

// Random location for getentropy. Fitting.

#include <sys/random.h>

#define UNIX_GET_ENTROPY

_clock_start = mach_absolute_time() * _clock_scale;

}

#else

#define GODOT_CLOCK CLOCK_MONOTONIC_RAW

#else

#define GODOT_CLOCK CLOCK_MONOTONIC

}

#endif

static void handle_interrupt(int sig) {

if (!EngineDebugger::is_active()) {

return;

}

void OS_Unix::initialize_core() {

init_thread_posix();

FileAccess::make_default<FileAccessUnix>(FileAccess::ACCESS_RESOURCES);

FileAccess::make_default<FileAccessUnix>(FileAccess::ACCESS_USERDATA);

DirAccess::make_default<DirAccessUnix>(DirAccess::ACCESS_USERDATA);

DirAccess::make_default<DirAccessUnix>(DirAccess::ACCESS_FILESYSTEM);

NetSocketPosix::make_default();

IPUnix::make_default();

_setup_clock();

}

NetSocketPosix::cleanup();

}

String OS_Unix::get_stdin_string(bool p_block) {

if (p_block) {

char buff[1024];

left -= chunk;

ofs += chunk;

} while (left > 0);

#elif !defined(NO_URANDOM)

int r = open("/dev/urandom", O_RDONLY);

ERR_FAIL_COND_V(r < 0, FAILED);

return "Unix";

}

double OS_Unix::get_unix_time() const {

struct timeval tv_now;

gettimeofday(&tv_now, nullptr);

return (double)tv_now.tv_sec + double(tv_now.tv_usec) / 1000000;

}

time_t t = time(nullptr);

struct tm lt;

if (p_utc) {

} else {

localtime_r(&t, &lt);

}

ret.year = 1900 + lt.tm_year;

// Index starting at 1 to match OS_Unix::get_date

// and Windows SYSTEMTIME and tm_mon follows the typical structure

ret.month = (Month)(lt.tm_mon + 1);

ret.day = lt.tm_mday;

ret.weekday = (Weekday)lt.tm_wday;

ret.hour = lt.tm_hour;

ret.minute = lt.tm_min;

ret.second = lt.tm_sec;

return ret;

}

Error OS_Unix::execute(const String &p_path, const List<String> &p_arguments, String *r_pipe, int *r_exitcode, bool read_stderr, Mutex *p_pipe_mutex, bool p_open_console) {

#ifdef __EMSCRIPTEN__

// Don't compile this code at all to avoid undefined references.

ERR_FAIL_V(ERR_BUG);

#else

if (r_pipe) {

if (p_pipe_mutex) {

p_pipe_mutex->lock();

}

if (p_pipe_mutex) {

p_pipe_mutex->unlock();

}

Error OS_Unix::create_process(const String &p_path, const List<String> &p_arguments, ProcessID *r_child_id, bool p_open_console) {

#ifdef __EMSCRIPTEN__

// Don't compile this code at all to avoid undefined references.

ERR_FAIL_V(ERR_BUG);

#else

pid_t pid = fork();

if (!FileAccess::exists(path)) {

// This code exists so GDExtension can load .so files from within the executable path.

}

if (!FileAccess::exists(path)) {

// This code exists so GDExtension can load .so files from a standard unix location.

}

p_library_handle = dlopen(path.utf8().get_data(), RTLD_NOW);

return setenv(p_var.utf8().get_data(), p_value.utf8().get_data(), /* overwrite: */ true) == 0;

}

String OS_Unix::get_user_data_dir() const {

if (!appname.is_empty()) {

if (use_custom_dir) {

if (custom_dir.is_empty()) {

custom_dir = appname;

}

} else {

}

}

}

String OS_Unix::get_executable_path() const {

WARN_PRINT("MAXPATHLEN is too small");

}

delete[] resolved_path;

return path;

public:

OS_Unix();

virtual String get_stdin_string(bool p_block) override;

virtual Error open_dynamic_library(const String p_path, void *&p_library_handle, bool p_also_set_library_path = false, String *r_resolved_path = nullptr) override;

virtual Error close_dynamic_library(void *p_library_handle) override;

virtual Error set_cwd(const String &p_cwd) override;

virtual String get_name() const override;

virtual TimeZoneInfo get_time_zone_info() const override;

virtual double get_unix_time() const override;

virtual bool set_environment(const String &p_var, const String &p_value) const override;

virtual String get_locale() const override;

virtual void initialize_debugging() override;

virtual String get_executable_path() const override;

virtual ~UnixTerminalLogger();

};

virtual ~SyslogLogger();

};

/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

/*************************************************************************/

#include "thread_posix.h"

}

void init_thread_posix() {

}

#ifndef THREAD_POSIX_H

#define THREAD_POSIX_H

void init_thread_posix();