[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r22733 - in libmicrohttpd: . doc src/daemon src/include
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r22733 - in libmicrohttpd: . doc src/daemon src/include |
|
Date: |
Tue, 17 Jul 2012 23:52:26 +0200 |
Author: grothoff
Date: 2012-07-17 23:52:26 +0200 (Tue, 17 Jul 2012)
New Revision: 22733
Modified:
libmicrohttpd/ChangeLog
libmicrohttpd/doc/microhttpd.texi
libmicrohttpd/src/daemon/connection.c
libmicrohttpd/src/daemon/connection.h
libmicrohttpd/src/daemon/daemon.c
libmicrohttpd/src/daemon/reason_phrase.c
libmicrohttpd/src/daemon/response.c
libmicrohttpd/src/include/microhttpd.h
Log:
code cleanup, minor bug fixes, allow lookup up trailing values with key of NULL
Modified: libmicrohttpd/ChangeLog
===================================================================
--- libmicrohttpd/ChangeLog 2012-07-17 20:40:39 UTC (rev 22732)
+++ libmicrohttpd/ChangeLog 2012-07-17 21:52:26 UTC (rev 22733)
@@ -1,3 +1,8 @@
+Tue Jul 17 23:50:43 CEST 2012
+ Stylistic code clean up. Allowing lookup up of trailing values
+ without keys using "MHD_lookup_connection_value" with a key of NULL
+ (thus achieving consistency with the existing iterator API). -CG
+
Tue Jul 17 22:37:05 CEST 2012
Adding experimental (!) code for MHD operation without listen socket.
-CG
Modified: libmicrohttpd/doc/microhttpd.texi
===================================================================
--- libmicrohttpd/doc/microhttpd.texi 2012-07-17 20:40:39 UTC (rev 22732)
+++ libmicrohttpd/doc/microhttpd.texi 2012-07-17 21:52:26 UTC (rev 22733)
@@ -1270,12 +1270,16 @@
@deftypefun {const char *} MHD_lookup_connection_value (struct MHD_Connection
*connection, enum MHD_ValueKind kind, const char *key)
-Get a particular header value. If multiple values match the @var{kind},
-return one of them (the ``first'', whatever that means). @var{key} must
-reference a zero-terminated @ascii{}-coded string representing the
-header to look for: it is compared against the headers using
address@hidden, so case is ignored. Return @mynull{} if no such
-item was found.
+Get a particular header value. If multiple values match the
address@hidden, return one of them (the ``first'', whatever that means).
address@hidden must reference a zero-terminated @ascii{}-coded string
+representing the header to look for: it is compared against the
+headers using @cfunction{strcasecmp}, so case is ignored. A value of
+NULL for @var{key} can be used to lookup 'trailing' values without a
+key, for example if a URI is of the form
+``http://example.com/?trailer'', a @var{key} of NULL can be used to
+access ``tailer" The function returns @mynull{} if no matching item
+was found.
@end deftypefun
Modified: libmicrohttpd/src/daemon/connection.c
===================================================================
--- libmicrohttpd/src/daemon/connection.c 2012-07-17 20:40:39 UTC (rev
22732)
+++ libmicrohttpd/src/daemon/connection.c 2012-07-17 21:52:26 UTC (rev
22733)
@@ -123,22 +123,18 @@
int ret;
struct MHD_HTTP_Header *pos;
- if (connection == NULL)
+ if (NULL == connection)
return -1;
ret = 0;
- pos = connection->headers_received;
- while (pos != NULL)
- {
- if (0 != (pos->kind & kind))
- {
- ret++;
- if ((iterator != NULL) &&
- (MHD_YES != iterator (iterator_cls,
- kind, pos->header, pos->value)))
- return ret;
- }
- pos = pos->next;
- }
+ for (pos = connection->headers_received; NULL != pos; pos = pos->next)
+ if (0 != (pos->kind & kind))
+ {
+ ret++;
+ if ((NULL != iterator) &&
+ (MHD_YES != iterator (iterator_cls,
+ kind, pos->header, pos->value)))
+ return ret;
+ }
return ret;
}
@@ -181,7 +177,7 @@
pos = MHD_pool_allocate (connection->pool,
sizeof (struct MHD_HTTP_Header), MHD_NO);
- if (pos == NULL)
+ if (NULL == pos)
return MHD_NO;
pos->header = (char *) key;
pos->value = (char *) value;
@@ -208,7 +204,7 @@
*
* @param connection connection to get values from
* @param kind what kind of value are we looking for
- * @param key the header to look for
+ * @param key the header to look for, NULL to lookup 'trailing' value without
a key
* @return NULL if no such item was found
*/
const char *
@@ -220,7 +216,11 @@
if (NULL == connection)
return NULL;
for (pos = connection->headers_received; NULL != pos; pos = pos->next)
- if ((0 != (pos->kind & kind)) && (0 == strcasecmp (key, pos->header)))
+ if ((0 != (pos->kind & kind)) &&
+ ( (key == pos->header) ||
+ ( (NULL != pos->header) &&
+ (NULL != key) &&
+ (0 == strcasecmp (key, pos->header))) ))
return pos->value;
return NULL;
}
@@ -240,28 +240,28 @@
MHD_queue_response (struct MHD_Connection *connection,
unsigned int status_code, struct MHD_Response *response)
{
- if ((connection == NULL) ||
- (response == NULL) ||
- (connection->response != NULL) ||
- ((connection->state != MHD_CONNECTION_HEADERS_PROCESSED) &&
- (connection->state != MHD_CONNECTION_FOOTERS_RECEIVED)))
+ if ( (NULL == connection) ||
+ (NULL == response) ||
+ (NULL != connection->response) ||
+ ( (MHD_CONNECTION_HEADERS_PROCESSED != connection->state) &&
+ (MHD_CONNECTION_FOOTERS_RECEIVED != connection->state) ) )
return MHD_NO;
MHD_increment_response_rc (response);
connection->response = response;
connection->responseCode = status_code;
- if ((connection->method != NULL) &&
- (0 == strcasecmp (connection->method, MHD_HTTP_METHOD_HEAD)))
+ if ( (NULL != connection->method) &&
+ (0 == strcasecmp (connection->method, MHD_HTTP_METHOD_HEAD)) )
{
/* if this is a "HEAD" request, pretend that we
have already sent the full message body */
connection->response_write_position = response->total_size;
}
- if (connection->state == MHD_CONNECTION_HEADERS_PROCESSED)
+ if (MHD_CONNECTION_HEADERS_PROCESSED == connection->state)
{
/* response was queued "early",
refuse to read body / footers or further
requests! */
- SHUTDOWN (connection->socket_fd, SHUT_RD);
+ (void) SHUTDOWN (connection->socket_fd, SHUT_RD);
connection->read_closed = MHD_YES;
connection->state = MHD_CONNECTION_FOOTERS_RECEIVED;
}
@@ -281,16 +281,16 @@
{
const char *expect;
- return ((connection->response == NULL) &&
- (connection->version != NULL) &&
- (0 == strcasecmp (connection->version,
- MHD_HTTP_VERSION_1_1)) &&
- (NULL != (expect = MHD_lookup_connection_value (connection,
- MHD_HEADER_KIND,
-
MHD_HTTP_HEADER_EXPECT)))
- && (0 == strcasecmp (expect, "100-continue"))
- && (connection->continue_message_write_offset <
- strlen (HTTP_100_CONTINUE)));
+ return ( (NULL == connection->response) &&
+ (NULL != connection->version) &&
+ (0 == strcasecmp (connection->version,
+ MHD_HTTP_VERSION_1_1)) &&
+ (NULL != (expect = MHD_lookup_connection_value (connection,
+ MHD_HEADER_KIND,
+
MHD_HTTP_HEADER_EXPECT))) &&
+ (0 == strcasecmp (expect, "100-continue")) &&
+ (connection->continue_message_write_offset <
+ strlen (HTTP_100_CONTINUE)) );
}
@@ -358,6 +358,7 @@
* this function may close the socket (and return
* MHD_NO).
*
+ * @param connection the connection
* @return MHD_NO if readying the response failed
*/
static int
@@ -367,7 +368,7 @@
struct MHD_Response *response;
response = connection->response;
- if (response->crc == NULL)
+ if (NULL == response->crc)
return MHD_YES;
if ( (response->data_start <=
connection->response_write_position) &&
@@ -375,7 +376,7 @@
connection->response_write_position) )
return MHD_YES; /* response already ready */
#if LINUX
- if ( (response->fd != -1) &&
+ if ( (-1 != response->fd) &&
(0 == (connection->daemon->options & MHD_USE_SSL)) )
{
/* will use sendfile, no need to bother response crc */
@@ -389,7 +390,7 @@
MHD_MIN (response->data_buffer_size,
response->total_size -
connection->response_write_position));
- if ((ret == 0) &&
+ if ((0 == ret) &&
(0 != (connection->daemon->options & MHD_USE_SELECT_INTERNALLY)))
mhd_panic (mhd_panic_cls, __FILE__, __LINE__,
#if HAVE_MESSAGES
@@ -398,8 +399,8 @@
NULL
#endif
);
- if ( (ret == MHD_CONTENT_READER_END_OF_STREAM) ||
- (ret == MHD_CONTENT_READER_END_WITH_ERROR) )
+ if ( (MHD_CONTENT_READER_END_OF_STREAM == ret) ||
+ (MHD_CONTENT_READER_END_WITH_ERROR == ret) )
{
/* either error or http 1.0 transfer, close socket! */
response->total_size = connection->response_write_position;
@@ -411,7 +412,7 @@
}
response->data_start = connection->response_write_position;
response->data_size = ret;
- if (ret == 0)
+ if (0 == ret)
{
connection->state = MHD_CONNECTION_NORMAL_BODY_UNREADY;
return MHD_NO;
@@ -426,6 +427,7 @@
* transmission is complete, this function may close the socket (and
* return MHD_NO).
*
+ * @param connection the connection
* @return MHD_NO if readying the response failed
*/
static int
@@ -439,7 +441,7 @@
int cblen;
response = connection->response;
- if (connection->write_buffer_size == 0)
+ if (0 == connection->write_buffer_size)
{
size = connection->daemon->pool_size;
do
@@ -454,7 +456,7 @@
}
buf = MHD_pool_allocate (connection->pool, size, MHD_NO);
}
- while (buf == NULL);
+ while (NULL == buf);
connection->write_buffer_size = size;
connection->write_buffer = buf;
}
@@ -480,7 +482,7 @@
&connection->write_buffer[sizeof (cbuf)],
connection->write_buffer_size - sizeof (cbuf) - 2);
}
- if (ret == MHD_CONTENT_READER_END_WITH_ERROR)
+ if (MHD_CONTENT_READER_END_WITH_ERROR == ret)
{
/* error, close socket! */
response->total_size = connection->response_write_position;
@@ -488,7 +490,7 @@
"Closing connection (error generating
response)\n");
return MHD_NO;
}
- if (ret == MHD_CONTENT_READER_END_OF_STREAM)
+ if (MHD_CONTENT_READER_END_OF_STREAM == ret)
{
/* end of message, signal other side! */
strcpy (connection->write_buffer, "0\r\n");
@@ -497,7 +499,7 @@
response->total_size = connection->response_write_position;
return MHD_YES;
}
- if (ret == 0)
+ if (0 == ret)
{
connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
return MHD_NO;
@@ -517,9 +519,12 @@
return MHD_YES;
}
+
/**
* Check if we need to set some additional headers
* for http-compiliance.
+ *
+ * @param connection connection to check (and possibly modify)
*/
static void
add_extra_headers (struct MHD_Connection *connection)
@@ -528,19 +533,19 @@
char buf[128];
connection->have_chunked_upload = MHD_NO;
- if (connection->response->total_size == MHD_SIZE_UNKNOWN)
+ if (MHD_SIZE_UNKNOWN == connection->response->total_size)
{
have = MHD_get_response_header (connection->response,
MHD_HTTP_HEADER_CONNECTION);
- if ((have == NULL) || (0 != strcasecmp (have, "close")))
+ if ((NULL == have) || (0 != strcasecmp (have, "close")))
{
- if ((connection->version != NULL) &&
+ if ((NULL != connection->version) &&
(0 == strcasecmp (connection->version, MHD_HTTP_VERSION_1_1)))
{
connection->have_chunked_upload = MHD_YES;
have = MHD_get_response_header (connection->response,
MHD_HTTP_HEADER_TRANSFER_ENCODING);
- if (have == NULL)
+ if (NULL == have)
MHD_add_response_header (connection->response,
MHD_HTTP_HEADER_TRANSFER_ENCODING,
"chunked");
@@ -557,12 +562,13 @@
{
SPRINTF (buf,
"%" MHD_LONG_LONG_PRINTF "u",
- (unsigned MHD_LONG_LONG)connection->response->total_size);
+ (unsigned MHD_LONG_LONG) connection->response->total_size);
MHD_add_response_header (connection->response,
MHD_HTTP_HEADER_CONTENT_LENGTH, buf);
}
}
+
/**
* Produce HTTP "Date:" header.
*
@@ -591,9 +597,11 @@
1900 + now.tm_year, now.tm_hour, now.tm_min, now.tm_sec);
}
+
/**
* Try growing the read buffer
*
+ * @param connection the connection
* @return MHD_YES on success, MHD_NO on failure
*/
static int
@@ -606,7 +614,7 @@
connection->read_buffer_size,
connection->read_buffer_size * 2 +
MHD_BUF_INC_SIZE + 1);
- if (buf == NULL)
+ if (NULL == buf)
return MHD_NO;
/* we can actually grow the buffer, do it! */
connection->read_buffer = buf;
@@ -620,6 +628,8 @@
* Allocate the connection's write buffer and fill it with all of the
* headers (or footers, if we have already sent the body) from the
* HTTPd's response.
+ *
+ * @param connection the connection
*/
static int
build_header_response (struct MHD_Connection *connection)
@@ -645,7 +655,7 @@
connection->write_buffer_size = 0;
return MHD_YES;
}
- if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
+ if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state)
{
add_extra_headers (connection);
rc = connection->responseCode & (~MHD_ICY_FLAG);
@@ -686,23 +696,19 @@
MHD_HTTP_HEADER_CONNECTION)) );
if (must_add_close)
size += strlen ("Connection: close\r\n");
- pos = connection->response->first_header;
- while (pos != NULL)
- {
- if (pos->kind == kind)
- size += strlen (pos->header) + strlen (pos->value) + 4; /* colon,
space, linefeeds */
- pos = pos->next;
- }
+ for (pos = connection->response->first_header; NULL != pos; pos = pos->next)
+ if (pos->kind == kind)
+ size += strlen (pos->header) + strlen (pos->value) + 4; /* colon, space,
linefeeds */
/* produce data */
data = MHD_pool_allocate (connection->pool, size + 1, MHD_YES);
- if (data == NULL)
+ if (NULL == data)
{
#if HAVE_MESSAGES
MHD_DLOG (connection->daemon, "Not enough memory for write!\n");
#endif
return MHD_NO;
}
- if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
+ if (MHD_CONNECTION_FOOTERS_RECEIVED == connection->state)
{
memcpy (data, code, off);
}
@@ -716,13 +722,12 @@
strlen ("Connection: close\r\n"));
off += strlen ("Connection: close\r\n");
}
- pos = connection->response->first_header;
- while (pos != NULL)
- {
- if (pos->kind == kind)
- off += SPRINTF (&data[off], "%s: %s\r\n", pos->header, pos->value);
- pos = pos->next;
- }
+ for (pos = connection->response->first_header; NULL != pos; pos = pos->next)
+ if (pos->kind == kind)
+ off += SPRINTF (&data[off],
+ "%s: %s\r\n",
+ pos->header,
+ pos->value);
if (connection->state == MHD_CONNECTION_FOOTERS_RECEIVED)
{
strcpy (&data[off], date);
@@ -746,15 +751,18 @@
* Handle it properly by stopping to read data
* and sending the indicated response code and message.
*
+ * @param connection the connection
* @param status_code the response code to send (400, 413 or 414)
+ * @param message the error message to send
*/
static void
transmit_error_response (struct MHD_Connection *connection,
- unsigned int status_code, const char *message)
+ unsigned int status_code,
+ const char *message)
{
struct MHD_Response *response;
- if (connection->version == NULL)
+ if (NULL == connection->version)
{
/* we were unable to process the full header line, so we don't
really know what version the client speaks; assume 1.0 */
@@ -786,12 +794,19 @@
}
}
+
/**
* Add "fd" to the "fd_set". If "fd" is
* greater than "*max", set "*max" to fd.
+ *
+ * @param fd file descriptor to add to the set
+ * @param set set to modify
+ * @param max_fd maximum value to potentially update
*/
static void
-do_fd_set (int fd, fd_set * set, int *max_fd)
+add_to_fd_set (int fd,
+ fd_set *set,
+ int *max_fd)
{
FD_SET (fd, set);
if ( (NULL != max_fd) &&
@@ -799,27 +814,38 @@
*max_fd = fd;
}
+
/**
- * Obtain the select sets for this connection
+ * Obtain the select sets for this connection. The given
+ * sets (and the maximum) are updated and must have
+ * already been initialized.
*
+ * @param connection connetion to get select sets for
+ * @param read_fd_set read set to initialize
+ * @param write_fd_set write set to initialize
+ * @param except_fd_set except set to initialize (never changed)
+ * @param max_fd where to store largest FD put into any set
* @return MHD_YES on success
*/
int
MHD_connection_get_fdset (struct MHD_Connection *connection,
- fd_set * read_fd_set,
- fd_set * write_fd_set,
- fd_set * except_fd_set, int *max_fd)
+ fd_set *read_fd_set,
+ fd_set *write_fd_set,
+ fd_set *except_fd_set,
+ int *max_fd)
{
int ret;
struct MHD_Pollfd p;
- memset(&p, 0, sizeof(struct MHD_Pollfd));
- ret = MHD_connection_get_pollfd(connection, &p);
- if ( (ret == MHD_YES) && (p.fd >= 0) ) {
+ /* we use the 'poll fd' as a convenient way to re-use code
+ when determining the select sets */
+ memset (&p, 0, sizeof(struct MHD_Pollfd));
+ ret = MHD_connection_get_pollfd (connection, &p);
+ if ( (MHD_YES == ret) && (p.fd >= 0) ) {
if (0 != (p.events & MHD_POLL_ACTION_IN))
- do_fd_set(p.fd, read_fd_set, max_fd);
+ add_to_fd_set(p.fd, read_fd_set, max_fd);
if (0 != (p.events & MHD_POLL_ACTION_OUT))
- do_fd_set(p.fd, write_fd_set, max_fd);
+ add_to_fd_set(p.fd, write_fd_set, max_fd);
}
return ret;
}
@@ -828,17 +854,20 @@
/**
* Obtain the pollfd for this connection
*
+ * @param connection connetion to get poll set for
+ * @param p where to store the polling information
* @return MHD_YES on success. If return MHD_YES and p->fd < 0, this
* connection is not waiting for any read or write events
*/
int
-MHD_connection_get_pollfd (struct MHD_Connection *connection, struct
MHD_Pollfd *p)
+MHD_connection_get_pollfd (struct MHD_Connection *connection,
+ struct MHD_Pollfd *p)
{
int fd;
- if (connection->pool == NULL)
+ if (NULL == connection->pool)
connection->pool = MHD_pool_create (connection->daemon->pool_size);
- if (connection->pool == NULL)
+ if (NULL == connection->pool)
{
CONNECTION_CLOSE_ERROR (connection,
"Failed to create memory pool!\n");
@@ -846,7 +875,7 @@
}
fd = connection->socket_fd;
p->fd = fd;
- if (fd == -1)
+ if (-1 == fd)
return MHD_YES;
while (1)
{
@@ -870,7 +899,7 @@
/* while reading headers, we always grow the
read buffer if needed, no size-check required */
if ((connection->read_closed) &&
- (connection->read_buffer_offset == 0))
+ (0 == connection->read_buffer_offset))
{
CONNECTION_CLOSE_ERROR (connection,
"Connection buffer to small for
request\n");
@@ -984,6 +1013,7 @@
return MHD_YES;
}
+
/**
* Parse a single line of the HTTP header. Advance
* read_buffer (!) appropriately. If the current line does not
@@ -998,12 +1028,12 @@
char *rbuf;
size_t pos;
- if (connection->read_buffer_offset == 0)
+ if (0 == connection->read_buffer_offset)
return NULL;
pos = 0;
rbuf = connection->read_buffer;
while ((pos < connection->read_buffer_offset - 1) &&
- (rbuf[pos] != '\r') && (rbuf[pos] != '\n'))
+ ('\r' != rbuf[pos]) && ('\n' != rbuf[pos]))
pos++;
if (pos == connection->read_buffer_offset - 1)
{
@@ -1015,10 +1045,10 @@
connection->read_buffer_size,
connection->read_buffer_size * 2 +
MHD_BUF_INC_SIZE);
- if (rbuf == NULL)
+ if (NULL == rbuf)
{
transmit_error_response (connection,
- (connection->url != NULL)
+ (NULL != connection->url)
? MHD_HTTP_REQUEST_ENTITY_TOO_LARGE
: MHD_HTTP_REQUEST_URI_TOO_LONG,
REQUEST_TOO_BIG);
@@ -1033,7 +1063,7 @@
return NULL;
}
/* found, check if we have proper CRLF */
- if ((rbuf[pos] == '\r') && (rbuf[pos + 1] == '\n'))
+ if (('\r' == rbuf[pos]) && ('\n' == rbuf[pos + 1]))
rbuf[pos++] = '\0'; /* skip both r and n */
rbuf[pos++] = '\0';
connection->read_buffer += pos;
@@ -1085,15 +1115,15 @@
*/
static int
parse_arguments (enum MHD_ValueKind kind,
- struct MHD_Connection *connection, char *args)
+ struct MHD_Connection *connection,
+ char *args)
{
char *equals;
char *amper;
- while (args != NULL)
+ while (NULL != args)
{
- equals = strstr (args, "=");
- if (equals == NULL)
+ if (NULL == (equals = strstr (args, "=")))
{
/* add with 'value' NULL */
connection->daemon->unescape_callback
(connection->daemon->unescape_callback_cls,
@@ -1220,6 +1250,7 @@
return MHD_YES;
}
+
/**
* Parse the first line of the HTTP HEADER.
*
@@ -1234,8 +1265,7 @@
char *httpVersion;
char *args;
- uri = strstr (line, " ");
- if (uri == NULL)
+ if (NULL == (uri = strstr (line, " ")))
return MHD_NO; /* serious error */
uri[0] = '\0';
connection->method = line;
@@ -1282,7 +1312,7 @@
{
size_t processed;
- if (connection->response != NULL)
+ if (NULL != connection->response)
return; /* already queued a response */
processed = 0;
connection->client_aware = MHD_YES;
@@ -1321,7 +1351,7 @@
char *buffer_head;
char *end;
- if (connection->response != NULL)
+ if (NULL != connection->response)
return; /* already queued a response */
buffer_head = connection->read_buffer;
@@ -1473,7 +1503,7 @@
if (connection->remaining_upload_size != MHD_SIZE_UNKNOWN)
connection->remaining_upload_size -= used;
}
- while (instant_retry == MHD_YES);
+ while (MHD_YES == instant_retry);
if (available > 0)
memmove (connection->read_buffer, buffer_head, available);
connection->read_buffer_offset = available;
@@ -1502,7 +1532,7 @@
connection->read_buffer_offset);
if (bytes_read < 0)
{
- if ((errno == EINTR) || (errno == EAGAIN))
+ if ((EINTR == errno) || (EAGAIN == errno))
return MHD_NO;
#if HAVE_MESSAGES
#if HTTPS_SUPPORT
@@ -1518,7 +1548,7 @@
CONNECTION_CLOSE_ERROR (connection, NULL);
return MHD_YES;
}
- if (bytes_read == 0)
+ if (0 == bytes_read)
{
/* other side closed connection */
connection->read_closed = MHD_YES;
@@ -1549,7 +1579,7 @@
if (ret < 0)
{
- if ((errno == EINTR) || (errno == EAGAIN))
+ if ((EINTR == errno) || (EAGAIN == errno))
return MHD_NO;
#if HAVE_MESSAGES
#if HTTPS_SUPPORT
@@ -1774,12 +1804,14 @@
}
}
+
/**
* This function handles a particular connection when it has been
* determined that there is data to be read off a socket. All
* implementations (multithreaded, external select, internal select)
* call this function to handle reads.
*
+ * @param connection connection to handle
* @return always MHD_YES (we should continue to process the
* connection)
*/
@@ -1843,6 +1875,7 @@
* implementations (multithreaded, external select, internal select)
* call this function
*
+ * @param connection connection to handle
* @return always MHD_YES (we should continue to process the
* connection)
*/
@@ -1993,12 +2026,14 @@
return MHD_YES;
}
+
/**
* This function was created to handle per-connection processing that
* has to happen even if the socket cannot be read or written to. All
* implementations (multithreaded, external select, internal select)
* call this function.
*
+ * @param connection connection to handle
* @return MHD_YES if we should continue to process the
* connection (not dead yet), MHD_NO if it died
*/
@@ -2381,6 +2416,11 @@
}
+/**
+ * Set callbacks for this connection to those for HTTP.
+ *
+ * @param connection connection to initialize
+ */
void
MHD_set_http_callbacks_ (struct MHD_Connection *connection)
{
Modified: libmicrohttpd/src/daemon/connection.h
===================================================================
--- libmicrohttpd/src/daemon/connection.h 2012-07-17 20:40:39 UTC (rev
22732)
+++ libmicrohttpd/src/daemon/connection.h 2012-07-17 21:52:26 UTC (rev
22733)
@@ -29,9 +29,17 @@
#include "internal.h"
+
/**
- * Obtain the select sets for this connection.
+ * Obtain the select sets for this connection. The given
+ * sets (and the maximum) are updated and must have
+ * already been initialized.
*
+ * @param connection connetion to get select sets for
+ * @param read_fd_set read set to initialize
+ * @param write_fd_set write set to initialize
+ * @param except_fd_set except set to initialize (never changed)
+ * @param max_fd where to store largest FD put into any set
* @return MHD_YES on success
*/
int
@@ -40,27 +48,81 @@
fd_set * write_fd_set,
fd_set * except_fd_set, int *max_fd);
+
/**
* Obtain the pollfd for this connection. The poll interface allows large
* file descriptors. Select goes stupid when the fd overflows fdset (which
* is fixed).
+ *
+ * @param connection connetion to get poll set for
+ * @param p where to store the polling information
*/
-int MHD_connection_get_pollfd(struct MHD_Connection *connection,
- struct MHD_Pollfd *p);
+int
+MHD_connection_get_pollfd (struct MHD_Connection *connection,
+ struct MHD_Pollfd *p);
-void MHD_set_http_callbacks_ (struct MHD_Connection *connection);
-int MHD_connection_handle_read (struct MHD_Connection *connection);
+/**
+ * Set callbacks for this connection to those for HTTP.
+ *
+ * @param connection connection to initialize
+ */
+void
+MHD_set_http_callbacks_ (struct MHD_Connection *connection);
-int MHD_connection_handle_write (struct MHD_Connection *connection);
-int MHD_connection_handle_idle (struct MHD_Connection *connection);
+/**
+ * This function handles a particular connection when it has been
+ * determined that there is data to be read off a socket. All
+ * implementations (multithreaded, external select, internal select)
+ * call this function to handle reads.
+ *
+ * @param connection connection to handle
+ * @return always MHD_YES (we should continue to process the
+ * connection)
+ */
+int
+MHD_connection_handle_read (struct MHD_Connection *connection);
+
/**
+ * This function was created to handle writes to sockets when it has
+ * been determined that the socket can be written to. All
+ * implementations (multithreaded, external select, internal select)
+ * call this function
+ *
+ * @param connection connection to handle
+ * @return always MHD_YES (we should continue to process the
+ * connection)
+ */
+int
+MHD_connection_handle_write (struct MHD_Connection *connection);
+
+
+/**
+ * This function was created to handle per-connection processing that
+ * has to happen even if the socket cannot be read or written to. All
+ * implementations (multithreaded, external select, internal select)
+ * call this function.
+ *
+ * @param connection connection to handle
+ * @return MHD_YES if we should continue to process the
+ * connection (not dead yet), MHD_NO if it died
+ */
+int
+MHD_connection_handle_idle (struct MHD_Connection *connection);
+
+
+/**
* Close the given connection and give the
* specified termination code to the user.
+ *
+ * @param connection connection to close
+ * @param termination_code termination reason to give
*/
-void MHD_connection_close (struct MHD_Connection *connection,
- enum MHD_RequestTerminationCode termination_code);
+void
+MHD_connection_close (struct MHD_Connection *connection,
+ enum MHD_RequestTerminationCode termination_code);
+
#endif
Modified: libmicrohttpd/src/daemon/daemon.c
===================================================================
--- libmicrohttpd/src/daemon/daemon.c 2012-07-17 20:40:39 UTC (rev 22732)
+++ libmicrohttpd/src/daemon/daemon.c 2012-07-17 21:52:26 UTC (rev 22733)
@@ -191,6 +191,7 @@
}
}
+
/**
* Tree comparison function for IP addresses (supplied to tsearch() family).
* We compare everything in the struct up through the beginning of the
@@ -203,7 +204,7 @@
static int
MHD_ip_addr_compare(const void *a1, const void *a2)
{
- return memcmp (a1, a2, offsetof(struct MHD_IPCount, count));
+ return memcmp (a1, a2, offsetof (struct MHD_IPCount, count));
}
@@ -216,15 +217,16 @@
* @return MHD_YES on success and MHD_NO otherwise (e.g., invalid address type)
*/
static int
-MHD_ip_addr_to_key(const struct sockaddr *addr, socklen_t addrlen,
+MHD_ip_addr_to_key(const struct sockaddr *addr,
+ socklen_t addrlen,
struct MHD_IPCount *key)
{
memset(key, 0, sizeof(*key));
/* IPv4 addresses */
- if (addrlen == sizeof(struct sockaddr_in))
+ if (sizeof (struct sockaddr_in) == addrlen)
{
- const struct sockaddr_in *addr4 = (const struct sockaddr_in*)addr;
+ const struct sockaddr_in *addr4 = (const struct sockaddr_in*) addr;
key->family = AF_INET;
memcpy (&key->addr.ipv4, &addr4->sin_addr, sizeof(addr4->sin_addr));
return MHD_YES;
@@ -232,9 +234,9 @@
#if HAVE_IPV6
/* IPv6 addresses */
- if (addrlen == sizeof (struct sockaddr_in6))
+ if (sizeof (struct sockaddr_in6) == addrlen)
{
- const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6*)addr;
+ const struct sockaddr_in6 *addr6 = (const struct sockaddr_in6*) addr;
key->family = AF_INET6;
memcpy (&key->addr.ipv6, &addr6->sin6_addr, sizeof(addr6->sin6_addr));
return MHD_YES;
@@ -261,17 +263,16 @@
socklen_t addrlen)
{
struct MHD_IPCount *key;
+ void **nodep;
void *node;
int result;
daemon = MHD_get_master (daemon);
-
/* Ignore if no connection limit assigned */
- if (daemon->per_ip_connection_limit == 0)
+ if (0 == daemon->per_ip_connection_limit)
return MHD_YES;
- key = malloc (sizeof(*key));
- if (NULL == key)
+ if (NULL == (key = malloc (sizeof(*key))))
return MHD_NO;
/* Initialize key */
@@ -281,32 +282,30 @@
free (key);
return MHD_YES;
}
-
MHD_ip_count_lock (daemon);
/* Search for the IP address */
- node = (void*)TSEARCH (key, &daemon->per_ip_connection_count,
MHD_ip_addr_compare);
- if (!node)
+ if (NULL == (nodep = TSEARCH (key,
+ &daemon->per_ip_connection_count,
+ &MHD_ip_addr_compare)))
{
#if HAVE_MESSAGES
- MHD_DLOG(daemon,
- "Failed to add IP connection count node\n");
+ MHD_DLOG (daemon,
+ "Failed to add IP connection count node\n");
#endif
MHD_ip_count_unlock (daemon);
free (key);
return MHD_NO;
}
- node = *(void**)node;
-
+ node = *nodep;
/* If we got an existing node back, free the one we created */
if (node != key)
free(key);
- key = (struct MHD_IPCount*)node;
-
+ key = (struct MHD_IPCount *) node;
/* Test if there is room for another connection; if so,
* increment count */
result = (key->count < daemon->per_ip_connection_limit);
- if (result == MHD_YES)
+ if (MHD_YES == result)
++key->count;
MHD_ip_count_unlock (daemon);
@@ -329,14 +328,12 @@
{
struct MHD_IPCount search_key;
struct MHD_IPCount *found_key;
- void *node;
+ void **nodep;
daemon = MHD_get_master (daemon);
-
/* Ignore if no connection limit assigned */
- if (daemon->per_ip_connection_limit == 0)
+ if (0 == daemon->per_ip_connection_limit)
return;
-
/* Initialize search key */
if (MHD_NO == MHD_ip_addr_to_key (addr, addrlen, &search_key))
return;
@@ -344,22 +341,21 @@
MHD_ip_count_lock (daemon);
/* Search for the IP address */
- node = (void*)TFIND (&search_key, &daemon->per_ip_connection_count,
MHD_ip_addr_compare);
-
- /* Something's wrong if we couldn't find an IP address
- * that was previously added */
- if (!node)
- {
+ if (NULL == (nodep = TFIND (&search_key,
+ &daemon->per_ip_connection_count,
+ &MHD_ip_addr_compare)))
+ {
+ /* Something's wrong if we couldn't find an IP address
+ * that was previously added */
#if HAVE_MESSAGES
MHD_DLOG (daemon,
"Failed to find previously-added IP address\n");
#endif
abort();
}
- found_key = (struct MHD_IPCount*)*(void**)node;
-
+ found_key = (struct MHD_IPCount *) *nodep;
/* Validate existing count for IP address */
- if (found_key->count == 0)
+ if (0 == found_key->count)
{
#if HAVE_MESSAGES
MHD_DLOG (daemon,
@@ -367,11 +363,12 @@
#endif
abort();
}
-
/* Remove the node entirely if count reduces to 0 */
- if (--found_key->count == 0)
+ if (0 == --found_key->count)
{
- TDELETE (found_key, &daemon->per_ip_connection_count,
MHD_ip_addr_compare);
+ TDELETE (found_key,
+ &daemon->per_ip_connection_count,
+ &MHD_ip_addr_compare);
free (found_key);
}
@@ -395,9 +392,10 @@
recv_tls_adapter (struct MHD_Connection *connection, void *other, size_t i)
{
int res;
+
res = gnutls_record_recv (connection->tls_session, other, i);
- if ( (res == GNUTLS_E_AGAIN) ||
- (res == GNUTLS_E_INTERRUPTED) )
+ if ( (GNUTLS_E_AGAIN == res) ||
+ (GNUTLS_E_INTERRUPTED == res) )
{
errno = EINTR;
return -1;
@@ -427,9 +425,10 @@
const void *other, size_t i)
{
int res;
+
res = gnutls_record_send (connection->tls_session, other, i);
- if ( (res == GNUTLS_E_AGAIN) ||
- (res == GNUTLS_E_INTERRUPTED) )
+ if ( (GNUTLS_E_AGAIN == res) ||
+ (GNUTLS_E_INTERRUPTED == res) )
{
errno = EINTR;
return -1;
@@ -450,7 +449,7 @@
gnutls_datum_t key;
gnutls_datum_t cert;
- if (daemon->https_mem_trust)
+ if (NULL != daemon->https_mem_trust)
{
cert.data = (unsigned char *) daemon->https_mem_trust;
cert.size = strlen (daemon->https_mem_trust);
@@ -466,7 +465,8 @@
}
/* certificate & key loaded from memory */
- if (daemon->https_mem_cert && daemon->https_mem_key)
+ if ( (NULL != daemon->https_mem_cert) &&
+ (NULL != daemon->https_mem_key) )
{
key.data = (unsigned char *) daemon->https_mem_key;
key.size = strlen (daemon->https_mem_key);
@@ -605,8 +605,8 @@
tv.tv_usec = 0;
tvp = &tv;
}
- if ((con->state == MHD_CONNECTION_NORMAL_BODY_UNREADY) ||
- (con->state == MHD_CONNECTION_CHUNKED_BODY_UNREADY))
+ if ( (MHD_CONNECTION_NORMAL_BODY_UNREADY == con->state) ||
+ (MHD_CONNECTION_CHUNKED_BODY_UNREADY == con->state) )
{
/* do not block (we're waiting for our callback to succeed) */
tv.tv_sec = 0;
@@ -628,10 +628,12 @@
num_ready = SELECT (max + 1, &rs, &ws, &es, tvp);
if (num_ready < 0)
{
- if (errno == EINTR)
+ if (EINTR == errno)
continue;
#if HAVE_MESSAGES
- MHD_DLOG (con->daemon, "Error during select (%d): `%s'\n", max,
+ MHD_DLOG (con->daemon,
+ "Error during select (%d): `%s'\n",
+ max,
STRERROR (errno));
#endif
break;
@@ -658,11 +660,9 @@
p[0].events |= POLLOUT;
if (poll (p,
1,
- (tvp == NULL)
- ? -1
- : tv.tv_sec * 1000) < 0)
+ (NULL == tvp) ? -1 : tv.tv_sec * 1000) < 0)
{
- if (errno == EINTR)
+ if (EINTR == errno)
continue;
#if HAVE_MESSAGES
MHD_DLOG (con->daemon, "Error during poll: `%s'\n",
@@ -681,7 +681,7 @@
}
#endif
}
- if (con->state != MHD_CONNECTION_IN_CLEANUP)
+ if (MHD_CONNECTION_IN_CLEANUP != con->state)
{
#if DEBUG_CLOSE
#if HAVE_MESSAGES
@@ -689,12 +689,13 @@
"Processing thread terminating, closing connection\n");
#endif
#endif
- if (con->state != MHD_CONNECTION_CLOSED)
- MHD_connection_close (con, MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);
+ if (MHD_CONNECTION_CLOSED != con->state)
+ MHD_connection_close (con,
+ MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN);
con->idle_handler (con);
}
exit:
- if (con->response != NULL)
+ if (NULL != con->response)
{
MHD_destroy_response (con->response);
con->response = NULL;
@@ -747,8 +748,8 @@
off_t left;
ssize_t ret;
#endif
- if ( (connection->socket_fd == -1) ||
- (connection->state == MHD_CONNECTION_CLOSED) )
+ if ( (-1 == connection->socket_fd) ||
+ (MHD_CONNECTION_CLOSED == connection->state) )
{
errno = ENOTCONN;
return -1;
@@ -766,16 +767,14 @@
left = connection->response->total_size -
connection->response_write_position;
if (left > SSIZE_MAX)
left = SSIZE_MAX; /* cap at return value limit */
- ret = sendfile (connection->socket_fd,
- fd,
- &offset,
- (size_t) left);
- if (ret != -1)
+ if (-1 != (ret = sendfile (connection->socket_fd,
+ fd,
+ &offset,
+ (size_t) left)))
return ret;
- if ((EINTR == errno) || (EAGAIN == errno))
+ if ( (EINTR == errno) || (EAGAIN == errno) )
return 0;
- if ( (EINVAL == errno) ||
- (EBADF == errno) )
+ if ( (EINVAL == errno) || (EBADF == errno) )
return -1;
/* None of the 'usual' sendfile errors occurred, so we should try
to fall back to 'SEND'; see also this thread for info on
@@ -806,7 +805,7 @@
pthread_attr_t *pattr;
int ret;
- if (daemon->thread_stack_size != 0)
+ if (0 != daemon->thread_stack_size)
{
if (0 != (ret = pthread_attr_init (&attr)))
goto ERR;
@@ -823,7 +822,7 @@
}
ret = pthread_create (thread, pattr,
start_routine, arg);
- if (daemon->thread_stack_size != 0)
+ if (0 != daemon->thread_stack_size)
pthread_attr_destroy (&attr);
return ret;
ERR:
@@ -893,8 +892,8 @@
MHD_DLOG (daemon, "Accepted connection on socket %d\n", s);
#endif
#endif
- if ((daemon->max_connections == 0)
- || (MHD_ip_limit_add (daemon, addr, addrlen) == MHD_NO))
+ if ( (0 == daemon->max_connections) ||
+ (MHD_NO == MHD_ip_limit_add (daemon, addr, addrlen)) )
{
/* above connection limit - reject */
#if HAVE_MESSAGES
@@ -907,8 +906,9 @@
}
/* apply connection acceptance policy if present */
- if ((daemon->apc != NULL)
- && (MHD_NO == daemon->apc (daemon->apc_cls, addr, addrlen)))
+ if ( (NULL != daemon->apc) &&
+ (MHD_NO == daemon->apc (daemon->apc_cls,
+ addr, addrlen)) )
{
#if DEBUG_CLOSE
#if HAVE_MESSAGES
@@ -924,16 +924,19 @@
#if OSX
#ifdef SOL_SOCKET
#ifdef SO_NOSIGPIPE
- setsockopt (client_socket, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof (on));
+ setsockopt (client_socket,
+ SOL_SOCKET, SO_NOSIGPIPE,
+ &on, sizeof (on));
#endif
#endif
#endif
- connection = malloc (sizeof (struct MHD_Connection));
- if (NULL == connection)
+ if (NULL == (connection = malloc (sizeof (struct MHD_Connection))))
{
#if HAVE_MESSAGES
- MHD_DLOG (daemon, "Error allocating memory: %s\n", STRERROR (errno));
+ MHD_DLOG (daemon,
+ "Error allocating memory: %s\n",
+ STRERROR (errno));
#endif
SHUTDOWN (client_socket, SHUT_RDWR);
CLOSE (client_socket);
@@ -943,11 +946,12 @@
memset (connection, 0, sizeof (struct MHD_Connection));
connection->connection_timeout = daemon->connection_timeout;
connection->pool = NULL;
- connection->addr = malloc (addrlen);
- if (connection->addr == NULL)
+ if (NULL == (connection->addr = malloc (addrlen)))
{
#if HAVE_MESSAGES
- MHD_DLOG (daemon, "Error allocating memory: %s\n", STRERROR (errno));
+ MHD_DLOG (daemon,
+ "Error allocating memory: %s\n",
+ STRERROR (errno));
#endif
SHUTDOWN (client_socket, SHUT_RDWR);
CLOSE (client_socket);
@@ -979,13 +983,14 @@
/* make socket non-blocking */
#ifndef MINGW
int flags = fcntl (connection->socket_fd, F_GETFL);
- if ( (flags == -1) ||
+ if ( (-1 == flags) ||
(0 != fcntl (connection->socket_fd, F_SETFL, flags | O_NONBLOCK)) )
{
#if HAVE_MESSAGES
- FPRINTF(stderr, "Failed to make socket %d non-blocking: %s\n",
- connection->socket_fd,
- STRERROR (errno));
+ MHD_DLOG (daemon,
+ "Failed to make socket %d non-blocking: %s\n",
+ connection->socket_fd,
+ STRERROR (errno));
#endif
}
#else
@@ -993,8 +998,9 @@
if (0 != ioctlsocket (connection->socket_fd, FIONBIO, &flags))
{
#if HAVE_MESSAGES
- FPRINTF(stderr, "Failed to make socket non-blocking: %s\n",
- STRERROR (errno));
+ MHD_DLOG (daemon,
+ "Failed to make socket non-blocking: %s\n",
+ STRERROR (errno));
#endif
}
#endif
@@ -1076,7 +1082,7 @@
{
res_thread_create = create_thread (&connection->pid, daemon,
&MHD_handle_connection, connection);
- if (res_thread_create != 0)
+ if (0 != res_thread_create)
{
#if HAVE_MESSAGES
MHD_DLOG (daemon, "Failed to create a thread: %s\n",
@@ -1148,14 +1154,16 @@
s = ACCEPT (daemon->socket_fd, addr, &addrlen);
need_fcntl = MHD_YES;
}
- if ((s == -1) || (addrlen <= 0))
+ if ((-1 == s) || (addrlen <= 0))
{
#if HAVE_MESSAGES
/* This could be a common occurance with multiple worker threads */
if ((EAGAIN != errno) && (EWOULDBLOCK != errno))
- MHD_DLOG (daemon, "Error accepting connection: %s\n", STRERROR
(errno));
+ MHD_DLOG (daemon,
+ "Error accepting connection: %s\n",
+ STRERROR (errno));
#endif
- if (s != -1)
+ if (-1 != s)
{
SHUTDOWN (s, SHUT_RDWR);
CLOSE (s);
@@ -1182,8 +1190,9 @@
#if WINDOWS
SetErrnoFromWinError (GetLastError ());
#endif
- FPRINTF(stderr, "Failed to make socket non-inheritable: %s\n",
- STRERROR (errno));
+ MHD_DLOG (daemon,
+ "Failed to make socket non-inheritable: %s\n",
+ STRERROR (errno));
#endif
}
}
@@ -1241,7 +1250,7 @@
gnutls_deinit (pos->tls_session);
#endif
MHD_ip_limit_del (daemon, (struct sockaddr*)pos->addr, pos->addr_len);
- if (pos->response != NULL)
+ if (NULL != pos->response)
{
MHD_destroy_response (pos->response);
pos->response = NULL;
@@ -1282,7 +1291,7 @@
time_t earliest_deadline;
time_t now;
struct MHD_Connection *pos;
- int have_timeout = MHD_NO;
+ int have_timeout;
if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
{
@@ -1291,10 +1300,8 @@
#endif
return MHD_NO;
}
- pos = daemon->connections_head;
- if (pos == NULL)
- return MHD_NO; /* no connections */
- while (pos != NULL)
+ have_timeout = MHD_NO;
+ for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
{
if (0 != pos->connection_timeout) {
if (!have_timeout ||
@@ -1307,9 +1314,8 @@
#endif
have_timeout = MHD_YES;
}
- pos = pos->next;
}
- if (!have_timeout)
+ if (MHD_NO == have_timeout)
return MHD_NO;
now = MHD_monotonic_time();
if (earliest_deadline < now)
@@ -1345,12 +1351,12 @@
timeout.tv_sec = 0;
timeout.tv_usec = 0;
- if (daemon->shutdown == MHD_YES)
+ if (MHD_YES == daemon->shutdown)
return MHD_NO;
FD_ZERO (&rs);
FD_ZERO (&ws);
FD_ZERO (&es);
- max = 0;
+ max = -1;
if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
{
/* single-threaded, go over everything */
@@ -1366,12 +1372,12 @@
else
{
/* accept only, have one thread per connection */
- max = daemon->socket_fd;
- if (max == -1)
- return MHD_NO;
- FD_SET (max, &rs);
+ if (-1 != daemon->socket_fd)
+ {
+ max = daemon->socket_fd;
+ FD_SET (daemon->socket_fd, &rs);
+ }
}
-
if (-1 != daemon->wpipe[0])
{
FD_SET (daemon->wpipe[0], &rs);
@@ -1381,7 +1387,7 @@
}
tv = NULL;
- if (may_block == MHD_NO)
+ if (MHD_NO == may_block)
{
timeout.tv_usec = 0;
timeout.tv_sec = 0;
@@ -1397,20 +1403,17 @@
}
num_ready = SELECT (max + 1, &rs, &ws, &es, tv);
- if (daemon->shutdown == MHD_YES)
+ if (MHD_YES == daemon->shutdown)
return MHD_NO;
if (num_ready < 0)
{
- if (errno == EINTR)
+ if (EINTR == errno)
return MHD_YES;
#if HAVE_MESSAGES
MHD_DLOG (daemon, "select failed: %s\n", STRERROR (errno));
#endif
return MHD_NO;
}
- if (MHD_YES == daemon->shutdown)
- return MHD_YES;
-
/* select connection thread handling type */
if ( (-1 != (ds = daemon->socket_fd)) &&
(FD_ISSET (ds, &rs)) )
@@ -1454,13 +1457,11 @@
struct MHD_Connection *pos;
struct MHD_Connection *next;
+ /* count number of connections and thus determine poll set size */
num_connections = 0;
- pos = daemon->connections_head;
- while (pos != NULL)
- {
- num_connections++;
- pos = pos->next;
- }
+ for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
+ num_connections++;
+
{
struct pollfd p[2 + num_connections];
struct MHD_Pollfd mp;
@@ -1515,7 +1516,9 @@
if (EINTR == errno)
return MHD_YES;
#if HAVE_MESSAGES
- MHD_DLOG (daemon, "poll failed: %s\n", STRERROR (errno));
+ MHD_DLOG (daemon,
+ "poll failed: %s\n",
+ STRERROR (errno));
#endif
return MHD_NO;
}
@@ -1620,7 +1623,7 @@
int may_block)
{
#ifdef HAVE_POLL_H
- if (daemon->shutdown == MHD_YES)
+ if (MHD_YES == daemon->shutdown)
return MHD_NO;
if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
return MHD_poll_all (daemon, may_block);
@@ -1814,9 +1817,9 @@
if (daemon->worker_pool_size >= SIZE_MAX / sizeof (struct MHD_Daemon))
{
#if HAVE_MESSAGES
- FPRINTF (stderr,
- "Specified thread pool size (%u) too big\n",
- daemon->worker_pool_size);
+ MHD_DLOG (daemon,
+ "Specified thread pool size (%u) too big\n",
+ daemon->worker_pool_size);
#endif
return MHD_NO;
}
@@ -1827,9 +1830,9 @@
daemon->https_mem_key = va_arg (ap, const char *);
#if HAVE_MESSAGES
else
- FPRINTF (stderr,
- "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not
set\n",
- opt);
+ MHD_DLOG (daemon,
+ "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not
set\n",
+ opt);
#endif
break;
case MHD_OPTION_HTTPS_MEM_CERT:
@@ -1837,9 +1840,9 @@
daemon->https_mem_cert = va_arg (ap, const char *);
#if HAVE_MESSAGES
else
- FPRINTF (stderr,
- "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not
set\n",
- opt);
+ MHD_DLOG (daemon,
+ "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not
set\n",
+ opt);
#endif
break;
case MHD_OPTION_HTTPS_MEM_TRUST:
@@ -1847,16 +1850,16 @@
daemon->https_mem_trust = va_arg (ap, const char *);
#if HAVE_MESSAGES
else
- FPRINTF (stderr,
- "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not
set\n",
- opt);
+ MHD_DLOG (daemon,
+ "MHD HTTPS option %d passed to MHD but MHD_USE_SSL not
set\n",
+ opt);
#endif
break;
case MHD_OPTION_HTTPS_CRED_TYPE:
daemon->cred_type = va_arg (ap, gnutls_credentials_type_t);
break;
case MHD_OPTION_HTTPS_PRIORITIES:
- if (daemon->options & MHD_USE_SSL)
+ if (0 != (daemon->options & MHD_USE_SSL))
{
gnutls_priority_deinit (daemon->priority_cache);
ret = gnutls_priority_init (&daemon->priority_cache,
@@ -1865,10 +1868,10 @@
if (ret != GNUTLS_E_SUCCESS)
{
#if HAVE_MESSAGES
- FPRINTF (stderr,
- "Setting priorities to `%s' failed: %s\n",
- pstr,
- gnutls_strerror (ret));
+ MHD_DLOG (daemon,
+ "Setting priorities to `%s' failed: %s\n",
+ pstr,
+ gnutls_strerror (ret));
#endif
daemon->priority_cache = NULL;
return MHD_NO;
@@ -1994,15 +1997,15 @@
if (((opt >= MHD_OPTION_HTTPS_MEM_KEY) &&
(opt <= MHD_OPTION_HTTPS_PRIORITIES)) || (opt ==
MHD_OPTION_HTTPS_MEM_TRUST))
{
- FPRINTF (stderr,
- "MHD HTTPS option %d passed to MHD compiled without
HTTPS support\n",
- opt);
+ MHD_DLOG (daemon,
+ "MHD HTTPS option %d passed to MHD compiled without
HTTPS support\n",
+ opt);
}
else
{
- FPRINTF (stderr,
- "Invalid option %d! (Did you terminate the list with
MHD_OPTION_END?)\n",
- opt);
+ MHD_DLOG (daemon,
+ "Invalid option %d! (Did you terminate the list with
MHD_OPTION_END?)\n",
+ opt);
}
#endif
return MHD_NO;
@@ -2050,13 +2053,9 @@
if (!GetHandleInformation ((HANDLE) fd, &dwFlags))
#endif
{
-#if HAVE_MESSAGES
#if WINDOWS
SetErrnoFromWinError (GetLastError ());
#endif
- FPRINTF(stderr, "Failed to get socket options to make socket
non-inheritable: %s\n",
- STRERROR (errno));
-#endif
return fd; /* good luck */
}
#if !WINDOWS
@@ -2065,18 +2064,14 @@
flags |= FD_CLOEXEC;
if (0 != fcntl (fd, F_SETFD, flags))
#else
- if (dwFlags != dwFlags | HANDLE_FLAG_INHERIT)
+ if (dwFlags != (dwFlags | HANDLE_FLAG_INHERIT))
return fd; /* already unset */
if (!SetHandleInformation ((HANDLE) fd, HANDLE_FLAG_INHERIT, 0))
#endif
{
-#if HAVE_MESSAGES
#if WINDOWS
SetErrnoFromWinError (GetLastError ());
#endif
- FPRINTF(stderr, "Failed to make socket non-inheritable: %s\n",
- STRERROR (errno));
-#endif
return fd; /* good luck */
}
return fd;
@@ -2103,7 +2098,7 @@
va_list ap)
{
const int on = 1;
- struct MHD_Daemon *retVal;
+ struct MHD_Daemon *daemon;
int socket_fd;
struct sockaddr_in servaddr4;
#if HAVE_INET6
@@ -2115,73 +2110,72 @@
int res_thread_create;
int use_pipe;
- if ((port == 0) || (dh == NULL))
+ if (NULL == dh)
return NULL;
- retVal = malloc (sizeof (struct MHD_Daemon));
- if (retVal == NULL)
+ if (NULL == (daemon = malloc (sizeof (struct MHD_Daemon))))
return NULL;
- memset (retVal, 0, sizeof (struct MHD_Daemon));
+ memset (daemon, 0, sizeof (struct MHD_Daemon));
#if HTTPS_SUPPORT
- if (options & MHD_USE_SSL)
+ if (0 != (options & MHD_USE_SSL))
{
- gnutls_priority_init (&retVal->priority_cache,
+ gnutls_priority_init (&daemon->priority_cache,
"NORMAL",
NULL);
}
#endif
- retVal->socket_fd = -1;
- retVal->options = (enum MHD_OPTION) options;
- retVal->port = port;
- retVal->apc = apc;
- retVal->apc_cls = apc_cls;
- retVal->default_handler = dh;
- retVal->default_handler_cls = dh_cls;
- retVal->max_connections = MHD_MAX_CONNECTIONS_DEFAULT;
- retVal->pool_size = MHD_POOL_SIZE_DEFAULT;
- retVal->unescape_callback = &MHD_http_unescape;
- retVal->connection_timeout = 0; /* no timeout */
- retVal->wpipe[0] = -1;
- retVal->wpipe[1] = -1;
+ daemon->socket_fd = -1;
+ daemon->options = (enum MHD_OPTION) options;
+ daemon->port = port;
+ daemon->apc = apc;
+ daemon->apc_cls = apc_cls;
+ daemon->default_handler = dh;
+ daemon->default_handler_cls = dh_cls;
+ daemon->max_connections = MHD_MAX_CONNECTIONS_DEFAULT;
+ daemon->pool_size = MHD_POOL_SIZE_DEFAULT;
+ daemon->unescape_callback = &MHD_http_unescape;
+ daemon->connection_timeout = 0; /* no timeout */
+ daemon->wpipe[0] = -1;
+ daemon->wpipe[1] = -1;
+#if HAVE_MESSAGES
+ daemon->custom_error_log =
+ (void (*)(void *, const char *, va_list)) &vfprintf;
+ daemon->custom_error_log_cls = stderr;
+#endif
#ifdef HAVE_LISTEN_SHUTDOWN
- use_pipe = (0 != (retVal->options & MHD_USE_NO_LISTEN_SOCKET));
+ use_pipe = (0 != (daemon->options & MHD_USE_NO_LISTEN_SOCKET));
#else
use_pipe = 1; /* yes, must use pipe to signal shutdown */
#endif
if ( (use_pipe) &&
- (0 != PIPE (retVal->wpipe)) )
+ (0 != PIPE (daemon->wpipe)) )
{
#if HAVE_MESSAGES
- FPRINTF(stderr,
- "Failed to create control pipe: %s\n",
- STRERROR (errno));
+ MHD_DLOG (daemon,
+ "Failed to create control pipe: %s\n",
+ STRERROR (errno));
#endif
- free (retVal);
+ free (daemon);
return NULL;
}
#ifndef WINDOWS
if ( (0 == (options & MHD_USE_POLL)) &&
- (retVal->wpipe[0] >= FD_SETSIZE) )
+ (daemon->wpipe[0] >= FD_SETSIZE) )
{
#if HAVE_MESSAGES
- FPRINTF(stderr,
- "file descriptor for control pipe exceeds maximum value\n");
+ MHD_DLOG (daemon,
+ "file descriptor for control pipe exceeds maximum value\n");
#endif
- CLOSE (retVal->wpipe[0]);
- CLOSE (retVal->wpipe[1]);
- free (retVal);
+ CLOSE (daemon->wpipe[0]);
+ CLOSE (daemon->wpipe[1]);
+ free (daemon);
return NULL;
}
#endif
#ifdef DAUTH_SUPPORT
- retVal->digest_auth_rand_size = 0;
- retVal->digest_auth_random = NULL;
- retVal->nonce_nc_size = 4; /* tiny */
+ daemon->digest_auth_rand_size = 0;
+ daemon->digest_auth_random = NULL;
+ daemon->nonce_nc_size = 4; /* tiny */
#endif
-#if HAVE_MESSAGES
- retVal->custom_error_log =
- (void (*)(void *, const char *, va_list)) &vfprintf;
- retVal->custom_error_log_cls = stderr;
-#endif
#if HTTPS_SUPPORT
if (0 != (options & MHD_USE_SSL))
{
@@ -2189,88 +2183,88 @@
if (0 != pthread_mutex_lock (&MHD_gnutls_init_mutex))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal, "Failed to acquire gnutls mutex\n");
+ MHD_DLOG (daemon, "Failed to acquire gnutls mutex\n");
#endif
mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL);
}
if (0 != pthread_mutex_unlock (&MHD_gnutls_init_mutex))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal, "Failed to release gnutls mutex\n");
+ MHD_DLOG (daemon, "Failed to release gnutls mutex\n");
#endif
mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL);
}
- retVal->cred_type = GNUTLS_CRD_CERTIFICATE;
+ daemon->cred_type = GNUTLS_CRD_CERTIFICATE;
}
#endif
- if (MHD_YES != parse_options_va (retVal, &servaddr, ap))
+ if (MHD_YES != parse_options_va (daemon, &servaddr, ap))
{
#if HTTPS_SUPPORT
if ( (0 != (options & MHD_USE_SSL)) &&
- (NULL != retVal->priority_cache) )
- gnutls_priority_deinit (retVal->priority_cache);
+ (NULL != daemon->priority_cache) )
+ gnutls_priority_deinit (daemon->priority_cache);
#endif
- free (retVal);
+ free (daemon);
return NULL;
}
#ifdef DAUTH_SUPPORT
- if (retVal->nonce_nc_size > 0)
+ if (daemon->nonce_nc_size > 0)
{
- if ( ( (size_t) (retVal->nonce_nc_size * sizeof(struct MHD_NonceNc))) /
- sizeof(struct MHD_NonceNc) != retVal->nonce_nc_size)
+ if ( ( (size_t) (daemon->nonce_nc_size * sizeof(struct MHD_NonceNc))) /
+ sizeof(struct MHD_NonceNc) != daemon->nonce_nc_size)
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Specified value for NC_SIZE too large\n");
#endif
#if HTTPS_SUPPORT
if (options & MHD_USE_SSL)
- gnutls_priority_deinit (retVal->priority_cache);
+ gnutls_priority_deinit (daemon->priority_cache);
#endif
- free (retVal);
+ free (daemon);
return NULL;
}
- retVal->nnc = malloc (retVal->nonce_nc_size * sizeof(struct
MHD_NonceNc));
- if (NULL == retVal->nnc)
+ daemon->nnc = malloc (daemon->nonce_nc_size * sizeof(struct
MHD_NonceNc));
+ if (NULL == daemon->nnc)
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Failed to allocate memory for nonce-nc map: %s\n",
STRERROR (errno));
#endif
#if HTTPS_SUPPORT
if (options & MHD_USE_SSL)
- gnutls_priority_deinit (retVal->priority_cache);
+ gnutls_priority_deinit (daemon->priority_cache);
#endif
- free (retVal);
+ free (daemon);
return NULL;
}
}
- if (0 != pthread_mutex_init (&retVal->nnc_lock, NULL))
+ if (0 != pthread_mutex_init (&daemon->nnc_lock, NULL))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"MHD failed to initialize nonce-nc mutex\n");
#endif
#if HTTPS_SUPPORT
if (options & MHD_USE_SSL)
- gnutls_priority_deinit (retVal->priority_cache);
+ gnutls_priority_deinit (daemon->priority_cache);
#endif
- free (retVal->nnc);
- free (retVal);
+ free (daemon->nnc);
+ free (daemon);
return NULL;
}
#endif
/* Thread pooling currently works only with internal select thread model */
if ( (0 == (options & MHD_USE_SELECT_INTERNALLY)) &&
- (retVal->worker_pool_size > 0) )
+ (daemon->worker_pool_size > 0) )
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"MHD thread pooling only works with
MHD_USE_SELECT_INTERNALLY\n");
#endif
goto free_and_fail;
@@ -2280,14 +2274,14 @@
if (0 != (options & (MHD_USE_SELECT_INTERNALLY |
MHD_USE_THREAD_PER_CONNECTION)))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Threaded operations are not supported on Symbian.\n");
#endif
goto free_and_fail;
}
#endif
- if ( (-1 == retVal->socket_fd) &&
- (0 == (retVal->options & MHD_USE_NO_LISTEN_SOCKET)) )
+ if ( (-1 == daemon->socket_fd) &&
+ (0 == (daemon->options & MHD_USE_NO_LISTEN_SOCKET)) )
{
/* try to open listen socket */
if ((options & MHD_USE_IPv6) != 0)
@@ -2296,7 +2290,7 @@
#else
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"AF_INET6 not supported\n");
#endif
goto free_and_fail;
@@ -2304,11 +2298,11 @@
#endif
else
socket_fd = create_socket (PF_INET, SOCK_STREAM, 0);
- if (socket_fd == -1)
+ if (-1 == socket_fd)
{
#if HAVE_MESSAGES
- if ((options & MHD_USE_DEBUG) != 0)
- MHD_DLOG (retVal,
+ if (0 != (options & MHD_USE_DEBUG))
+ MHD_DLOG (daemon,
"Call to socket failed: %s\n",
STRERROR (errno));
#endif
@@ -2320,7 +2314,7 @@
&on, sizeof (on)) < 0) && ((options & MHD_USE_DEBUG) !=
0))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"setsockopt failed: %s\n",
STRERROR (errno));
#endif
@@ -2328,7 +2322,7 @@
/* check for user supplied sockaddr */
#if HAVE_INET6
- if ((options & MHD_USE_IPv6) != 0)
+ if (0 != (options & MHD_USE_IPv6))
addrlen = sizeof (struct sockaddr_in6);
else
#endif
@@ -2336,7 +2330,7 @@
if (NULL == servaddr)
{
#if HAVE_INET6
- if ((options & MHD_USE_IPv6) != 0)
+ if (0 != (options & MHD_USE_IPv6))
{
memset (&servaddr6, 0, sizeof (struct sockaddr_in6));
servaddr6.sin6_family = AF_INET6;
@@ -2358,9 +2352,9 @@
servaddr = (struct sockaddr *) &servaddr4;
}
}
- retVal->socket_fd = socket_fd;
+ daemon->socket_fd = socket_fd;
- if ((options & MHD_USE_IPv6) != 0)
+ if (0 != (options & MHD_USE_IPv6))
{
#ifdef IPPROTO_IPV6
#ifdef IPV6_V6ONLY
@@ -2382,11 +2376,11 @@
#endif
#endif
}
- if (BIND (socket_fd, servaddr, addrlen) == -1)
+ if (-1 == BIND (socket_fd, servaddr, addrlen))
{
#if HAVE_MESSAGES
- if ((options & MHD_USE_DEBUG) != 0)
- MHD_DLOG (retVal,
+ if (0 != (options & MHD_USE_DEBUG))
+ MHD_DLOG (daemon,
"Failed to bind to port %u: %s\n",
(unsigned int) port,
STRERROR (errno));
@@ -2398,8 +2392,8 @@
if (LISTEN (socket_fd, 20) < 0)
{
#if HAVE_MESSAGES
- if ((options & MHD_USE_DEBUG) != 0)
- MHD_DLOG (retVal,
+ if (0 != (options & MHD_USE_DEBUG))
+ MHD_DLOG (daemon,
"Failed to listen for connections: %s\n",
STRERROR (errno));
#endif
@@ -2409,7 +2403,7 @@
}
else
{
- socket_fd = retVal->socket_fd;
+ socket_fd = daemon->socket_fd;
}
#ifndef WINDOWS
if ( (socket_fd >= FD_SETSIZE) &&
@@ -2417,7 +2411,7 @@
{
#if HAVE_MESSAGES
if ((options & MHD_USE_DEBUG) != 0)
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Socket descriptor larger than FD_SETSIZE: %d > %d\n",
socket_fd,
FD_SETSIZE);
@@ -2427,23 +2421,23 @@
}
#endif
- if (0 != pthread_mutex_init (&retVal->per_ip_connection_mutex, NULL))
+ if (0 != pthread_mutex_init (&daemon->per_ip_connection_mutex, NULL))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"MHD failed to initialize IP connection limit mutex\n");
#endif
if (-1 != socket_fd)
CLOSE (socket_fd);
goto free_and_fail;
}
- if (0 != pthread_mutex_init (&retVal->cleanup_connection_mutex, NULL))
+ if (0 != pthread_mutex_init (&daemon->cleanup_connection_mutex, NULL))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"MHD failed to initialize IP connection limit mutex\n");
#endif
- pthread_mutex_destroy (&retVal->cleanup_connection_mutex);
+ pthread_mutex_destroy (&daemon->cleanup_connection_mutex);
if (-1 != socket_fd)
CLOSE (socket_fd);
goto free_and_fail;
@@ -2451,39 +2445,39 @@
#if HTTPS_SUPPORT
/* initialize HTTPS daemon certificate aspects & send / recv functions */
- if ((0 != (options & MHD_USE_SSL)) && (0 != MHD_TLS_init (retVal)))
+ if ((0 != (options & MHD_USE_SSL)) && (0 != MHD_TLS_init (daemon)))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Failed to initialize TLS support\n");
#endif
if (-1 != socket_fd)
CLOSE (socket_fd);
- pthread_mutex_destroy (&retVal->cleanup_connection_mutex);
- pthread_mutex_destroy (&retVal->per_ip_connection_mutex);
+ pthread_mutex_destroy (&daemon->cleanup_connection_mutex);
+ pthread_mutex_destroy (&daemon->per_ip_connection_mutex);
goto free_and_fail;
}
#endif
if ( ( (0 != (options & MHD_USE_THREAD_PER_CONNECTION)) ||
( (0 != (options & MHD_USE_SELECT_INTERNALLY)) &&
- (0 == retVal->worker_pool_size)) ) &&
- (0 == (retVal->options & MHD_USE_NO_LISTEN_SOCKET)) &&
+ (0 == daemon->worker_pool_size)) ) &&
+ (0 == (daemon->options & MHD_USE_NO_LISTEN_SOCKET)) &&
(0 != (res_thread_create =
- create_thread (&retVal->pid, retVal, &MHD_select_thread,
retVal))))
+ create_thread (&daemon->pid, daemon, &MHD_select_thread,
daemon))))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Failed to create listen thread: %s\n",
STRERROR (res_thread_create));
#endif
- pthread_mutex_destroy (&retVal->cleanup_connection_mutex);
- pthread_mutex_destroy (&retVal->per_ip_connection_mutex);
+ pthread_mutex_destroy (&daemon->cleanup_connection_mutex);
+ pthread_mutex_destroy (&daemon->per_ip_connection_mutex);
if (-1 != socket_fd)
CLOSE (socket_fd);
goto free_and_fail;
}
- if ( (retVal->worker_pool_size > 0) &&
- (0 == (retVal->options & MHD_USE_NO_LISTEN_SOCKET)) )
+ if ( (daemon->worker_pool_size > 0) &&
+ (0 == (daemon->options & MHD_USE_NO_LISTEN_SOCKET)) )
{
#ifndef MINGW
int sk_flags;
@@ -2494,10 +2488,10 @@
/* Coarse-grained count of connections per thread (note error
* due to integer division). Also keep track of how many
* connections are leftover after an equal split. */
- unsigned int conns_per_thread = retVal->max_connections
- / retVal->worker_pool_size;
- unsigned int leftover_conns = retVal->max_connections
- % retVal->worker_pool_size;
+ unsigned int conns_per_thread = daemon->max_connections
+ / daemon->worker_pool_size;
+ unsigned int leftover_conns = daemon->max_connections
+ % daemon->worker_pool_size;
i = 0; /* we need this in case fcntl or malloc fails */
@@ -2513,8 +2507,8 @@
#else
sk_flags = 1;
#if HAVE_PLIBC_FD
- if (ioctlsocket (plibc_fd_get_handle (socket_fd), FIONBIO, &sk_flags) ==
- SOCKET_ERROR)
+ if (SOCKET_ERROR ==
+ ioctlsocket (plibc_fd_get_handle (socket_fd), FIONBIO, &sk_flags))
#else
if (ioctlsocket (socket_fd, FIONBIO, &sk_flags) == SOCKET_ERROR)
#endif // PLIBC_FD
@@ -2522,22 +2516,22 @@
#endif // MINGW
/* Allocate memory for pooled objects */
- retVal->worker_pool = malloc (sizeof (struct MHD_Daemon)
- * retVal->worker_pool_size);
- if (NULL == retVal->worker_pool)
+ daemon->worker_pool = malloc (sizeof (struct MHD_Daemon)
+ * daemon->worker_pool_size);
+ if (NULL == daemon->worker_pool)
goto thread_failed;
/* Start the workers in the pool */
- for (i = 0; i < retVal->worker_pool_size; ++i)
+ for (i = 0; i < daemon->worker_pool_size; ++i)
{
/* Create copy of the Daemon object for each worker */
- struct MHD_Daemon *d = &retVal->worker_pool[i];
- memcpy (d, retVal, sizeof (struct MHD_Daemon));
+ struct MHD_Daemon *d = &daemon->worker_pool[i];
+ memcpy (d, daemon, sizeof (struct MHD_Daemon));
/* Adjust pooling params for worker daemons; note that memcpy()
has already copied MHD_USE_SELECT_INTERNALLY thread model into
the worker threads. */
- d->master = retVal;
+ d->master = daemon;
d->worker_pool_size = 0;
d->worker_pool = NULL;
@@ -2549,10 +2543,10 @@
++d->max_connections;
/* Spawn the worker thread */
- if (0 != (res_thread_create = create_thread (&d->pid, retVal,
&MHD_select_thread, d)))
+ if (0 != (res_thread_create = create_thread (&d->pid, daemon,
&MHD_select_thread, d)))
{
#if HAVE_MESSAGES
- MHD_DLOG (retVal,
+ MHD_DLOG (daemon,
"Failed to create pool thread: %s\n",
STRERROR (res_thread_create));
#endif
@@ -2562,21 +2556,21 @@
}
}
}
- return retVal;
+ return daemon;
thread_failed:
/* If no worker threads created, then shut down normally. Calling
MHD_stop_daemon (as we do below) doesn't work here since it
assumes a 0-sized thread pool means we had been in the default
MHD_USE_SELECT_INTERNALLY mode. */
- if (i == 0)
+ if (0 == i)
{
if (-1 != socket_fd)
CLOSE (socket_fd);
- pthread_mutex_destroy (&retVal->cleanup_connection_mutex);
- pthread_mutex_destroy (&retVal->per_ip_connection_mutex);
- if (NULL != retVal->worker_pool)
- free (retVal->worker_pool);
+ pthread_mutex_destroy (&daemon->cleanup_connection_mutex);
+ pthread_mutex_destroy (&daemon->per_ip_connection_mutex);
+ if (NULL != daemon->worker_pool)
+ free (daemon->worker_pool);
goto free_and_fail;
}
@@ -2584,22 +2578,22 @@
as though we had fully initialized our daemon, but
with a smaller number of threads than had been
requested. */
- retVal->worker_pool_size = i - 1;
- MHD_stop_daemon (retVal);
+ daemon->worker_pool_size = i - 1;
+ MHD_stop_daemon (daemon);
return NULL;
free_and_fail:
- /* clean up basic memory state in 'retVal' and return NULL to
+ /* clean up basic memory state in 'daemon' and return NULL to
indicate failure */
#ifdef DAUTH_SUPPORT
- free (retVal->nnc);
- pthread_mutex_destroy (&retVal->nnc_lock);
+ free (daemon->nnc);
+ pthread_mutex_destroy (&daemon->nnc_lock);
#endif
#if HTTPS_SUPPORT
- if (options & MHD_USE_SSL)
- gnutls_priority_deinit (retVal->priority_cache);
+ if (0 != (options & MHD_USE_SSL))
+ gnutls_priority_deinit (daemon->priority_cache);
#endif
- free (retVal);
+ free (daemon);
return NULL;
}
@@ -2627,7 +2621,7 @@
#endif
abort();
}
- for (pos = daemon->connections_head; pos != NULL; pos = pos->next)
+ for (pos = daemon->connections_head; NULL != pos; pos = pos->next)
SHUTDOWN (pos->socket_fd,
(pos->read_closed == MHD_YES) ? SHUT_WR : SHUT_RDWR);
if (0 != pthread_mutex_unlock(&daemon->cleanup_connection_mutex))
@@ -2684,7 +2678,7 @@
unsigned int i;
int rc;
- if (daemon == NULL)
+ if (NULL == daemon)
return;
daemon->shutdown = MHD_YES;
fd = daemon->socket_fd;
@@ -2699,7 +2693,7 @@
daemon->worker_pool[i].socket_fd = -1;
}
}
- if (daemon->wpipe[1] != -1)
+ if (-1 != daemon->wpipe[1])
{
WRITE (daemon->wpipe[1], "e", 1);
}
Modified: libmicrohttpd/src/daemon/reason_phrase.c
===================================================================
--- libmicrohttpd/src/daemon/reason_phrase.c 2012-07-17 20:40:39 UTC (rev
22732)
+++ libmicrohttpd/src/daemon/reason_phrase.c 2012-07-17 21:52:26 UTC (rev
22733)
@@ -151,7 +151,9 @@
const char *
MHD_get_reason_phrase_for (unsigned int code)
{
- if ((code >= 100 && code < 600) && (reasons[code / 100].max > code % 100))
+ if ( (code >= 100) &&
+ (code < 600) &&
+ (reasons[code / 100].max > (code % 100)) )
return reasons[code / 100].data[code % 100];
return "Unknown";
}
Modified: libmicrohttpd/src/daemon/response.c
===================================================================
--- libmicrohttpd/src/daemon/response.c 2012-07-17 20:40:39 UTC (rev 22732)
+++ libmicrohttpd/src/daemon/response.c 2012-07-17 21:52:26 UTC (rev 22733)
@@ -45,28 +45,26 @@
{
struct MHD_HTTP_Header *hdr;
- if ((response == NULL) ||
- (header == NULL) ||
- (content == NULL) ||
- (strlen (header) == 0) ||
- (strlen (content) == 0) ||
- (NULL != strstr (header, "\t")) ||
- (NULL != strstr (header, "\r")) ||
- (NULL != strstr (header, "\n")) ||
- (NULL != strstr (content, "\t")) ||
- (NULL != strstr (content, "\r")) || (NULL != strstr (content, "\n")))
+ if ( (NULL == response) ||
+ (NULL == header) ||
+ (NULL == content) ||
+ (0 == strlen (header)) ||
+ (0 == strlen (content)) ||
+ (NULL != strstr (header, "\t")) ||
+ (NULL != strstr (header, "\r")) ||
+ (NULL != strstr (header, "\n")) ||
+ (NULL != strstr (content, "\t")) ||
+ (NULL != strstr (content, "\r")) ||
+ (NULL != strstr (content, "\n")) )
return MHD_NO;
- hdr = malloc (sizeof (struct MHD_HTTP_Header));
- if (hdr == NULL)
+ if (NULL == (hdr = malloc (sizeof (struct MHD_HTTP_Header))))
return MHD_NO;
- hdr->header = strdup (header);
- if (hdr->header == NULL)
+ if (NULL == (hdr->header = strdup (header)))
{
free (hdr);
return MHD_NO;
}
- hdr->value = strdup (content);
- if (hdr->value == NULL)
+ if (NULL == (hdr->value = strdup (content)))
{
free (hdr->header);
free (hdr);
@@ -132,7 +130,7 @@
struct MHD_HTTP_Header *pos;
struct MHD_HTTP_Header *prev;
- if ((header == NULL) || (content == NULL))
+ if ( (NULL == header) || (NULL == content) )
return MHD_NO;
prev = NULL;
pos = response->first_header;
@@ -143,7 +141,7 @@
{
free (pos->header);
free (pos->value);
- if (prev == NULL)
+ if (NULL == prev)
response->first_header = pos->next;
else
prev->next = pos->next;
@@ -171,15 +169,14 @@
{
struct MHD_HTTP_Header *pos;
int numHeaders = 0;
- pos = response->first_header;
- while (pos != NULL)
+
+ for (pos = response->first_header; NULL != pos; pos = pos->next)
{
numHeaders++;
- if ((iterator != NULL) &&
+ if ((NULL != iterator) &&
(MHD_YES != iterator (iterator_cls,
pos->kind, pos->header, pos->value)))
break;
- pos = pos->next;
}
return numHeaders;
}
@@ -196,15 +193,11 @@
{
struct MHD_HTTP_Header *pos;
- if (key == NULL)
+ if (NULL == key)
return NULL;
- pos = response->first_header;
- while (pos != NULL)
- {
- if (0 == strcmp (key, pos->header))
- return pos->value;
- pos = pos->next;
- }
+ for (pos = response->first_header; NULL != pos; pos = pos->next)
+ if (0 == strcmp (key, pos->header))
+ return pos->value;
return NULL;
}
@@ -231,28 +224,27 @@
void *crc_cls,
MHD_ContentReaderFreeCallback crfc)
{
- struct MHD_Response *retVal;
+ struct MHD_Response *response;
- if ((crc == NULL) || (block_size == 0))
+ if ((NULL == crc) || (0 == block_size))
return NULL;
- retVal = malloc (sizeof (struct MHD_Response) + block_size);
- if (retVal == NULL)
+ if (NULL == (response = malloc (sizeof (struct MHD_Response) + block_size)))
return NULL;
- memset (retVal, 0, sizeof (struct MHD_Response));
- retVal->fd = -1;
- retVal->data = (void *) &retVal[1];
- retVal->data_buffer_size = block_size;
- if (pthread_mutex_init (&retVal->mutex, NULL) != 0)
+ memset (response, 0, sizeof (struct MHD_Response));
+ response->fd = -1;
+ response->data = (void *) &response[1];
+ response->data_buffer_size = block_size;
+ if (0 != pthread_mutex_init (&response->mutex, NULL))
{
- free (retVal);
+ free (response);
return NULL;
}
- retVal->crc = crc;
- retVal->crfc = crfc;
- retVal->crc_cls = crc_cls;
- retVal->reference_count = 1;
- retVal->total_size = size;
- return retVal;
+ response->crc = crc;
+ response->crfc = crfc;
+ response->crc_cls = crc_cls;
+ response->reference_count = 1;
+ response->total_size = size;
+ return response;
}
@@ -274,7 +266,7 @@
(void) lseek (response->fd, pos + response->fd_off, SEEK_SET);
n = read (response->fd, buf, max);
- if (n == 0)
+ if (0 == n)
return MHD_CONTENT_READER_END_OF_STREAM;
if (n < 0)
return MHD_CONTENT_READER_END_WITH_ERROR;
@@ -292,6 +284,7 @@
free_callback (void *cls)
{
struct MHD_Response *response = cls;
+
(void) close (response->fd);
response->fd = -1;
}
@@ -310,24 +303,22 @@
int fd,
off_t offset)
{
- struct MHD_Response *ret;
+ struct MHD_Response *response;
- ret = MHD_create_response_from_callback (size,
- 4 * 1024,
- &file_reader,
- NULL,
- &free_callback);
- if (ret == NULL)
+ response = MHD_create_response_from_callback (size,
+ 4 * 1024,
+ &file_reader,
+ NULL,
+ &free_callback);
+ if (NULL == response)
return NULL;
- ret->fd = fd;
- ret->fd_off = offset;
- ret->crc_cls = ret;
- return ret;
+ response->fd = fd;
+ response->fd_off = offset;
+ response->crc_cls = response;
+ return response;
}
-
-
/**
* Create a response object. The response object can be extended with
* header information and then be used any number of times.
@@ -360,42 +351,40 @@
MHD_create_response_from_data (size_t size,
void *data, int must_free, int must_copy)
{
- struct MHD_Response *retVal;
+ struct MHD_Response *response;
void *tmp;
- if ((data == NULL) && (size > 0))
+ if ((NULL == data) && (size > 0))
return NULL;
- retVal = malloc (sizeof (struct MHD_Response));
- if (retVal == NULL)
+ if (NULL == (response = malloc (sizeof (struct MHD_Response))))
return NULL;
- memset (retVal, 0, sizeof (struct MHD_Response));
- retVal->fd = -1;
- if (pthread_mutex_init (&retVal->mutex, NULL) != 0)
+ memset (response, 0, sizeof (struct MHD_Response));
+ response->fd = -1;
+ if (0 != pthread_mutex_init (&response->mutex, NULL))
{
- free (retVal);
+ free (response);
return NULL;
}
if ((must_copy) && (size > 0))
{
- tmp = malloc (size);
- if (tmp == NULL)
+ if (NULL == (tmp = malloc (size)))
{
- pthread_mutex_destroy (&retVal->mutex);
- free (retVal);
+ pthread_mutex_destroy (&response->mutex);
+ free (response);
return NULL;
}
memcpy (tmp, data, size);
must_free = MHD_YES;
data = tmp;
}
- retVal->crc = NULL;
- retVal->crfc = must_free ? &free : NULL;
- retVal->crc_cls = must_free ? data : NULL;
- retVal->reference_count = 1;
- retVal->total_size = size;
- retVal->data = data;
- retVal->data_size = size;
- return retVal;
+ response->crc = NULL;
+ response->crfc = must_free ? &free : NULL;
+ response->crc_cls = must_free ? data : NULL;
+ response->reference_count = 1;
+ response->total_size = size;
+ response->data = data;
+ response->data_size = size;
+ return response;
}
@@ -431,7 +420,7 @@
{
struct MHD_HTTP_Header *pos;
- if (response == NULL)
+ if (NULL == response)
return;
pthread_mutex_lock (&response->mutex);
if (0 != --(response->reference_count))
@@ -443,7 +432,7 @@
pthread_mutex_destroy (&response->mutex);
if (response->crfc != NULL)
response->crfc (response->crc_cls);
- while (response->first_header != NULL)
+ while (NULL != response->first_header)
{
pos = response->first_header;
response->first_header = pos->next;
Modified: libmicrohttpd/src/include/microhttpd.h
===================================================================
--- libmicrohttpd/src/include/microhttpd.h 2012-07-17 20:40:39 UTC (rev
22732)
+++ libmicrohttpd/src/include/microhttpd.h 2012-07-17 21:52:26 UTC (rev
22733)
@@ -1245,7 +1245,7 @@
*
* @param connection connection to get values from
* @param kind what kind of value are we looking for
- * @param key the header to look for
+ * @param key the header to look for, NULL to lookup 'trailing' value without
a key
* @return NULL if no such item was found
*/
const char *
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r22733 - in libmicrohttpd: . doc src/daemon src/include,
gnunet <=