webroar 0.4.0 → 0.5.0

data/src/vendor/libyaml/parser.c

@@ -1280,10 +1280,10 @@ yaml_parser_process_directives(yaml_parser_t *parser,
         }
 
         else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
-            yaml_tag_directive_t value = {
-                token->data.tag_directive.handle,
-                token->data.tag_directive.prefix
-            };
+            yaml_tag_directive_t value;
+            value.handle = token->data.tag_directive.handle;
+            value.prefix = token->data.tag_directive.prefix;
+
             if (!yaml_parser_append_tag_directive(parser, value, 0,
                         token->start_mark))
                 goto error;

data/src/vendor/libyaml/reader.c

@@ -120,7 +120,7 @@ yaml_parser_update_raw_buffer(yaml_parser_t *parser)
 
     if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last,
                 parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) {
-        return yaml_parser_set_reader_error(parser, "Input error",
+        return yaml_parser_set_reader_error(parser, "input error",
                 parser->offset, -1);
     }
     parser->raw_buffer.last += size_read;
@@ -141,6 +141,8 @@ yaml_parser_update_raw_buffer(yaml_parser_t *parser)
 YAML_DECLARE(int)
 yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 {
+    int first = 1;
+
     assert(parser->read_handler);   /* Read handler must be set. */
 
     /* If the EOF flag is set and the raw buffer is empty, do nothing. */
@@ -178,9 +180,12 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
     while (parser->unread < length)
     {
-        /* Fill the raw buffer. */
+        /* Fill the raw buffer if necessary. */
 
-        if (!yaml_parser_update_raw_buffer(parser)) return 0;
+        if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) {
+            if (!yaml_parser_update_raw_buffer(parser)) return 0;
+        }
+        first = 0;
 
         /* Decode the raw buffer. */
 
@@ -232,7 +237,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
                     if (!width)
                         return yaml_parser_set_reader_error(parser,
-                                "Invalid leading UTF-8 octet",
+                                "invalid leading UTF-8 octet",
                                 parser->offset, octet);
 
                     /* Check if the raw buffer contains an incomplete character. */
@@ -240,7 +245,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
                     if (width > raw_unread) {
                         if (parser->eof) {
                             return yaml_parser_set_reader_error(parser,
-                                    "Incomplete UTF-8 octet sequence",
+                                    "incomplete UTF-8 octet sequence",
                                     parser->offset, -1);
                         }
                         incomplete = 1;
@@ -264,7 +269,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
                         if ((octet & 0xC0) != 0x80)
                             return yaml_parser_set_reader_error(parser,
-                                    "Invalid trailing UTF-8 octet",
+                                    "invalid trailing UTF-8 octet",
                                     parser->offset+k, octet);
 
                         /* Decode the octet. */
@@ -279,14 +284,14 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
                             (width == 3 && value >= 0x800) ||
                             (width == 4 && value >= 0x10000)))
                         return yaml_parser_set_reader_error(parser,
-                                "Invalid length of a UTF-8 sequence",
+                                "invalid length of a UTF-8 sequence",
                                 parser->offset, -1);
 
                     /* Check the range of the value. */
 
                     if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
                         return yaml_parser_set_reader_error(parser,
-                                "Invalid Unicode character",
+                                "invalid Unicode character",
                                 parser->offset, value);
 
                     break;
@@ -328,7 +333,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
                     if (raw_unread < 2) {
                         if (parser->eof) {
                             return yaml_parser_set_reader_error(parser,
-                                    "Incomplete UTF-16 character",
+                                    "incomplete UTF-16 character",
                                     parser->offset, -1);
                         }
                         incomplete = 1;
@@ -344,7 +349,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
                     if ((value & 0xFC00) == 0xDC00)
                         return yaml_parser_set_reader_error(parser,
-                                "Unexpected low surrogate area",
+                                "unexpected low surrogate area",
                                 parser->offset, value);
 
                     /* Check for a high surrogate area. */
@@ -358,7 +363,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
                         if (raw_unread < 4) {
                             if (parser->eof) {
                                 return yaml_parser_set_reader_error(parser,
-                                        "Incomplete UTF-16 surrogate pair",
+                                        "incomplete UTF-16 surrogate pair",
                                         parser->offset, -1);
                             }
                             incomplete = 1;
@@ -374,7 +379,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
 
                         if ((value2 & 0xFC00) != 0xDC00)
                             return yaml_parser_set_reader_error(parser,
-                                    "Expected low surrogate area",
+                                    "expected low surrogate area",
                                     parser->offset+2, value2);
 
                         /* Generate the value of the surrogate pair. */
@@ -409,7 +414,7 @@ yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
                         || (value >= 0xE000 && value <= 0xFFFD)
                         || (value >= 0x10000 && value <= 0x10FFFF)))
                 return yaml_parser_set_reader_error(parser,
-                        "Control characters are not allowed",
+                        "control characters are not allowed",
                         parser->offset, value);
 
             /* Move the raw pointers. */

data/src/vendor/libyaml/scanner.c

@@ -1118,9 +1118,11 @@ yaml_parser_save_simple_key(yaml_parser_t *parser)
 
     if (parser->simple_key_allowed)
     {
-        yaml_simple_key_t simple_key = { 1, required,
-            parser->tokens_parsed + parser->tokens.tail - parser->tokens.head,
-            { 0, 0, 0 } };
+        yaml_simple_key_t simple_key;
+        simple_key.possible = 1;
+        simple_key.required = required;
+        simple_key.token_number = 
+            parser->tokens_parsed + parser->tokens.tail - parser->tokens.head;
         simple_key.mark = parser->mark;
 
         if (!yaml_parser_remove_simple_key(parser)) return 0;

data/src/vendor/libyaml/writer.c

@@ -58,7 +58,7 @@ yaml_emitter_flush(yaml_emitter_t *emitter)
             return 1;
         }
         else {
-            return yaml_emitter_set_writer_error(emitter, "Write error");
+            return yaml_emitter_set_writer_error(emitter, "write error");
         }
     }
 
