making it compile

3 files changed, 133 insertions, 82 deletions

diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 0ebf21d0..4b743aad 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -294,6 +294,15 @@ MHD_cleanup_sessions(struct MHD_Daemon * daemon) {
       else
         prev->next = pos->next;
       free(pos->addr);
+      if (pos->url != NULL)
+        free(pos->url);
+      if (pos->method != NULL)
+        free(pos->method);
+      if (pos->write_buffer != NULL)
+        free(pos->write_buffer);
+      if (pos->read_buffer != NULL)
+        free(pos->read_buffer);
+      /* FIXME: free headers_received here! */
       /* FIXME: more to free here! */
       free(pos);
     }
diff --git a/src/daemon/internal.h b/src/daemon/internal.h
index 61653d8e..4beff728 100644
--- a/src/daemon/internal.h
+++ b/src/daemon/internal.h
@@ -150,8 +150,14 @@ struct MHD_Session {
   
   struct MHD_Response * response;
 
+  /**
+   * Request method.  Should be GET/POST/etc.
+   */
   char * method;
 
+  /**
+   * Requested URL (everything after "GET" only).
+   */
   char * url;
 
   /**
diff --git a/src/daemon/session.c b/src/daemon/session.c
index fa3864ca..a719c51a 100644
--- a/src/daemon/session.c
+++ b/src/daemon/session.c
@@ -142,37 +142,65 @@ MHD_session_get_fdset(struct MHD_Session * session,
   return MHD_YES;
 }
 
-
-
-/* FIXME: implement/fix code below this line! */
-
-
 /**
- * This function needs to do a lot more (i.e. break up get arguments)
- * but for now just seperates the prefix of the url from the document
- * portion.
+ * Parse a single line of the HTTP header.  Remove it
+ * from the read buffer.  If the current line does not
+ * fit, consider growing the buffer.  If the line is
+ * far too long, close the connection.  If no line is
+ * found (incomplete, buffer too small, line too long),
+ * return NULL.  Otherwise return a copy of the line.
  */
-static void
-MHD_parse_URL(struct MHD_Session * session) {
-#if 0
-        char * working;
-        int pos,i;
-
-        working = session->headers[0]->value;
-
-        pos = 0;
-        for(i = 0; i < strlen(working); i++) {
-                if(working[i] == '/')
-                        pos = i+1;
-        }
-        if(pos >= strlen(working))
-                        pos = 0;
-
-        session->documentName = session->headers[0]->value+pos;
-#endif
+static char * 
+MHD_get_next_header_line(struct MHD_Session * session) {
+  char * rbuf;
+  size_t pos;
+  size_t start;
+
+  start = 0;
+  pos = 0;
+  rbuf = session->read_buffer;
+  while ( (pos < session->readLoc - 1) &&
+          (rbuf[pos] != '\r') &&
+          (rbuf[pos] != '\n') )
+    pos++;
+  if (pos == session->readLoc) {
+    /* not found, consider growing... */
+    if (session->readLoc == session->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);
+        memcpy(rbuf,
+               session->read_buffer,
+               session->readLoc);
+        free(session->read_buffer);
+        session->read_buffer = rbuf;
+        session->read_buffer_size *= 2;
+      } else {
+        /* die, header far too long to be reasonable */
+        /* FIXME: log */
+        close(session->socket_fd);
+        session->socket_fd = -1;
+      }
+    }
+    return NULL;
+  }
+  /* found, check if we have proper CRLF */
+  rbuf = malloc(pos);
+  memcpy(rbuf,
+         session->read_buffer,
+         pos-1);
+  rbuf[pos-1] = '\0';
+  if ( (rbuf[pos] == '\r') &&
+       (rbuf[pos+1] == '\n') )
+    pos++; /* skip both r and n */
+  pos++; 
+  memmove(session->read_buffer,
+          &session->read_buffer[pos],
+          session->readLoc - pos);
+  session->readLoc -= pos;
+  return rbuf;
 }
 
