1 files changed, 217 insertions, 217 deletions

diff --git a/src/daemon/session.c b/src/daemon/session.c
index 48f88868..6b82f9e7 100644
--- a/src/daemon/session.c
+++ b/src/daemon/session.c
@@ -19,14 +19,14 @@
 */
 
 /**
- * @file session.c
- * @brief  Methods for managing sessions
+ * @file connection.c
+ * @brief  Methods for managing connections
  * @author Daniel Pittman
  * @author Christian Grothoff
  */
 
 #include "internal.h"
-#include "session.h"
+#include "connection.h"
 #include "response.h"
 
 
@@ -39,17 +39,17 @@
  * @return number of entries iterated over
  */
 int
-MHD_get_session_values(struct MHD_Session * session,
+MHD_get_connection_values(struct MHD_Connection * connection,
                        enum MHD_ValueKind kind,
                        MHD_KeyValueIterator iterator,
                        void * iterator_cls) {
   int ret;
   struct MHD_HTTP_Header * pos;
 
-  if (session == NULL)
+  if (connection == NULL)
     return -1;
   ret = 0;
-  pos = session->headers_received;
+  pos = connection->headers_received;
   while (pos != NULL) {
     if (0 != (pos->kind & kind)) {
       ret++;
@@ -74,14 +74,14 @@ MHD_get_session_values(struct MHD_Session * session,
  * @return NULL if no such item was found
  */
 const char *
-MHD_lookup_session_value(struct MHD_Session * session,
+MHD_lookup_connection_value(struct MHD_Connection * connection,
                          enum MHD_ValueKind kind,
                          const char * key) {
   struct MHD_HTTP_Header * pos;
 
-  if (session == NULL)
+  if (connection == NULL)
     return NULL;
-  pos = session->headers_received;
+  pos = connection->headers_received;
   while (pos != NULL) {
     if ( (0 != (pos->kind & kind)) &&
          (0 == strcasecmp(key,
@@ -96,55 +96,55 @@ MHD_lookup_session_value(struct MHD_Session * session,
  * Queue a response to be transmitted to the client (as soon as
  * possible).
  *
- * @param session the session identifying the client
+ * @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
  */
 int
-MHD_queue_response(struct MHD_Session * session,
+MHD_queue_response(struct MHD_Connection * connection,
                    unsigned int status_code,
                    struct MHD_Response * response) {
-  if ( (session == NULL) ||
+  if ( (connection == NULL) ||
        (response == NULL) ||
-       (session->response != NULL) ||
-       (session->bodyReceived == 0) ||
-       (session->headersReceived == 0) )
+       (connection->response != NULL) ||
+       (connection->bodyReceived == 0) ||
+       (connection->headersReceived == 0) )
     return MHD_NO;      
   MHD_increment_response_rc(response);
-  session->response = response;
-  session->responseCode = status_code;
+  connection->response = response;
+  connection->responseCode = status_code;
   return MHD_YES;
 }
 
 
 /**
- * Obtain the select sets for this session
+ * Obtain the select sets for this connection
  *
  * @return MHD_YES on success
  */
 int
-MHD_session_get_fdset(struct MHD_Session * session,
+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) {
   int fd;
 
-  fd = session->socket_fd;
+  fd = connection->socket_fd;
   if (fd == -1)
     return MHD_YES;
-  if ( (session->read_close == 0) &&
-       ( (session->headersReceived == 0) ||
-         (session->readLoc < session->read_buffer_size) ) )
+  if ( (connection->read_close == 0) &&
+       ( (connection->headersReceived == 0) ||
+         (connection->readLoc < connection->read_buffer_size) ) )
     FD_SET(fd, read_fd_set);
-  if (session->response != NULL)
+  if (connection->response != NULL)
     FD_SET(fd, write_fd_set);
   if ( (fd > *max_fd) &&
-       ( (session->headersReceived == 0) ||
-         (session->readLoc < session->read_buffer_size) ||
-         (session->response != NULL) ) )
+       ( (connection->headersReceived == 0) ||
+         (connection->readLoc < connection->read_buffer_size) ||
+         (connection->response != NULL) ) )
     *max_fd = fd;
   return MHD_YES;
 }
@@ -158,39 +158,39 @@ MHD_session_get_fdset(struct MHD_Session * session,
  * return NULL.  Otherwise return a copy of the line.
  */
 static char *
-MHD_get_next_header_line(struct MHD_Session * session) {
+MHD_get_next_header_line(struct MHD_Connection * connection) {
   char * rbuf;
   size_t pos;
   size_t start;
 
-  if (session->readLoc == 0)
+  if (connection->readLoc == 0)
     return NULL;
   start = 0;
   pos = 0;
-  rbuf = session->read_buffer;
-  while ( (pos < session->readLoc - 1) &&
+  rbuf = connection->read_buffer;
+  while ( (pos < connection->readLoc - 1) &&
           (rbuf[pos] != '\r') &&
           (rbuf[pos] != '\n') )
     pos++;
-  if (pos == session->readLoc - 1) {
+  if (pos == connection->readLoc - 1) {
     /* not found, consider growing... */
-    if (session->readLoc == session->read_buffer_size) {
+    if (connection->readLoc == connection->read_buffer_size) {
       /* grow buffer to read larger header or die... */
-      if (session->read_buffer_size < 4 * MHD_MAX_BUF_SIZE) {
-        rbuf = malloc(session->read_buffer_size * 2);
+      if (connection->read_buffer_size < 4 * MHD_MAX_BUF_SIZE) {
+        rbuf = malloc(connection->read_buffer_size * 2);
         memcpy(rbuf,
-               session->read_buffer,
-               session->readLoc);
-        free(session->read_buffer);
-        session->read_buffer = rbuf;
-        session->read_buffer_size *= 2;
+               connection->read_buffer,
+               connection->readLoc);
+        free(connection->read_buffer);
+        connection->read_buffer = rbuf;
+        connection->read_buffer_size *= 2;
       } else {
         /* die, header far too long to be reasonable */
-        MHD_DLOG(session->daemon,
+        MHD_DLOG(connection->daemon,
                  "Received excessively long header line (>%u), closing connection.\n",
                  4 * MHD_MAX_BUF_SIZE);
-        CLOSE(session->socket_fd);
-        session->socket_fd = -1;
+        CLOSE(connection->socket_fd);
+        connection->socket_fd = -1;
       }
     }
     return NULL;
@@ -198,33 +198,33 @@ MHD_get_next_header_line(struct MHD_Session * session) {
   /* found, check if we have proper CRLF */
   rbuf = malloc(pos + 1);
   memcpy(rbuf,
-         session->read_buffer,
+         connection->read_buffer,
          pos);
   rbuf[pos] = '\0';
-  if ( (session->read_buffer[pos] == '\r') &&
-       (session->read_buffer[pos+1] == '\n') )
+  if ( (connection->read_buffer[pos] == '\r') &&
+       (connection->read_buffer[pos+1] == '\n') )
     pos++; /* skip both r and n */
   pos++;
-  memmove(session->read_buffer,
-          &session->read_buffer[pos],
-          session->readLoc - pos);
-  session->readLoc -= pos;
+  memmove(connection->read_buffer,
+          &connection->read_buffer[pos],
+          connection->readLoc - pos);
+  connection->readLoc -= pos;
   return rbuf;
 }
 
 static void
-MHD_session_add_header(struct MHD_Session * session,
+MHD_connection_add_header(struct MHD_Connection * connection,
                        const char * key,
                        const char * value,
                        enum MHD_ValueKind kind) {
   struct MHD_HTTP_Header * hdr;
 
   hdr = malloc(sizeof(struct MHD_HTTP_Header));
-  hdr->next = session->headers_received;
+  hdr->next = connection->headers_received;
   hdr->header = strdup(key);
   hdr->value = strdup(value);
   hdr->kind = kind;
-  session->headers_received = hdr;
+  connection->headers_received = hdr;
 }
 
 /**
@@ -254,7 +254,7 @@ MHD_http_unescape(char * val) {
 }
 
 static void
-MHD_parse_arguments(struct MHD_Session * session,
+MHD_parse_arguments(struct MHD_Connection * connection,
                     char * args) {
   char * equals;
   char * amper;
@@ -272,7 +272,7 @@ MHD_parse_arguments(struct MHD_Session * session,
     }
     MHD_http_unescape(args);
     MHD_http_unescape(equals);
-    MHD_session_add_header(session,
+    MHD_connection_add_header(connection,
                            args,
                            equals,
                            MHD_GET_ARGUMENT_KIND);
@@ -284,7 +284,7 @@ MHD_parse_arguments(struct MHD_Session * session,
  * Parse the cookie header (see RFC 2109).
  */
 static void
-MHD_parse_cookie_header(struct MHD_Session * session) {
+MHD_parse_cookie_header(struct MHD_Connection * connection) {
   const char * hdr;
   char * cpy;
   char * pos;
@@ -292,7 +292,7 @@ MHD_parse_cookie_header(struct MHD_Session * session) {
   char * equals;
   int quotes;
 
-  hdr = MHD_lookup_session_value(session,
+  hdr = MHD_lookup_connection_value(connection,
                                  MHD_HEADER_KIND,
                                  "Cookie");
   if (hdr == NULL)
@@ -327,7 +327,7 @@ MHD_parse_cookie_header(struct MHD_Session * session) {
       equals[strlen(equals)-1] = '\0';
       equals++;
     }
-    MHD_session_add_header(session,
+    MHD_connection_add_header(connection,
                            pos,
                            equals,
                            MHD_COOKIE_KIND);
@@ -338,7 +338,7 @@ MHD_parse_cookie_header(struct MHD_Session * session) {
 
 
 /**
- * This function is designed to parse the input buffer of a given session.
+ * This function is designed to parse the input buffer of a given connection.
  *
  * Once the header is complete, it should have set the
  * headers_received, url and method values and set
@@ -348,7 +348,7 @@ MHD_parse_cookie_header(struct MHD_Session * session) {
  * size of the body is unknown, it should be set to -1.
  */
 static void
-MHD_parse_session_headers(struct MHD_Session * session) {
+MHD_parse_connection_headers(struct MHD_Connection * connection) {
   char * last;
   char * line;
   char * colon;
@@ -359,10 +359,10 @@ MHD_parse_session_headers(struct MHD_Session * session) {
   const char * clen;
   unsigned long long cval;
 
-  if (session->bodyReceived == 1)
+  if (connection->bodyReceived == 1)
     abort();
   last = NULL;
-  while (NULL != (line = MHD_get_next_header_line(session))) {
+  while (NULL != (line = MHD_get_next_header_line(connection))) {
     if (last != NULL) {
       if ( (line[0] == ' ') ||
            (line[0] == '\t') ) {
@@ -373,11 +373,11 @@ MHD_parse_session_headers(struct MHD_Session * session) {
           free(line);
           free(last);
           last = NULL;
-          MHD_DLOG(session->daemon,
+          MHD_DLOG(connection->daemon,
                    "Received excessively long header line (>%u), closing connection.\n",
                    4 * MHD_MAX_BUF_SIZE);
-          CLOSE(session->socket_fd);
-          session->socket_fd = -1;
+          CLOSE(connection->socket_fd);
+          connection->socket_fd = -1;
           break;
         }
         tmp = malloc(strlen(line) + strlen(last) + 1);
@@ -392,7 +392,7 @@ MHD_parse_session_headers(struct MHD_Session * session) {
         free(line);
         continue; /* possibly more than 2 lines... */
       } else {
-        MHD_session_add_header(session,
+        MHD_connection_add_header(connection,
                                last,
                                colon,
                                MHD_HEADER_KIND);
@@ -400,13 +400,13 @@ MHD_parse_session_headers(struct MHD_Session * session) {
         last = NULL;    
       }
     }
-    if (session->url == NULL) {
+    if (connection->url == NULL) {
       /* line must be request line */
       uri = strstr(line, " ");
       if (uri == NULL)
         goto DIE;
       uri[0] = '\0';
-      session->method = strdup(line);
+      connection->method = strdup(line);
       uri++;
       httpType = strstr(uri, " ");
       if (httpType != NULL) {
@@ -417,14 +417,14 @@ MHD_parse_session_headers(struct MHD_Session * session) {
       if (args != NULL) {
         args[0] = '\0';
         args++;
-        MHD_parse_arguments(session,
+        MHD_parse_arguments(connection,
                             args);
       }
-      session->url = strdup(uri);
+      connection->url = strdup(uri);
       if (httpType == NULL)
-        session->version = strdup("");
+        connection->version = strdup("");
       else
-        session->version = strdup(httpType);
+        connection->version = strdup(httpType);
       free(line);
       continue;
     }
@@ -432,31 +432,31 @@ MHD_parse_session_headers(struct MHD_Session * session) {
     if (strlen(line) == 0) {
       free(line);
       /* end of header */
-      session->headersReceived = 1;
-      clen = MHD_lookup_session_value(session,
+      connection->headersReceived = 1;
+      clen = MHD_lookup_connection_value(connection,
                                       MHD_HEADER_KIND,
                                       "Content-Length");
       if (clen != NULL) {
         if (1 != sscanf(clen,
                         "%llu",
                         &cval)) {
-          MHD_DLOG(session->daemon,
+          MHD_DLOG(connection->daemon,
                    "Failed to parse Content-Length header `%s', closing connection.\n",
                    clen);
           goto DIE;
         }
-        session->uploadSize = cval;
-        session->bodyReceived = cval == 0 ? 1 : 0;
+        connection->uploadSize = cval;
+        connection->bodyReceived = cval == 0 ? 1 : 0;
       } else {
-        if (NULL == MHD_lookup_session_value(session,
+        if (NULL == MHD_lookup_connection_value(connection,
                                              MHD_HEADER_KIND,
                                              "Transfer-Encoding")) {
           /* this request does not have a body */
-          session->uploadSize = 0;
-          session->bodyReceived = 1;
+          connection->uploadSize = 0;
+          connection->bodyReceived = 1;
         } else {
-          session->uploadSize = -1; /* unknown size */
-          session->bodyReceived = 0;
+          connection->uploadSize = -1; /* unknown size */
+          connection->bodyReceived = 0;
         }
       }
       break;
@@ -465,7 +465,7 @@ MHD_parse_session_headers(struct MHD_Session * session) {
     colon = strstr(line, ":");
     if (colon == NULL) {
       /* error in header line, die hard */
-      MHD_DLOG(session->daemon,
+      MHD_DLOG(connection->daemon,
                "Received malformed line (no colon), closing connection.\n");
       goto DIE;
     }
@@ -476,24 +476,24 @@ MHD_parse_session_headers(struct MHD_Session * session) {
             ( (colon[0] == ' ') ||
               (colon[0] == '\t') ) )
       colon++;
-    /* we do the actual adding of the session
+    /* we do the actual adding of the connection
        header at the beginning of the while
        loop since we need to be able to inspect
        the *next* header line (in case it starts
        with a space...) */
   }
   if (last != NULL) {
-    MHD_session_add_header(session,
+    MHD_connection_add_header(connection,
                            last,
                            colon,
                            MHD_HEADER_KIND);
     free(last);
   }
-  MHD_parse_cookie_header(session);
+  MHD_parse_cookie_header(connection);
   return;
  DIE:
-  CLOSE(session->socket_fd);
-  session->socket_fd = -1;
+  CLOSE(connection->socket_fd);
+  connection->socket_fd = -1;
 }
 
 
@@ -501,61 +501,61 @@ MHD_parse_session_headers(struct MHD_Session * session) {
  * Find the handler responsible for this request.
  */
 static struct MHD_Access_Handler *
-MHD_find_access_handler(struct MHD_Session * session) {
+MHD_find_access_handler(struct MHD_Connection * connection) {
   struct MHD_Access_Handler * pos;
 
-  pos = session->daemon->handlers;
+  pos = connection->daemon->handlers;
   while (pos != NULL) {
-    if (0 == strcmp(session->url,
+    if (0 == strcmp(connection->url,
                     pos->uri_prefix))
       return pos;
     pos = pos->next;
   }
-  return &session->daemon->default_handler;
+  return &connection->daemon->default_handler;
 }
 
 /**
  * Call the handler of the application for this
- * session.
+ * connection.
  */
 void
-MHD_call_session_handler(struct MHD_Session * session) {
+MHD_call_connection_handler(struct MHD_Connection * connection) {
   struct MHD_Access_Handler * ah;
   unsigned int processed;
 
-  if (session->headersReceived == 0)
+  if (connection->headersReceived == 0)
     abort(); /* bad timing... */
-  ah = MHD_find_access_handler(session);
-  processed = session->readLoc;
+  ah = MHD_find_access_handler(connection);
+  processed = connection->readLoc;
   if (MHD_NO == ah->dh(ah->dh_cls,
-                       session,
-                       session->url,
-                       session->method,
-                       session->read_buffer,
+                       connection,
+                       connection->url,
+                       connection->method,
+                       connection->read_buffer,
                        &processed)) {
     /* serios internal error, close connection */
-    MHD_DLOG(session->daemon,
+    MHD_DLOG(connection->daemon,
              "Internal application error, closing connection.");
-    CLOSE(session->socket_fd);
-    session->socket_fd = -1;
+    CLOSE(connection->socket_fd);
+    connection->socket_fd = -1;
     return;
   }
   /* dh left "processed" bytes in buffer for next time... */
-  memmove(session->read_buffer,
-          &session->read_buffer[session->readLoc - processed],
+  memmove(connection->read_buffer,
+          &connection->read_buffer[connection->readLoc - processed],
           processed);
-  if (session->uploadSize != -1)
-    session->uploadSize -= (session->readLoc - processed);
-  session->readLoc = processed;
-  if ( (session->uploadSize == 0) ||
-       ( (session->readLoc == 0) &&
-         (session->uploadSize == -1) &&
-         (session->socket_fd == -1) ) ) {
-    session->bodyReceived = 1;
-    session->readLoc = 0;
-    session->read_buffer_size = 0;
-    free(session->read_buffer);
-    session->read_buffer = NULL;
+  if (connection->uploadSize != -1)
+    connection->uploadSize -= (connection->readLoc - processed);
+  connection->readLoc = processed;
+  if ( (connection->uploadSize == 0) ||
+       ( (connection->readLoc == 0) &&
+         (connection->uploadSize == -1) &&
+         (connection->socket_fd == -1) ) ) {
+    connection->bodyReceived = 1;
+    connection->readLoc = 0;
+    connection->read_buffer_size = 0;
+    free(connection->read_buffer);
+    connection->read_buffer = NULL;
   }
 }
 
@@ -567,54 +567,54 @@ MHD_call_session_handler(struct MHD_Session * session) {
  * to handle reads.
  */
 int
-MHD_session_handle_read(struct MHD_Session * session) {
+MHD_connection_handle_read(struct MHD_Connection * connection) {
   int bytes_read;
   void * tmp;
 
-  if ( (session->readLoc >= session->read_buffer_size) &&
-       (session->headersReceived == 0) ) {
+  if ( (connection->readLoc >= connection->read_buffer_size) &&
+       (connection->headersReceived == 0) ) {
     /* need to grow read buffer */
-    tmp = malloc(session->read_buffer_size * 2 + MHD_MAX_BUF_SIZE);
+    tmp = malloc(connection->read_buffer_size * 2 + MHD_MAX_BUF_SIZE);
     memcpy(tmp,
-           session->read_buffer,
-           session->read_buffer_size);
-    session->read_buffer_size = session->read_buffer_size * 2 + MHD_MAX_BUF_SIZE;
-    if (session->read_buffer != NULL)
-      free(session->read_buffer);
-    session->read_buffer = tmp;
+           connection->read_buffer,
+           connection->read_buffer_size);
+    connection->read_buffer_size = connection->read_buffer_size * 2 + MHD_MAX_BUF_SIZE;
+    if (connection->read_buffer != NULL)
+      free(connection->read_buffer);
+    connection->read_buffer = tmp;
   }
-  if (session->readLoc >= session->read_buffer_size) {
-    MHD_DLOG(session->daemon,
+  if (connection->readLoc >= connection->read_buffer_size) {
+    MHD_DLOG(connection->daemon,
              "Unexpected call to %s.\n",
              __FUNCTION__);
     return MHD_NO;
   }
-  bytes_read = RECV(session->socket_fd,
-                    &session->read_buffer[session->readLoc],
-                    session->read_buffer_size - session->readLoc,
+  bytes_read = RECV(connection->socket_fd,
+                    &connection->read_buffer[connection->readLoc],
+                    connection->read_buffer_size - connection->readLoc,
                     0);
   if (bytes_read < 0) {
     if (errno == EINTR)
       return MHD_NO;
-    MHD_DLOG(session->daemon,
+    MHD_DLOG(connection->daemon,
              "Failed to receive data: %s\n",
              STRERROR(errno));
-    CLOSE(session->socket_fd);
-    session->socket_fd = -1;
+    CLOSE(connection->socket_fd);
+    connection->socket_fd = -1;
     return MHD_YES;
   }
   if (bytes_read == 0) {
     /* other side closed connection */
-    if (session->readLoc > 0)
-      MHD_call_session_handler(session);
-    shutdown(session->socket_fd, SHUT_RD);
+    if (connection->readLoc > 0)
+      MHD_call_connection_handler(connection);
+    shutdown(connection->socket_fd, SHUT_RD);
     return MHD_YES;
   }
-  session->readLoc += bytes_read;
-  if (session->headersReceived == 0)
-    MHD_parse_session_headers(session);
-  if (session->headersReceived == 1)
-    MHD_call_session_handler(session);
+  connection->readLoc += bytes_read;
+  if (connection->headersReceived == 0)
+    MHD_parse_connection_headers(connection);
+  if (connection->headersReceived == 1)
+    MHD_call_connection_handler(connection);
   return MHD_YES;
 }
 
@@ -623,50 +623,50 @@ MHD_session_handle_read(struct MHD_Session * session) {
  * for http-compiliance.
  */
 static void
-MHD_add_extra_headers(struct MHD_Session * session) {
+MHD_add_extra_headers(struct MHD_Connection * connection) {
   const char * have;
   char buf[128];
 
-  if (session->response->total_size == -1) {
-    have = MHD_get_response_header(session->response,
+  if (connection->response->total_size == -1) {
+    have = MHD_get_response_header(connection->response,
                                    "Connection");
     if (have == NULL)
-      MHD_add_response_header(session->response,
+      MHD_add_response_header(connection->response,
                               "Connection",
                               "close");
-  } else if (NULL == MHD_get_response_header(session->response,
+  } else if (NULL == MHD_get_response_header(connection->response,
                                              "Content-Length")) {
     _REAL_SNPRINTF(buf,
              128,
              "%llu",
-             (unsigned long long) session->response->total_size);
-    MHD_add_response_header(session->response,
+             (unsigned long long) connection->response->total_size);
+    MHD_add_response_header(connection->response,
                             "Content-Length",
                             buf);
   }
 }
 
 /**
- * Allocate the session's write buffer and
+ * Allocate the connection's write buffer and
  * fill it with all of the headers from the
  * HTTPd's response.
  */
 static void
-MHD_build_header_response(struct MHD_Session * session) {
+MHD_build_header_response(struct MHD_Connection * connection) {
   size_t size;
   size_t off;
   struct MHD_HTTP_Header * pos;
   char code[32];
   char * data;
 
-  MHD_add_extra_headers(session);
+  MHD_add_extra_headers(connection);
   SPRINTF(code,
           "HTTP/1.1 %u\r\n",
-          session->responseCode);
+          connection->responseCode);
   off = strlen(code);
   /* estimate size */
   size = off + 2; /* extra \r\n at the end */
-  pos = session->response->first_header;
+  pos = connection->response->first_header;
   while (pos != NULL) {
     size += strlen(pos->header) + strlen(pos->value) + 4; /* colon, space, linefeeds */
     pos = pos->next;
@@ -676,7 +676,7 @@ MHD_build_header_response(struct MHD_Session * session) {
   memcpy(data,
          code,
          off);
-  pos = session->response->first_header;
+  pos = connection->response->first_header;
   while (pos != NULL) {
     SPRINTF(&data[off],
             "%s: %s\r\n",
@@ -690,8 +690,8 @@ MHD_build_header_response(struct MHD_Session * session) {
   off += 2;
   if (off != size)
     abort();
-  session->write_buffer = data;
-  session->write_buffer_size = size;
+  connection->write_buffer = data;
+  connection->write_buffer_size = size;
 }
 
 /**
@@ -701,53 +701,53 @@ MHD_build_header_response(struct MHD_Session * session) {
  * call this function
  */
 int
-MHD_session_handle_write(struct MHD_Session * session) {
+MHD_connection_handle_write(struct MHD_Connection * connection) {
   struct MHD_Response * response;
   int ret;
 
-  response = session->response;
+  response = connection->response;
   if(response == NULL) {
-    MHD_DLOG(session->daemon,
+    MHD_DLOG(connection->daemon,
              "Unexpected call to %s.\n",
              __FUNCTION__);
     return MHD_NO;
   }
-  if (! session->headersSent) {
-    if (session->write_buffer == NULL)
-      MHD_build_header_response(session);
-    ret = SEND(session->socket_fd,
-               &session->write_buffer[session->writeLoc],
-               session->write_buffer_size - session->writeLoc,
+  if (! connection->headersSent) {
+    if (connection->write_buffer == NULL)
+      MHD_build_header_response(connection);
+    ret = SEND(connection->socket_fd,
+               &connection->write_buffer[connection->writeLoc],
+               connection->write_buffer_size - connection->writeLoc,
                0);
     if (ret < 0) {
       if (errno == EINTR)
         return MHD_YES;
-      MHD_DLOG(session->daemon,
+      MHD_DLOG(connection->daemon,
                "Failed to send data: %s\n",
                STRERROR(errno));
-      CLOSE(session->socket_fd);
-      session->socket_fd = -1;
+      CLOSE(connection->socket_fd);
+      connection->socket_fd = -1;
       return MHD_YES;
     }
-    session->writeLoc += ret;
-    if (session->writeLoc == session->write_buffer_size) {
-      session->writeLoc = 0;
-      free(session->write_buffer);
-      session->write_buffer = NULL;
-      session->write_buffer_size = 0;
-      session->headersSent = 1;
+    connection->writeLoc += ret;
+    if (connection->writeLoc == connection->write_buffer_size) {
+      connection->writeLoc = 0;
+      free(connection->write_buffer);
+      connection->write_buffer = NULL;
+      connection->write_buffer_size = 0;
+      connection->headersSent = 1;
     }
     return MHD_YES;
   }
-  if (response->total_size <= session->messagePos)
+  if (response->total_size <= connection->messagePos)
     abort(); /* internal error */
   if (response->crc != NULL)
     pthread_mutex_lock(&response->mutex);
 
   /* prepare send buffer */
   if ( (response->data == NULL) ||
-       (response->data_start > session->messagePos) ||
-       (response->data_start + response->data_size < session->messagePos) ) {
+       (response->data_start > connection->messagePos) ||
+       (response->data_start + response->data_size < connection->messagePos) ) {
     if (response->data_size == 0) {
       if (response->data != NULL)
         free(response->data);
@@ -755,20 +755,20 @@ MHD_session_handle_write(struct MHD_Session * session) {
       response->data_size = MHD_MAX_BUF_SIZE;
     }
     ret = response->crc(response->crc_cls,
-                        session->messagePos,
+                        connection->messagePos,
                         response->data,
                         MAX(MHD_MAX_BUF_SIZE,
-                            response->data_size - session->messagePos));
+                            response->data_size - connection->messagePos));
     if (ret == -1) {
       /* end of message, signal other side by closing! */
-      response->data_size = session->messagePos;
-      CLOSE(session->socket_fd);
-      session->socket_fd = -1;
+      response->data_size = connection->messagePos;
+      CLOSE(connection->socket_fd);
+      connection->socket_fd = -1;
       if (response->crc != NULL)
         pthread_mutex_unlock(&response->mutex);
       return MHD_YES;
     }
-    response->data_start = session->messagePos;
+    response->data_start = connection->messagePos;
     response->data_size = ret;
     if (ret == 0) {
       if (response->crc != NULL)
@@ -778,54 +778,54 @@ MHD_session_handle_write(struct MHD_Session * session) {
   }
 
   /* transmit */
-  ret = SEND(session->socket_fd,
-             &response->data[session->messagePos - response->data_start],
-             response->data_size - (session->messagePos - response->data_start),
+  ret = SEND(connection->socket_fd,
+             &response->data[connection->messagePos - response->data_start],
+             response->data_size - (connection->messagePos - response->data_start),
              0);
   if (response->crc != NULL)
     pthread_mutex_unlock(&response->mutex);
   if (ret < 0) {
     if (errno == EINTR)
       return MHD_YES;
-    MHD_DLOG(session->daemon,
+    MHD_DLOG(connection->daemon,
              "Failed to send data: %s\n",
              STRERROR(errno));
-    CLOSE(session->socket_fd);
-    session->socket_fd = -1;
+    CLOSE(connection->socket_fd);
+    connection->socket_fd = -1;
     return MHD_YES;
   }
-  session->messagePos += ret;
-  if (session->messagePos > response->data_size)
+  connection->messagePos += ret;
+  if (connection->messagePos > response->data_size)
     abort(); /* internal error */
-  if (session->messagePos == response->data_size) {
-    if ( (session->bodyReceived == 0) ||
-         (session->headersReceived == 0) )
+  if (connection->messagePos == response->data_size) {
+    if ( (connection->bodyReceived == 0) ||
+         (connection->headersReceived == 0) )
       abort(); /* internal error */
     MHD_destroy_response(response);
-    session->responseCode = 0;
-    session->response = NULL;
-    session->headersReceived = 0;
-    session->headersSent = 0;
-    session->bodyReceived = 0;
-    session->messagePos = 0;
-    free(session->method);
-    session->method = NULL;
-    free(session->url);
-    session->url = NULL;
-    free(session->version);
-    session->version = NULL;
-    free(session->write_buffer);
-    session->write_buffer = NULL;
-    session->write_buffer_size = 0;
-    if (session->read_close != 0) {
+    connection->responseCode = 0;
+    connection->response = NULL;
+    connection->headersReceived = 0;
+    connection->headersSent = 0;
+    connection->bodyReceived = 0;
+    connection->messagePos = 0;
+    free(connection->method);
+    connection->method = NULL;
+    free(connection->url);
+    connection->url = NULL;
+    free(connection->version);
+    connection->version = NULL;
+    free(connection->write_buffer);
+    connection->write_buffer = NULL;
+    connection->write_buffer_size = 0;
+    if (connection->read_close != 0) {
       /* closed for reading => close for good! */
-      CLOSE(session->socket_fd);
-      session->socket_fd = -1;
+      CLOSE(connection->socket_fd);
+      connection->socket_fd = -1;
     }
   }
   return MHD_YES;
 }
 
-/* end of session.c */
+/* end of connection.c */