GNU Libmicrohttpd

https://www.gnu.org/software/libmicrohttpd/
Admin
GNU Libmicrohttpd is a small C library that makes it easy to run an HTTP server as part of another...
Tokens:171,236
Snippets:923
Trust Score:10
Update:5 days ago
Show doc for...
Tokens:
Raw
### basicauthentication.c: main() daemon setup

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Starts the MHD daemon with MHD_USE_AUTO and MHD_USE_INTERNAL_POLLING_THREAD, registers answer_to_connection and request_completed, waits for a key press, then stops the daemon.

```c
int
main (void)
{
  struct MHD_Daemon *daemon;

  daemon = MHD_start_daemon (MHD_USE_AUTO | MHD_USE_INTERNAL_POLLING_THREAD,
                             PORT, NULL, NULL,
                             &answer_to_connection, NULL,
                             MHD_OPTION_NOTIFY_COMPLETED, request_completed,
                             NULL, MHD_OPTION_END);
  if (NULL == daemon)
    return 1;

  (void) getchar ();

  MHD_stop_daemon (daemon);

  return 0;
}
```

--------------------------------

### Minimal Libmicrohttpd HTTP server example

Source: https://www.gnu.org/software/libmicrohttpd

A complete minimal example for GNU/Linux that starts a daemon with thread-per-connection, handles GET requests by returning a static HTML page, and stops when stdin is closed. Requires including microhttpd.h and defining MHD_PLATFORM_H if needed.

```c
#include <microhttpd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define PAGE "<html><head><title>libmicrohttpd demo</title>"\
             "</head><body>libmicrohttpd demo</body></html>"

static enum MHD_Result
ahc_echo(void * cls,
         struct MHD_Connection * connection,
         const char * url,
         const char * method,
         const char * version,
         const char * upload_data,
         size_t * upload_data_size,
         void ** ptr) {
  static int dummy;
  const char *page = (const char *) cls;
  struct MHD_Response *response;
  enum MHD_Result ret;

  if (0 != strcmp(method, "GET"))
    return MHD_NO; /* unexpected method */
  if (&dummy != *ptr)
  {
    /* The first time only the headers are valid,
       do not respond in the first round... */
    *ptr = &dummy;
    return MHD_YES;
  }
  if (0 != *upload_data_size)
    return MHD_NO; /* upload data in a GET!? */
  *ptr = NULL; /* clear context pointer */
  response = MHD_create_response_from_buffer (strlen(page),
                                              (void*) page,
  					      MHD_RESPMEM_PERSISTENT);
  ret = MHD_queue_response(connection,
			   MHD_HTTP_OK,
			   response);
  MHD_destroy_response(response);
  return ret;
}

int
main(int argc,
     char ** argv) {
  struct MHD_Daemon * d;

  if (argc != 2)
  {
    printf("%s PORT\n",
	   argv[0]);
    return 1;
  }
  d = MHD_start_daemon(MHD_USE_THREAD_PER_CONNECTION,
		       atoi(argv[1]),
		       NULL,
		       NULL,
		       &ahc_echo,
		       PAGE,
		       MHD_OPTION_END);
  if (NULL == d)
    return 1;
  (void) getc (stdin);
  MHD_stop_daemon(d);
  return 0;
}

```

--------------------------------

### MHD_start_daemon with SNI callback

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Example of starting the MHD daemon with an HTTPS certificate callback for SNI support.

```APIDOC
## MHD_start_daemon

### Description
Starts the MHD daemon with SNI support by providing a certificate callback instead of a static certificate.

### Method
MHD_start_daemon

### Parameters
- **flags** (int) - Required - Combination of MHD_USE_INTERNAL_POLLING_THREAD and MHD_USE_SSL.
- **port** (uint16_t) - Required - Port number to listen on.
- **apc** (MHD_AcceptPolicyCallback) - Optional - Accept policy callback (NULL in example).
- **apc_cls** (void*) - Optional - Closure for accept policy callback (NULL in example).
- **dh** (MHD_AccessHandlerCallback) - Required - Handler for incoming connections.
- **dh_cls** (void*) - Optional - Closure for the access handler (NULL in example).
- **MHD_OPTION_HTTPS_CERT_CALLBACK** - Required - Option to set the SNI callback.
- **sni_callback** - Required - Pointer to the callback function.
- **MHD_OPTION_END** - Required - Terminates the option list.

### Request Example
```c
daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_SSL,
                           PORT, NULL, NULL,
                           &answer_to_connection, NULL,
                           MHD_OPTION_HTTPS_CERT_CALLBACK, &sni_callback,
                           MHD_OPTION_END);
