[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r28771 - libmicrohttpd/src/include
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r28771 - libmicrohttpd/src/include |
|
Date: |
Thu, 22 Aug 2013 06:44:38 +0200 |
Author: grothoff
Date: 2013-08-22 06:44:38 +0200 (Thu, 22 Aug 2013)
New Revision: 28771
Modified:
libmicrohttpd/src/include/microhttpd.h
Log:
improving doxygen use
Modified: libmicrohttpd/src/include/microhttpd.h
===================================================================
--- libmicrohttpd/src/include/microhttpd.h 2013-08-21 17:48:08 UTC (rev
28770)
+++ libmicrohttpd/src/include/microhttpd.h 2013-08-22 04:44:38 UTC (rev
28771)
@@ -28,7 +28,7 @@
* errors (you can only enable or disable logging to stderr). Also,
* it may not support all of the HTTP features directly, where
* applicable, portions of HTTP may have to be handled by clients of
- * the library.<p>
+ * the library.
*
* The library is supposed to handle everything that it must handle
* (because the API would not allow clients to do this), such as basic
@@ -38,14 +38,14 @@
* the response and not the body, even if the client supplied a body.
* The library also understands headers that control connection
* management (specifically, "Connection: close" and "Expect: 100
- * continue" are understood and handled automatically).<p>
+ * continue" are understood and handled automatically).
*
* MHD understands POST data and is able to decode certain formats
* (at the moment only "application/x-www-form-urlencoded" and
* "mulitpart/formdata"). Unsupported encodings and large POST
* submissions may require the application to manually process
* the stream, which is provided to the main application (and thus can be
- * processed, just not conveniently by MHD).<p>
+ * processed, just not conveniently by MHD).
*
* The header file defines various constants used by the HTTP protocol.
* This does not mean that MHD actually interprets all of these
@@ -53,11 +53,11 @@
* for users of the library. MHD does not verify that transmitted
* HTTP headers are part of the standard specification; users of the
* library are free to define their own extensions of the HTTP
- * standard and use those with MHD.<p>
+ * standard and use those with MHD.
*
* All functions are guaranteed to be completely reentrant and
- * thread-safe (with the exception of 'MHD_set_connection_value',
- * which must only be used in a particular context).<p>
+ * thread-safe (with the exception of #MHD_set_connection_value,
+ * which must only be used in a particular context).
*
* NEW: Before including "microhttpd.h" you should add the necessary
* includes to define the "uint64_t", "size_t", "fd_set", "socklen_t"
@@ -67,6 +67,16 @@
* should also have a line with "#define MHD_PLATFORM_H" which will
* prevent this header from trying (and, depending on your platform,
* failing) to include the right headers.
+ *
+ * @defgroup tls HTTPS/SSL/TLS control
+ * @defgroup event event-loop control
+ * @defgroup response generation of responses
+ * @defgroup request handling of requests
+ * @defgroup authentication HTTP authentication
+ * @defgroup logging logging and error handling
+ * @defgroup networking general networking
+ * @defgroup specialized misc. specialized functions
+ * @defgroup limits configuring resource limitations
*/
#ifndef MHD_MICROHTTPD_H
@@ -167,7 +177,8 @@
/**
- * HTTP response codes.
+ * @defgroup httpcode HTTP response codes.
+ * @{
*/
#define MHD_HTTP_CONTINUE 100
#define MHD_HTTP_SWITCHING_PROTOCOLS 101
@@ -230,13 +241,20 @@
#define MHD_HTTP_BANDWIDTH_LIMIT_EXCEEDED 509
#define MHD_HTTP_NOT_EXTENDED 510
+/** @} */ /* end of group httpcode */
+
/**
* Flag to be "OR"ed with MHD_HTTP status code for
* SHOUTcast. This will cause the response to begin
* with the SHOUTcast "ICY" line instad of "HTTP".
+ * @ingroup specialized
*/
#define MHD_ICY_FLAG ((uint32_t)(1 << 31))
+/**
+ * @defgroup headers HTTP headers
+ * @{
+ */
/* See also: http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html */
#define MHD_HTTP_HEADER_ACCEPT "Accept"
#define MHD_HTTP_HEADER_ACCEPT_CHARSET "Accept-Charset"
@@ -290,15 +308,21 @@
#define MHD_HTTP_HEADER_WARNING "Warning"
#define MHD_HTTP_HEADER_WWW_AUTHENTICATE "WWW-Authenticate"
+/** @} */ /* end of group headers */
+
/**
- * HTTP versions (used to match against the first line of the
+ * @defgroup versions HTTP versions (used to match against the first line of
the
* HTTP header as well as in the response code).
+ * @{
*/
#define MHD_HTTP_VERSION_1_0 "HTTP/1.0"
#define MHD_HTTP_VERSION_1_1 "HTTP/1.1"
+/** @} */ /* end of group versions */
+
/**
- * HTTP methods
+ * @defgroup methods HTTP methods
+ * @{
*/
#define MHD_HTTP_METHOD_CONNECT "CONNECT"
#define MHD_HTTP_METHOD_DELETE "DELETE"
@@ -309,18 +333,23 @@
#define MHD_HTTP_METHOD_PUT "PUT"
#define MHD_HTTP_METHOD_TRACE "TRACE"
+/** @} */ /* end of group methods */
+
/**
- * HTTP POST encodings, see also
+ * @defgroup postenc HTTP POST encodings, see also
* http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4
+ * @{
*/
#define MHD_HTTP_POST_ENCODING_FORM_URLENCODED
"application/x-www-form-urlencoded"
#define MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA "multipart/form-data"
+/** @} */ /* end of group postenc */
+
/**
* Options for the MHD daemon. Note that if neither
- * MHD_USE_THREAD_PER_CONNECTION nor MHD_USE_SELECT_INTERNALLY is
+ * #MHD_USE_THREAD_PER_CONNECTION nor #MHD_USE_SELECT_INTERNALLY is
* used, the client wants control over the process and will call the
- * appropriate microhttpd callbacks.<p>
+ * appropriate microhttpd callbacks.
*
* Starting the daemon may also fail if a particular option is not
* implemented or not supported on the target platform (i.e. no
@@ -337,55 +366,63 @@
* Run in debug mode. If this flag is used, the
* library should print error messages and warnings
* to stderr.
+ * @ingroup logging
*/
MHD_USE_DEBUG = 1,
/**
- * Run in https mode.
+ * Run in HTTPS mode.
+ * @ingroup tls
*/
MHD_USE_SSL = 2,
/**
* Run using one thread per connection.
+ * @ingroup event
*/
MHD_USE_THREAD_PER_CONNECTION = 4,
/**
- * Run using an internal thread (or thread pool) doing SELECT.
+ * Run using an internal thread (or thread pool) doing select().
+ * @ingroup event
*/
MHD_USE_SELECT_INTERNALLY = 8,
/**
* Run using the IPv6 protocol (otherwise, MHD will just support
* IPv4). If you want MHD to support IPv4 and IPv6 using a single
- * socket, pass MHD_USE_DUAL_STACK, otherwise, if you only pass
+ * socket, pass #MHD_USE_DUAL_STACK, otherwise, if you only pass
* this option, MHD will try to bind to IPv6-only (resulting in
* no IPv4 support).
+ * @ingroup networking
*/
MHD_USE_IPv6 = 16,
/**
* Be pedantic about the protocol (as opposed to as tolerant as
* possible). Specifically, at the moment, this flag causes MHD to
- * reject http 1.1 connections without a "Host" header. This is
+ * reject HTTP 1.1 connections without a "Host" header. This is
* required by the standard, but of course in violation of the "be
* as liberal as possible in what you accept" norm. It is
* recommended to turn this ON if you are testing clients against
* MHD, and OFF in production.
+ * @ingroup logging
*/
MHD_USE_PEDANTIC_CHECKS = 32,
/**
* Use poll instead of select. This allows sockets with fd >=
* FD_SETSIZE. This option is not compatible with using an
- * 'external' select mode (as there is no API to get the file
+ * 'external' select() mode (as there is no API to get the file
* descriptors for the external select from MHD) and must also not
- * be used in combination with MHD_USE_EPOLL_LINUX_ONLY.
+ * be used in combination with #MHD_USE_EPOLL_LINUX_ONLY.
+ * @ingroup event
*/
MHD_USE_POLL = 64,
/**
- * Run using an internal thread (or thread pool) doing POLL.
+ * Run using an internal thread (or thread pool) doing poll().
+ * @ingroup event
*/
MHD_USE_POLL_INTERNALLY = MHD_USE_SELECT_INTERNALLY | MHD_USE_POLL,
@@ -394,60 +431,67 @@
* This option should ONLY be used on systems that do not have a clock
* and that DO provide other mechanisms for cache control. See also
* RFC 2616, section 14.18 (exception 3).
+ * @ingroup specialized
*/
MHD_SUPPRESS_DATE_NO_CLOCK = 128,
/**
* Run without a listen socket. This option only makes sense if
- * 'MHD_add_connection' is to be used exclusively to connect HTTP
+ * #MHD_add_connection is to be used exclusively to connect HTTP
* clients to the HTTP server. This option is incompatible with
- * using a thread pool; if it is used, 'MHD_OPTION_THREAD_POOL_SIZE'
+ * using a thread pool; if it is used, #MHD_OPTION_THREAD_POOL_SIZE
* is ignored.
+ * @ingroup specialized
*/
MHD_USE_NO_LISTEN_SOCKET = 256,
/**
- * Use 'epoll' instead of 'select' or 'poll' for the event loop.
+ * Use epoll() instead of select() or poll() for the event loop.
* This option is only available on Linux; using the option on
- * non-Linux systems will cause 'MHD_start_daemon' to fail.
+ * non-Linux systems will cause #MHD_start_daemon to fail.
+ * @ingroup event
*/
MHD_USE_EPOLL_LINUX_ONLY = 512,
/**
- * Run using an internal thread (or thread pool) doing EPOLL.
+ * Run using an internal thread (or thread pool) doing epoll().
* This option is only available on Linux; using the option on
- * non-Linux systems will cause 'MHD_start_daemon' to fail.
+ * non-Linux systems will cause #MHD_start_daemon to fail.
+ * @ingroup event
*/
MHD_USE_EPOLL_INTERNALLY_LINUX_ONLY = MHD_USE_SELECT_INTERNALLY |
MHD_USE_EPOLL_LINUX_ONLY,
/**
* Force MHD to use a signal pipe to notify the event loop (of
* threads) of our shutdown. This is required if an appliction uses
- * 'MHD_USE_INTERNAL_SELECT' or 'MHD_USE_THREAD_PER_CONNECTION' and
- * then performs 'MHD_quiesce_daemon' (which eliminates our ability
+ * #MHD_USE_INTERNAL_SELECT or #MHD_USE_THREAD_PER_CONNECTION and
+ * then performs #MHD_quiesce_daemon (which eliminates our ability
* to signal termination via the listen socket). In these modes,
- * 'MHD_quiesce_daemon' will fail if this option was not set. Also,
+ * #MHD_quiesce_daemon will fail if this option was not set. Also,
* use of this option is automatic (as in, you do not even have to
- * specify it), if 'MHD_USE_NO_LISTEN_SOCKET' is specified. In
- * "external" select mode, this option is always simply ignored.
+ * specify it), if #MHD_USE_NO_LISTEN_SOCKET is specified. In
+ * "external" select() mode, this option is always simply ignored.
* On W32 a pair of sockets is used instead of a pipe.
*
* You must also use this option if you use internal select mode
- * or a thread pool in conjunction with 'MHD_add_connection'.
+ * or a thread pool in conjunction with #MHD_add_connection.
+ * @ingroup event
*/
MHD_USE_PIPE_FOR_SHUTDOWN = 1024,
/**
* Use a single socket for IPv4 and IPv6.
+ * @ingroup networking
*/
MHD_USE_DUAL_STACK = MHD_USE_IPv6 | 2048,
/**
- * Enable EPOLL turbo. Disables certain calls to 'shutdown'
+ * Enable epoll() turbo. Disables certain calls to shutdown()
* and enables aggressive non-blocking optimisitc reads.
- * Most effects only happen with MHD_USE_EPOLL_LINUX_ONLY.
- * Enalbed always on W32 as winsock doesn't properly behave
- * with shutdown and this then fixes potential problems.
+ * Most effects only happen with #MHD_USE_EPOLL_LINUX_ONLY.
+ * Enalbed always on W32 as winsock does not properly behave
+ * with shutdown() and this then fixes potential problems.
+ * @ingroup event
*/
MHD_USE_EPOLL_TURBO = 4096
@@ -458,14 +502,15 @@
* Type of a callback function used for logging by MHD.
*
* @param cls closure
- * @param fm format string (printf-style)
- * @param ap arguments to 'fm'
+ * @param fm format string (printf()-style)
+ * @param ap arguments to @a fm
+ * @ingroup logging
*/
typedef void (*MHD_LogCallback)(void *cls, const char *fm, va_list ap);
/**
- * MHD options. Passed in the varargs portion of MHD_start_daemon.
+ * MHD options. Passed in the varargs portion of #MHD_start_daemon.
*/
enum MHD_OPTION
{
@@ -478,16 +523,18 @@
/**
* Maximum memory size per connection (followed by a size_t).
- * Default is 32 kb (MHD_POOL_SIZE_DEFAULT).
+ * Default is 32 kb (#MHD_POOL_SIZE_DEFAULT).
* Values above 128k are unlikely to result in much benefit, as half
* of the memory will be typically used for IO, and TCP buffers are
* unlikely to support window sizes above 64k on most systems.
+ * @ingroup limits
*/
MHD_OPTION_CONNECTION_MEMORY_LIMIT = 1,
/**
* Maximum number of concurrent connections to
* accept (followed by an unsigned int).
+ * @ingroup limits
*/
MHD_OPTION_CONNECTION_LIMIT = 2,
@@ -495,6 +542,7 @@
* After how many seconds of inactivity should a
* connection automatically be timed out? (followed
* by an unsigned int; use zero for no timeout).
+ * @ingroup limits
*/
MHD_OPTION_CONNECTION_TIMEOUT = 3,
@@ -503,12 +551,13 @@
* been completed (this can be used for application-specific clean
* up). Requests that have never been presented to the application
* (via MHD_AccessHandlerCallback) will not result in
- * notifications.<p>
+ * notifications.
*
* This option should be followed by TWO pointers. First a pointer
* to a function of type "MHD_RequestCompletedCallback" and second a
* pointer to a closure to pass to the request completed callback.
* The second pointer maybe NULL.
+ * @ingroup request
*/
MHD_OPTION_NOTIFY_COMPLETED = 4,
@@ -521,13 +570,15 @@
* should be followed by an "unsigned int". The default is
* zero, which means no limit on the number of connections
* from the same IP address.
+ * @ingroup limits
*/
MHD_OPTION_PER_IP_CONNECTION_LIMIT = 5,
/**
* Bind daemon to the supplied sockaddr. this option should be followed by a
- * 'struct sockaddr *'. If 'MHD_USE_IPv6' is specified, the 'struct
sockaddr*'
+ * 'struct sockaddr *'. If #MHD_USE_IPv6 is specified, the 'struct
sockaddr*'
* should point to a 'struct sockaddr_in6', otherwise to a 'struct
sockaddr_in'.
+ * @ingroup networking
*/
MHD_OPTION_SOCK_ADDR = 6,
@@ -539,7 +590,7 @@
* logging. This option should be followed by two arguments, the first
* one must be of the form
* <pre>
- * void * my_logger(void * cls, const char * uri)
+ * void * my_logger(void *cls, const char *uri)
* </pre>
* where the return value will be passed as
* (*con_cls) in calls to the MHD_AccessHandlerCallback
@@ -547,26 +598,29 @@
* value of NULL has no special significance (however,
* note that if you return non-NULL, you can no longer
* rely on the first call to the access handler having
- * NULL == *con_cls on entry;)
+ * `NULL == *con_cls` on entry;)
* "cls" will be set to the second argument following
- * MHD_OPTION_URI_LOG_CALLBACK. Finally, uri will
+ * #MHD_OPTION_URI_LOG_CALLBACK. Finally, uri will
* be the 0-terminated URI of the request.
+ * @ingroup logging
*/
MHD_OPTION_URI_LOG_CALLBACK = 7,
/**
* Memory pointer for the private key (key.pem) to be used by the
* HTTPS daemon. This option should be followed by an
- * "const char*" argument.
- * This should be used in conjunction with 'MHD_OPTION_HTTPS_MEM_CERT'.
+ * "const char *" argument.
+ * This should be used in conjunction with #MHD_OPTION_HTTPS_MEM_CERT.
+ * @ingroup tls
*/
MHD_OPTION_HTTPS_MEM_KEY = 8,
/**
* Memory pointer for the certificate (cert.pem) to be used by the
* HTTPS daemon. This option should be followed by an
- * "const char*" argument.
- * This should be used in conjunction with 'MHD_OPTION_HTTPS_MEM_KEY'.
+ * "const char *" argument.
+ * This should be used in conjunction with #MHD_OPTION_HTTPS_MEM_KEY.
+ * @ingroup tls
*/
MHD_OPTION_HTTPS_MEM_CERT = 9,
@@ -574,12 +628,14 @@
* Daemon credentials type.
* Followed by an argument of type
* "gnutls_credentials_type_t".
+ * @ingroup tls
*/
MHD_OPTION_HTTPS_CRED_TYPE = 10,
/**
- * Memory pointer to a "const char*" specifying the
+ * Memory pointer to a "const char *" specifying the
* cipher algorithm (default: "NORMAL").
+ * @ingroup tls
*/
MHD_OPTION_HTTPS_PRIORITIES = 11,
@@ -588,6 +644,7 @@
* option is used, MHD will not open its own listen socket(s). The
* argument passed must be of type "int" and refer to an
* existing socket that has been bound to a port and is listening.
+ * @ingroup specialized
*/
MHD_OPTION_LISTEN_SOCKET = 12,
@@ -595,14 +652,15 @@
* Use the given function for logging error messages.
* This option must be followed by two arguments; the
* first must be a pointer to a function
- * of type "void fun(void * arg, const char * fmt, va_list ap)"
+ * of type `void fun (void *arg, const char *fmt, va_list ap)`
* (also known as MHD_LogCallback)
- * and the second a pointer "void*" which will
+ * and the second a pointer "void *" which will
* be passed as the "arg" argument to "fun".
* <p>
* Note that MHD will not generate any log messages
* if it was compiled without the "--enable-messages"
* flag being set.
+ * @ingroup logging
*/
MHD_OPTION_EXTERNAL_LOGGER = 13,
@@ -610,16 +668,17 @@
* Number (unsigned int) of threads in thread pool. Enable
* thread pooling by setting this value to to something
* greater than 1. Currently, thread model must be
- * MHD_USE_SELECT_INTERNALLY if thread pooling is enabled
- * (MHD_start_daemon returns NULL for an unsupported thread
+ * #MHD_USE_SELECT_INTERNALLY if thread pooling is enabled
+ * (#MHD_start_daemon returns NULL for an unsupported thread
* model).
+ * @ingroup event
*/
MHD_OPTION_THREAD_POOL_SIZE = 14,
/**
* Additional options given in an array of "struct MHD_OptionItem".
* The array must be terminated with an entry '{MHD_OPTION_END, 0, NULL}'.
- * An example for code using MHD_OPTION_ARRAY is:
+ * An example for code using #MHD_OPTION_ARRAY is:
* <code>
* struct MHD_OptionItem ops[] = {
* { MHD_OPTION_CONNECTION_LIMIT, 100, NULL },
@@ -634,6 +693,7 @@
* second member of the struct MHD_OptionItem is ignored.
* For options that expect two pointer arguments, the first
* argument must be cast to 'intptr_t'.
+ * @ingroup specialized
*/
MHD_OPTION_ARRAY = 15,
@@ -646,14 +706,15 @@
* This option should be followed by two arguments, the first
* one must be of the form
* <pre>
- * size_t my_unescaper(void * cls, struct MHD_Connection *c, char *s)
+ * size_t my_unescaper(void *cls, struct MHD_Connection *c, char *s)
* </pre>
* where the return value must be "strlen(s)" and
* "s" should be updated. Note that the unescape function
* must not lengthen "s" (the result must be shorter than
* the input and still be 0-terminated).
* "cls" will be set to the second argument following
- * MHD_OPTION_UNESCAPE_CALLBACK.
+ * #MHD_OPTION_UNESCAPE_CALLBACK.
+ * @ingroup specialized
*/
MHD_OPTION_UNESCAPE_CALLBACK = 16,
@@ -665,6 +726,7 @@
* Note that the application must ensure that the buffer of the
* second argument remains allocated and unmodified while the
* deamon is running.
+ * @ingroup auth
*/
MHD_OPTION_DIGEST_AUTH_RANDOM = 17,
@@ -672,12 +734,14 @@
* Size of the internal array holding the map of the nonce and
* the nonce counter. This option should be followed by a "unsigend int"
* argument.
+ * @ingroup auth
*/
MHD_OPTION_NONCE_NC_SIZE = 18,
/**
* Desired size of the stack for threads created by MHD. Followed
* by an argument of type 'size_t'. Use 0 for system 'default'.
+ * @ingroup event
*/
MHD_OPTION_THREAD_STACK_SIZE = 19,
@@ -685,24 +749,27 @@
* Memory pointer for the certificate (ca.pem) to be used by the
* HTTPS daemon for client authentification.
* This option should be followed by a "const char*" argument.
+ * @ingroup tls
*/
MHD_OPTION_HTTPS_MEM_TRUST = 20,
/**
* Increment to use for growing the read buffer (followed by a
- * size_t). Must fit within MHD_OPTION_CONNECTION_MEMORY_LIMIT.
+ * size_t). Must fit within #MHD_OPTION_CONNECTION_MEMORY_LIMIT.
+ * @ingroup limits
*/
MHD_OPTION_CONNECTION_MEMORY_INCREMENT = 21
};
/**
- * Entry in an MHD_OPTION_ARRAY.
+ * Entry in an #MHD_OPTION_ARRAY.
+ * @ingroup specialized
*/
struct MHD_OptionItem
{
/**
- * Which option is being given. Use MHD_OPTION_END
+ * Which option is being given. Use #MHD_OPTION_END
* to terminate the array.
*/
enum MHD_OPTION option;
@@ -726,23 +793,27 @@
/**
* The MHD_ValueKind specifies the source of
* the key-value pairs in the HTTP protocol.
+ * @ingroup request
*/
enum MHD_ValueKind
{
/**
* Response header
+ * @ingroup response
*/
MHD_RESPONSE_HEADER_KIND = 0,
/**
* HTTP header.
+ * @ingroup request
*/
MHD_HEADER_KIND = 1,
/**
* Cookies. Note that the original HTTP header containing
* the cookie(s) will still be available and intact.
+ * @ingroup request
*/
MHD_COOKIE_KIND = 2,
@@ -753,16 +824,19 @@
* memory pool. Note that in that case, the upload data
* given to the MHD_AccessHandlerCallback will be
* empty (since it has already been processed).
+ * @ingroup request
*/
MHD_POSTDATA_KIND = 4,
/**
* GET (URI) arguments.
+ * @ingroup request
*/
MHD_GET_ARGUMENT_KIND = 8,
/**
* HTTP footer (only for http 1.1 chunked encodings).
+ * @ingroup request
*/
MHD_FOOTER_KIND = 16
};
@@ -771,12 +845,14 @@
/**
* The MHD_RequestTerminationCode specifies reasons
* why a request has been terminated (or completed).
+ * @ingroup request
*/
enum MHD_RequestTerminationCode
{
/**
* We finished sending the response.
+ * @ingroup request
*/
MHD_REQUEST_TERMINATED_COMPLETED_OK = 0,
@@ -784,28 +860,32 @@
* Error handling the connection (resources
* exhausted, other side closed connection,
* application error accepting request, etc.)
+ * @ingroup request
*/
MHD_REQUEST_TERMINATED_WITH_ERROR = 1,
/**
* No activity on the connection for the number
* of seconds specified using
- * MHD_OPTION_CONNECTION_TIMEOUT.
+ * #MHD_OPTION_CONNECTION_TIMEOUT.
+ * @ingroup request
*/
MHD_REQUEST_TERMINATED_TIMEOUT_REACHED = 2,
/**
* We had to close the session since MHD was being
* shut down.
+ * @ingroup request
*/
MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN = 3,
/**
* We tried to read additional data, but the other side closed the
* connection. This error is similar to
- * MHD_REQUEST_TERMINATED_WITH_ERROR, but specific to the case where
+ * #MHD_REQUEST_TERMINATED_WITH_ERROR, but specific to the case where
* the connection died because the other side did not send expected
* data.
+ * @ingroup request
*/
MHD_REQUEST_TERMINATED_READ_ERROR = 4
@@ -815,18 +895,21 @@
/**
* Values of this enum are used to specify what
* information about a connection is desired.
+ * @ingroup request
*/
enum MHD_ConnectionInfoType
{
/**
* What cipher algorithm is being used.
* Takes no extra arguments.
+ * @ingroup request
*/
MHD_CONNECTION_INFO_CIPHER_ALGO,
/**
*
* Takes no extra arguments.
+ * @ingroup request
*/
MHD_CONNECTION_INFO_PROTOCOL,
@@ -835,16 +918,18 @@
* Returns essentially a "struct sockaddr **" (since the API returns
* a "union MHD_ConnectionInfo *" and that union contains a "struct
* sockaddr *").
+ * @ingroup request
*/
MHD_CONNECTION_INFO_CLIENT_ADDRESS,
/**
- * Get the GNUTLS session handle.
+ * Get the gnuTLS session handle.
+ * @ingroup request
*/
MHD_CONNECTION_INFO_GNUTLS_SESSION,
/**
- * Get the GNUTLS client certificate handle. Dysfunctional (never
+ * Get the gnuTLS client certificate handle. Dysfunctional (never
* implemented, deprecated). Use MHD_CONNECTION_INFO_GNUTLS_SESSION
* to get the gnutls_session_t and then call
* gnutls_certificate_get_peers().
@@ -853,13 +938,14 @@
/**
* Get the 'struct MHD_Daemon' responsible for managing this connection.
+ * @ingroup request
*/
MHD_CONNECTION_INFO_DAEMON,
-
/**
* Request the file descriptor for the listening socket.
* No extra arguments should be passed.
+ * @ingroup request
*/
MHD_CONNECTION_INFO_CONNECTION_FD
@@ -893,12 +979,14 @@
/**
* Request the file descriptor for the listening socket.
* No extra arguments should be passed.
+ * @ingroup networking
*/
MHD_DAEMON_INFO_LISTEN_FD,
/**
* Request the file descriptor for the external epoll.
* No extra arguments should be passed.
+ * @ingroup event
*/
MHD_DAEMON_INFO_EPOLL_FD_LINUX_ONLY
};
@@ -906,6 +994,7 @@
/**
* Handle for the daemon (listening on a socket for HTTP traffic).
+ * @ingroup event
*/
struct MHD_Daemon;
@@ -914,16 +1003,19 @@
* requests can be run over the same connection. However, MHD will
* only show one request per TCP connection to the client at any given
* time.
+ * @ingroup request
*/
struct MHD_Connection;
/**
* Handle for a response.
+ * @ingroup response
*/
struct MHD_Response;
/**
* Handle for POST processing.
+ * @ingroup response
*/
struct MHD_PostProcessor;
@@ -936,6 +1028,7 @@
* @param file where the error occured
* @param line where the error occured
* @param reason error detail, may be NULL
+ * @ingroup logging
*/
typedef
void (*MHD_PanicCallback) (void *cls,
@@ -947,8 +1040,8 @@
* Allow or deny a client to connect.
*
* @param addr address information from the client
- * @param addrlen length of the address information
- * @return MHD_YES if connection is allowed, MHD_NO if not
+ * @param addrlen length of @a addr
+ * @return #MHD_YES if connection is allowed, #MHD_NO if not
*/
typedef int
(*MHD_AcceptPolicyCallback) (void *cls,
@@ -973,9 +1066,9 @@
* given in upload_data and is instead available as
* part of MHD_get_connection_values; very large POST
* data *will* be made available incrementally in
- * upload_data)
+ * @a upload_data)
* @param upload_data_size set initially to the size of the
- * upload_data provided; the method must update this
+ * @a upload_data provided; the method must update this
* value to the number of bytes NOT processed;
* @param con_cls pointer that the callback can set to some
* address and that will be preserved by MHD for future
@@ -985,15 +1078,15 @@
* to easily associate some request-specific state.
* If necessary, this state can be cleaned up in the
* global "MHD_RequestCompleted" callback (which
- * can be set with the MHD_OPTION_NOTIFY_COMPLETED).
+ * can be set with the #MHD_OPTION_NOTIFY_COMPLETED).
* Initially, <tt>*con_cls</tt> will be NULL.
- * @return MHS_YES if the connection was handled successfully,
- * MHS_NO if the socket must be closed due to a serios
+ * @return #MHS_YES if the connection was handled successfully,
+ * #MHS_NO if the socket must be closed due to a serios
* error while handling the request
*/
typedef int
(*MHD_AccessHandlerCallback) (void *cls,
- struct MHD_Connection * connection,
+ struct MHD_Connection *connection,
const char *url,
const char *method,
const char *version,
@@ -1011,7 +1104,8 @@
* @param con_cls value as set by the last call to
* the MHD_AccessHandlerCallback
* @param toe reason for request termination
- * @see MHD_OPTION_NOTIFY_COMPLETED
+ * @see #MHD_OPTION_NOTIFY_COMPLETED
+ * @ingroup request
*/
typedef void
(*MHD_RequestCompletedCallback) (void *cls,
@@ -1027,8 +1121,9 @@
* also to iterate over the headers that have been
* added to a response.
*
- * @return MHD_YES to continue iterating,
- * MHD_NO to abort the iteration
+ * @return #MHD_YES to continue iterating,
+ * #MHD_NO to abort the iteration
+ * @ingroup request
*/
typedef int
(*MHD_KeyValueIterator) (void *cls,
@@ -1038,14 +1133,14 @@
/**
* Callback used by libmicrohttpd in order to obtain content. The
- * callback is to copy at most "max" bytes of content into "buf". The
- * total number of bytes that has been placed into "buf" should be
+ * callback is to copy at most @a max bytes of content into @a buf. The
+ * total number of bytes that has been placed into @a buf should be
* returned.<p>
*
* Note that returning zero will cause libmicrohttpd to try again,
* either "immediately" if in multi-threaded mode (in which case the
* callback may want to do blocking operations) or in the next round
- * if MHD_run is used. Returning 0 for a daemon that runs in internal
+ * if #MHD_run is used. Returning 0 for a daemon that runs in internal
* select mode is an error (since it would result in busy waiting) and
* will cause the program to be aborted (abort()).
*
@@ -1059,28 +1154,28 @@
* the sum of all non-negative return values
* obtained from the content reader so far.
* @param buf where to copy the data
- * @param max maximum number of bytes to copy to buf (size of buf)
- * @return number of bytes written to 'buf';
+ * @param max maximum number of bytes to copy to @a buf (size of @a buf)
+ * @return number of bytes written to @a buf;
* 0 is legal unless we are running in internal select mode (since
* this would cause busy-waiting); 0 in external select mode
* will cause this function to be called again once the external
* select calls MHD again;
- * MHD_CONTENT_READER_END_OF_STREAM (-1) for the regular
+ * #MHD_CONTENT_READER_END_OF_STREAM (-1) for the regular
* end of transmission (with chunked encoding, MHD will then
* terminate the chunk and send any HTTP footers that might be
* present; without chunked encoding and given an unknown
* response size, MHD will simply close the connection; note
- * that while returning END_OF_STREAM is not technically
+ * that while returning #MHD_CONTENT_READER_END_OF_STREAM is not technically
* legal if a response size was specified, MHD accepts this
- * and treats it just as MHD_CONTENT_READER_END_WITH_ERROR;
- * MHD_CONTENT_READER_END_WITH_ERROR (-2) to indicate a server
+ * and treats it just as #MHD_CONTENT_READER_END_WITH_ERROR;
+ * #MHD_CONTENT_READER_END_WITH_ERROR (-2) to indicate a server
* error generating the response; this will cause MHD to simply
* close the connection immediately. If a response size was
* given or if chunked encoding is in use, this will indicate
* an error to the client. Note, however, that if the client
* does not know a response size and chunked encoding is not in
* use, then clients will not be able to tell the difference between
- * MHD_CONTENT_READER_END_WITH_ERROR and MHD_CONTENT_READER_END_OF_STREAM.
+ * #MHD_CONTENT_READER_END_WITH_ERROR and #MHD_CONTENT_READER_END_OF_STREAM.
* This is not a limitation of MHD but rather of the HTTP protocol.
*/
typedef ssize_t
@@ -1095,6 +1190,9 @@
* are done with a content reader. It should
* be used to free resources associated with the
* content reader.
+ *
+ * @param cls closure
+ * @ingroup response
*/
typedef void
(*MHD_ContentReaderFreeCallback) (void *cls);
@@ -1107,17 +1205,17 @@
* POST data.
*
* @param cls user-specified closure
- * @param kind type of the value, always MHD_POSTDATA_KIND when called from MHD
+ * @param kind type of the value, always #MHD_POSTDATA_KIND when called from
MHD
* @param key 0-terminated key for the value
* @param filename name of the uploaded file, NULL if not known
* @param content_type mime-type of the data, NULL if not known
* @param transfer_encoding encoding of the data, NULL if not known
- * @param data pointer to size bytes of data at the
+ * @param data pointer to @a size bytes of data at the
* specified offset
* @param off offset of data in the overall value
- * @param size number of bytes in data available
- * @return MHD_YES to continue iterating,
- * MHD_NO to abort the iteration
+ * @param size number of bytes in @a data available
+ * @return #MHD_YES to continue iterating,
+ * #MHD_NO to abort the iteration
*/
typedef int
(*MHD_PostDataIterator) (void *cls,
@@ -1143,10 +1241,11 @@
* accepted
* @param apc_cls extra argument to apc
* @param dh handler called for all requests (repeatedly)
- * @param dh_cls extra argument to dh
+ * @param dh_cls extra argument to @a dh
* @param ap list of options (type-value pairs,
- * terminated with MHD_OPTION_END).
+ * terminated with #MHD_OPTION_END).
* @return NULL on error, handle to daemon on success
+ * @ingroup event
*/
struct MHD_Daemon *
MHD_start_daemon_va (unsigned int flags,
@@ -1158,7 +1257,7 @@
/**
* Start a webserver on the given port. Variadic version of
- * MHD_start_daemon_va.
+ * #MHD_start_daemon_va.
*
* @param flags combination of MHD_FLAG values
* @param port port to bind to
@@ -1168,8 +1267,9 @@
* accepted
* @param apc_cls extra argument to apc
* @param dh handler called for all requests (repeatedly)
- * @param dh_cls extra argument to dh
+ * @param dh_cls extra argument to @a dh
* @return NULL on error, handle to daemon on success
+ * @ingroup event
*/
struct MHD_Daemon *
MHD_start_daemon (unsigned int flags,
@@ -1185,17 +1285,18 @@
* connections. Note that the caller is responsible for closing the
* returned socket; however, if MHD is run using threads (anything but
* external select mode), it must not be closed until AFTER
- * "MHD_stop_daemon" has been called (as it is theoretically possible
+ * #MHD_stop_daemon has been called (as it is theoretically possible
* that an existing thread is still using it).
*
* Note that some thread modes require the caller to have passed
- * MHD_USE_PIPE_FOR_SHUTDOWN when using this API. If this daemon is
+ * #MHD_USE_PIPE_FOR_SHUTDOWN when using this API. If this daemon is
* in one of those modes and this option was not given to
- * 'MHD_start_daemon', this function will return -1.
+ * #MHD_start_daemon, this function will return -1.
*
* @param daemon daemon to stop accepting new connections for
* @return old listen socket on success, -1 if the daemon was
* already not listening anymore
+ * @ingroup specialized
*/
int
MHD_quiesce_daemon (struct MHD_Daemon *daemon);
@@ -1205,6 +1306,7 @@
* Shutdown an http daemon.
*
* @param daemon daemon to stop
+ * @ingroup event
*/
void
MHD_stop_daemon (struct MHD_Daemon *daemon);
@@ -1219,7 +1321,7 @@
*
* If you use this API in conjunction with a internal select or a
* thread pool, you must set the option
- * @code{MHD_USE_PIPE_FOR_SHUTDOWN} to ensure that the freshly added
+ * #MHD_USE_PIPE_FOR_SHUTDOWN to ensure that the freshly added
* connection is immediately processed by MHD.
*
* The given client socket will be managed (and closed!) by MHD after
@@ -1230,11 +1332,12 @@
* @param client_socket socket to manage (MHD will expect
* to receive an HTTP request from this socket next).
* @param addr IP address of the client
- * @param addrlen number of bytes in addr
- * @return MHD_YES on success, MHD_NO if this daemon could
- * not handle the connection (i.e. malloc failed, etc).
- * The socket will be closed in any case; 'errno' is
+ * @param addrlen number of bytes in @a addr
+ * @return #MHD_YES on success, #MHD_NO if this daemon could
+ * not handle the connection (i.e. malloc() failed, etc).
+ * The socket will be closed in any case; @code{errno} is
* set to indicate further details about the error.
+ * @ingroup specialized
*/
int
MHD_add_connection (struct MHD_Daemon *daemon,
@@ -1252,9 +1355,10 @@
* @param except_fd_set except set
* @param max_fd increased to largest FD added (if larger
* than existing value); can be NULL
- * @return MHD_YES on success, MHD_NO if this
+ * @return #MHD_YES on success, #MHD_NO if this
* daemon was not started with the right
* options for this call.
+ * @ingroup event
*/
int
MHD_get_fdset (struct MHD_Daemon *daemon,
@@ -1265,40 +1369,41 @@
/**
- * Obtain timeout value for select for this daemon (only needed if
- * connection timeout is used). The returned value is how long select
- * should at most block, not the timeout value set for connections.
- * This function MUST NOT be called if MHD is running with
- * "MHD_USE_THREAD_PER_CONNECTION".
+ * Obtain timeout value for select() for this daemon (only needed if
+ * connection timeout is used). The returned value is how long
+ * select() or poll() should at most block, not the timeout value set
+ * for connections. This function MUST NOT be called if MHD is
+ * running with #MHD_USE_THREAD_PER_CONNECTION.
*
* @param daemon daemon to query for timeout
* @param timeout set to the timeout (in milliseconds)
- * @return MHD_YES on success, MHD_NO if timeouts are
+ * @return #MHD_YES on success, #MHD_NO if timeouts are
* not used (or no connections exist that would
* necessiate the use of a timeout right now).
+ * @ingroup event
*/
int MHD_get_timeout (struct MHD_Daemon *daemon,
MHD_UNSIGNED_LONG_LONG *timeout);
/**
- * Run webserver operations (without blocking unless
- * in client callbacks). This method should be called
- * by clients in combination with MHD_get_fdset
- * if the client-controlled select method is used.
+ * Run webserver operations (without blocking unless in client
+ * callbacks). This method should be called by clients in combination
+ * with #MHD_get_fdset if the client-controlled select method is used.
*
* This function is a convenience method, which is useful if the
- * fd_sets from "MHD_get_fdset" were not directly passed to 'select';
- * with this function, MHD will internally do the appropriate 'select'
- * call itself again. While it is always safe to call 'MHD_run' (in
- * external select mode), you should call 'MHD_run_from_select' if
+ * fd_sets from #MHD_get_fdset were not directly passed to select();
+ * with this function, MHD will internally do the appropriate select()
+ * call itself again. While it is always safe to call #MHD_run (in
+ * external select mode), you should call #MHD_run_from_select if
* performance is important (as it saves an expensive call to
- * 'select').
+ * select()).
*
* @param daemon daemon to run
- * @return MHD_YES on success, MHD_NO if this
+ * @return #MHD_YES on success, #MHD_NO if this
* daemon was not started with the right
* options for this call.
+ * @ingroup event
*/
int
MHD_run (struct MHD_Daemon *daemon);
@@ -1306,21 +1411,21 @@
/**
* Run webserver operations. This method should be called by clients
- * in combination with MHD_get_fdset if the client-controlled select
+ * in combination with #MHD_get_fdset if the client-controlled select
* method is used.
*
- * You can use this function instead of "MHD_run" if you called
- * 'select' on the result from "MHD_get_fdset". File descriptors in
+ * You can use this function instead of #MHD_run if you called
+ * select() on the result from #MHD_get_fdset. File descriptors in
* the sets that are not controlled by MHD will be ignored. Calling
- * this function instead of "MHD_run" is more efficient as MHD will
- * not have to call 'select' again to determine which operations are
+ * this function instead of #MHD_run is more efficient as MHD will
+ * not have to call select() again to determine which operations are
* ready.
*
* @param daemon daemon to run select loop for
* @param read_fd_set read set
* @param write_fd_set write set
* @param except_fd_set except set (not used, can be NULL)
- * @return MHD_NO on serious errors, MHD_YES on success
+ * @return #MHD_NO on serious errors, #MHD_YES on success
*/
int
MHD_run_from_select (struct MHD_Daemon *daemon,
@@ -1340,8 +1445,9 @@
* @param kind types of values to iterate over
* @param iterator callback to call on each header;
* maybe NULL (then just count headers)
- * @param iterator_cls extra argument to iterator
+ * @param iterator_cls extra argument to @a iterator
* @return number of entries iterated over
+ * @ingroup request
*/
int
MHD_get_connection_values (struct MHD_Connection *connection,
@@ -1350,33 +1456,29 @@
/**
- * This function can be used to add an entry to
- * the HTTP headers of a connection (so that the
- * MHD_get_connection_values function will return
- * them -- and the MHD PostProcessor will also
- * see them). This maybe required in certain
- * situations (see Mantis #1399) where (broken)
- * HTTP implementations fail to supply values needed
- * by the post processor (or other parts of the
- * application).
- * <p>
- * This function MUST only be called from within
- * the MHD_AccessHandlerCallback (otherwise, access
- * maybe improperly synchronized). Furthermore,
- * the client must guarantee that the key and
- * value arguments are 0-terminated strings that
- * are NOT freed until the connection is closed.
- * (The easiest way to do this is by passing only
- * arguments to permanently allocated strings.).
+ * This function can be used to add an entry to the HTTP headers of a
+ * connection (so that the #MHD_get_connection_values function will
+ * return them -- and the MHD PostProcessor will also see them). This
+ * maybe required in certain situations (see Mantis #1399) where
+ * (broken) HTTP implementations fail to supply values needed by the
+ * post processor (or other parts of the application).
+ *
+ * This function MUST only be called from within the
+ * MHD_AccessHandlerCallback (otherwise, access maybe improperly
+ * synchronized). Furthermore, the client must guarantee that the key
+ * and value arguments are 0-terminated strings that are NOT freed
+ * until the connection is closed. (The easiest way to do this is by
+ * passing only arguments to permanently allocated strings.).
*
* @param connection the connection for which a
* value should be set
* @param kind kind of the value
* @param key key for the value
* @param value the value itself
- * @return MHD_NO if the operation could not be
+ * @return #MHD_NO if the operation could not be
* performed due to insufficient memory;
- * MHD_YES on success
+ * #MHD_YES on success
+ * @ingroup request
*/
int
MHD_set_connection_value (struct MHD_Connection *connection,
@@ -1386,19 +1488,20 @@
/**
- * Sets the global error handler to a different implementation. "cb"
+ * Sets the global error handler to a different implementation. @a cb
* will only be called in the case of typically fatal, serious
* internal consistency issues. These issues should only arise in the
* case of serious memory corruption or similar problems with the
- * architecture. While "cb" is allowed to return and MHD will then
+ * architecture. While @a cb is allowed to return and MHD will then
* try to continue, this is never safe.
*
* The default implementation that is used if no panic function is set
- * simply prints an error message and calls "abort". Alternative
- * implementations might call "exit" or other similar functions.
+ * simply prints an error message and calls abort(). Alternative
+ * implementations might call exit() or other similar functions.
*
* @param cb new error handler
- * @param cls passed to error handler
+ * @param cls passed to @a cb
+ * @ingroup logging
*/
void
MHD_set_panic_func (MHD_PanicCallback cb, void *cls);
@@ -1412,6 +1515,7 @@
* @param kind what kind of value are we looking for
* @param key the header to look for, NULL to lookup 'trailing' value without
a key
* @return NULL if no such item was found
+ * @ingroup request
*/
const char *
MHD_lookup_connection_value (struct MHD_Connection *connection,
@@ -1426,8 +1530,9 @@
* @param connection the connection identifying the client
* @param status_code HTTP status code (i.e. 200 for OK)
* @param response response to transmit
- * @return MHD_NO on error (i.e. reply already sent),
- * MHD_YES on success or if message has been queued
+ * @return #MHD_NO on error (i.e. reply already sent),
+ * #MHD_YES on success or if message has been queued
+ * @ingroup response
*/
int
MHD_queue_response (struct MHD_Connection *connection,
@@ -1441,16 +1546,17 @@
* Create a response object. The response object can be extended with
* header information and then be used any number of times.
*
- * @param size size of the data portion of the response, MHD_SIZE_UNKNOWN for
unknown
+ * @param size size of the data portion of the response, #MHD_SIZE_UNKNOWN for
unknown
* @param block_size preferred block size for querying crc (advisory only,
- * MHD may still call crc using smaller chunks); this
+ * MHD may still call @a crc using smaller chunks); this
* is essentially the buffer size used for IO, clients
* should pick a value that is appropriate for IO and
* memory performance requirements
* @param crc callback to use to obtain response data
- * @param crc_cls extra argument to crc
- * @param crfc callback to call to free crc_cls resources
+ * @param crc_cls extra argument to @a crc
+ * @param crfc callback to call to free @a crc_cls resources
* @return NULL on error (i.e. invalid arguments, out of memory)
+ * @ingroup response
*/
struct MHD_Response *
MHD_create_response_from_callback (uint64_t size,
@@ -1463,14 +1569,15 @@
* Create a response object. The response object can be extended with
* header information and then be used any number of times.
*
- * @param size size of the data portion of the response
+ * @param size size of the @a data portion of the response
* @param data the data itself
* @param must_free libmicrohttpd should free data when done
- * @param must_copy libmicrohttpd must make a copy of data
+ * @param must_copy libmicrohttpd must make a copy of @a data
* right away, the data maybe released anytime after
* this call returns
* @return NULL on error (i.e. invalid arguments, out of memory)
- * @deprecated use MHD_create_response_from_buffer instead
+ * @deprecated use #MHD_create_response_from_buffer instead
+ * @ingroup response
*/
struct MHD_Response *
MHD_create_response_from_data (size_t size,
@@ -1482,28 +1589,33 @@
/**
* Specification for how MHD should treat the memory buffer
* given for the response.
+ * @ingroup response
*/
-enum MHD_ResponseMemoryMode {
+enum MHD_ResponseMemoryMode
+{
/**
* Buffer is a persistent (static/global) buffer that won't change
* for at least the lifetime of the response, MHD should just use
* it, not free it, not copy it, just keep an alias to it.
+ * @ingroup response
*/
MHD_RESPMEM_PERSISTENT,
/**
- * Buffer is heap-allocated with 'malloc' (or equivalent) and
+ * Buffer is heap-allocated with malloc() (or equivalent) and
* should be freed by MHD after processing the response has
* concluded (response reference counter reaches zero).
+ * @ingroup response
*/
MHD_RESPMEM_MUST_FREE,
/**
* Buffer is in transient memory, but not on the heap (for example,
* on the stack or non-malloc allocated) and only valid during the
- * call to 'MHD_create_response_from_buffer'. MHD must make its
+ * call to #MHD_create_response_from_buffer. MHD must make its
* own private copy of the data for processing.
+ * @ingroup response
*/
MHD_RESPMEM_MUST_COPY
@@ -1518,6 +1630,7 @@
* @param buffer size bytes containing the response's data portion
* @param mode flags for buffer management
* @return NULL on error (i.e. invalid arguments, out of memory)
+ * @ingroup response
*/
struct MHD_Response *
MHD_create_response_from_buffer (size_t size,
@@ -1534,6 +1647,7 @@
* data; will be closed when response is destroyed;
* fd should be in 'blocking' mode
* @return NULL on error (i.e. invalid arguments, out of memory)
+ * @ingroup response
*/
struct MHD_Response *
MHD_create_response_from_fd (size_t size,
@@ -1554,6 +1668,7 @@
* also has to be compiled using the same options! Read
* the MHD manual for more details.
* @return NULL on error (i.e. invalid arguments, out of memory)
+ * @ingroup response
*/
struct MHD_Response *
MHD_create_response_from_fd_at_offset (size_t size,
@@ -1702,8 +1817,10 @@
* necessarily be freed immediatley.
*
* @param response response to destroy
+ * @ingroup response
*/
-void MHD_destroy_response (struct MHD_Response *response);
+void
+MHD_destroy_response (struct MHD_Response *response);
/**
@@ -1712,8 +1829,9 @@
* @param response response to add a header to
* @param header the header to add
* @param content value to add
- * @return MHD_NO on error (i.e. invalid header or content format),
+ * @return #MHD_NO on error (i.e. invalid header or content format),
* or out of memory
+ * @ingroup response
*/
int
MHD_add_response_header (struct MHD_Response *response,
@@ -1726,7 +1844,8 @@
* @param response response to remove a header from
* @param footer the footer to delete
* @param content value to delete
- * @return MHD_NO on error (i.e. invalid footer or content format).
+ * @return #MHD_NO on error (i.e. invalid footer or content format).
+ * @ingroup response
*/
int
MHD_add_response_footer (struct MHD_Response *response,
@@ -1739,7 +1858,8 @@
* @param response response to remove a header from
* @param header the header to delete
* @param content value to delete
- * @return MHD_NO on error (no such header known)
+ * @return #MHD_NO on error (no such header known)
+ * @ingroup response
*/
int
MHD_del_response_header (struct MHD_Response *response,
@@ -1752,8 +1872,9 @@
* @param response response to query
* @param iterator callback to call on each header;
* maybe NULL (then just count headers)
- * @param iterator_cls extra argument to iterator
+ * @param iterator_cls extra argument to @a iterator
* @return number of entries iterated over
+ * @ingroup response
*/
int
MHD_get_response_headers (struct MHD_Response *response,
@@ -1766,9 +1887,11 @@
* @param response response to query
* @param key which header to get
* @return NULL if header does not exist
+ * @ingroup response
*/
-const char *MHD_get_response_header (struct MHD_Response *response,
- const char *key);
+const char *
+MHD_get_response_header (struct MHD_Response *response,
+ const char *key);
/* ********************** PostProcessor functions ********************** */
@@ -1779,7 +1902,7 @@
* A PostProcessor can be used to (incrementally) parse the data
* portion of a POST request. Note that some buggy browsers fail to
* set the encoding type. If you want to support those, you may have
- * to call 'MHD_set_connection_value' with the proper encoding type
+ * to call #MHD_set_connection_value with the proper encoding type
* before creating a post processor (if no supported encoding type is
* set, this function will fail).
*
@@ -1793,41 +1916,44 @@
* performance, use 32 or 64k (i.e. 65536).
* @param iter iterator to be called with the parsed data,
* Must NOT be NULL.
- * @param iter_cls first argument to iter
- * @return NULL on error (out of memory, unsupported encoding),
- * otherwise a PP handle
+ * @param iter_cls first argument to @a iter
+ * @return NULL on error (out of memory, unsupported encoding),
+ * otherwise a PP handle
+ * @ingroup request
*/
struct MHD_PostProcessor *
MHD_create_post_processor (struct MHD_Connection *connection,
size_t buffer_size,
MHD_PostDataIterator iter, void *iter_cls);
+
/**
- * Parse and process POST data.
- * Call this function when POST data is available
- * (usually during an MHD_AccessHandlerCallback)
- * with the upload_data and upload_data_size.
- * Whenever possible, this will then cause calls
- * to the MHD_IncrementalKeyValueIterator.
+ * Parse and process POST data. Call this function when POST data is
+ * available (usually during an MHD_AccessHandlerCallback) with the
+ * upload_data and upload_data_size. Whenever possible, this will
+ * then cause calls to the MHD_IncrementalKeyValueIterator.
*
* @param pp the post processor
- * @param post_data post_data_len bytes of POST data
- * @param post_data_len length of post_data
- * @return MHD_YES on success, MHD_NO on error
+ * @param post_data @a post_data_len bytes of POST data
+ * @param post_data_len length of @a post_data
+ * @return #MHD_YES on success, #MHD_NO on error
* (out-of-memory, iterator aborted, parse error)
+ * @ingroup request
*/
int
MHD_post_process (struct MHD_PostProcessor *pp,
const char *post_data, size_t post_data_len);
+
/**
* Release PostProcessor resources.
*
* @param pp the PostProcessor to destroy
- * @return MHD_YES if processing completed nicely,
- * MHD_NO if there were spurious characters / formatting
+ * @return #MHD_YES if processing completed nicely,
+ * #MHD_NO if there were spurious characters / formatting
* problems; it is common to ignore the return
* value of this function
+ * @ingroup request
*/
int
MHD_destroy_post_processor (struct MHD_PostProcessor *pp);
@@ -1839,6 +1965,7 @@
/**
* Constant to indicate that the nonce of the provided
* authentication code was wrong.
+ * @ingroup authentication
*/
#define MHD_INVALID_NONCE -1
@@ -1849,6 +1976,7 @@
* @param connection The MHD connection structure
* @return NULL if no username could be found, a pointer
* to the username if found
+ * @ingroup authentication
*/
char *
MHD_digest_auth_get_username (struct MHD_Connection *connection);
@@ -1863,8 +1991,9 @@
* @param password The password used in the authentication
* @param nonce_timeout The amount of time for a nonce to be
* invalid in seconds
- * @return MHD_YES if authenticated, MHD_NO if not,
- * MHD_INVALID_NONCE if nonce is invalid
+ * @return #MHD_YES if authenticated, #MHD_NO if not,
+ * #MHD_INVALID_NONCE if nonce is invalid
+ * @ingroup authentication
*/
int
MHD_digest_auth_check (struct MHD_Connection *connection,
@@ -1883,9 +2012,10 @@
* @param response reply to send; should contain the "access denied"
* body; note that this function will set the "WWW Authenticate"
* header and that the caller should not do this
- * @param signal_stale MHD_YES if the nonce is invalid to add
+ * @param signal_stale #MHD_YES if the nonce is invalid to add
* 'stale=true' to the authentication header
- * @return MHD_YES on success, MHD_NO otherwise
+ * @return #MHD_YES on success, #MHD_NO otherwise
+ * @ingroup authentication
*/
int
MHD_queue_auth_fail_response (struct MHD_Connection *connection,
@@ -1902,6 +2032,7 @@
* @param password a pointer for the password
* @return NULL if no username could be found, a pointer
* to the username if found
+ * @ingroup authentication
*/
char *
MHD_basic_auth_get_username_password (struct MHD_Connection *connection,
@@ -1916,7 +2047,8 @@
* @param connection The MHD connection structure
* @param realm the realm presented to the client
* @param response response object to modify and queue
- * @return MHD_YES on success, MHD_NO otherwise
+ * @return #MHD_YES on success, #MHD_NO otherwise
+ * @ingroup authentication
*/
int
MHD_queue_basic_auth_fail_response (struct MHD_Connection *connection,
@@ -1933,41 +2065,49 @@
/**
* Cipher algorithm used, of type "enum gnutls_cipher_algorithm".
+ * @ingroup tls
*/
int /* enum gnutls_cipher_algorithm */ cipher_algorithm;
/**
* Protocol used, of type "enum gnutls_protocol".
+ * @ingroup tls
*/
int /* enum gnutls_protocol */ protocol;
/**
* Connect socket
+ * @ingroup networking
*/
int connect_fd;
/**
* GNUtls session handle, of type "gnutls_session_t".
+ * @ingroup tls
*/
void * /* gnutls_session_t */ tls_session;
/**
* GNUtls client certificate handle, of type "gnutls_x509_crt_t".
+ * @ingroup tls
*/
void * /* gnutls_x509_crt_t */ client_cert;
/**
* Address information for the client.
+ * @ingroup networking
*/
struct sockaddr *client_addr;
/**
* Which daemon manages this connection (useful in case there are many
* daemons running).
+ * @ingroup specialized
*/
struct MHD_Daemon *daemon;
};
+
/**
* Obtain information about the given connection.
*
@@ -1976,6 +2116,7 @@
* @param ... depends on infoType
* @return NULL if this information is not available
* (or if the infoType is unknown)
+ * @ingroup specialized
*/
const union MHD_ConnectionInfo *
MHD_get_connection_info (struct MHD_Connection *connection,
@@ -1984,8 +2125,9 @@
/**
- * MHD connection options. Given to 'MHD_set_connection_option' to
+ * MHD connection options. Given to #MHD_set_connection_option to
* set custom options for a particular connection.
+ * @ingroup specialized
*/
enum MHD_CONNECTION_OPTION
{
@@ -1994,6 +2136,7 @@
* Set a custom timeout for the given connection. Specified
* as the number of seconds, given as an 'unsigned int'. Use
* zero for no timeout.
+ * @ingroup limits
*/
MHD_CONNECTION_OPTION_TIMEOUT
@@ -2006,7 +2149,8 @@
* @param connection connection to modify
* @param option option to set
* @param ... arguments to the option, depending on the option type
- * @return MHD_YES on success, MHD_NO if setting the option failed
+ * @return #MHD_YES on success, #MHD_NO if setting the option failed
+ * @ingroup specialized
*/
int
MHD_set_connection_option (struct MHD_Connection *connection,
@@ -2016,25 +2160,30 @@
/**
* Information about an MHD daemon.
+ * @ingroup specialized
*/
union MHD_DaemonInfo
{
/**
* Size of the key (unit??)
+ * @ingroup tls
*/
size_t key_size;
/**
* Size of the mac key (unit??)
+ * @ingroup tls
*/
size_t mac_key_size;
/**
* Listen socket file descriptor
+ * @ingroup networking
*/
int listen_fd;
};
+
/**
* Obtain information about the given daemon
* (not fully implemented!).
@@ -2044,6 +2193,7 @@
* @param ... depends on infoType
* @return NULL if this information is not available
* (or if the infoType is unknown)
+ * @ingroup specialized
*/
const union MHD_DaemonInfo *
MHD_get_daemon_info (struct MHD_Daemon *daemon,
@@ -2055,10 +2205,12 @@
* Obtain the version of this library
*
* @return static version string, e.g. "0.9.9"
+ * @ingroup specialized
*/
const char*
MHD_get_version (void);
+
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r28771 - libmicrohttpd/src/include,
gnunet <=