webroar 0.2.2 → 0.2.3

data/src/head/wr_request.c

@@ -1,5 +1,5 @@
 /* WebROaR - Ruby Application Server - http://webroar.in/
- * Copyright (C) 2009  WebROaR
+ * Copyright (C) 2009  Goonj LLC
  *
  * This file is part of WebROaR.
  *
@@ -20,6 +20,8 @@
 
 // Reqeust count
 static unsigned int wr_req_count = 0;
+#define HTTP_PREFIX "HTTP_"
+#define HTTP_PREFIX_LEN 5
 
 /** Private function */
 
@@ -37,7 +39,7 @@ static inline int wr_req_path_set(wr_req_t *req) {
 
   if(req->req_path.len) {
     // Request path is present (not absolute request uri)
-    if(scgi_request_header_get(req->scgi_req, "HTTP_HOST") == NULL) {
+    if(scgi_header_value_get(req->scgi, "HTTP_HOST") == NULL) {
       LOG_DEBUG(DEBUG,"Host is missing");
       req->resp_buf_len = sprintf(req->resp_buf,"%s","The request host is missing.");
       wr_req_invalid(req->conn, WR_HTTP_STATUS_400);
@@ -92,14 +94,20 @@ static inline int wr_req_path_set(wr_req_t *req) {
           return;
         }
       } else {
-        size_t host_len = req->req_uri.len - (ptr-req->req_uri.str);
+        host_len = req->req_uri.len - (ptr - req->req_uri.str);
       }
 
       // Replace 'Host' header if it exist or add new 'Host' header
       wr_str_t host;
       wr_string_new(host, ptr, host_len);
       LOG_DEBUG(DEBUG,"Host = %s", host.str);
-      scgi_request_header_set(req->scgi_req, "HTTP_HOST", host.str, 1);
+      // If HTTP_HOST is already present in the request, hide it by replacing with TTTP_HOST
+      scgi_header_t *header = scgi_header_get(req->scgi, "HTTP_HOST");
+      if(header){
+        req->scgi->header[header->field_offset] = 'T';
+      }
+      // Add new HTTP_HOST header
+      scgi_header_add(req->scgi, "HTTP_HOST", strlen("HTTP_HOST"), ptr, host_len);
     }
 
     // Drop host length from request uri lenght. Host is not passed to worker with request_uri
@@ -108,10 +116,11 @@ static inline int wr_req_path_set(wr_req_t *req) {
   return 0;
 }
 
+/*
 static inline void wr_req_header_add(wr_req_t * req) {
   int i = 5;
 
-  if(req->scgi_req->request_headers_len+1 > WR_MAX_REQ_HEADER_LEN) {
+  if(req->scgi->request_headers_len+1 > WR_MAX_REQ_HEADER_LEN) {
     req->resp_buf_len = sprintf(req->resp_buf,"%s","The number of request headers is too large.");
     wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
     return;
@@ -123,7 +132,7 @@ static inline void wr_req_header_add(wr_req_t * req) {
 
   LOG_DEBUG(DEBUG, "%s() header=%s, value=%s", __FUNCTION__, req->tmp_header.str, req->tmp_value.str);
 
-  SCGI_REQUEST_HEADER_SET(req->scgi_req,
+  scgiUEST_HEADER_SET(req->scgi,
                           req->tmp_header.str, req->tmp_header.len,
                           req->tmp_value.str, req->tmp_value.len);
 
@@ -132,70 +141,93 @@ static inline void wr_req_header_add(wr_req_t * req) {
   wr_string_null(req->tmp_value);
   wr_string_null(req->tmp_header);
 }
-
-static inline void wr_req_special_header_add(wr_req_t *req, const char *header,
-    size_t header_len, const char *at, size_t length) {
-
-  wr_string_new(req->tmp_header, header, header_len);
-  wr_string_new(req->tmp_value, at, length);
-
-  SCGI_REQUEST_HEADER_SET(req->scgi_req,
-                          req->tmp_header.str, req->tmp_header.len,
-                          req->tmp_value.str, req->tmp_value.len);
-
+*/
+
+static int wr_req_header_length_check(wr_req_t *req, size_t length, int index){
+  // Check no. of headers
+  if(index >= WR_MAX_REQ_HEADER_NO) {
+    req->resp_buf_len = sprintf(req->resp_buf, "%s", "The number of request header is too large.");
+    return WR_HTTP_STATUS_413;
+  }
+  
+  // Check field length
+  if(req->scgi->index == index){
+    if(req->scgi->header_list->field_length + length >  WR_MAX_REQ_FIELD_NAME_LEN){
+      LOG_DEBUG(DEBUG,"header len = %d", req->scgi->header_list->field_length);
+      req->resp_buf_len = sprintf(req->resp_buf, "%s", "The request field name is too large.");
+      return WR_HTTP_STATUS_413;
+    }
+  }else{
+    if((length + 5) > WR_MAX_REQ_FIELD_NAME_LEN){
+      LOG_DEBUG(DEBUG,"header len = %d", length + 5);
+      req->resp_buf_len = sprintf(req->resp_buf, "%s", "The request field name is too large.");
+      return WR_HTTP_STATUS_413;
+    }else{
+      // Add 'HTTP_' prefix with each headers
+      scgi_header_field_add(req->scgi, HTTP_PREFIX, HTTP_PREFIX_LEN, index);
+    }
+  }
+  
+  // Check request size
+  if((req->scgi->header_offset + length) > WR_MAX_REQ_HEADER_LEN) {
+    req->resp_buf_len = sprintf(req->resp_buf,"%s","The request is too large.");
+    return WR_HTTP_STATUS_413;
+  }
+  return 0;
 }
 
-
 void wr_req_header_field_cb(ebb_request* request, const char *at, size_t length, int header_index) {
   wr_req_t* req = (wr_req_t*) request->data;
+  short status = wr_req_header_length_check(req, length, header_index);
+  size_t i;
 
-  if(header_index >= WR_MAX_REQ_HEADER_NO) {
-    req->resp_buf_len = sprintf(req->resp_buf,"%s","The number of request header is too large.");
-    wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
-    return;
-  }
-
-  // Check request header size
-  if(req->tmp_header.len+length >  WR_MAX_REQ_FIELD_NAME_LEN) {
-    LOG_DEBUG(DEBUG,"header len = %d", req->tmp_header.len);
-    req->resp_buf_len = sprintf(req->resp_buf,"%s","The request field name is too large.");
-    wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
+  if(status != 0){
+    wr_req_invalid(req->conn, status);
     return;
   }
+  
+  scgi_header_field_add(req->scgi, at, length, header_index);
+ 
+  LOG_DEBUG(DEBUG,"field name = %s",req->scgi->header + req->scgi->header_list->field_offset);
+}
 
-  if(req->tmp_header.str && req->tmp_value.str) {
-    wr_req_header_add(req);
+static int wr_req_header_value_check(wr_req_t *req, size_t length, int index){
+  // Check value length
+  if(req->scgi->index == index){
+    if(req->scgi->header_list->value_length + length >  WR_MAX_REQ_FIELD_VALUE_LEN){
+      LOG_DEBUG(DEBUG,"value len = %d", req->scgi->header_list->value_length);
+      req->resp_buf_len = sprintf(req->resp_buf, "%s", "The request field value is too large.");
+      return WR_HTTP_STATUS_413;
+    }
+  }else{
+    if(length > WR_MAX_REQ_FIELD_VALUE_LEN){
+      LOG_DEBUG(DEBUG,"value len = %d", length + 5);
+      req->resp_buf_len = sprintf(req->resp_buf, "%s", "The request field value is too large.");
+      return WR_HTTP_STATUS_413;
+    }
   }
-
-  if(wr_string_is_empty(req->tmp_header)) {
-    wr_string_new(req->tmp_header, "HTTP_", 5);
-    wr_string_append(req->tmp_header, at, length);
-  } else {
-    wr_string_append(req->tmp_header, at, length);
+  
+  // Check request size
+  if((req->scgi->header_offset + length) > WR_MAX_REQ_HEADER_LEN) {
+    req->resp_buf_len = sprintf(req->resp_buf,"%s","The request is too large.");
+    return WR_HTTP_STATUS_413;
   }
-
-  LOG_DEBUG(DEBUG,"cli_tmp_header=%s",req->tmp_header.str);
+  return 0;
 }
 
 /** Header value received */
 void wr_req_header_value_cb(ebb_request* request, const char *at, size_t length, int header_index) {
   wr_req_t* req =(wr_req_t*) request->data;
-
-  //Check request header value size
-  if(req->tmp_value.len+length > WR_MAX_REQ_FIELD_VALUE_LEN) {
-    LOG_DEBUG(DEBUG,"value len = %d",req->tmp_value.len);
-    req->resp_buf_len = sprintf(req->resp_buf,"%s","The request field value is too large.");
-    wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
+  short status = wr_req_header_value_check(req, length, header_index);
+  
+  if(status != 0){
+    wr_req_invalid(req->conn, status);
     return;
   }
-
-  if(wr_string_is_empty(req->tmp_value)) {
-    wr_string_new(req->tmp_value, at, length);
-  } else {
-    wr_string_append(req->tmp_value, at, length);
-  }
-
-  LOG_DEBUG(DEBUG,"cli_tmp_value=%s",req->tmp_value.str);
+  
+  scgi_header_value_add(req->scgi, at, length, header_index);
+  
+  LOG_DEBUG(DEBUG,"field value = %s",req->scgi->header + req->scgi->header_list->value_offset);
 }
 
 /** HTTP Request path received */
@@ -234,7 +266,7 @@ void wr_req_uri_cb(ebb_request* request, const char *at, size_t length) {
   wr_req_t* req =(wr_req_t*) request->data;
   char *value=NULL;
 
-  if(req->req_uri.len+length > WR_MAX_REQ_URI_LEN) {
+  if(req->req_uri.len + length > WR_MAX_REQ_URI_LEN) {
     LOG_DEBUG(DEBUG,"req uri len = %d",__FUNCTION__, req->req_uri.len);
     req->resp_buf_len = sprintf(req->resp_buf,"%s","The request URI is too large.");
     wr_req_invalid(req->conn, WR_HTTP_STATUS_414);
@@ -246,7 +278,6 @@ void wr_req_uri_cb(ebb_request* request, const char *at, size_t length) {
   } else {
     wr_string_append(req->req_uri, at, length);
   }
-
 }
 
 /** Request fragment received */
@@ -255,28 +286,19 @@ void wr_req_fragment_cb(ebb_request* request, const char *at, size_t length) {
   wr_req_t* req =(wr_req_t*) request->data;
 
   // Check request path length
-  if(length > WR_MAX_REQ_FRAG_LEN) {
+  LOG_DEBUG(DEBUG,"Fragment length = %d", req->req_fragment.len + length);
+  if((req->req_fragment.len + length) > WR_MAX_REQ_FRAG_LEN) {
     LOG_DEBUG(DEBUG,"req fragment len = %d", length);
-    req->resp_buf_len = sprintf(req->resp_buf,"%s","The request fragment is too large.");
+    req->resp_buf_len = sprintf(req->resp_buf, "%s", "The request fragment is too large.");
     wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
     return;
   }
-
-  if(req->tmp_header.str && req->tmp_value.str) {
-    if(  strncmp(req->tmp_header.str, WR_EBB_FRAGMENT, WR_EBB_FRAGMENT_LEN) != 0) {
-      wr_req_header_add(req);
-    } else {
-      // Append value if header is "WR_EBB_REQ_PATH"
-      wr_string_append(req->tmp_value, at, length);
-      return;
-    }
-  }
-
-  if(wr_string_is_empty(req->tmp_header)) {
-    wr_string_new(req->tmp_header,WR_EBB_FRAGMENT, WR_EBB_FRAGMENT_LEN);
+  
+  if(wr_string_is_empty(req->req_fragment)) {
+    wr_string_new(req->req_fragment, at , length);
+  }else{
+    wr_string_append(req->req_fragment, at, length);
   }
-
-  wr_string_new(req->tmp_value, at, length);
 }
 
 /** Request body received */
@@ -303,91 +325,96 @@ void wr_headers_complete_cb(ebb_request * request) {
     return;
   }
 
+/*
   if(req->tmp_header.str && req->tmp_value.str) {
     wr_req_header_add(req);
   }
+*/
 
   if(wr_req_path_set(req)!=0) {
     return;
   }
 
-  wr_req_special_header_add(req, WR_EBB_REQ_URI, WR_EBB_REQ_URI_LEN, req->req_path.str, req->req_uri.len);
-  LOG_DEBUG(DEBUG,"headers_complete_cb() len = %d, req uri=%s" ,req->req_uri.len, req->req_uri.str);
+  LOG_DEBUG(DEBUG,"Request URI = %s, length = %d" ,req->req_path.str , req->req_uri.len);
+  scgi_header_add(req->scgi, WR_EBB_REQ_URI, WR_EBB_REQ_URI_LEN, req->req_path.str, req->req_uri.len);
   if(req->req_path.str) {
-    wr_req_special_header_add(req, WR_EBB_REQ_PATH, WR_EBB_REQ_PATH_LEN, req->req_path.str, req->req_path.len);
-    LOG_DEBUG(DEBUG,"headers_complete_cb() len = %d, req path=%s" ,req->req_path.len, req->req_path.str);
+    LOG_DEBUG(DEBUG,"Request path = %s, length = %d" ,req->req_path.str , req->req_path.len);
+    scgi_header_add(req->scgi, WR_EBB_REQ_PATH, WR_EBB_REQ_PATH_LEN, req->req_path.str, req->req_path.len);
   }
 
   if(req->req_query_str.str) {
-    wr_req_special_header_add(req, WR_EBB_QUERY_STR, WR_EBB_QUERY_STR_LEN, req->req_query_str.str, req->req_query_str.len);
-    LOG_DEBUG(DEBUG,"headers_complete_cb() len = %d, query string=%s" ,req->req_query_str.len, req->req_query_str.str);
+    LOG_DEBUG(DEBUG,"Request query string = %s, length = %d" ,req->req_query_str.str , req->req_query_str.len);
+    scgi_header_add(req->scgi, WR_EBB_QUERY_STR, WR_EBB_QUERY_STR_LEN, req->req_query_str.str, req->req_query_str.len);
+  }
+  
+  if(req->req_fragment.str) {
+    LOG_DEBUG(DEBUG,"Request fragment = %s, length = %d" ,req->req_fragment.str , req->req_fragment.len);
+    scgi_header_add(req->scgi, WR_EBB_FRAGMENT, WR_EBB_FRAGMENT_LEN, req->req_fragment.str, req->req_fragment.len);
   }
 
 #ifdef HAVE_GNUTLS
   // Add extra field to server HTTPS requests
   // RequestHeader set X_FORWARDED_PROTO ‘https’
   if(conn->svr->secure_ebb_svr.fd == connection->server->fd) {
-    wr_req_special_header_add(req, WR_EBB_HTTPS_HEADER, WR_EBB_HTTPS_HEADER_LEN, "on", 2);
+    scgi_header_add(req->scgi, WR_EBB_HTTPS_HEADER, WR_EBB_HTTPS_HEADER_LEN, "on", 2);
   }
 #endif
 
   /** Add CONTENT_LENGTH header into CGI header list */
-  scgi_request_add_content_len(req->scgi_req, request->content_length);
+  scgi_content_length_add(req->scgi, request->content_length);
 
   /** Add WR_EBB_CHUNKED header into CGI header list */
   if(request->transfer_encoding == EBB_CHUNKED) {
-    wr_req_special_header_add(req, WR_EBB_CHUNKED, WR_EBB_CHUNKED_LEN, "Yes", 3);
+    scgi_header_add(req->scgi, WR_EBB_CHUNKED, WR_EBB_CHUNKED_LEN, "Yes", 3);
   } else {
-    wr_req_special_header_add(req, WR_EBB_CHUNKED, WR_EBB_CHUNKED_LEN, "No", 2);
+    scgi_header_add(req->scgi, WR_EBB_CHUNKED, WR_EBB_CHUNKED_LEN, "No", 2);
   }
 
   /** Add WR_EBB_REQ_METHOD header into CGI header list */
   switch(request->method) {
   case EBB_COPY :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_COPY, WR_EBB_REQ_METHOD_COPY_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_COPY, WR_EBB_REQ_METHOD_COPY_LEN);
     break;
   case EBB_DELETE :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_DELETE, WR_EBB_REQ_METHOD_DELETE_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_DELETE, WR_EBB_REQ_METHOD_DELETE_LEN);
     break;
   case EBB_GET       :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_GET, WR_EBB_REQ_METHOD_GET_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_GET, WR_EBB_REQ_METHOD_GET_LEN);
     break;
   case EBB_HEAD      :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_HEAD, WR_EBB_REQ_METHOD_HEAD_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_HEAD, WR_EBB_REQ_METHOD_HEAD_LEN);
     break;
   case EBB_LOCK      :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_LOCK, WR_EBB_REQ_METHOD_LOCK_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_LOCK, WR_EBB_REQ_METHOD_LOCK_LEN);
     break;
   case EBB_MKCOL     :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_MKCOL, WR_EBB_REQ_METHOD_MKCOL_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_MKCOL, WR_EBB_REQ_METHOD_MKCOL_LEN);
     break;
   case EBB_MOVE      :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_MOVE, WR_EBB_REQ_METHOD_MOVE_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_MOVE, WR_EBB_REQ_METHOD_MOVE_LEN);
     break;
   case EBB_OPTIONS   :
     wr_req_invalid(req->conn, WR_HTTP_STATUS_501);
-    wr_string_null(req->tmp_value);
-    wr_string_null(req->tmp_header);
     return;
-    //wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_OPTIONS, WR_EBB_REQ_METHOD_OPTIONS_LEN);
+    //scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_OPTIONS, WR_EBB_REQ_METHOD_OPTIONS_LEN);
     break;
   case EBB_POST      :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_POST, WR_EBB_REQ_METHOD_POST_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_POST, WR_EBB_REQ_METHOD_POST_LEN);
     break;
   case EBB_PROPFIND  :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_PROPFIND, WR_EBB_REQ_METHOD_PROPFIND_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_PROPFIND, WR_EBB_REQ_METHOD_PROPFIND_LEN);
     break;
   case EBB_PROPPATCH :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_PROPPATCH, WR_EBB_REQ_METHOD_PROPPATCH_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_PROPPATCH, WR_EBB_REQ_METHOD_PROPPATCH_LEN);
     break;
   case EBB_PUT       :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_PUT, WR_EBB_REQ_METHOD_PUT_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_PUT, WR_EBB_REQ_METHOD_PUT_LEN);
     break;
   case EBB_TRACE     :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_TRACE, WR_EBB_REQ_METHOD_TRACE_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_TRACE, WR_EBB_REQ_METHOD_TRACE_LEN);
     break;
   case EBB_UNLOCK    :
