Fix mongoose docs generation

PUBLISHED_FROM=331821dcd1f7dc8a94581cd8a9b51aa00a89fddc

docs/c-api/mg_http.h/mg_http_send_digest_auth_request.md

+---
+title: "mg_http_send_digest_auth_request()"
+decl_name: "mg_http_send_digest_auth_request"
+symbol_kind: "func"
+signature: |
+  void mg_http_send_digest_auth_request(struct mg_connection *c,
+                                        const char *domain);
+---
+
+Sends 401 Unauthorized response. 
+

docs/c-api/mg_http.h/mg_printf_websocket_frame.md

+---
+title: "mg_printf_websocket_frame()"
+decl_name: "mg_printf_websocket_frame"
+symbol_kind: "func"
+signature: |
+  void mg_printf_websocket_frame(struct mg_connection *nc, int op_and_flags,
+                                 const char *fmt, ...);
+---
+
+Sends WebSocket frame to the remote end.
+
+Like `mg_send_websocket_frame()`, but allows to create formatted messages
+with `printf()`-like semantics. 
+

docs/c-api/mg_http.h/mg_send_websocket_frame.md

+---
+title: "mg_send_websocket_frame()"
+decl_name: "mg_send_websocket_frame"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_frame(struct mg_connection *nc, int op_and_flags,
+                               const void *data, size_t data_len);
+---
+
+Send WebSocket frame to the remote end.
+
+`op_and_flags` specifies the frame's type. It's one of:
+
+- WEBSOCKET_OP_CONTINUE
+- WEBSOCKET_OP_TEXT
+- WEBSOCKET_OP_BINARY
+- WEBSOCKET_OP_CLOSE
+- WEBSOCKET_OP_PING
+- WEBSOCKET_OP_PONG
+
+Orred with one of the flags:
+
+- WEBSOCKET_DONT_FIN: Don't set the FIN flag on the frame to be sent.
+
+`data` and `data_len` contain frame data. 
+

docs/c-api/mg_http.h/mg_send_websocket_framev.md

+---
+title: "mg_send_websocket_framev()"
+decl_name: "mg_send_websocket_framev"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_framev(struct mg_connection *nc, int op_and_flags,
+                                const struct mg_str *strings, int num_strings);
+---
+
+Like `mg_send_websocket_frame()`, but composes a single frame from multiple
+buffers. 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake.md

+---
+title: "mg_send_websocket_handshake()"
+decl_name: "mg_send_websocket_handshake"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake(struct mg_connection *nc, const char *uri,
+                                   const char *extra_headers);
+---
+
+Send websocket handshake to the server.
+
+`nc` must be a valid connection, connected to a server. `uri` is an URI
+to fetch, extra_headers` is extra HTTP headers to send or `NULL`.
+
+This function is intended to be used by websocket client.
+
+Note that the Host header is mandatory in HTTP/1.1 and must be
+included in `extra_headers`. `mg_send_websocket_handshake2` offers
+a better API for that.
+
+Deprecated in favour of `mg_send_websocket_handshake2` 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake2.md

+---
+title: "mg_send_websocket_handshake2()"
+decl_name: "mg_send_websocket_handshake2"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake2(struct mg_connection *nc, const char *path,
+                                    const char *host, const char *protocol,
+                                    const char *extra_headers);
+---
+
+Send websocket handshake to the server.
+
+`nc` must be a valid connection, connected to a server. `uri` is an URI
+to fetch, `host` goes into the `Host` header, `protocol` goes into the
+`Sec-WebSocket-Proto` header (NULL to omit), extra_headers` is extra HTTP
+headers to send or `NULL`.
+
+This function is intended to be used by websocket client. 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake3.md

+---
+title: "mg_send_websocket_handshake3()"
+decl_name: "mg_send_websocket_handshake3"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake3(struct mg_connection *nc, const char *path,
+                                    const char *host, const char *protocol,
+                                    const char *extra_headers, const char *user,
+                                    const char *pass);
+---
+
+Like mg_send_websocket_handshake2 but also passes basic auth header 
+

