/// \file /// a bunch of OS-dependent functions #ifndef OS_H_ #define OS_H_ #include "base.h" typedef enum { FS_NON_EXISTENT, FS_FILE, FS_DIRECTORY, FS_OTHER } FsType; enum { FS_PERMISSION_READ = 0x01, FS_PERMISSION_WRITE = 0x02, }; typedef u8 FsPermission; typedef struct { FsType type; char name[]; } FsDirectoryEntry; /// returns what kind of thing this is. FsType fs_path_type(const char *path); FsPermission fs_path_permission(const char *path); /// Does this file exist? Returns false for directories. bool fs_file_exists(const char *path); /// Returns a NULL-terminated array of the files/directories in this directory, or NULL if the directory does not exist/out of memory. /// When you're done with the entries, call fs_dir_entries_free (or call free on each entry, then on the whole array). /// NOTE: The files/directories aren't returned in any particular order! FsDirectoryEntry **fs_list_directory(const char *dirname); /// Create the directory specified by `path`\n /// Returns:\n /// 1 if the directory was created successfully\n /// 0 if the directory already exists\n /// -1 if the path already exists, but it's not a directory, or if there's another error (e.g. don't have permission to create directory).\n int fs_mkdir(const char *path); // Puts the current working directory into buf, including a null-terminator, writing at most buflen bytes.\n // Returns:\n // 1 if the working directory was inserted into buf successfully\n // 0 if buf is too short to hold the cwd\n // -1 if we can't get the cwd for whatever reason.\n int os_get_cwd(char *buf, size_t buflen); // Unlike ISO C rename() function, this will overwrite `newname` if it exists.\n // Returns:\n // >= 0 if successful\n // < 0 on error\n int os_rename_overwrite(const char *oldname, const char *newname); struct timespec time_last_modified(const char *filename); struct timespec time_get(void); /// sleep for a certain number of nanoseconds void time_sleep_ns(u64 ns); /// runs xdg-open or equivalent on the given path, which can be a URL. /// /// returns `true` on success. bool open_with_default_application(const char *path); /// equivalent to POSIX function chdir, but returns `true` on success and `false` on failure. bool change_directory(const char *path); /// free the entries generated by fs_list_directory. static void fs_dir_entries_free(FsDirectoryEntry **entries) { for (int i = 0; entries[i]; ++i) free(entries[i]); free(entries); } /// get current time in seconds since some arbitrary point static double time_get_seconds(void) { struct timespec t = time_get(); return (double)t.tv_sec + (double)t.tv_nsec * 1e-9; } /// sleep for microseconds static void time_sleep_us(u64 us) { time_sleep_ns(us * 1000); } /// sleep for milliseconds static void time_sleep_ms(u64 ms) { time_sleep_ns(ms * 1000000); } /// sleep for seconds static void time_sleep_s(u64 s) { time_sleep_ns(s * 1000000000); } /// a process typedef struct Process Process; /// zero everything except what you're using typedef struct { bool separate_stderr; const char *working_directory; /// for forwards compatibility char _reserved[256]; } ProcessSettings; typedef struct { /// string like "exited with code 9" char message[62]; /// it might be possible that both `signalled` and `exited` are false, /// if something weird happens. bool signalled; bool exited; /// only relevant if `exited = true` int exit_code; /// only relevant if `signalled = true` int signal; } ProcessExitInfo; /// get process ID of this process int process_get_id(void); /// execute the given command (like if it was passed to `system()`), creating a new \ref Process object. /// /// returns a valid process object on failure, but it will have an error, according to \ref process_geterr Process *process_run_ex(const char *command, const ProcessSettings *settings); /// like \ref process_run_ex, but with the default settings Process *process_run(const char *command); /// returns the error last error produced, or NULL if there was no error. const char *process_geterr(Process *process); /// write to stdin /// /// \returns -2 on error,\n /// -1 if the read end of the pipe was closed,\n /// or a non-negative number indicating the number of bytes written. long long process_write(Process *process, const char *data, size_t size); /// read from stdout+stderr. /// /// \returns /// -2 on error\n /// -1 if no data is available right now\n /// 0 on end of file\n /// or a positive number indicating the number of bytes read to `data` (at most `size`)\n /// This does a nonblocking read. long long process_read(Process *process, char *data, size_t size); /// like \ref process_read, but reads stderr. /// /// this function ALWAYS RETURNS -2 if `separate_stderr` is not specified in the \ref ProcessSettings. /// if `separate_stderr` is false, then both stdout and stderr will be sent via \ref process_read. long long process_read_stderr(Process *process, char *data, size_t size); /// Checks if the process has exited. /// /// \returns /// -1 if the process returned a non-zero exit code, or got a signal.\n /// 1 if the process exited successfully\n /// 0 if the process hasn't exited.\n /// If the process has exited, `*info` will be filled out with details. /// if the process is no longer running, `*process` will be freed and set to NULL. int process_check_status(Process **process, ProcessExitInfo *info); /// kills process if still running /// /// this also frees any resources used by `*process`. /// `*process` will be set to NULL. void process_kill(Process **process); typedef struct Socket Socket; /// create TCP socket with address and port. /// /// currently only supports IPv4. /// if you pass `NULL` for `address`, `127.0.0.1` will be used. Socket *socket_connect_tcp(const char *address, u16 port); /// get last error from socket /// /// returns `""` if there is no error. const char *socket_get_error(Socket *socket); /// read from socket. /// /// \returns /// -2 on error\n /// -1 if no data is available right now\n /// 0 on end of file\n /// or a positive number indicating the number of bytes read to `data` (at most `size`)\n /// This does a nonblocking read. long long socket_read(Socket *socket, char *data, size_t size); /// write to socket /// /// \returns -2 on error\n /// -1 if the read end of the socket was closed\n /// or a non-negative number indicating the number of bytes written. long long socket_write(Socket *socket, const char *data, size_t size); #endif // OS_H_