```

### Response
#### Success Response
Returns a pointer to the daemon object on success, or NULL on failure.
```

--------------------------------

### largepost.c: Daemon setup and event loop

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Initializes the PRNG, starts the daemon with MHD_start_daemon, sets a 15-second connection timeout, and registers a completion callback. The main loop uses select() with MHD_get_fdset and MHD_get_timeout64, then calls MHD_run. Stops the daemon with MHD_stop_daemon on exit.

```c
  /* initialize PRNG */
  srand ((unsigned int) time (NULL));
  d = MHD_start_daemon (MHD_USE_ERROR_LOG,
                        (uint16_t) port,
                        NULL, NULL,
                        &create_response, NULL,
                        MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 15,
                        MHD_OPTION_NOTIFY_COMPLETED,
                        &request_completed_callback, NULL,
                        MHD_OPTION_APP_FD_SETSIZE, (int) FD_SETSIZE,
                        MHD_OPTION_END);
  if (NULL == d)
    return 1;
  while (1)
  {
    expire_sessions ();
    max = 0;
    FD_ZERO (&rs);
    FD_ZERO (&ws);
    FD_ZERO (&es);
    if (MHD_YES != MHD_get_fdset (d, &rs, &ws, &es, &max))
      break; /* fatal internal error */
    if (MHD_get_timeout64 (d, &mhd_timeout) == MHD_YES)
    {
#if ! defined(_WIN32) || defined(__CYGWIN__)
      tv.tv_sec = (time_t) (mhd_timeout / 1000);
#else  /* Native W32 */
      tv.tv_sec = (long) (mhd_timeout / 1000);
#endif /* Native W32 */
      tv.tv_usec = ((long) (mhd_timeout % 1000)) * 1000;
      tvp = &tv;
    }
    else
      tvp = NULL;
    if (-1 == select ((int) max + 1, &rs, &ws, &es, tvp))
    {
      if (EINTR != errno)
        fprintf (stderr,
                 "Aborting due to error during select: %s\n",
                 strerror (errno));
      break;
    }
    MHD_run (d);
  }
  MHD_stop_daemon (d);
  return 0;
}
```

--------------------------------

### Example: Create and Queue a Response

Source: https://www.gnu.org/software/libmicrohttpd/manual/libmicrohttpd.txt

Example showing how to create a response from a statically allocated string and queue it with a 404 status.

```APIDOC
## Example: Create and Queue a Response

### Description
Example showing how to create a response from a statically allocated string and queue it with a 404 status.

### Code
```c
const char * data = "<html><body><p>Error!</p></body></html>";

struct MHD_Connection * connection = ...;
struct MHD_Response *   response;

response = MHD_create_response_from_buffer (strlen(data), data,
                                            MHD_RESPMEM_PERSISTENT);
MHD_queue_response(connection, 404, response);
MHD_destroy_response(response);
```
```

--------------------------------

### hellobrowser.c: Minimal HTTP server with static response

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Complete example program that starts a libmicrohttpd daemon on port 8888 and serves a static HTML page. The callback 'answer_to_connection' creates a response from a static buffer and queues it. The daemon uses MHD_USE_AUTO and MHD_USE_INTERNAL_POLLING_THREAD. Pressing a key stops the daemon.

```c
/* Feel free to use this example code in any way
   you see fit (Public Domain) */

#include <sys/types.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/socket.h>
#else
#include <winsock2.h>
#endif
#include <string.h>
#include <microhttpd.h>
#include <stdio.h>

#define PORT 8888

static enum MHD_Result
answer_to_connection (void *cls, struct MHD_Connection *connection,
                      const char *url, const char *method,
                      const char *version, const char *upload_data,
                      size_t *upload_data_size, void **req_cls)
{
  const char *page = "<html><body>Hello, browser!</body></html>";
  struct MHD_Response *response;
  enum MHD_Result ret;
  (void) cls;               /* Unused. Silent compiler warning. */
  (void) url;               /* Unused. Silent compiler warning. */
  (void) method;            /* Unused. Silent compiler warning. */
  (void) version;           /* Unused. Silent compiler warning. */
  (void) upload_data;       /* Unused. Silent compiler warning. */
  (void) upload_data_size;  /* Unused. Silent compiler warning. */
  (void) req_cls;           /* Unused. Silent compiler warning. */

  response = MHD_create_response_from_buffer_static (strlen (page), page);
  ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
  MHD_destroy_response (response);

  return ret;
}


int
main (void)
{
  struct MHD_Daemon *daemon;

  daemon = MHD_start_daemon (MHD_USE_AUTO | MHD_USE_INTERNAL_POLLING_THREAD,
                             PORT, NULL, NULL,
                             &answer_to_connection, NULL, MHD_OPTION_END);
  if (NULL == daemon)
    return 1;

  (void) getchar ();

  MHD_stop_daemon (daemon);
  return 0;
}

```

