src/libfast/request.c

   1 /*
   2  * Copyright (C) 2007 Martin Willi
   3  * Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  *
  15  * $Id$
  16  */
  17
  18 #define _GNU_SOURCE
  19
  20 #include "request.h"
  21
  22 #include <library.h>
  23 #include <debug.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <pthread.h>
  27 #include <ClearSilver/ClearSilver.h>
  28
  29 typedef struct private_request_t private_request_t;
  30
  31 /**
  32  * private data of the task manager
  33  */
  34 struct private_request_t {
  35
  36         /**
  37          * public functions
  38          */
  39         request_t public;
  40
  41         /**
  42          * FastCGI request object
  43          */
  44         FCGX_Request req;
  45
  46         /**
  47          * length of the req.envp array
  48          */
  49         int req_env_len;
  50
  51         /**
  52          * ClearSilver CGI Kit context
  53          */
  54         CGI *cgi;
  55
  56         /**
  57          * ClearSilver HDF dataset for this request
  58          */
  59         HDF *hdf;
  60
  61         /**
  62          * close the session?
  63          */
  64         bool closed;
  65
  66         /**
  67          * reference count
  68          */
  69         refcount_t ref;
  70 };
  71
  72 /**
  73  * key to a the threads "this" request, used for ClearSilver cgiwrap callbacks.
  74  * ClearSilver cgiwrap is not threadsave, so we use a private
  75  * context for each thread.
  76  */
  77 static pthread_key_t this_key;
  78
  79 /**
  80  * control variable for pthread_once
  81  */
  82 pthread_once_t once = PTHREAD_ONCE_INIT;
  83
  84 /**
  85  * fcgiwrap read callback
  86  */
  87 static int read_cb(void *null, char *buf, int size)
  88 {
  89         private_request_t *this = (private_request_t*)pthread_getspecific(this_key);
  90
  91         return FCGX_GetStr(buf, size, this->req.in);
  92 }
  93
  94 /**
  95  * fcgiwrap writef callback
  96  */
  97 static int writef_cb(void *null, const char *format, va_list args)
  98 {
  99         private_request_t *this = (private_request_t*)pthread_getspecific(this_key);
 100
 101         FCGX_VFPrintF(this->req.out, format, args);
 102         return 0;
 103 }
 104 /**
 105  * fcgiwrap write callback
 106  */
 107 static int write_cb(void *null, const char *buf, int size)
 108 {
 109         private_request_t *this = (private_request_t*)pthread_getspecific(this_key);
 110
 111         return FCGX_PutStr(buf, size, this->req.out);
 112 }
 113
 114 /**
 115  * fcgiwrap getenv callback
 116  */
 117 static char *getenv_cb(void *null, const char *key)
 118 {
 119         char *value;
 120         private_request_t *this = (private_request_t*)pthread_getspecific(this_key);
 121
 122         value = FCGX_GetParam(key, this->req.envp);
 123         return value ? strdup(value) : NULL;
 124 }
 125
 126 /**
 127  * fcgiwrap getenv callback
 128  */
 129 static int putenv_cb(void *null, const char *key, const char *value)
 130 {
 131         /* not supported */
 132         return 1;
 133 }
 134
 135 /**
 136  * fcgiwrap iterenv callback
 137  */
 138 static int iterenv_cb(void *null, int num, char **key, char **value)
 139 {
 140         *key = NULL;
 141         *value = NULL;
 142         private_request_t *this = (private_request_t*)pthread_getspecific(this_key);
 143         if (num < this->req_env_len)
 144         {
 145                 char *eq;
 146
 147                 eq = strchr(this->req.envp[num], '=');
 148                 if (eq)
 149                 {
 150                         *key = strndup(this->req.envp[num], eq - this->req.envp[num]);
 151                         *value = strdup(eq + 1);
 152                 }
 153                 if (*key == NULL || *value == NULL)
 154                 {
 155                         free(*key);
 156                         free(*value);
 157                         return 1;
 158                 }
 159         }
 160         return 0;
 161 }
 162
 163 /**
 164  * Implementation of request_t.get_cookie.
 165  */
 166 static char* get_cookie(private_request_t *this, char *name)
 167 {
 168         return hdf_get_valuef(this->hdf, "Cookie.%s", name);
 169 }
 170
 171 /**
 172  * Implementation of request_t.get_path.
 173  */
 174 static char* get_path(private_request_t *this)
 175 {
 176         char * path = FCGX_GetParam("PATH_INFO", this->req.envp);
 177         return path ? path : "";
 178 }
 179
 180 /**
 181  * Implementation of request_t.get_host.
 182  */
 183 static char* get_host(private_request_t *this)
 184 {
 185         char *addr = FCGX_GetParam("REMOTE_ADDR", this->req.envp);
 186         return addr ? addr : "";
 187 }
 188
 189 /**
 190  * Implementation of request_t.get_user_agent.
 191  */
 192 static char* get_user_agent(private_request_t *this)
 193 {
 194         char *agent = FCGX_GetParam("HTTP_USER_AGENT", this->req.envp);
 195         return agent ? agent : "";
 196 }
 197
 198 /**
 199  * Implementation of request_t.get_post_data.
 200  */
 201 static char* get_query_data(private_request_t *this, char *name)
 202 {
 203         return hdf_get_valuef(this->hdf, "Query.%s", name);
 204 }
 205
 206 /**
 207  * Implementation of request_t.add_cookie.
 208  */
 209 static void add_cookie(private_request_t *this, char *name, char *value)
 210 {
 211         pthread_setspecific(this_key, this);
 212         cgi_cookie_set (this->cgi, name, value,
 213                                         FCGX_GetParam("SCRIPT_NAME", this->req.envp),
 214                                         NULL, NULL, 0, 0);
 215 }
 216
 217 /**
 218  * Implementation of request_t.redirect.
 219  */
 220 static void redirect(private_request_t *this, char *fmt, ...)
 221 {
 222         va_list args;
 223
 224         FCGX_FPrintF(this->req.out, "Status: 303 See Other\n");
 225         FCGX_FPrintF(this->req.out, "Location: %s%s",
 226                                  FCGX_GetParam("SCRIPT_NAME", this->req.envp),
 227                                  *fmt == '/' ? "" : "/");
 228         va_start(args, fmt);
 229         FCGX_VFPrintF(this->req.out, fmt, args);
 230         va_end(args);
 231         FCGX_FPrintF(this->req.out, "\n\n");
 232 }
 233
 234 /**
 235  * Implementation of request_t.to_referer.
 236  */
 237 static void to_referer(private_request_t *this)
 238 {
 239         FCGX_FPrintF(this->req.out, "Status: 303 See Other\n");
 240         FCGX_FPrintF(this->req.out, "Location: %s\n\n",
 241                                  FCGX_GetParam("HTTP_REFERER", this->req.envp));
 242 }
 243
 244 /**
 245  * Implementation of request_t.get_base.
 246  */
 247 static char* get_base(private_request_t *this)
 248 {
 249         return FCGX_GetParam("SCRIPT_NAME", this->req.envp);
 250 }
 251
 252 /**
 253  * Implementation of request_t.session_closed.
 254  */
 255 static bool session_closed(private_request_t *this)
 256 {
 257         return this->closed;
 258 }
 259
 260 /**
 261  * Implementation of request_t.close_session.
 262  */
 263 static void close_session(private_request_t *this)
 264 {
 265         this->closed = TRUE;
 266 }
 267
 268 /**
 269  * Implementation of request_t.serve.
 270  */
 271 static void serve(private_request_t *this, char *headers, chunk_t chunk)
 272 {
 273         FCGX_FPrintF(this->req.out, "%s\n\n", headers);
 274
 275         FCGX_PutStr(chunk.ptr, chunk.len, this->req.out);
 276 }
 277
 278 /**
 279  * Implementation of request_t.render.
 280  */
 281 static void render(private_request_t *this, char *template)
 282 {
 283         NEOERR* err;
 284
 285         pthread_setspecific(this_key, this);
 286         err = cgi_display(this->cgi, template);
 287         if (err)
 288         {
 289                 cgi_neo_error(this->cgi, err);
 290                 nerr_log_error(err);
 291         }
 292         return;
 293 }
 294
 295 /**
 296  * Implementation of request_t.streamf.
 297  */
 298 static int streamf(private_request_t *this, char *format, ...)
 299 {
 300         va_list args;
 301         int written;
 302
 303         va_start(args, format);
 304         written = FCGX_VFPrintF(this->req.out, format, args);
 305         va_end(args);
 306         if (written >= 0 &&
 307                 FCGX_FFlush(this->req.out) == -1)
 308         {
 309                 return -1;
 310         }
 311         return written;
 312 }
 313
 314 /**
 315  * Implementation of request_t.set.
 316  */
 317 static void set(private_request_t *this, char *key, char *value)
 318 {
 319         hdf_set_value(this->hdf, key, value);
 320 }
 321
 322 /**
 323  * Implementation of request_t.setf.
 324  */
 325 static void setf(private_request_t *this, char *format, ...)
 326 {
 327         va_list args;
 328
 329         va_start(args, format);
 330         hdf_set_valuevf(this->hdf, format, args);
 331         va_end(args);
 332 }
 333
 334 /**
 335  * Implementation of request_t.get_ref.
 336  */
 337 static request_t* get_ref(private_request_t *this)
 338 {
 339         ref_get(&this->ref);
 340         return &this->public;
 341 }
 342
 343 /**
 344  * Implementation of request_t.destroy
 345  */
 346 static void destroy(private_request_t *this)
 347 {
 348         if (ref_put(&this->ref))
 349         {
 350                 pthread_setspecific(this_key, this);
 351                 cgi_destroy(&this->cgi);
 352                 FCGX_Finish_r(&this->req);
 353                 free(this);
 354         }
 355 }
 356
 357 /**
 358  * This initialization method is guaranteed to run only once
 359  * for all threads.
 360  */
 361 static void init(void)
 362 {
 363         cgiwrap_init_emu(NULL, read_cb, writef_cb, write_cb,
 364                          getenv_cb, putenv_cb, iterenv_cb);
 365         pthread_key_create(&this_key, NULL);
 366 }
 367
 368 /*
 369  * see header file
 370  */
 371 request_t *request_create(int fd, bool debug)
 372 {
 373         NEOERR* err;
 374         private_request_t *this = malloc_thing(private_request_t);
 375         bool failed = FALSE;
 376
 377         pthread_cleanup_push(free, this);
 378         if (FCGX_InitRequest(&this->req, fd, 0) != 0 ||
 379                 FCGX_Accept_r(&this->req) != 0)
 380         {
 381                 failed = TRUE;
 382         }
 383         pthread_cleanup_pop(failed);
 384         if (failed)
 385         {
 386                 return NULL;
 387         }
 388
 389         this->public.get_path = (char*(*)(request_t*))get_path;
 390         this->public.get_base = (char*(*)(request_t*))get_base;
 391         this->public.get_host = (char*(*)(request_t*))get_host;
 392         this->public.get_user_agent = (char*(*)(request_t*))get_user_agent;
 393         this->public.add_cookie = (void(*)(request_t*, char *name, char *value))add_cookie;
 394         this->public.get_cookie = (char*(*)(request_t*,char*))get_cookie;
 395         this->public.get_query_data = (char*(*)(request_t*, char *name))get_query_data;
 396         this->public.session_closed = (bool(*)(request_t*))session_closed;
 397         this->public.close_session = (void(*)(request_t*))close_session;
 398         this->public.redirect = (void(*)(request_t*, char *fmt,...))redirect;
 399         this->public.to_referer = (void(*)(request_t*))to_referer;
 400         this->public.render = (void(*)(request_t*,char*))render;
 401         this->public.streamf = (int(*)(request_t*, char *format, ...))streamf;
 402         this->public.serve = (void(*)(request_t*,char*,chunk_t))serve;
 403         this->public.set = (void(*)(request_t*, char *, char*))set;
 404         this->public.setf = (void(*)(request_t*, char *format, ...))setf;
 405         this->public.get_ref = (request_t*(*)(request_t*))get_ref;
 406         this->public.destroy = (void(*)(request_t*))destroy;
 407
 408         pthread_once(&once, init);
 409         pthread_setspecific(this_key, this);
 410
 411         this->ref = 1;
 412         this->closed = FALSE;
 413         this->req_env_len = 0;
 414         while (this->req.envp[this->req_env_len] != NULL)
 415         {
 416                 this->req_env_len++;
 417         }
 418
 419         err = hdf_init(&this->hdf);
 420         if (!err)
 421         {
 422                 hdf_set_value(this->hdf, "base", get_base(this));
 423                 hdf_set_value(this->hdf, "Config.NoCache", "true");
 424                 if (!debug)
 425                 {
 426                         hdf_set_value(this->hdf, "Config.TimeFooter", "0");
 427                         hdf_set_value(this->hdf, "Config.CompressionEnabled", "1");
 428                         hdf_set_value(this->hdf, "Config.WhiteSpaceStrip", "2");
 429                 }
 430
 431                 err = cgi_init(&this->cgi, this->hdf);
 432                 if (!err)
 433                 {
 434                         err = cgi_parse(this->cgi);
 435                         if (!err)
 436                         {
 437                                 return &this->public;
 438                         }
 439                         cgi_destroy(&this->cgi);
 440                 }
 441         }
 442         nerr_log_error(err);
 443         FCGX_Finish_r(&this->req);
 444         free(this);
 445         return NULL;
 446 }
 447