1 files changed, 191 insertions, 0 deletions

diff --git a/snac.c b/snac.c
index 41db86d..9c84205 100644
--- a/snac.c
+++ b/snac.c
@@ -33,12 +33,18 @@
 
 #include <sys/time.h>
 #include <sys/stat.h>
+#include <sys/wait.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
 
 xs_str *srv_basedir = NULL;
 xs_dict *srv_config = NULL;
 xs_str *srv_baseurl = NULL;
 xs_str *srv_proxy_token_seed = NULL;
 xs_dict *srv_langs = NULL;
+const char *months[12] = {0};
 
 int dbglevel = 0;
 
@@ -171,3 +177,188 @@ int check_password(const char *uid, const char *passwd, const char *hash)
 
     return ret;
 }
+
+
+char* findprog(const char *prog)
+/* find a prog in PATH and return the first match */
+{
+    char *path_env, *path, *dir, filename[PATH_MAX];
+    int len;
+    struct stat sbuf;
+
+    path_env = getenv("PATH");
+    if (!prog || !path_env)
+        return NULL;
+
+    path_env = strdup(path_env);
+    if (!path_env)
+        return NULL;
+    path = path_env;
+
+    while ((dir = strsep(&path, ":")) != NULL) {
+        /* empty entries as ./ instead of / */
+        if (*dir == '\0')
+            dir = ".";
+
+        /* strip trailing / */
+        len = strlen(dir);
+        while (len > 0 && dir[len-1] == '/')
+            dir[--len] = '\0';
+
+        len = snprintf(filename, sizeof(filename), "%s/%s", dir, prog);
+        if (len > 0 && len < (int) sizeof(filename) &&
+            (stat(filename, &sbuf) == 0) && S_ISREG(sbuf.st_mode) &&
+            access(filename, X_OK) == 0) {
+            free(path_env);
+            return strdup(filename);
+        }
+    }
+
+    free(path_env);
+    return NULL;
+}
+
+
+int strip_media(const char *fn)
+/* strips EXIF data from a file */
+{
+    int ret = 0;
+
+    const xs_val *v = xs_dict_get(srv_config, "strip_exif");
+
+    if (xs_type(v) == XSTYPE_TRUE) {
+        /* Heuristic: find 'user/' in the path to make it relative */
+        /* This works for ~/user/..., /var/snac/user/..., etc. */
+        const char *r_fn = strstr(fn, "user/");
+        
+        if (r_fn == NULL) {
+            /* Fallback: try to strip ~/ if present */
+            if (strncmp(fn, "~/", 2) == 0)
+                r_fn = fn + 2;
+            else
+                r_fn = fn;
+        }
+
+        xs *l_fn = xs_tolower_i(xs_dup(r_fn));
+
+        /* check image extensions */
+        if (xs_endswith(l_fn, ".jpg") || xs_endswith(l_fn, ".jpeg") ||
+            xs_endswith(l_fn, ".png") || xs_endswith(l_fn, ".webp") ||
+            xs_endswith(l_fn, ".heic") || xs_endswith(l_fn, ".heif") ||
+            xs_endswith(l_fn, ".avif") || xs_endswith(l_fn, ".tiff") ||
+            xs_endswith(l_fn, ".gif")  || xs_endswith(l_fn, ".bmp")) {
+
+            const char *mp = xs_dict_get(srv_config, "mogrify_path");
+
+            pid_t pid = fork();
+            if (pid == -1) {
+                srv_log(xs_fmt("strip_media: cannot fork()"));
+                return -1;
+            } else if (pid == 0) {
+                chdir(srv_basedir);
+                execl(mp, "-auto-orient", "-strip", r_fn, (char*) NULL);
+                _exit(1);
+            }
+
+            if (waitpid(pid, &ret, 0) == -1) {
+                srv_log(xs_fmt("strip_media: cannot waitpid()"));
+                return -1;
+            }
+
+            if (ret != 0)
+                srv_log(xs_fmt("strip_media: error stripping %s %d", r_fn, ret));
+            else
+                srv_debug(1, xs_fmt("strip_media: stripped %s", r_fn));
+        }
+        else
+        /* check video extensions */
+        if (xs_endswith(l_fn, ".mp4") || xs_endswith(l_fn, ".m4v") ||
+            xs_endswith(l_fn, ".mov") || xs_endswith(l_fn, ".webm") ||
+            xs_endswith(l_fn, ".mkv") || xs_endswith(l_fn, ".avi")) {
+
+            const char *fp = xs_dict_get(srv_config, "ffmpeg_path");
+
+            /* ffmpeg cannot modify in-place, so we need a temp file */
+            /* we must preserve valid extension for ffmpeg to guess the format */
+            const char *ext = strrchr(r_fn, '.');
+            if (ext == NULL) ext = "";
+            xs *tmp_fn = xs_fmt("%s.tmp%s", r_fn, ext);
+
+            pid_t pid = fork();
+            if (pid == -1) {
+                srv_log(xs_fmt("strip_media: cannot fork()"));
+                return -1;
+            } else if (pid == 0) {
+                chdir(srv_basedir);
+                /* -map_metadata -1 strips all global metadata */
+                /* -c copy copies input streams without re-encoding */
+                execl(fp, "-y", "-i", r_fn, "-map_metadata", "-1", "-c", "copy", tmp_fn, (char*) NULL);
+                _exit(1);
+            }
+
+            if (waitpid(pid, &ret, 0) == -1) {
+                srv_log(xs_fmt("strip_media: cannot waitpid()"));
+                return -1;
+            }
+
+            if (ret != 0) {
+                srv_log(xs_fmt("strip_media: error stripping %s %d", r_fn, ret));
+
+                /* try to cleanup, just in case */
+                /* unlink needs full path too if we are not in basedir */
+                xs *full_tmp_fn = xs_fmt("%s/%s", srv_basedir, tmp_fn);
+                unlink(full_tmp_fn);
+            }
+            else {
+                /* rename tmp file to original */
+                /* use full path for source because it was created relative to basedir */
+                xs *full_tmp_fn = xs_fmt("%s/%s", srv_basedir, tmp_fn);
+                
+                if (rename(full_tmp_fn, fn) == 0)
+                    srv_debug(1, xs_fmt("strip_media: stripped %s", fn));
+                else
+                    srv_log(xs_fmt("strip_media: error renaming %s to %s", full_tmp_fn, fn));
+            }
+        }
+    }
+
+    return ret;
+}
+
+
+int check_strip_tool(void)
+/* check if strip_exif tools do exist and fix their absolute path */
+{
+    const xs_val *v = xs_dict_get(srv_config, "strip_exif");
+    /* skip if unless strip_exif; return non-error */
+    if (xs_type(v) != XSTYPE_TRUE)
+        return 1;
+
+    int ret = 1;
+    const char *progs[] = { "ffmpeg", "mogrify" };
+
+    for (int i = 0; i < (int)(sizeof(progs) / sizeof(progs[0])); i++) {
+        xs_str *key = xs_fmt("%s_path", progs[i]);
+
+        const char *val = xs_dict_get(srv_config, key);
+        if (val == NULL) {
+            val = findprog(progs[i]);
+            if (val != NULL)
+                srv_debug(1, xs_fmt("check_strip_tool: found %s in PATH at %s", progs[i], val));
+        }
+
+        if (val == NULL) {
+            srv_log(xs_fmt("check_strip_tool: %s not found in PATH", progs[i]));
+            ret = 0;
+        } else if (access(val, X_OK) != 0) {
+            srv_log(xs_fmt("check_strip_tool: %s '%s' is not executable", progs[i], val));
+            ret = 0;
+        } else {
+            srv_config = xs_dict_set(srv_config, key, val);
+        }
+
+        xs_free(key);
+    }
+
+    return ret;
+}