snxraven/bare-operating-system
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
3b0ada9a07aee0e0996e99c5352dbd79a9a9cdbc
bare-operating-system/kernel/lib/bare/bundles/bareHttpParser.js
T
Raven Scott 9bdecc4170
Release rolling / release (push) Successful in 11m16s
Details
Sync Holepunch modules to current clone/npm latest 
Bump published pins (compact-encoding 3, bare-fetch/tls/https/ws 3,
bare-subprocess 6, bare-signals 5, corestore 7.12, protomux 3.11,
hypercore-crypto 3.7, bare-runtime 1.31) and regenerate catalogs,
manifests, and kernel/seeder bundles.

Adapt call sites to the new APIs:
- Corestore: explicit session flush before suspend(); treeCache ctor opts
- bare-crypto: KeyObject.export() instead of removed ._key
- Protomux 3.11: wait for fullyOpened()/fullyClosed() on chat channels
- bare-fetch: surface response.type and Headers.getSetCookie
- host snapshots: bare-os 3.9 / bare-posix / bare-fs.statfs frsize
- bare-subprocess 6: optional IPC channel + json serialization

Keep catalog sync from wiping curated pearEntries. Teach the Node test
shim to stub bare-thread/bare-worker (ESM absolute paths) and chain
Bare.on so bare-timers can load. Booter 479, protocol 34, seeder 14.
2026-08-12 20:56:28 -04:00

722 lines
25 KiB
JavaScript
Raw Blame History

