webcit-ng/server/http.c

   1 // This module handles HTTP transactions.
   2 //
   3 // Copyright (c) 1996-2022 by the citadel.org team
   4 //
   5 // This program is open source software.  Use, duplication, or
   6 // disclosure are subject to the GNU General Public License v3.
   7
   8 #include "webcit.h"
   9
  10 // Write data to the HTTP client.  Encrypt if necessary.
  11 int client_write(struct client_handle *ch, char *buf, int nbytes) {
  12         if (is_https) {
  13                 return client_write_ssl(ch, buf, nbytes);
  14         }
  15         else {
  16                 return write(ch->sock, buf, nbytes);
  17         }
  18 }
  19
  20
  21 // Read data from the HTTP client.  Decrypt if necessary.
  22 // Returns number of bytes read, or -1 to indicate an error.
  23 int client_read(struct client_handle *ch, char *buf, int nbytes) {
  24         if (is_https) {
  25                 return client_read_ssl(ch, buf, nbytes);
  26         }
  27         else {
  28                 int bytes_received = 0;
  29                 int bytes_this_block = 0;
  30                 while (bytes_received < nbytes) {
  31                         bytes_this_block = read(ch->sock, &buf[bytes_received], nbytes - bytes_received);
  32                         if (bytes_this_block < 1) {
  33                                 return (-1);
  34                         }
  35                         bytes_received += bytes_this_block;
  36                 }
  37                 return (nbytes);
  38         }
  39 }
  40
  41
  42 // Read a newline-terminated line of text from the client.
  43 // Implemented in terms of client_read() and is therefore transparent...
  44 // Returns the string length or -1 for error.
  45 int client_readline(struct client_handle *ch, char *buf, int maxbytes) {
  46         int len = 0;
  47         int c = 0;
  48
  49         if (buf == NULL) {
  50                 return (-1);
  51         }
  52
  53         while (len < maxbytes) {
  54                 c = client_read(ch, &buf[len], 1);
  55                 if (c <= 0) {
  56                         syslog(LOG_DEBUG, "Socket error or zero-length read");
  57                         return (-1);
  58                 }
  59                 if (buf[len] == '\n') {
  60                         if ((len > 0) && (buf[len - 1] == '\r')) {
  61                                 --len;
  62                         }
  63                         buf[len] = 0;
  64                         return (len);
  65                 }
  66                 ++len;
  67         }
  68         return (len);
  69 }
  70
  71
  72 // printf() type function to send data to the web client.
  73 void client_printf(struct client_handle *ch, const char *format, ...) {
  74         va_list arg_ptr;
  75         StrBuf *Buf = NewStrBuf();
  76
  77         va_start(arg_ptr, format);
  78         StrBufVAppendPrintf(Buf, format, arg_ptr);
  79         va_end(arg_ptr);
  80
  81         client_write(ch, (char *) ChrPtr(Buf), StrLength(Buf));
  82         FreeStrBuf(&Buf);
  83 }
  84
  85
  86 // Push one new header into the response of an HTTP request.
  87 // When completed, the HTTP transaction now owns the memory allocated for key and val.
  88 void add_response_header(struct http_transaction *h, char *key, char *val) {
  89         struct keyval new_response_header;
  90         new_response_header.key = key;
  91         new_response_header.val = val;
  92         array_append(h->response_headers, &new_response_header);
  93 }
  94
  95
  96 // Entry point for this layer.  Socket is connected.  If running as an HTTPS
  97 // server, SSL has already been negotiated.  Now perform one transaction.
  98 void perform_one_http_transaction(struct client_handle *ch) {
  99         char buf[1024];
 100         int len;
 101         int lines_read = 0;
 102         struct http_transaction h;
 103         char *c, *d;
 104         struct sockaddr_in sin;
 105         int i;                                  // general purpose iterator variable
 106
 107         memset(&h, 0, sizeof h);
 108         h.request_headers = array_new(sizeof(struct keyval));
 109         h.request_parms = array_new(sizeof(struct keyval));
 110         h.response_headers = array_new(sizeof(struct keyval));
 111
 112         while (len = client_readline(ch, buf, sizeof buf), (len > 0)) {
 113                 ++lines_read;
 114
 115                 if (lines_read == 1) {          // First line is method and URL.
 116                         c = strchr(buf, ' ');   // IGnore the HTTP-version.
 117                         if (c == NULL) {
 118                                 h.method = strdup("NULL");
 119                                 h.url = strdup("/");
 120                         }
 121                         else {
 122                                 *c = 0;
 123                                 h.method = strdup(buf);
 124                                 ++c;
 125                                 d = c;
 126                                 c = strchr(d, ' ');
 127                                 if (c != NULL) {
 128                                         *c = 0;
 129                                 }
 130                                 ++c;
 131                                 h.url = strdup(d);
 132                         }
 133                 }
 134                 else {                          // Subsequent lines are headers.
 135                         c = strchr(buf, ':');   // Header line folding is obsolete so we don't support it.
 136                         if (c != NULL) {
 137
 138                                 struct keyval new_request_header;
 139                                 *c = 0;
 140                                 new_request_header.key = strdup(buf);
 141                                 ++c;
 142                                 new_request_header.val = strdup(c);
 143                                 string_trim(new_request_header.key);
 144                                 string_trim(new_request_header.val);
 145                                 array_append(h.request_headers, &new_request_header);
 146 #ifdef DEBUG_HTTP
 147                                 syslog(LOG_DEBUG, "\033[1m\033[35m{ %s: %s\033[0m", new_request_header.key, new_request_header.val);
 148 #endif
 149                         }
 150                 }
 151
 152         }
 153
 154         // If the URL had any query parameters in it, parse them out now.
 155         char *p = (h.url ? strchr(h.url, '?') : NULL);
 156         if (p) {
 157                 *p++ = 0;                                               // insert a null to remove parameters from the URL
 158                 char *tok, *saveptr = NULL;
 159                 for (tok = strtok_r(p, "&", &saveptr); tok!=NULL; tok = strtok_r(NULL, "&", &saveptr)) {
 160                         char *eq = strchr(tok, '=');
 161                         if (eq) {
 162                                 *eq++ = 0;
 163                                 unescape_input(eq);
 164                                 struct keyval kv;
 165                                 kv.key = strdup(tok);
 166                                 kv.val = strdup(eq);
 167                                 array_append(h.request_parms, &kv);
 168 #ifdef DEBUG_HTTP
 169                                 syslog(LOG_DEBUG, "\033[1m\033[33m| %s = %s\033[0m", kv.key, kv.val);
 170 #endif
 171                         }
 172                 }
 173         }
 174
 175         // build up the site prefix, such as https://foo.bar.com:4343
 176         h.site_prefix = malloc(256);
 177         strcpy(h.site_prefix, (is_https ? "https://" : "http://"));
 178         char *hostheader = header_val(&h, "Host");
 179         if (hostheader) {
 180                 strcat(h.site_prefix, hostheader);
 181         }
 182         else {
 183                 strcat(h.site_prefix, "127.0.0.1");
 184         }
 185         socklen_t llen = sizeof(sin);
 186         if (getsockname(ch->sock, (struct sockaddr *) &sin, &llen) >= 0) {
 187                 sprintf(&h.site_prefix[strlen(h.site_prefix)], ":%d", ntohs(sin.sin_port));
 188         }
 189
 190         // Now try to read in the request body (if one is present)
 191         if (len < 0) {
 192                 syslog(LOG_DEBUG, "Client disconnected");
 193         }
 194         else {
 195 //#ifdef DEBUG_HTTP
 196                 syslog(LOG_DEBUG, "\033[33m\033[1m< %s %s\033[0m", h.method, h.url);
 197 //#endif
 198
 199                 // If there is a request body, read it now.
 200                 char *ccl = header_val(&h, "Content-Length");
 201                 if (ccl) {
 202                         h.request_body_length = atol(ccl);
 203                 }
 204                 if (h.request_body_length > 0) {
 205                         syslog(LOG_DEBUG, "Reading request body (%ld bytes)", h.request_body_length);
 206                         h.request_body = malloc(h.request_body_length);
 207                         client_read(ch, h.request_body, h.request_body_length);
 208
 209                         // Write the entire request body to stderr -- not what you want during normal operation.
 210                         #ifdef BODY_TO_STDERR
 211                         write(2, HKEY("\033[31m"));
 212                         write(2, h.request_body, h.request_body_length);
 213                         write(2, HKEY("\033[0m\n"));
 214                         #endif
 215
 216                 }
 217
 218                 // Now pass control up to the next layer to perform the request.
 219                 perform_request(&h);
 220
 221                 // Write the entire response body to stderr -- not what you want during normal operation.
 222                 #ifdef BODY_TO_STDERR
 223                 write(2, HKEY("\033[32m"));
 224                 write(2, h.response_body, h.response_body_length);
 225                 write(2, HKEY("\033[0m\n"));
 226                 #endif
 227
 228                 // Output the results back to the client.
 229 #ifdef DEBUG_HTTP
 230                 syslog(LOG_DEBUG, "\033[33m\033[1m> %03d %s\033[0m", h.response_code, h.response_string);
 231 #endif
 232                 client_printf(ch, "HTTP/1.1 %03d %s\r\n", h.response_code, h.response_string);
 233                 client_printf(ch, "Connection: close\r\n");
 234                 client_printf(ch, "Content-Length: %ld\r\n", h.response_body_length);
 235                 char *datestring = http_datestring(time(NULL));
 236                 if (datestring) {
 237                         client_printf(ch, "Date: %s\r\n", datestring);
 238                         free(datestring);
 239                 }
 240
 241                 client_printf(ch, "Content-encoding: identity\r\n");    // change if we gzip/deflate
 242                 int number_of_response_headers = array_len(h.response_headers);
 243                 for (i=0; i<number_of_response_headers; ++i) {
 244                         struct keyval *kv = array_get_element_at(h.response_headers, i);
 245 #ifdef DEBUG_HTTP
 246                         syslog(LOG_DEBUG, "\033[1m\033[35m} %s: %s\033[0m", kv->key, kv->val);
 247 #endif
 248                         client_printf(ch, "%s: %s\r\n", kv->key, kv->val);
 249                 }
 250                 client_printf(ch, "\r\n");
 251                 if ((h.response_body_length > 0) && (h.response_body != NULL)) {
 252                         client_write(ch, h.response_body, h.response_body_length);
 253                 }
 254         }
 255
 256         // free the transaction memory
 257         while (array_len(h.request_headers) > 0) {
 258                 struct keyval *kv = array_get_element_at(h.request_headers, 0);
 259                 if (kv->key) free(kv->key);
 260                 if (kv->val) free(kv->val);
 261                 array_delete_element_at(h.request_headers, 0);
 262         }
 263         array_free(h.request_headers);
 264         while (array_len(h.request_parms) > 0) {
 265                 struct keyval *kv = array_get_element_at(h.request_parms, 0);
 266                 if (kv->key) free(kv->key);
 267                 if (kv->val) free(kv->val);
 268                 array_delete_element_at(h.request_parms, 0);
 269         }
 270         array_free(h.request_parms);
 271         while (array_len(h.response_headers) > 0) {
 272                 struct keyval *kv = array_get_element_at(h.response_headers, 0);
 273                 if (kv->key) free(kv->key);
 274                 if (kv->val) free(kv->val);
 275                 array_delete_element_at(h.response_headers, 0);
 276         }
 277         array_free(h.response_headers);
 278         if (h.method) {
 279                 free(h.method);
 280         }
 281         if (h.url) {
 282                 free(h.url);
 283         }
 284         if (h.request_body) {
 285                 free(h.request_body);
 286         }
 287         if (h.response_string) {
 288                 free(h.response_string);
 289         }
 290         if (h.site_prefix) {
 291                 free(h.site_prefix);
 292         }
 293 }
 294
 295
 296 // Utility function to fetch a specific header from a completely read-in request.
 297 // Returns the value of the requested header, or NULL if the specified header was not sent.
 298 // The caller does NOT own the memory of the returned pointer, but can count on the pointer
 299 // to still be valid through the end of the transaction.
 300 char *header_val(struct http_transaction *h, char *requested_header) {
 301         struct keyval *kv;
 302         int i;
 303         for (i=0; i<array_len(h->request_headers); ++i) {
 304                 kv = array_get_element_at(h->request_headers, i);
 305                 if (!strcasecmp(kv->key, requested_header)) {
 306                         return (kv->val);
 307                 }
 308         }
 309         return (NULL);
 310 }
 311
 312
 313 // Utility function to fetch a specific URL parameter from a completely read-in request.
 314 // Returns the value of the requested parameter, or NULL if the specified parameter was not sent.
 315 // The caller does NOT own the memory of the returned pointer, but can count on the pointer
 316 // to still be valid through the end of the transaction.
 317 char *get_url_param(struct http_transaction *h, char *requested_param) {
 318         struct keyval *kv;
 319         int i;
 320         for (i=0; i<array_len(h->request_parms); ++i) {
 321                 kv = array_get_element_at(h->request_parms, i);
 322                 if (!strcasecmp(kv->key, requested_param)) {
 323                         return (kv->val);
 324                 }
 325         }
 326         return (NULL);
 327 }