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 "config.h"
   7
   8 #include <ctype.h>
   9 #include <fcntl.h>
  10 #include <errno.h>
  11 #include <signal.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/stat.h>
  16 #include <unistd.h>
  17
  18 #ifdef HAVE_MMAP
  19 #include <sys/mman.h>
  20 #endif
  21
  22 #include <libsoup/soup.h>
  23
  24 #ifdef HAVE_MMAP
  25 struct mapping {
  26         void   *start;
  27         size_t  length;
  28 };
  29
  30 static void
  31 free_mapping (gpointer data)
  32 {
  33         struct mapping *mapping = data;
  34         munmap (mapping->start, mapping->length);
  35         g_slice_free (struct mapping, mapping);
  36 }
  37 #endif
  38
  39 static void
  40 do_get (SoupServer *server, SoupMessage *msg, const char *path)
  41 {
  42         char *slash;
  43         struct stat st;
  44         int fd;
  45
  46         if (stat (path, &st) == -1) {
  47                 if (errno == EPERM)
  48                         soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
  49                 else if (errno == ENOENT)
  50                         soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
  51                 else
  52                         soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
  53                 return;
  54         }
  55
  56         if (S_ISDIR (st.st_mode)) {
  57                 char *index_path;
  58
  59                 slash = strrchr (path, '/');
  60                 if (!slash || slash[1]) {
  61                         char *uri, *redir_uri;
  62
  63                         uri = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
  64                         redir_uri = g_strdup_printf ("%s/", uri);
  65                         soup_message_headers_append (msg->response_headers,
  66                                                      "Location", redir_uri);
  67                         soup_message_set_status (msg, SOUP_STATUS_MOVED_PERMANENTLY);
  68                         g_free (redir_uri);
  69                         g_free (uri);
  70                         return;
  71                 }
  72
  73                 index_path = g_strdup_printf ("%s/index.html", path);
  74                 do_get (server, msg, index_path);
  75                 g_free (index_path);
  76                 return;
  77         }
  78
  79         fd = open (path, O_RDONLY);
  80         if (fd == -1) {
  81                 soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
  82                 return;
  83         }
  84
  85         if (msg->method == SOUP_METHOD_GET) {
  86 #ifdef HAVE_MMAP
  87                 struct mapping *mapping = g_slice_new (struct mapping);
  88                 SoupBuffer *buffer;
  89
  90                 mapping->start = mmap (NULL, st.st_size, PROT_READ,
  91                                        MAP_PRIVATE, fd, 0);
  92                 mapping->length = st.st_size;
  93                 buffer = soup_buffer_new_with_owner (mapping->start,
  94                                                      mapping->length,
  95                                                      mapping, free_mapping);
  96                 soup_message_body_append_buffer (msg->response_body, buffer);
  97                 soup_buffer_free (buffer);
  98 #else
  99                 char *buf;
 100
 101                 buf = g_malloc (st.st_size);
 102                 read (fd, buf, st.st_size);
 103                 close (fd);
 104                 soup_message_body_append (msg->response_body, SOUP_MEMORY_TAKE,
 105                                           buf, st.st_size);
 106 #endif
 107         } else /* msg->method == SOUP_METHOD_HEAD */ {
 108                 char *length;
 109
 110                 /* We could just use the same code for both GET and
 111                  * HEAD. But we'll optimize and avoid the extra
 112                  * malloc.
 113                  */
 114                 length = g_strdup_printf ("%lu", (gulong)st.st_size);
 115                 soup_message_headers_append (msg->response_headers,
 116                                              "Content-Length", length);
 117                 g_free (length);
 118         }
 119
 120         soup_message_set_status (msg, SOUP_STATUS_OK);
 121 }
 122
 123 static void
 124 do_put (SoupServer *server, SoupMessage *msg, const char *path)
 125 {
 126         struct stat st;
 127         FILE *f;
 128         gboolean created = TRUE;
 129
 130         if (stat (path, &st) != -1) {
 131                 const char *match = soup_message_headers_get (msg->request_headers, "If-None-Match");
 132                 if (match && !strcmp (match, "*")) {
 133                         soup_message_set_status (msg, SOUP_STATUS_CONFLICT);
 134                         return;
 135                 }
 136
 137                 if (!S_ISREG (st.st_mode)) {
 138                         soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
 139                         return;
 140                 }
 141
 142                 created = FALSE;
 143         }
 144
 145         f = fopen (path, "w");
 146         if (!f) {
 147                 soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
 148                 return;
 149         }
 150
 151         fwrite (msg->request_body->data, 1, msg->request_body->length, f);
 152         fclose (f);
 153
 154         soup_message_set_status (msg, created ? SOUP_STATUS_CREATED : SOUP_STATUS_OK);
 155 }
 156
 157 static void
 158 server_callback (SoupServer *server, SoupMessage *msg,
 159                  const char *path, GHashTable *query,
 160                  SoupClientContext *context, gpointer data)
 161 {
 162         char *file_path;
 163         SoupMessageHeadersIter iter;
 164         const char *name, *value;
 165
 166         printf ("%s %s HTTP/1.%d\n", msg->method, path,
 167                 soup_message_get_http_version (msg));
 168         soup_message_headers_iter_init (&iter, msg->request_headers);
 169         while (soup_message_headers_iter_next (&iter, &name, &value))
 170                 printf ("%s: %s\n", name, value);
 171         if (msg->request_body->length)
 172                 printf ("%s\n", msg->request_body->data);
 173
 174         file_path = g_strdup_printf (".%s", path);
 175
 176         if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD)
 177                 do_get (server, msg, file_path);
 178         else if (msg->method == SOUP_METHOD_PUT)
 179                 do_put (server, msg, file_path);
 180         else
 181                 soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
 182
 183         g_free (file_path);
 184         printf ("  -> %d %s\n\n", msg->status_code, msg->reason_phrase);
 185 }
 186
 187 static void
 188 quit (int sig)
 189 {
 190         /* Exit cleanly on ^C in case we're valgrinding. */
 191         exit (0);
 192 }
 193
 194 int
 195 main (int argc, char **argv)
 196 {
 197         GMainLoop *loop;
 198         SoupServer *server, *ssl_server;
 199         int opt;
 200         int port = SOUP_ADDRESS_ANY_PORT;
 201         int ssl_port = SOUP_ADDRESS_ANY_PORT;
 202         const char *ssl_cert_file = NULL, *ssl_key_file = NULL;
 203
 204         g_type_init ();
 205         g_thread_init (NULL);
 206         signal (SIGINT, quit);
 207
 208         while ((opt = getopt (argc, argv, "p:k:c:s:")) != -1) {
 209                 switch (opt) {
 210                 case 'p':
 211                         port = atoi (optarg);
 212                         break;
 213                 case 'k':
 214                         ssl_key_file = optarg;
 215                         break;
 216                 case 'c':
 217                         ssl_cert_file = optarg;
 218                         break;
 219                 case 's':
 220                         ssl_port = atoi (optarg);
 221                         break;
 222                 default:
 223                         fprintf (stderr, "Usage: %s [-p port] [-c ssl-cert-file -k ssl-key-file [-s ssl-port]]\n",
 224                                  argv[0]);
 225                         exit (1);
 226                 }
 227         }
 228
 229         server = soup_server_new (SOUP_SERVER_PORT, port,
 230                                   SOUP_SERVER_SERVER_HEADER, "simple-httpd ",
 231                                   NULL);
 232         if (!server) {
 233                 fprintf (stderr, "Unable to bind to server port %d\n", port);
 234                 exit (1);
 235         }
 236         soup_server_add_handler (server, NULL,
 237                                  server_callback, NULL, NULL);
 238         printf ("\nStarting Server on port %d\n",
 239                 soup_server_get_port (server));
 240         soup_server_run_async (server);
 241
 242         if (ssl_cert_file && ssl_key_file) {
 243                 ssl_server = soup_server_new (
 244                         SOUP_SERVER_PORT, ssl_port,
 245                         SOUP_SERVER_SSL_CERT_FILE, ssl_cert_file,
 246                         SOUP_SERVER_SSL_KEY_FILE, ssl_key_file,
 247                         NULL);
 248
 249                 if (!ssl_server) {
 250                         fprintf (stderr, "Unable to bind to SSL server port %d\n", ssl_port);
 251                         exit (1);
 252                 }
 253                 soup_server_add_handler (ssl_server, NULL,
 254                                          server_callback, NULL, NULL);
 255                 printf ("Starting SSL Server on port %d\n",
 256                         soup_server_get_port (ssl_server));
 257                 soup_server_run_async (ssl_server);
 258         }
 259
 260         printf ("\nWaiting for requests...\n");
 261
 262         loop = g_main_loop_new (NULL, TRUE);
 263         g_main_loop_run (loop);
 264
 265         return 0;
 266 }