var __bare_os_bundle_exports__ = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// ../../node_modules/bare-http-parser/lib/errors.js
var require_errors = __commonJS({
"../../node_modules/bare-http-parser/lib/errors.js"(exports, module) {
module.exports = class HTTPParserError extends Error {
constructor(msg, fn = HTTPParserError, code = fn.name) {
super(`${code}: ${msg}`);
this.code = code;
if (Error.captureStackTrace) Error.captureStackTrace(this, fn);
}
get name() {
return "HTTPParserError";
}
static INVALID_MESSAGE(msg = "Invalid HTTP message") {
return new HTTPParserError(msg, HTTPParserError.INVALID_MESSAGE);
}
static INVALID_HEADER(msg = "Invalid HTTP header") {
return new HTTPParserError(msg, HTTPParserError.INVALID_HEADER);
}
static INVALID_CONTENT_LENGTH(msg = "Invalid HTTP Content-Length") {
return new HTTPParserError(msg, HTTPParserError.INVALID_CONTENT_LENGTH);
}
static INVALID_CHUNK_LENGTH(msg = "Invalid HTTP chunk length") {
return new HTTPParserError(msg, HTTPParserError.INVALID_CHUNK_LENGTH);
}
};
}
});
// ../../node_modules/bare-http-parser/index.js
var require_bare_http_parser = __commonJS({
"../../node_modules/bare-http-parser/index.js"(exports, module) {
var errors = require_errors();
var constants = {
REQUEST: 1,
RESPONSE: 2,
DATA: 3,
END: 4
};
var TAB = 9;
var LF = 10;
var CR = 13;
var SP = 32;
var ZERO = 48;
var NINE = 57;
var UPPER_A = 65;
var UPPER_F = 70;
var UPPER_Z = 90;
var LOWER_A = 97;
var LOWER_F = 102;
var COLON = 58;
var MAX_CHUNK_SIZE_LENGTH = 16;
var FIRST_TOKEN = 0;
var REQUEST_URL = 1;
var REQUEST_VERSION = 2;
var STATUS_CODE = 3;
var STATUS_REASON = 4;
var FIRST_LINE_LF = 5;
var HEADER_START = 6;
var HEADER_NAME = 7;
var HEADER_VALUE_WS = 8;
var HEADER_VALUE = 9;
var HEADER_LINE_LF = 10;
var HEADER_END_LF = 11;
var BODY = 12;
var CHUNK_SIZE = 13;
var CHUNK_SIZE_LF = 14;
var CHUNK_DATA = 15;
var CHUNK_EXTENSION = 16;
var LAST_CHUNK_LF = 17;
var TRAILER_CR = 18;
var TRAILER_LF = 19;
module.exports = exports = class HTTPParser {
constructor(opts = {}) {
const { maxHeaderSize = 16384, maxHeadersCount = 2e3 } = opts;
this._maxHeaderSize = maxHeaderSize;
this._maxHeadersCount = maxHeadersCount;
this._state = FIRST_TOKEN;
this._buffer = [];
this._bufferIndex = 0;
this._byteIndex = 0;
this._buffered = 0;
this._accumulator = [];
this._isResponse = false;
this._method = "";
this._url = "";
this._version = "";
this._code = 0;
this._reason = "";
this._headerName = "";
this._headers = /* @__PURE__ */ Object.create(null);
this._headerCount = 0;
this._headerSize = 0;
this._remaining = 0;
}
*push(data, encoding) {
if (typeof data === "string") data = Buffer.from(data, encoding);
this._buffer.push(data);
this._buffered += data.byteLength;
yield* this._parse();
this._compact();
}
end() {
const buffers = this._buffer;
const bufferIndex = this._bufferIndex;
const byteIndex = this._byteIndex;
this._buffer = [];
this._bufferIndex = 0;
this._byteIndex = 0;
this._buffered = 0;
if (bufferIndex >= buffers.length) return Buffer.alloc(0);
buffers[bufferIndex] = buffers[bufferIndex].subarray(byteIndex);
const remaining = buffers.slice(bufferIndex);
if (remaining.length === 0) return Buffer.alloc(0);
if (remaining.length === 1) return remaining[0];
return Buffer.concat(remaining);
}
_compact() {
if (this._bufferIndex > 0) {
this._buffer = this._buffer.slice(this._bufferIndex);
this._bufferIndex = 0;
}
if (this._byteIndex > 0 && this._buffer.length > 0) {
this._buffer[0] = this._buffer[0].subarray(this._byteIndex);
this._byteIndex = 0;
}
}
_consume(n) {
this._buffered -= n;
const current = this._buffer[this._bufferIndex];
if (this._byteIndex + n <= current.byteLength) {
const slice = current.subarray(this._byteIndex, this._byteIndex + n);
this._byteIndex += n;
if (this._byteIndex >= current.byteLength) {
this._bufferIndex++;
this._byteIndex = 0;
}
return slice;
}
const result = Buffer.allocUnsafe(n);
let written = 0;
while (written < n) {
const buffer = this._buffer[this._bufferIndex];
const available = buffer.byteLength - this._byteIndex;
const take = Math.min(available, n - written);
buffer.copy(result, written, this._byteIndex, this._byteIndex + take);
written += take;
this._byteIndex += take;
if (this._byteIndex >= buffer.byteLength) {
this._bufferIndex++;
this._byteIndex = 0;
}
}
return result;
}
_buildString() {
const string = String.fromCharCode.apply(null, this._accumulator);
this._accumulator = [];
return string;
}
_checkHeaderSize() {
if (++this._headerSize > this._maxHeaderSize) {
throw errors.INVALID_MESSAGE("Header exceeds limit of " + this._maxHeaderSize + " bytes");
}
}
_storeHeader(name, value) {
let end = value.length;
while (end > 0 && (value.charCodeAt(end - 1) === SP || value.charCodeAt(end - 1) === TAB)) {
end--;
}
if (end < value.length) value = value.substring(0, end);
this._headerCount++;
if (this._headerCount > this._maxHeadersCount) {
throw errors.INVALID_MESSAGE("Header count exceeds limit of " + this._maxHeadersCount);
}
switch (name) {
case "__proto__":
case "constructor":
case "prototype":
throw errors.INVALID_HEADER("Unsafe header name '" + name + "'");
case "host":
case "content-length":
case "transfer-encoding":
if (name in this._headers) {
throw errors.INVALID_HEADER("Duplicate header '" + name + "'");
}
this._headers[name] = value;
break;
default: {
const delimiter = name === "cookie" ? "; " : ", ";
if (name in this._headers) {
this._headers[name] += delimiter + value;
} else {
this._headers[name] = value;
}
}
}
}
*_parse() {
while (true) {
if (this._state === BODY) {
if (this._buffered === 0) return;
const available = Math.min(this._buffered, this._remaining);
const data = this._consume(available);
this._remaining -= available;
const ended = this._remaining === 0;
if (ended) this._state = FIRST_TOKEN;
yield { type: constants.DATA, data };
if (ended) yield { type: constants.END };
continue;
}
if (this._state === CHUNK_DATA) {
if (this._buffered < this._remaining) return;
const consumed = this._consume(this._remaining);
if (consumed[this._remaining - 2] !== CR || consumed[this._remaining - 1] !== LF) {
throw errors.INVALID_MESSAGE("Expected CRLF after chunk data");
}
const data = consumed.subarray(0, this._remaining - 2);
this._remaining = 0;
this._state = CHUNK_SIZE;
yield { type: constants.DATA, data };
continue;
}
if (this._buffered === 0) return;
const byte = this._buffer[this._bufferIndex][this._byteIndex++];
this._buffered--;
if (this._byteIndex >= this._buffer[this._bufferIndex].byteLength) {
this._bufferIndex++;
this._byteIndex = 0;
}
switch (this._state) {
case FIRST_TOKEN: {
this._checkHeaderSize();
if (byte === SP) {
const token = this._buildString();
if (token.length === 0) throw errors.INVALID_MESSAGE();
this._isResponse = token.startsWith("HTTP/");
if (this._isResponse) {
if (token !== "HTTP/1.0" && token !== "HTTP/1.1") {
throw errors.INVALID_MESSAGE();
}
this._version = token;
this._state = STATUS_CODE;
} else {
this._method = token;
this._state = REQUEST_URL;
}
} else if (byte === CR) {
throw errors.INVALID_MESSAGE();
} else if (isTokenByte(byte)) {
this._accumulator.push(byte);
} else if (byte === 47 && this._accumulator.length === 4 && this._accumulator[0] === 72 && this._accumulator[1] === 84 && this._accumulator[2] === 84 && this._accumulator[3] === 80) {
this._accumulator.push(byte);
} else {
throw errors.INVALID_MESSAGE();
}
break;
}
case REQUEST_URL: {
this._checkHeaderSize();
if (byte === SP) {
this._url = this._buildString();
if (this._url.length === 0) throw errors.INVALID_MESSAGE();
this._state = REQUEST_VERSION;
} else if (byte === CR) {
throw errors.INVALID_MESSAGE();
} else if (byte >= 33 && byte !== 127) {
this._accumulator.push(byte);
} else {
throw errors.INVALID_MESSAGE();
}
break;
}
case REQUEST_VERSION: {
this._checkHeaderSize();
if (byte === CR) {
this._version = this._buildString();
if (this._version !== "HTTP/1.0" && this._version !== "HTTP/1.1") {
throw errors.INVALID_MESSAGE();
}
this._state = FIRST_LINE_LF;
} else if (byte >= 33 && byte !== 127) {
this._accumulator.push(byte);
} else {
throw errors.INVALID_MESSAGE();
}
break;
}
case STATUS_CODE: {
this._checkHeaderSize();
if (byte === SP) {
if (this._accumulator.length === 0) throw errors.INVALID_MESSAGE();
let code = 0;
for (let i = 0, n = this._accumulator.length; i < n; i++) {
code = code * 10 + this._accumulator[i];
}
this._accumulator = [];
if (code < 100 || code > 999) throw errors.INVALID_MESSAGE();
this._code = code;
this._state = STATUS_REASON;
} else if (byte >= ZERO && byte <= NINE) {
this._accumulator.push(byte - ZERO);
} else {
throw errors.INVALID_MESSAGE();
}
break;
}
case STATUS_REASON: {
this._checkHeaderSize();
if (byte === CR) {
this._reason = this._buildString();
this._state = FIRST_LINE_LF;
} else if (isFieldByte(byte)) {
this._accumulator.push(byte);
} else {
throw errors.INVALID_MESSAGE();
}
break;
}
case FIRST_LINE_LF: {
if (byte !== LF) throw errors.INVALID_MESSAGE();
this._headers = /* @__PURE__ */ Object.create(null);
this._headerCount = 0;
this._state = HEADER_START;
break;
}
case HEADER_START: {
this._checkHeaderSize();
if (byte === CR) {
this._state = HEADER_END_LF;
} else if (byte !== COLON && isTokenByte(byte)) {
this._accumulator.push(byte >= UPPER_A && byte <= UPPER_Z ? byte + 32 : byte);
this._state = HEADER_NAME;
} else {
throw errors.INVALID_HEADER();
}
break;
}
case HEADER_NAME: {
this._checkHeaderSize();
if (byte === COLON) {
this._headerName = this._buildString();
this._state = HEADER_VALUE_WS;
} else if (byte !== COLON && isTokenByte(byte)) {
this._accumulator.push(byte >= UPPER_A && byte <= UPPER_Z ? byte + 32 : byte);
} else {
throw errors.INVALID_HEADER();
}
break;
}
case HEADER_VALUE_WS: {
this._checkHeaderSize();
if (byte === SP || byte === TAB) break;
if (byte === CR) {
this._storeHeader(this._headerName, "");
this._headerName = "";
this._state = HEADER_LINE_LF;
break;
}
if (!isFieldByte(byte)) throw errors.INVALID_HEADER();
this._accumulator.push(byte);
this._state = HEADER_VALUE;
break;
}
case HEADER_VALUE: {
this._checkHeaderSize();
if (byte === CR) {
this._storeHeader(this._headerName, this._buildString());
this._headerName = "";
this._state = HEADER_LINE_LF;
} else if (isFieldByte(byte)) {
this._accumulator.push(byte);
} else {
throw errors.INVALID_HEADER();
}
break;
}
case HEADER_LINE_LF: {
if (byte !== LF) throw errors.INVALID_HEADER();
this._state = HEADER_START;
break;
}
case HEADER_END_LF: {
if (byte !== LF) throw errors.INVALID_MESSAGE();
const headers = { ...this._headers };
if (this._isResponse) {
yield {
type: constants.RESPONSE,
version: this._version,
code: this._code,
reason: this._reason,
headers
};
} else {
if (this._version === "HTTP/1.1" && !("host" in headers)) {
throw errors.INVALID_HEADER("Header 'Host' is missing");
}
yield {
type: constants.REQUEST,
version: this._version,
method: this._method,
url: this._url,
headers
};
}
const transferEncoding = headers["transfer-encoding"];
const contentLength = headers["content-length"];
if (transferEncoding) {
const encodings = transferEncoding.split(",");
let chunkedCount = 0;
for (let i = 0, n = encodings.length; i < n; i++) {
if (encodings[i].trim().toLowerCase() === "chunked") chunkedCount++;
}
const lastEncoding = encodings[encodings.length - 1].trim().toLowerCase();
if (lastEncoding !== "chunked") {
throw errors.INVALID_MESSAGE("'Transfer-Encoding' must end with 'chunked'");
}
if (chunkedCount > 1) {
throw errors.INVALID_MESSAGE(
"'chunked' must not appear more than once in 'Transfer-Encoding'"
);
}
if (contentLength) {
throw errors.INVALID_MESSAGE(
"Conflicting 'Content-Length' and 'Transfer-Encoding' headers"
);
}
this._state = CHUNK_SIZE;
this._headerSize = 0;
continue;
}
if (contentLength) {
if (contentLength.length === 0) throw errors.INVALID_CONTENT_LENGTH();
let length = 0;
for (let i = 0, n = contentLength.length; i < n; i++) {
const c = contentLength.charCodeAt(i);
if (c < ZERO || c > NINE) throw errors.INVALID_CONTENT_LENGTH();
length = length * 10 + (c - ZERO);
}
if (!Number.isSafeInteger(length) || length < 0) {
throw errors.INVALID_CONTENT_LENGTH();
}
if (length === 0) {
this._state = FIRST_TOKEN;
this._headerSize = 0;
yield { type: constants.END };
} else {
this._state = BODY;
this._remaining = length;
this._headerSize = 0;
}
} else {
this._state = FIRST_TOKEN;
this._headerSize = 0;
yield { type: constants.END };
}
break;
}
case CHUNK_SIZE: {
if (byte === CR || byte === 59) {
if (this._accumulator.length === 0) throw errors.INVALID_CHUNK_LENGTH();
let length = 0;
for (let i = 0, n = this._accumulator.length; i < n; i++) {
length = length * 16 + this._accumulator[i];
}
this._accumulator = [];
if (!Number.isSafeInteger(length)) throw errors.INVALID_CHUNK_LENGTH();
if (byte === 59) {
this._remaining = length;
this._state = CHUNK_EXTENSION;
} else if (length === 0) {
this._state = LAST_CHUNK_LF;
} else {
this._remaining = length + 2;
this._state = CHUNK_SIZE_LF;
}
} else if (isHex(byte)) {
if (this._accumulator.length >= MAX_CHUNK_SIZE_LENGTH) {
throw errors.INVALID_CHUNK_LENGTH();
}
this._accumulator.push(hexValue(byte));
} else {
throw errors.INVALID_CHUNK_LENGTH();
}
break;
}
case CHUNK_EXTENSION: {
this._checkHeaderSize();
if (byte === CR) {
if (this._remaining === 0) {
this._state = LAST_CHUNK_LF;
} else {
this._remaining += 2;
this._state = CHUNK_SIZE_LF;
}
} else if (!isFieldByte(byte)) {
throw errors.INVALID_CHUNK_LENGTH();
}
break;
}
case CHUNK_SIZE_LF: {
if (byte !== LF) throw errors.INVALID_CHUNK_LENGTH();
this._state = CHUNK_DATA;
break;
}
case LAST_CHUNK_LF: {
if (byte !== LF) throw errors.INVALID_CHUNK_LENGTH();
this._state = TRAILER_CR;
break;
}
case TRAILER_CR: {
if (byte !== CR) throw errors.INVALID_MESSAGE();
this._state = TRAILER_LF;
break;
}
case TRAILER_LF: {
if (byte !== LF) throw errors.INVALID_MESSAGE();
this._state = FIRST_TOKEN;
this._headerSize = 0;
yield { type: constants.END };
break;
}
default:
throw errors.INVALID_MESSAGE();
}
}
}
};
exports.constants = constants;
var TOKEN_BYTES = Buffer.from([
// 0x00-0x1f (control characters) + 0x20 (space)
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
// 0x21-0x41: ! " # $ % & ' ( ) * + , - . / 0-9 : ; < = > ? @ A
1,
0,
1,
1,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
1,
// 0x42-0x62: B-Z [ \ ] ^ _ ` a b
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
// 0x63-0x7f: c-z { | } ~ DEL
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
1,
0
]);
function isTokenByte(b) {
return TOKEN_BYTES[b] === 1;
}
function isFieldByte(b) {
return b === TAB || b >= 32 && b <= 126;
}
function isHex(b) {
return b >= ZERO && b <= NINE || b >= UPPER_A && b <= UPPER_F || b >= LOWER_A && b <= LOWER_F;
}
function hexValue(b) {
if (b >= ZERO && b <= NINE) return b - ZERO;
if (b >= UPPER_A && b <= UPPER_F) return b - UPPER_A + 10;
return b - LOWER_A + 10;
}
}
});
// ../../bare-lib-entry-bareHttpParser.js
var bare_lib_entry_bareHttpParser_exports = {};
__export(bare_lib_entry_bareHttpParser_exports, {
default: () => bare_lib_entry_bareHttpParser_default
});
var import_bare_http_parser = __toESM(require_bare_http_parser());
var bare_lib_entry_bareHttpParser_default = import_bare_http_parser.default;
return __toCommonJS(bare_lib_entry_bareHttpParser_exports);
})();
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareHttpParser"]=v;})();
Reference in New Issue View Git Blame Copy Permalink