docs/c-api/mg_http.h/mg_send_websocket_handshake3v.md

+---
+title: "mg_send_websocket_handshake3v()"
+decl_name: "mg_send_websocket_handshake3v"
+symbol_kind: "func"
+signature: |
+  void mg_send_websocket_handshake3v(struct mg_connection *nc,
+                                     const struct mg_str path,
+                                     const struct mg_str host,
+                                     const struct mg_str protocol,
+                                     const struct mg_str extra_headers,
+                                     const struct mg_str user,
+                                     const struct mg_str pass);
+---
+
+Same as mg_send_websocket_handshake3 but with strings not necessarily
+NUL-temrinated 
+

docs/c-api/mg_http.h/mg_set_protocol_http_websocket.md

+---
+title: "mg_set_protocol_http_websocket()"
+decl_name: "mg_set_protocol_http_websocket"
+symbol_kind: "func"
+signature: |
+  void mg_set_protocol_http_websocket(struct mg_connection *nc);
+---
+
+Attaches a built-in HTTP event handler to the given connection.
+The user-defined event handler will receive following extra events:
+
+- MG_EV_HTTP_REQUEST: HTTP request has arrived. Parsed HTTP request
+ is passed as
+  `struct http_message` through the handler's `void *ev_data` pointer.
+- MG_EV_HTTP_REPLY: The HTTP reply has arrived. The parsed HTTP reply is
+  passed as `struct http_message` through the handler's `void *ev_data`
+  pointer.
+- MG_EV_HTTP_CHUNK: The HTTP chunked-encoding chunk has arrived.
+  The parsed HTTP reply is passed as `struct http_message` through the
+  handler's `void *ev_data` pointer. `http_message::body` would contain
+  incomplete, reassembled HTTP body.
+  It will grow with every new chunk that arrives, and it can
+  potentially consume a lot of memory. An event handler may process
+  the body as chunks are coming, and signal Mongoose to delete processed
+  body by setting `MG_F_DELETE_CHUNK` in `mg_connection::flags`. When
+  the last zero chunk is received,
+  Mongoose sends `MG_EV_HTTP_REPLY` event with
+  full reassembled body (if handler did not signal to delete chunks) or
+  with empty body (if handler did signal to delete chunks).
+- MG_EV_WEBSOCKET_HANDSHAKE_REQUEST: server has received the WebSocket
+  handshake request. `ev_data` contains parsed HTTP request.
+- MG_EV_WEBSOCKET_HANDSHAKE_DONE: server has completed the WebSocket
+  handshake. `ev_data` is `NULL`.
+- MG_EV_WEBSOCKET_FRAME: new WebSocket frame has arrived. `ev_data` is
+  `struct websocket_message *`
+
+When compiled with MG_ENABLE_HTTP_STREAMING_MULTIPART, Mongoose parses
+multipart requests and splits them into separate events:
+- MG_EV_HTTP_MULTIPART_REQUEST: Start of the request.
+  This event is sent before body is parsed. After this, the user
+  should expect a sequence of PART_BEGIN/DATA/END requests.
+  This is also the last time when headers and other request fields are
+  accessible.
+- MG_EV_HTTP_PART_BEGIN: Start of a part of a multipart message.
+  Argument: mg_http_multipart_part with var_name and file_name set
+  (if present). No data is passed in this message.
+- MG_EV_HTTP_PART_DATA: new portion of data from the multipart message.
+  Argument: mg_http_multipart_part. var_name and file_name are preserved,
+  data is available in mg_http_multipart_part.data.
+- MG_EV_HTTP_PART_END: End of the current part. var_name, file_name are
+  the same, no data in the message. If status is 0, then the part is
+  properly terminated with a boundary, status < 0 means that connection
+  was terminated.
+- MG_EV_HTTP_MULTIPART_REQUEST_END: End of the multipart request.
+  Argument: mg_http_multipart_part, var_name and file_name are NULL,
+  status = 0 means request was properly closed, < 0 means connection
+  was terminated (note: in this case both PART_END and REQUEST_END are
+  delivered). 
+

docs/c-api/mg_http.h/mg_url_decode.md