--------------------------------

### websocket.c: Full WebSocket server example with HTML client

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

This is the complete websocket.c example from the GNU libmicrohttpd tutorial. It includes the HTML/JavaScript client that opens a WebSocket connection, and the C server code that handles the upgrade. The server uses MHD_websocket_stream_init and MHD_websocket_stream_is_valid to manage the WebSocket stream. Note that the code is truncated in the source, so the full example is not shown.

```C
/* Feel free to use this example code in any way
   you see fit (Public Domain) */

#include <sys/types.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/socket.h>
#include <fcntl.h>
#else
#include <winsock2.h>
#endif
#include <microhttpd.h>
#include <microhttpd_ws.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define PORT 80

#define PAGE \
  "<!DOCTYPE html>\n" \
  "<html>\n" \
  "<head>\n" \
  "<meta charset=\"UTF-8\">\n" \
  "<title>Websocket Demo</title>\n" \
  "<script>\n" \
  "\n" \
  "let url = 'ws' + (window.location.protocol === 'https:' ? 's' : '')" \
    "  + ':/" "/' +\n" \
  "          window.location.host + '/chat';\n" \
  "let socket = null;\n" \
  "\n" \
  "window.onload = function(event) {\n" \
  "  socket = new WebSocket(url);\n" \
  "  socket.onopen = function(event) {\n" \
  "    document.write('The websocket connection has been " \
    "established.<br>');\n" \
  "\n" \
  "    /" "/ Send some text\n" \
  "    socket.send('Hello from JavaScript!');\n" \
  "  }\n" \
  "\n" \
  "  socket.onclose = function(event) {\n" \
  "    document.write('The websocket connection has been closed.<br>');\n" \
  "  }\n" \
  "\n" \
  "  socket.onerror = function(event) {\n" \
  "    document.write('An error occurred during the websocket " \
    "communication.<br>');\n" \
  "  }\n" \
  "\n" \
  "  socket.onmessage = function(event) {\n" \
  "    document.write('Websocket message received: ' + " \
    "event.data + '<br>');\n" \
  "  }\n" \
  "}\n" \
  "\n" \
  "</script>\n" \
  "</head>\n" \
  "<body>\n" \
  "</body>\n" \
  "</html>"

#define PAGE_NOT_FOUND \
  "404 Not Found"

#define PAGE_INVALID_WEBSOCKET_REQUEST \
  "Invalid WebSocket request!"

static void
send_all (MHD_socket fd,
          const char *buf,
          size_t len);

static void
make_blocking (MHD_socket fd);

static void
upgrade_handler (void *cls,
                 struct MHD_Connection *connection,
                 void *req_cls,
                 const char *extra_in,
                 size_t extra_in_size,
                 MHD_socket fd,
                 struct MHD_UpgradeResponseHandle *urh)
{
  /* make the socket blocking (operating-system-dependent code) */
  make_blocking (fd);

  /* create a websocket stream for this connection */
  struct MHD_WebSocketStream *ws;
  int result = MHD_websocket_stream_init (&ws,
                                          0,
                                          0);
  if (0 != result)
  {
    /* Couldn't create the websocket stream.
     * So we close the socket and leave
     */
    MHD_upgrade_action (urh,
                        MHD_UPGRADE_ACTION_CLOSE);
    return;
  }

  /* Let's wait for incoming data */
  const size_t buf_len = 256;
  char buf[buf_len];
  ssize_t got;
  while (MHD_WEBSOCKET_VALIDITY_VALID == MHD_websocket_stream_is_valid (ws))
  {
    got = recv (fd,
                buf,
                buf_len,
                0);
    if (0 >= got)
    {
      /* the TCP/IP socket has been closed */
      break;
    }

```

--------------------------------

### Build GNU libmicrohttpd with configure, make, and make install

Source: https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002dintro.html

Standard build process for GNU libmicrohttpd. Run these commands in the source directory to configure, compile, and install the library.

```shell
$ ./configure
$ make
$ make install

```

