Make major improvements to redbean

- lua server pages
- lua http library
- http v0.9 support
- request uri parsing
- fork failure recovery
- accelerated redirects
- http pipelining support
- lenient message framing
- html / uri / js escaping
- fix shutdown signal handling

test/net/http/escapehtml_test.c

@@ -0,0 +1,41 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/gc.internal.h"
+#include "libc/testlib/testlib.h"
+#include "net/http/escape.h"
+
+char *escapehtml(const char *s) {
+  struct EscapeResult r;
+  r = EscapeHtml(s, strlen(s));
+  ASSERT_EQ(strlen(r.data), r.size);
+  return r.data;
+}
+
+TEST(escapehtml, test) {
+  EXPECT_STREQ("abc&<>"'\1\2",
+               gc(escapehtml("abc&<>\"'\1\2")));
+}
+
+TEST(escapehtml, testLargeGrowth) {
+  EXPECT_STREQ("&quot;&quot;&quot;", gc(escapehtml("\"\"\"")));
+}
+
+TEST(escapehtml, testEmpty) {
+  EXPECT_STREQ("", gc(escapehtml("")));
+}

test/net/http/parsecontentlength_test.c

@@ -0,0 +1,32 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/testlib/testlib.h"
+#include "net/http/http.h"
+
+TEST(ParseContentLength, test) {
+  EXPECT_EQ(-1, ParseContentLength("", 0));
+  EXPECT_EQ(-1, ParseContentLength("-1", 2));
+  EXPECT_EQ(-1, ParseContentLength("-2", 2));
+  EXPECT_EQ(0, ParseContentLength("0", 1));
+  EXPECT_EQ(1, ParseContentLength("1", 1));
+  EXPECT_EQ(0x7fffffff, ParseContentLength("2147483647", 10));
+  EXPECT_EQ(-1, ParseContentLength("2147483648", 10));
+  EXPECT_EQ(-1, ParseContentLength("9223372036854775808", 19));
+  EXPECT_EQ(-1, ParseContentLength("88223372036854775808", 20));
+}

test/net/http/parsehttprequest_test.c

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/bits/bits.h"
+#include "libc/errno.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/gc.internal.h"
 #include "libc/stdio/stdio.h"
@@ -24,6 +25,7 @@
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
 #include "net/http/http.h"
+#include "net/http/uri.h"
 
 struct HttpRequest req[1];
 
@@ -35,16 +37,23 @@ static char *slice(const char *m, struct HttpRequestSlice s) {
   return p;
 }
 
+static unsigned version(const char *m) {
+  return ParseHttpVersion(m + req->version.a, req->version.b - req->version.a);
+}
+
 TEST(ParseHttpRequest, testEmpty_tooShort) {
+  InitHttpRequest(req);
   EXPECT_EQ(0, ParseHttpRequest(req, "", 0));
 }
 
 TEST(ParseHttpRequest, testTooShort) {
+  InitHttpRequest(req);
   EXPECT_EQ(0, ParseHttpRequest(req, "\r\n", 2));
 }
 
 TEST(ParseHttpRequest, testNoHeaders) {
   static const char m[] = "GET /foo HTTP/1.0\r\n\r\n";
+  InitHttpRequest(req);
   EXPECT_EQ(strlen(m), ParseHttpRequest(req, m, strlen(m)));
   EXPECT_EQ(kHttpGet, req->method);
   EXPECT_STREQ("/foo", gc(slice(m, req->uri)));
@@ -57,6 +66,7 @@ POST /foo?bar%20hi HTTP/1.0\r\n\
 Host: foo.example\r\n\
 Content-Length: 0\r\n\
 \r\n";
+  InitHttpRequest(req);
   EXPECT_EQ(strlen(m), ParseHttpRequest(req, m, strlen(m)));
   EXPECT_EQ(kHttpPost, req->method);
   EXPECT_STREQ("/foo?bar%20hi", gc(slice(m, req->uri)));
@@ -65,3 +75,83 @@ Content-Length: 0\r\n\
   EXPECT_STREQ("0", gc(slice(m, req->headers[kHttpContentLength])));
   EXPECT_STREQ("", gc(slice(m, req->headers[kHttpEtag])));
 }
+
+TEST(ParseHttpRequest, testHttp101) {
+  static const char m[] = "GET / HTTP/1.1\r\n\r\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(strlen(m), ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_EQ(kHttpGet, req->method);
+  EXPECT_STREQ("/", gc(slice(m, req->uri)));
+  EXPECT_STREQ("HTTP/1.1", gc(slice(m, req->version)));
+  EXPECT_EQ(101, version(m));
+}
+
+TEST(ParseHttpRequest, testHttp100) {
+  static const char m[] = "GET / HTTP/1.0\r\n\r\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(strlen(m), ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_EQ(kHttpGet, req->method);
+  EXPECT_STREQ("/", gc(slice(m, req->uri)));
+  EXPECT_STREQ("HTTP/1.0", gc(slice(m, req->version)));
+  EXPECT_EQ(100, version(m));
+}
+
+TEST(ParseHttpRequest, testHttp009) {
+  static const char m[] = "GET /\r\n\r\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(strlen(m), ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_EQ(kHttpGet, req->method);
+  EXPECT_STREQ("/", gc(slice(m, req->uri)));
+  EXPECT_STREQ("", gc(slice(m, req->version)));
+  EXPECT_EQ(9, version(m));
+}
+
+TEST(ParseHttpRequest, testLeadingLineFeeds_areIgnored) {
+  static const char m[] = "\
+\r\n\
+GET /foo?bar%20hi HTTP/1.0\r\n\
+User-Agent: hi\r\n\
+\r\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(strlen(m), ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_STREQ("/foo?bar%20hi", gc(slice(m, req->uri)));
+}
+
+TEST(ParseHttpRequest, testLineFolding_isRejected) {
+  static const char m[] = "\
+GET /foo?bar%20hi HTTP/1.0\r\n\
+User-Agent: hi\r\n\
+ there\r\n\
+\r\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(-1, ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_EQ(EBADMSG, errno);
+}
+
+TEST(ParseHttpRequest, testEmptyHeaderName_isRejected) {
+  static const char m[] = "\
+GET /foo?bar%20hi HTTP/1.0\r\n\
+User-Agent: hi\r\n\
+: hi\r\n\
+\r\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(-1, ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_EQ(EBADMSG, errno);
+}
+
+TEST(ParseHttpRequest, testUnixNewlines) {
+  static const char m[] = "\
+POST /foo?bar%20hi HTTP/1.0\n\
+Host: foo.example\n\
+Content-Length: 0\n\
+\n\
+\n";
+  InitHttpRequest(req);
+  EXPECT_EQ(strlen(m) - 1, ParseHttpRequest(req, m, strlen(m)));
+  EXPECT_EQ(kHttpPost, req->method);
+  EXPECT_STREQ("/foo?bar%20hi", gc(slice(m, req->uri)));
+  EXPECT_STREQ("HTTP/1.0", gc(slice(m, req->version)));
+  EXPECT_STREQ("foo.example", gc(slice(m, req->headers[kHttpHost])));
+  EXPECT_STREQ("0", gc(slice(m, req->headers[kHttpContentLength])));
+  EXPECT_STREQ("", gc(slice(m, req->headers[kHttpEtag])));
+}