Skip to content

Releases: arnelify/arnelify-server-cpp

v0.9.8

23 Mar 02:24
@taronsarkisyan taronsarkisyan
v0.9.8
6ae6d78

Choose a tag to compare

View all tags
v0.9.8 Latest
Latest

Arnelify Logo

Arnelify Server for C & C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C & C++ — a multi-language server with HTTP 3.0 and WebTransport support.

All supported protocols:

# Protocol Transport
1 TCP2 WebTransport
2 TCP2 HTTP 3.0
3 TCP1 WebSocket
4 TCP1 HTTP 2.0
5 TCP1 HTTP 1.1

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v15.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Run in terminal:

git clone git@github.com:arnelify/arnelify-server-cpp.git

🎉 TCP2 / WebTransport

📚 Configuration

Option Description
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
HANDSHAKE_TIMEOUT Maximum time in seconds to complete the TLS handshake.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_MESSAGE_SIZE_MB Maximum size of a single message the server will accept from a client.
PING_TIMEOUT Maximum time the server will wait for a ping from the client.
PORT Defines which port the server will listen on.
SEND_TIMEOUT Maximum time for the client to receive a response from the server.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  WebTransportOpts opts(
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* compression */ false,
      /* handshake_timeout */ 30,
      /* key_pem */ "certs/key.pem",
      /* max_message_size_kb */ 64,
      /* ping_timeout */ 15,
      /* port */ 4433,
      /* send_timeout */ 30,
      /* thread_limit */ 4);

  WebTransport wt(opts);
  WebTransportLogger wt_logger = [](const std::string& _level,
                                    const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  wt.logger(wt_logger);

  WebTransportHandler wt_handler = [](WebTransportCtx& ctx,
                                      WebTransportBytes& bytes,
                                      WebTransportStream& stream) -> void {
    stream.push(ctx, bytes);
    stream.close();
  };

  wt.on("connect", wt_handler);
  wt.start();
}

🎉 TCP2 / HTTP 3.0

📚 Configuration

Option Description
ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
CHARSET Defines the encoding that the server will recommend to all client applications.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
KEEP_ALIVE defines how long the HTTP server keeps a connection.
KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_FIELDS Defines the maximum number of fields in the received form.
MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
MAX_FILES Defines the maximum number of files in the form.
MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
PORT Defines which port the server will listen on.
STORAGE_PATH Specifies the upload directory for storage.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  Http3Opts opts(
      /* allow_empty_files */ true,
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* charset */ "utf-8",
      /* compression */ true,
      /* keep_alive */ 30,
      /* keep_extensions */ true,
      /* key_pem */ "certs/key.pem",
      /* max_fields*/ 60,
      /* max_fields_size_total_mb */ 1,
      /* max_files */ 1,
      /* max_files_size_total_mb */ 60,
      /* max_file_size_mb */ 60,
      /* port */ 4433,
      /* storage_path */ "/var/www/cpp/storage",
      /* thread_limit */ 4);

  Http3 http3(opts);
  Http3Logger http3_logger = [](const std::string& _level,
                                const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  http3.logger(http3_logger);
  Http3Handler http3_handler = [](Http3Req& ctx, Http3Stream& stream) -> void {
    Json::StreamWriterBuilder writer;
    writer["indentation"] = "";
    writer["emitUTF8"] = true;

    const std::string res = Json::writeString(writer, ctx);
    const Http1Res bytes(res.begin(), res.end());

    stream.set_code(200);
    stream.push_bytes(bytes, false);
    stream.end();
  };

  http3.on("/", http3_handler);
  http3.start();
}

🎉 TCP1 / WebSocket

📚 Configuration

Option Description
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
HANDSHAKE_TIMEOUT Maximum time in seconds to complete the TLS handshake.
MAX_MESSAGE_SIZE_MB Maximum size of a single message the server will accept from a client.
PING_TIMEOUT Maximum time the server will wait for a ping from the client.
PORT Defines which port the server will listen on.
SEND_TIMEOUT Maximum time for the client to receive a response from the server.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  WebSocketOpts opts(
      /* block_size_kb */ 64,
      /* compression */ false,
      /* handshake_timeout */ 30,
      /* max_message_size_kb */ 64,
      /* ping_timeout */ 15,
      /* port */ 4433,
      /* send_timeout */ 30,
      /* thread_limit */ 4);

  WebSocket ws(opts);
  WebSocketLogger ws_logger = [](const std::string& _level,
                                 const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  ws.logger(ws_logger);
  WebSocketHandler ws_handler = [](WebSocketCtx& ctx, WebSocketBytes& bytes,
                                   WebSocketStream& stream) -> void {
    stream.push(ctx, bytes);
    stream.close();
  };

  ws.on("connect", ws_handler);
  ws.start();
}