--------------------------------

### Start daemon with MHD_ALLOW_UPGRADE flag

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Pass MHD_ALLOW_UPGRADE to MHD_start_daemon() to enable upgrading HTTP connections. The example also uses MHD_USE_INTERNAL_POLLING_THREAD, MHD_USE_THREAD_PER_CONNECTION, and MHD_USE_ERROR_LOG.

```c
daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD |
                           MHD_USE_THREAD_PER_CONNECTION |
                           MHD_ALLOW_UPGRADE |
                           MHD_USE_ERROR_LOG,
                           PORT, NULL, NULL,
                           &access_handler, NULL,
                           MHD_OPTION_END);

```

--------------------------------

### Start daemon in main

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Starts the HTTP daemon with MHD_start_daemon using MHD_USE_INTERNAL_POLLING_THREAD, the defined port, and the answer_to_connection callback. Returns 1 if the daemon fails to start.

```c
int main ()
{
  struct MHD_Daemon *daemon;

  daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD, PORT, NULL, NULL,
                             &answer_to_connection, NULL, MHD_OPTION_END);
  if (NULL == daemon) return 1;

```

--------------------------------

### Initialize daemon with MHD_OPTION_ARRAY

Source: https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002dconst.html

Shows how to use MHD_OPTION_ARRAY to pass options via an array of struct MHD_OptionItem. The array must be terminated with MHD_OPTION_END. The example sets connection limit and timeout, then starts the daemon with MHD_start_daemon.

```c
struct MHD_OptionItem ops[] = {
 { MHD_OPTION_CONNECTION_LIMIT, 100, NULL },
 { MHD_OPTION_CONNECTION_TIMEOUT, 10, NULL },
 { MHD_OPTION_END, 0, NULL }
};
d = MHD_start_daemon(0, 8080, NULL, NULL, dh, NULL,
                     MHD_OPTION_ARRAY, ops,
                     MHD_OPTION_END);

```

--------------------------------

### Start HTTPS daemon with MHD_OPTION_HTTPS_MEM_KEY and MHD_OPTION_HTTPS_MEM_CERT

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Starts the daemon with MHD_USE_SSL and passes the loaded key and certificate. If startup fails, prints the certificate, frees memory, and returns 1.

```c
  daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_SSL,
  	   	     PORT, NULL, NULL,
                             &answer_to_connection, NULL,
                             MHD_OPTION_HTTPS_MEM_KEY, key_pem,
                             MHD_OPTION_HTTPS_MEM_CERT, cert_pem,
                             MHD_OPTION_END);

  if (NULL == daemon)
    {
      printf ("%s\n", cert_pem);

      free (key_pem);
      free (cert_pem);

      return 1;
    }

```

--------------------------------

### Example: Handling Digest Authentication

Source: https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002ddauth-digest.html

Example code demonstrating how to handle digest authentication requests and responses using MHD_digest_auth_get_username, MHD_digest_auth_check2, and MHD_queue_auth_fail_response2.

```APIDOC
## Example: Handling Digest Authentication

### Description
Example handler that checks digest authentication credentials and queues appropriate responses.

### Code
```c
#define PAGE "<html><head><title>libmicrohttpd demo</title></head><body>Access granted</body></html>"
#define DENIED "<html><head><title>libmicrohttpd demo</title></head><body>Access denied</body></html>"
#define OPAQUE "11733b200778ce33060f31c9af70a870ba96ddd4"

static int
ahc_echo (void *cls,
          struct MHD_Connection *connection,
          const char *url,
          const char *method,
          const char *version,
          const char *upload_data, size_t *upload_data_size, void **ptr)
{
  struct MHD_Response *response;
  char *username;
  const char *password = "testpass";
  const char *realm = "test@example.com";
  int ret;

  username = MHD_digest_auth_get_username (connection);
  if (username == NULL)
    {
      response = MHD_create_response_from_buffer(strlen (DENIED),
					         DENIED,
					         MHD_RESPMEM_PERSISTENT);
      ret = MHD_queue_auth_fail_response2 (connection,
                                           realm,
					   OPAQUE,
					   response,
					   MHD_NO,
                                           MHD_DIGEST_ALG_SHA256);
      MHD_destroy_response(response);
      return ret;
    }
  ret = MHD_digest_auth_check2 (connection,
                                realm,
			        username,
			        password,
			        300,
                                MHD_DIGEST_ALG_SHA256);
  free(username);
  if ( (ret == MHD_INVALID_NONCE) ||
       (ret == MHD_NO) )
    {
      response = MHD_create_response_from_buffer(strlen (DENIED),
					         DENIED,
					         MHD_RESPMEM_PERSISTENT);
      if (NULL == response)
	return MHD_NO;
      ret = MHD_queue_auth_fail_response2 (connection,
                                           realm,
					   OPAQUE,
					   response,
					   (ret == MHD_INVALID_NONCE) ? MHD_YES : MHD_NO,
                                           MHD_DIGEST_ALG_SHA256);
      MHD_destroy_response(response);
      return ret;
    }
  response = MHD_create_response_from_buffer (strlen(PAGE),
                                              PAGE,
 					      MHD_RESPMEM_PERSISTENT);
  ret = MHD_queue_response (connection,
                            MHD_HTTP_OK,
                            response);
  MHD_destroy_response(response);
  return ret;
}
```
```

