Important

This library uses 'blocking' socket I/O. If you are looking for a library with 'non-blocking' socket I/O, this is not the one that you want.

Simple examples

Server (Multi-threaded)

#defineCPPHTTPLIB_OPENSSL_SUPPORT#include"path/to/httplib.h"// HTTPhttplib::Server svr;// HTTPShttplib::SSLServer svr;svr.Get("/hi", [](const httplib::Request &, httplib::Response &res) {  res.set_content("Hello World!","text/plain");});svr.listen("0.0.0.0",8080);

Client

#defineCPPHTTPLIB_OPENSSL_SUPPORT#include"path/to/httplib.h"// HTTPhttplib::Clientcli("http://yhirose.github.io");// HTTPShttplib::Clientcli("https://yhirose.github.io");auto res = cli.Get("/hi");res->status;res->body;

SSL Support

Note

cpp-httplib currently supports only version 3.0 or later. Please seethis page to get more information.

Tip

For macOS: cpp-httplib now can use system certs withCPPHTTPLIB_USE_CERTS_FROM_MACOSX_KEYCHAIN.CoreFoundation andSecurity should be linked with-framework.

#defineCPPHTTPLIB_OPENSSL_SUPPORT#include"path/to/httplib.h"// Serverhttplib::SSLServersvr("./cert.pem","./key.pem");// Clienthttplib::Clientcli("https://localhost:1234");// scheme + hosthttplib::SSLClientcli("localhost:1234");// hosthttplib::SSLClientcli("localhost",1234);// host, port// Use your CA bundlecli.set_ca_cert_path("./ca-bundle.crt");// Disable cert verificationcli.enable_server_certificate_verification(false);// Disable host verificationcli.enable_server_hostname_verification(false);

Note

When using SSL, it seems impossible to avoid SIGPIPE in all cases, since on some operating systems, SIGPIPE can only be suppressed on a per-message basis, but there is no way to make the OpenSSL library do so for its internal communications. If your program needs to avoid being terminated on SIGPIPE, the only fully general way might be to set up a signal handler for SIGPIPE to handle or ignore it yourself.

SSL Error Handling

#defineCPPHTTPLIB_OPENSSL_SUPPORT#include"path/to/httplib.h"httplib::Clientcli("https://example.com");auto res = cli.Get("/");if (!res) {// Check the error typeconstauto err = res.error();switch (err) {case httplib::Error::SSLConnection:      std::cout <<"SSL connection failed, SSL error:"                << res.ssl_error() << std::endl;break;case httplib::Error::SSLLoadingCerts:      std::cout <<"SSL cert loading failed, OpenSSL error:"                << std::hex << res.ssl_openssl_error() << std::endl;break;case httplib::Error::SSLServerVerification:      std::cout <<"SSL verification failed, X509 error:"                << res.ssl_openssl_error() << std::endl;break;case httplib::Error::SSLServerHostnameVerification:      std::cout <<"SSL hostname verification failed, X509 error:"                << res.ssl_openssl_error() << std::endl;break;default:      std::cout <<"HTTP error:" <<httplib::to_string(err) << std::endl;  }}

Server

#include<httplib.h>intmain(void){usingnamespacehttplib;  Server svr;  svr.Get("/hi", [](const Request& req, Response& res) {    res.set_content("Hello World!","text/plain");  });// Match the request path against a regular expression// and extract its captures  svr.Get(R"(/numbers/(\d+))", [&](const Request& req, Response& res) {auto numbers = req.matches[1];    res.set_content(numbers,"text/plain");  });// Capture the second segment of the request path as "id" path param  svr.Get("/users/:id", [&](const Request& req, Response& res) {auto user_id = req.path_params.at("id");    res.set_content(user_id,"text/plain");  });// Extract values from HTTP headers and URL query params  svr.Get("/body-header-param", [](const Request& req, Response& res) {if (req.has_header("Content-Length")) {auto val = req.get_header_value("Content-Length");    }if (req.has_param("key")) {auto val = req.get_param_value("key");    }    res.set_content(req.body,"text/plain");  });// If the handler takes time to finish, you can also poll the connection state  svr.Get("/task", [&](const Request& req, Response& res) {constchar * result =nullptr;    process.run();// for example, starting an external processwhile (result ==nullptr) {sleep(1);if (req.is_connection_closed()) {        process.kill();// kill the processreturn;      }      result = process.stdout();// != nullptr if the process finishes    }    res.set_content(result,"text/plain");  });  svr.Get("/stop", [&](const Request& req, Response& res) {    svr.stop();  });  svr.listen("localhost",1234);}