@@ -135,7 +135,7 @@ yaml_emitter_flush(yaml_emitter_t *emitter)
         return 1;
     }
     else {
-        return yaml_emitter_set_writer_error(emitter, "Write error");
+        return yaml_emitter_set_writer_error(emitter, "write error");
     }
 }
 

data/src/vendor/libyaml/yaml_private.h

@@ -113,6 +113,11 @@ yaml_string_join(
 
 #define STRING(string,length)   { (string), (string)+(length), (string) }
 
+#define STRING_ASSIGN(value,string,length)                                      \
+    ((value).start = (string),                                                  \
+     (value).end = (string)+(length),                                           \
+     (value).pointer = (string))
+
 #define STRING_INIT(context,string,size)                                        \
     (((string).start = yaml_malloc(size)) ?                                     \
         ((string).pointer = (string).start,                                     \

data/src/worker/wkr_http_response.h

@@ -29,6 +29,7 @@ struct http_resp_s {
   size_t            bytes_write;
   scgi_t    *scgi;
   wr_buffer_t       *resp_body;
+  int content_encoding;
   wr_str_t          header;
 #ifdef _POSIX_C_SOURCE
   int              file;

data/src/worker/wkr_main.c

@@ -130,7 +130,7 @@ void wr_worker_config_read(){
   }
   
   wr_set_numeric_value(root, "Worker/maximum_request_body_size", &Config->Worker.max_body_size, FALSE);
-  node_free(root);
+  yaml_node_free(root);
   
   Config->Worker.Compress.lower_limit = DEFAULT_LOWER_LIMIT;
   Config->Worker.Compress.upper_limit = DEFAULT_UPPER_LIMIT;
@@ -274,7 +274,7 @@ int main(int argc, char **argv) {
   w = worker_new(loop, tmp);
   
   if(w==NULL){
-    wr_worker_config_free(Config);
+    cleanup();
     return -1;
   }
 

data/src/worker/wkr_static.c

@@ -34,11 +34,14 @@
 extern config_t *Config;
 
 #define DEFAULT_EXPIRES "Headers/expires"
-#define EXPIRES_BY_TYPE "Headers/expires_by_type"
-#define EXPIRES_BY_TYPE_EXT "expires_by_type/ext"
-#define EXPIRES_BY_TYPE_EXPIRES "expires_by_type/expires"
+#define EXPIRES_BY_TYPE "Headers/expires_by_type/*"
+#define EXPIRES_BY_TYPE_EXT "ext"
+#define EXPIRES_BY_TYPE_EXPIRES "expires"
 #define HTTP_HEADER_IF_MODIFIED_SINCE "HTTP_IF_MODIFIED_SINCE"
 #define HTTP_HEADER_CONNECTION "HTTP_CONNECTION"
+#define WR_NO_ENCODING 0
+#define WR_DEFLATE_ENCODING 1
+#define WR_GZIP_ENCODING 2
 
 #define CONNECTION_CLOSE "Close"
 #define CONNECTION_KEEP_ALIVE "Keep-Alive"
@@ -47,6 +50,15 @@ extern config_t *Config;
 #define WR_MSG_QUEUE_SERVER_PORT "starling/port"
 #define WR_PID_MSG_QUEUE_NAME "starling/pid_queue_name"
 
+/* from zutil.h */
+#ifndef DEF_MEM_LEVEL
+#if MAX_MEM_LEVEL >= 8
+#define DEF_MEM_LEVEL  8
+#else
+#define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+#endif
+
 typedef enum {
   HTTP_STATUS_200 = 0,
   HTTP_STATUS_304,
@@ -213,7 +225,7 @@ short get_resp_code(static_server_t *s) {
 }
 
 long int get_default_expires(node_t *root) {
-  char *node_value = get_node_value(root, DEFAULT_EXPIRES);
+  char *node_value = yaml_get_value(root, DEFAULT_EXPIRES);
 
   if (node_value == NULL) {
     //return EXPIRES_DURATION;
@@ -241,7 +253,7 @@ int create_dictionary(static_server_t *s, const char *mapping_file, long int exp
     return -1;
   }
 
-  node = get_nodes(root, "File Extensions");
+  node = yaml_get_node(root, "File Extensions");
 
   if (root == NULL || node->child == NULL) {
     LOG_ERROR(SEVERE, "Could not read 'File Extensions' from the file %s", mapping_file);
@@ -252,7 +264,7 @@ int create_dictionary(static_server_t *s, const char *mapping_file, long int exp
 
   while (node) {
     ext = wr_malloc(static_file_t);
-    strcpy(ext->ext, node->name);
+    strcpy(ext->ext, node->key);
     strcpy(ext->mime_type, node->value);
     ext->expires = expires;
     int index;
@@ -273,7 +285,7 @@ int create_dictionary(static_server_t *s, const char *mapping_file, long int exp
     }
     node = node->next;
   }
-  node_free(root);
+  yaml_node_free(root);
 
   // Set default mime type
   ext = wr_malloc(static_file_t);
@@ -287,37 +299,145 @@ int create_dictionary(static_server_t *s, const char *mapping_file, long int exp
 }
 
 void set_expires_by_type(static_server_t *s, node_t *root) {
-  node_t *node = get_nodes(root, EXPIRES_BY_TYPE);
+  node_t *node = yaml_get_node(root, EXPIRES_BY_TYPE);
   long int expires;
   char *types, *expires_str, *type;
   while (node) {
-    types = get_node_value(node, EXPIRES_BY_TYPE_EXT);
-    expires_str = get_node_value(node, EXPIRES_BY_TYPE_EXPIRES);
+    types = yaml_get_value(node->child, EXPIRES_BY_TYPE_EXT);
+    expires_str = yaml_get_value(node->child, EXPIRES_BY_TYPE_EXPIRES);
     expires = atol(expires_str);
     type = strtok(types, " ,");
     while (type != NULL) {
       set_expires_time(s, type, expires);
       type = strtok(NULL, " ,");
     }
-    node = NODE_NEXT(node);
+    node = node->next;
   }
 }
 
 
 #ifdef W_ZLIB
 
+int deflate_file_compression(http_t *h) {
+  if(compress2((Bytef*)h->resp->resp_body->str, (uLongf*)&h->resp->resp_body->size,
+              (const Bytef*)h->stat->buffer->str, (uLongf)h->stat->buffer->len, Z_DEFAULT_COMPRESSION) != Z_OK){
+    wr_buffer_null(h->stat->buffer);
+    wr_buffer_null(h->resp->resp_body);
+    return FALSE;
+  } else {
+    h->resp->resp_body->len = h->resp->resp_body->size;
+    return TRUE;
+  } 
+}
+
+int gzip_file_compression(http_t *h) {  
+  z_stream c_stream;
+  int err;
+
+  c_stream.zalloc = NULL;
+  c_stream.zfree = NULL;
+  c_stream.opaque = NULL;
+  c_stream.total_out = 0;
+
+  err = deflateInit2(&c_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                     15+16, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+                     
+  if (err != Z_OK) {
+    LOG_ERROR(WARN,"Deflate Init error"); 
+    return FALSE;
+  }
+
+  c_stream.next_in = (Bytef*) h->stat->buffer->str;
+  c_stream.avail_in = h->stat->buffer->len;
+  c_stream.next_out = (Bytef*) h->resp->resp_body->str;
+  c_stream.avail_out = h->resp->resp_body->size;
+  
+  do {      
+    c_stream.next_out = (Bytef*) (h->resp->resp_body->str + c_stream.total_out);
+
+    // Calculate the amount of remaining free space in the output buffer
+    // by subtracting the number of bytes that have been written so far
+    // from the buffer's total capacity
+    c_stream.avail_out = h->resp->resp_body->size - c_stream.total_out;
+    err = deflate(&c_stream, Z_FINISH);   
+  } while (err == Z_OK);
+  
+  if (err = Z_STREAM_END) {      
+    err = deflateEnd(&c_stream);
+    if ( err != Z_OK) {
+      LOG_ERROR(WARN, "Deflate End error"); 
+      return FALSE;
+    } else {
+      h->resp->resp_body->len = c_stream.total_out;
+      return TRUE;
+    }     
+  } else {
+    switch (err) {
+    case Z_ERRNO:
+      LOG_ERROR(WARN, "Error occured while reading file.");
+      break;
+    case Z_STREAM_ERROR:
+      LOG_ERROR(WARN, "The stream state was inconsistent (e.g., next_in or next_out was NULL).");
+      break;
+    case Z_DATA_ERROR:
+      LOG_ERROR(WARN, "The deflate data was invalid or incomplete.");
+      break;
+    case Z_MEM_ERROR:
+      LOG_ERROR(WARN, "Memory could not be allocated for processing.");
+      break;
+    case Z_BUF_ERROR:
+      LOG_ERROR(WARN, "Ran out of output buffer for writing compressed bytes.");
+      break;
+    case Z_VERSION_ERROR:
+      LOG_ERROR(WARN, "The version of zlib.h and the version of the library linked do not match.");
+      break;
+    default:
+      LOG_ERROR(WARN, "Unknown error code.");
+      break;
+    }
+    return FALSE;
+  }  
+}
 /** Compress file */
 /* Compress file if its size is >10kb and < 1mb and its mime-type has either
  * text or xml */
 
-int file_compress(http_t *h, static_file_t *ext){
-  LOG_FUNCTION  
+int file_compress(http_t *h, static_file_t *ext) {
+  LOG_FUNCTION
+  int rv=0;
+  char *cache_control=NULL;
+  
+  cache_control = scgi_header_value_get(h->req->scgi, "Cache-Control");
+  if(cache_control && strstr(cache_control, "no-transform")) {
+    return FALSE;
+  }
+  
   h->stat->encoding = scgi_header_value_get(h->req->scgi, "HTTP_ACCEPT_ENCODING");
   h->stat->user_agent = scgi_header_value_get(h->req->scgi, "HTTP_USER_AGENT");
-  
-  if(h->stat->buf.st_size >= Config->Worker.Compress.lower_limit 
-     && h->stat->buf.st_size <= Config->Worker.Compress.upper_limit
-     && h->stat->encoding && strstr(h->stat->encoding,"deflate")){
+  /*  Skip compressing entity body if user agent is IE6
+      refer http://schroepl.net/projekte/mod_gzip/browser.htm and 
+      http://support.microsoft.com/default.aspx?scid=kb;en-us;Q313712
+      for problem details
+  */
+  if(h->stat->user_agent && strstr(h->stat->user_agent, "MSIE 6.0")) {
+    return FALSE;
+  }
+
+  if(h->stat->buf.st_size >= Config->Worker.Compress.lower_limit
+      && h->stat->buf.st_size <= Config->Worker.Compress.upper_limit
+      && h->stat->encoding) {
+    //TODO: look into Cache-Control request header and q value of Accept-Encoding request header
+    // to decide correct encoding
+    if (strstr(h->stat->encoding, "gzip")) {
+      h->resp->content_encoding = WR_GZIP_ENCODING;
+    }
+    else if (strstr(h->stat->encoding, "deflate")) {
+      h->resp->content_encoding = WR_DEFLATE_ENCODING;
+    }
+    else {
+      h->resp->content_encoding = WR_NO_ENCODING;
+      return FALSE;
+    }
 
 #ifdef W_REGEX
      if(h->stat->r_content_type){
@@ -338,6 +458,11 @@ int file_compress(http_t *h, static_file_t *ext){
     wr_u_int read;
     FILE *file;
     wr_buffer_create(h->stat->buffer, h->stat->buf.st_size);
+    
+    if(h->stat->buffer->str == NULL) {
+      return FALSE;
+    }
+    
     file = fopen(h->stat->path, "r");
 
     if(file == NULL) return FALSE;
@@ -357,18 +482,26 @@ int file_compress(http_t *h, static_file_t *ext){
 
     //zlib states that the source buffer must be at least 0.1 times larger than 
     //the source buffer plus 12 bytes to cope with the overhead of zlib data streams
-    wr_buffer_create(h->resp->resp_body, h->stat->buf.st_size + h->stat->buf.st_size*0.1 + 12);
-    h->resp->resp_body->len = h->resp->resp_body->size;
-    //now compress the data
-    if(compress2((Bytef*)h->resp->resp_body->str, (uLongf*)&h->resp->resp_body->len,
-                (const Bytef*)h->stat->buffer->str, (uLongf)h->stat->buffer->len, Z_DEFAULT_COMPRESSION) != Z_OK){
-      wr_buffer_null(h->stat->buffer);
-      wr_buffer_null(h->resp->resp_body);
-      return FALSE;
+    wr_buffer_create(h->resp->resp_body, h->stat->buf.st_size * 1.01 + 12);
+    
+    switch(h->resp->content_encoding) {
+      case WR_GZIP_ENCODING:
+        rv = gzip_file_compression(h);        
+        LOG_DEBUG(DEBUG, "Done gzip encoding rv = %d", rv);        
+        break;
+      case WR_DEFLATE_ENCODING:
+        rv = deflate_file_compression(h);
+        LOG_DEBUG(DEBUG, "Done deflate encoding rv = %d", rv);
+        break;  
     }
+    
     wr_buffer_null(h->stat->buffer);
-
-    return TRUE;
+    
+    if(rv == FALSE) {
+      wr_buffer_null(h->resp->resp_body);
+    }
+    
+    return rv;
   }
   return FALSE; 
 } 
@@ -379,7 +512,7 @@ void http_resp_200(http_t *h) {
   LOG_FUNCTION
   char str[STR_SIZE512], expire_date[STR_SIZE64] = "", current_date[STR_SIZE64] = "", modify_date[STR_SIZE64] = "";
   int len;
-  int ret_val;
+  int ret_val = FALSE;
   time_t t;
   
   static_file_t *ext = get_mime_type(h->stat);
@@ -407,16 +540,16 @@ void http_resp_200(http_t *h) {
     t += ext->expires;
     time_to_httpdate(t, expire_date, STR_SIZE64);
     len = sprintf(str, "HTTP/1.1 200 OK\r\nDate: %s\r\nServer: %s-%s\r\nLast-Modified: %s\r\nExpires: %s\r\nConnection: %s\r\n%sContent-Type: %s\r\nContent-Length: %d\r\n\r\n",
-            current_date, Config->Worker.Server.name.str, Config->Worker.Server.version.str, modify_date, expire_date,
-            (conn_header ? conn_header : CONNECTION_CLOSE),
-            (ret_val == TRUE ? "Content-Encoding: deflate\r\n" : ""),
-            ext->mime_type, h->resp->resp_body->len);
-  }else {
+                  current_date, Config->Worker.Server.name.str, Config->Worker.Server.version.str, modify_date, expire_date,
+                  (conn_header ? conn_header : CONNECTION_CLOSE),
+                  (ret_val == TRUE ? (h->resp->content_encoding == WR_GZIP_ENCODING ? "Content-Encoding: gzip\r\n" : "Content-Encoding: deflate\r\n") : ""),
+                  ext->mime_type, h->resp->resp_body->len);
+  } else {
     len = sprintf(str, "HTTP/1.1 200 OK\r\nDate: %s\r\nServer: %s-%s\r\nLast-Modified: %s\r\nConnection: %s\r\n%sContent-Type: %s\r\nContent-Length: %d\r\n\r\n",
-             current_date, Config->Worker.Server.name.str, Config->Worker.Server.version.str, modify_date,
-            (conn_header ? conn_header : CONNECTION_CLOSE),
-            (ret_val == TRUE ? "Content-Encoding: deflate\r\n" : ""), 
-            ext->mime_type, h->resp->resp_body->len);
+                  current_date, Config->Worker.Server.name.str, Config->Worker.Server.version.str, modify_date,
+                  (conn_header ? conn_header : CONNECTION_CLOSE),
+                  (ret_val == TRUE ? (h->resp->content_encoding == WR_GZIP_ENCODING ? "Content-Encoding: gzip\r\n" : "Content-Encoding: deflate\r\n") : ""),
+                  ext->mime_type, h->resp->resp_body->len);
   }
 
   wr_string_new(h->resp->header, str, len);
@@ -507,9 +640,9 @@ void send_static_worker_pid() {
     char msg_value[STR_SIZE32];
     int rv;
     
-    host = get_node_value(root, WR_MSG_QUEUE_SERVER_HOST);
-    port = get_node_value(root, WR_MSG_QUEUE_SERVER_PORT);
-    queue_name = get_node_value(root, WR_PID_MSG_QUEUE_NAME);    
+    host = yaml_get_value(root, WR_MSG_QUEUE_SERVER_HOST);
+    port = yaml_get_value(root, WR_MSG_QUEUE_SERVER_PORT);
+    queue_name = yaml_get_value(root, WR_PID_MSG_QUEUE_NAME);
     if (!host || !port || !queue_name) {
       LOG_ERROR(SEVERE, "Error getting message queue configuration");
       goto err; 
@@ -537,7 +670,7 @@ void send_static_worker_pid() {
       LOG_INFO("PID sent to queue successfully."); 
     }
 err:    
-    node_free(root);
+    yaml_node_free(root);
     wr_msg_queue_conn_free(msg_queue_conn);
     wr_msg_queue_server_free(msg_queue_server);
     return;
@@ -559,13 +692,13 @@ int static_module_init(static_server_t *s) {
   expires = get_default_expires(root);
   
   if (create_dictionary(s, Config->Worker.File.mime_type.str, expires) != 0) {
-    node_free(root);
+    yaml_node_free(root);
     return FALSE;
   }
 
   set_expires_by_type(s, root);
 
-  node_free(root);
+  yaml_node_free(root);
   
   send_static_worker_pid();
   return TRUE;

data/src/worker/worker.c

@@ -109,6 +109,9 @@ wkr_t* worker_new(struct ev_loop *loop, wkr_tmp_t *tmp) {
   w->loop = loop;
   wr_string_null(w->sock_path);
   w->listen_port = 0;
+  w->w_accept.active = 0;
+  w->w_req.active = 0;
+  w->http = NULL;
 
   w->tmp = tmp;
   assert(w->tmp!=NULL);
@@ -154,15 +157,11 @@ void worker_free(wkr_t **wrk) {
       unlink(w->sock_path.str);
       wr_string_free(w->sock_path);
     }
-    ev_io_stop(w->loop, &(w->w_accept));
-    ev_io_stop(w->loop, &(w->ctl->w_read));
-    if(w->http)
-      http_free(&w->http);    
-    if(w->tmp)
-      wkr_tmp_free(&w->tmp);
-    if(w->ctl)
-      wkr_ctl_free(&w->ctl);
-
+    if(ev_is_active(&w->w_accept)) ev_io_stop(w->loop, &(w->w_accept));
+    if(ev_is_active(&w->ctl->w_read)) ev_io_stop(w->loop, &(w->ctl->w_read));
+    if(w->http)       http_free(&w->http);
+    if(w->tmp)        wkr_tmp_free(&w->tmp);
+    if(w->ctl)        wkr_ctl_free(&w->ctl);
     wr_string_list_free(w->env_var);
     free(w);
   }

data/tasks/gem.rake

@@ -36,8 +36,8 @@ spec = Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.summary               = "A ruby application server."
   s.description           = "WebROaR is an application server that makes deployments of ruby web applications extremely simple. It provides an integrated solution to view the run time performance numbers and email notifications in case any exceptions occur in any of the deployed applications. It is 5 to 55% faster than all other comparable deployment stacks for Ruby on Rails applications. Check out http://webroar.in for more details."
-  s.authors               = ["Aditya Babbar", "Dharmarth Shah", "Nikunj Limbaseeya"]
-  s.email                 = ["aditya.babbar@webroar.in", "dharmarth.shah@webroar.in", "nikunj.limbaseeya@webroar.in"]
+  s.authors               = ["Dharmarth Shah", "Nikunj Limbaseeya"]
+  s.email                 = ["dharmarth.shah@webroar.in", "nikunj.limbaseeya@webroar.in"]
   s.homepage              = "http://webroar.in"
   s.rubyforge_project     = "webroar"
   s.has_rdoc              = false
@@ -49,7 +49,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency 'calendar_date_select', '>= 1.15'  
   s.add_dependency 'rack', '>= 1.0.1'
   s.add_dependency 'rake', '>= 0.8.1'  
-  s.add_dependency 'rspec', '>=1.2.2'
+  s.add_dependency 'rspec', '~>1.3.1'
   s.add_dependency 'sqlite3-ruby', '>=1.2.3'
   s.add_dependency 'starling', '>=0.10.0'
   s.add_dependency 'will_paginate', '~>2.3.12'