webroar 0.3.1 → 0.4.0

data/src/worker/wkr_static.h

@@ -19,7 +19,13 @@
 #ifndef WKR_STATIC_H_
 #define WKR_STATIC_H_
 
-#include <wkr_http.h>
+#include <wkr_http_response.h>
+#if defined(W_ZLIB) && defined(W_REGEX)
+#include <regex.h>
+#endif
+
+#define MAP_SIZE 36
+#define DEFAULT_CONTENT_TYPE "javascript|css|xml|text"
 
 typedef struct static_file_s{
     char ext[10];
@@ -28,13 +34,20 @@ typedef struct static_file_s{
     struct static_file_s *next;
 }static_file_t;
 
-/* Initialize extension and mime-type map */
-int static_module_init(char *root_path);
+typedef struct static_server_s{
+  struct stat     buf;
+  const char      *path, *encoding, *user_agent, *modify;
+  wr_buffer_t     *buffer;  // Buffer to
+  static_file_t   *map[MAP_SIZE + 1];
+#if defined(W_ZLIB) && defined(W_REGEX) 
+  regex_t         *r_user_agent, *r_content_type;
+#endif
+}static_server_t;
 
-/* Free extension and mime-type map */
-void static_module_free();
+static_server_t * static_server_new(void *worker);
+void static_server_free(static_server_t *stat);
 
 /* Serve the static file content */
-void static_file_process(http_t *h);
+void static_file_process(void *http);
 
-#endif /*WKR_STATIC_H_*/
+#endif /*WKR_STATIC_H_*/

data/src/worker/worker.c

@@ -33,6 +33,15 @@
 #include <netinet/in.h>
 #include <sys/un.h>
 #include <ev.c>
+#include <pwd.h>
+
+#ifdef __linux__
+#include <sys/prctl.h>
+#endif
+
+extern config_t *Config;
+
+void load_application(wkr_t* w);
 
 wkr_tmp_t* wkr_tmp_new() {
   LOG_FUNCTION
@@ -46,23 +55,23 @@ wkr_tmp_t* wkr_tmp_new() {
   wr_string_null(tmp->type);
   wr_string_null(tmp->name);
   wr_string_null(tmp->resolver);
-  wr_string_null(tmp->ruby_path);
-  wr_string_null(tmp->script_path);
   wr_string_null(tmp->root_path);
   wr_string_null(tmp->ctl_path);
   wr_string_null(tmp->log_file);
 
-  //  tmp->path = tmp->env = tmp->type = tmp->name =
-  //  tmp->resolver = tmp->ruby_path = tmp->script_path =
-  //  tmp->root_path = tmp->ctl_path = tmp->log_file = NULL;
-
   tmp->profiler = 'n';
   tmp->gid = tmp->uid = 0;
   // HTTP1.1 assumes persistent connection by default
   tmp->keep_alive = TRUE;
   tmp->is_uds = FALSE;
   tmp->is_static = 0;
-
+#ifdef W_ZLIB
+  tmp->lower_limit = tmp->upper_limit = 0;
+#ifdef W_REGEX
+  wr_string_null(tmp->r_user_agent);
+  wr_string_null(tmp->r_content_type);
+#endif
+#endif
   return tmp;
 }
 
@@ -75,23 +84,13 @@ void wkr_tmp_free(wkr_tmp_t** t) {
     wr_string_free(tmp->type);
     wr_string_free(tmp->name);
     wr_string_free(tmp->resolver);
-    wr_string_free(tmp->ruby_path);
-    wr_string_free(tmp->script_path);
     wr_string_free(tmp->root_path);
     wr_string_free(tmp->ctl_path);
     wr_string_free(tmp->log_file);
-
-    //    if(tmp->path)      free(tmp->path);
-    //    if(tmp->env)        free(tmp->env);
-    //    if(tmp->type)      free(tmp->type);
-    //    if(tmp->name)      free(tmp->name);
-    //    if(tmp->resolver)    free(tmp->resolver);
-    //    if(tmp->ruby_path)  free(tmp->ruby_path);
-    //    if(tmp->script_path)  free(tmp->script_path);
-    //    if(tmp->root_path)  free(tmp->root_path);
-    //    if(tmp->ctl_path)    free(tmp->ctl_path);
-    //    if(tmp->log_file)    free(tmp->log_file);
-
+#if defined(W_ZLIB) && defined(W_REGEX)
+    wr_string_free(tmp->r_content_type);
+    wr_string_free(tmp->r_user_agent);
+#endif
     free(tmp);
   }
   *t = NULL;
@@ -114,38 +113,25 @@ wkr_t* worker_new(struct ev_loop *loop, wkr_tmp_t *tmp) {
   w->tmp = tmp;
   assert(w->tmp!=NULL);
 
-  w->ctl = wkr_ctl_new();
+  w->env_var = NULL;
+  
+  w->ctl = wkr_ctl_new(w);
   assert(w->ctl!=NULL);
-
-  // Connect to head controller UDS socket before user previliges get lowered.
-  if(tmp->is_uds) {
-    struct sockaddr_un addr;
-
-    if ((w->ctl->fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
-      LOG_ERROR(WARN,"socket()%s",strerror(errno));
-      worker_free(&w);
-      return NULL;
-    }
-
-    setsocketoption(w->ctl->fd);
-
-    memset(&addr, 0, sizeof(addr));
-    addr.sun_family = AF_UNIX;
-    strcpy(addr.sun_path, tmp->ctl_path.str);
-
-    int len = sizeof(addr.sun_family)+strlen(addr.sun_path);
-#ifdef __APPLE__
-    len ++;
-#endif
-
-    LOG_DEBUG(DEBUG,"send_ack_on_unix_socket() connecting with socket %s",addr.sun_path);
-    if(connect(w->ctl->fd, (struct sockaddr *)&addr, len) < 0) {
-      LOG_ERROR(SEVERE,"Connect with controller fd failed: %s",strerror(errno));
-      worker_free(&w);
-      return NULL;
-    }
+  if(connect_to_head(w) == FALSE){
+    worker_free(&w);
+    return NULL;
+  }
+  start_ctl_watcher(w);
+/*  if(w->tmp->is_static){
+    w->ctl->scgi = scgi_new();
+    load_application(w);
+  } else */ if(send_config_req_msg(w) < 0){
+    worker_free(&w);
+    return NULL;
   }
 
+  // Connect to head controller UDS socket before user previliges get lowered.
+  
   return w;
 }
 
@@ -157,7 +143,6 @@ void worker_free(wkr_t **wrk) {
       close(w->req_fd);
     if(w->listen_fd > 0)
       close(w->listen_fd);
-    //    if(w->sock_path){
     if(w->sock_path.str) {
       // Set root privilege to remove socket file.
       //      if(setegid(0)!=0){
@@ -168,8 +153,6 @@ void worker_free(wkr_t **wrk) {
       //      }
       unlink(w->sock_path.str);
       wr_string_free(w->sock_path);
-      //      unlink(w->sock_path);
-      //      free(w->sock_path);
     }
     ev_io_stop(w->loop, &(w->w_accept));
     ev_io_stop(w->loop, &(w->ctl->w_read));
@@ -180,13 +163,14 @@ void worker_free(wkr_t **wrk) {
     if(w->ctl)
       wkr_ctl_free(&w->ctl);
 
+    wr_string_list_free(w->env_var);
     free(w);
   }
   *wrk=NULL;
 }
 
 /** Conenct worker on internet socket */
-static inline int connect_internet_socket(wkr_t* w) {
+int listen_internet_socket(wkr_t* w) {
   LOG_FUNCTION
   struct sockaddr_in addr;
   if ((w->listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
@@ -223,8 +207,7 @@ static inline int connect_internet_socket(wkr_t* w) {
   return 0;
 }
 
-/** Connect worker on unix domain socket */
-static inline int connect_unix_socket(wkr_t* w) {
+int listen_unix_socket(wkr_t* w) {
   LOG_FUNCTION
   struct sockaddr_un addr;
 
@@ -241,19 +224,14 @@ static inline int connect_unix_socket(wkr_t* w) {
   memset(&addr, 0, sizeof(addr));
   /* Preparing socket path unique to this worker*/
   w->sock_path.str = (char*) malloc(sizeof(char)*50);
-  w->sock_path.len = sprintf(w->sock_path.str, "%s_%d",WR_WKR_SOCK_PATH,getpid());
+  w->sock_path.len = sprintf(w->sock_path.str, "%s_%d", Config->Worker.sock_path.str, getpid());
 
-  //  w->sock_path = wr_malloc_CHAR(50);
-  //  sprintf(w->sock_path, "%s_%d",WR_WKR_SOCK_PATH,getpid());
-
-  //  LOG_DEBUG(DEBUG,"connect_unix_socket() socket name is %s",w->sock_path);
   LOG_DEBUG(DEBUG,"connect_unix_socket() socket name is %s",w->sock_path.str);
 
   addr.sun_family = AF_UNIX;
   //strcpy(addr.sun_path,w->sock_path);
   strcpy(addr.sun_path,w->sock_path.str);
   unlink(addr.sun_path);
-  //  LOG_DEBUG(DEBUG,"connect_unix_socket() Binding worker at socket path %s",w->sock_path);
   LOG_DEBUG(DEBUG,"connect_unix_socket() Binding worker at socket path %s",w->sock_path.str);
 
   int len = sizeof(addr.sun_family) + strlen(addr.sun_path);
@@ -277,20 +255,20 @@ static inline int connect_unix_socket(wkr_t* w) {
 
 
 /** Connect worket to Head */
-int worker_connect(wkr_t* w) {
+int worker_listen(wkr_t* w) {
   LOG_FUNCTION
+  int retval;
   if(w->is_uds == 1) {
-    if(connect_unix_socket(w) >= 0)
-      return send_ack_on_unix_socket(w);
-  } else {
-    if(connect_internet_socket(w) >=0)
-      return send_ack_on_internet_socket(w);
+    return listen_unix_socket(w);
+  }else{
+    return listen_internet_socket(w);
   }
-  return -1;
+
+//  if(retval >= 0 ) return send_ack_ctl_msg(w);
 }
 
 /** This function accept connection from Head. */
-static void request_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+void request_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
   LOG_FUNCTION
   wkr_t *w = (wkr_t*) watcher->data;
 
@@ -332,5 +310,202 @@ void worker_accept_requests(wkr_t* w) {
   w->w_accept.data = w;
   ev_io_init(&(w->w_accept), request_accept_cb, w->listen_fd, EV_READ);
   ev_io_start(w->loop,&(w->w_accept));
+  //wkr_tmp_free(&w->tmp);
+}
+
+int drop_privileges(wkr_t *w, scgi_t *scgi) {
+  char *str;
+  
+  str = (char*) scgi_header_value_get(scgi, "USER");
+  
+  if(str && strlen(str) > 0) {
+    struct passwd *user_info=NULL;
+    user_info = getpwnam(str);
+    // Check for user existence
+    if(user_info) {
+      w->tmp->uid = user_info->pw_uid; 
+      w->tmp->gid = user_info->pw_gid;
+    } else {
+      scgi_body_add(w->ctl->scgi, "Application run_as_user is invalid. Application not started.", strlen("Application run_as_user is invalid. Application not started."));
+      LOG_ERROR(SEVERE,"Application run_as_user is invalid. Application not started.");
+      return FALSE;
+    }
+  } else {
+    scgi_body_add(w->ctl->scgi, "Application run_as_user is missing. Application not started.", strlen("Application run_as_user is missing. Application not started."));
+    LOG_ERROR(SEVERE,"Application run_as_user is missing. Application not started.");
+    return FALSE;
+  }
+  
+  change_log_file_owner(w->tmp->uid, w->tmp->gid);
+  //setting read, effective, saved group and user id
+  if(setgid(w->tmp->gid)!=0) {
+    scgi_body_add(w->ctl->scgi, "setegid() failed", strlen("setegid() failed"));
+    LOG_ERROR(SEVERE,"setegid() failed");
+    return FALSE;
+  }
+  if(setuid(w->tmp->uid)!=0) {
+    scgi_body_add(w->ctl->scgi, "seteuid() failed", strlen("seteuid() failed"));
+    LOG_ERROR(SEVERE,"seteuid() failed");
+    return FALSE;
+  }
+  
+  LOG_DEBUG(DEBUG,"Passed userid=%d and groupid=%d",
+            w->tmp->uid, w->tmp->gid);
+  LOG_DEBUG(DEBUG,"effective userid=%d and groupid=%d",geteuid(),getegid());
+#ifdef __linux__
+  int rv = prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
+  LOG_DEBUG(DEBUG,"prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) = %d", rv);
+  if (rv < 0) {
+    LOG_ERROR(SEVERE,"error setting prctl(PR_SET_DUMPABLE, 1, 0, 0, 0), errno = %d, desc = %s", errno, strerror(errno));
+  }
+#endif  
+  return TRUE;
+}
+
+void manipulate_environment_variable(wkr_t* w, scgi_t *scgi) {
+  LOG_FUNCTION
+  char *var, *str;
+  int rv = 0;  
+    
+  str = (char*) scgi_header_value_get(scgi, "ENV_VAR");
+  w->env_var = wr_string_list_new();  
+  if(str){    
+    var = strtok(str,"#");
+    while(var){
+      LOG_DEBUG(DEBUG,"Environment variable string = %s", var);
+      wr_string_list_add(w->env_var, var, strlen(var));
+       // TODO: see the security concerns     
+      rv = putenv(w->env_var->rear->str.str);
+      if (rv != 0) {
+        LOG_ERROR(WARN, "putenv() failed, errno = %d, description = %s", errno, strerror(errno)); 
+      } 
+      var = strtok(NULL,"#");
+    }
+  }
+}
+
+void load_application(wkr_t* w){
+  LOG_FUNCTION
+  
+  w->ctl->scgi = scgi_new();
+  if(w->ctl->scgi == NULL) {
+    LOG_ERROR(SEVERE,"Cannot create SCGI Request");
+    sigproc();
+    return;
+  }
+  
+  w->http = http_new(w);
+  if(w->http == NULL) {
+    scgi_body_add(w->ctl->scgi, "unable to load application.", strlen("unable to load application."));
+    LOG_ERROR(SEVERE,"unable to load application.");
+  }else if(worker_listen(w) < 0) {
+    scgi_body_add(w->ctl->scgi, "Error Initializing Workers.", strlen("Error Initializing Workers."));
+    LOG_ERROR(WARN,"Error Initializing Workers.");
+  }else{
+    worker_accept_requests(w);
+    LOG_INFO("Worker ready for serving requests.");
+    init_idle_watcher(w);
+    
+    LOG_INFO("Successfully loaded rack application=%s with environment=%s",
+             w->tmp->path.str,   w->tmp->env.str);
+  }  
+  
+  //loading adapter according to application type
+  LOG_DEBUG(DEBUG,"webroar_root = %s", w->tmp->root_path.str);
+  LOG_DEBUG(DEBUG,"path = %s, name = %s, type = %s, environment = %s, baseuri = %s, analytics = %c",
+            w->tmp->path.str,  w->tmp->name.str, w->tmp->type.str,
+            w->tmp->env.str, w->tmp->resolver.str, w->tmp->profiler);
+  
+  // Send error or ok acknowledgement message
+  if(w->ctl->scgi->body_length > 0){
+    // Send error response
+    w->ctl->error = TRUE;
+    get_worker_add_ctl_scgi(w, TRUE);
+    ev_io_start(w->loop,&(w->ctl->w_write));
+    ev_timer_again(w->loop, &w->ctl->t_ack);
+  }else{
+    // Send acknowledgement message
+    get_worker_add_ctl_scgi(w, FALSE);
+    ev_io_start(w->loop,&(w->ctl->w_write));        
+  }
   wkr_tmp_free(&w->tmp);
 }
+
+void application_config_read_cb(wkr_t* w, scgi_t *scgi){
+  LOG_FUNCTION
+  char *str;
+  /*w->ctl->scgi = scgi_new();
+  
+  if(w->ctl->scgi == NULL) {
+    LOG_ERROR(SEVERE,"Cannot create SCGI Request");
+    sigproc();
+    return;
+  } */ 
+  
+  if(w->tmp->is_static){
+
+#ifdef W_ZLIB
+    str = (char*) scgi_header_value_get(scgi, "LOWER_LIMIT");
+    if(str){
+      w->tmp->lower_limit = atol(str);
+    }
+
+    str = (char*) scgi_header_value_get(scgi, "UPPER_LIMIT");
+    if(str){
+      w->tmp->upper_limit = atol(str);
+    }
+
+#ifdef W_REGEX
+    str = (char*) scgi_header_value_get(scgi, "CONTENT_TYPE");
+    if(str){
+      wr_string_new(w->tmp->r_content_type, str, strlen(str));
+    }else {
+      wr_string_new(w->tmp->r_content_type, DEFAULT_CONTENT_TYPE, strlen(DEFAULT_CONTENT_TYPE));
+    }
+
+
+    str = (char*) scgi_header_value_get(scgi, "USER_AGENT");
+    if(str){
+      wr_string_new(w->tmp->r_user_agent, str, strlen(str));
+    }
+#endif
+
+#endif
+  }else{
+    if(drop_privileges(w, scgi) == FALSE) {
+      wkr_tmp_free(&w->tmp);
+      sigproc();
+      return;
+    }
+    
+    manipulate_environment_variable(w, scgi);
+    str = (char*) scgi_header_value_get(scgi, "PATH");
+    if(str){
+      wr_string_new(w->tmp->path, str, strlen(str));
+    }
+
+    str = (char*) scgi_header_value_get(scgi, "ENV");
+    if(str){
+      wr_string_new(w->tmp->env, str, strlen(str));
+    }
+
+    str = (char*) scgi_header_value_get(scgi, "TYPE");
+    if(str){
+      wr_string_new(w->tmp->type, str, strlen(str));
+    }
+
+    str = (char*) scgi_header_value_get(scgi, "BASE_URI");
+    if(str){
+      wr_string_new(w->tmp->resolver, str, strlen(str));
+    }
+
+    str = (char*) scgi_header_value_get(scgi, "ANALYTICS");
+    if(str && strcmp(str,"enabled")==0){
+      w->tmp->profiler = 'y';
+    }else{
+      w->tmp->profiler = 'n'; 
+    }
+  }
+  
+  load_application(w);
+}

data/src/worker/worker.h

@@ -23,7 +23,7 @@
 #ifndef WORKER_H_
 #define WORKER_H_
 
-#include <wkr_static.h>
+#include <wkr_http.h>
 
 typedef struct wkr_s       wkr_t;
 typedef struct wkr_tmp_s   wkr_tmp_t;
@@ -31,22 +31,28 @@ typedef struct wkr_ctl_s     wkr_ctl_t;
 
 /****** Worket temporary structure ****/
 struct wkr_tmp_s {
-  wr_str_t path;      /**< Application path */
-  wr_str_t env;        /**< Application environment */
-  wr_str_t type;      /**< Application type */
-  wr_str_t name;      /**< Application name */
-  wr_str_t resolver;    /**< Application baseuri */
-  wr_str_t ruby_path;  /**< Ruby library path */
-  wr_str_t script_path;  /**< webroar.rb script path */
-  wr_str_t root_path;    /**< WebROaR root path */
-  char    profiler;      /**< Analytics flag */
-  wr_str_t ctl_path;    /**< Server control path/port */
-  wr_str_t log_file;         /**< Log file name */
-  short   gid;              /**< Process group id */
-  short   uid;              /**< Process user id */
-  short    keep_alive;      /**< HTTP connection keep alive flag */
-  short   is_uds;
-  short   is_static;        /**< Worker to serve static files only */
+  wr_str_t  path;      /**< Application path */
+  wr_str_t  env;        /**< Application environment */
+  wr_str_t  type;      /**< Application type */
+  wr_str_t  name;      /**< Application name */
+  wr_str_t  resolver;    /**< Application baseuri */
+  wr_str_t  root_path;    /**< WebROaR root path */
+  char      profiler;      /**< Analytics flag */
+  wr_str_t  ctl_path;    /**< Server control path/port */
+  wr_str_t  log_file;         /**< Log file name */
+  short     gid;              /**< Process group id */
+  short     uid;              /**< Process user id */
+  short     keep_alive;      /**< HTTP connection keep alive flag */
+  short     is_uds;
+  short     is_static;        /**< Worker to serve static files only */
+#ifdef W_ZLIB
+  wr_u_long lower_limit;    /**< Content-Length lower than the value would not be encoded */
+  wr_u_long upper_limit;    /**< Content-Length larger than the value would not be encoded */
+#ifdef W_REGEX
+  wr_str_t  r_user_agent;    /**< Regex value to validate User-Agent */
+  wr_str_t  r_content_type; /**< Regex value to validate Content-Type */
+#endif
+#endif
 };
 
 wkr_tmp_t* wkr_tmp_new();
@@ -56,44 +62,50 @@ void wkr_tmp_free(wkr_tmp_t**);
 struct wkr_ctl_s {
   int       fd;
   ev_io      w_read;
-  char      msg[WR_MSG_SIZE];
+  char      msg[STR_SIZE1KB];
   size_t    msg_size;
   size_t    bytes_read;
   ev_io     w_write;
+  ev_timer  t_ack;
   //size_t    bytes_write;
   scgi_t*      scgi;
+  int       error;
 };
 
-wkr_ctl_t* wkr_ctl_new();
+wkr_ctl_t* wkr_ctl_new(wkr_t *w);
 void wkr_ctl_free(wkr_ctl_t**);
-int send_ack_on_internet_socket(wkr_t* w);
-int send_ack_on_unix_socket(wkr_t* w);
+int connect_to_head(wkr_t *w);
+void start_ctl_watcher(wkr_t *w);
+// Flag to create error response.
+void get_worker_add_ctl_scgi(wkr_t* w, const int flag);
+int send_config_req_msg(wkr_t* w);
+void application_config_read_cb(wkr_t* w, scgi_t *scgi);
 
 /********** Worker structure *********/
 struct wkr_s {
   /** Listen request from Head */
-  int       listen_fd;
-  int       listen_port;
-  wr_str_t   sock_path;
-  ev_io     w_accept;
+  int           listen_fd;
+  int           listen_port;
+  wr_str_t      sock_path;
+  ev_io         w_accept;
   struct ev_loop      *loop;
 
   /** Request */
-  int             req_fd;  /**< Socket fd */
-  ev_io           w_req;  /**< watcher */
-  short          is_uds;
+  int           req_fd;  /**< Socket fd */
+  ev_io         w_req;  /**< watcher */
+  short         is_uds;
 
-  wkr_ctl_t    *ctl;
-  wkr_tmp_t    *tmp;
-  http_t      *http;
+  wkr_ctl_t     *ctl;
+  wkr_tmp_t     *tmp;
+  http_t        *http;
+  
+  wr_str_list_t *env_var;   /**< Environment variable array */
 };
 
 wkr_t* worker_new(struct ev_loop *, wkr_tmp_t*);
 void worker_free(wkr_t**);
-void worker_accept_requests(wkr_t*);
-int worker_connect(wkr_t*);
+void init_idle_watcher(wkr_t *w);
 void start_idle_watcher();
-void stop_idle_watcher();
 void sigproc();
 
 #endif /*WORKER_H_*/