-
 /**
  * This function is designed to parse the input buffer of a given session.
  *
@@ -185,62 +213,66 @@ MHD_parse_URL(struct MHD_Session * session) {
  */
 static void
 MHD_parse_session_headers(struct MHD_Session * session) {
-#if 0
-  const char * crlfcrlf = "\r\n\r\n";
-  const char * crlf = "\r\n";
-
-        char * saveptr;
-        char * saveptr1;
-
-        struct MHD_HTTP_Header * newHeader;
-        char * curTok;
-   char * curTok1;
+  char * line;
+  char * colon;
+  char * uri;
+  char * httpType;
+  struct MHD_HTTP_Header * hdr;
 
-        int numBytes;
-
-        curTok = strstr(session->inbuf, crlfcrlf);
-
-        if(curTok == NULL) {
-                return -1;
-        } 
-
-        memset(curTok+2, 0, 2);
-
-        numBytes = strlen(session->inbuf) + 2;
-
-        curTok = strtok_r(session->inbuf, crlf, &saveptr);
-
-        session->requestType = strtok_r(curTok, " ", &saveptr1);
-        
-        newHeader = (struct MHD_HTTP_Header *)malloc(sizeof(struct MHD_HTTP_Header));
-        if(newHeader == NULL) {
-                if(session->daemon->options & MHD_USE_DEBUG)
-                        fprintf(stderr, "Error allocating memory!\n");
-                return -1;
-        }               
-        newHeader->kind = MHD_GET_ARGUMENT_KIND;
-        newHeader->header = session->requestType;
-        newHeader->value = strtok_r(NULL, " ", &saveptr1);
-
-        session->headers[session->firstFreeHeader++] = newHeader;
-
-        curTok = strtok_r(NULL, crlf, &saveptr);
-        while(curTok != NULL && session->firstFreeHeader < MHD_MAX_HEADERS) {
-                curTok1 = strtok_r(curTok, ":", &saveptr1);
-                newHeader = (struct MHD_HTTP_Header *)malloc(sizeof(struct MHD_HTTP_Header));
-                if(newHeader == NULL) {
-                        if(session->daemon->options & MHD_USE_DEBUG)
-                                fprintf(stderr, "Error allocating memory!\n");
-                        return -1;
-                }                       
-                newHeader->header = curTok1;
-                newHeader->value = curTok + strlen(curTok1) + 2;
-                //For now, everything is a get!
-                newHeader->kind = MHD_GET_ARGUMENT_KIND;
-                session->headers[session->firstFreeHeader++] = newHeader;
-                curTok = strtok_r(NULL, crlf, &saveptr);
-        }       
-#endif
+  if (session->bodyReceived == 1)
+    abort();
+  while (NULL != (line = MHD_get_next_header_line(session))) {    
+    if (session->url == NULL) {
+      /* line must be request line */
+      uri = strstr(line, " ");
+      if (uri == NULL)
+        goto DIE;
+      uri[0] = '\0';
+      session->method = strdup(line);
+      uri++;
+      httpType = strstr(uri, " ");
+      if (httpType != NULL)
+        httpType[0] = '\0';
+      session->url = strdup(uri);
+      /* do we want to do anything with httpType? */
+      free(line);
+      continue;
+    }
+    /* check if this is the end of the header */
+    if (strlen(line) == 0) {
+      /* end of header */
+      session->headersReceived = 1;
+      /* FIXME: check with methods may have a body,
+         check headers to find out upload size */
+      session->uploadSize = 0;
+      session->bodyReceived = 1;
+      free(line);
+      break; 
+    }
+    /* ok, line should be normal header line, find colon */
+    colon = strstr(line, ": ");
+    if (colon == NULL) {
+      /* error in header line, die hard */
+      /* FIXME: log */
+      goto DIE;
+    }
+    /* zero-terminate header */
+    colon[0] = '\0';
+    colon += 2; /* advance to value */
+    hdr = malloc(sizeof(struct MHD_HTTP_Header));
+    hdr->next = session->headers_received;
+    hdr->header = line;
+    hdr->value = strdup(colon);
+    hdr->kind = MHD_HEADER_KIND;
+    session->headers_received = hdr;
+  }
+  if (session->bodyReceived == 0)
+    return;
+  /* FIXME: here: find cookie header and parse that! */
+  return;
+ DIE:
+  close(session->socket_fd);
+  session->socket_fd = -1;
 }
 
 
@@ -463,6 +495,10 @@ MHD_session_handle_write(struct MHD_Session * session) {
     session->headersSent = 0;
     session->bodyReceived = 0;
     session->messagePos = 0;
+    free(session->method);
+    session->method = NULL;
+    free(session->url);
+    session->url = NULL;
     free(session->write_buffer);
     session->write_buffer = NULL;
     session->write_buffer_size = 0;