--------------------------------

### simplepost.c: Handling POST requests with libmicrohttpd (partial)

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Partial example of a libmicrohttpd server that handles POST requests. It defines a connection_info_struct to store the connection type and a post processor, and includes an askpage HTML form that submits to /namepost. The code is incomplete as it only shows the beginning of the example, including the send_page helper function. The example is in the public domain.

```C
/* Feel free to use this example code in any way
   you see fit (Public Domain) */

#include <sys/types.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/socket.h>
#else
#include <winsock2.h>
#endif
#include <microhttpd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#if defined(_MSC_VER) && _MSC_VER + 0 <= 1800
/* Substitution is OK while return value is not used */
#define snprintf _snprintf
#endif

#define PORT            8888
#define POSTBUFFERSIZE  512
#define MAXNAMESIZE     20
#define MAXANSWERSIZE   512

#define GET             0
#define POST            1

struct connection_info_struct
{
  int connectiontype;
  char *answerstring;
  struct MHD_PostProcessor *postprocessor;
};

static const char *askpage =
  "<html><body>\n"
  "What's your name, Sir?<br>\n"
  "<form action=\"/namepost\" method=\"post\">\n"
  "<input name=\"name\" type=\"text\">\n"
  "<input type=\"submit\" value=\" Send \"></form>\n"
  "</body></html>";

#define GREETINGPAGE \
  "<html><body><h1>Welcome, %s!</center></h1></body></html>"

static const char *errorpage =
  "<html><body>This doesn't seem to be right.</body></html>";


static enum MHD_Result
send_page (struct MHD_Connection *connection, const char *page)
{
  enum MHD_Result ret;
  struct MHD_Response *response;


  response = MHD_create_response_from_buffer_static (strlen (page), page);
  if (! response)
    return MHD_NO;

```

--------------------------------

### Load key and certificate files in main()

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Loads the server key and certificate files into memory. If either file cannot be read, prints an error and returns 1.

```c
int
main ()
{
  struct MHD_Daemon *daemon;
  char *key_pem;
  char *cert_pem;

  key_pem = load_file (SERVERKEYFILE);
  cert_pem = load_file (SERVERCERTFILE);

  if ((key_pem == NULL) || (cert_pem == NULL))
  {
    printf ("The key/certificate files could not be read.\n");
    return 1;
  }

```

--------------------------------

### SIGPIPE handler example in C

Source: https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002dintro.html

C code to install a SIGPIPE handler that ignores the signal, preventing process termination on platforms where MHD does not disable SIGPIPE. Call ignore_sigpipe() in main.

```c
static void
catcher (int sig)
{
}

static void
ignore_sigpipe ()
{
  struct sigaction oldsig;
  struct sigaction sig;

  sig.sa_handler = &catcher;
  sigemptyset (&sig.sa_mask);
#ifdef SA_INTERRUPT
  sig.sa_flags = SA_INTERRUPT;  /* SunOS */
#else
  sig.sa_flags = SA_RESTART;
#endif
  if (0 != sigaction (SIGPIPE, &sig, &oldsig))
    fprintf (stderr,
             "Failed to install SIGPIPE handler: %s\n", strerror (errno));
}
```

--------------------------------

### Build GNU libmicrohttpd with configure, make, and make install

Source: https://www.gnu.org/software/libmicrohttpd/manual/libmicrohttpd.txt

Standard GNU build process for MHD. Run these commands in sequence from the source directory.

```shell
$ ./configure
$ make
$ make install
```

--------------------------------

