request_t.redirect takes variable argument list

request_t.serve to serve non-template data
fixed dispatcher thread locking code

diff --git a/src/manager/lib/dispatcher.c b/src/manager/lib/dispatcher.c
index df669ceb6f86c83bbefca7dd4407d4b5a8c2df37..ce53d39ea1760e2e5ee32e2220c127db41f3cc6b 100644 (file)
--- a/src/manager/lib/dispatcher.c
+++ b/src/manager/lib/dispatcher.c
@@ -30,6 +30,7 @@
 #include <signal.h>
 #include <unistd.h>
 
+#include <debug.h>
 #include <utils/linked_list.h>
 
 typedef struct private_dispatcher_t private_dispatcher_t;
@@ -122,8 +123,8 @@ typedef struct {
        session_t *session;
        /** condvar to wait for session */
        pthread_cond_t cond;
-       /** number of threads waiting for session */
-       int waiting;
+       /** TRUE if session is in use */
+       bool in_use;
        /** last use of the session */
        time_t used;
 } session_entry_t;
@@ -164,7 +165,7 @@ static session_entry_t *session_entry_create(private_dispatcher_t *this)
        session_entry_t *entry;
        
        entry = malloc_thing(session_entry_t);
-       entry->waiting = 1;
+       entry->in_use = FALSE;
        pthread_cond_init(&entry->cond, NULL);
        entry->session = load_session(this);
        entry->used = time(NULL);
@@ -228,11 +229,12 @@ static void dispatch(private_dispatcher_t *this)
                        now = time(NULL);
                        
                        /* find session */
-                       iterator = this->sessions->create_iterator_locked(this->sessions, &this->mutex);
+                       pthread_mutex_lock(&this->mutex);
+                       iterator = this->sessions->create_iterator(this->sessions, TRUE);
                        while (iterator->iterate(iterator, (void**)&current))
                        {
                                /* check all sessions for timeout */
-                               if (current->waiting == 0 &&
+                               if (!current->in_use &&
                                        current->used < now - this->timeout)
                                {
                                        iterator->remove(iterator);
@@ -243,27 +245,24 @@ static void dispatch(private_dispatcher_t *this)
                                        streq(current->session->get_sid(current->session), sid))
                                {
                                        found = current;
-                                       found->waiting++;
                                }
                        }
                        iterator->destroy(iterator);
                        
                        if (found)
                        {       /* wait until session is unused */
-                               pthread_mutex_lock(&this->mutex);
-                               while (found->waiting > 1)
+                               while (found->in_use)
                                {
                                        pthread_cond_wait(&found->cond, &this->mutex);
                                }
-                               pthread_mutex_unlock(&this->mutex);
                        }
                        else
                        {       /* create a new session if not found */
                                found = session_entry_create(this);
-                               pthread_mutex_lock(&this->mutex);
                                this->sessions->insert_first(this->sessions, found);
-                               pthread_mutex_unlock(&this->mutex);
                        }
+                       found->in_use = TRUE;
+                       pthread_mutex_unlock(&this->mutex);
                
                        /* start processing */
                        found->session->process(found->session, request);
@@ -271,7 +270,7 @@ static void dispatch(private_dispatcher_t *this)
                        
                        /* release session */
                        pthread_mutex_lock(&this->mutex);
-                       found->waiting--;
+                       found->in_use = FALSE;
                        pthread_cond_signal(&found->cond);
                        pthread_mutex_unlock(&this->mutex);
                        

diff --git a/src/manager/lib/request.c b/src/manager/lib/request.c
index 4623b3860cb87e02b06d91e9493b6de9c24dc35f..2e18bded51a2829d908727d309f6c32ee7eb8049 100644 (file)
--- a/src/manager/lib/request.c
+++ b/src/manager/lib/request.c
@@ -179,12 +179,18 @@ static void add_cookie(private_request_t *this, char *name, char *value)
 /**
  * Implementation of request_t.redirect.
  */
-static void redirect(private_request_t *this, char *location)
+static void redirect(private_request_t *this, char *fmt, ...)
 {
+       va_list args;
+
        FCGX_FPrintF(this->req->out, "Status: 303 See Other\n");
-       FCGX_FPrintF(this->req->out, "Location: %s%s%s\n\n",
+       FCGX_FPrintF(this->req->out, "Location: %s%s",
                                 FCGX_GetParam("SCRIPT_NAME", this->req->envp),
-                                *location == '/' ? "" : "/", location);
+                                *fmt == '/' ? "" : "/");
+       va_start(args, fmt);
+       FCGX_VFPrintF(this->req->out, fmt, args);
+       va_end(args);
+       FCGX_FPrintF(this->req->out, "\n\n");
 }
 
 /**
@@ -195,6 +201,16 @@ static char* get_base(private_request_t *this)
        return FCGX_GetParam("SCRIPT_NAME", this->req->envp);
 }
 
+/**
+ * Implementation of request_t.serve.
+ */
+static void serve(private_request_t *this, char *headers, chunk_t chunk)
+{
+       FCGX_FPrintF(this->req->out, "%s\n\n", headers);
+
+       FCGX_PutStr(chunk.ptr, chunk.len, this->req->out);
+}
+
 /**
  * Implementation of request_t.render.
  */
@@ -254,8 +270,9 @@ request_t *request_create(FCGX_Request *request, bool debug)
        this->public.add_cookie = (void(*)(request_t*, char *name, char *value))add_cookie;
        this->public.get_cookie = (char*(*)(request_t*,char*))get_cookie;
        this->public.get_query_data = (char*(*)(request_t*, char *name))get_query_data;
-       this->public.redirect = (void(*)(request_t*, char *location))redirect;
+       this->public.redirect = (void(*)(request_t*, char *fmt,...))redirect;
        this->public.render = (void(*)(request_t*,char*))render;
+       this->public.serve = (void(*)(request_t*,char*,chunk_t))serve;
        this->public.set = (void(*)(request_t*, char *, char*))set;
        this->public.setf = (void(*)(request_t*, char *format, ...))setf;
        this->public.destroy = (void(*)(request_t*))destroy;

diff --git a/src/manager/lib/request.h b/src/manager/lib/request.h
index e6fd71e714411d61b5df7334749df6d53d87f10e..f78741d379a2f61978c83f55392881f02f75f133 100644 (file)
--- a/src/manager/lib/request.h
+++ b/src/manager/lib/request.h
@@ -75,9 +75,10 @@ struct request_t {
        /**
         * @brief Redirect the client to another location.
         *
-        * @param location              location to redirect to
+        * @param fmt           location format string
+        * @param ...           variable argument for fmt
         */
-       void (*redirect)(request_t *this, char *location);
+       void (*redirect)(request_t *this, char *fmt, ...);
        
        /**
         * @brief Set a template value.
@@ -106,10 +107,17 @@ struct request_t {
         * other targets without to worry about path location.
         *
         * @param template      clearsilver template file location
-        * @return                      rendered template string
         */
        void (*render)(request_t *this, char *template);
        
+       /**
+        * @brief Serve a request with headers and a body.
+        *
+        * @param headers       HTTP headers, \n separated
+        * @param chunk         body to write to output
+        */
+       void (*serve)(request_t *this, char *headers, chunk_t chunk);
+       
        /**
         * @brief Destroy the request_t.
         */