Bind a socket to multiple interfaces and any available port

int port = svr.bind_to_any_port("0.0.0.0");svr.listen_after_bind();

Static File Server

// Mount / to ./www directoryauto ret = svr.set_mount_point("/","./www");if (!ret) {// The specified base directory doesn't exist...}// Mount /public to ./www directoryret = svr.set_mount_point("/public","./www");// Mount /public to ./www1 and ./www2 directoriesret = svr.set_mount_point("/public","./www1");// 1st order to searchret = svr.set_mount_point("/public","./www2");// 2nd order to search// Remove mount /ret = svr.remove_mount_point("/");// Remove mount /publicret = svr.remove_mount_point("/public");

// User defined file extension and MIME type mappingssvr.set_file_extension_and_mimetype_mapping("cc","text/x-c");svr.set_file_extension_and_mimetype_mapping("cpp","text/x-c");svr.set_file_extension_and_mimetype_mapping("hh","text/x-h");

Warning

These static file server methods are not thread-safe.

File request handler

// The handler is called right before the response is sent to a clientsvr.set_file_request_handler([](const Request &req, Response &res) {  ...});

Logging

Access Logging

svr.set_logger([](const httplib::Request& req,const httplib::Response& res) {  std::cout << req.method <<"" << req.path <<" ->" << res.status << std::endl;});

Pre-compression Logging