### basicauthentication.c: HTTP Basic Authentication with libmicrohttpd

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Complete example of a libmicrohttpd server that requires HTTP Basic Authentication. It uses MHD_basic_auth_get_username_password3 to retrieve credentials and MHD_queue_basic_auth_required_response3 to send a 401 challenge. The server listens on port 8888 and only responds to GET requests, checking for username 'root' and password 'pa$$w0rd'. The example is in the public domain.

```C
/* Feel free to use this example code in any way
   you see fit (Public Domain) */

#include <sys/types.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/socket.h>
#else
#include <winsock2.h>
#endif
#include <microhttpd.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define PORT 8888


static enum MHD_Result
answer_to_connection (void *cls, struct MHD_Connection *connection,
                      const char *url, const char *method,
                      const char *version, const char *upload_data,
                      size_t *upload_data_size, void **req_cls)
{
  struct MHD_BasicAuthInfo *auth_info;
  enum MHD_Result ret;
  struct MHD_Response *response;
  (void) cls;               /* Unused. Silent compiler warning. */
  (void) url;               /* Unused. Silent compiler warning. */
  (void) version;           /* Unused. Silent compiler warning. */
  (void) upload_data;       /* Unused. Silent compiler warning. */
  (void) upload_data_size;  /* Unused. Silent compiler warning. */

  if (0 != strcmp (method, "GET"))
    return MHD_NO;
  if (NULL == *req_cls)
  {
    *req_cls = connection;
    return MHD_YES;
  }
  auth_info = MHD_basic_auth_get_username_password3 (connection);
  if (NULL == auth_info)
  {
    static const char *page =
      "<html><body>Authorization required</body></html>";
    response = MHD_create_response_from_buffer_static (strlen (page), page);
    ret = MHD_queue_basic_auth_required_response3 (connection,
                                                   "admins",
                                                   MHD_YES,
                                                   response);
  }
  else if ((strlen ("root") != auth_info->username_len) ||
           (0 != memcmp (auth_info->username, "root",
                         auth_info->username_len)) ||
           /* The next check against NULL is optional,
            * if 'password' is NULL then 'password_len' is always zero. */
           (NULL == auth_info->password) ||
           (strlen ("pa$$w0rd") != auth_info->password_len) ||
           (0 != memcmp (auth_info->password, "pa$$w0rd",
                         auth_info->password_len)))
  {
    static const char *page =
      "<html><body>Wrong username or password</body></html>";
    response = MHD_create_response_from_buffer_static (strlen (page), page);
    ret = MHD_queue_basic_auth_required_response3 (connection,
                                                   "admins",
                                                   MHD_YES,
                                                   response);
  }
  else
  {
    static const char *page = "<html><body>A secret.</body></html>";
    response = MHD_create_response_from_buffer_static (strlen (page), page);
    ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
  }
  if (NULL != auth_info)
    MHD_free (auth_info);
  MHD_destroy_response (response);
  return ret;
}


int
main (void)
{
  struct MHD_Daemon *daemon;

  daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD, PORT, NULL, NULL,
                             &answer_to_connection, NULL, MHD_OPTION_END);
  if (NULL == daemon)
    return 1;

  (void) getchar ();

  MHD_stop_daemon (daemon);
  return 0;
}

```

--------------------------------

### Compile hellobrowser.c with cc

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Compile the example with the C compiler, linking against libmicrohttpd. Set PATH_TO_LIBMHD_INCLUDES and PATH_TO_LIBMHD_LIBS to the appropriate paths. The output binary is named hellobrowser.

```shell
cc hellobrowser.c -o hellobrowser -I$PATH_TO_LIBMHD_INCLUDES
  -L$PATH_TO_LIBMHD_LIBS -lmicrohttpd

```

--------------------------------

### Example WebSocket client request

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

A valid HTTP request that initiates a WebSocket handshake. Must be a GET request with HTTP/1.1 or higher, and include Host, Upgrade: websocket, Connection: Upgrade, Sec-WebSocket-Key (base64-encoded 16-byte random value), and Sec-WebSocket-Version: 13.

```http
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

```

--------------------------------

### responseheaders.c: Serve a file with custom Content-Type header

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Complete libmicrohttpd example that serves the file 'picture.png' with MIME type 'image/png'. It only handles GET requests, returns a 500 error page if the file cannot be opened, and adds the Content-Type header using MHD_add_response_header. The server runs until a key is pressed.

