zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/utils/db.c

@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include <string.h>
+#include <sqlite3.h>
+#include <jsonwriter.h>
+#include <zsv/utils/string.h>
+
+// starts_w_str_underscore(): helper function
+// returns 1 if s starts with prefix (case-insensitive), followed by underscore
+static char starts_w_str_underscore(const unsigned char *s, size_t s_len, const unsigned char *prefix) {
+  char result = 0;
+  unsigned char *s_lc = zsv_strtolowercase(s, &s_len);
+  size_t pfx_len = strlen((const char *)prefix);
+  unsigned char *prefix_lc = zsv_strtolowercase(prefix, &pfx_len);
+  if (pfx_len + 1 < s_len && !memcmp(s_lc, prefix_lc, pfx_len) && s_lc[pfx_len] == '_')
+    result = 1;
+  free(s_lc);
+  free(prefix_lc);
+  return result;
+}
+
+int zsv_dbtable2json(sqlite3 *db, const char *tname, jsonwriter_handle jsw, size_t limit) {
+  int err = 0;
+  const char *index_sql = "select name, sql from sqlite_master where type = 'index' and tbl_name = :tbl_name";
+  const char *unique_sql = "select 1 from PRAGMA_index_list(?) where name = ? and [unique] <> 0";
+  sqlite3_str *data_sql = sqlite3_str_new(db);
+  if (data_sql) {
+    sqlite3_str_appendf(data_sql, "select * from \"%w\"", tname);
+    sqlite3_stmt *data_stmt = NULL;
+    sqlite3_stmt *index_stmt = NULL;
+    sqlite3_stmt *unique_stmt = NULL;
+    int colcount = 0;
+
+    err = 1;
+    if (sqlite3_prepare_v2(db, sqlite3_str_value(data_sql), -1, &data_stmt, NULL) != SQLITE_OK)
+      fprintf(stderr, "Unable to prepare %s: %s\n", sqlite3_str_value(data_sql), sqlite3_errmsg(db));
+    else if (!(colcount = sqlite3_column_count(data_stmt)))
+      fprintf(stderr, "No columns found in table %s\n", tname);
+    else if (sqlite3_prepare_v2(db, index_sql, -1, &index_stmt, NULL) != SQLITE_OK)
+      fprintf(stderr, "Unable to prepare %s: %s\n", index_sql, sqlite3_errmsg(db));
+    else if (sqlite3_prepare_v2(db, unique_sql, -1, &unique_stmt, NULL) != SQLITE_OK)
+      fprintf(stderr, "Unable to prepare %s: %s\n", unique_sql, sqlite3_errmsg(db));
+    else {
+      err = 0;
+      jsonwriter_start_array(jsw); // output is an array with 2 items: meta and data
+
+      // ----- meta: columns and index info
+      jsonwriter_start_object(jsw);
+
+      jsonwriter_object_cstr(jsw, "name", tname);
+
+      // indexes
+      jsonwriter_object_object(jsw, "indexes"); // indexes
+      sqlite3_bind_text(index_stmt, 1, tname, (int)strlen(tname), SQLITE_STATIC);
+      while (sqlite3_step(index_stmt) == SQLITE_ROW) {
+        const unsigned char *text = sqlite3_column_text(index_stmt, 0);
+        const unsigned char *ix_sql = sqlite3_column_text(index_stmt, 1);
+        size_t len = text ? sqlite3_column_bytes(index_stmt, 0) : 0;
+        size_t ix_sql_len = ix_sql ? sqlite3_column_bytes(index_stmt, 1) : 0;
+
+        if (text && ix_sql && len && ix_sql_len) {
+          // on: for now we just look for the first and last parens
+          const unsigned char *first_paren = memchr(ix_sql, '(', ix_sql_len);
+          const unsigned char *last_paren = ix_sql + ix_sql_len;
+          while (first_paren && last_paren > first_paren + 1 && *last_paren != ')')
+            last_paren--;
+          if (first_paren && last_paren > first_paren) {
+            // name
+
+            // strip the leading "tablename_" from the index name
+            const char *ix_name = (const char *)text;
+            size_t ix_name_len = len;
+            if (ix_name_len > strlen(tname) + 1 &&
+                starts_w_str_underscore((const unsigned char *)ix_name, ix_name_len, (const unsigned char *)tname)) {
+              ix_name += strlen(tname) + 1;
+              ix_name_len -= strlen(tname) + 1;
+            }
+            jsonwriter_object_keyn(jsw, (const char *)ix_name, ix_name_len);
+
+            // ix obj
+            jsonwriter_start_object(jsw);
+
+            // on
+            jsonwriter_object_strn(jsw, "on", first_paren + 1, last_paren - first_paren - 1);
+
+            // unique
+            sqlite3_bind_text(unique_stmt, 1, tname, (int)strlen(tname), SQLITE_STATIC);
+            sqlite3_bind_text(unique_stmt, 2, (const char *)text, len, SQLITE_STATIC);
+            if (sqlite3_step(unique_stmt) == SQLITE_ROW)
+              jsonwriter_object_bool(jsw, "unique", 1);
+            sqlite3_reset(unique_stmt);
+
+            // end ix obj
+            jsonwriter_end_object(jsw);
+          }
+        }
+      }
+      jsonwriter_end_object(jsw); // end indexes
+
+      // columns
+      jsonwriter_object_array(jsw, "columns");
+      for (int i = 0; i < colcount; i++) {
+        const char *colname = sqlite3_column_name(data_stmt, i);
+        jsonwriter_start_object(jsw);
+        jsonwriter_object_cstr(jsw, "name", colname);
+        const char *dtype = sqlite3_column_decltype(data_stmt, i);
+        if (dtype)
+          jsonwriter_object_cstr(jsw, "datatype", dtype);
+
+        // TO DO: collate nocase etc
+        jsonwriter_end_object(jsw);
+      }
+      jsonwriter_end_array(jsw); // end columns
+
+      jsonwriter_end_object(jsw); // end meta obj
+
+      // ------ data: array of rows
+      jsonwriter_start_array(jsw);
+      // for each row
+      size_t count = 0;
+      while (sqlite3_step(data_stmt) == SQLITE_ROW) {
+        jsonwriter_start_array(jsw); // start row
+        for (int i = 0; i < colcount; i++) {
+          const unsigned char *text = sqlite3_column_text(data_stmt, i);
+          if (text) {
+            int len = sqlite3_column_bytes(data_stmt, i);
+            jsonwriter_strn(jsw, text, len);
+          } else
+            jsonwriter_null(jsw);
+        }
+        jsonwriter_end_array(jsw); // end row
+        if (limit && ++count >= limit)
+          break;
+      }
+      jsonwriter_end_array(jsw);
+
+      jsonwriter_end_array(jsw); // end of output
+    }
+    if (data_stmt)
+      sqlite3_finalize(data_stmt);
+    if (index_stmt)
+      sqlite3_finalize(index_stmt);
+    if (unique_stmt)
+      sqlite3_finalize(unique_stmt);
+
+    sqlite3_free(sqlite3_str_finish(data_sql));
+  } // if data_sql
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/dirs-no-jq.c

@@ -0,0 +1,2 @@
+#define ZSV_NO_JQ
+#include "dirs.c"

data/ext/zsv/vendor/zsv-1.3.0/app/utils/dirs.c

@@ -0,0 +1,427 @@
+/*
+ * Copyright (C) 2021 Liquidaty and the zsv/lib contributors
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <dirent.h>
+#include <errno.h>
+#include <zsv/utils/os.h>
+#ifndef ZSV_NO_JQ
+#include <zsv/utils/json.h>
+#include <zsv/utils/jq.h>
+#endif
+#include <zsv/utils/dirs.h>
+#include <zsv/utils/string.h>
+#include <unistd.h> // unlink
+#include <sys/stat.h>
+#ifndef ZSV_NO_JQ
+#include <yajl_helper/yajl_helper.h>
+#endif
+
+#if defined(_WIN32)
+#include <windows.h>
+#include "win/io.c"
+#endif
+
+/**
+ * Most of these functions require the caller to provide a buffer, in which case
+ * the buffer size should be at least FILENAME_MAX
+ */
+
+static size_t chop_slash(char *buff, size_t len) {
+  if (buff[len - 1] == '\\' || buff[len - 1] == '/') {
+    buff[len - 1] = '\0';
+    len--;
+  }
+  return (size_t)len;
+}
+
+/**
+ * Get os-independent configuration file path
+ * prefix should be determined at compile time e.g. /usr/local or ""
+ * @return length written to buff, or 0 if failed
+ */
+size_t zsv_get_config_dir(char *buff, size_t buffsize, const char *prefix) {
+#if defined(_WIN32)
+  const char *env_val = getenv("ZSV_CONFIG_DIR");
+  (void)(prefix);
+  //  if(!(env_val && *env_val))
+  //    env_val = getenv(prefix);
+  if (!(env_val && *env_val))
+    env_val = getenv("LOCALAPPDATA");
+  if (!(env_val && *env_val))
+    env_val = "C:\\temp";
+  int written = snprintf(buff, buffsize, "%s", env_val);
+#elif defined(__EMSCRIPTEN__)
+  (void)(prefix);
+  int written = snprintf(buff, buffsize, "/tmp");
+#else
+  int written;
+  const char *env_val = getenv("ZSV_CONFIG_DIR");
+  if (env_val && *env_val)
+    written = snprintf(buff, buffsize, "%s", env_val);
+  else
+    written = snprintf(buff, buffsize, "%s/etc", prefix ? prefix : "");
+#endif
+  if (written > 0 && ((size_t)written) < buffsize)
+    return chop_slash(buff, written);
+  return 0;
+}
+
+/**
+ * Check if a directory exists
+ * return true (non-zero) or false (zero)
+ */
+#ifdef WIN32
+#include "win/dir_exists_longpath.c"
+#endif
+int zsv_dir_exists(const char *path) {
+#ifdef WIN32
+  if (strlen(path) >= MAX_PATH)
+    return zsv_dir_exists_winlp(path);
+
+  // TO DO: support win long filepath prefix
+  // TO DO: work properly if dir exists but we don't have permission
+  wchar_t wpath[MAX_PATH];
+  mbstowcs(wpath, path, MAX_PATH);
+
+  DWORD attrs = GetFileAttributesW(wpath);
+  if (attrs == INVALID_FILE_ATTRIBUTES)
+    // Could check GetLastError() to see if it's a permission issue vs. not-found
+    return 0;
+
+  // If it has the directory attribute, it's presumably a directory
+  return (attrs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+#else
+  struct stat path_stat;
+  if (!stat(path, &path_stat))
+    return S_ISDIR(path_stat.st_mode);
+  return 0;
+#endif
+}
+
+/**
+ * Make a directory, as well as any intermediate dirs
+ * return zero on success
+ */
+#ifdef WIN32
+#include "win/mkdir_longpath.c"
+#define zsv_mkdir zsv_mkdir_winlp
+#else
+#define zsv_mkdir mkdir
+#endif
+
+int zsv_mkdirs(const char *path, char path_is_filename) {
+  // int rc = 0;
+  if (!path || !*path)
+    return -1;
+  size_t len = strlen(path);
+  if (len < 1)
+    return -1;
+
+  char *tmp = strdup(path);
+  if (!tmp) {
+    perror(path);
+    return -1;
+  }
+
+  if (len && strchr("/\\", tmp[len - 1]))
+    tmp[--len] = 0;
+
+  int offset = 0;
+#ifdef WIN32
+  if (len > 1) {
+    // starts with two slashes
+    if (strchr("/\\", tmp[0]) && strchr("/\\", tmp[1])) {
+      offset = 2;
+      // find the next slash
+      char *path_end = tmp + 3;
+      while (*path_end && !strchr("/\\", *path_end))
+        path_end++;
+      if (*path_end)
+        path_end++;
+      if (*path_end)
+        offset = path_end - tmp;
+      else {
+        fprintf(stderr, "Invalid path: %s\n", path);
+        free(tmp);
+        return -1;
+      }
+    }
+    // starts with *:
+    else if (tmp[1] == ':')
+      offset = 2;
+  }
+#else
+  offset = 1;
+#endif
+
+  // TO DO: first find the longest subdir that exists, in *reverse* order so as
+  // to properly handle case where no access to intermediate dir,
+  // and then only start mkdir from there
+  int last_dir_exists_rc = 0;
+  int last_errno = -1;
+  for (char *p = tmp + offset; /* !rc && */ *p; p++) {
+    if (strchr("/\\", *p)) {
+      char tmp_c = p[1];
+      p[0] = FILESLASH;
+      p[1] = '\0';
+      if (*tmp && !(last_dir_exists_rc = zsv_dir_exists(tmp))) {
+        if (zsv_mkdir(tmp
+#ifndef WIN32
+                      ,
+                      S_IRWXU
+#endif
+                      )) {
+          if (errno == EEXIST)
+            last_dir_exists_rc = 1;
+          else { // errno could be EEXIST if we have no permissions to an intermediate directory
+            last_errno = errno;
+            perror(tmp);
+            //          rc = -1;
+          }
+        } else
+          last_dir_exists_rc = 1;
+      }
+      p[1] = tmp_c;
+    }
+  }
+
+  if (/* !rc && */ path_is_filename == 0 && *tmp && !(last_dir_exists_rc = zsv_dir_exists(tmp))) {
+    if (zsv_mkdir(tmp
+#ifndef WIN32
+                  ,
+                  S_IRWXU
+#endif
+                  )) {
+      if (errno == EEXIST)
+        last_dir_exists_rc = 1;
+      else {
+        last_errno = errno;
+        perror(tmp);
+        // rc = -1;
+      }
+    } else
+      last_dir_exists_rc = 1;
+  }
+
+  free(tmp);
+  return last_dir_exists_rc ? 0 : last_errno ? last_errno : -1;
+}
+
+#if defined(_WIN32)
+size_t zsv_get_executable_path(char *buff, size_t buffsize) {
+  return GetModuleFileNameA(NULL, buff, (DWORD)buffsize);
+}
+
+#elif defined(__APPLE__)
+#include <mach-o/dyld.h>
+size_t zsv_get_executable_path(char *buff, size_t bufflen) {
+  uint32_t pathlen = bufflen;
+  if (!_NSGetExecutablePath(buff, &pathlen)) {
+    char real[FILENAME_MAX];
+    if (realpath(buff, real) != NULL && strlen(real) < bufflen) {
+      bufflen = strlen(real);
+      memcpy(buff, real, bufflen);
+      buff[bufflen] = '\0';
+    } else
+      bufflen = pathlen;
+    return bufflen;
+  }
+  return 0;
+}
+#elif defined(__linux__) || defined(__EMSCRIPTEN__)
+#include <unistd.h>
+size_t zsv_get_executable_path(char *buff, size_t buffsize) {
+  buffsize = readlink("/proc/self/exe", buff, buffsize - 1);
+  buff[buffsize] = '\0';
+  return buffsize;
+}
+#elif defined(__FreeBSD__)
+#include <sys/stat.h>
+#include <sys/sysctl.h>
+size_t zsv_get_executable_path(char *buff, size_t buffsize) {
+  int mib[4];
+  mib[0] = CTL_KERN;
+  mib[1] = KERN_PROC;
+  mib[2] = KERN_PROC_PATHNAME;
+  mib[3] = -1;
+  sysctl(mib, 4, buff, &buffsize, NULL, 0);
+  buff[buffsize] = '\0';
+  return buffsize;
+}
+#else
+// TODO: Add support for this OS!
+#endif /* end of: #if defined(_WIN32) */
+
+/**
+ * Get current user's home dir, without trailing slash
+ * On win, any backslashes are replaced with fwd slash
+ *   ex: zsv_get_home_dir(char[MAX_PATH], MAX_PATH)
+ * returns 0 if no home dir could be found
+ * returns > 0 and < bufflen on success
+ * returns > 0 and >= bufflen if buffer was too small
+ */
+int zsv_get_home_dir(char *buff, size_t bufflen) {
+  int written = 0;
+  if (getenv("HOME"))
+    written = snprintf(buff, bufflen, "%s", getenv("HOME"));
+#if defined(WIN32) || defined(_WIN32)
+  if (!written && getenv("HOMEDRIVE") && getenv("HOMEPATH"))
+    written = snprintf(buff, bufflen, "%s%s", getenv("HOMEDRIVE"), getenv("HOMEPATH"));
+#endif
+  if (written > 0 && ((size_t)written) < bufflen) {
+    if (buff[written - 1] == '\\' || buff[written - 1] == '/') {
+      buff[written - 1] = '\0';
+      written--;
+    }
+  }
+#if defined(WIN32) || defined(_WIN32)
+  for (int i = 0; i < written; i++)
+    if (buff[i] == '\\')
+      buff[i] = '/';
+#endif
+  return written;
+}
+
+struct dir_path {
+  struct dir_path *next;
+  char *path;
+};
+
+/**
+ * remove an empty directory; on error print msg to stderr
+ * return 0 on success
+ */
+static int rmdir_w_msg(const char *path, int *err) {
+#ifdef WIN32
+  if (!RemoveDirectoryA(path)) {
+    zsv_perror(path);
+    // zsv_win_printLastError();
+    *err = 1;
+  }
+#else
+  if (remove(path)) {
+    perror(path);
+    *err = 1;
+  }
+#endif
+  return *err;
+}
+
+static int zsv_foreach_dirent_remove(struct zsv_foreach_dirent_handle *h, size_t depth) {
+  (void)(depth);
+  if (!h->is_dir) { // file
+    if (h->parent_and_entry) {
+      if (zsv_remove(h->parent_and_entry)) {
+        perror(h->parent_and_entry); // "Unable to remove file");
+        return 1;
+      }
+    }
+  } else { // dir
+    if (h->parent_and_entry) {
+      struct dir_path *dn = calloc(1, sizeof(*dn));
+      if (!dn) {
+        fprintf(stderr, "Out of memory!\n");
+        return 1;
+      }
+      dn->path = strdup(h->parent_and_entry);
+      dn->next = *((struct dir_path **)h->ctx);
+      *((struct dir_path **)h->ctx) = dn;
+    }
+  }
+  return 0;
+}
+
+#ifdef _WIN32
+#include "win/foreach_dirent_longpath.c"
+#else
+// return error
+static int zsv_foreach_dirent_aux(const char *dir_path, size_t depth, size_t max_depth,
+                                  zsv_foreach_dirent_handler handler, void *ctx, char verbose) {
+  int err = 0;
+  if (!dir_path)
+    return 1;
+
+  if (max_depth > 0 && depth >= max_depth)
+    return 0;
+
+  DIR *dr;
+  if ((dr = opendir(dir_path))) {
+    struct dirent *de;
+    while ((de = readdir(dr)) != NULL) {
+      if (!*de->d_name || !strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
+        continue;
+      char *tmp;
+      asprintf(&tmp, "%s%c%s", dir_path, FILESLASH, de->d_name);
+      if (!tmp)
+        fprintf(stderr, "Out of memory!\n"), err = 1;
+      else {
+        struct zsv_foreach_dirent_handle h = {0};
+        h.verbose = verbose;
+        stat(tmp, (struct stat *)&h.stat);
+        h.parent = dir_path;
+        h.entry = de->d_name;
+        h.parent_and_entry = tmp;
+        h.ctx = ctx;
+        char is_dir = h.stat.st_mode & S_IFDIR ? 1 : 0;
+        h.is_dir = is_dir;
+        if (handler)
+          handler(&h, depth + 1);
+
+        if (is_dir && !h.no_recurse)
+          // recurse!
+          err = zsv_foreach_dirent_aux(tmp, depth + 1, max_depth, handler, ctx, verbose);
+        free(tmp);
+      }
+    }
+    closedir(dr);
+  }
+  return err;
+}
+#endif
+
+int zsv_foreach_dirent(const char *dir_path, size_t max_depth, zsv_foreach_dirent_handler handler, void *ctx,
+                       char verbose) {
+  return zsv_foreach_dirent_aux(dir_path, 0, max_depth, handler, ctx, verbose);
+}
+
+/**
+ * Remove a directory and all of its contents
+ */
+int zsv_remove_dir_recursive(const unsigned char *path) {
+  // we will delete all files first, then
+  // delete directories in the reverse order we received them
+  struct dir_path *reverse_dirs = NULL;
+  int err = zsv_foreach_dirent((const char *)path, 0, zsv_foreach_dirent_remove, &reverse_dirs, 0);
+
+  // unlink each dir
+  for (struct dir_path *dn = reverse_dirs; !err && dn; dn = dn->next)
+    rmdir_w_msg(dn->path, &err);
+
+  // free each dir
+  for (struct dir_path *next, *dn = reverse_dirs; !err && dn; dn = next) {
+    next = dn->next;
+    free(dn->path);
+    free(dn);
+  }
+  if (!err)
+    rmdir_w_msg((const char *)path, &err);
+
+  return err;
+}
+
+#ifndef ZSV_NO_JQ
+#include "dirs_to_json.c"
+
+#include "dirs_from_json.c"
+
+#endif