Add options to store files directly to the file system and to omit duplicating files in memory (#257)

* Add options to store files directly to the file system and to omit duplicating files in memory

* Delete accidentially added newline in http_resource.hpp

* Removed unused function, fixed some code style and typos in comments

* Removed asprintf in favor or string concatenation

As asprintf is a gnu extension it should not be used in a multi plattform code.
To generate the needed string, std::string is used
As the finally called function mkstemp changes its first argument of type char *
the concatenated string is still strdup-ed into a char * before handing it to mkstemp

* Made http_utils::generate_random_upload_filename plattform independant

Mkstemp is only available on windows. As there is no suitable plattform independant function
to generate a unique filename within a specified directory, use mkstemp on linux and a
combination of _mktemp_s and _sopen_s on windows.
Furthermore the path separator differs on linux and windows so use a static const char
which provides the appropriate path separator

Additionally within this patch the function http_utils::generate_random_upload_filename
uses an exception to reports errors rather than a empty string as return code

* Input and output of http_utils::generate_random_upload_filename are const

* Added options and functions for file upload to README.md

* Use correct include and functions in generate_random_upload_filename to run on windows

The current code won't compile on ApVeyor. So this is a an untested patch to include
the correct headers and not use functions, which are not supported (or deprecated)
on windows.

* Add missing includes for windows, fixed wrong argument for _mktemp_s

* Removed accidentially pushed debug code

* Use a static const char* for the random file system template

This is only used inside http_utils.cpp and therefor can be static

* Make output of get_or_create_file_info const and introduce new setters

The output of get_or_create_file_info should be const.
As previously the result was used to direclty alter the content of the struct
new setters to set the file_system_file_name and to grow the size
are introduced (and used)

* Use const variables for the webserver options

* Added an example for file upload

file_upload.cpp is a very basic example for a file upload server.
It features a simple HTML input form with file upload (which supports multiple files).
The uploaded files will be stored to the directory, which has to be given as
command line parameter to the example program.
All uploaded files will be printed in a table including their original name,
the generated random filepath and the size.

* Use a prefixed operator in for loop

* Added safety check for use of strlen and some missing free()s

Static code analysis complained about use of unprotected strlen.
This changes adds a safety check directly before the us of strlen.
Additionally some free()s (before some throws) where missing.

* Changed file map to be a map of keys with a nested map of files

There is the possibility to upload the same file with two different keys
or to upload multiple (different) files with the same key within the
same request.
The current solution can only handle the second use case but not the first.
This patch changes the file map to use a nested map of files within
a map of keys to support both use cases.

* Adjusted file_upload example to use new files map

* Updated description of files map in README.md

* Removed strlen from generate_random_upload_filename

As Codacy static code analysis warns about the safety issue of strlen
if a given string is not terminated, this is removed.
The solution uses the size of the original string, which is just duplicated
to a char* as the used function _mktemp_s requires a char* which will
be changed by the function and the changed result is needed afterwards.

* Use a pointer to std::ofstream in modded_request

One of the workflows did not run successfully, as it is obviously not allowed
to have a std::ofstream in a class if it is not a pointer or reference.
This patch uses a pointer to the ofstream in the modded requests and
adjusts all usage of the ofstream in webserver.cpp

* Moved struct file_info_s to class file_info

* Setters of class file_info are private and class webserver is a friend of this class

As the file_info has to be changed (especially the file_size) in multiple iterations
of the post iterator, this class cannot be fully immutable.
To realise a interface without setters to the outside of the library these
setters are private now. The only other classe, which uses these setters
is the class webserver and is therefor declared as friend to the file_info class.

* Use const reference as parameter for set_file_system_file_name

* Don't create zero length files if no file is uploaded

If an upload field is submitted without a file selected, the previous
implementation would still create a random file with zero length.
This is due to the fact, that the key would be present in the content,
but the filename is empty.

So a simple check, whether the filename is really present is introduced.

This is done by simply looking at the very first sign of the const char*
(which is given from libmicrohttpd). As strlen is considered unsafe and
there is already a check, whether the const char* is not a nullptr, it is
always safe to dereference and inspect the first char.

* Updated README.md as file_info is now a class

* Some code styling and small refactorings after review

* Replaced std::exception with custom generateFilenameException

Although there is no distinct error handling, if the filename generation
throws an exception, it should be usable in the future and destinguishable
from other common exceptions. Therefor the std::exception was replaced by
generateFilenameException

* Some more comments and code style fixes after review

* Some more code style changes after review

* Added error string to generateFilenameException

Though it is not used at the moment the generateFilenameException
features now a error string, which is set and can be used for debugging.

* Added comment for c functions in generate_random_upload_filename

Actually we should use standard C++ classes like ofstream for file operations.
But as these do not feature some wanted functions, this is done by C functions.
This patch adds some comments to explain the reasons for this decision.

* Removed const qualifier from file_info::get_file_size()

This is removed as the const qualifier is superfluous and generates
warning on pedantic checks.

* Added unit test for generate_random_upload_filename

This is a first show on a unit test for the function generate_random_upload_filename.
After calling the function, this unit test not only checks the returned filename,
but also, whether the file exists.

Maybe to be improved:
- the filename template and the path_separator are currently duplicated
- should there be a check, whether the removal of the temporary file worked?

* Removed filesystem include from unit tests again, as it would require C++17

* Close open upload file after post processor is done

If the file is not closed after the post processor is done, the
last info of the file might not be written to disk until the calling
application accesses the file. This could easily be reproduceable with
uploading very small files ( < 100 Bytes). In this case the content
of the file was missing for the calling process.

* Added content_type and transfer_encoding to file_info

The post iterator can set the content_type and the transfer_encoding
of the uploaded file into the file_info.
According to the documentation of libmicrohttpd this is sometimes unknown.
In this case the values will be nullptr and therefor the file_info
may be empty on this values.

* Fixed file_upload example

* Made filename_template and path_separator part of class http_utils

As these two constant values are used in the unit tests they could
no longer be static only in http_utils.cpp.
So they are members of the class http_utils and therefor accessible
in the unit tests

* Added integration test for file upload

Added an integration test for file upload which tests the upload
with different settings of the webserver:
- Upload to memory and disk
- Upload to disk only
- Upload to memory, duplicated in get_content and args
- Upload to memory, only stored in args

* Fixed integration test for file upload

* Removed empty AUTO_TEST from file_upload integration test

* Use internal values for http_ressource class in integration tests

Avoid using pointers in class print_file_upload_resource in favour of
internal values and according getter functions.
Additionally simplified the code by wrapping lines and using
the auto keyword instead of long map specifiers.

* Added further integration tests for file upload

Added the following integration tests
- Upload of a file via PUT (then there is no post_processor used
  and the content of the file will only be available via get_content
- Upload of two files
- Upload of a file and an additional ordinary POST parameter

* Added test_content_2 to configure script

As the test_content_2 was missing in the configure script the
file was not copy to the build/test directory and therefor the
integration tests failed

* Fixed memory leak in post_iterator

If multiple files are uploaded, the ofstream to write the data to the file
was created again (with new()) for the next file without deleting the
previously created one.
This resulted in a memory leak.

* Some code style fixed on file upload integration test

* Use map definition instead of auto in integration test

Co-authored-by: Christian Tomahogh <ctomahogh@users.noreply.github.com>

Author: ctomahogh

README.md

@@ -190,6 +190,13 @@ For example, if your connection limit is “1”, a browser may open a first con
 * _.debug() and .no_debug():_ Enables debug messages from the library. `off` by default.
 * _.regex_checking() and .no_regex_checking():_ Enables pattern matching for endpoints. Read more [here](#registering-resources). `on` by default.
 * _.post_process() and .no_post_process():_ Enables/Disables the library to automatically parse the body of the http request as arguments if in querystring format. Read more [here](#parsing-requests). `on` by default.
+* _.put_processed_data_to_content() and .no_put_processed_data_to_content():_ Enables/Disables the library to copy parsed body data to the content or to only store it in the arguments map. `on` by default.
+* _.file_upload_target(**file_upload_target_T** file_upload_target):_ Controls, how the library stores uploaded files. Default value is `FILE_UPLOAD_MEMORY_ONLY`.
+	* `FILE_UPLOAD_MEMORY_ONLY`: The content of the file is only stored in memory. Depending on `put_processed_data_to_content` only as part of the arguments map or additionally in the content.
+	* `FILE_UPLOAD_DISK_ONLY`: The content of the file is stored only in the file system. The path is created from `file_upload_dir` and either a random name (if `generate_random_filename_on_upload` is true) or the actually uploaded file name.
+	* `FILE_UPLOAD_MEMORY_AND_DISK`: The content of the file is stored in memory and on the file system.
+* _.file_upload_dir(**const std::string&** file_upload_dir):_ Specifies the directory to store all uploaded files. Default value is `/tmp`.
+* _.generate_random_filename_on_upload() and .no_generate_random_filename_on_upload():_ Enables/Disables the library to generate a unique and unused filename to store the uploaded file to. Otherwise the actually uploaded file name is used. `off` by default.
 * _.deferred()_ and _.no_deferred():_ Enables/Disables the ability for the server to suspend and resume connections. Simply put, it enables/disables the ability to use `deferred_response`. Read more [here](#building-responses-to-requests). `on` by default.
 * _.single_resource() and .no_single_resource:_ Sets or unsets the server in single resource mode. This limits all endpoints to be served from a single resource. The resultant is that the webserver will process the request matching to the endpoint skipping any complex semantic. Because of this, the option is incompatible with `regex_checking` and requires the resource to be registered against an empty endpoint or the root endpoint (`"/"`). The resource will also have to be registered as family. (For more information on resource registration, read more [here](#registering-resources)). `off` by default.
 
@@ -553,6 +560,8 @@ The `http_request` class has a set of methods you will have access to when imple
 * _**const std::map<std::string, std::string, http::header_comparator>** get_cookies() **const**:_ Returns a map containing all the cookies present in the HTTP request.
 * _**const std::map<std::string, std::string, http::header_comparator>** get_footers() **const**:_ Returns a map containing all the footers present in the HTTP request (only for http 1.1 chunked encodings).
 * _**const std::map<std::string, std::string, http::arg_comparator>** get_args() **const**:_ Returns all the arguments present in the HTTP request. Arguments can be (1) querystring parameters, (2) path argument (in case of parametric endpoint, (3) parameters parsed from the HTTP request body if the body is in `application/x-www-form-urlencoded` or `multipart/form-data` formats and the postprocessor is enabled in the webserver (enabled by default).
+* _**const std::map<std::string, file_info_s>** get_files() **const**:_ Returns information about all the uploaded files (if the files are stored to disk). This information includes the original file name, the size of the file and the path to the file in the file system.
+* _**const std::map<std::string, std::map<std::string, http::file_info>>** get_files() **const**:_ Returns information about all the uploaded files (if the files are stored to disk). This information includes the key (as identifier of the outer map), the original file name (as identifier of the inner map) and a class `file_info`, which includes the size of the file and the path to the file in the file system.
 * _**const std::string&** get_content() **const**:_ Returns the body of the HTTP request.
 * _**bool**  content_too_large() **const**:_ Returns `true` if the body length of the HTTP request sent by the client is longer than the max allowed on the server.
 * _**const std::string** get_querystring() **const**:_ Returns the `querystring` of the HTTP request.

configure.ac

@@ -273,6 +273,7 @@ AC_SUBST(EXT_LIB_PATH)
 AC_SUBST(EXT_LIBS)
 
 AC_CONFIG_FILES([test/test_content:test/test_content])
+AC_CONFIG_FILES([test/test_content_2:test/test_content_2])
 AC_CONFIG_FILES([test/test_content_empty:test/test_content_empty])
 AC_CONFIG_FILES([test/cert.pem:test/cert.pem])
 AC_CONFIG_FILES([test/key.pem:test/key.pem])

examples/Makefile.am

@@ -19,7 +19,7 @@
 LDADD = $(top_builddir)/src/libhttpserver.la
 AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_srcdir)/src/httpserver/
 METASOURCES = AUTO
-noinst_PROGRAMS = hello_world service minimal_hello_world custom_error allowing_disallowing_methods handlers hello_with_get_arg setting_headers custom_access_log basic_authentication digest_authentication minimal_https minimal_file_response minimal_deferred url_registration minimal_ip_ban benchmark_select benchmark_threads benchmark_nodelay deferred_with_accumulator
+noinst_PROGRAMS = hello_world service minimal_hello_world custom_error allowing_disallowing_methods handlers hello_with_get_arg setting_headers custom_access_log basic_authentication digest_authentication minimal_https minimal_file_response minimal_deferred url_registration minimal_ip_ban benchmark_select benchmark_threads benchmark_nodelay deferred_with_accumulator file_upload
 
 hello_world_SOURCES = hello_world.cpp
 service_SOURCES = service.cpp
@@ -41,3 +41,4 @@ minimal_ip_ban_SOURCES = minimal_ip_ban.cpp
 benchmark_select_SOURCES = benchmark_select.cpp
 benchmark_threads_SOURCES = benchmark_threads.cpp
 benchmark_nodelay_SOURCES = benchmark_nodelay.cpp
+file_upload_SOURCES = file_upload.cpp

examples/file_upload.cpp

@@ -0,0 +1,116 @@
+/*
+     This file is part of libhttpserver
+     Copyright (C) 2011, 2012, 2013, 2014, 2015 Sebastiano Merlino
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+     USA
+*/
+
+#include <iostream>
+#include <httpserver.hpp>
+
+class file_upload_resource : public httpserver::http_resource {
+ public:
+     const std::shared_ptr<httpserver::http_response> render_GET(const httpserver::http_request&) {
+         std::string get_response = "<html>\n";
+         get_response += "  <body>\n";
+         get_response += "    <form method=\"POST\" enctype=\"multipart/form-data\">\n";
+         get_response += "      <h1>Upload 1 (key is 'files', multiple files can be selected)</h1><br>\n";
+         get_response += "      <input type=\"file\" name=\"files\" multiple>\n";
+         get_response += "      <br><br>\n";
+         get_response += "      <h1>Upload 2 (key is 'files2', multiple files can be selected)</h1><br>\n";
+         get_response += "      <input type=\"file\" name=\"files2\" multiple><br><br>\n";
+         get_response += "      <input type=\"submit\" value=\"Upload\">\n";
+         get_response += "    </form>\n";
+         get_response += "  </body>\n";
+         get_response += "</html>\n";
+
+         return std::shared_ptr<httpserver::http_response>(new httpserver::string_response(get_response, 200, "text/html"));
+     }
+
+     const std::shared_ptr<httpserver::http_response> render_POST(const httpserver::http_request& req) {
+        std::string post_response = "<html>\n";
+        post_response += "<head>\n";
+        post_response += "  <style>\n";
+        post_response += "    table, th, td {\n";
+        post_response += "      border: 1px solid black;\n";
+        post_response += "      border-collapse: collapse;\n";
+        post_response += "    }\n";
+        post_response += "  </style>\n";
+        post_response += "</head>\n";
+        post_response += "<body>\n";
+        post_response += "  Uploaded files:\n";
+        post_response += "  <br><br>\n";
+        post_response += "  <table>\n";
+        post_response += "    <tr>\n";
+        post_response += "      <th>Key</th>\n";
+        post_response += "      <th>Uploaded filename</th>\n";
+        post_response += "      <th>File system path</th>\n";
+        post_response += "      <th>File size</th>\n";
+        post_response += "      <th>Content type</th>\n";
+        post_response += "      <th>Transfer encoding</th>\n";
+        post_response += "    </tr>\n";
+
+        for (auto &file_key : req.get_files()) {
+            for (auto &files : file_key.second) {
+                post_response += "    <tr><td>";
+                post_response += file_key.first;
+                post_response += "</td><td>";
+                post_response += files.first;
+                post_response += "</td><td>";
+                post_response += files.second.get_file_system_file_name();
+                post_response += "</td><td>";
+                post_response += std::to_string(files.second.get_file_size());
+                post_response += "</td><td>";
+                post_response += files.second.get_content_type();
+                post_response += "</td><td>";
+                post_response += files.second.get_transfer_encoding();
+                post_response += "</td></tr>\n";
+            }
+        }
+
+        post_response += "  </table><br><br>\n";
+        post_response += "  <a href=\"/\">back</a>\n";
+        post_response += "</body>\n</html>";
+        return std::shared_ptr<httpserver::http_response>(new httpserver::string_response(post_response, 201, "text/html"));
+    }
+};
+
+int main(int argc, char** argv) {
+    // this example needs a directory as parameter
+    if (2 != argc) {
+        std::cout << "Usage: file_upload <upload_dir>" << std::endl;
+        std::cout << std::endl;
+        std::cout << "         file_upload: writeable directory where uploaded files will be stored" << std::endl;
+        return -1;
+    }
+
+    std::cout << "CAUTION: this example will create files in the directory " << std::string(argv[1]) << std::endl;
+    std::cout << "These files won't be deleted at termination" << std::endl;
+    std::cout << "Please make sure, that the given directory exists and is writeable" << std::endl;
+
+    httpserver::webserver ws = httpserver::create_webserver(8080)
+                              .no_put_processed_data_to_content()
+                              .file_upload_dir(std::string(argv[1]))
+                              .generate_random_filename_on_upload()
+                              .file_upload_target(httpserver::FILE_UPLOAD_DISK_ONLY);
+
+    file_upload_resource fur;
+    ws.register_resource("/", &fur);
+    ws.start(true);
+
+    return 0;
+}
+

src/Makefile.am

@@ -19,9 +19,9 @@
 AM_CPPFLAGS = -I../ -I$(srcdir)/httpserver/
 METASOURCES = AUTO
 lib_LTLIBRARIES = libhttpserver.la
-libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp http_utils.cpp http_request.cpp http_response.cpp string_response.cpp basic_auth_fail_response.cpp digest_auth_fail_response.cpp deferred_response.cpp file_response.cpp http_resource.cpp details/http_endpoint.cpp
+libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp http_utils.cpp file_info.cpp http_request.cpp http_response.cpp string_response.cpp basic_auth_fail_response.cpp digest_auth_fail_response.cpp deferred_response.cpp file_response.cpp http_resource.cpp details/http_endpoint.cpp
 noinst_HEADERS = httpserver/string_utilities.hpp httpserver/details/modded_request.hpp gettext.h
-nobase_include_HEADERS = httpserver.hpp httpserver/create_webserver.hpp httpserver/webserver.hpp httpserver/http_utils.hpp httpserver/details/http_endpoint.hpp httpserver/http_request.hpp httpserver/http_response.hpp httpserver/http_resource.hpp httpserver/string_response.hpp httpserver/basic_auth_fail_response.hpp httpserver/digest_auth_fail_response.hpp httpserver/deferred_response.hpp httpserver/file_response.hpp
+nobase_include_HEADERS = httpserver.hpp httpserver/create_webserver.hpp httpserver/webserver.hpp httpserver/http_utils.hpp httpserver/file_info.hpp httpserver/details/http_endpoint.hpp httpserver/http_request.hpp httpserver/http_response.hpp httpserver/http_resource.hpp httpserver/string_response.hpp httpserver/basic_auth_fail_response.hpp httpserver/digest_auth_fail_response.hpp httpserver/deferred_response.hpp httpserver/file_response.hpp
 
 AM_CXXFLAGS += -fPIC -Wall
 

src/file_info.cpp

@@ -0,0 +1,56 @@
+/*
+     This file is part of libhttpserver
+     Copyright (C) 2011-2019 Sebastiano Merlino
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+     USA
+*/
+
+#include <string.h>
+#include "httpserver/file_info.hpp"
+
+namespace httpserver {
+namespace http {
+
+void file_info::set_file_system_file_name(const std::string& file_system_file_name) {
+    _file_system_file_name = file_system_file_name;
+}
+
+void file_info::set_content_type(const std::string& content_type) {
+    _content_type = content_type;
+}
+
+void file_info::set_transfer_encoding(const std::string& transfer_encoding) {
+    _transfer_encoding = transfer_encoding;
+}
+
+void file_info::grow_file_size(size_t additional_file_size) {
+    _file_size += additional_file_size;
+}
+size_t file_info::get_file_size() const {
+    return _file_size;
+}
+const std::string file_info::get_file_system_file_name() const {
+    return _file_system_file_name;
+}
+const std::string file_info::get_content_type() const {
+    return _content_type;
+}
+const std::string file_info::get_transfer_encoding() const {
+    return _transfer_encoding;
+}
+
+}  // namespace http
+}  // namespace httpserver

src/http_request.cpp

@@ -127,6 +127,10 @@ const std::map<std::string, std::string, http::arg_comparator> http_request::get
     return arguments;
 }
 
+http::file_info& http_request::get_or_create_file_info(const std::string& key, const std::string& upload_file_name) {
+    return files[key][upload_file_name];
+}
+
 const std::string http_request::get_querystring() const {
     std::string querystring = "";
 

src/http_utils.cpp

@@ -23,6 +23,10 @@
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #include <winsock2.h>
 #include <ws2tcpip.h>
+#include <io.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <share.h>
 #else  // WIN32 check
 #include <arpa/inet.h>
 #include <netdb.h>
@@ -33,6 +37,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <fstream>
 #include <iomanip>
 #include <iterator>
@@ -198,6 +203,14 @@ const char* http_utils::http_post_encoding_multipart_formdata = MHD_HTTP_POST_EN
 const char* http_utils::application_octet_stream = "application/octet-stream";
 const char* http_utils::text_plain = "text/plain";
 
+const char* http_utils::upload_filename_template = "libhttpserver.XXXXXX";
+
+#if defined(_WIN32)
+    const char http_utils::path_separator = '\\';
+#else  // _WIN32
+    const char http_utils::path_separator = '/';
+#endif  // _WIN32
+
 std::vector<std::string> http_utils::tokenize_url(const std::string& str, const char separator) {
     return string_utilities::string_split(str, separator);
 }
@@ -221,6 +234,45 @@ std::string http_utils::standardize_url(const std::string& url) {
     return result;
 }
 
+const std::string http_utils::generate_random_upload_filename(const std::string& directory) {
+    std::string filename = directory + http_utils::path_separator + http_utils::upload_filename_template;
+    char *template_filename = strdup(filename.c_str());
+    int fd = 0;
+
+#if defined(_WIN32)
+    // only function for win32 which creates unique filenames and can handle a given template including a path
+    // all other functions like tmpnam() always create filenames in the 'temp' directory
+    if (0 != _mktemp_s(template_filename, filename.size() + 1)) {
+        free(template_filename);
+        throw generateFilenameException("Failed to create unique filename");
+    }
+
+    // as no existing file should be overwritten the operation should fail if the file already exists
+    // fstream or ofstream classes don't feature such an option
+    // with the function _sopen_s this can be achieved by setting the flag _O_EXCL
+    if (0 != _sopen_s(&fd, template_filename, _O_CREAT | _O_EXCL | _O_NOINHERIT, _SH_DENYNO, _S_IREAD | _S_IWRITE)) {
+        free(template_filename);
+        throw generateFilenameException("Failed to create file");
+    }
+    if (fd == -1) {
+        free(template_filename);
+        throw generateFilenameException("File descriptor after successful _sopen_s is -1");
+    }
+    _close(fd);
+#else  // _WIN32
+    fd = mkstemp(template_filename);
+
+    if (fd == -1) {
+        free(template_filename);
+        throw generateFilenameException("Failed to create unique file");
+    }
+    close(fd);
+#endif  // _WIN32
+    std::string ret_filename = template_filename;
+    free(template_filename);
+    return ret_filename;
+}
+
 std::string get_ip_str(const struct sockaddr *sa) {
     if (!sa) throw std::invalid_argument("socket pointer is null");
 

src/httpserver.hpp

@@ -31,6 +31,7 @@
 #include "httpserver/http_resource.hpp"
 #include "httpserver/http_response.hpp"
 #include "httpserver/http_utils.hpp"
+#include "httpserver/file_info.hpp"
 #include "httpserver/string_response.hpp"
 #include "httpserver/webserver.hpp"