webroar 0.3.1 → 0.4.0

data/src/worker/wkr_http_request.c

@@ -18,9 +18,10 @@
  */
 #include <worker.h>
 #include <stdlib.h>
-#include <wr_logger.h>
 #include <assert.h>
 
+extern config_t *Config;
+
 http_req_t* http_req_new() {
   LOG_FUNCTION
   http_req_t* req = wr_malloc(http_req_t);
@@ -109,7 +110,7 @@ int http_req_body_read(http_req_t *req, char *buf, int len) {
 }
 
 /** Read SCGI request body in buffer */
-static inline void http_req_body_read_in_buff(http_req_t *req, struct ev_loop *loop, struct ev_io *watcher) {
+void http_req_body_read_in_buff(http_req_t *req, struct ev_loop *loop, struct ev_io *watcher) {
   LOG_FUNCTION
   ssize_t read = recv(watcher->fd,
                       req->buf + req->scgi_header_len + req->bytes_read,
@@ -136,14 +137,14 @@ static inline void http_req_body_read_in_buff(http_req_t *req, struct ev_loop *l
 }
 
 /** Read SCGI request body in file */
-static inline void http_req_body_read_in_file(http_req_t *req, struct ev_loop *loop, struct ev_io *watcher) {
+void http_req_body_read_in_file(http_req_t *req, struct ev_loop *loop, struct ev_io *watcher) {
   LOG_FUNCTION
-  char buffer[WR_BUF_SIZE+1];
+  char buffer[STR_SIZE10KB+1];
   ssize_t read, write = 0, rv;
 
   read = recv(watcher->fd,
               buffer,
-              wr_min(req->req_len - req->bytes_read, WR_BUF_SIZE),
+              wr_min(req->req_len - req->bytes_read, STR_SIZE10KB),
               0);
 
   if(read < 0) {
@@ -170,7 +171,7 @@ static inline void http_req_body_read_in_file(http_req_t *req, struct ev_loop *l
 }
 
 /** Read SCGI request body */
-static void http_req_body_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
+void http_req_body_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) {
   LOG_FUNCTION
   wkr_t *w     = (wkr_t*) watcher->data;
   http_req_t *req   = w->http->req;
@@ -193,7 +194,7 @@ static void http_req_body_cb(struct ev_loop *loop, struct ev_io *watcher, int re
 }
 
 /** Parse SCGI request */
-static inline void parser_req_buf(http_req_t *req, struct ev_loop *loop, struct ev_io *watcher) {
+void parser_req_buf(http_req_t *req, struct ev_loop *loop, struct ev_io *watcher) {
   LOG_FUNCTION
   if(req->scgi_header_len == 0) {
     // Fetch header packet length
@@ -234,7 +235,7 @@ static inline void parser_req_buf(http_req_t *req, struct ev_loop *loop, struct
 #ifdef L_DEBUG
       // Fetch Connection id
       wkr_t *w = (wkr_t*) watcher->data;
-      scgi_header_t *header = scgi_header_get(req->scgi, WR_CONN_ID);
+      scgi_header_t *header = scgi_header_get(req->scgi, Config->Worker.Header.conn_id.str);
       if(header){
         w->http->conn_id = atoi(req->scgi->header + req->scgi->start_offset + header->value_offset);
       }else{
@@ -242,7 +243,7 @@ static inline void parser_req_buf(http_req_t *req, struct ev_loop *loop, struct
       }
       
       // Fetch request id
-      header = scgi_header_get(req->scgi, WR_REQ_ID);
+      header = scgi_header_get(req->scgi, Config->Worker.Header.req_id.str);
       if(header){
         w->http->req_id = atoi(req->scgi->header + req->scgi->start_offset + header->value_offset);
       }else{
@@ -257,7 +258,7 @@ static inline void parser_req_buf(http_req_t *req, struct ev_loop *loop, struct
         req->bytes_read = 0;
         http_req_process();
       } else {
-        if(req->req_len + req->scgi_header_len  > WR_BUF_SIZE) {
+        if(req->req_len + req->scgi_header_len  > STR_SIZE10KB) {
           ssize_t write;
           size_t processed_bytes = 0;
 
@@ -300,7 +301,7 @@ void http_req_header_cb(struct ev_loop *loop, struct ev_io *watcher, int revents
 
     ssize_t read = recv(watcher->fd
                         , req->buf + req->bytes_read
-                        , WR_BUF_SIZE - req->bytes_read
+                        , STR_SIZE10KB - req->bytes_read
                         , 0
                        );
     if(read < 0) {

data/src/worker/wkr_http_request.h

@@ -19,7 +19,6 @@
 #ifndef WKR_HTTP_REQUEST_H_
 #define WKR_HTTP_REQUEST_H_
 
-#include <wr_config.h>
 #include <wr_helper.h>
 #include <errno.h>
 #include <ev.h>
@@ -29,13 +28,13 @@ typedef struct http_req_s    http_req_t;
 
 /******* HTTP Request  ******/
 struct http_req_s {
-  char           buf[WR_BUF_SIZE];    /**< Request buffer */
-  size_t           bytes_read;
-  scgi_t     *scgi;    /**< Parsed SCGI request */
-  FILE             *file;          /**< File pointer */
-  char           file_name[WR_STR_LEN];      /**< File name */
-  size_t           scgi_header_len;    /**< Header packet length */
-  size_t           req_len;        /**< Content length */
+  char          buf[STR_SIZE10KB];    /**< Request buffer */
+  size_t        bytes_read;
+  scgi_t        *scgi;    /**< Parsed SCGI request */
+  FILE          *file;          /**< File pointer */
+  char          file_name[STR_SIZE64];      /**< File name */
+  size_t        scgi_header_len;    /**< Header packet length */
+  size_t        req_len;        /**< Content length */
 };
 
 http_req_t* http_req_new();

data/src/worker/wkr_http_response.c

@@ -18,7 +18,8 @@
  */
 #include <worker.h>
 #include <stdlib.h>
-#include <wr_logger.h>
+
+extern config_t *Config;
 
 http_resp_t* http_resp_new() {
   LOG_FUNCTION
@@ -83,12 +84,6 @@ void http_resp_set(http_resp_t *rsp) {
   rsp->scgi = NULL;
 }
 
-int http_resp_body_add(http_resp_t *rsp, const char* str, size_t len) {
-  LOG_FUNCTION
-  wr_buffer_add(rsp->resp_body, str, len);
-  return 0;
-}
-
 int http_resp_process(http_resp_t *rsp) {
   LOG_FUNCTION
   rsp->scgi = scgi_new();
@@ -101,10 +96,10 @@ int http_resp_process(http_resp_t *rsp) {
   size_t len;
 
   len = sprintf(str, "%d", rsp->resp_code);
-  scgi_header_add(rsp->scgi, RESP_CODE, strlen(RESP_CODE), str, len);
+  scgi_header_add(rsp->scgi, Config->Worker.Header.resp_code.str, Config->Worker.Header.resp_code.len, str, len);
 
   len = sprintf(str, "%d", rsp->resp_body->len);
-  scgi_header_add(rsp->scgi, RESP_CONTENT_LENGTH, strlen(RESP_CONTENT_LENGTH), str, len);
+  scgi_header_add(rsp->scgi, Config->Worker.Header.resp_content_len.str, Config->Worker.Header.resp_content_len.len, str, len);
 
   scgi_content_length_add(rsp->scgi, rsp->resp_body->len + rsp->header.len);
 
@@ -126,14 +121,14 @@ void http_resp_file_write_cb(struct ev_loop* loop, struct ev_io* watcher, int re
   ssize_t sent;
 
     if (rsp->file) {
-      char buffer[WR_REQ_BODY_MAX_SIZE];
+      char buffer[Config->Worker.max_body_size];
       ssize_t read;
       int rv = fseek(rsp->file, rsp->bytes_write, SEEK_SET);
       if (rv < 0) {
         LOG_ERROR(WARN, "Error reading file:%s", strerror(errno));
         return;
       }
-      read = fread(buffer, 1, WR_REQ_BODY_MAX_SIZE, rsp->file);
+      read = fread(buffer, 1, Config->Worker.max_body_size, rsp->file);
       sent = send(watcher->fd, buffer, read, 0);
     }
 
@@ -212,14 +207,14 @@ void http_resp_file_send_cb(struct ev_loop* loop, struct ev_io* watcher, int rev
     return;
   }
 #else
-   char buffer[WR_REQ_BODY_MAX_SIZE];
+   char buffer[Config->Worker.max_body_size];
    ssize_t read, sent;
    int rv = fseek(rsp->file, rsp->bytes_write, SEEK_SET);
    if(rv < 0) {
      LOG_ERROR(WARN,"Error reading file:%s",strerror(errno));
      return;
    }
-   read = fread(buffer, 1, WR_REQ_BODY_MAX_SIZE, rsp->file);
+   read = fread(buffer, 1, Config->Worker.max_body_size, rsp->file);
    sent = send(watcher->fd, buffer, read, 0);
    if (sent < 0) {
     LOG_ERROR(SEVERE, "error in file sending: %s\n", strerror(errno));
@@ -274,7 +269,8 @@ void http_resp_header_write_cb(struct ev_loop* loop, struct ev_io* watcher, int
       LOG_DEBUG(DEBUG, "http_resp_header_write_cb() starting read watcher. bytes write=%d", rsp->bytes_write);
       if (rsp->resp_body->len > 0) {
         rsp->bytes_write = 0;
-        if (w->http->is_static && w->http->resp->resp_code == 200) {
+        if (w->http->stat && w->http->resp->resp_code == 200 &&
+            rsp->resp_body->str == NULL) {
           ev_io_init(watcher, http_resp_file_send_cb, w->req_fd, EV_WRITE);
           //send_file(w);
           //ev_io_init(watcher, http_resp_file_write_cb, w->req_fd, EV_WRITE);

data/src/worker/wkr_http_response.h

@@ -41,7 +41,6 @@ struct http_resp_s {
 http_resp_t* http_resp_new();
 void http_resp_free(http_resp_t**);
 void http_resp_set(http_resp_t*);
-int http_resp_body_add(http_resp_t*, const char* , size_t);
 int http_resp_process(http_resp_t*);
 void http_resp_scgi_write_cb(struct ev_loop*, struct ev_io*, int);
 

data/src/worker/wkr_main.c

@@ -23,56 +23,28 @@
 #include <ruby.h>
 #include <rubysig.h>
 #include <execinfo.h>
-#ifdef __linux__
-#include <sys/prctl.h>
-#endif
 
-static wkr_t       *worker = NULL;
+#define DEFAULT_LOWER_LIMIT 1024
+#define DEFAULT_UPPER_LIMIT 10485760
+
+static wkr_t        *worker = NULL;
+config_t            *Config = NULL;
 
 struct               ev_loop *loop;    // Event loop
 struct               ev_idle idle_watcher;
-int                 is_alive = 1;
-
-static int drop_privileges(wkr_t *w) {
-  change_log_file_owner(w->tmp->uid, w->tmp->gid);
-  //setting read, effective, saved group and user id
-  if(setgid(w->tmp->gid)!=0) {
-    LOG_ERROR(SEVERE,"setegid() failed");
-    return -1;
-  }
-  if(setuid(w->tmp->uid)!=0) {
-    LOG_ERROR(SEVERE,"seteuid() failed");
-    return -1;
-  }
-
-  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 0;
-}
+int                  is_alive = 1;
 
 /** Usage */
-static inline void print_usage(char *appname) {
-  printf("usage: \n%s -a <application_path> [-e <environment>] [-u <cuid >] [-g <cgid>] ",appname);
-  printf("[-c <control port/sock path>] [-i <uds>] [-t <application_type>] [-n <application_name>] ");
-  printf("[-p <analytics>] [-r <application baseuri>]\n");
-  printf("<application_path> = path of rails application. e.g. /home/xyz/rails_projects/app1\n");
-  printf("<environment> = rails environment. development/production. Default is production.\n");
-  printf("<cuid> = User id.\n");
-  printf("<cgid> = Group id.\n");
-  printf("<control port/sock path> = Control port number (control sock path in case [-i 1])\n");
+void print_usage(char *appname) {
+  printf("usage: \n%s [-c <control_port/sock_path>] [-i <uds>] [-n <application_name>]",appname);
+  printf("[-l <log_level>] [-f <log_file>] [-o <root_path>] [-k <keep_alive>]\n");
+  printf("<control_port/sock_path> = Control port number (control sock path in case [-i 1])\n");
   printf("<uds> = Unix domain socket flag. Value should be 0 or 1.\n");
-  printf("<application_type> = Type of application {rails, merb}.\n");
   printf("<application_name> = Name of application\n");
-  printf("<analytics> = Analytics flag. Value should be yes or no.\n");
-  printf("<baseuri> = Application URL baseuri.\n");
+  printf("<log_level> = Logging Level\n");
+  printf("<log_file> = Name of the log file\n");
+  printf("<root_path> = Root directory path\n");
+  printf("<keep_alive> = Keep Alive flag value must be 'y'/'n'\n");
 }
 
 void sigproc() {
@@ -83,11 +55,12 @@ void sigproc() {
 
 void cleanup() {
   LOG_FUNCTION
-  stop_idle_watcher();
+  ev_idle_stop(loop, &idle_watcher);
   LOG_DEBUG(DEBUG,"stoping event loop");
   ev_unloop(loop,EVUNLOOP_ALL);
   //TODO: send worker stopping signal
   worker_free(&worker);
+  wr_worker_config_free(Config);
   LOG_INFO("Worker stopped and exiting gracefully.");
   close_logger();
   exit(0);
@@ -95,10 +68,10 @@ void cleanup() {
  
 /** Handle segmentation fault */
 void crash_handler(int sig) {
-  void *array[WR_STACKTRACE_SIZE];
+  void *array[Config->Worker.stack_tace];
   size_t size;
   char **bt_symbols;
-  char bt_string[WR_STACKTRACE_SIZE * WR_LONG_STR_LEN * 2];
+  char bt_string[Config->Worker.stack_tace * STR_SIZE256];
   int i;
   
   LOG_ERROR(FATAL, "Got %d signal, trying to create core file.", sig);
@@ -129,7 +102,7 @@ void crash_handler(int sig) {
   }
   sleep(5);
   // get void*'s for all entries on the stack
-  size = backtrace(array, WR_STACKTRACE_SIZE);
+  size = backtrace(array, Config->Worker.stack_tace);
   bt_symbols = backtrace_symbols(array, size);
   strcpy(bt_string, "\n");
   for(i = 0; i < size; i++) {
@@ -142,34 +115,43 @@ void crash_handler(int sig) {
   cleanup();
 }
 
+/** Read and set Worker Configuration **/
+void wr_worker_config_read(){
+  LOG_FUNCTION
+  node_t *root;
+  
+  LOG_DEBUG(4,"YAML file path %s", Config->Worker.File.internal_config);
+  root = yaml_parse(Config->Worker.File.internal_config.str);
+
+  if(!root) {
+    LOG_ERROR(SEVERE, "Config file found with erroneous entries. Please correct it.");
+    printf("Config file found with erroneous entries. Please correct it.\n");
+    return;
+  }
+  
+  wr_set_numeric_value(root, "Worker/maximum_request_body_size", &Config->Worker.max_body_size, FALSE);
+  node_free(root);
+  
+  Config->Worker.Compress.lower_limit = DEFAULT_LOWER_LIMIT;
+  Config->Worker.Compress.upper_limit = DEFAULT_UPPER_LIMIT;
+}
+
 /** Parse command line arguments */
-static inline wkr_tmp_t* parse_args(int argc, char **argv) {
+wkr_tmp_t* parse_args(int argc, char **argv) {
   int option;
   extern char *optarg;
   size_t len;
   char *str;
-  int invalid_arg_flag = 0, app_path_flag = 0, log_level = INFO;
+  int invalid_arg_flag = 0, log_level = INFO;
   wkr_tmp_t *tmp = wkr_tmp_new();
-
+  
   if(tmp == NULL)
     return NULL;
-
-  while ( (option=getopt(argc,argv,"a:b:e:l:f:g:u:c:i:t:n:o:p:r:k:")) != -1 ) {
+    
+  while ( (option=getopt(argc,argv,"l:f:c:i:n:o:k:")) != -1 ) {
     str = optarg;
     len = strlen(str);
-    switch ( option ) {
-    case 'a':  // Application Path
-      wr_string_new(tmp->path, str, len);
-      app_path_flag = 1;
-      break;
-    case 'b':  // Ruby library path
-      wr_string_new(tmp->ruby_path, str, len);
-      tmp->script_path.str = (char*) malloc(sizeof(char)*(tmp->ruby_path.len + 32));
-      tmp->script_path.len = sprintf(tmp->script_path.str, "%s%swebroar_app_loader.rb", tmp->ruby_path.str, WR_PATH_SEPARATOR);
-      break;
-    case 'e':  // Application environment
-      wr_string_new(tmp->env, str, len);
-      break;
+    switch ( option ) {    
     case 'l':  // Logging level
       log_level = atoi(optarg);
       break;
@@ -177,12 +159,6 @@ static inline wkr_tmp_t* parse_args(int argc, char **argv) {
       wr_string_free(tmp->log_file);
       wr_string_new(tmp->log_file, str, len);
       break;
-    case 'g':  // Group id
-      tmp->gid = atoi(optarg);
-      break;
-    case 'u':  // User id
-      tmp->uid = atoi(optarg);
-      break;
     case 'c':  // Control path
       wr_string_new(tmp->ctl_path, str, len);
       break;
@@ -191,9 +167,6 @@ static inline wkr_tmp_t* parse_args(int argc, char **argv) {
         tmp->is_uds = TRUE;
       }
       break;
-    case 't':  // Application type
-      wr_string_new(tmp->type, str, len);
-      break;
     case 'n':  // Application name
       wr_string_new(tmp->name, str, len);
       wr_string_free(tmp->log_file);
@@ -203,14 +176,6 @@ static inline wkr_tmp_t* parse_args(int argc, char **argv) {
     case 'o':  // Server root path
       wr_string_new(tmp->root_path, str, len);
       break;
-    case 'r':  // Applicaiton base uri
-      wr_string_new(tmp->resolver, str, len);
-      break;
-    case 'p':  // Analytics flag
-      if(strcmp(optarg, "y")==0) {
-        tmp->profiler = 'y';
-      }
-      break;
     case 'k':
       if(strcmp(optarg, "n")==0) {
         tmp->keep_alive = FALSE;
@@ -220,9 +185,12 @@ static inline wkr_tmp_t* parse_args(int argc, char **argv) {
       invalid_arg_flag++;
     }
   }
-
+  
+  Config = wr_worker_config_init(tmp->root_path.str);
+  wr_worker_config_read();
+  
   if(tmp->log_file.str){
-    initialize_logger(tmp->log_file.str, WR_SERVER, WR_VERSION);
+    initialize_logger(tmp->log_file.str, Config->Worker.Server.name.str, Config->Worker.Server.version.str);
     redirect_standard_io();
 #ifdef L_DEBUG
       set_log_severity(DEBUG);
@@ -232,14 +200,16 @@ static inline wkr_tmp_t* parse_args(int argc, char **argv) {
   }else{
     perror("Log file is not specified.");
   }
-
-  if (invalid_arg_flag > 0 || app_path_flag == 0) {
+  
+  if (invalid_arg_flag > 0 || tmp->root_path.str == NULL || Config == NULL) {
     print_usage(argv[0]);
-    LOG_ERROR(SEVERE, "Either argument is invalid or application path is not passed.");
+    LOG_ERROR(SEVERE, "Either argument is invalid or application/root path is not passed.");
     wkr_tmp_free(&tmp);
+    wr_worker_config_free(Config);
     return NULL;
   }
-  if(strcmp(tmp->name.str, WR_STATIC_FILE_SERVER_NAME) == 0){
+  
+  if(strcmp(tmp->name.str, Config->Worker.static_server.str) == 0){
     tmp->is_static = 1;
   }
   return tmp;
@@ -252,11 +222,6 @@ void start_idle_watcher() {
   }
 }
 
-void stop_idle_watcher() {
-  LOG_FUNCTION
-  ev_idle_stop(loop, &idle_watcher);
-}
-
 void idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) {
   LOG_FUNCTION
   /* Calling libev's blocking call ev_loop() between TRAP_* macros were working on Ruby 1.8, 
@@ -264,7 +229,7 @@ void idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) {
    */
   if(rb_thread_alone()) {
     /* Stop scheduling ruby threads, there is only one! */
-    stop_idle_watcher();    
+    ev_idle_stop(loop, &idle_watcher);
   } else {
     /* TODO: Found following three api to schedule ruby threads  
      * rb_thread_schedule() was getting called infinitely and eating most of the CPU. 
@@ -280,10 +245,16 @@ void idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents) {
   } 
 }
 
+void init_idle_watcher(wkr_t *w){
+  if(!w->http->stat){
+    ev_idle_init (&idle_watcher, idle_cb);
+    start_idle_watcher();
+  }  
+}
+
 int main(int argc, char **argv) {
-  int retval = 0;
   wkr_t* w = NULL;
-
+  
   if(argc == 1) {
     print_usage(argv[0]);
     return -1;
@@ -298,70 +269,33 @@ int main(int argc, char **argv) {
   wkr_tmp_t *tmp = parse_args(argc, argv);
   if(tmp == NULL)
     return -1;
-  
   loop = ev_default_loop (0);
 
   w = worker_new(loop, tmp);
-  if(w==NULL)
-    goto err;
-  worker = w;  
   
-  LOG_DEBUG(DEBUG,"control path = %s, Application baseuri = %s",
-            w->tmp->ctl_path.str,  w->tmp->resolver.str);
-
-  if((retval = drop_privileges(w))!=0) {
-    goto err;
-  }
-
-  w->http = http_new(w);
-  if(w->http == NULL) {
-    LOG_ERROR(SEVERE,"unable to load application.");
-    goto err;
-  }
-
-  retval = worker_connect(w);
-  if(retval<0) {
-    LOG_ERROR(WARN,"Error Initializing Workers.");
-    retval = -1;
-    goto err;
+  if(w==NULL){
+    wr_worker_config_free(Config);
+    return -1;
   }
 
-  //loading adapter according to application type
-  LOG_DEBUG(DEBUG,"ruby lib = %s and webroar_root = %s",
-            w->tmp->ruby_path.str, 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);
-
-  LOG_INFO("Successfully loaded rack application=%s with environment=%s",
-           w->tmp->path.str,   w->tmp->env.str);
-
+  worker = w;  
+  
   //TODO: Windows Portability?
   signal(SIGHUP, sigproc); /* catch hangup signal */
   signal(SIGINT, sigproc);
   signal(SIGTERM, sigproc);
-//  signal(SIGCHLD, SIG_IGN);
+  //  signal(SIGCHLD, SIG_IGN);
   signal(SIGTSTP, SIG_IGN);
   signal(SIGTTOU, SIG_IGN);
-  signal(SIGTTIN, SIG_IGN);  
+  signal(SIGTTIN, SIG_IGN);
   signal(SIGPIPE, SIG_IGN);
 
-  worker_accept_requests(w);
-  LOG_INFO("Worker ready for serving requests.");
-
-  if(!w->http->is_static){
-    ev_idle_init (&idle_watcher, idle_cb);
-    start_idle_watcher();
-  }
-
   while(is_alive ==1) {
     /* TODO: wrapping ev_loop() between TARP_* macros didn't worked in Ruby 1.9 */
     //TRAP_BEG;
     ev_loop(loop,EVLOOP_ONESHOT);
     //TRAP_END;
   }
-
-err:
   cleanup();
-  return retval;
+  return 0;
 }