modernized local media file handling with std::filesystem and std::ifstream

Author: cchadowitz

common/arg.cpp

@@ -3304,9 +3304,9 @@ common_params_context common_params_parser_init(common_params & params, llama_ex
     ).set_examples({LLAMA_EXAMPLE_SERVER}).set_env("LLAMA_ARG_ALLOWED_LOCAL_MEDIA_PATH"));
     add_opt(common_arg(
         {"--local-media-max-size-mb"}, "N",
-        string_format("max size in mb for local media files (default: %d)", params.local_media_max_size_mb),
+        string_format("max size in mb for local media files (default: %lu)", params.local_media_max_size_mb),
         [](common_params & params, int value) {
-            params.local_media_max_size_mb = value;
+            params.local_media_max_size_mb = static_cast<size_t>(value);
         }
     ).set_examples({LLAMA_EXAMPLE_SERVER}).set_env("LLAMA_ARG_LOCAL_MEDIA_MAX_SIZE_MB"));
     add_opt(common_arg(

common/common.h

@@ -429,7 +429,7 @@ struct common_params {
     int32_t n_cache_reuse     = 0;            // min chunk size to reuse from the cache via KV shifting
     int32_t n_ctx_checkpoints = 8;            // max number of context checkpoints per slot
     int32_t cache_ram_mib     = 8192;         // -1 = no limit, 0 - disable, 1 = 1 MiB, etc.
-    int32_t local_media_max_size_mb = 15;     // max size of loaded local media files
+    size_t local_media_max_size_mb = 15;      // 0 = no limit, 15 = 1 MiB. Max size of loaded local media files
 
     std::string hostname      = "127.0.0.1";
     std::string public_path   = "";                                                                         // NOLINT

tools/server/server.cpp

@@ -2586,15 +2586,15 @@ struct server_context {
         SRV_INF("thinking = %d\n", enable_thinking);
 
         oai_parser_opt = {
-            /* use_jinja             */ params_base.use_jinja,
-            /* prefill_assistant     */ params_base.prefill_assistant,
-            /* reasoning_format      */ params_base.reasoning_format,
-            /* chat_template_kwargs  */ params_base.default_template_kwargs,
-            /* common_chat_templates */ chat_templates.get(),
-            /* allow_image           */ mctx ? mtmd_support_vision(mctx) : false,
-            /* allow_audio           */ mctx ? mtmd_support_audio (mctx) : false,
-            /* enable_thinking       */ enable_thinking,
-            /* local_media_max_size_mb */ params_base.local_media_max_size_mb,
+            /* use_jinja                */ params_base.use_jinja,
+            /* prefill_assistant        */ params_base.prefill_assistant,
+            /* reasoning_format         */ params_base.reasoning_format,
+            /* chat_template_kwargs     */ params_base.default_template_kwargs,
+            /* common_chat_templates    */ chat_templates.get(),
+            /* allow_image              */ mctx ? mtmd_support_vision(mctx) : false,
+            /* allow_audio              */ mctx ? mtmd_support_audio (mctx) : false,
+            /* enable_thinking          */ enable_thinking,
+            /* local_media_max_size_mb  */ params_base.local_media_max_size_mb,
             /* allowed_local_media_path */ params_base.allowed_local_media_path,
         };
     }

tools/server/utils.hpp

@@ -28,6 +28,8 @@
 #include <vector>
 #include <memory>
 #include <cinttypes>
+#include <filesystem>
+#include <fstream>
 
 #define DEFAULT_OAICOMPAT_MODEL "gpt-3.5-turbo"
 
@@ -530,7 +532,7 @@ struct oaicompat_parser_options {
     bool allow_image;
     bool allow_audio;
     bool enable_thinking = true;
-    int32_t local_media_max_size_mb;
+    size_t local_media_max_size_mb;
     std::string allowed_local_media_path;
 };
 
@@ -642,36 +644,35 @@ static json oaicompat_chat_params_parse(
 
                 } else if (string_starts_with(url, "file://")) {
                     // Strip off the leading "file://"
-                    std::string fname = url.substr(7);
-                    std::vector<std::string> fparts = string_split<std::string>(fname, std::filesystem::path::preferred_separator);
-                    for (const auto &piece : fparts) {
-                        if (piece != "" && !fs_validate_filename(piece)) {
-                            throw std::runtime_error("Invalid filename piece '" + piece + "': " + fname);
-                        }
+                    const std::string fname = url.substr(7);
+                    if (opt.allowed_local_media_path == "") {
+                        throw std::runtime_error("Local media paths are not enabled");
                     }
-                    // Check allowed local media path
-                    if (opt.allowed_local_media_path == "" || !string_starts_with(fname, opt.allowed_local_media_path)) {
-                        throw std::runtime_error("File path not allowed");
+                    const std::filesystem::path allowed_local_media_path = std::filesystem::canonical(std::filesystem::path(opt.allowed_local_media_path));
+                    const std::filesystem::path input_path = std::filesystem::canonical(std::filesystem::path(fname));
+                    if (!std::filesystem::is_directory(allowed_local_media_path)) {
+                        throw std::runtime_error("Invalid local media path: " + opt.allowed_local_media_path);
                     }
-                    // load local file path
-                    raw_buffer buf;
-                    FILE * f = fopen(fname.c_str(), "rb");
-                    if (!f) {
-                        SVR_ERR("Unable to open file %s: %s\n", fname.c_str(), strerror(errno));
-                        throw std::runtime_error("Unable to open image file");
+                    auto [allowed_end, nothing] = std::mismatch(allowed_local_media_path.begin(), allowed_local_media_path.end(), input_path.begin());
+                    if (allowed_end != allowed_local_media_path.end()) {
+                        throw std::runtime_error("Local media file path not allowed: " + fname);
+                    }
+                    if (!std::filesystem::is_regular_file(input_path)) {
+                        throw std::runtime_error("Local media file does not exist: " + fname);
                     }
-                    fseek(f, 0, SEEK_END);
-                    long file_size = ftell(f);
+                    const auto file_size = std::filesystem::file_size(input_path);
                     if (file_size > opt.local_media_max_size_mb * 1024 * 1024) {
-                        fclose(f);
-                        throw std::runtime_error("Local file exceeds maximum allowed size");
+                        throw std::runtime_error("Local media file exceeds maximum allowed size");
+                    }
+                    // load local file path
+                    std::ifstream f(input_path, std::ios::binary);
+                    if (!f) {
+                        SRV_ERR("Unable to open file %s: %s\n", fname.c_str(), strerror(errno));
+                        throw std::runtime_error("Unable to open local media file: " + fname);
                     }
-                    fseek(f, 0, SEEK_SET);
-                    buf.resize(file_size);
-                    size_t n_read = fread(buf.data(), 1, file_size, f);
-                    fclose(f);
-                    if (n_read != (size_t)file_size) {
-                        SVR_ERR("Failed to read entire file %s", fname.c_str());
+                    raw_buffer buf((std::istreambuf_iterator(f)), std::istreambuf_iterator<char>());
+                    if (buf.size() != file_size) {
+                        SRV_ERR("Failed to read entire file %s", fname.c_str());
                         throw std::runtime_error("Failed to read entire image file");
                     }
                     out_files.push_back(buf);