mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-01-31 03:27:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
cosmopolitan/tool/net/lfuncs.c
Justine Tunney 31194165d2
Remove .internal from more header filenames
2024-08-04 12:52:25 -07:00

1271 lines
32 KiB
C
Raw Blame History

/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et 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 "tool/net/lfuncs.h"
#include "dsp/scale/cdecimate2xuint8x8.h"
#include "libc/calls/calls.h"
#include "libc/calls/struct/rusage.h"
#include "libc/calls/struct/stat.h"
#include "libc/calls/struct/timespec.h"
#include "libc/errno.h"
#include "libc/fmt/itoa.h"
#include "libc/fmt/leb128.h"
#include "libc/intrin/bsf.h"
#include "libc/intrin/bsr.h"
#include "libc/intrin/popcnt.h"
#include "libc/log/check.h"
#include "libc/log/log.h"
#include "libc/macros.h"
#include "libc/math.h"
#include "libc/mem/gc.h"
#include "libc/mem/mem.h"
#include "libc/nexgen32e/bench.h"
#include "libc/nexgen32e/crc32.h"
#include "libc/nexgen32e/rdtsc.h"
#include "libc/nexgen32e/rdtscp.h"
#include "libc/runtime/runtime.h"
#include "libc/serialize.h"
#include "libc/sock/sock.h"
#include "libc/stdio/rand.h"
#include "libc/str/highwayhash64.h"
#include "libc/str/str.h"
#include "libc/str/strwidth.h"
#include "libc/str/tab.h"
#include "libc/sysv/consts/af.h"
#include "libc/sysv/consts/ipproto.h"
#include "libc/sysv/consts/o.h"
#include "libc/sysv/consts/rusage.h"
#include "libc/sysv/consts/sock.h"
#include "libc/thread/thread.h"
#include "libc/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/lua/luaconf.h"
#include "third_party/lua/lunix.h"
#include "third_party/mbedtls/everest.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 "third_party/musl/netdb.h"
#include "third_party/zlib/zlib.h"
static int Rdpid(void) {
#ifdef __x86_64__
return rdpid();
#else
return -1;
#endif
}
int LuaHex(lua_State *L) {
char b[19];
uint64_t x;
x = luaL_checkinteger(L, 1);
FormatHex64(b, x, true);
lua_pushstring(L, b);
return 1;
}
int LuaOct(lua_State *L) {
char b[24];
uint64_t x;
x = luaL_checkinteger(L, 1);
FormatOctal64(b, x, true);
lua_pushstring(L, b);
return 1;
}
int LuaBin(lua_State *L) {
char b[67];
uint64_t x;
x = luaL_checkinteger(L, 1);
FormatBinary64(b, x, 2);
lua_pushstring(L, b);
return 1;
}
int LuaGetTime(lua_State *L) {
struct timespec now = timespec_real();
lua_pushnumber(L, now.tv_sec + now.tv_nsec * 1e-9);
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 LuaGetCpuCount(lua_State *L) {
lua_pushinteger(L, __get_cpu_count());
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) {
char *p;
size_t n, m;
const char *s;
luaL_Buffer buf;
s = luaL_checklstring(L, 1, &n);
m = ROUNDUP(n, 16);
p = luaL_buffinitsize(L, &buf, m);
memcpy(p, s, n);
bzero(p + n, m - n);
cDecimate2xUint8x8(m, (unsigned char *)p,
(signed char[8]){-1, -3, 3, 17, 17, 3, -3, -1});
luaL_pushresultsize(&buf, (n + 1) >> 1);
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 LuaGetHostIsa(lua_State *L) {
const char *s;
#ifdef __x86_64__
s = "X86_64";
#elif defined(__aarch64__)
s = "AARCH64";
#elif defined(__powerpc64__)
s = "POWERPC64";
#elif defined(__s390x__)
s = "S390X";
#else
#error "unsupported architecture"
#endif
lua_pushstring(L, s);
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;
if (!lua_isnoneornil(L, 1)) {
data = luaL_checklstring(L, 1, &size);
bzero(&h, sizeof(h));
if ((m = ParseParams(data, size, &h))) {
LuaPushUrlParams(L, &h);
free(h.p);
free(m);
return 1;
} else {
luaL_error(L, "out of memory");
__builtin_unreachable();
}
} else {
return lua_gettop(L);
}
}
int LuaParseHost(lua_State *L) {
void *m;
size_t n;
struct Url h;
const char *p;
if (!lua_isnoneornil(L, 1)) {
bzero(&h, sizeof(h));
p = luaL_checklstring(L, 1, &n);
if ((m = ParseHost(p, n, &h))) {
lua_newtable(L);
LuaPushUrlView(L, &h.host);
LuaPushUrlView(L, &h.port);
free(m);
return 1;
} else {
luaL_error(L, "out of memory");
__builtin_unreachable();
}
} else {
return lua_gettop(L);
}
}
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, bsrl(x));
return 1;
} else {
luaL_argerror(L, 1, "zero");
__builtin_unreachable();
}
}
int LuaBsf(lua_State *L) {
long x;
if ((x = luaL_checkinteger(L, 1))) {
lua_pushinteger(L, bsfl(x));
return 1;
} else {
luaL_argerror(L, 1, "zero");
__builtin_unreachable();
}
}
int LuaHighwayHash64(lua_State *L) {
size_t n;
uint64_t k[4];
const char *p;
p = luaL_checklstring(L, 1, &n);
k[0] = luaL_optinteger(L, 2, 0);
k[1] = luaL_optinteger(L, 3, 0);
k[2] = luaL_optinteger(L, 4, 0);
k[3] = luaL_optinteger(L, 5, 0);
lua_pushinteger(L, HighwayHash64(p, n, k));
return 1;
}
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) {
size_t n, j;
const void *p;
if (!lua_isnoneornil(L, 1)) {
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");
__builtin_unreachable();
}
char *q = IndentLines(p, n, &n, j);
lua_pushlstring(L, q, n);
free(q);
return 1;
} else {
return lua_gettop(L);
}
}
int LuaGetMonospaceWidth(lua_State *L) {
int w;
if (lua_isnumber(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");
__builtin_unreachable();
}
lua_pushinteger(L, w);
return 1;
}
// Slurp(path:str[, i:int[, j:int]])
// ├─→ data:str
// └─→ nil, unix.Errno
int LuaSlurp(lua_State *L) {
ssize_t rc;
char tb[2048];
luaL_Buffer b;
struct stat st;
int fd, olderr;
bool shouldpread;
lua_Integer i, j, got;
olderr = errno;
if (lua_isnoneornil(L, 2)) {
i = 1;
} else {
i = luaL_checkinteger(L, 2);
}
if (lua_isnoneornil(L, 3)) {
j = LUA_MAXINTEGER;
} else {
j = luaL_checkinteger(L, 3);
}
luaL_buffinit(L, &b);
if ((fd = open(luaL_checkstring(L, 1), O_RDONLY | O_SEQUENTIAL)) == -1) {
return LuaUnixSysretErrno(L, "open", olderr);
}
if (i < 0 || j < 0) {
if (fstat(fd, &st) == -1) {
close(fd);
return LuaUnixSysretErrno(L, "fstat", olderr);
}
if (i < 0) {
i = st.st_size + (i + 1);
}
if (j < 0) {
j = st.st_size + (j + 1);
}
}
if (i < 1) {
i = 1;
}
shouldpread = i > 1;
for (; i <= j; i += got) {
if (shouldpread) {
rc = pread(fd, tb, MIN(j - i + 1, sizeof(tb)), i - 1);
} else {
rc = read(fd, tb, MIN(j - i + 1, sizeof(tb)));
}
if (rc != -1) {
got = rc;
if (!got)
break;
luaL_addlstring(&b, tb, got);
} else if (errno == EINTR) {
errno = olderr;
got = 0;
} else {
close(fd);
return LuaUnixSysretErrno(L, "read", olderr);
}
}
if (close(fd) == -1) {
return LuaUnixSysretErrno(L, "close", olderr);
}
luaL_pushresult(&b);
return 1;
}
// Barf(path:str, data:str[, mode:int[, flags:int[, offset:int]]])
// ├─→ true
// └─→ nil, unix.Errno
int LuaBarf(lua_State *L) {
ssize_t rc;
const char *data;
lua_Number offset;
size_t i, n, wrote;
int fd, mode, flags, olderr;
olderr = errno;
data = luaL_checklstring(L, 2, &n);
if (lua_isnoneornil(L, 5)) {
offset = 0;
} else {
offset = luaL_checkinteger(L, 5);
if (offset < 1) {
luaL_error(L, "offset must be >= 1");
__builtin_unreachable();
}
--offset;
}
mode = luaL_optinteger(L, 3, 0644);
flags = O_WRONLY | O_SEQUENTIAL | luaL_optinteger(L, 4, O_TRUNC | O_CREAT);
if (flags & O_NONBLOCK) {
luaL_error(L, "O_NONBLOCK not allowed");
__builtin_unreachable();
}
if ((flags & O_APPEND) && offset) {
luaL_error(L, "O_APPEND with offset not possible");
__builtin_unreachable();
}
if ((fd = open(luaL_checkstring(L, 1), flags, mode)) == -1) {
return LuaUnixSysretErrno(L, "open", olderr);
}
for (i = 0; i < n; i += wrote) {
if (offset) {
rc = pwrite(fd, data + i, n - i, offset + i);
} else {
rc = write(fd, data + i, n - i);
}
if (rc != -1) {
wrote = rc;
} else if (errno == EINTR) {
errno = olderr;
wrote = 0;
} else {
close(fd);
return LuaUnixSysretErrno(L, "write", olderr);
}
}
if (close(fd) == -1) {
return LuaUnixSysretErrno(L, "close", olderr);
}
lua_pushboolean(L, true);
return 1;
}
int LuaResolveIp(lua_State *L) {
ssize_t rc;
int64_t ip;
const char *host;
struct addrinfo *ai = NULL;
struct addrinfo hint = {AI_NUMERICSERV, AF_INET, SOCK_STREAM, IPPROTO_TCP};
host = luaL_checkstring(L, 1);
if ((ip = ParseIp(host, -1)) != -1) {
lua_pushinteger(L, ip);
return 1;
} else if ((rc = getaddrinfo(host, "0", &hint, &ai)) == 0) {
lua_pushinteger(
L, ntohl(((struct sockaddr_in *)ai->ai_addr)->sin_addr.s_addr));
freeaddrinfo(ai);
return 1;
} else {
lua_pushnil(L);
lua_pushfstring(L, "%s: DNS lookup failed: EAI_%s", host, gai_strerror(rc));
return 2;
}
}
static int LuaCheckControlFlags(lua_State *L, int idx) {
int f = luaL_optinteger(L, idx, 0);
if (f & ~(kControlWs | kControlC0 | kControlC1)) {
luaL_argerror(L, idx, "invalid control flags");
__builtin_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 *q;
size_t n;
const char *p;
p = luaL_checklstring(L, 1, &n);
f = LuaCheckControlFlags(L, 2);
if ((q = EncodeLatin1(p, n, &n, f))) {
lua_pushlstring(L, q, n);
free(q);
return 1;
} else {
luaL_error(L, "out of memory");
__builtin_unreachable();
}
}
dontinline int LuaBase32Impl(lua_State *L,
char *B32(const char *, size_t, const char *,
size_t, size_t *)) {
char *p;
size_t sl, al; // source/output and alphabet lengths
const char *s = luaL_checklstring(L, 1, &sl);
// use an empty string, as EncodeBase32 provides a default value
const char *a = luaL_optlstring(L, 2, "", &al);
if (!IS2POW(al) || al > 128 || al == 1)
return luaL_error(L, "alphabet length is not a power of 2 in range 2..128");
if (!(p = B32(s, sl, a, al, &sl)))
return luaL_error(L, "out of memory");
lua_pushlstring(L, p, sl);
free(p);
return 1;
}
int LuaEncodeBase32(lua_State *L) {
return LuaBase32Impl(L, EncodeBase32);
}
int LuaDecodeBase32(lua_State *L) {
return LuaBase32Impl(L, DecodeBase32);
}
int LuaEncodeHex(lua_State *L) {
char *p;
size_t n;
const char *s;
luaL_Buffer buf;
s = luaL_checklstring(L, 1, &n);
p = luaL_buffinitsize(L, &buf, n * 2 + 1);
hexpcpy(p, s, n);
luaL_pushresultsize(&buf, n * 2);
return 1;
}
int LuaDecodeHex(lua_State *L) {
char *p;
int x, y;
size_t i, n;
const char *s;
luaL_Buffer buf;
s = luaL_checklstring(L, 1, &n);
if (n & 1) {
luaL_argerror(L, 1, "hex string length uneven");
__builtin_unreachable();
}
p = luaL_buffinitsize(L, &buf, n >> 1);
for (i = 0; i < n; i += 2) {
if ((x = kHexToInt[s[i + 0] & 255]) == -1 ||
(y = kHexToInt[s[i + 1] & 255]) == -1) {
luaL_argerror(L, 1, "hex string has non-hex character");
__builtin_unreachable();
}
p[i >> 1] = x << 4 | y;
}
luaL_pushresultsize(&buf, n >> 1);
return 1;
}
int LuaGetRandomBytes(lua_State *L) {
size_t n;
luaL_Buffer buf;
n = luaL_optinteger(L, 1, 16);
if (!(n > 0 && n <= 256)) {
luaL_argerror(L, 1, "not in range 1..256");
__builtin_unreachable();
}
CHECK_EQ(n, getrandom(luaL_buffinitsize(L, &buf, n), n, 0));
luaL_pushresultsize(&buf, n);
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];
// get hash name, payload, and key
const void *h = luaL_checklstring(L, 1, &hl);
const void *p = luaL_checklstring(L, 2, &pl);
const 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 *q;
size_t n;
const void *p;
if (!lua_isnoneornil(L, 1)) {
p = luaL_checklstring(L, 1, &n);
if ((q = C(p, n, &n))) {
lua_pushlstring(L, q, n);
free(q);
} else {
luaL_error(L, "out of memory");
__builtin_unreachable();
}
return 1;
} else {
return lua_gettop(L);
}
}
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) {
const char *p;
char *z, *q = 0;
size_t n, y = 0;
p = luaL_checklstring(L, 1, &n);
if ((z = EscapeJsStringLiteral(&q, &y, p, n, &n))) {
lua_pushlstring(L, z, n);
free(z);
return 1;
} else {
luaL_error(L, "out of memory");
__builtin_unreachable();
}
}
int LuaVisualizeControlCodes(lua_State *L) {
return LuaCoder(L, VisualizeControlCodes);
}
int LuaUuidV4(lua_State *L) {
static const char v[] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
char uuid_str[37] = {0};
uint64_t r = _rand64();
int j = 0;
for (int i = 0; i < 36; ++i, ++j) {
if (j == 16) {
r = _rand64();
j = 0;
}
uuid_str[i] = v[(r & (0xfull << (j * 4ull))) >> (j * 4ull)];
}
uuid_str[8] = '-';
uuid_str[13] = '-';
uuid_str[14] = '4';
uuid_str[18] = '-';
uuid_str[19] = v[8 | (r & (0x3ull << (j * 4ull))) >> (j * 4ull)];
uuid_str[23] = '-';
uuid_str[36] = '\0';
lua_pushfstring(L, uuid_str);
return 1;
}
int LuaUuidV7(lua_State *L) {
//See https://www.rfc-editor.org/rfc/rfc9562.html
char bin[16], uuid_str[37];
struct timespec ts = timespec_real();
uint64_t unix_ts_ms = (uint64_t)((ts.tv_sec * 1000) + (ts.tv_nsec / 1000000));
int fractional_ms = (int)floor((double)((double)(ts.tv_nsec - (ts.tv_nsec / 1000000) * 1000000)/1000000) * 4096) <<4;
uint64_t rand_b = _rand64();
int rand_a = fractional_ms | (rand_b & 0x000000000000000f); //use the last 4 bits of rand_b
bin[0] = unix_ts_ms >> 050;
bin[1] = unix_ts_ms >> 040;
bin[2] = unix_ts_ms >> 030;
bin[3] = unix_ts_ms >> 020;
bin[4] = unix_ts_ms >> 010;
bin[5] = unix_ts_ms >> 000;
bin[6] = rand_a >> 010;
bin[7] = rand_a >> 000;
bin[8] = rand_b >> 070;
bin[9] = rand_b >> 060;
bin[10] = rand_b >> 050;
bin[11] = rand_b >> 040;
bin[12] = rand_b >> 030;
bin[13] = rand_b >> 020;
bin[14] = rand_b >> 010;
bin[15] = rand_b >> 000;
uuid_str[0] = "0123456789abcdef"[(bin[0] & 0xf0) >>4];
uuid_str[1] = "0123456789abcdef"[(bin[0] & 0x0f)];
uuid_str[2] = "0123456789abcdef"[(bin[1] & 0xf0) >>4];
uuid_str[3] = "0123456789abcdef"[(bin[1] & 0x0f)];
uuid_str[4] = "0123456789abcdef"[(bin[2] & 0xf0) >>4];
uuid_str[5] = "0123456789abcdef"[(bin[2] & 0x0f)];
uuid_str[6] = "0123456789abcdef"[(bin[3] & 0xf0) >>4];
uuid_str[7] = "0123456789abcdef"[(bin[3] & 0x0f)];
uuid_str[8] = '-';
uuid_str[9] = "0123456789abcdef"[(bin[4] & 0xf0) >>4];
uuid_str[10] = "0123456789abcdef"[(bin[4] & 0x0f)];
uuid_str[11] = "0123456789abcdef"[(bin[5] & 0xf0) >>4];
uuid_str[12] = "0123456789abcdef"[(bin[5] & 0x0f)];
uuid_str[13] = '-';
uuid_str[14] = '7';
uuid_str[15] = "0123456789abcdef"[(bin[6] & 0xf0) >>4];
uuid_str[16] = "0123456789abcdef"[(bin[6] & 0x0f)];
uuid_str[17] = "0123456789abcdef"[(bin[7] & 0xf0) >>4];
uuid_str[18] = '-';
uuid_str[19] = "0123456789abcdef"[(0x8 | ((bin[7] & 0x0f) >>2))];
uuid_str[20] = "0123456789abcdef"[(bin[7] & 0x03) | (bin[8] & 0xf0) >>6]; //See https://www.rfc-editor.org/rfc/rfc9562.html#version_field
uuid_str[21] = "0123456789abcdef"[(bin[8] & 0x0f)];
uuid_str[22] = "0123456789abcdef"[(bin[9] & 0xf0) >>4];
uuid_str[23] = '-';
uuid_str[24] = "0123456789abcdef"[(bin[9] & 0x0f)];
uuid_str[25] = "0123456789abcdef"[(bin[10] & 0xf0) >>4];
uuid_str[26] = "0123456789abcdef"[(bin[10] & 0x0f)];
uuid_str[27] = "0123456789abcdef"[(bin[11] & 0xf0) >>4];
uuid_str[28] = "0123456789abcdef"[(bin[11] & 0x0f)];
uuid_str[29] = "0123456789abcdef"[(bin[12] & 0xf0) >>4];
uuid_str[30] = "0123456789abcdef"[(bin[12] & 0x0f)];
uuid_str[31] = "0123456789abcdef"[(bin[13] & 0xf0) >>4];
uuid_str[32] = "0123456789abcdef"[(bin[13] & 0x0f)];
uuid_str[33] = "0123456789abcdef"[(bin[14] & 0xf0) >>4];
uuid_str[34] = "0123456789abcdef"[(bin[14] & 0x0f)];
uuid_str[35] = "0123456789abcdef"[(bin[15] & 0xf0) >>4];
uuid_str[36] = '\0';
lua_pushfstring(L, uuid_str);
return 1;
}
static dontinline int LuaHasherImpl(lua_State *L, size_t k,
int H(const void *, size_t, uint8_t *)) {
size_t n;
uint8_t d[64];
const void *p;
if (!lua_isnoneornil(L, 1)) {
p = luaL_checklstring(L, 1, &n);
H(p, n, d);
lua_pushlstring(L, (void *)d, k);
mbedtls_platform_zeroize(d, sizeof(d));
return 1;
} else {
return lua_gettop(L);
}
}
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);
}
}
static int64_t GetInterrupts(void) {
struct rusage ru;
if (!getrusage(RUSAGE_SELF, &ru)) {
return ru.ru_nivcsw;
} else {
return 0;
}
}
static int DoNothing(lua_State *L) {
return 0;
}
int LuaBenchmark(lua_State *L) {
uint64_t t1, t2;
int64_t interrupts;
double avgticks, overhead;
int core, iter, count, attempts, maxattempts;
luaL_checktype(L, 1, LUA_TFUNCTION);
count = luaL_optinteger(L, 2, 100);
maxattempts = luaL_optinteger(L, 3, 10);
__warn_if_powersave();
lua_gc(L, LUA_GCSTOP);
for (attempts = 0;;) {
lua_gc(L, LUA_GCCOLLECT);
pthread_yield();
core = TSC_AUX_CORE(Rdpid());
interrupts = GetInterrupts();
for (avgticks = iter = 1; iter < count; ++iter) {
lua_pushcfunction(L, DoNothing);
t1 = __startbench_m();
lua_call(L, 0, 0);
t2 = __endbench_m();
avgticks += 1. / iter * ((int)(t2 - t1) - avgticks);
}
++attempts;
if (TSC_AUX_CORE(Rdpid()) == core && GetInterrupts() == interrupts) {
break;
} else if (attempts >= maxattempts) {
luaL_error(L, "system is under too much load to run benchmark");
__builtin_unreachable();
}
}
overhead = avgticks;
for (attempts = 0;;) {
lua_gc(L, LUA_GCCOLLECT);
pthread_yield();
core = TSC_AUX_CORE(Rdpid());
interrupts = GetInterrupts();
for (avgticks = iter = 1; iter < count; ++iter) {
lua_pushvalue(L, 1);
t1 = __startbench_m();
lua_call(L, 0, 0);
t2 = __endbench_m();
avgticks += 1. / iter * ((int)(t2 - t1) - avgticks);
}
++attempts;
if (TSC_AUX_CORE(Rdpid()) == core && GetInterrupts() == interrupts) {
break;
} else if (attempts >= maxattempts) {
luaL_error(L, "system is under too much load to run benchmark");
__builtin_unreachable();
}
}
avgticks = MAX(avgticks - overhead, 0);
lua_gc(L, LUA_GCRESTART);
lua_pushinteger(L, avgticks / 3);
lua_pushinteger(L, round(avgticks));
lua_pushinteger(L, round(overhead));
lua_pushinteger(L, attempts);
return 4;
}
static void LuaCompress2(lua_State *L, void *dest, size_t *destLen,
const void *source, size_t sourceLen, int level) {
switch (compress2(dest, destLen, source, sourceLen, level)) {
case Z_OK:
break;
case Z_BUF_ERROR:
luaL_error(L, "out of memory");
__builtin_unreachable();
case Z_STREAM_ERROR:
luaL_error(L, "invalid level");
__builtin_unreachable();
default:
__builtin_unreachable();
}
}
// VERY DEPRECATED - PLEASE DO NOT USE
int LuaCompress(lua_State *L) {
size_t n, m;
char *q, *e;
uint32_t crc;
const char *p;
luaL_Buffer buf;
int level, hdrlen;
p = luaL_checklstring(L, 1, &n);
level = luaL_optinteger(L, 2, Z_DEFAULT_COMPRESSION);
m = compressBound(n);
if (lua_toboolean(L, 3)) {
// raw mode
q = luaL_buffinitsize(L, &buf, m);
LuaCompress2(L, q, &m, p, n, level);
} else {
// easy mode
q = luaL_buffinitsize(L, &buf, 10 + 4 + m);
crc = crc32_z(0, p, n);
e = uleb64(q, n);
e = WRITE32LE(e, crc);
hdrlen = e - q;
LuaCompress2(L, q + hdrlen, &m, p, n, level);
m += hdrlen;
}
luaL_pushresultsize(&buf, m);
return 1;
}
// VERY DEPRECATED - PLEASE DO NOT USE
int LuaUncompress(lua_State *L) {
int rc;
char *q;
uint32_t crc;
const char *p;
luaL_Buffer buf;
size_t n, m, len;
p = luaL_checklstring(L, 1, &n);
if (lua_isnoneornil(L, 2)) {
if ((rc = unuleb64(p, n, &m)) == -1 || n < rc + 4) {
luaL_error(L, "compressed value too short to be valid");
__builtin_unreachable();
}
len = m;
crc = READ32LE(p + rc);
q = luaL_buffinitsize(L, &buf, m);
if (uncompress((void *)q, &m, (unsigned char *)p + rc + 4, n) != Z_OK ||
m != len || crc32_z(0, q, m) != crc) {
luaL_error(L, "compressed value is corrupted");
__builtin_unreachable();
}
} else {
len = m = luaL_checkinteger(L, 2);
q = luaL_buffinitsize(L, &buf, m);
if (uncompress((void *)q, &m, (void *)p, n) != Z_OK || m != len) {
luaL_error(L, "compressed value is corrupted");
__builtin_unreachable();
}
}
luaL_pushresultsize(&buf, m);
return 1;
}
// unix.deflate(uncompressed:str[, level:int])
// ├─→ compressed:str
// └─→ nil, error:str
int LuaDeflate(lua_State *L) {
char *out;
z_stream zs;
int rc, level;
const char *in;
luaL_Buffer buf;
size_t insize, outsize, actualoutsize;
in = luaL_checklstring(L, 1, &insize);
level = luaL_optinteger(L, 2, Z_DEFAULT_COMPRESSION);
outsize = compressBound(insize);
out = luaL_buffinitsize(L, &buf, outsize);
zs.next_in = (const uint8_t *)in;
zs.avail_in = insize;
zs.next_out = (uint8_t *)out;
zs.avail_out = outsize;
zs.zalloc = Z_NULL;
zs.zfree = Z_NULL;
if ((rc = deflateInit2(&zs, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL,
Z_DEFAULT_STRATEGY)) != Z_OK) {
lua_pushnil(L);
lua_pushfstring(L, "%s() failed: %d", "deflateInit2", rc);
return 2;
}
rc = deflate(&zs, Z_FINISH);
actualoutsize = outsize - zs.avail_out;
deflateEnd(&zs);
if (rc != Z_STREAM_END) {
lua_pushnil(L);
lua_pushfstring(L, "%s() failed: %d", "deflate", rc);
return 2;
}
luaL_pushresultsize(&buf, actualoutsize);
return 1;
}
// unix.inflate(compressed:str, maxoutsize:int)
// ├─→ uncompressed:str
// └─→ nil, error:str
int LuaInflate(lua_State *L) {
int rc;
char *out;
z_stream zs;
const char *in;
luaL_Buffer buf;
size_t insize, outsize, actualoutsize;
in = luaL_checklstring(L, 1, &insize);
outsize = luaL_checkinteger(L, 2);
out = luaL_buffinitsize(L, &buf, outsize);
zs.next_in = (const uint8_t *)in;
zs.avail_in = insize;
zs.total_in = insize;
zs.next_out = (uint8_t *)out;
zs.avail_out = outsize;
zs.total_out = outsize;
zs.zalloc = Z_NULL;
zs.zfree = Z_NULL;
if ((rc = inflateInit2(&zs, -MAX_WBITS)) != Z_OK) {
lua_pushnil(L);
lua_pushfstring(L, "%s() failed: %d", "inflateInit2", rc);
return 2;
}
rc = inflate(&zs, Z_FINISH);
actualoutsize = outsize - zs.avail_out;
inflateEnd(&zs);
if (rc != Z_STREAM_END) {
lua_pushnil(L);
lua_pushfstring(L, "%s() failed: %d", "inflate", rc);
return 2;
}
luaL_pushresultsize(&buf, actualoutsize);
return 1;
}
static void GetCurve25519Arg(lua_State *L, int arg, uint8_t buf[static 32]) {
size_t len;
const char *val;
val = luaL_checklstring(L, arg, &len);
bzero(buf, 32);
if (len) {
if (len > 32) {
len = 32;
}
memcpy(buf, val, len);
}
}
/*
* Example usage:
*
* >: secret1 = "\1"
* >: secret2 = "\2"
* >: public1 = Curve25519(secret1, "\9")
* >: public2 = Curve25519(secret2, "\9")
* >: Curve25519(secret1, public2)
* "\x93\xfe\xa2\xa7\xc1\xae\xb6,\xfddR\xff...
* >: Curve25519(secret2, public1)
* "\x93\xfe\xa2\xa7\xc1\xae\xb6,\xfddR\xff...
*
*/
int LuaCurve25519(lua_State *L) {
uint8_t mypublic[32], secret[32], basepoint[32];
GetCurve25519Arg(L, 1, secret);
GetCurve25519Arg(L, 2, basepoint);
curve25519(mypublic, secret, basepoint);
lua_pushlstring(L, (const char *)mypublic, 32);
return 1;
}
Reference in a new issue View git blame Copy permalink