svr.set_pre_compression_logger([](const httplib::Request& req,const httplib::Response& res) {// Log before compression - res.body contains uncompressed content// Content-Encoding header is not yet setyour_pre_compression_logger(req, res);});

Error Logging

svr.set_error_logger([](const httplib::Error& err,const httplib::Request* req) {  std::cerr <<httplib::to_string(err) <<" while processing request";if (req) {    std::cerr <<", client:" << req->get_header_value("X-Forwarded-For")              <<", request: '" << req->method <<"" << req->path <<"" << req->version <<"'"              <<", host:" << req->get_header_value("Host");  }  std::cerr << std::endl;});

Error handler

svr.set_error_handler([](constauto& req,auto& res) {auto fmt ="<p>Error Status: <span style='color:red;'>%d</span></p>";char buf[BUFSIZ];snprintf(buf,sizeof(buf), fmt, res.status);  res.set_content(buf,"text/html");});

Exception handler

svr.set_exception_handler([](constauto& req,auto& res, std::exception_ptr ep) {auto fmt ="<h1>Error 500</h1><p>%s</p>";char buf[BUFSIZ];try {std::rethrow_exception(ep);  }catch (std::exception &e) {snprintf(buf,sizeof(buf), fmt, e.what());  }catch (...) {// See the following NOTEsnprintf(buf,sizeof(buf), fmt,"Unknown Exception");  }  res.set_content(buf,"text/html");  res.status = StatusCode::InternalServerError_500;});

Caution

if you don't provide thecatch (...) block for a rethrown exception pointer, an uncaught exception will end up causing the server crash. Be careful!

Pre routing handler

svr.set_pre_routing_handler([](constauto& req,auto& res) {if (req.path =="/hello") {    res.set_content("world","text/html");return Server::HandlerResponse::Handled;  }return Server::HandlerResponse::Unhandled;});

Post routing handler

svr.set_post_routing_handler([](constauto& req,auto& res) {  res.set_header("ADDITIONAL_HEADER","value");});

Pre request handler

svr.set_pre_request_handler([](constauto& req,auto& res) {if (req.matched_route =="/user/:user") {auto user = req.path_params.at("user");if (user !="john") {      res.status = StatusCode::Forbidden_403;      res.set_content("error","text/html");return Server::HandlerResponse::Handled;    }  }return Server::HandlerResponse::Unhandled;});

Form data handling

URL-encoded form data ('application/x-www-form-urlencoded')

svr.Post("/form", [&](constauto& req,auto& res) {// URL query parameters and form-encoded data are accessible via req.params  std::string username = req.get_param_value("username");  std::string password = req.get_param_value("password");// Handle multiple values with same nameauto interests = req.get_param_values("interests");// Check existenceif (req.has_param("newsletter")) {// Handle newsletter subscription  }});

'multipart/form-data' POST data

svr.Post("/multipart", [&](const Request& req, Response& res) {// Access text fields (from form inputs without files)  std::string username = req.form.get_field("username");  std::string bio = req.form.get_field("bio");// Access uploaded filesif (req.form.has_file("avatar")) {constauto& file = req.form.get_file("avatar");    std::cout <<"Uploaded file:" << file.filename              <<" (" << file.content_type <<") -"              << file.content.size() <<" bytes" << std::endl;// Access additional headers if neededfor (constauto& header : file.headers) {      std::cout <<"Header:" << header.first <<" =" << header.second << std::endl;    }// Save to disk    std::ofstreamofs(file.filename, std::ios::binary);    ofs << file.content;  }// Handle multiple values with same nameauto tags = req.form.get_fields("tags");// e.g., multiple checkboxesfor (constauto& tag : tags) {    std::cout <<"Tag:" << tag << std::endl;  }auto documents = req.form.get_files("documents");// multiple file uploadfor (constauto& doc : documents) {    std::cout <<"Document:" << doc.filename              <<" (" << doc.content.size() <<" bytes)" << std::endl;  }// Check existence before accessingif (req.form.has_field("newsletter")) {    std::cout <<"Newsletter subscription:" << req.form.get_field("newsletter") << std::endl;  }// Get counts for validationif (req.form.get_field_count("tags") >5) {    res.status = StatusCode::BadRequest_400;    res.set_content("Too many tags","text/plain");return;  }// Summary  std::cout <<"Received" << req.form.fields.size() <<" text fields and"            << req.form.files.size() <<" files" << std::endl;  res.set_content("Upload successful","text/plain");});

Receive content with a content receiver

svr.Post("/content_receiver",  [&](const Request &req, Response &res,const ContentReader &content_reader) {if (req.is_multipart_form_data()) {// NOTE: `content_reader` is blocking until every form data field is read// This approach allows streaming processing of large files      std::vector<FormData> items;content_reader(        [&](const FormData &item) {          items.push_back(item);returntrue;        },        [&](constchar *data,size_t data_length) {          items.back().content.append(data, data_length);returntrue;        });// Process the received itemsfor (constauto& item : items) {if (item.filename.empty()) {// Text field          std::cout <<"Field:" << item.name <<" =" << item.content << std::endl;        }else {// File          std::cout <<"File:" << item.name <<" (" << item.filename <<") -"                    << item.content.size() <<" bytes" << std::endl;        }      }    }else {      std::string body;content_reader([&](constchar *data,size_t data_length) {        body.append(data, data_length);returntrue;      });    }  });

Send content with the content provider

constsize_t DATA_CHUNK_SIZE =4;svr.Get("/stream", [&](const Request &req, Response &res) {auto data =newstd::string("abcdefg");  res.set_content_provider(    data->size(),// Content length"text/plain",// Content type    [&, data](size_t offset,size_t length, DataSink &sink) {constauto &d = *data;      sink.write(&d[offset],std::min(length, DATA_CHUNK_SIZE));returntrue;// return 'false' if you want to cancel the process.    },    [data](bool success) {delete data; });});

svr.Get("/stream", [&](const Request &req, Response &res) {  res.set_content_provider("text/plain",// Content type    [&](size_t offset, DataSink &sink) {if (/* there is still data*/) {        std::vector<char> data;// prepare data...        sink.write(data.data(), data.size());      }else {        sink.done();// No more data      }returntrue;// return 'false' if you want to cancel the process.    });});

Chunked transfer encoding

svr.Get("/chunked", [&](const Request& req, Response& res) {  res.set_chunked_content_provider("text/plain",    [](size_t offset, DataSink &sink) {      sink.write("123",3);      sink.write("345",3);      sink.write("789",3);      sink.done();// No more datareturntrue;// return 'false' if you want to cancel the process.    }  );});

svr.Get("/chunked", [&](const Request& req, Response& res) {  res.set_header("Trailer","Dummy1, Dummy2");  res.set_chunked_content_provider("text/plain",    [](size_t offset, DataSink &sink) {      sink.write("123",3);      sink.write("345",3);      sink.write("789",3);      sink.done_with_trailer({        {"Dummy1","DummyVal1"},        {"Dummy2","DummyVal2"}      });returntrue;    }  );});

Send file content

svr.Get("/content", [&](const Request &req, Response &res) {  res.set_file_content("./path/to/content.html");});svr.Get("/content", [&](const Request &req, Response &res) {  res.set_file_content("./path/to/content","text/html");});

'Expect: 100-continue' handler

// Send a '417 Expectation Failed' response.svr.set_expect_100_continue_handler([](const Request &req, Response &res) {return StatusCode::ExpectationFailed_417;});

// Send a final status without reading the message body.svr.set_expect_100_continue_handler([](const Request &req, Response &res) {return res.status = StatusCode::Unauthorized_401;});

Keep-Alive connection

svr.set_keep_alive_max_count(2);// Default is 100svr.set_keep_alive_timeout(10);// Default is 5

Timeout

svr.set_read_timeout(5,0);// 5 secondssvr.set_write_timeout(5,0);// 5 secondssvr.set_idle_interval(0,100000);// 100 milliseconds

Set maximum payload length for reading a request body

svr.set_payload_max_length(1024 *1024 *512);// 512MB

Note

When the request body content type is 'www-form-urlencoded', the actual payload length shouldn't exceedCPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH.

Server-Sent Events

Default thread pool support

svr.new_task_queue = [] {returnnewThreadPool(12); };

svr.new_task_queue = [] {returnnewThreadPool(/*num_threads=*/12,/*max_queued_requests=*/18); };

Override the default thread pool with yours

classYourThreadPoolTaskQueue :publicTaskQueue {public:YourThreadPoolTaskQueue(size_t n) {    pool_.start_with_thread_count(n);  }virtualboolenqueue(std::function<void()> fn)override {/* Return true if the task was actually enqueued, or false     * if the caller must drop the corresponding connection.*/return pool_.enqueue(fn);  }virtualvoidshutdown()override {    pool_.shutdown_gracefully();  }private:  YourThreadPool pool_;};svr.new_task_queue = [] {returnnewYourThreadPoolTaskQueue(12);};

Client

#include<httplib.h>#include<iostream>intmain(void){  httplib::Clientcli("localhost",1234);if (auto res = cli.Get("/hi")) {if (res->status == StatusCode::OK_200) {      std::cout << res->body << std::endl;    }  }else {auto err = res.error();    std::cout <<"HTTP error:" <<httplib::to_string(err) << std::endl;  }}

Tip

Constructor with scheme-host-port string is now supported!

httplib::Clientcli("localhost");httplib::Clientcli("localhost:8080");httplib::Clientcli("http://localhost");httplib::Clientcli("http://localhost:8080");httplib::Clientcli("https://localhost");httplib::SSLClientcli("localhost");

Error code

enum Error {  Success =0,  Unknown,  Connection,  BindIPAddress,  Read,  Write,  ExceedRedirectCount,  Canceled,  SSLConnection,  SSLLoadingCerts,  SSLServerVerification,  SSLServerHostnameVerification,  UnsupportedMultipartBoundaryChars,  Compression,  ConnectionTimeout,  ProxyConnection,};

Client Logging

Access Logging

cli.set_logger([](const httplib::Request& req,const httplib::Response& res) {auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start_time).count();  std::cout <<"✓" << req.method <<"" << req.path            <<" ->" << res.status <<" (" << res.body.size() <<" bytes,"            << duration <<"ms)" << std::endl;});

Error Logging

cli.set_error_logger([](const httplib::Error& err,const httplib::Request* req) {  std::cerr <<"✗";if (req) {    std::cerr << req->method <<"" << req->path <<"";  }  std::cerr <<"failed:" <<httplib::to_string(err);// Add specific guidance based on error typeswitch (err) {case httplib::Error::Connection:      std::cerr <<" (verify server is running and reachable)";break;case httplib::Error::SSLConnection:      std::cerr <<" (check SSL certificate and TLS configuration)";break;case httplib::Error::ConnectionTimeout:      std::cerr <<" (increase timeout or check network latency)";break;case httplib::Error::Read:      std::cerr <<" (server may have closed connection prematurely)";break;default:break;  }  std::cerr << std::endl;});

GET with HTTP headers

httplib::Headers headers = {  {"Hello","World!" }};auto res = cli.Get("/hi", headers);

auto res = cli.Get("/hi", {{"Hello","World!"}});

cli.set_default_headers({  {"Hello","World!" }});auto res = cli.Get("/hi");

POST

res = cli.Post("/post","text","text/plain");res = cli.Post("/person","name=john1&note=coder","application/x-www-form-urlencoded");

POST with parameters

httplib::Params params;params.emplace("name","john");params.emplace("note","coder");auto res = cli.Post("/post", params);

httplib::Params params{  {"name","john" },  {"note","coder" }};auto res = cli.Post("/post", params);

POST with Multipart Form Data

httplib::UploadFormDataItems items = {  {"text1","text default","","" },  {"text2","aωb","","" },  {"file1","h\ne\n\nl\nl\no\n","hello.txt","text/plain" },  {"file2","{\n\"world\", true\n}\n","world.json","application/json" },  {"file3","","","application/octet-stream" },};auto res = cli.Post("/multipart", items);

PUT

res = cli.Put("/resource/foo","text","text/plain");

DELETE

res = cli.Delete("/resource/foo");

OPTIONS

res = cli.Options("*");res = cli.Options("/resource/foo");

Timeout

cli.set_connection_timeout(0,300000);// 300 millisecondscli.set_read_timeout(5,0);// 5 secondscli.set_write_timeout(5,0);// 5 seconds// This method works the same as curl's `--max-time` optioncli.set_max_timeout(5000);// 5 seconds

Receive content with a content receiver

std::string body;auto res = cli.Get("/large-data",  [&](constchar *data,size_t data_length) {    body.append(data, data_length);returntrue;  });

std::string body;auto res = cli.Get("/stream", Headers(),  [&](const Response &response) {EXPECT_EQ(StatusCode::OK_200, response.status);returntrue;// return 'false' if you want to cancel the request.  },  [&](constchar *data,size_t data_length) {    body.append(data, data_length);returntrue;// return 'false' if you want to cancel the request.  });

Send content with a content provider

std::string body = ...;auto res = cli.Post("/stream", body.size(),  [](size_t offset,size_t length, DataSink &sink) {    sink.write(body.data() + offset, length);returntrue;// return 'false' if you want to cancel the request.  },"text/plain");

Chunked transfer encoding

auto res = cli.Post("/stream",  [](size_t offset, DataSink &sink) {    sink.os <<"chunked data 1";    sink.os <<"chunked data 2";    sink.os <<"chunked data 3";    sink.done();returntrue;// return 'false' if you want to cancel the request.  },"text/plain");

With Progress Callback

httplib::Clientcli(url, port);// prints: 0 / 000 bytes => 50% completeauto res = cli.Get("/", [](size_t len,size_t total) {printf("%lld / %lld bytes => %d%% complete\n",    len, total,    (int)(len*100/total));returntrue;// return 'false' if you want to cancel the request.});

Authentication

// Basic Authenticationcli.set_basic_auth("user","pass");// Digest Authenticationcli.set_digest_auth("user","pass");// Bearer Token Authenticationcli.set_bearer_token_auth("token");

Note

OpenSSL is required for Digest Authentication.

Proxy server support

cli.set_proxy("host", port);// Basic Authenticationcli.set_proxy_basic_auth("user","pass");// Digest Authenticationcli.set_proxy_digest_auth("user","pass");// Bearer Token Authenticationcli.set_proxy_bearer_token_auth("pass");

Note

OpenSSL is required for Digest Authentication.

Range

httplib::Clientcli("httpbin.org");auto res = cli.Get("/range/32", {httplib::make_range_header({{1,10}})// 'Range: bytes=1-10'});// res->status should be 206.// res->body should be "bcdefghijk".

httplib::make_range_header({{1,10}, {20, -1}})// 'Range: bytes=1-10, 20-'httplib::make_range_header({{100,199}, {500,599}})// 'Range: bytes=100-199, 500-599'httplib::make_range_header({{0,0}, {-1,1}})// 'Range: bytes=0-0, -1'

Keep-Alive connection

httplib::Clientcli("localhost",1234);cli.Get("/hello");// with "Connection: close"cli.set_keep_alive(true);cli.Get("/world");cli.set_keep_alive(false);cli.Get("/last-request");// with "Connection: close"

Redirect

httplib::Clientcli("yahoo.com");auto res = cli.Get("/");res->status;// 301cli.set_follow_location(true);res = cli.Get("/");res->status;// 200

Use a specific network interface

Note

This feature is not available on Windows, yet.

cli.set_interface("eth0");// Interface name, IP address or host name

Automatic Path Encoding

httplib::Clientcli("https://example.com");// Automatic path encoding (default behavior)cli.set_path_encode(true);auto res = cli.Get("/path with spaces/file.txt");// Automatically encodes spaces// Disable automatic path encodingcli.set_path_encode(false);auto res = cli.Get("/already%20encoded/path");// Use pre-encoded paths

Performance Note for Local Connections

Warning

On Windows systems with improperly configured IPv6 settings, using "localhost" as the hostname may cause significant connection delays (up to 2 seconds per request) due to DNS resolution issues. This affects both client and server operations. For better performance when connecting to local services, use "127.0.0.1" instead of "localhost".

See:yhirose#366 (comment)

// May be slower on Windows due to DNS resolution delayshttplib::Clientcli("localhost",8080);httplib::Server svr;svr.listen("localhost",8080);// Faster alternative for local connectionshttplib::Clientcli("127.0.0.1",8080);httplib::Server svr;svr.listen("127.0.0.1",8080);

Compression

Zlib Support

Brotli Support

Zstd Support

DefaultAccept-Encoding value

res = cli.Get("/resource/foo");res = cli.Get("/resource/foo", {{"Accept-Encoding","br, gzip, deflate, zstd"}});

res = cli.Get("/resource/foo", {{"Accept-Encoding",""}});

Compress request body on client

cli.set_compress(true);res = cli.Post("/resource/foo","...","text/plain");

Compress response body on client

cli.set_decompress(false);res = cli.Get("/resource/foo");res->body;// Compressed data

Unix Domain Socket Support

// Serverhttplib::Server svr;svr.set_address_family(AF_UNIX).listen("./my-socket.sock",80);// Clienthttplib::Clientcli("./my-socket.sock");cli.set_address_family(AF_UNIX);

URI Encoding/Decoding Utilities

#include<httplib.h>std::string url ="https://example.com/search?q=hello world";std::string encoded = httplib::encode_uri(url);std::string decoded = httplib::decode_uri(encoded);std::string param ="hello world";std::string encoded_component = httplib::encode_uri_component(param);std::string decoded_component = httplib::decode_uri_component(encoded_component);

Functions

Split httplib.h into .h and .cc

$./split.py -husage: split.py [-h] [-e EXTENSION] [-o OUT]This script splits httplib.h into .h and .cc parts.optional arguments:  -h, --help            show this help message and exit  -e EXTENSION, --extension EXTENSION                        extension of the implementation file (default: cc)  -o OUT, --out OUT     where to write the files (default: out)$./split.pyWrote out/httplib.h and out/httplib.cc

Dockerfile for Static HTTP Server

> docker build -t cpp-httplib-server....> docker run --rm -it -p 8080:80 -v ./docker/html:/html cpp-httplib-serverServing HTTP on 0.0.0.0 port 80 ...192.168.65.1 - - [31/Aug/2024:21:33:56 +0000]"GET / HTTP/1.1" 200 599"-""curl/8.7.1"192.168.65.1 - - [31/Aug/2024:21:34:26 +0000]"GET / HTTP/1.1" 200 599"-""Mozilla/5.0 ..."192.168.65.1 - - [31/Aug/2024:21:34:26 +0000]"GET /favicon.ico HTTP/1.1" 404 152"-""Mozilla/5.0 ..."

> docker run --rm -it -p 8080:80 -v ./docker/html:/html yhirose4dockerhub/cpp-httplib-serverServing HTTP on 0.0.0.0 port 80 ...192.168.65.1 - - [31/Aug/2024:21:33:56 +0000]"GET / HTTP/1.1" 200 599"-""curl/8.7.1"192.168.65.1 - - [31/Aug/2024:21:34:26 +0000]"GET / HTTP/1.1" 200 599"-""Mozilla/5.0 ..."192.168.65.1 - - [31/Aug/2024:21:34:26 +0000]"GET /favicon.ico HTTP/1.1" 404 152"-""Mozilla/5.0 ..."

NOTE

Regular Expression Stack Overflow

Caution

When using complex regex patterns in route handlers, be aware that certain patterns may cause stack overflow during pattern matching. This is a known issue withstd::regex implementations and affects thedispatch_request() method.

// This pattern can cause stack overflow with large inputsvr.Get(".*", handler);

Consider using simpler patterns or path parameters to avoid this issue:

// Safer alternativessvr.Get("/users/:id", handler);// Path parameterssvr.Get(R"(/api/v\d+/.*)", handler);// More specific patterns

g++

Windows

#include<httplib.h>#include<Windows.h>

#defineWIN32_LEAN_AND_MEAN#include<Windows.h>#include<httplib.h>

Note

cpp-httplib officially supports only the latest Visual Studio. It might work with former versions of Visual Studio, but I can no longer verify it. Pull requests are always welcome for the older versions of Visual Studio unless they break the C++11 conformance.

Note

Windows 8 or lower, Visual Studio 2015 or lower, and Cygwin and MSYS2 including MinGW are neither supported nor tested.

License

Special Thanks To