os.h

Go to the documentation of this file.

 
#ifndef OS_H
#define OS_H
 
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/time.h> // required for `struct timeval`
#include <sys/types.h>
#include <unistd.h>
#include <utarray.h>
 
#include "hashmap.h"
#include "log.h"
 
/* Common costant definitions */
#define MAX_OS_PATH_LEN 4096
#define MAX_WEB_PATH_LEN 2048
#define MAX_RANDOM_UUID_LEN 37
 
#define OS_HOST_NAME_MAX 64
 
#ifndef BIT
#define BIT(x) (1U << (x))
#endif
 
#ifndef ARRAY_SIZE
#define ARRAY_SIZE(s) (sizeof(s) / sizeof(s[0]))
#endif
 
#define BD_NO_CHDIR 01       /* Don't chdir("/") */
#define BD_NO_CLOSE_FILES 02 /* Don't close all open files */
#define BD_NO_REOPEN_STD_FDS                                                   \
  04                     /* Don't reopen stdin, stdout, and                    \
                            stderr to /dev/null */
#define BD_NO_UMASK0 010 /* Don't do a umask(0) */
#define BD_MAX_CLOSE                                                           \
  8192 /* Maximum file descriptors to close if                                 \
         sysconf(_SC_OPEN_MAX) is indeterminate */
 
#ifndef os_strlen
// Used by code taken from hostapd
#define os_strlen(s) strlen((s))
#endif
 
#ifndef os_snprintf
#define os_snprintf(s, maxlen, ...) snprintf((s), (maxlen), __VA_ARGS__)
#endif
 
#ifndef os_strncmp
#define os_strncmp(s1, s2, n) strncmp((s1), (s2), (n))
#endif
 
#ifndef os_strstr
#define os_strstr(s1, s2) strstr((s1), (s2))
#endif
 
#ifndef os_strcmp
#define os_strcmp(s1, s2) strcmp((s1), (s2))
#endif
 
#ifndef os_strchr
#define os_strchr(s, c) strchr((s), (c))
#endif
 
struct find_dir_type {
  int proc_running;
  const char *proc_name;
};
 
typedef long os_time_t;
 
struct os_time {
  os_time_t sec;
  os_time_t usec;
};
 
struct os_reltime {
  os_time_t sec;
  os_time_t usec;
};
 
int become_daemon(int flags);
 
#define os_get_time(t) edge_os_get_time(t)
 
int edge_os_get_time(struct os_time *t);
 
int edge_os_get_reltime(struct os_reltime *t);
 
#ifndef os_get_reltime
#define os_get_reltime(t) edge_os_get_reltime((t))
#endif
 
static inline int os_reltime_before(const struct os_reltime *a,
                                    const struct os_reltime *b) {
  return (a->sec < b->sec) || (a->sec == b->sec && a->usec < b->usec);
}
 
static inline void os_reltime_sub(const struct os_reltime *a,
                                  const struct os_reltime *b,
                                  struct os_reltime *res) {
  *res = (struct os_reltime){
      .sec = a->sec - b->sec,
      .usec = a->usec - b->usec,
  };
  if (res->usec < 0) {
    res->sec--;
    res->usec += 1000000;
  }
}
 
int os_get_timestamp(uint64_t *timestamp);
 
void os_to_timestamp(struct timeval ts, uint64_t *timestamp);
 
#define os_get_random(buf, len) edge_os_get_random((buf), (len))
 
int edge_os_get_random(unsigned char *buf, size_t len);
 
int os_get_random_int_range(int low, int up);
 
void os_init_random_seed(void);
 
int os_get_random_number_s(unsigned char *buf, size_t len);
 
int8_t hex2num(char c);
 
int edge_hexstr2bin(const char *hex, uint8_t *buf, size_t len);
 
bool is_number(const char *ptr);
 
#define os_strlcpy(dest, src, siz) edge_os_strlcpy((dest), (src), (siz))
 
size_t edge_os_strlcpy(char *restrict dest, const char *restrict src,
                       size_t siz);
 
size_t os_strnlen_s(const char *str, size_t max_len);
 
#define os_memcmp_const(a, b, len) edge_os_memcmp_const((a), (b), (len))
 
int edge_os_memcmp_const(const void *a, const void *b, size_t len);
 
/*
 * gcc 4.4 ends up generating strict-aliasing warnings about some very common
 * networking socket uses that do not really result in a real problem and
 * cannot be easily avoided with union-based type-punning due to struct
 * definitions including another struct in system header files. To avoid having
 * to fully disable strict-aliasing warnings, provide a mechanism to hide the
 * typecast from aliasing for now. A cleaner solution will hopefully be found
 * in the future to handle these cases.
 */
void *__hide_aliasing_typecast(void *foo);
#define aliasing_hide_typecast(a, t) (t *)__hide_aliasing_typecast((a))
 
typedef void (*process_callback_fn)(void *ctx, void *buf, size_t count);
 
char **copy_argv(const char *const argv[]);
 
int run_command(char *const argv[], char *const envp[], process_callback_fn fn,
                void *ctx);
 
int run_argv_command(const char *path, const char *const argv[],
                     process_callback_fn fn, void *ctx);
 
void replace_string_char(char *s, char in, char out);
 
typedef int (*split_string_fn)(const char *, size_t, void *);
 
ssize_t split_string(const char *str, char sep, split_string_fn fun,
                     void *data);
 
ssize_t split_string_array(const char *str, char sep, UT_array *arr);
 
char *concat_paths(const char *path_left, const char *path_right);
 
char *get_valid_path(const char *path);
 
char *construct_path(const char *path_left, const char *path_right);
 
char *get_secure_path(const UT_array *bin_path_arr, const char *filename,
                      bool real);
 
typedef bool (*list_dir_fn)(char *, void *args);
 
int list_dir(const char *dirpath, list_dir_fn fun, void *args);
 
pid_t is_proc_app(const char *path, const char *proc_name);
 
bool kill_process(char *proc_name);
 
bool signal_process(const char *proc_name, int sig);
 
int run_process(char *argv[], pid_t *child_pid);
 
int is_proc_running(const char *name);
 
int make_file_exec_fd(int fd);
 
char *rtrim(char *str, const char *seps);
 
char *string_array2string(const char *const strings[]);
 
void generate_radom_uuid(char rid[static MAX_RANDOM_UUID_LEN]);
 
bool find_dir_proc_fn(char *path, void *args);
 
int exist_dir(const char *dirpath);
 
int make_dirs_to_path(const char *file_path, mode_t mode);
 
int create_dir(const char *dirpath, mode_t mode);
 
int create_pipe_file(const char *path);
 
int check_file_exists(const char *path, struct stat *sb);
 
int check_sock_file_exists(const char *path);
 
int get_hostname(char buf[static OS_HOST_NAME_MAX]);
 
int create_pid_file(const char *pid_file, int flags);
 
ssize_t read_file(const char *path, uint8_t **out);
 
int read_file_string(const char *path, char **out);
 
ssize_t open_write_nonblock(const char *path, int *fd, const uint8_t *buffer,
                            size_t length);
 
int get_commands_paths(const char *commands[], const UT_array *bin_path_arr,
                       hmap_str_keychar **hmap_bin_paths);
 
char *string_append_char(const char *str, char character);
#endif /* OS_H */