handle zero size Base64 conversions
[strongswan.git] / 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 strdupnull(value);
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