+---
+title: "mg_url_decode()"
+decl_name: "mg_url_decode"
+symbol_kind: "func"
+signature: |
+  int mg_url_decode(const char *src, int src_len, char *dst, int dst_len,
+                    int is_form_url_encoded);
+---
+
+Decodes a URL-encoded string.
+
+Source string is specified by (`src`, `src_len`), and destination is
+(`dst`, `dst_len`). If `is_form_url_encoded` is non-zero, then
+`+` character is decoded as a blank space character. This function
+guarantees to NUL-terminate the destination. If destination is too small,
+then the source string is partially decoded and `-1` is returned.
+*Otherwise,
+a length of the decoded string is returned, not counting final NUL. 
+

docs/c-api/mg_http.h/struct_http_message.md

+---
+title: "struct http_message"
+decl_name: "struct http_message"
+symbol_kind: "struct"
+signature: |
+  struct http_message {
+    struct mg_str message; /* Whole message: request line + headers + body */
+    struct mg_str body;    /* Message body. 0-length for requests with no body */
+  
+    /* HTTP Request line (or HTTP response line) */
+    struct mg_str method; /* "GET" */
+    struct mg_str uri;    /* "/my_file.html" */
+    struct mg_str proto;  /* "HTTP/1.1" -- for both request and response */
+  
+    /* For responses, code and response status message are set */
+    int resp_code;
+    struct mg_str resp_status_msg;
+  
+    /*
+     * Query-string part of the URI. For example, for HTTP request
+     *    GET /foo/bar?param1=val1&param2=val2
+     *    |    uri    |     query_string     |
+     *
+     * Note that question mark character doesn't belong neither to the uri,
+     * nor to the query_string
+     */
+    struct mg_str query_string;
+  
+    /* Headers */
+    struct mg_str header_names[MG_MAX_HTTP_HEADERS];
+    struct mg_str header_values[MG_MAX_HTTP_HEADERS];
+  };
+---
+
+HTTP message 
+

docs/c-api/mg_http.h/struct_mg_http_multipart_part.md

+---
+title: "struct mg_http_multipart_part"
+decl_name: "struct mg_http_multipart_part"
+symbol_kind: "struct"
+signature: |
+  struct mg_http_multipart_part {
+    const char *file_name;
+    const char *var_name;
+    struct mg_str data;
+    int status; /* <0 on error */
+    void *user_data;
+  };
+---
+
+HTTP multipart part 
+

docs/c-api/mg_http.h/struct_mg_ssi_call_ctx.md

+---
+title: "struct mg_ssi_call_ctx"
+decl_name: "struct mg_ssi_call_ctx"
+symbol_kind: "struct"
+signature: |
+  struct mg_ssi_call_ctx {
+    struct http_message *req; /* The request being processed. */
+    struct mg_str file;       /* Filesystem path of the file being processed. */
+    struct mg_str arg; /* The argument passed to the tag: <!-- call arg -->. */
+  };
+---
+
+SSI call context 
+

docs/c-api/mg_http.h/struct_websocket_message.md

+---
+title: "struct websocket_message"
+decl_name: "struct websocket_message"
+symbol_kind: "struct"
+signature: |
+  struct websocket_message {
+    unsigned char *data;
+    size_t size;
+    unsigned char flags;
+  };
+---
+
+WebSocket message 
+

docs/c-api/mg_http_client.h/intro.md

+---
+title: "Client API reference"
+symbol_kind: "intro"
+decl_name: "mg_http_client.h"
+items:
+  - { name: mg_connect_http.md }
+  - { name: mg_connect_http_opt.md }
+  - { name: mg_http_create_digest_auth_header.md }
+---
+
+
+

docs/c-api/mg_http_client.h/mg_connect_http.md