```C
/* Feel free to use this example code in any way
   you see fit (Public Domain) */

#include <sys/types.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/socket.h>
#else
#include <winsock2.h>
#endif
#include <microhttpd.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>

#define PORT 8888
#define FILENAME "picture.png"
#define MIMETYPE "image/png"

static enum MHD_Result
answer_to_connection (void *cls, struct MHD_Connection *connection,
                      const char *url, const char *method,
                      const char *version, const char *upload_data,
                      size_t *upload_data_size, void **req_cls)
{
  struct MHD_Response *response;
  int fd;
  enum MHD_Result ret;
  struct stat sbuf;
  (void) cls;               /* Unused. Silent compiler warning. */
  (void) url;               /* Unused. Silent compiler warning. */
  (void) version;           /* Unused. Silent compiler warning. */
  (void) upload_data;       /* Unused. Silent compiler warning. */
  (void) upload_data_size;  /* Unused. Silent compiler warning. */
  (void) req_cls;           /* Unused. Silent compiler warning. */

  if (0 != strcmp (method, "GET"))
    return MHD_NO;

  if ( (-1 == (fd = open (FILENAME, O_RDONLY))) ||
       (0 != fstat (fd, &sbuf)) )
  {
    const char *errorstr =
      "<html><body>An internal server error has occurred!\
                              </body></html>";
    /* error accessing file */
    if (fd != -1)
      (void) close (fd);
    response =
      MHD_create_response_from_buffer_static (strlen (errorstr), errorstr);
    if (NULL != response)
    {
      ret =
        MHD_queue_response (connection, MHD_HTTP_INTERNAL_SERVER_ERROR,
                            response);
      MHD_destroy_response (response);

      return ret;
    }
    else
      return MHD_NO;
  }
  response =
    MHD_create_response_from_fd_at_offset64 ((size_t) sbuf.st_size,
                                             fd,
                                             0);
  if (MHD_YES !=
      MHD_add_response_header (response,
                               MHD_HTTP_HEADER_CONTENT_TYPE,
                               MIMETYPE))
  {
    fprintf (stderr,
             "Failed to set content type header!\n");
    /* return response without content encoding anyway ... */
  }
  ret = MHD_queue_response (connection,
                            MHD_HTTP_OK,
                            response);
  MHD_destroy_response (response);

  return ret;
}


int
main (void)
{
  struct MHD_Daemon *daemon;

  daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD, PORT, NULL, NULL,
                             &answer_to_connection, NULL, MHD_OPTION_END);
  if (NULL == daemon)
    return 1;

  (void) getchar ();

  MHD_stop_daemon (daemon);

  return 0;
}

```

--------------------------------

### logging.c: Log incoming request headers with MHD_get_connection_values

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Complete libmicrohttpd example that starts a daemon on port 8888 and, for each request, prints the method, URL, and version, then uses MHD_get_connection_values with MHD_HEADER_KIND to print all request headers via the print_out_key callback. The server runs until a key is pressed, then stops the daemon.

```C
/* Feel free to use this example code in any way
   you see fit (Public Domain) */

#include <sys/types.h>
#ifndef _WIN32
#include <sys/select.h>
#include <sys/socket.h>
#else
#include <winsock2.h>
#endif
#include <microhttpd.h>
#include <stdio.h>

#define PORT 8888


static enum MHD_Result
print_out_key (void *cls, enum MHD_ValueKind kind, const char *key,
               const char *value)
{
  (void) cls;    /* Unused. Silent compiler warning. */
  (void) kind;   /* Unused. Silent compiler warning. */
  printf ("%s: %s\n", key, value);
  return MHD_YES;
}


static enum MHD_Result
answer_to_connection (void *cls, struct MHD_Connection *connection,
                      const char *url, const char *method,
                      const char *version, const char *upload_data,
                      size_t *upload_data_size, void **req_cls)
{
  (void) cls;               /* Unused. Silent compiler warning. */
  (void) version;           /* Unused. Silent compiler warning. */
  (void) upload_data;       /* Unused. Silent compiler warning. */
  (void) upload_data_size;  /* Unused. Silent compiler warning. */
  (void) req_cls;           /* Unused. Silent compiler warning. */
  printf ("New %s request for %s using version %s\n", method, url, version);

  MHD_get_connection_values (connection, MHD_HEADER_KIND, print_out_key,
                             NULL);

  return MHD_NO;
}


int
main (void)
{
  struct MHD_Daemon *daemon;

  daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD, PORT, NULL, NULL,
                             &answer_to_connection, NULL, MHD_OPTION_END);
  if (NULL == daemon)
    return 1;

  (void) getchar ();

  MHD_stop_daemon (daemon);
  return 0;
}

```

--------------------------------

