tools/tools/netrate/httpd/httpd.c

   1 /*-
   2  * Copyright (c) 2005-2006 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/mman.h>
  31 #include <sys/socket.h>
  32 #include <sys/uio.h>
  33 #include <sys/utsname.h>
  34 #include <sys/wait.h>
  35
  36 #include <netinet/in.h>
  37
  38 #include <arpa/inet.h>
  39
  40 #include <err.h>
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #include <limits.h>
  44 #include <pthread.h>
  45 #include <signal.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <sysexits.h>
  50 #include <unistd.h>
  51
  52 static int      threaded;               /* 1 for threaded, 0 for forked. */
  53
  54 /*
  55  * Simple, multi-threaded/multi-process HTTP server.  Very dumb.
  56  *
  57  * If a path is specified as an argument, only that file is served.  If no
  58  * path is specified, httpd will create one file to send per server thread.
  59  */
  60 #define THREADS         128
  61 #define BUFFER          1024
  62 #define FILESIZE        1024
  63
  64 #define HTTP_OK         "HTTP/1.1 200 OK\n"
  65 #define HTTP_SERVER1    "Server rwatson_httpd/1.0 ("
  66 #define HTTP_SERVER2    ")\n"
  67 #define HTTP_CONNECTION "Connection: close\n"
  68 #define HTTP_CONTENT    "Content-Type: text/html\n\n"
  69
  70 /*
  71  * In order to support both multi-threaded and multi-process operation but
  72  * use a single shared memory statistics model, we create a page-aligned
  73  * statistics buffer.  For threaded operation, it's just shared memory due to
  74  * threading; for multi-process operation, we mark it as INHERIT_SHARE, so we
  75  * must put it in page-aligned memory that isn't shared with other memory, or
  76  * risk accidental sharing of other statep.
  77  */
  78 static struct state {
  79         struct httpd_thread_statep {
  80                 pthread_t       hts_thread;     /* Multi-thread. */
  81                 pid_t           hts_pid;        /* Multi-process. */
  82                 int             hts_fd;
  83         } hts[THREADS];
  84
  85         const char      *path;
  86         int              data_file;
  87         int              listen_sock;
  88         struct utsname   utsname;
  89 } *statep;
  90
  91 /*
  92  * Borrowed from sys/param.h.
  93  */
  94 #define roundup(x, y)   ((((x)+((y)-1))/(y))*(y))       /* to any y */
  95
  96 /*
  97  * Given an open client socket, process its request.  No notion of timeout.
  98  */
  99 static int
 100 http_serve(int sock, int fd)
 101 {
 102         struct iovec header_iovec[6];
 103         struct sf_hdtr sf_hdtr;
 104         char buffer[BUFFER];
 105         ssize_t len;
 106         int i, ncount;
 107
 108         /* Read until \n\n.  Not very smart. */
 109         ncount = 0;
 110         while (1) {
 111                 len = recv(sock, buffer, BUFFER, 0);
 112                 if (len < 0) {
 113                         warn("recv");
 114                         return (-1);
 115                 }
 116                 if (len == 0)
 117                         return (-1);
 118                 for (i = 0; i < len; i++) {
 119                         switch (buffer[i]) {
 120                         case '\n':
 121                                 ncount++;
 122                                 break;
 123
 124                         case '\r':
 125                                 break;
 126
 127                         default:
 128                                 ncount = 0;
 129                         }
 130                 }
 131                 if (ncount == 2)
 132                         break;
 133         }
 134
 135         bzero(&sf_hdtr, sizeof(sf_hdtr));
 136         bzero(&header_iovec, sizeof(header_iovec));
 137         header_iovec[0].iov_base = HTTP_OK;
 138         header_iovec[0].iov_len = strlen(HTTP_OK);
 139         header_iovec[1].iov_base = HTTP_SERVER1;
 140         header_iovec[1].iov_len = strlen(HTTP_SERVER1);
 141         header_iovec[2].iov_base = statep->utsname.sysname;
 142         header_iovec[2].iov_len = strlen(statep->utsname.sysname);
 143         header_iovec[3].iov_base = HTTP_SERVER2;
 144         header_iovec[3].iov_len = strlen(HTTP_SERVER2);
 145         header_iovec[4].iov_base = HTTP_CONNECTION;
 146         header_iovec[4].iov_len = strlen(HTTP_CONNECTION);
 147         header_iovec[5].iov_base = HTTP_CONTENT;
 148         header_iovec[5].iov_len = strlen(HTTP_CONTENT);
 149         sf_hdtr.headers = header_iovec;
 150         sf_hdtr.hdr_cnt = 6;
 151         sf_hdtr.trailers = NULL;
 152         sf_hdtr.trl_cnt = 0;
 153
 154         if (sendfile(fd, sock, 0, 0, &sf_hdtr, NULL, 0) < 0)
 155                 warn("sendfile");
 156
 157         return (0);
 158 }
 159
 160 static void *
 161 httpd_worker(void *arg)
 162 {
 163         struct httpd_thread_statep *htsp;
 164         int sock;
 165
 166         htsp = arg;
 167
 168         while (1) {
 169                 sock = accept(statep->listen_sock, NULL, NULL);
 170                 if (sock < 0)
 171                         continue;
 172                 (void)http_serve(sock, htsp->hts_fd);
 173                 close(sock);
 174         }
 175 }
 176
 177 static void
 178 killall(void)
 179 {
 180         int i;
 181
 182         for (i = 0; i < THREADS; i++) {
 183                 if (statep->hts[i].hts_pid != 0)
 184                         (void)kill(statep->hts[i].hts_pid, SIGTERM);
 185         }
 186 }
 187
 188 static void
 189 usage(void)
 190 {
 191
 192         fprintf(stderr, "httpd [-t] port [path]\n");
 193         exit(EX_USAGE);
 194 }
 195
 196 int
 197 main(int argc, char *argv[])
 198 {
 199         u_char filebuffer[FILESIZE];
 200         char temppath[PATH_MAX];
 201         struct sockaddr_in sin;
 202         int ch, error, i;
 203         char *pagebuffer;
 204         ssize_t len;
 205         pid_t pid;
 206
 207
 208         while ((ch = getopt(argc, argv, "t")) != -1) {
 209                 switch (ch) {
 210                 case 't':
 211                         threaded = 1;
 212                         break;
 213
 214                 default:
 215                         usage();
 216                 }
 217         }
 218         argc -= optind;
 219         argv += optind;
 220
 221         if (argc != 1 && argc != 2)
 222                 usage();
 223
 224         len = roundup(sizeof(struct state), getpagesize());
 225         pagebuffer = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_ANON, -1, 0);
 226         if (pagebuffer == MAP_FAILED)
 227                 err(-1, "mmap");
 228         if (minherit(pagebuffer, len, INHERIT_SHARE) < 0)
 229                 err(-1, "minherit");
 230         statep = (struct state *)pagebuffer;
 231
 232         if (uname(&statep->utsname) < 0)
 233                 err(-1, "utsname");
 234
 235         statep->listen_sock = socket(PF_INET, SOCK_STREAM, 0);
 236         if (statep->listen_sock < 0)
 237                 err(-1, "socket(PF_INET, SOCK_STREAM)");
 238
 239         bzero(&sin, sizeof(sin));
 240         sin.sin_len = sizeof(sin);
 241         sin.sin_family = AF_INET;
 242         sin.sin_port = htons(atoi(argv[0]));
 243
 244         /*
 245          * If a path is specified, use it.  Otherwise, create temporary files
 246          * with some data for each thread.
 247          */
 248         statep->path = argv[1];
 249         if (statep->path != NULL) {
 250                 statep->data_file = open(statep->path, O_RDONLY);
 251                 if (statep->data_file < 0)
 252                         err(-1, "open: %s", statep->path);
 253                 for (i = 0; i < THREADS; i++)
 254                         statep->hts[i].hts_fd = statep->data_file;
 255         } else {
 256                 memset(filebuffer, 'A', FILESIZE - 1);
 257                 filebuffer[FILESIZE - 1] = '\n';
 258                 for (i = 0; i < THREADS; i++) {
 259                         snprintf(temppath, PATH_MAX, "/tmp/httpd.XXXXXXXXXXX");
 260                         statep->hts[i].hts_fd = mkstemp(temppath);
 261                         if (statep->hts[i].hts_fd < 0)
 262                                 err(-1, "mkstemp");
 263                         (void)unlink(temppath);
 264                         len = write(statep->hts[i].hts_fd, filebuffer,
 265                             FILESIZE);
 266                         if (len < 0)
 267                                 err(-1, "write");
 268                         if (len < FILESIZE)
 269                                 errx(-1, "write: short");
 270                 }
 271         }
 272
 273         if (bind(statep->listen_sock, (struct sockaddr *)&sin,
 274             sizeof(sin)) < 0)
 275                 err(-1, "bind");
 276
 277         if (listen(statep->listen_sock, -1) < 0)
 278                 err(-1, "listen");
 279
 280         for (i = 0; i < THREADS; i++) {
 281                 if (threaded) {
 282                         if (pthread_create(&statep->hts[i].hts_thread, NULL,
 283                             httpd_worker, &statep->hts[i]) != 0)
 284                                 err(-1, "pthread_create");
 285                 } else {
 286                         pid = fork();
 287                         if (pid < 0) {
 288                                 error = errno;
 289                                 killall();
 290                                 errno = error;
 291                                 err(-1, "fork");
 292                         }
 293                         if (pid == 0)
 294                                 httpd_worker(&statep->hts[i]);
 295                         statep->hts[i].hts_pid = pid;
 296                 }
 297         }
 298
 299         for (i = 0; i < THREADS; i++) {
 300                 if (threaded) {
 301                         if (pthread_join(statep->hts[i].hts_thread, NULL)
 302                             != 0)
 303                                 err(-1, "pthread_join");
 304                 } else {
 305                         pid = waitpid(statep->hts[i].hts_pid, NULL, 0);
 306                         if (pid == statep->hts[i].hts_pid)
 307                                 statep->hts[i].hts_pid = 0;
 308                 }
 309         }
 310         if (!threaded)
 311                 killall();
 312         return (0);
 313 }