webroar 0.3.1 → 0.4.0

data/src/head/wr_request.c

@@ -22,7 +22,7 @@
 static unsigned int wr_req_count = 0;
 #define HTTP_PREFIX "HTTP_"
 #define HTTP_PREFIX_LEN 5
-
+extern config_t *Config;
 /** Private function */
 
 /** HTTP header received */
@@ -33,7 +33,7 @@ static unsigned int wr_req_count = 0;
  */
 
 
-static inline int wr_req_path_set(wr_req_t *req) {
+int wr_req_path_set(wr_req_t *req) {
   LOG_FUNCTION
   // terminate request uri with 'null' character
 
@@ -62,7 +62,7 @@ static inline int wr_req_path_set(wr_req_t *req) {
     }
 
     // Check Query String length
-    if(req->req_query_str.len > WR_MAX_REQ_QRY_STR_LEN) {
+    if(req->req_query_str.len > Config->Request.max_query_size) {
       LOG_DEBUG(DEBUG,"query str len = %d", req->req_query_str.len);
       req->resp_buf_len = sprintf(req->resp_buf,"%s","The request query string is too large.");
       wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
@@ -87,7 +87,7 @@ static inline int wr_req_path_set(wr_req_t *req) {
         }
 
         // Check request path length
-        if(req->req_path.len > WR_MAX_REQ_PATH_LEN) {
+        if(req->req_path.len > Config->Request.max_path_size) {
           LOG_DEBUG(DEBUG,"req path len = %d", req->req_path.len);
           req->resp_buf_len = sprintf(req->resp_buf,"%s","The request path is too large.");
           wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
@@ -116,49 +116,22 @@ 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->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;
-  }
-
-  for( ; i < req->tmp_header.len ; i++) {
-    req->tmp_header.str[i] = (req->tmp_header.str[i]=='-' ? '_' : wr_toupper(req->tmp_header.str[i]));
-  }
-
-  LOG_DEBUG(DEBUG, "%s() header=%s, value=%s", __FUNCTION__, req->tmp_header.str, req->tmp_value.str);
-
-  scgiUEST_HEADER_SET(req->scgi,
-                          req->tmp_header.str, req->tmp_header.len,
-                          req->tmp_value.str, req->tmp_value.len);
-
-
-
-  wr_string_null(req->tmp_value);
-  wr_string_null(req->tmp_header);
-}
-*/
-
-static int wr_req_header_length_check(wr_req_t *req, size_t length, int index){
+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) {
+  if(index >= Config->Request.max_header_count) {
     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){
+    if(req->scgi->header_list->field_length + length >  Config->Request.max_field_size){
       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){
+    if((length + 5) > Config->Request.max_field_size){
       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;
@@ -169,7 +142,7 @@ static int wr_req_header_length_check(wr_req_t *req, size_t length, int index){
   }
   
   // Check request size
-  if((req->scgi->header_offset + length) > WR_MAX_REQ_HEADER_LEN) {
+  if((req->scgi->header_offset + length) > Config->Request.max_header_size) {
     req->resp_buf_len = sprintf(req->resp_buf,"%s","The request is too large.");
     return WR_HTTP_STATUS_413;
   }
@@ -187,19 +160,19 @@ void wr_req_header_field_cb(ebb_request* request, const char *at, size_t length,
   
   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);
+  //LOG_DEBUG(DEBUG,"field name = %s",req->scgi->header + req->scgi->header_list->field_offset);
 }
 
-static int wr_req_header_value_check(wr_req_t *req, size_t length, int index){
+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){
+    if(req->scgi->header_list->value_length + length >  Config->Request.max_value_size){
       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){
+    if(length > Config->Request.max_value_size){
       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;
@@ -207,7 +180,7 @@ static int wr_req_header_value_check(wr_req_t *req, size_t length, int index){
   }
   
   // Check request size
-  if((req->scgi->header_offset + length) > WR_MAX_REQ_HEADER_LEN) {
+  if((req->scgi->header_offset + length) > Config->Request.max_header_size) {
     req->resp_buf_len = sprintf(req->resp_buf,"%s","The request is too large.");
     return WR_HTTP_STATUS_413;
   }
@@ -226,7 +199,7 @@ void wr_req_header_value_cb(ebb_request* request, const char *at, size_t length,
   
   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);
+  //LOG_DEBUG(DEBUG,"field value = %s",req->scgi->header + req->scgi->header_list->value_offset);
 }
 
 /** HTTP Request path received */
@@ -236,7 +209,7 @@ void wr_req_path_cb(ebb_request* request, const char *at, size_t length) {
   req->req_path.len += length;
 
   // Check request path length
-  if(req->req_path.len > WR_MAX_REQ_PATH_LEN) {
+  if(req->req_path.len > Config->Request.max_path_size) {
     LOG_DEBUG(DEBUG,"req path len = %d", req->req_path.len);
     req->resp_buf_len = sprintf(req->resp_buf,"%s","The request path is too large.");
     wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
@@ -251,7 +224,7 @@ void wr_query_string_cb(ebb_request* request, const char *at, size_t length) {
   req->req_query_str.len += length;
 
   // Check query string size
-  if(req->req_query_str.len > WR_MAX_REQ_QRY_STR_LEN) {
+  if(req->req_query_str.len > Config->Request.max_query_size) {
     LOG_DEBUG(DEBUG,"query str len = %d", req->req_query_str.len);
     req->resp_buf_len = sprintf(req->resp_buf,"%s","The request query string is too large.");
     wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
@@ -264,7 +237,7 @@ void wr_req_uri_cb(ebb_request* request, const char *at, size_t length) {
   LOG_FUNCTION
   wr_req_t* req =(wr_req_t*) request->data;
 
-  if(req->req_uri.len + length > WR_MAX_REQ_URI_LEN) {
+  if(req->req_uri.len + length > Config->Request.max_uri_size) {
     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);
@@ -285,7 +258,7 @@ void wr_req_fragment_cb(ebb_request* request, const char *at, size_t length) {
 
   // Check request path length
   LOG_DEBUG(DEBUG,"Fragment length = %d", req->req_fragment.len + length);
-  if((req->req_fragment.len + length) > WR_MAX_REQ_FRAG_LEN) {
+  if((req->req_fragment.len + length) > Config->Request.max_frag_size) {
     LOG_DEBUG(DEBUG,"req fragment len = %d", length);
     req->resp_buf_len = sprintf(req->resp_buf, "%s", "The request fragment is too large.");
     wr_req_invalid(req->conn, WR_HTTP_STATUS_413);
@@ -299,6 +272,22 @@ void wr_req_fragment_cb(ebb_request* request, const char *at, size_t length) {
   }
 }
 
+/** Add req request body */
+int wr_req_body_add(wr_req_t *req, const char *at, size_t length) {
+  LOG_FUNCTION
+  if(req->upload_file) {
+    LOG_DEBUG(DEBUG, "writing into file");
+    size_t write = 0;
+    while(write < length) {
+      write += fwrite( at + write, sizeof(char), length - write, req->upload_file);
+    }
+  } else {
+    LOG_DEBUG(DEBUG, "copying into buffer. len=%d", length);
+    scgi_body_add(req->scgi, at, length);
+  }
+  return 0;
+}
+
 /** Request body received */
 void wr_req_body_cb(ebb_request* request, const char *at, size_t length) {
   LOG_FUNCTION
@@ -429,17 +418,17 @@ void wr_headers_complete_cb(ebb_request * request) {
   /* Add WR_EBB_HTTP_VER header into CGI header list */
   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);
+  wr_buffer_create(buf, STR_SIZE16);
+  buf->len = snprintf(buf->str, STR_SIZE16, "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) {
+  if(request->content_length > Config->Request.max_body_size) {
     // Open file to write req request body
     wr_buffer_new(req->upload_file_name);
-    wr_buffer_create(req->upload_file_name, WR_SHORT_STR_LEN);
+    wr_buffer_create(req->upload_file_name, STR_SIZE32);
     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) {
@@ -475,74 +464,73 @@ void wr_req_complete_cb(ebb_request * request) {
     WR_QUEUE_INSERT(req->app->q_messages, req, rv)
     if(rv == 0){
       wr_wkr_dispatch_req(req);
-      return;
+    }else{
+      LOG_ERROR(WARN,"Application pending message queue overflow.", req->id, req->req_uri.str);
+      wr_req_invalid(req->conn, WR_HTTP_STATUS_503);
     }
+    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);
 }
 
-/********************************************************
- *     Request Function Definition      *
- ********************************************************/
-
 /** Create new Request */
 wr_req_t* wr_req_new(wr_conn_t* conn) {
   LOG_FUNCTION
   LOG_DEBUG(DEBUG,"for connection = %d", conn->id);
-
+  
   wr_req_t  *req = wr_malloc(wr_req_t);
-
+  
   if(req == NULL) {
     LOG_DEBUG(SEVERE, "Error req is null. Returning ...");
     return NULL;
   }
-
+  
   req->conn = conn;
   req->id = ++wr_req_count;
-
+  
   req->app       = NULL;
   req->wkr       = NULL;
-
+  
   req->upload_file      = NULL;
   req->upload_file_name = NULL;
   //  req->uri_hash    =
   req->bytes_sent      = 0;
   req->scgi    = scgi_new();
-
+  
   if(req->scgi == NULL) {
     free(req);
     LOG_ERROR(WARN, "Error req->scgi is null. Returning ...");
     return NULL;
   }
-
+  
   req->resp_buf_len   =
-    req->bytes_received =
-      req->resp_body_len = 0;
+  req->bytes_received =
+  req->resp_body_len = 0;
   req->resp_code = 0;
-
+  
   req->conn_err = req->using_wkr = FALSE;
-
+  
 #ifdef L_DEBUG
   /* Adding Connection id and req id */
   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);
+  wr_buffer_create(conn_id, STR_SIZE32);
+  wr_buffer_create(req_id, STR_SIZE32);
   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);
+  scgi_header_add(req->scgi, Config->Request.Header.conn_id.str, Config->Request.Header.conn_id.len, conn_id->str, conn_id->len);
+  scgi_header_add(req->scgi, Config->Request.Header.req_id.str, Config->Request.Header.req_id.len, req_id->str, req_id->len);
   wr_buffer_free(conn_id);
   wr_buffer_free(req_id);
 #endif
-
+  
   wr_string_null(req->req_uri);
   wr_string_null(req->req_path);
   wr_string_null(req->req_query_str);
   wr_string_null(req->req_fragment);
-
+  
   ebb_request *request = wr_malloc(ebb_request);
   if(request == NULL) {
     scgi_free(req->scgi);
@@ -550,12 +538,12 @@ wr_req_t* wr_req_new(wr_conn_t* conn) {
     LOG_DEBUG(SEVERE, "Error ebb_request is null. Returning ...");
     return NULL;
   }
-
+  
   ebb_request_init(request);
-
+  
   //TODO: can connection have multiple requests?
   req->ebb_req = request;
-
+  
   request->data = req;
   request->on_path = wr_req_path_cb;
   request->on_query_string = wr_query_string_cb;
@@ -566,13 +554,18 @@ wr_req_t* wr_req_new(wr_conn_t* conn) {
   request->on_headers_complete = wr_headers_complete_cb;
   request->on_body = wr_req_body_cb;
   request->on_complete = wr_req_complete_cb;
-
+  
   //TODO: Check for keep alive status & then increment 'responses_to_write'
   // Else it will be 1
-
+  
   return req;
 }
 
+
+/********************************************************
+ *     Request Function Definition      *
+ ********************************************************/
+
 /** Destroy req */
 void wr_req_free(wr_req_t* req) {
   LOG_FUNCTION
@@ -604,22 +597,6 @@ void wr_req_free(wr_req_t* req) {
   }
 }
 
-/** Add req request body */
-int wr_req_body_add(wr_req_t *req, const char *at, size_t length) {
-  LOG_FUNCTION
-  if(req->upload_file) {
-    LOG_DEBUG(DEBUG, "writing into file");
-    size_t write = 0;
-    while(write < length) {
-      write += fwrite( at + write, sizeof(char), length - write, req->upload_file);
-    }
-  } else {
-    LOG_DEBUG(DEBUG, "copying into buffer. len=%d", length);
-    scgi_body_add(req->scgi, at, length);
-  }
-  return 0;
-}
-
 ebb_request* wr_new_req_cb(ebb_connection *connection) {
   LOG_FUNCTION
   // Create new wr_req

data/src/head/wr_request.h

@@ -52,12 +52,8 @@ struct wr_req_s {
   size_t        bytes_received;
 };
 
-/** Create new Request */
-wr_req_t* wr_req_new(wr_conn_t*);
 /** Destroy Request */
 void wr_req_free(wr_req_t*);
-/** Add Request body */
-int wr_req_body_add(wr_req_t*, const char*, size_t);
 /** Invalid request */
 void wr_req_invalid(wr_conn_t *, wr_resp_status_t);
 /** Allocates and initializes ab ebb_request */

data/src/head/wr_resolver.c

@@ -19,6 +19,8 @@
 #include <wr_request.h>
 #include <string.h>
 
+extern config_t *Config;
+
 /*********** Private Function ***********/
 void wr_req_resolver_print(wr_req_resolver_t* resolver) {
   LOG_FUNCTION
@@ -41,15 +43,19 @@ void wr_req_resolver_print(wr_req_resolver_t* resolver) {
 }
 
 /** Resolve static content */
+/* Do not set req->app if static workers are not there.
+ * If req->app does not set, the static content served by the worker of
+ * respective application */
 int wr_req_resolve_static_content(wr_req_t *req){
   LOG_FUNCTION
-  char path[WR_FILE_PATH_LEN + WR_MAX_REQ_PATH_LEN];
+  char path[STR_SIZE1KB + Config->Request.max_path_size];
   char *req_path;
   struct stat buf;
   int len;
   wr_str_t decoded_req_path;
 
-  if(WR_QUEUE_SIZE(req->app->svr->static_app->q_workers) <= 0){
+  // Check static-workers exist or not
+  if(req->app->svr->static_app == NULL || WR_QUEUE_SIZE(req->app->svr->static_app->q_workers) <= 0){
     LOG_ERROR(SEVERE,"Static content server is down.")
     return -1;
   }
@@ -77,7 +83,7 @@ int wr_req_resolve_static_content(wr_req_t *req){
 
   /* Add WR_FILE_PATH header into SCGI header list */
   LOG_DEBUG(DEBUG, "File path = %s, lenght = %d", path, strlen(path));
-  scgi_header_add(req->scgi, WR_HTTP_FILE_PATH, WR_HTTP_FILE_PATH_LEN, path, strlen(path));
+  scgi_header_add(req->scgi, Config->Request.Header.file_path.str, Config->Request.Header.file_path.len, path, strlen(path));
   req->app = req->app->svr->static_app;
 
   return 0;
@@ -99,20 +105,20 @@ wr_req_resolver_t* wr_req_resolver_new() {
 }
 
 /** Add Application resolver */
-int wr_req_resolver_add(wr_svr_t *server, wr_app_t *app, wr_app_conf_t *conf) {
+int wr_req_resolver_add(wr_svr_t *server, wr_app_t *app) {
   LOG_FUNCTION
   short  rv = 0;
 
-  if(conf->baseuri.str) {
-    LOG_DEBUG(DEBUG, "Adding resolver baseuri = %s",conf->baseuri.str);
+  if(app->conf->baseuri.str) {
+    LOG_DEBUG(DEBUG, "Adding resolver baseuri = %s",app->conf->baseuri.str);
     wr_baseuri_t *baseuri = wr_malloc(wr_baseuri_t);
     if(baseuri == NULL) {
       rv = -1;
     }
 
-    baseuri->baseuri_hash = uri_hash(conf->baseuri.str + 1);
+    baseuri->baseuri_hash = uri_hash(app->conf->baseuri.str + 1);
 
-    if(baseuri->baseuri_hash == WR_DEFAULT_PREFIX_HASH) {
+    if(baseuri->baseuri_hash == Config->Request.prefix_hash) {
       free(baseuri);
       server->default_app = app;
     } else {
@@ -129,8 +135,8 @@ int wr_req_resolver_add(wr_svr_t *server, wr_app_t *app, wr_app_conf_t *conf) {
   * Host name start and end with '*'
   */
 
-  if(conf->host_name_list) {
-    wr_host_name_t *host = conf->host_name_list;
+  if(app->conf->host_name_list) {
+    config_host_list_t *host = app->conf->host_name_list;
     while(host) {
       LOG_DEBUG(DEBUG, "Adding resolver Host = %s, type=%d",host->name.str, host->type);
       wr_host_list_t *list = wr_malloc(wr_host_list_t);
@@ -180,7 +186,7 @@ int wr_req_resolver_remove(wr_svr_t *server, wr_app_t *app) {
   while(baseuri) {
     if(baseuri->app == app) {
       LOG_DEBUG(DEBUG,"Removed application %s",baseuri->app->conf->baseuri.str);
-      //      if(baseuri->baseuri_hash == WR_DEFAULT_PREFIX_HASH){
+      //      if(baseuri->baseuri_hash == Config->Request.prefix_hash){
       //        server->default_app = NULL;
       //      }
       if(prev_baseuri == NULL) {
@@ -260,25 +266,25 @@ int wr_req_resolve_http_req(wr_svr_t *server, wr_req_t *req) {
       }
 
       while(list) {
-        if(list->host->type == WR_HOST_TYPE_STATIC &&
+        if(list->host->type == HOST_TYPE_STATIC &&
             list->host->name.len == host_str.len &&
             strncmp(list->host->name.str, host_str.str, host_str.len)==0) {
           LOG_DEBUG(DEBUG,"Application resolved with WR_HOST_TYPE_STATIC host %s", list->host->name.str);
           app = list->app;
           break;
-        } else if(list->host->type == WR_HOST_TYPE_WILDCARD_IN_START &&
+        } else if(list->host->type == HOST_TYPE_WILDCARD_IN_START &&
                   list->host->name.len < host_str.len &&
                   strncmp(list->host->name.str, host_str.str + host_str.len -  list->host->name.len, list->host->name.len)==0) {
           LOG_DEBUG(DEBUG,"Application resolved with WR_HOST_TYPE_WILDCARD_IN_START host %s", list->host->name.str);
           app = list->app;
           break;
-        } else if(list->host->type == WR_HOST_TYPE_WILDCARD_IN_END &&
+        } else if(list->host->type == HOST_TYPE_WILDCARD_IN_END &&
                   list->host->name.len < host_str.len &&
                   strncmp(list->host->name.str, host_str.str, list->host->name.len)==0) {
           LOG_DEBUG(DEBUG,"Application resolved with WR_HOST_TYPE_WILDCARD_IN_END host %s", list->host->name.str);
           app = list->app;
           break;
-        } else if(list->host->type == WR_HOST_TYPE_WILDCARD_IN_START_END &&
+        } else if(list->host->type == HOST_TYPE_WILDCARD_IN_START_END &&
                   list->host->name.len < host_str.len &&
                   strstr(host_str.str, list->host->name.str)!=NULL) {
           LOG_DEBUG(DEBUG,"Application resolved with WR_HOST_TYPE_WILDCARD_IN_START_END host %s", list->host->name.str);

data/src/head/wr_resolver.h

@@ -31,7 +31,7 @@ typedef struct wr_host_list_s   wr_host_list_t;
  * Host name start and end with '*'
  */
 struct wr_host_list_s {
-  wr_host_name_t  *host;
+  config_host_list_t      *host;
   wr_app_t        *app;
   wr_host_list_t     *next;
 };
@@ -50,7 +50,7 @@ struct wr_req_resolver_s {
 };
 
 wr_req_resolver_t* wr_req_resolver_new();
-int wr_req_resolver_add(wr_svr_t*, wr_app_t*, wr_app_conf_t*);
+int wr_req_resolver_add(wr_svr_t*, wr_app_t*);
 int wr_req_resolver_remove(wr_svr_t*, wr_app_t*);
 int wr_req_resolve_http_req(wr_svr_t*, wr_req_t*);
 void wr_req_resolver_free(wr_req_resolver_t*);