+---
+title: "mg_connect_http()"
+decl_name: "mg_connect_http"
+symbol_kind: "func"
+signature: |
+  struct mg_connection *mg_connect_http(
+      struct mg_mgr *mgr,
+      MG_CB(mg_event_handler_t event_handler, void *user_data);
+---
+
+Helper function that creates an outbound HTTP connection.
+
+`url` is the URL to fetch. It must be properly URL-encoded, e.g. have
+no spaces, etc. By default, `mg_connect_http()` sends the Connection and
+Host headers. `extra_headers` is an extra HTTP header to send, e.g.
+`"User-Agent: my-app\r\n"`.
+If `post_data` is NULL, then a GET request is created. Otherwise, a POST
+request is created with the specified POST data. Note that if the data being
+posted is a form submission, the `Content-Type` header should be set
+accordingly (see example below).
+
+Examples:
+
+```c
+  nc1 = mg_connect_http(mgr, ev_handler_1, "http://www.google.com", NULL,
+                        NULL);
+  nc2 = mg_connect_http(mgr, ev_handler_1, "https://github.com", NULL, NULL);
+  nc3 = mg_connect_http(
+      mgr, ev_handler_1, "my_server:8000/form_submit/",
+      "Content-Type: application/x-www-form-urlencoded\r\n",
+      "var_1=value_1&var_2=value_2");
+``` 
+

docs/c-api/mg_http_client.h/mg_connect_http_opt.md

+---
+title: "mg_connect_http_opt()"
+decl_name: "mg_connect_http_opt"
+symbol_kind: "func"
+signature: |
+  struct mg_connection *mg_connect_http_opt(
+      struct mg_mgr *mgr, MG_CB(mg_event_handler_t ev_handler, void *user_data);
+---
+
+Helper function that creates an outbound HTTP connection.
+
+Mostly identical to mg_connect_http, but allows you to provide extra
+*parameters
+(for example, SSL parameters) 
+

docs/c-api/mg_http_client.h/mg_http_create_digest_auth_header.md

+---
+title: "mg_http_create_digest_auth_header()"
+decl_name: "mg_http_create_digest_auth_header"
+symbol_kind: "func"
+signature: |
+  int mg_http_create_digest_auth_header(char *buf, size_t buf_len,
+                                        const char *method, const char *uri,
+                                        const char *auth_domain, const char *user,
+                                        const char *passwd, const char *nonce);
+---
+
+Creates digest authentication header for a client request. 
+

docs/c-api/mg_http_server.h/intro.md

+---
+title: "Server API reference"
+symbol_kind: "intro"
+decl_name: "mg_http_server.h"
+items:
+  - { name: mg_check_digest_auth.md }
+  - { name: mg_file_upload_handler.md }
+  - { name: mg_get_http_basic_auth.md }
+  - { name: mg_get_http_header.md }
+  - { name: mg_get_http_var.md }
+  - { name: mg_http_check_digest_auth.md }
+  - { name: mg_http_parse_header.md }
+  - { name: mg_http_reverse_proxy.md }
+  - { name: mg_http_send_error.md }
+  - { name: mg_http_send_redirect.md }
+  - { name: mg_http_serve_file.md }
+  - { name: mg_parse_http.md }
+  - { name: mg_parse_http_basic_auth.md }
+  - { name: mg_parse_multipart.md }
+  - { name: mg_printf_html_escape.md }
+  - { name: mg_printf_http_chunk.md }
+  - { name: mg_register_http_endpoint.md }
+  - { name: mg_send_head.md }
+  - { name: mg_send_http_chunk.md }
+  - { name: mg_send_response_line.md }
+  - { name: mg_serve_http.md }
+  - { name: mg_fu_fname_fn.md }
+  - { name: struct_mg_serve_http_opts.md }
+---
+
+
+

docs/c-api/mg_http_server.h/mg_check_digest_auth.md

+---
+title: "mg_check_digest_auth()"
+decl_name: "mg_check_digest_auth"
+symbol_kind: "func"
+signature: |
+  int mg_check_digest_auth(struct mg_str method, struct mg_str uri,
+                           struct mg_str username, struct mg_str cnonce,
+                           struct mg_str response, struct mg_str qop,
+                           struct mg_str nc, struct mg_str nonce,
+                           struct mg_str auth_domain, FILE *fp);
+---
+
+Authenticates given response params against an opened password file.
+Returns 1 if authenticated, 0 otherwise.
+
+It's used by mg_http_check_digest_auth(). 
+