1 files changed, 145 insertions, 158 deletions

diff --git a/src/daemon/session.c b/src/daemon/session.c
index c50af0ba..fa3864ca 100644
--- a/src/daemon/session.c
+++ b/src/daemon/session.c
@@ -26,17 +26,6 @@
  * @version 0.1.0
  */
 
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <netdb.h>
-#include <string.h>
-#include <unistd.h>
-#include <stdarg>
-#include <fcntl.h>
-#include <pthread.h>
-#include <netinet/in.h>
-
 #include "microhttpd.h"
 #include "session.h"
 #include "response.h"
@@ -55,7 +44,7 @@
 int
 MHD_get_session_values(struct MHD_Session * session,
 		       enum MHD_ValueKind kind,
-		       MHD_KeyValueIterator * iterator,
+		       MHD_KeyValueIterator iterator,
 		       void * iterator_cls) {
   int ret;
   struct MHD_HTTP_Header * pos;
@@ -95,7 +84,6 @@ MHD_lookup_session_value(struct MHD_Session * session,
 
   if (session == NULL) 
     return NULL;
-  ret = 0;
   pos = session->headers_received;
   while (pos != NULL) {
     if ( (0 != (pos->kind & kind)) &&
@@ -145,7 +133,8 @@ MHD_session_get_fdset(struct MHD_Session * session,
 		      int * max_fd) {
   /* FIXME: need to be VERY careful here
      determining when the socket is ready for
-     reading/writing; plenty of cases to handle! */
+     reading/writing; plenty of cases to handle!
+     (the current code is one big bug) */
   FD_SET(session->socket_fd, read_fd_set);
   FD_SET(session->socket_fd, write_fd_set);
   if (session->socket_fd > *max_fd)
@@ -165,6 +154,7 @@ MHD_session_get_fdset(struct MHD_Session * session,
  */
 static void
 MHD_parse_URL(struct MHD_Session * session) {
+#if 0
 	char * working;
 	int pos,i;
 
@@ -179,10 +169,10 @@ MHD_parse_URL(struct MHD_Session * session) {
 			pos = 0;
 
 	session->documentName = session->headers[0]->value+pos;
+#endif
 }
 
 
-
 /**
  * This function is designed to parse the input buffer of a given session.
  *
@@ -195,6 +185,7 @@ 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";
 
@@ -249,8 +240,7 @@ MHD_parse_session_headers(struct MHD_Session * session) {
 		session->headers[session->firstFreeHeader++] = newHeader;
 		curTok = strtok_r(NULL, crlf, &saveptr);
 	}	
-
-	return numBytes;
+#endif
 }
 
 
@@ -269,7 +259,7 @@ MHD_find_access_handler(struct MHD_Session * session) {
  * (multithreaded, external select, internal select) call this function
  * to handle reads. 
  */
-static int
+int
 MHD_session_handle_read(struct MHD_Session * session) {
   int bytes_read;
   void * tmp;
@@ -322,8 +312,8 @@ MHD_session_handle_read(struct MHD_Session * session) {
       return MHD_NO;
     }
     /* dh left "processed" bytes in buffer for next time... */
-    memmove(session->readBuffer,
-	    &session->readBuffer[session->readLoc - processed],
+    memmove(session->read_buffer,
+	    &session->read_buffer[session->readLoc - processed],
 	    processed);
     session->readLoc = processed;
     session->uploadSize -= processed;
@@ -332,157 +322,154 @@ MHD_session_handle_read(struct MHD_Session * session) {
   return MHD_YES;
 }
 
+/**
+ * Allocate the session'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) {
+  size_t size;
+  size_t off;
+  struct MHD_HTTP_Header * pos;
+  char code[32];
+  char * data;
+
+  sprintf(code,
+	  "HTTP/1.1 %u\r\n", 
+	  session->responseCode);
+  off = strlen(code);
+  /* estimate size */
+  size = off + 2; /* extra \r\n at the end */
+  pos = session->response->first_header;
+  while (pos != NULL) {
+    size += strlen(pos->header) + strlen(pos->value) + 4; /* colon, space, linefeeds */
+    pos = pos->next;
+  }
+  /* produce data */
+  data = malloc(size);
+  memcpy(data,
+	 code,
+	 off);
+  pos = session->response->first_header;
+  while (pos != NULL) {
+    sprintf(&data[off],
+	    "%s: %s\r\n",
+	    pos->header,
+	    pos->value);
+    off += strlen(pos->header) + strlen(pos->value) + 4;
+    pos = pos->next;
+  }
+  if (off != size) 
+    abort();
+  session->write_buffer = data;
+  session->write_buffer_size = size;  
+}
 
 /**
- * This function was created to handle writes to sockets when it has been
- * determined that the socket can be written to. If there is no data
- * to be written, however, the function call does nothing. All implementations
- * (multithreaded, external select, internal select) call this function
+ * 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
  */
 int
 MHD_session_handle_write(struct MHD_Session * session) {
   struct MHD_Response * response;
-  int i;
-  char * buffer[2048];
-  char * responseMessage;
-  int numBytesInMessage;
+  int ret;
 
   response = session->response;
   if(response == NULL) {
     /* FIXME: LOG: why are we here? */
     return MHD_NO;
   }
-  numBytesInMessage = 25;
-  responseMessage = malloc(25);
-
-	pthread_mutex_lock(&response->mutex);	
-
-	if(!response->headersSent) {
-		sprintf(responseMessage, "HTTP/1.1 %i Go to hell!\r\n", response->responseCode);
-		fprintf(stderr, "%s\n", responseMessage);
-		if(send(session->socket_fd, responseMessage, strlen(responseMessage), 0) != strlen(responseMessage)) {
-			fprintf(stderr, "Error! could not send an entire header in one call to send! unable to handle this case as of this time.\n");
-			pthread_mutex_unlock(&response->mutex);
-			return MHD_NO;
-		}
-
-		for(i = 0; i < MHD_MAX_HEADERS; i++) {
-			if(response->headers[i] == NULL)
-				continue;
-
-			if(strlen(response->headers[i]->header) + strlen(response->headers[i]->value) + 5 > numBytesInMessage) {
-				free(responseMessage);
-				responseMessage = malloc(strlen(response->headers[i]->header) + strlen(response->headers[i]->value) + 5);
-				if(responseMessage == NULL) {
-					 if(daemon->options & MHD_USE_DEBUG)
-				       fprintf(stderr, "Error allocating memory!\n");
-	    			 pthread_mutex_unlock(&response->mutex);
-				    return MHD_NO;
-				}				
-				numBytesInMessage = strlen(response->headers[i]->header) + strlen(response->headers[i]->value) + 5;
-			}
-			sprintf(responseMessage, "%s: %s\r\n", response->headers[i]->header, response->headers[i]->value);
-			fprintf(stderr, "%s\n", responseMessage);
-			if(send(session->socket_fd, responseMessage, strlen(responseMessage), 0) != strlen(responseMessage)) {
-				fprintf(stderr, "Error! could not send an entire header in one call to send! unable to handle this case as of this time.\n");
-				pthread_mutex_unlock(&response->mutex);
-				return MHD_NO;
-			}
-		}
-		
-		response->headersSent = 1;
-	}
-
-	if(response->data != NULL) {
-		if(response->bytesSentSoFar == 0) {
-			if(numBytesInMessage < 32) {
-				free(responseMessage);
-				responseMessage = malloc(32);	
-				if(responseMessage == NULL) {
-					 if(daemon->options & MHD_USE_DEBUG)
-				       fprintf(stderr, "Error allocating memory!\n");
-	    			 pthread_mutex_unlock(&response->mutex);
-				    return MHD_NO;
-				}					
-			}
-			sprintf(responseMessage, "Content-length: %llu\r\n\r\n", (unsigned long long)response->size);
-			fprintf(stderr, "%s\n", responseMessage);
-			if(send(session->socket_fd, responseMessage, strlen(responseMessage),0)!= strlen(responseMessage)) {
-				fprintf(stderr, "Error! could not send an entire header in one call to send! unable to handle this case as of this time.\n");
-				pthread_mutex_unlock(&response->mutex);
-				return MHD_NO;
-			}			
-		}
-		
-		i = send(session->socket_fd, response->data+response->bytesSentSoFar, response->size-response->bytesSentSoFar,0);
-		response->bytesSentSoFar += i;
-
-		fprintf(stderr, "Sent %i bytes of data\nTotal to send is %llu bytes\n", i, (unsigned long long)response->size);
-
-		if(response->bytesSentSoFar == response->size) {
-			session->currentResponses[session->currentResponse] = NULL;
-			session->currentResponse = (session->currentResponse + 1) % MHD_MAX_RESPONSE;
-			response->currentSession = NULL;		
-
-			if(response->freeWhenFinished) {
-				pthread_mutex_unlock(&response->mutex);				
-				MHD_destroy_response(response); 
-			}
-			/*THIS NEEDS TO BE HANDLED ANOTHER WAY!!! TIMEOUT, ect..., as of now this is the only way to get test case to work
-			 * since client never disconnects on their own!
-			 */
-			if(session->currentResponses[session->currentResponse] == NULL) {
-				MHD_destroy_session(session);
-				daemon->connections[connection_id] = NULL;
-				return MHD_NO;
-			}						
-		}
-	} else {
-		if(response->crc == NULL) {
-			pthread_mutex_unlock(&response->mutex);
-			return MHD_NO;
-		}
-
-		if(response->bytesSentSoFar == 0) {
-			if(send(session->socket_fd, "\r\n", response->size,0) != 2) {
-				fprintf(stderr, "Error! could not send an entire header in one call to send! unable to handle this case as of this time.\n");
-				pthread_mutex_unlock(&response->mutex);
-				return MHD_NO;
-			}					
-		}
-		memset(buffer, 0, 2048);
-
-		i = response->crc(response->crc_cls, response->bytesSentSoFar, (char *)buffer, 2048);
-
-		if(i == -1) {
-			pthread_mutex_unlock(&response->mutex);
-				
-			session->currentResponses[session->currentResponse] = NULL;
-			session->currentResponse = (session->currentResponse + 1) % MHD_MAX_RESPONSE;		
-			response->currentSession = NULL;			
-
-			if(response->freeWhenFinished) {
-				pthread_mutex_unlock(&response->mutex);
-				MHD_destroy_response(response);
-			}
-			/*THIS NEEDS TO BE HANDLED ANOTHER WAY!!! TIMEOUT, ect..., as of now this is the only way to get test case to work
-			 * since client never disconnects on their own!
-			 */
-			if(session->currentResponses[session->currentResponse] == NULL) {
-				MHD_destroy_session(session);
-				daemon->connections[connection_id] = NULL;
-				return MHD_NO;
-			}
-
-		} else {
-			i = send(session->socket_fd, buffer, i,0);
-			response->bytesSentSoFar += i;				
-		}
-	}
-	pthread_mutex_unlock(&response->mutex);	
-	return MHD_YES;	
+  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,
+	       0);
+    if (ret < 0) {
+      if (errno == EINTR)
+	return MHD_YES;
+      /* FIXME: log error */
+      close(session->socket_fd);
+      session->socket_fd = -1;
+      return MHD_NO;
+    }
+    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;
+    }
+    return MHD_YES;
+  }
+  if (response->total_size <= session->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) ) {
+    if (response->data_size == 0) {
+      if (response->data != NULL)
+	free(response->data);
+      response->data = malloc(MHD_MAX_BUF_SIZE);
+      response->data_size = MHD_MAX_BUF_SIZE;
+    }
+    ret = response->crc(response->crc_cls,
+			session->messagePos,
+			response->data,
+			MAX(MHD_MAX_BUF_SIZE,
+			    response->data_size - session->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;
+      return MHD_YES;
+    }
+    response->data_start = session->messagePos;
+    response->data_size = ret;
+    if (ret == 0)
+      return MHD_YES; /* or NO? */
+  }
+  
+  /* transmit */
+  ret = send(session->socket_fd, 
+	     &response->data[session->messagePos - response->data_start],
+	     response->data_size - (session->messagePos - response->data_start),
+	     0);
+  if (response->crc != NULL)
+    pthread_mutex_unlock(&response->mutex);    
+  if (ret == -1) {
+    if (errno == EINTR)
+      return MHD_YES;
+    /* FIXME: log */
+    return MHD_NO;
+  }
+  session->messagePos += ret;
+  if (session->messagePos == response->data_size) {
+    /* reset session, wait for next request! */
+    MHD_destroy_response(response);
+    session->responseCode = 0;
+    session->response = NULL;
+    session->headersReceived = 0;
+    session->headersSent = 0;
+    session->bodyReceived = 0;
+    session->messagePos = 0;
+    free(session->write_buffer);
+    session->write_buffer = NULL;
+    session->write_buffer_size = 0;
+  }
+  return MHD_YES;
 }
 
-
+/* end of session.c */