🎉 TCP1 / HTTP 2.0

📚 Configuration

Option Description
ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
CHARSET Defines the encoding that the server will recommend to all client applications.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
KEEP_ALIVE defines how long the HTTP server keeps a connection.
KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_FIELDS Defines the maximum number of fields in the received form.
MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
MAX_FILES Defines the maximum number of files in the form.
MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
PORT Defines which port the server will listen on.
STORAGE_PATH Specifies the upload directory for storage.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  Http2Opts opts(
      /* allow_empty_files */ true,
      /* block_size_kb */ 64,
      /* cert_pem ...
Read more
Assets 2
Loading

v0.9.6

20 Mar 10:33
@taronsarkisyan taronsarkisyan
v0.9.6
686e9a6

Choose a tag to compare

View all tags
v0.9.6

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C & C++ — a multi-language server with HTTP 3.0 and WebTransport support.

All supported protocols:

# Protocol Transport
1 TCP1 HTTP 1.1
2 TCP1 HTTP 2.0
3 TCP1 WebSocket
4 TCP2 HTTP 3.0
5 TCP2 WebTransport

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v15.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Run in terminal:

git clone git@github.com:arnelify/arnelify-server-cpp.git

🎉 TCP2 / WebTransport

📚 Configuration

Option Description
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
HANDSHAKE_TIMEOUT Maximum time in seconds to complete the TLS handshake.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_MESSAGE_SIZE_MB Maximum size of a single message the server will accept from a client.
PING_TIMEOUT Maximum time the server will wait for a ping from the client.
PORT Defines which port the server will listen on.
SEND_TIMEOUT Maximum time for the client to receive a response from the server.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  WebTransportOpts opts(
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* compression */ false,
      /* handshake_timeout */ 30,
      /* key_pem */ "certs/key.pem",
      /* max_message_size_kb */ 64,
      /* ping_timeout */ 15,
      /* port */ 4433,
      /* send_timeout */ 30,
      /* thread_limit */ 4);

  WebTransport wt(opts);
  WebTransportLogger wt_logger = [](const std::string& _level,
                                    const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  wt.logger(wt_logger);

  WebTransportHandler wt_handler = [](WebTransportCtx& ctx,
                                      WebTransportBytes& bytes,
                                      WebTransportStream& stream) -> void {
    stream.push(ctx, bytes);
    stream.close();
  };

  wt.on("connect", wt_handler);
  wt.start();
}

🎉 TCP2 / HTTP 3.0

📚 Configuration

Option Description
ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
CHARSET Defines the encoding that the server will recommend to all client applications.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_FIELDS Defines the maximum number of fields in the received form.
MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
MAX_FILES Defines the maximum number of files in the form.
MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
PORT Defines which port the server will listen on.
STORAGE_PATH Specifies the upload directory for storage.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  Http3Opts opts(
      /* allow_empty_files */ true,
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* charset */ "utf-8",
      /* compression */ true,
      /* keep_alive */ 30,
      /* keep_extensions */ true,
      /* key_pem */ "certs/key.pem",
      /* max_fields*/ 60,
      /* max_fields_size_total_mb */ 1,
      /* max_files */ 1,
      /* max_files_size_total_mb */ 60,
      /* max_file_size_mb */ 60,
      /* port */ 4433,
      /* storage_path */ "/var/www/cpp/storage",
      /* thread_limit */ 4);

  Http3 http3(opts);
  Http3Logger http3_logger = [](const std::string& _level,
                                const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  http3.logger(http3_logger);
  Http3Handler http3_handler = [](Http3Req& ctx, Http3Stream& stream) -> void {
    Json::StreamWriterBuilder writer;
    writer["indentation"] = "";
    writer["emitUTF8"] = true;

    const std::string res = Json::writeString(writer, ctx);
    const Http1Res bytes(res.begin(), res.end());

    stream.set_code(200);
    stream.push_bytes(bytes, false);
    stream.end();
  };

  http3.on("/", http3_handler);
  http3.start();
}

🎉 TCP1 / WebSocket

📚 Configuration

