Make improvements

- Expand redbean UNIX module - Expand redbean documentation - Ensure Lua copyright is embedded in binary - Increase the PATH_MAX limit especially on NT - Use column major sorting for linenoise completions - Fix some suboptimalities in redbean's new UNIX API - Figured out right flags for Multics newline in raw mode
2025-08-05 09:20:29 +00:00 · 2022-04-24 09:59:22 -07:00 · 2022-04-24 09:59:22 -07:00 · 2046c0d2ae
commit 2046c0d2ae
parent cf3174dc74
305 changed files with 6602 additions and 4221 deletions
--- a/tool/net/lfuncs.c
+++ b/tool/net/lfuncs.c
@ -0,0 +1,562 @@
+/*-*- 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 2022 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 "dsp/scale/cdecimate2xuint8x8.h"
+#include "libc/bits/popcnt.h"
+#include "libc/log/check.h"
+#include "libc/log/log.h"
+#include "libc/macros.internal.h"
+#include "libc/mem/mem.h"
+#include "libc/nexgen32e/bsf.h"
+#include "libc/nexgen32e/bsr.h"
+#include "libc/nexgen32e/crc32.h"
+#include "libc/nexgen32e/rdtsc.h"
+#include "libc/nexgen32e/rdtscp.h"
+#include "libc/rand/rand.h"
+#include "libc/runtime/gc.internal.h"
+#include "libc/sock/sock.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/time/time.h"
+#include "libc/x/x.h"
+#include "net/http/escape.h"
+#include "net/http/http.h"
+#include "net/http/ip.h"
+#include "net/http/url.h"
+#include "third_party/lua/cosmo.h"
+#include "third_party/lua/lauxlib.h"
+#include "third_party/lua/lua.h"
+#include "third_party/mbedtls/md.h"
+#include "third_party/mbedtls/md5.h"
+#include "third_party/mbedtls/platform.h"
+#include "third_party/mbedtls/sha1.h"
+#include "third_party/mbedtls/sha256.h"
+#include "third_party/mbedtls/sha512.h"
+#include "tool/net/lfuncs.h"
+
+int LuaGetTime(lua_State *L) {
+  lua_pushnumber(L, nowl());
+  return 1;
+}
+
+int LuaSleep(lua_State *L) {
+  usleep(1e6 * luaL_checknumber(L, 1));
+  return 0;
+}
+
+int LuaRdtsc(lua_State *L) {
+  lua_pushinteger(L, rdtsc());
+  return 1;
+}
+
+int LuaGetCpuNode(lua_State *L) {
+  lua_pushinteger(L, TSC_AUX_NODE(rdpid()));
+  return 1;
+}
+
+int LuaGetCpuCore(lua_State *L) {
+  lua_pushinteger(L, TSC_AUX_CORE(rdpid()));
+  return 1;
+}
+
+int LuaGetLogLevel(lua_State *L) {
+  lua_pushinteger(L, __log_level);
+  return 1;
+}
+
+int LuaSetLogLevel(lua_State *L) {
+  __log_level = luaL_checkinteger(L, 1);
+  return 0;
+}
+
+static int LuaRand(lua_State *L, uint64_t impl(void)) {
+  lua_pushinteger(L, impl());
+  return 1;
+}
+
+int LuaLemur64(lua_State *L) {
+  return LuaRand(L, lemur64);
+}
+
+int LuaRand64(lua_State *L) {
+  return LuaRand(L, rand64);
+}
+
+int LuaRdrand(lua_State *L) {
+  return LuaRand(L, rdrand);
+}
+
+int LuaRdseed(lua_State *L) {
+  return LuaRand(L, rdseed);
+}
+
+int LuaDecimate(lua_State *L) {
+  size_t n, m;
+  const char *s;
+  unsigned char *p;
+  s = luaL_checklstring(L, 1, &n);
+  m = ROUNDUP(n, 16);
+  p = xmalloc(m);
+  bzero(p + n, m - n);
+  cDecimate2xUint8x8(m, p, (signed char[8]){-1, -3, 3, 17, 17, 3, -3, -1});
+  lua_pushlstring(L, (char *)p, (n + 1) >> 1);
+  free(p);
+  return 1;
+}
+
+int LuaMeasureEntropy(lua_State *L) {
+  size_t n;
+  const char *s;
+  s = luaL_checklstring(L, 1, &n);
+  lua_pushnumber(L, MeasureEntropy(s, n));
+  return 1;
+}
+
+int LuaGetHostOs(lua_State *L) {
+  const char *s = NULL;
+  if (IsLinux()) {
+    s = "LINUX";
+  } else if (IsMetal()) {
+    s = "METAL";
+  } else if (IsWindows()) {
+    s = "WINDOWS";
+  } else if (IsXnu()) {
+    s = "XNU";
+  } else if (IsOpenbsd()) {
+    s = "OPENBSD";
+  } else if (IsFreebsd()) {
+    s = "FREEBSD";
+  } else if (IsNetbsd()) {
+    s = "NETBSD";
+  }
+  if (s) {
+    lua_pushstring(L, s);
+  } else {
+    lua_pushnil(L);
+  }
+  return 1;
+}
+
+int LuaFormatIp(lua_State *L) {
+  char b[16];
+  uint32_t ip;
+  ip = htonl(luaL_checkinteger(L, 1));
+  inet_ntop(AF_INET, &ip, b, sizeof(b));
+  lua_pushstring(L, b);
+  return 1;
+}
+
+int LuaParseIp(lua_State *L) {
+  size_t n;
+  const char *s;
+  s = luaL_checklstring(L, 1, &n);
+  lua_pushinteger(L, ParseIp(s, n));
+  return 1;
+}
+
+static int LuaIsIp(lua_State *L, bool IsIp(uint32_t)) {
+  lua_pushboolean(L, IsIp(luaL_checkinteger(L, 1)));
+  return 1;
+}
+
+int LuaIsPublicIp(lua_State *L) {
+  return LuaIsIp(L, IsPublicIp);
+}
+
+int LuaIsPrivateIp(lua_State *L) {
+  return LuaIsIp(L, IsPrivateIp);
+}
+
+int LuaIsLoopbackIp(lua_State *L) {
+  return LuaIsIp(L, IsLoopbackIp);
+}
+
+int LuaCategorizeIp(lua_State *L) {
+  lua_pushstring(L, GetIpCategoryName(CategorizeIp(luaL_checkinteger(L, 1))));
+  return 1;
+}
+
+int LuaFormatHttpDateTime(lua_State *L) {
+  char buf[30];
+  lua_pushstring(L, FormatUnixHttpDateTime(buf, luaL_checkinteger(L, 1)));
+  return 1;
+}
+
+int LuaParseHttpDateTime(lua_State *L) {
+  size_t n;
+  const char *s;
+  s = luaL_checklstring(L, 1, &n);
+  lua_pushinteger(L, ParseHttpDateTime(s, n));
+  return 1;
+}
+
+int LuaParseParams(lua_State *L) {
+  void *m;
+  size_t size;
+  const char *data;
+  struct UrlParams h;
+  data = luaL_checklstring(L, 1, &size);
+  bzero(&h, sizeof(h));
+  m = ParseParams(data, size, &h);
+  LuaPushUrlParams(L, &h);
+  free(h.p);
+  free(m);
+  return 1;
+}
+
+int LuaParseHost(lua_State *L) {
+  void *m;
+  size_t n;
+  struct Url h;
+  const char *p;
+  bzero(&h, sizeof(h));
+  p = luaL_checklstring(L, 1, &n);
+  m = ParseHost(p, n, &h);
+  lua_newtable(L);
+  LuaPushUrlView(L, &h.host);
+  LuaPushUrlView(L, &h.port);
+  free(m);
+  return 1;
+}
+
+int LuaPopcnt(lua_State *L) {
+  lua_pushinteger(L, popcnt(luaL_checkinteger(L, 1)));
+  return 1;
+}
+
+int LuaBsr(lua_State *L) {
+  long x;
+  if ((x = luaL_checkinteger(L, 1))) {
+    lua_pushinteger(L, bsr(x));
+    return 1;
+  } else {
+    luaL_argerror(L, 1, "zero");
+    unreachable;
+  }
+}
+
+int LuaBsf(lua_State *L) {
+  long x;
+  if ((x = luaL_checkinteger(L, 1))) {
+    lua_pushinteger(L, bsf(x));
+    return 1;
+  } else {
+    luaL_argerror(L, 1, "zero");
+    unreachable;
+  }
+}
+
+static int LuaHash(lua_State *L, uint32_t H(uint32_t, const void *, size_t)) {
+  long i;
+  size_t n;
+  const char *p;
+  i = luaL_checkinteger(L, 1);
+  p = luaL_checklstring(L, 2, &n);
+  lua_pushinteger(L, H(i, p, n));
+  return 1;
+}
+
+int LuaCrc32(lua_State *L) {
+  return LuaHash(L, crc32_z);
+}
+
+int LuaCrc32c(lua_State *L) {
+  return LuaHash(L, crc32c);
+}
+
+int LuaIndentLines(lua_State *L) {
+  void *p;
+  size_t n, j;
+  p = luaL_checklstring(L, 1, &n);
+  j = luaL_optinteger(L, 2, 1);
+  if (!(0 <= j && j <= 65535)) {
+    luaL_argerror(L, 2, "not in range 0..65535");
+    unreachable;
+  }
+  p = IndentLines(p, n, &n, j);
+  lua_pushlstring(L, p, n);
+  free(p);
+  return 1;
+}
+
+int LuaGetMonospaceWidth(lua_State *L) {
+  int w;
+  if (lua_isinteger(L, 1)) {
+    w = wcwidth(lua_tointeger(L, 1));
+  } else if (lua_isstring(L, 1)) {
+    w = strwidth(luaL_checkstring(L, 1), luaL_optinteger(L, 2, 0) & 7);
+  } else {
+    luaL_argerror(L, 1, "not integer or string");
+    unreachable;
+  }
+  lua_pushinteger(L, w);
+  return 1;
+}
+
+int LuaSlurp(lua_State *L) {
+  char *p, *f;
+  size_t n;
+  f = luaL_checkstring(L, 1);
+  if ((p = xslurp(f, &n))) {
+    lua_pushlstring(L, p, n);
+    free(p);
+    return 1;
+  } else {
+    lua_pushnil(L);
+    lua_pushstring(L, gc(xasprintf("Can't slurp file %`'s: %m", f)));
+    return 2;
+  }
+}
+
+static int LuaCheckControlFlags(lua_State *L, int idx) {
+  int f = luaL_checkinteger(L, idx);
+  if (f & ~(kControlWs | kControlC0 | kControlC1)) {
+    luaL_argerror(L, idx, "invalid control flags");
+    unreachable;
+  }
+  return f;
+}
+
+int LuaHasControlCodes(lua_State *L) {
+  int f;
+  size_t n;
+  const char *p;
+  p = luaL_checklstring(L, 1, &n);
+  f = LuaCheckControlFlags(L, 2);
+  lua_pushboolean(L, HasControlCodes(p, n, f) != -1);
+  return 1;
+}
+
+int LuaEncodeLatin1(lua_State *L) {
+  int f;
+  char *p;
+  size_t n;
+  p = luaL_checklstring(L, 1, &n);
+  f = LuaCheckControlFlags(L, 2);
+  p = EncodeLatin1(p, n, &n, f);
+  lua_pushlstring(L, p, n);
+  free(p);
+  return 1;
+}
+
+int LuaGetRandomBytes(lua_State *L) {
+  char *p;
+  size_t n = luaL_optinteger(L, 1, 16);
+  if (!(n > 0 && n <= 256)) {
+    luaL_argerror(L, 1, "not in range 1..256");
+    unreachable;
+  }
+  p = malloc(n);
+  CHECK_EQ(n, getrandom(p, n, 0));
+  lua_pushlstring(L, p, n);
+  free(p);
+  return 1;
+}
+
+int LuaGetHttpReason(lua_State *L) {
+  lua_pushstring(L, GetHttpReason(luaL_checkinteger(L, 1)));
+  return 1;
+}
+
+int LuaGetCryptoHash(lua_State *L) {
+  size_t hl, pl, kl;
+  uint8_t d[64];
+  mbedtls_md_context_t ctx;
+  // get hash name, payload, and key
+  void *h = luaL_checklstring(L, 1, &hl);
+  void *p = luaL_checklstring(L, 2, &pl);
+  void *k = luaL_optlstring(L, 3, "", &kl);
+  const mbedtls_md_info_t *digest = mbedtls_md_info_from_string(h);
+  if (!digest) return luaL_argerror(L, 1, "unknown hash type");
+  if (kl == 0) {
+    // no key provided, run generic hash function
+    if ((digest->f_md)(p, pl, d)) return luaL_error(L, "bad input data");
+  } else if (mbedtls_md_hmac(digest, k, kl, p, pl, d)) {
+    return luaL_error(L, "bad input data");
+  }
+  lua_pushlstring(L, (void *)d, digest->size);
+  mbedtls_platform_zeroize(d, sizeof(d));
+  return 1;
+}
+
+static dontinline int LuaIsValid(lua_State *L, bool V(const char *, size_t)) {
+  size_t size;
+  const char *data;
+  data = luaL_checklstring(L, 1, &size);
+  lua_pushboolean(L, V(data, size));
+  return 1;
+}
+
+int LuaIsValidHttpToken(lua_State *L) {
+  return LuaIsValid(L, IsValidHttpToken);
+}
+
+int LuaIsAcceptablePath(lua_State *L) {
+  return LuaIsValid(L, IsAcceptablePath);
+}
+
+int LuaIsReasonablePath(lua_State *L) {
+  return LuaIsValid(L, IsReasonablePath);
+}
+
+int LuaIsAcceptableHost(lua_State *L) {
+  return LuaIsValid(L, IsAcceptableHost);
+}
+
+int LuaIsAcceptablePort(lua_State *L) {
+  return LuaIsValid(L, IsAcceptablePort);
+}
+
+static dontinline int LuaCoderImpl(lua_State *L,
+                                   char *C(const char *, size_t, size_t *)) {
+  void *p;
+  size_t n;
+  p = luaL_checklstring(L, 1, &n);
+  p = C(p, n, &n);
+  lua_pushlstring(L, p, n);
+  free(p);
+  return 1;
+}
+
+static dontinline int LuaCoder(lua_State *L,
+                               char *C(const char *, size_t, size_t *)) {
+  return LuaCoderImpl(L, C);
+}
+
+int LuaUnderlong(lua_State *L) {
+  return LuaCoder(L, Underlong);
+}
+
+int LuaEncodeBase64(lua_State *L) {
+  return LuaCoder(L, EncodeBase64);
+}
+
+int LuaDecodeBase64(lua_State *L) {
+  return LuaCoder(L, DecodeBase64);
+}
+
+int LuaDecodeLatin1(lua_State *L) {
+  return LuaCoder(L, DecodeLatin1);
+}
+
+int LuaEscapeHtml(lua_State *L) {
+  return LuaCoder(L, EscapeHtml);
+}
+
+int LuaEscapeParam(lua_State *L) {
+  return LuaCoder(L, EscapeParam);
+}
+
+int LuaEscapePath(lua_State *L) {
+  return LuaCoder(L, EscapePath);
+}
+
+int LuaEscapeHost(lua_State *L) {
+  return LuaCoder(L, EscapeHost);
+}
+
+int LuaEscapeIp(lua_State *L) {
+  return LuaCoder(L, EscapeIp);
+}
+
+int LuaEscapeUser(lua_State *L) {
+  return LuaCoder(L, EscapeUser);
+}
+
+int LuaEscapePass(lua_State *L) {
+  return LuaCoder(L, EscapePass);
+}
+
+int LuaEscapeSegment(lua_State *L) {
+  return LuaCoder(L, EscapeSegment);
+}
+
+int LuaEscapeFragment(lua_State *L) {
+  return LuaCoder(L, EscapeFragment);
+}
+
+int LuaEscapeLiteral(lua_State *L) {
+  return LuaCoder(L, EscapeJsStringLiteral);
+}
+
+int LuaVisualizeControlCodes(lua_State *L) {
+  return LuaCoder(L, VisualizeControlCodes);
+}
+
+static dontinline int LuaHasherImpl(lua_State *L, size_t k,
+                                    int H(const void *, size_t, uint8_t *)) {
+  void *p;
+  size_t n;
+  uint8_t d[64];
+  p = luaL_checklstring(L, 1, &n);
+  H(p, n, d);
+  lua_pushlstring(L, (void *)d, k);
+  mbedtls_platform_zeroize(d, sizeof(d));
+  return 1;
+}
+
+static dontinline int LuaHasher(lua_State *L, size_t k,
+                                int H(const void *, size_t, uint8_t *)) {
+  return LuaHasherImpl(L, k, H);
+}
+
+int LuaMd5(lua_State *L) {
+  return LuaHasher(L, 16, mbedtls_md5_ret);
+}
+
+int LuaSha1(lua_State *L) {
+  return LuaHasher(L, 20, mbedtls_sha1_ret);
+}
+
+int LuaSha224(lua_State *L) {
+  return LuaHasher(L, 28, mbedtls_sha256_ret_224);
+}
+
+int LuaSha256(lua_State *L) {
+  return LuaHasher(L, 32, mbedtls_sha256_ret_256);
+}
+
+int LuaSha384(lua_State *L) {
+  return LuaHasher(L, 48, mbedtls_sha512_ret_384);
+}
+
+int LuaSha512(lua_State *L) {
+  return LuaHasher(L, 64, mbedtls_sha512_ret_512);
+}
+
+int LuaIsHeaderRepeatable(lua_State *L) {
+  int h;
+  bool r;
+  size_t n;
+  const char *s;
+  s = luaL_checklstring(L, 1, &n);
+  if ((h = GetHttpHeader(s, n)) != -1) {
+    r = kHttpRepeatable[h];
+  } else {
+    r = false;
+  }
+  lua_pushboolean(L, r);
+  return 1;
+}
+
+void LuaPushUrlView(lua_State *L, struct UrlView *v) {
+  if (v->p) {
+    lua_pushlstring(L, v->p, v->n);
+  } else {
+    lua_pushnil(L);
+  }
+}