-    wr_req_special_header_add(req, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_UNLOCK, WR_EBB_REQ_METHOD_UNLOCK_LEN);
+    scgi_header_add(req->scgi, WR_EBB_REQ_METHOD, WR_EBB_REQ_METHOD_LEN, WR_EBB_REQ_METHOD_UNLOCK, WR_EBB_REQ_METHOD_UNLOCK_LEN);
     break;
   }
 
@@ -396,48 +423,41 @@ void wr_headers_complete_cb(ebb_request * request) {
   //rb_hash_aset(env, g_path_info, rb_hash_aref(env, g_request_path));
 
   /* Add WR_EBB_SVR_PORT header into CGI header list */
-  wr_req_special_header_add(req, WR_EBB_SVR_PORT, WR_EBB_SVR_PORT_LEN, connection->server->port, strlen(connection->server->port));
+  scgi_header_add(req->scgi, WR_EBB_SVR_PORT, WR_EBB_SVR_PORT_LEN, connection->server->port, strlen(connection->server->port));
 
   /* Add WR_EBB_HTTP_CLI_IP header into CGI header list */
-  wr_req_special_header_add(req, WR_EBB_HTTP_CLI_IP, WR_EBB_HTTP_CLI_IP_LEN, connection->ip, strlen(connection->ip));
+  scgi_header_add(req->scgi, WR_EBB_HTTP_CLI_IP, WR_EBB_HTTP_CLI_IP_LEN, connection->ip, strlen(connection->ip));
 
   /* Add WR_EBB_HTTP_VER header into CGI header list */
-  wr_string_new(req->tmp_header, WR_EBB_HTTP_VER, WR_EBB_HTTP_VER_LEN);
-  wr_str_buf_t buf;
-  wr_string_buf_new(buf, WR_TINY_STR_LEN);
-  buf.len = snprintf(buf.str, WR_TINY_STR_LEN, "HTTP/%d.%d", request->version_major, request->version_minor);
-
-  SCGI_REQUEST_HEADER_SET(req->scgi_req,
-                          req->tmp_header.str, req->tmp_header.len,
-                          buf.str, buf.len);
+  wr_buffer_t *buf;
+  wr_buffer_new(buf);
+  wr_buffer_create(buf, WR_TINY_STR_LEN);
+  buf->len = snprintf(buf->str, WR_TINY_STR_LEN, "HTTP/%d.%d", request->version_major, request->version_minor);
+  scgi_header_add(req->scgi, WR_EBB_HTTP_VER, WR_EBB_HTTP_VER_LEN, buf->str, buf->len);
+  wr_buffer_free(buf);
 
   /** Check content length */
   LOG_DEBUG(DEBUG,"Request content len = %d", request->content_length);
   if(request->content_length > WR_REQ_BODY_MAX_SIZE) {
     // Open file to write req request body
-    wr_string_buf_new(req->upload_file_name, WR_SHORT_STR_LEN);
-    req->upload_file_name.len = sprintf(req->upload_file_name.str,"/tmp/ebb_upload_%d", req->id);
-    req->upload_file = fopen(req->upload_file_name.str,"w+");
+    wr_buffer_new(req->upload_file_name);
+    wr_buffer_create(req->upload_file_name, WR_SHORT_STR_LEN);
+    req->upload_file_name->len = sprintf(req->upload_file_name->str,"/tmp/ebb_upload_%d", req->id);
+    req->upload_file = fopen(req->upload_file_name->str,"w+");
     if(req->upload_file == NULL) {
-      LOG_ERROR(SEVERE,"Cannot open tmpfile %s", req->upload_file_name.str);
-      wr_string_buf_free(req->upload_file_name);
-      wr_string_null(req->tmp_value);
-      wr_string_null(req->tmp_header);
+      LOG_ERROR(SEVERE,"Cannot open tmpfile %s", req->upload_file_name->str);
       wr_req_free(req);
       return;
     }
-  } else if(request->content_length > 0) {
-    req->scgi_req->request_body = (char*) malloc(sizeof(char)*(request->content_length+1));
-    req->scgi_req->request_body_len = 0;
   }
-  wr_string_null(req->tmp_value);
-  wr_string_null(req->tmp_header);
+  wr_req_resolve_http_req(req->conn->svr, req);
 }
 
 /** HTTP request completed */
 void wr_req_complete_cb(ebb_request * request) {
   LOG_FUNCTION
   wr_req_t* req = (wr_req_t*) request->data;
+  short retval;
   LOG_DEBUG(DEBUG,"req = %d",req->id);
   // Rewind file pointer if request body is written into file
   if(req->upload_file) {
@@ -451,15 +471,18 @@ void wr_req_complete_cb(ebb_request * request) {
     #endif*/
   req->conn->keep_alive = ebb_request_should_keep_alive(req->ebb_req);
   req->conn->resp_to_write ++;
-  scgi_request_build(req->scgi_req);
-
+  scgi_build(req->scgi);
   // ebb_request parsing completed, send call back to Server
-  if(wr_req_resolve_http_req(req->conn->svr, req)==0) {
-    wr_wkr_dispatch_req(req);
-  } else {
-    LOG_DEBUG(DEBUG,"Failed to dispatch req no %d to any application. Request PATH is %s", req->id, req->req_uri.str);
-    wr_req_invalid(req->conn, WR_HTTP_STATUS_404);
+  if(req->app){
+    int rv;
+    WR_QUEUE_INSERT(req->app->msg_que, req, rv)
+    if(rv == 0){
+      wr_wkr_dispatch_req(req);
+      return;
+    }
   }
+  LOG_ERROR(WARN,"Failed to dispatch req no %d to any application. Request PATH is %s", req->id, req->req_uri.str);
+  wr_req_invalid(req->conn, WR_HTTP_STATUS_404);
 }
 
 /********************************************************
@@ -485,13 +508,14 @@ wr_req_t* wr_req_new(wr_conn_t* conn) {
   req->wkr       = NULL;
 
   req->upload_file      = NULL;
+  req->upload_file_name = NULL;
   //  req->uri_hash    =
   req->bytes_sent      = 0;
-  req->scgi_req    = scgi_request_new();
+  req->scgi    = scgi_new();
 
-  if(req->scgi_req == NULL) {
+  if(req->scgi == NULL) {
     free(req);
-    LOG_DEBUG(SEVERE, "Error req->scgi_req is null. Returning ...");
+    LOG_ERROR(WARN, "Error req->scgi is null. Returning ...");
     return NULL;
   }
 
@@ -504,33 +528,27 @@ wr_req_t* wr_req_new(wr_conn_t* conn) {
 
 #ifdef L_DEBUG
   /* Adding Connection id and req id */
-  wr_str_buf_t buf_field, buf_value;
-  wr_string_buf_new(buf_field, WR_SHORT_STR_LEN);
-  wr_string_buf_new(buf_value, WR_SHORT_STR_LEN);
-  buf_field.len = snprintf(buf_field.str, buf_field.size, "%s", WR_CONN_ID);
-  buf_value.len = snprintf(buf_value.str, buf_value.size, "%d", conn->id);
-
-  SCGI_REQUEST_HEADER_SET(req->scgi_req, buf_field.str, buf_field.len, buf_value.str, buf_value.len);
-
-  wr_string_buf_new(buf_field, WR_TINY_STR_LEN);
-  wr_string_buf_new(buf_value, WR_TINY_STR_LEN);
-  buf_field.len = snprintf(buf_field.str, buf_field.size, "%s", WR_REQ_ID);
-  buf_value.len = snprintf(buf_value.str, buf_value.size, "%d", req->id);
-
-  SCGI_REQUEST_HEADER_SET(req->scgi_req, buf_field.str, buf_field.len, buf_value.str, buf_value.len);
-
+  wr_buffer_t *conn_id, *req_id;
+  wr_buffer_new(conn_id);
+  wr_buffer_new(req_id);
+  wr_buffer_create(conn_id, WR_SHORT_STR_LEN);
+  wr_buffer_create(req_id, WR_SHORT_STR_LEN);
+  conn_id->len = snprintf(conn_id->str, conn_id->size, "%d", conn->id);
+  req_id->len = snprintf(req_id->str, req_id->size, "%d", req->id);
+  scgi_header_add(req->scgi, WR_CONN_ID, strlen(WR_CONN_ID), conn_id->str, conn_id->len);
+  scgi_header_add(req->scgi, WR_REQ_ID, strlen(WR_REQ_ID), req_id->str, req_id->len);
+  wr_buffer_free(conn_id);
+  wr_buffer_free(req_id);
 #endif
 
-  wr_string_null(req->tmp_header);
-  wr_string_null(req->tmp_value);
   wr_string_null(req->req_uri);
   wr_string_null(req->req_path);
   wr_string_null(req->req_query_str);
-  wr_string_buf_null(req->upload_file_name);
+  wr_string_null(req->req_fragment);
 
   ebb_request *request = wr_malloc(ebb_request);
   if(request == NULL) {
-    scgi_request_free(req->scgi_req);
+    scgi_free(req->scgi);
     free(req);
     LOG_DEBUG(SEVERE, "Error ebb_request is null. Returning ...");
     return NULL;
@@ -576,13 +594,12 @@ void wr_req_free(wr_req_t* req) {
       free(req->ebb_req);
 
     wr_string_free(req->req_uri);
-    wr_string_free(req->tmp_header);
-    wr_string_free(req->tmp_value);
-    scgi_request_free(req->scgi_req);
+    wr_string_free(req->req_fragment);
+    scgi_free(req->scgi);
     if(req->upload_file) {
       fclose(req->upload_file);
-      remove(req->upload_file_name.str);
-      wr_string_buf_free(req->upload_file_name);
+      remove(req->upload_file_name->str);
+      wr_buffer_free(req->upload_file_name);
     }
     free(req);
   } else {
@@ -601,8 +618,7 @@ int wr_req_body_add(wr_req_t *req, const char *at, size_t length) {
     }
   } else {
     LOG_DEBUG(DEBUG, "copying into buffer. len=%d", length);
-    memcpy(req->scgi_req->request_body + req->scgi_req->request_body_len, at, length);
-    req->scgi_req->request_body_len += length;
+    scgi_body_add(req->scgi, at, length);
   }
   return 0;
 }

data/src/head/wr_request.h

@@ -1,5 +1,5 @@
 /* WebROaR - Ruby Application Server - http://webroar.in/
- * Copyright (C) 2009  WebROaR
+ * Copyright (C) 2009  Goonj LLC
  *
  * This file is part of WebROaR.
  *
@@ -37,14 +37,12 @@ struct wr_req_s {
 
   /**< variable used by the request */
   FILE           *upload_file;        /**< File pointer to store request body */
-  wr_str_buf_t    upload_file_name;  /**< File name */
+  wr_buffer_t    *upload_file_name;  /**< File name */
 
-  wr_str_t      tmp_header;    /**< Temporarily  store request header */
-  wr_str_t      tmp_value;    /**< Temporarily  store request value */
-  wr_str_t      req_uri, req_path, req_query_str;
+  wr_str_t      req_uri, req_path, req_query_str, req_fragment;
 
   size_t        bytes_sent;
-  scgi_request_t  *scgi_req;    /**< SCGI request */
+  scgi_t  *scgi;    /**< SCGI request */
 
   /**< variable used by the response */
   char         resp_buf[WR_RESP_BUF_SIZE];  /**< Buffer to read processed response from 'webroar-worker' */
@@ -124,13 +122,6 @@ ebb_request* wr_new_req_cb(ebb_connection*);
 #define WR_EBB_HTTP_VER        "HTTP_VERSION"
 #define WR_EBB_HTTP_VER_LEN      12
 
-#ifdef L_DEBUG
-#define WR_CONN_ID      "CONNECTION_ID"
-#define WR_CONN_ID_LEN    19
-#define WR_REQ_ID        "REQ_ID"
-#define WR_REQ_ID_LEN      12
-#endif
-
 #ifdef HAVE_GNUTLS
 #define WR_EBB_HTTPS_HEADER    "HTTPS"
 #define WR_EBB_HTTPS_HEADER_LEN  5