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
  16 #define _GNU_SOURCE
  17
  18 #include "request.h"
  19
  20 #include <library.h>
  21 #include <debug.h>
  22 #include <stdlib.h>
  23 #include <pthread.h>
  24 #include <string.h>
  25 #include <ClearSilver/ClearSilver.h>
  26
  27 #include <threading/thread.h>
  28 #include <threading/thread_value.h>
  29
  30 typedef struct private_request_t private_request_t;
  31
  32 /**
  33  * private data of the task manager
  34  */
  35 struct private_request_t {
  36
  37         /**
  38          * public functions
  39          */
  40         request_t public;
  41
  42         /**
  43          * FastCGI request object
  44          */
  45         FCGX_Request req;
  46
  47         /**
  48          * length of the req.envp array
  49          */
  50         int req_env_len;
  51
  52         /**
  53          * ClearSilver CGI Kit context
  54          */
  55         CGI *cgi;
  56
  57         /**
  58          * ClearSilver HDF dataset for this request
  59          */
  60         HDF *hdf;
  61
  62         /**
  63          * close the session?
  64          */
  65         bool closed;
  66
  67         /**
  68          * reference count
  69          */
  70         refcount_t ref;
  71 };
  72
  73 /**
  74  * ClearSilver cgiwrap is not threadsave, so we use a private
  75  * context for each thread.
  76  */
  77 static thread_value_t *thread_this;
  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*)thread_this->get(thread_this);
  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*)thread_this->get(thread_this);
 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*)thread_this->get(thread_this);
 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*)thread_this->get(thread_this);
 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*)thread_this->get(thread_this);
 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.get_env_var.
 208  */
 209 static char* get_env_var(private_request_t *this, char *name)
 210 {
 211         return FCGX_GetParam(name, this->req.envp);
 212 }
 213
 214 /**
 215  * Implementation of request_t.read_data.
 216  */
 217 static int read_data(private_request_t *this, char *buf, int len)
 218 {
 219         return FCGX_GetStr(buf, len, this->req.in);
 220 }
 221
 222 /**
 223  * Implementation of request_t.get_base.
 224  */
 225 static char* get_base(private_request_t *this)
 226 {
 227         return FCGX_GetParam("SCRIPT_NAME", this->req.envp);
 228 }
 229
 230 /**
 231  * Implementation of request_t.add_cookie.
 232  */
 233 static void add_cookie(private_request_t *this, char *name, char *value)
 234 {
 235         thread_this->set(thread_this, this);
 236         cgi_cookie_set (this->cgi, name, value, get_base(this), NULL, NULL, 0, 0);
 237 }
 238
 239 /**
 240  * Implementation of request_t.redirect.
 241  */
 242 static void redirect(private_request_t *this, char *fmt, ...)
 243 {
 244         va_list args;
 245
 246         FCGX_FPrintF(this->req.out, "Status: 303 See Other\n");
 247         FCGX_FPrintF(this->req.out, "Location: %s%s", get_base(this),
 248                                  *fmt == '/' ? "" : "/");
 249         va_start(args, fmt);
 250         FCGX_VFPrintF(this->req.out, fmt, args);
 251         va_end(args);
 252         FCGX_FPrintF(this->req.out, "\n\n");
 253 }
 254
 255 /**
 256  * Implementation of request_t.get_referer.
 257  */
 258 static char* get_referer(private_request_t *this)
 259 {
 260         return FCGX_GetParam("HTTP_REFERER", this->req.envp);
 261 }
 262
 263 /**
 264  * Implementation of request_t.to_referer.
 265  */
 266 static void to_referer(private_request_t *this)
 267 {
 268         char *referer;
 269
 270         referer = get_referer(this);
 271         if (referer)
 272         {
 273                 FCGX_FPrintF(this->req.out, "Status: 303 See Other\n");
 274                 FCGX_FPrintF(this->req.out, "Location: %s\n\n", referer);
 275         }
 276         else
 277         {
 278                 redirect(this, "/");
 279         }
 280 }
 281
 282 /**
 283  * Implementation of request_t.session_closed.
 284  */
 285 static bool session_closed(private_request_t *this)
 286 {
 287         return this->closed;
 288 }
 289
 290 /**
 291  * Implementation of request_t.close_session.
 292  */
 293 static void close_session(private_request_t *this)
 294 {
 295         this->closed = TRUE;
 296 }
 297
 298 /**
 299  * Implementation of request_t.serve.
 300  */
 301 static void serve(private_request_t *this, char *headers, chunk_t chunk)
 302 {
 303         FCGX_FPrintF(this->req.out, "%s\n\n", headers);
 304
 305         FCGX_PutStr(chunk.ptr, chunk.len, this->req.out);
 306 }
 307
 308 /**
 309  * Implementation of request_t.render.
 310  */
 311 static void render(private_request_t *this, char *template)
 312 {
 313         NEOERR* err;
 314
 315         thread_this->set(thread_this, this);
 316         err = cgi_display(this->cgi, template);
 317         if (err)
 318         {
 319                 cgi_neo_error(this->cgi, err);
 320                 nerr_log_error(err);
 321         }
 322         return;
 323 }
 324
 325 /**
 326  * Implementation of request_t.streamf.
 327  */
 328 static int streamf(private_request_t *this, char *format, ...)
 329 {
 330         va_list args;
 331         int written;
 332
 333         va_start(args, format);
 334         written = FCGX_VFPrintF(this->req.out, format, args);
 335         va_end(args);
 336         if (written >= 0 &&
 337                 FCGX_FFlush(this->req.out) == -1)
 338         {
 339                 return -1;
 340         }
 341         return written;
 342 }
 343
 344 /**
 345  * Implementation of request_t.set.
 346  */
 347 static void set(private_request_t *this, char *key, char *value)
 348 {
 349         hdf_set_value(this->hdf, key, value);
 350 }
 351
 352 /**
 353  * Implementation of request_t.setf.
 354  */
 355 static void setf(private_request_t *this, char *format, ...)
 356 {
 357         va_list args;
 358
 359         va_start(args, format);
 360         hdf_set_valuevf(this->hdf, format, args);
 361         va_end(args);
 362 }
 363
 364 /**
 365  * Implementation of request_t.get_ref.
 366  */
 367 static request_t* get_ref(private_request_t *this)
 368 {
 369         ref_get(&this->ref);
 370         return &this->public;
 371 }
 372
 373 /**
 374  * Implementation of request_t.destroy
 375  */
 376 static void destroy(private_request_t *this)
 377 {
 378         if (ref_put(&this->ref))
 379         {
 380                 thread_this->set(thread_this, this);
 381                 cgi_destroy(&this->cgi);
 382                 FCGX_Finish_r(&this->req);
 383                 free(this);
 384         }
 385 }
 386
 387 /**
 388  * This initialization method is guaranteed to run only once
 389  * for all threads.
 390  */
 391 static void init(void)
 392 {
 393         cgiwrap_init_emu(NULL, read_cb, writef_cb, write_cb,
 394                                          getenv_cb, putenv_cb, iterenv_cb);
 395         thread_this = thread_value_create(NULL);
 396 }
 397
 398 /*
 399  * see header file
 400  */
 401 request_t *request_create(int fd, bool debug)
 402 {
 403         NEOERR* err;
 404         private_request_t *this = malloc_thing(private_request_t);
 405         bool failed = FALSE;
 406
 407         thread_cleanup_push(free, this);
 408         if (FCGX_InitRequest(&this->req, fd, 0) != 0 ||
 409                 FCGX_Accept_r(&this->req) != 0)
 410         {
 411                 failed = TRUE;
 412         }
 413         thread_cleanup_pop(failed);
 414         if (failed)
 415         {
 416                 return NULL;
 417         }
 418
 419         this->public.get_path = (char*(*)(request_t*))get_path;
 420         this->public.get_base = (char*(*)(request_t*))get_base;
 421         this->public.get_host = (char*(*)(request_t*))get_host;
 422         this->public.get_user_agent = (char*(*)(request_t*))get_user_agent;
 423         this->public.add_cookie = (void(*)(request_t*, char *name, char *value))add_cookie;
 424         this->public.get_cookie = (char*(*)(request_t*,char*))get_cookie;
 425         this->public.get_query_data = (char*(*)(request_t*, char *name))get_query_data;
 426         this->public.get_env_var = (char*(*)(request_t*, char *name))get_env_var;
 427         this->public.read_data = (int(*)(request_t*, char*, int))read_data;
 428         this->public.session_closed = (bool(*)(request_t*))session_closed;
 429         this->public.close_session = (void(*)(request_t*))close_session;
 430         this->public.redirect = (void(*)(request_t*, char *fmt,...))redirect;
 431         this->public.get_referer = (char*(*)(request_t*))get_referer;
 432         this->public.to_referer = (void(*)(request_t*))to_referer;
 433         this->public.render = (void(*)(request_t*,char*))render;
 434         this->public.streamf = (int(*)(request_t*, char *format, ...))streamf;
 435         this->public.serve = (void(*)(request_t*,char*,chunk_t))serve;
 436         this->public.set = (void(*)(request_t*, char *, char*))set;
 437         this->public.setf = (void(*)(request_t*, char *format, ...))setf;
 438         this->public.get_ref = (request_t*(*)(request_t*))get_ref;
 439         this->public.destroy = (void(*)(request_t*))destroy;
 440
 441         pthread_once(&once, init);
 442         thread_this->set(thread_this, this);
 443
 444         this->ref = 1;
 445         this->closed = FALSE;
 446         this->req_env_len = 0;
 447         while (this->req.envp[this->req_env_len] != NULL)
 448         {
 449                 this->req_env_len++;
 450         }
 451
 452         err = hdf_init(&this->hdf);
 453         if (!err)
 454         {
 455                 hdf_set_value(this->hdf, "base", get_base(this));
 456                 hdf_set_value(this->hdf, "Config.NoCache", "true");
 457                 if (!debug)
 458                 {
 459                         hdf_set_value(this->hdf, "Config.TimeFooter", "0");
 460                         hdf_set_value(this->hdf, "Config.CompressionEnabled", "1");
 461                         hdf_set_value(this->hdf, "Config.WhiteSpaceStrip", "2");
 462                 }
 463
 464                 err = cgi_init(&this->cgi, this->hdf);
 465                 if (!err)
 466                 {
 467                         err = cgi_parse(this->cgi);
 468                         if (!err)
 469                         {
 470                                 return &this->public;
 471                         }
 472                         cgi_destroy(&this->cgi);
 473                 }
 474         }
 475         nerr_log_error(err);
 476         FCGX_Finish_r(&this->req);
 477         free(this);
 478         return NULL;
 479 }
 480