### MHD_start_daemon

Source: https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002dinit.html

Starts a webserver on the given port. Returns a handle to the daemon on success, or NULL on error.

```APIDOC
## MHD_start_daemon

### Description
Start a webserver on the given port. Returns `NULL` on error, handle to daemon on success.

### Function Signature
`struct MHD_Daemon *MHD_start_daemon(unsigned int flags, unsigned short port, MHD_AcceptPolicyCallback apc, void *apc_cls, MHD_AccessHandlerCallback dh, void *dh_cls, ...)`

### Parameters
- **flags** (unsigned int) - Required - OR-ed combination of `MHD_FLAG` values.
- **port** (unsigned short) - Required - Port to bind to.
- **apc** (MHD_AcceptPolicyCallback) - Required - Callback to call to check which clients will be allowed to connect; you can pass `NULL` in which case connections from any IP will be accepted.
- **apc_cls** (void*) - Required - Extra argument to apc.
- **dh** (MHD_AccessHandlerCallback) - Required - Default handler for all URIs.
- **dh_cls** (void*) - Required - Extra argument to dh.
- **...** (variadic) - Required - Additional arguments are a list of options (type-value pairs, terminated with `MHD_OPTION_END`). It is mandatory to use `MHD_OPTION_END` as last argument, even when there are no additional arguments.

### Return Value
Returns `NULL` on error, handle to daemon on success.
```

--------------------------------

### Handle GET requests

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

For GET requests, send the question form using `send_page` with `askpage`.

```c
  if (0 == strcmp (method, "GET"))
    {
      return send_page (connection, askpage);
    }

```

--------------------------------

### Generate a 1024-bit private key with OpenSSL

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

Run this command to create a private key file named server.key. The key is used to authenticate the server to clients. A 1024-bit key is sufficient for this tutorial.

```bash
> openssl genrsa -out server.key 1024

```

--------------------------------

### MHD_start_daemon

Source: https://www.gnu.org/software/libmicrohttpd/manual/html_node/microhttpd_002dinit.html

Starts a HTTP daemon with the specified options and callbacks. Returns a handle to the daemon on success or NULL on error.

```APIDOC
## MHD_start_daemon

### Description
Starts a HTTP daemon with the given options and callbacks. This function initializes the server and begins listening for connections.

### Function Signature
```c
struct MHD_Daemon *MHD_start_daemon (unsigned int flags,
                                    uint16_t port,
                                    MHD_AcceptPolicyCallback apc,
                                    void *apc_cls,
                                    MHD_AccessHandlerCallback dh,
                                    void *dh_cls,
                                    ...);
```

### Parameters
- **flags** (unsigned int) - Required - Bitwise OR of MHD_OPTION_* values controlling daemon behavior.
- **port** (uint16_t) - Required - Port number to listen on. Use 0 to let the system choose.
- **apc** (MHD_AcceptPolicyCallback) - Optional - Callback to decide whether to accept incoming connections. Can be NULL.
- **apc_cls** (void*) - Optional - Extra argument passed to apc.
- **dh** (MHD_AccessHandlerCallback) - Required - Callback to handle incoming requests.
- **dh_cls** (void*) - Optional - Extra argument passed to dh.
- **...** - Optional - Additional options terminated by MHD_OPTION_END.

### Return Value
- On success, returns a pointer to the daemon handle.
- On error, returns NULL and sets errno.

### Example
```c
struct MHD_Daemon *daemon = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD,
                                              8888,
                                              NULL, NULL,
                                              &answer_to_connection,
                                              NULL,
                                              MHD_OPTION_END);
```
```

--------------------------------

### Main function with port validation

Source: https://www.gnu.org/software/libmicrohttpd/tutorial.html

The main function parses the port argument, validates it is between 1 and 65535, and then proceeds to set up the server. It prints usage if the argument count is incorrect.

```c
int
main (int argc, char *const *argv)
{
  struct MHD_Daemon *d;
  struct timeval tv;
  struct timeval *tvp;
  fd_set rs;
  fd_set ws;
  fd_set es;
  MHD_socket max;
  uint64_t mhd_timeout;
  unsigned int port;

  if (argc != 2)
  {
    printf ("%s PORT\n", argv[0]);
    return 1;
  }
  if ( (1 != sscanf (argv[1], "%u", &port)) ||
       (0 == port) || (65535 < port) )
  {
    fprintf (stderr,
             "Port must be a number between 1 and 65535.\n");
    return 1;
  }
```
Tokens:
Raw