96b1b82e7a8a9f93684ab0bfd5970f51fbd87701
[collection4.git] / src / utils_cgi.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4 #include <ctype.h>
5 #include <errno.h>
6 #include <time.h>
7 #include <assert.h>
8
9 #include "utils_cgi.h"
10 #include "common.h"
11
12 #include <fcgiapp.h>
13 #include <fcgi_stdio.h>
14
15 struct parameter_s
16 {
17   char *key;
18   char *value;
19 };
20 typedef struct parameter_s parameter_t;
21
22 struct param_list_s
23 {
24   parameter_t *parameters;
25   size_t parameters_num;
26 };
27
28 static param_list_t *pl_global = NULL;
29
30 static char *uri_unescape_copy (char *dest, const char *src, size_t n) /* {{{ */
31 {
32   const char *src_ptr;
33   char *dest_ptr;
34
35   if ((dest == NULL) || (src == NULL) || (n < 1))
36     return (NULL);
37
38   src_ptr = src;
39   dest_ptr = dest;
40
41   *dest_ptr = 0;
42
43   while (*src_ptr != 0)
44   {
45     if (n < 2)
46       break;
47
48     if (*src_ptr == '+')
49     {
50       *dest_ptr = ' ';
51     }
52     else if ((src_ptr[0] == '%')
53         && isxdigit ((int) src_ptr[1]) && isxdigit ((int) src_ptr[2]))
54     {
55       char tmpstr[3];
56       char *endptr;
57       long value;
58
59       tmpstr[0] = src_ptr[1];
60       tmpstr[1] = src_ptr[2];
61       tmpstr[2] = 0;
62
63       errno = 0;
64       endptr = NULL;
65       value = strtol (tmpstr, &endptr, /* base = */ 16);
66       if ((endptr == tmpstr) || (errno != 0))
67       {
68         *dest_ptr = '?';
69       }
70       else
71       {
72         *dest_ptr = (char) value;
73       }
74
75       src_ptr += 2;
76     }
77     else
78     {
79       *dest_ptr = *src_ptr;
80     }
81
82     src_ptr++;
83     dest_ptr++;
84     *dest_ptr = 0;
85   } /* while (*src_ptr != 0) */
86
87   assert (*dest_ptr == 0);
88   return (dest);
89 } /* }}} char *uri_unescape */
90
91 static char *uri_unescape (const char *string) /* {{{ */
92 {
93   char buffer[4096];
94
95   if (string == NULL)
96     return (NULL);
97
98   uri_unescape_copy (buffer, string, sizeof (buffer));
99   
100   return (strdup (buffer));
101 } /* }}} char *uri_unescape */
102
103 static int param_parse_keyval (param_list_t *pl, char *keyval) /* {{{ */
104 {
105   char *key_raw;
106   char *value_raw;
107   char *key;
108   char *value;
109
110   key_raw = keyval;
111   value_raw = strchr (key_raw, '=');
112   if (value_raw == NULL)
113     return (EINVAL);
114   *value_raw = 0;
115   value_raw++;
116
117   key = uri_unescape (key_raw);
118   if (key == NULL)
119     return (ENOMEM);
120
121   value = uri_unescape (value_raw);
122   if (value == NULL)
123   {
124     free (key);
125     return (ENOMEM);
126   }
127   
128   param_set (pl, key, value);
129
130   free (key);
131   free (value);
132
133   return (0);
134 } /* }}} int param_parse_keyval */
135
136 static int parse_query_string (param_list_t *pl, /* {{{ */
137     char *query_string)
138 {
139   char *dummy;
140   char *keyval;
141
142   if ((pl == NULL) || (query_string == NULL))
143     return (EINVAL);
144
145   dummy = query_string;
146   while ((keyval = strtok (dummy, ";&")) != NULL)
147   {
148     dummy = NULL;
149     param_parse_keyval (pl, keyval);
150   }
151
152   return (0);
153 } /* }}} int parse_query_string */
154
155 int param_init (void) /* {{{ */
156 {
157   if (pl_global != NULL)
158     return (0);
159
160   pl_global = param_create (/* query string = */ NULL);
161   if (pl_global == NULL)
162     return (ENOMEM);
163
164   return (0);
165 } /* }}} int param_init */
166
167 void param_finish (void) /* {{{ */
168 {
169   param_destroy (pl_global);
170   pl_global = NULL;
171 } /* }}} void param_finish */
172
173 const char *param (const char *key) /* {{{ */
174 {
175   param_init ();
176
177   return (param_get (pl_global, key));
178 } /* }}} const char *param */
179
180 param_list_t *param_create (const char *query_string) /* {{{ */
181 {
182   char *tmp;
183   param_list_t *pl;
184
185   if (query_string == NULL)
186     query_string = getenv ("QUERY_STRING");
187
188   if (query_string == NULL)
189     return (NULL);
190
191   tmp = strdup (query_string);
192   if (tmp == NULL)
193     return (NULL);
194   
195   pl = malloc (sizeof (*pl));
196   if (pl == NULL)
197   {
198     free (tmp);
199     return (NULL);
200   }
201   memset (pl, 0, sizeof (*pl));
202
203   parse_query_string (pl, tmp);
204
205   free (tmp);
206   return (pl);
207 } /* }}} param_list_t *param_create */
208
209   param_list_t *param_clone (__attribute__((unused)) param_list_t *pl) /* {{{ */
210 {
211   /* FIXME: To be implemented. */
212   assert (23 == 42);
213   return (NULL);
214 } /* }}} param_list_t *param_clone */
215
216 void param_destroy (param_list_t *pl) /* {{{ */
217 {
218   size_t i;
219
220   if (pl == NULL)
221     return;
222
223   for (i = 0; i < pl->parameters_num; i++)
224   {
225     free (pl->parameters[i].key);
226     free (pl->parameters[i].value);
227   }
228   free (pl->parameters);
229   free (pl);
230 } /* }}} void param_destroy */
231
232 const char *param_get (param_list_t *pl, const char *name) /* {{{ */
233 {
234   size_t i;
235
236   if ((pl == NULL) || (name == NULL))
237     return (NULL);
238
239   for (i = 0; i < pl->parameters_num; i++)
240   {
241     if ((name == NULL) && (pl->parameters[i].key == NULL))
242       return (pl->parameters[i].value);
243     else if ((name != NULL) && (pl->parameters[i].key != NULL)
244         && (strcmp (name, pl->parameters[i].key) == 0))
245       return (pl->parameters[i].value);
246   }
247
248   return (NULL);
249 } /* }}} char *param_get */
250
251 static int param_add (param_list_t *pl, /* {{{ */
252     const char *key, const char *value)
253 {
254   parameter_t *tmp;
255
256   tmp = realloc (pl->parameters,
257       sizeof (*pl->parameters) * (pl->parameters_num + 1));
258   if (tmp == NULL)
259     return (ENOMEM);
260   pl->parameters = tmp;
261   tmp = pl->parameters + pl->parameters_num;
262
263   memset (tmp, 0, sizeof (*tmp));
264   tmp->key = strdup (key);
265   if (tmp->key == NULL)
266     return (ENOMEM);
267
268   tmp->value = strdup (value);
269   if (tmp->value == NULL)
270   {
271     free (tmp->key);
272     return (ENOMEM);
273   }
274
275   pl->parameters_num++;
276
277   return (0);
278 } /* }}} int param_add */
279
280 static int param_delete (param_list_t *pl, /* {{{ */
281     const char *name)
282 {
283   size_t i;
284
285   if ((pl == NULL) || (name == NULL))
286     return (EINVAL);
287
288   for (i = 0; i < pl->parameters_num; i++)
289     if (strcasecmp (pl->parameters[i].key, name) == 0)
290       break;
291
292   if (i >= pl->parameters_num)
293     return (ENOENT);
294
295   if (i < (pl->parameters_num - 1))
296   {
297     parameter_t p;
298
299     p = pl->parameters[i];
300     pl->parameters[i] = pl->parameters[pl->parameters_num - 1];
301     pl->parameters[pl->parameters_num - 1] = p;
302   }
303
304   pl->parameters_num--;
305   free (pl->parameters[pl->parameters_num].key);
306   free (pl->parameters[pl->parameters_num].value);
307
308   return (0);
309 } /* }}} int param_delete */
310
311 int param_set (param_list_t *pl, const char *name, /* {{{ */
312     const char *value)
313 {
314   parameter_t *p;
315   char *value_copy;
316   size_t i;
317
318   if ((pl == NULL) || (name == NULL))
319     return (EINVAL);
320
321   if (value == NULL)
322     return (param_delete (pl, name));
323
324   p = NULL;
325   for (i = 0; i < pl->parameters_num; i++)
326   {
327     if (strcasecmp (pl->parameters[i].key, name) == 0)
328     {
329       p = pl->parameters + i;
330       break;
331     }
332   }
333
334   if (p == NULL)
335     return (param_add (pl, name, value));
336
337   value_copy = strdup (value);
338   if (value_copy == NULL)
339     return (ENOMEM);
340
341   free (p->value);
342   p->value = value_copy;
343
344   return (0);
345 } /* }}} int param_set */
346
347 char *param_as_string (param_list_t *pl) /* {{{ */
348 {
349   char buffer[4096];
350   char key[2048];
351   char value[2048];
352   size_t i;
353
354   if (pl == NULL)
355     return (NULL);
356
357   buffer[0] = 0;
358   for (i = 0; i < pl->parameters_num; i++)
359   {
360     uri_escape_copy (key, pl->parameters[i].key, sizeof (key));
361     uri_escape_copy (value, pl->parameters[i].value, sizeof (value));
362
363     if (i != 0)
364       strlcat (buffer, ";", sizeof (buffer));
365     strlcat (buffer, key, sizeof (buffer));
366     strlcat (buffer, "=", sizeof (buffer));
367     strlcat (buffer, value, sizeof (buffer));
368   }
369
370   return (strdup (buffer));
371 } /* }}} char *param_as_string */
372
373 int param_print_hidden (param_list_t *pl) /* {{{ */
374 {
375   char key[2048];
376   char value[2048];
377   size_t i;
378
379   if (pl == NULL)
380     return (EINVAL);
381
382   for (i = 0; i < pl->parameters_num; i++)
383   {
384     html_escape_copy (key, pl->parameters[i].key, sizeof (key));
385     html_escape_copy (value, pl->parameters[i].value, sizeof (value));
386
387     printf ("  <input type=\"hidden\" name=\"%s\" value=\"%s\" />\n",
388         key, value);
389   }
390
391   return (0);
392 } /* }}} int param_print_hidden */
393
394 char *uri_escape_copy (char *dest, const char *src, size_t n) /* {{{ */
395 {
396   size_t in;
397   size_t out;
398
399   in = 0;
400   out = 0;
401   while (42)
402   {
403     if (src[in] == 0)
404     {
405       dest[out] = 0;
406       return (dest);
407     }
408     else if ((((unsigned char) src[in]) < 32)
409         || (src[in] == '&')
410         || (src[in] == ';')
411         || (src[in] == '?')
412         || (src[in] == '/')
413         || (((unsigned char) src[in]) >= 128))
414     {
415       char esc[4];
416
417       if ((n - out) < 4)
418         break;
419       
420       snprintf (esc, sizeof (esc), "%%%02x", (unsigned int) src[in]);
421       dest[out] = esc[0];
422       dest[out+1] = esc[1];
423       dest[out+2] = esc[2];
424
425       out += 3;
426       in++;
427     }
428     else
429     {
430       dest[out] = src[in];
431       out++;
432       in++;
433     }
434   } /* while (42) */
435
436   return (dest);
437 } /* }}} char *uri_escape_copy */
438
439 char *uri_escape (const char *string) /* {{{ */
440 {
441   char buffer[4096];
442
443   if (string == NULL)
444     return (NULL);
445
446   uri_escape_copy (buffer, string, sizeof (buffer));
447
448   return (strdup (buffer));
449 } /* }}} char *uri_escape */
450
451 const char *script_name (void) /* {{{ */
452 {
453   char *ret;
454
455   ret = getenv ("SCRIPT_NAME");
456   if (ret == NULL)
457     ret = "collection4.fcgi";
458
459   return (ret);
460 } /* }}} char *script_name */
461
462 int time_to_rfc1123 (time_t t, char *buffer, size_t buffer_size) /* {{{ */
463 {
464   struct tm tm_tmp;
465   size_t status;
466
467   /* RFC 1123 *requires* the time to be GMT and the "GMT" timezone string.
468    * Apache will ignore the timezone if "localtime_r" and "%z" is used,
469    * resulting in weird behavior. */
470   if (gmtime_r (&t, &tm_tmp) == NULL)
471     return (errno);
472
473   status = strftime (buffer, buffer_size, "%a, %d %b %Y %T GMT", &tm_tmp);
474   if (status == 0)
475     return (errno);
476
477   return (0);
478 } /* }}} int time_to_rfc1123 */
479
480 #define COPY_ENTITY(e) do {    \
481   size_t len = strlen (e);     \
482   if (dest_size < (len + 1)) \
483     break;                     \
484   strcpy (dest_ptr, (e));    \
485   dest_ptr += len;           \
486   dest_size -= len;          \
487 } while (0)
488
489 char *html_escape_copy (char *dest, const char *src, size_t n) /* {{{ */
490 {
491   char *dest_ptr;
492   size_t dest_size;
493   size_t pos;
494
495   dest[0] = 0;
496   dest_ptr = dest;
497   dest_size = n;
498   for (pos = 0; src[pos] != 0; pos++)
499   {
500     if (src[pos] == '"')
501       COPY_ENTITY ("&quot;");
502     else if (src[pos] == '<')
503       COPY_ENTITY ("&lt;");
504     else if (src[pos] == '>')
505       COPY_ENTITY ("&gt;");
506     else if (src[pos] == '&')
507       COPY_ENTITY ("&amp;");
508     else
509     {
510       *dest_ptr = src[pos];
511       dest_ptr++;
512       dest_size--;
513       *dest_ptr = 0;
514     }
515
516     if (dest_size <= 1)
517       break;
518   }
519
520   return (dest);
521 } /* }}} char *html_escape_copy */
522
523 #undef COPY_ENTITY
524
525 char *html_escape_buffer (char *buffer, size_t buffer_size) /* {{{ */
526 {
527   char tmp[buffer_size];
528
529   html_escape_copy (tmp, buffer, sizeof (tmp));
530   memcpy (buffer, tmp, buffer_size);
531
532   return (buffer);
533 } /* }}} char *html_escape_buffer */
534
535 char *html_escape (const char *string) /* {{{ */
536 {
537   char buffer[4096];
538
539   if (string == NULL)
540     return (NULL);
541
542   html_escape_copy (buffer, string, sizeof (buffer));
543
544   return (strdup (buffer));
545 } /* }}} char *html_escape */
546
547 int html_print_page (const char *title, /* {{{ */
548     const page_callbacks_t *cb, void *user_data)
549 {
550   char *title_html;
551
552   printf ("Content-Type: text/html\n\n");
553
554   if (title == NULL)
555     title = "c4: collection4 graph interface";
556
557   title_html = html_escape (title);
558
559   printf ("<html>\n"
560       "  <head>\n"
561       "    <title>%s</title>\n"
562       "    <link rel=\"stylesheet\" type=\"text/css\" href=\"../share/style.css\" />\n"
563       "    <script type=\"text/javascript\" src=\"../share/jquery-1.4.2.min.js\">\n"
564       "    </script>\n"
565       "    <script type=\"text/javascript\" src=\"../share/collection.js\">\n"
566       "    </script>\n"
567       "  </head>\n",
568       title_html);
569
570   printf ("  <body>\n"
571       "    <table id=\"layout-table\">\n"
572       "      <tr id=\"layout-top\">\n"
573       "        <td id=\"layout-top-left\">");
574   if (cb->top_left != NULL)
575     (*cb->top_left) (user_data);
576   else
577     html_print_logo (NULL);
578   printf ("</td>\n"
579       "        <td id=\"layout-top-center\">");
580   if (cb->top_center != NULL)
581     (*cb->top_center) (user_data);
582   else
583     printf ("<h1>%s</h1>", title_html);
584   printf ("</td>\n"
585       "        <td id=\"layout-top-right\">");
586   if (cb->top_right != NULL)
587     (*cb->top_right) (user_data);
588   printf ("</td>\n"
589       "      </tr>\n"
590       "      <tr id=\"layout-middle\">\n"
591       "        <td id=\"layout-middle-left\">");
592   if (cb->middle_left != NULL)
593     (*cb->middle_left) (user_data);
594   printf ("</td>\n"
595       "        <td id=\"layout-middle-center\">");
596   if (cb->middle_center != NULL)
597     (*cb->middle_center) (user_data);
598   printf ("</td>\n"
599       "        <td id=\"layout-middle-right\">");
600   if (cb->middle_right != NULL)
601     (*cb->middle_right) (user_data);
602   printf ("</td>\n"
603       "      </tr>\n"
604       "      <tr id=\"layout-bottom\">\n"
605       "        <td id=\"layout-bottom-left\">");
606   if (cb->bottom_left != NULL)
607     (*cb->bottom_left) (user_data);
608   printf ("</td>\n"
609       "        <td id=\"layout-bottom-center\">");
610   if (cb->bottom_center != NULL)
611     (*cb->bottom_center) (user_data);
612   printf ("</td>\n"
613       "        <td id=\"layout-bottom-right\">");
614   if (cb->bottom_right != NULL)
615     (*cb->bottom_right) (user_data);
616   printf ("</td>\n"
617       "      </tr>\n"
618       "    </table>\n"
619       "  </body>\n"
620       "</html>\n");
621
622   free (title_html);
623   return (0);
624 } /* }}} int html_print_page */
625
626 int html_print_logo (__attribute__((unused)) void *user_data) /* {{{ */
627 {
628   printf ("<a href=\"%s?action=list_graphs\" id=\"logo-canvas\">\n"
629       "  <h1>c<sup>4</sup></h1>\n"
630       "  <div id=\"logo-subscript\">collection&nbsp;4</div>\n"
631       "</a>\n");
632
633   return (0);
634 } /* }}} int html_print_search_box */
635
636 int html_print_search_box (__attribute__((unused)) void *user_data) /* {{{ */
637 {
638   char *term_html;
639
640   term_html = html_escape (param ("q"));
641
642   printf ("<form action=\"%s\" method=\"get\" id=\"search-form\">\n"
643       "  <input type=\"hidden\" name=\"action\" value=\"list_graphs\" />\n"
644       "  <input type=\"text\" name=\"q\" value=\"%s\" id=\"search-input\" />\n"
645       "  <input type=\"submit\" name=\"button\" value=\"Search\" />\n"
646       "</form>\n",
647       script_name (),
648       (term_html != NULL) ? term_html : "");
649
650   free (term_html);
651
652   return (0);
653 } /* }}} int html_print_search_box */
654
655 /* vim: set sw=2 sts=2 et fdm=marker : */