Option Description
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
HANDSHAKE_TIMEOUT Maximum time in seconds to complete the TLS handshake.
MAX_MESSAGE_SIZE_MB Maximum size of a single message the server will accept from a client.
PING_TIMEOUT Maximum time the server will wait for a ping from the client.
PORT Defines which port the server will listen on.
SEND_TIMEOUT Maximum time for the client to receive a response from the server.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  WebSocketOpts opts(
      /* block_size_kb */ 64,
      /* compression */ false,
      /* handshake_timeout */ 30,
      /* max_message_size_kb */ 64,
      /* ping_timeout */ 15,
      /* port */ 4433,
      /* send_timeout */ 30,
      /* thread_limit */ 4);

  WebSocket ws(opts);
  WebSocketLogger ws_logger = [](const std::string& _level,
                                 const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  ws.logger(ws_logger);
  WebSocketHandler ws_handler = [](WebSocketCtx& ctx, WebSocketBytes& bytes,
                                   WebSocketStream& stream) -> void {
    stream.push(ctx, bytes);
    stream.close();
  };

  ws.on("connect", ws_handler);
  ws.start();
}

🎉 TCP1 / HTTP 2.0

📚 Configuration

Option Description
ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
CHARSET Defines the encoding that the server will recommend to all client applications.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_FIELDS Defines the maximum number of fields in the received form.
MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
MAX_FILES Defines the maximum number of files in the form.
MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
PORT Defines which port the server will listen on.
STORAGE_PATH Specifies the upload directory for storage.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  Http2Opts opts(
      /* allow_empty_files */ true,
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* charset */ "utf-8",
      /* compression */ true,
      /* keep_alive */ 30,
      /* keep_extensions */ true,
      ...
Read more
Loading

v0.9.3

02 Mar 19:06
@taronsarkisyan taronsarkisyan
v0.9.3
3617cc4

Choose a tag to compare

View all tags
v0.9.3

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C & C++ — a multi-language server with HTTP 3.0 and WebTransport support.

All supported protocols:

# Protocol Transport
1 TCP1 HTTP 1.1
2 TCP1 HTTP 2.0
3 TCP1 WebSocket
4 TCP2 HTTP 3.0
5 TCP2 WebTransport

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v15.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Run in terminal:

git clone git@github.com:arnelify/arnelify-server-cpp.git

🎉 TCP2 / WebTransport

📚 Configuration

Option Description
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
HANDSHAKE_TIMEOUT Maximum time in seconds to complete the TLS handshake.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_MESSAGE_SIZE_MB Maximum size of a single message the server will accept from a client.
PING_TIMEOUT Maximum time the server will wait for a ping from the client.
PORT Defines which port the server will listen on.
SEND_TIMEOUT Maximum time for the client to receive a response from the server.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  WebTransportOpts opts(
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* compression */ true,
      /* handshake_timeout */ 30,
      /* key_pem */ "certs/key.pem",
      /* max_message_size_kb */ 60,
      /* ping_timeout */ 30,
      /* port */ 4433,
      /* send_timeout */ 30,
      /* thread_limit */ 4);

  WebTransport wt(opts);
  WebTransportLogger wt_logger = [](const std::string& level,
                                    const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  wt.logger(wt_logger);

  WebTransportHandler wt_handler = [](WebTransportCtx& ctx,
                                      WebTransportBytes& bytes,
                                      WebTransportStream& stream) -> void {
    const WebTransportRes res = ctx;
    stream.push_json(res);
    stream.close();
  };

  wt.on("connect", wt_handler);
  wt.start();
}

🎉 TCP2 / HTTP 3.0

📚 Configuration

Option Description
ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
CHARSET Defines the encoding that the server will recommend to all client applications.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_FIELDS Defines the maximum number of fields in the received form.
MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
MAX_FILES Defines the maximum number of files in the form.
MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
PORT Defines which port the server will listen on.
STORAGE_PATH Specifies the upload directory for storage.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  Http3Opts opts(
      /* allow_empty_files */ true,
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* charset */ "utf-8",
      /* compression */ true,
      /* keep_alive */ 30,
      /* keep_extensions */ true,
      /* key_pem */ "certs/key.pem",
      /* max_fields*/ 60,
      /* max_fields_size_total_mb */ 1,
      /* max_files */ 3,
      /* max_files_size_total_mb */ 60,
      /* max_file_size_mb */ 60,
      /* port */ 4433,
      /* storage_path */ "/var/www/cpp/storage",
      /* thread_limit */ 4);

  Http3 http3(opts);
  Http3Logger http3_logger = [](const std::string& level,
                                const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  http3.logger(http3_logger);

  Http3Handler http3_handler = [](Http3Req& ctx, Http3Stream& stream) -> void {
    Json::StreamWriterBuilder writer;
    writer["indentation"] = "";
    writer["emitUTF8"] = true;

    const std::string res = Json::writeString(writer, ctx);
    const Http1Res bytes(res.begin(), res.end());

    stream.set_code(200);
    stream.push_bytes(bytes);
    stream.end();
  };

  http3.on("/", http3_handler);
  http3.start();
}

🎉 TCP1 / WebSocket

📚 Configuration

Option Description
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
HANDSHAKE_TIMEOUT Maximum time in seconds to complete the TLS handshake.
MAX_MESSAGE_SIZE_MB Maximum size of a single message the server will accept from a client.
PING_TIMEOUT Maximum time the server will wait for a ping from the client.
PORT Defines which port the server will listen on.
SEND_TIMEOUT Maximum time for the client to receive a response from the server.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  WebSocketOpts opts(
      /* block_size_kb */ 64,
      /* compression */ true,
      /* handshake_timeout */ 30,
      /* max_message_size_kb */ 64,
      /* ping_timeout */ 30,
      /* port */ 4433,
      /* send_timeout */ 30,
      /* thread_limit */ 4);

  WebSocket ws(opts);
  WebSocketLogger ws_logger = [](const std::string& level,
                                 const std::string& message) -> void {
    std::cout << "[Arnelify Server]: " << message << std::endl;
  };

  ws.logger(ws_logger);

  WebSocketHandler ws_handler = [](WebSocketCtx& ctx, WebSocketBytes& bytes,
                                   WebSocketStream& stream) -> void {
    const WebSocketRes res = ctx;
    stream.push_json(res);
    stream.close();
  };

  ws.on("connect", ws_handler);
  ws.start();
}

