tests/simple-httpd.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2001-2003, Ximian, Inc.
   4  */
   5
   6 #include "test-utils.h"
   7
   8 #include <dirent.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <stdio.h>
  12 #include <sys/stat.h>
  13
  14 #ifdef G_OS_WIN32
  15 #include <getopt.h>
  16 #endif
  17
  18 static int
  19 compare_strings (gconstpointer a, gconstpointer b)
  20 {
  21         const char **sa = (const char **)a;
  22         const char **sb = (const char **)b;
  23
  24         return strcmp (*sa, *sb);
  25 }
  26
  27 static GString *
  28 get_directory_listing (const char *path)
  29 {
  30         GPtrArray *entries;
  31         GString *listing;
  32         char *escaped;
  33         DIR *dir;
  34         struct dirent *dent;
  35         int i;
  36
  37         entries = g_ptr_array_new ();
  38         dir = opendir (path);
  39         if (dir) {
  40                 while ((dent = readdir (dir))) {
  41                         if (!strcmp (dent->d_name, ".") ||
  42                             (!strcmp (dent->d_name, "..") &&
  43                              !strcmp (path, "./")))
  44                                 continue;
  45                         escaped = g_markup_escape_text (dent->d_name, -1);
  46                         g_ptr_array_add (entries, escaped);
  47                 }
  48                 closedir (dir);
  49         }
  50
  51         g_ptr_array_sort (entries, (GCompareFunc)compare_strings);
  52
  53         listing = g_string_new ("<html>\r\n");
  54         escaped = g_markup_escape_text (strchr (path, '/'), -1);
  55         g_string_append_printf (listing, "<head><title>Index of %s</title></head>\r\n", escaped);
  56         g_string_append_printf (listing, "<body><h1>Index of %s</h1>\r\n<p>\r\n", escaped);
  57         g_free (escaped);
  58         for (i = 0; i < entries->len; i++) {
  59                 g_string_append_printf (listing, "<a href=\"%s\">%s</a><br>\r\n",
  60                                         (char *)entries->pdata[i],
  61                                         (char *)entries->pdata[i]);
  62                 g_free (entries->pdata[i]);
  63         }
  64         g_string_append (listing, "</body>\r\n</html>\r\n");
  65
  66         g_ptr_array_free (entries, TRUE);
  67         return listing;
  68 }
  69
  70 static void
  71 do_get (SoupServer *server, SoupMessage *msg, const char *path)
  72 {
  73         char *slash;
  74         struct stat st;
  75
  76         if (stat (path, &st) == -1) {
  77                 if (errno == EPERM)
  78                         soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
  79                 else if (errno == ENOENT)
  80                         soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
  81                 else
  82                         soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
  83                 return;
  84         }
  85
  86         if (S_ISDIR (st.st_mode)) {
  87                 GString *listing;
  88                 char *index_path;
  89
  90                 slash = strrchr (path, '/');
  91                 if (!slash || slash[1]) {
  92                         char *redir_uri;
  93
  94                         redir_uri = g_strdup_printf ("%s/", soup_message_get_uri (msg)->path);
  95                         soup_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY,
  96                                                    redir_uri);
  97                         g_free (redir_uri);
  98                         return;
  99                 }
 100
 101                 index_path = g_strdup_printf ("%s/index.html", path);
 102                 if (stat (index_path, &st) != -1) {
 103                         do_get (server, msg, index_path);
 104                         g_free (index_path);
 105                         return;
 106                 }
 107                 g_free (index_path);
 108
 109                 listing = get_directory_listing (path);
 110                 soup_message_set_response (msg, "text/html",
 111                                            SOUP_MEMORY_TAKE,
 112                                            listing->str, listing->len);
 113                 g_string_free (listing, FALSE);
 114                 return;
 115         }
 116
 117         if (msg->method == SOUP_METHOD_GET) {
 118                 GMappedFile *mapping;
 119                 SoupBuffer *buffer;
 120
 121                 mapping = g_mapped_file_new (path, FALSE, NULL);
 122                 if (!mapping) {
 123                         soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
 124                         return;
 125                 }
 126
 127                 buffer = soup_buffer_new_with_owner (g_mapped_file_get_contents (mapping),
 128                                                      g_mapped_file_get_length (mapping),
 129                                                      mapping, (GDestroyNotify)g_mapped_file_unref);
 130                 soup_message_body_append_buffer (msg->response_body, buffer);
 131                 soup_buffer_free (buffer);
 132         } else /* msg->method == SOUP_METHOD_HEAD */ {
 133                 char *length;
 134
 135                 /* We could just use the same code for both GET and
 136                  * HEAD (soup-message-server-io.c will fix things up).
 137                  * But we'll optimize and avoid the extra I/O.
 138                  */
 139                 length = g_strdup_printf ("%lu", (gulong)st.st_size);
 140                 soup_message_headers_append (msg->response_headers,
 141                                              "Content-Length", length);
 142                 g_free (length);
 143         }
 144
 145         soup_message_set_status (msg, SOUP_STATUS_OK);
 146 }
 147
 148 static void
 149 do_put (SoupServer *server, SoupMessage *msg, const char *path)
 150 {
 151         struct stat st;
 152         FILE *f;
 153         gboolean created = TRUE;
 154
 155         if (stat (path, &st) != -1) {
 156                 const char *match = soup_message_headers_get_one (msg->request_headers, "If-None-Match");
 157                 if (match && !strcmp (match, "*")) {
 158                         soup_message_set_status (msg, SOUP_STATUS_CONFLICT);
 159                         return;
 160                 }
 161
 162                 if (!S_ISREG (st.st_mode)) {
 163                         soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
 164                         return;
 165                 }
 166
 167                 created = FALSE;
 168         }
 169
 170         f = fopen (path, "w");
 171         if (!f) {
 172                 soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
 173                 return;
 174         }
 175
 176         fwrite (msg->request_body->data, 1, msg->request_body->length, f);
 177         fclose (f);
 178
 179         soup_message_set_status (msg, created ? SOUP_STATUS_CREATED : SOUP_STATUS_OK);
 180 }
 181
 182 static void
 183 server_callback (SoupServer *server, SoupMessage *msg,
 184                  const char *path, GHashTable *query,
 185                  SoupClientContext *context, gpointer data)
 186 {
 187         char *file_path;
 188         SoupMessageHeadersIter iter;
 189         const char *name, *value;
 190
 191         g_print ("%s %s HTTP/1.%d\n", msg->method, path,
 192                  soup_message_get_http_version (msg));
 193         soup_message_headers_iter_init (&iter, msg->request_headers);
 194         while (soup_message_headers_iter_next (&iter, &name, &value))
 195                 g_print ("%s: %s\n", name, value);
 196         if (msg->request_body->length)
 197                 g_print ("%s\n", msg->request_body->data);
 198
 199         file_path = g_strdup_printf (".%s", path);
 200
 201         if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD)
 202                 do_get (server, msg, file_path);
 203         else if (msg->method == SOUP_METHOD_PUT)
 204                 do_put (server, msg, file_path);
 205         else
 206                 soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
 207
 208         g_free (file_path);
 209         g_print ("  -> %d %s\n\n", msg->status_code, msg->reason_phrase);
 210 }
 211
 212 static void
 213 quit (int sig)
 214 {
 215         /* Exit cleanly on ^C in case we're valgrinding. */
 216         exit (0);
 217 }
 218
 219 int
 220 main (int argc, char **argv)
 221 {
 222         GMainLoop *loop;
 223         SoupServer *server, *ssl_server;
 224         int opt;
 225         int port = SOUP_ADDRESS_ANY_PORT;
 226         int ssl_port = SOUP_ADDRESS_ANY_PORT;
 227         const char *ssl_cert_file = NULL, *ssl_key_file = NULL;
 228
 229         signal (SIGINT, quit);
 230
 231         while ((opt = getopt (argc, argv, "p:k:c:s:")) != -1) {
 232                 switch (opt) {
 233                 case 'p':
 234                         port = atoi (optarg);
 235                         break;
 236                 case 'k':
 237                         ssl_key_file = optarg;
 238                         break;
 239                 case 'c':
 240                         ssl_cert_file = optarg;
 241                         break;
 242                 case 's':
 243                         ssl_port = atoi (optarg);
 244                         break;
 245                 default:
 246                         g_printerr ("Usage: %s [-p port] [-c ssl-cert-file -k ssl-key-file [-s ssl-port]]\n",
 247                                     argv[0]);
 248                         exit (1);
 249                 }
 250         }
 251
 252         server = soup_server_new (SOUP_SERVER_PORT, port,
 253                                   SOUP_SERVER_SERVER_HEADER, "simple-httpd ",
 254                                   NULL);
 255         if (!server) {
 256                 g_printerr ("Unable to bind to server port %d\n", port);
 257                 exit (1);
 258         }
 259         soup_server_add_handler (server, NULL,
 260                                  server_callback, NULL, NULL);
 261         g_print ("\nStarting Server on port %d\n",
 262                  soup_server_get_port (server));
 263         soup_server_run_async (server);
 264
 265         if (ssl_cert_file && ssl_key_file) {
 266                 ssl_server = soup_server_new (
 267                         SOUP_SERVER_PORT, ssl_port,
 268                         SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
 269                         SOUP_SERVER_SSL_KEY_FILE, ssl_key_file,
 270                         NULL);
 271
 272                 if (!ssl_server) {
 273                         g_printerr ("Unable to bind to SSL server port %d\n", ssl_port);
 274                         exit (1);
 275                 }
 276                 soup_server_add_handler (ssl_server, NULL,
 277                                          server_callback, NULL, NULL);
 278                 g_print ("Starting SSL Server on port %d\n",
 279                          soup_server_get_port (ssl_server));
 280                 soup_server_run_async (ssl_server);
 281         }
 282
 283         g_print ("\nWaiting for requests...\n");
 284
 285         loop = g_main_loop_new (NULL, TRUE);
 286         g_main_loop_run (loop);
 287
 288         return 0;
 289 }