src/utils_cgi.c

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