🎉 TCP1 / HTTP 2.0

📚 Configuration

Option Description
ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
CERT_PEM Path to the TLS cert-file in PEM format.
CHARSET Defines the encoding that the server will recommend to all client applications.
COMPRESSION If this option is enabled, the server will use BROTLI compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of BLOCK_SIZE_KB.
KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
KEY_PEM Path to the TLS private key-file in PEM format.
MAX_FIELDS Defines the maximum number of fields in the received form.
MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
MAX_FILES Defines the maximum number of files in the form.
MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
PORT Defines which port the server will listen on.
STORAGE_PATH Specifies the upload directory for storage.
THREAD_LIMIT Defines the maximum number of threads that will handle requests.

📚 Examples

#include <iostream>

#include "json.h"
#include "lib.hpp"

int main() {
  Http2Opts opts(
      /* allow_empty_files */ true,
      /* block_size_kb */ 64,
      /* cert_pem */ "certs/cert.pem",
      /* charset */ "utf-8",
      /* compression */ true,
      /*...
Read more
Loading

v0.7.8

09 May 16:11
@taronsarkisyan taronsarkisyan
v0.7.8
15b4304

Choose a tag to compare

View all tags
v0.7.8

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_NET_CHECK_FREQ_MS Network interface check frequency in milliseconds. The lower the value, the higher the CPU load.
SERVER_PORT Defines which port the server will listen on.
SERVER_THREAD_LIMIT Defines the maximum number of threads that will handle requests.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.7.8 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Minimalistic dynamic library for C++
  • Block processing in "on-the-fly" mode
  • Multi-Threading
  • GZIP support
  • FFI & Unix Domain Socket
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading

v0.7.7

05 May 00:21
@taronsarkisyan taronsarkisyan
v0.7.7
4d51c6a

Choose a tag to compare

View all tags
v0.7.7

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_PORT Defines which port the server will listen on.
SERVER_THREAD_LIMIT Defines the maximum number of threads that will handle requests.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.7.7 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Minimalistic dynamic library for C++
  • Block processing in "on-the-fly" mode
  • Multi-Threading
  • GZIP support
  • FFI & Unix Domain Socket
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading

v0.7.5

27 Apr 05:16
@taronsarkisyan taronsarkisyan
v0.7.5
2274d65

Choose a tag to compare

View all tags
v0.7.5

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_PORT Defines which port the server will listen on.
SERVER_THREAD_LIMIT Defines the maximum number of threads that will handle requests.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.7.5 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Minimalistic dynamic library for C++
  • Block processing in "on-the-fly" mode
  • Multi-Threading
  • GZIP support
  • FFI & Unix Domain Socket
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading

v0.7.4

21 Apr 19:07
@taronsarkisyan taronsarkisyan
v0.7.4
ea26fc5

Choose a tag to compare

View all tags
v0.7.4

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful http-server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_PORT Defines which port the server will listen on.
SERVER_THREAD_LIMIT Defines the maximum number of threads that will handle requests.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.7.4 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Multi-Threading
  • Minimalistic dynamic library for C++
  • Block processing in "on-the-fly" mode
  • GZIP support
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading

v0.7.3

07 Apr 07:37
@taronsarkisyan taronsarkisyan
v0.7.3
492a5f2

Choose a tag to compare

View all tags
v0.7.3

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful http-server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_PORT Defines which port the server will listen on.
SERVER_THREAD_LIMIT Defines the maximum number of threads that will handle requests.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.7.3 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Multi-Threading
  • Minimalistic dynamic library for C++
  • Block processing in "on-the-fly" mode
  • GZIP support
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading

v0.6.5

03 Apr 23:41
@taronsarkisyan taronsarkisyan
v0.6.5
16856d6

Choose a tag to compare

View all tags
v0.6.5

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful http-server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_PORT Defines which port the server will listen on.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.6.5 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Minimalistic dynamic library
  • NodeJS (Bun) addon
  • FFI Support
  • Block processing in "on-the-fly" mode
  • GZIP support
  • Boost and Magic libraries have been removed
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading

v0.6.4

02 Apr 00:07
@taronsarkisyan taronsarkisyan
v0.6.4
beb0f6b

Choose a tag to compare

View all tags
v0.6.4

Arnelify Logo

Arnelify Server for C++ C++ G++ C-Lang

🚀 About

Arnelify® Server for C++ - is a minimalistic dynamic library which is a powerful http-server written in C and C++.

📋 Minimal Requirements

Important: It's strongly recommended to use in a container that has been built from the gcc v14.2.0 image.

  • CPU: Apple M1 / Intel Core i7 / AMD Ryzen 7
  • OS: Debian 11 / MacOS 15 / Windows 10 with WSL2.
  • RAM: 4 GB

📦 Installation

Install to the folder that needs to be created:

git clone https://github.com/arnelify/arnelify-server-cpp.git

Run Docker:

docker compose up -d --build
docker ps
docker exec -it <CONTAINER ID> bash

🎉 Usage

Compile library:

make build

Run test:

make test

📚 Code Examples

Configure the C/C++ IntelliSense plugin for VSCode (optional).

Clang_format_fallback = Google

IncludePath for VSCode (optional):

"includePath": [
  "/opt/homebrew/Cellar/jsoncpp/1.9.6/include/json",
  "${workspaceFolder}/src/cpp",
  "${workspaceFolder}/src"
],

You can find code examples here.

Option Description
SERVER_ALLOW_EMPTY_FILES If this option is enabled, the server will not reject empty files.
SERVER_BLOCK_SIZE_KB The size of the allocated memory used for processing large packets.
SERVER_CHARSET Defines the encoding that the server will recommend to all client applications.
SERVER_GZIP If this option is enabled, the server will use GZIP compression if the client application supports it. This setting increases CPU resource consumption. The server will not use compression if the data size exceeds the value of SERVER_BLOCK_SIZE_KB.
SERVER_KEEP_EXTENSIONS If this option is enabled, file extensions will be preserved.
SERVER_MAX_FIELDS Defines the maximum number of fields in the received form.
SERVER_MAX_FIELDS_SIZE_TOTAL_MB Defines the maximum total size of all fields in the form. This option does not include file sizes.
SERVER_MAX_FILES Defines the maximum number of files in the form.
SERVER_MAX_FILES_SIZE_TOTAL_MB Defines the maximum total size of all files in the form.
SERVER_MAX_FILE_SIZE_MB Defines the maximum size of a single file in the form.
SERVER_PORT Defines which port the server will listen on.
SERVER_QUEUE_LIMIT Defines the maximum size of the queue on the client socket.
SERVER_UPLOAD_DIR Specifies the upload directory for storage.

⚖️ MIT License

This software is licensed under the MIT License. The original author's name, logo, and the original name of the software must be included in all copies or substantial portions of the software.

🛠️ Contributing

Join us to help improve this software, fix bugs or implement new functionality. Active participation will help keep the software up-to-date, reliable, and aligned with the needs of its users.

⭐ Release Notes

Version 0.6.4 - Minimalistic dynamic library

We are excited to introduce the Arnelify Server for C++ dynamic library! Please note that this version is raw and still in active development.

Change log:

  • Minimalistic dynamic library
  • NodeJS (Bun) addon
  • FFI Support
  • Block processing in "on-the-fly" mode
  • GZIP support
  • Boost and Magic libraries have been removed
  • Significant refactoring and optimizations

Please use this version with caution, as it may contain bugs and unfinished features. We are actively working on improving and expanding the server's capabilities, and we welcome your feedback and suggestions.

🔗 Mentioned

Loading