gout

utils.c (3312B)

---

 #include "utils.h"
 
 #include <assert.h>
 #include <err.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "third_party/openbsd/strlcpy.h"
 
 char* path_concat(const char* p1, const char* p2) {
   size_t p1_len = p1 ? strlen(p1) : 0;
   size_t p2_len = p2 ? strlen(p2) : 0;
 
   if (p1_len == 0) {
     return estrdup(p2 ? p2 : "");
   }
   if (p2_len == 0) {
     return estrdup(p1);
   }
 
   bool p1_slash = p1[p1_len - 1] == '/';
   bool p2_slash = p2[0] == '/';
   bool sep = !p1_slash && !p2_slash;
   bool skip = p1_slash && p2_slash;
 
   size_t total_len = p1_len + p2_len + sep - skip + 1;
   char* out = ecalloc(total_len, sizeof(char));
   int r = snprintf(out, total_len, "%s%s%s", p1, sep ? "/" : "", p2 + skip);
   if (r < 0 || (size_t)r >= total_len) {
     errx(1, "snprintf: path truncated or error");
   }
   return out;
 }
 
 void* ecalloc(size_t count, size_t size) {
   void* ptr = calloc(count, size);
   if (!ptr) {
     err(1, "calloc");
   }
   return ptr;
 }
 
 char* estrdup(const char* s) {
   assert(s != NULL);
   char* out_str = strdup(s);
   if (!out_str) {
     err(1, "strdup");
   }
   return out_str;
 }
 
 size_t estrlcpy(char* dst, const char* src, size_t dsize) {
   assert(dst != NULL);
   assert(src != NULL);
   size_t len = strlcpy(dst, src, dsize);
   if (len >= dsize) {
     errx(1, "string truncated: '%s'", src);
   }
   return len;
 }
 
 bool is_safe_repo_path(const char* path) {
   if (path[0] == '/') {
     return false;
   }
 
   const char* p = path;
   while (*p) {
     /* Locate the next path component, or end of path. */
     const char* start = p;
     while (*p && *p != '/') {
       p++;
     }
 
     /* Check for "..". */
     size_t len = p - start;
     if (len == 2 && start[0] == '.' && start[1] == '.') {
       return false;
     }
 
     /* Skip over the path delimiter. */
     if (*p) {
       p++;
     }
   }
   return true;
 }
 
 bool is_safe_url(const char* url) {
   return strncmp(url, "http://", 7) == 0 || strncmp(url, "https://", 8) == 0 ||
          strncmp(url, "git://", 6) == 0;
 }
 
 bool is_safe_mailto(const char* email) {
   /* A basic sanity check. We don't need a full RFC 5322 validator. We just
    * want to prevent injection of HTML/JS. Disallow characters that are special
    * in HTML or could be used to craft malicious URIs. */
   return strpbrk(email, "<>\"'\\\r\n") == NULL;
 }
 
 char* relpath_from_dir(const char* dir) {
   if (!dir || dir[0] == '\0' || strcmp(dir, ".") == 0) {
     return estrdup("");
   }
 
   size_t depth = 0;
   const char* p = dir;
   /* Skip leading slashes. */
   while (*p == '/') {
     p++;
   }
 
   /* For each component, increment depth. Skip repeated slashes. */
   while (*p != '\0') {
     depth++;
     while (*p != '\0' && *p != '/') {
       p++;
     }
     while (*p == '/') {
       p++;
     }
   }
   if (depth == 0) {
     return estrdup("");
   }
 
   /* Output the appropriate number of ../ for the depth. */
   const char segment[] = "../";
   const size_t segment_len = sizeof(segment) - 1;
   size_t relpath_size = (depth * segment_len) + 1;
 
   char* relpath = ecalloc(relpath_size, 1);
   char* ptr = relpath;
   for (size_t i = 0; i < depth; i++) {
     memcpy(ptr, segment, segment_len);
     ptr += segment_len;
   }
   *ptr = '\0';
 
   return relpath;
 }