spec-3nweb-server 1.8.4 → 1.8.6

package/ts-code/lib-common/buffer-utils.ts

@@ -0,0 +1,124 @@
+/*
+ Copyright (C) 2016, 2018 - 2019 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export const EMPTY_BUFFER = Buffer.alloc(0);
+
+/**
+ * Buffer and Uint8Array are intimately linked in Node, starting with some
+ * version. As a result, Uint8Array can be efficiently turned into Buffer,
+ * or Buffer can be used as Uint8Array.
+ * This function checks if given argument is a Buffer, and, if not, does
+ * proper enveloping.
+ * @param bytes that we need to have as a Buffer
+ * @return Buffer with given bytes. 
+ */
+export function toBuffer(bytes: Uint8Array): Buffer {
+	if (Buffer.isBuffer(bytes)) { return bytes; }
+	if (bytes.length === 0) { return EMPTY_BUFFER; }
+	return Buffer.from(bytes.buffer as ArrayBuffer, bytes.byteOffset, bytes.length);
+}
+
+/**
+ * Node's JSON.stringify turns Buffer into a particular json.
+ * This function turns this json back to Buffer.
+ * @param json of a Buffer
+ * @return a Buffer reconstructed from a given json.
+ */
+export function bufFromJson(json: any): Buffer {
+	if ((json.type !== 'Buffer') || !Array.isArray(json.data)) { throw new Error(
+		'Given argument is not a buffer json.'); }
+	return Buffer.from(json.data);
+}
+
+export namespace base64 {
+	
+	export function pack(bytes: Uint8Array): string {
+		const buf = toBuffer(bytes);
+		return buf.toString('base64');
+	}
+	
+	export function open(str: string): Uint8Array {
+		return Buffer.from(str, 'base64');
+	}
+	
+}
+Object.freeze(base64);
+
+export namespace base64urlSafe {
+	
+	export function pack(bytes: Uint8Array): string {
+		const str = base64.pack(bytes);
+		return str
+			.replace(/\+/g, '-')
+			.replace(/\//g, '_');
+	}
+	
+	export function open(str: string): Uint8Array {
+		str = str
+			.replace(/-/g, '+')
+			.replace(/_/g, '/');
+		return base64.open(str);
+	}
+
+	export function allCharsFromAlphabet(str: string): boolean {
+		for (let i=0; i<str.length; i+=1) {
+			const cp = str.codePointAt(i)!;
+			// small letters
+			if ((0x61 <= cp) && (cp <= 0x7A)) { continue; }
+			// capital letters
+			if ((0x41 <= cp) && (cp <= 0x5A)) { continue; }
+			// digits
+			if ((0x30 <= cp) && (cp <= 0x39)) { continue; }
+			// underscore and hyphen
+			if ((cp === 0x5F) || (cp === 0x2D)) { continue; }
+			return false;
+		}
+		return true;
+	}
+
+}
+Object.freeze(base64);
+
+export namespace utf8 {
+	
+	export function pack(str: string): Uint8Array {
+		return Buffer.from(str, 'utf8');
+	}
+	
+	export function open(bytes: Uint8Array): string {
+		const buf = toBuffer(bytes);
+		return buf.toString('utf8');
+	}
+	
+}
+Object.freeze(utf8);
+
+export function joinByteArrs(arrs: Uint8Array[]): Uint8Array {
+	let totalLen = 0;
+	for (const arr of arrs) {
+		totalLen += arr.length;
+	}
+	const allBytes = Buffer.allocUnsafe(totalLen);
+	let ofs = 0;
+	for (const arr of arrs) {
+		allBytes.set(arr, ofs);
+		ofs += arr.length;
+	}
+	return allBytes;
+}
+
+Object.freeze(exports);

package/ts-code/lib-common/byte-streaming/common.ts

@@ -0,0 +1,166 @@
+/*
+ Copyright (C) 2015 - 2016, 2019 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+export type ByteSource = web3n.ByteSource;
+
+type Transferable = web3n.implementation.Transferable;
+
+export function wrapByteSourceImplementation(src: ByteSource): ByteSource {
+	const wrap: ByteSource = {
+		read: src.read.bind(src),
+		getSize: src.getSize.bind(src)
+	};
+	if (src.seek) {
+		wrap.seek = src.seek.bind(src);
+		wrap.getPosition = src.getPosition!.bind(src);
+	}
+	(wrap as any as Transferable).$_transferrable_type_id_$ = 'ByteSource';
+	return wrap;
+}
+
+export type ByteSink = web3n.ByteSink; 
+
+export function wrapByteSinkImplementation(sink: ByteSink): ByteSink {
+	const wrap: ByteSink = {
+		setSize: sink.setSize.bind(sink),
+		write: sink.write.bind(sink),
+		getSize: sink.getSize.bind(sink)
+	};
+	if (sink.seek) {
+		wrap.seek = sink.seek.bind(sink);
+		wrap.getPosition = sink.getPosition!.bind(sink);
+	}
+	(wrap as any as Transferable).$_transferrable_type_id_$ = 'ByteSink';
+	return wrap;
+}
+
+export class BytesFIFOBuffer {
+	
+	private queue: Uint8Array[] = [];
+	private bytesLen = 0;
+	get length(): number {
+		return this.bytesLen;
+	}
+	get queueLength(): number {
+		return this.queue.length;
+	}
+	
+	constructor() {
+		Object.seal(this);
+	}
+
+	clear(): void {
+		this.queue = [];
+		this.bytesLen = 0;
+	}
+	
+	push(bytes: Uint8Array): void {
+		if (bytes.length === 0) { return; }
+		this.queue.push(bytes);
+		this.bytesLen += bytes.length;
+	}
+	
+	/**
+	 * @param extractLen is number of bytes to extract. It must always be less,
+	 * or equal to current length of queue.
+	 * @return requested bytes
+	 */
+	private extractSomeBytesFrom(extractLen: number): Uint8Array|undefined {
+		if (this.queue.length === 0) { return undefined; }
+		const extract = new Uint8Array(extractLen);
+		let offset = 0;
+		while (offset < extractLen) {
+			const chunk = this.queue[0];
+			if ((offset + chunk.length) <= extractLen) {
+				extract.set(chunk, offset);
+				offset += chunk.length;
+				this.queue.shift();
+			} else {
+				extract.set(chunk.subarray(0, extractLen-offset), offset);
+				this.queue[0] = chunk.subarray(extractLen-offset);
+				break;
+			}
+		}
+		return extract;
+	}
+	
+	private extractAllBytesFrom(): Uint8Array|undefined {
+		return this.extractSomeBytesFrom(this.bytesLen);
+	}
+		
+	/**
+	 * @param len is a number of bytes to get.
+	 * If undefined is given, all bytes should be returned.
+	 * @return an array of bytes, or undefined, if there are not enough bytes.
+	 */
+	getBytes(len: number|undefined, canBeLess = false): Uint8Array|undefined {
+		let extract: Uint8Array|undefined;
+		if (typeof len !== 'number') {
+			extract = this.extractAllBytesFrom();
+		} else {
+			if (len < 1) { throw new Error('Length parameter is illegal: '+len); }
+			if (this.queue.length === 0) { return undefined; }
+			if (this.bytesLen < len) {
+				if (canBeLess) {
+					extract = this.extractAllBytesFrom();
+				} else {
+					return undefined;
+				}
+			} else {
+				extract = this.extractSomeBytesFrom(len);
+			}
+		}
+		if (extract) {
+			this.bytesLen -= extract.length;
+		}
+		return extract;
+	}
+	
+}
+Object.freeze(BytesFIFOBuffer.prototype);
+Object.freeze(BytesFIFOBuffer);
+
+/**
+ * @param bytes
+ * @return a seekable byte source, based on a given byte array.
+ */
+export function sourceFromArray(bytes: Uint8Array): ByteSource {
+	let pos = 0;
+	const src: ByteSource = {
+		getPosition: async (): Promise<number> => { return pos; },
+		getSize: async (): Promise<number> => { return bytes.length; },
+		read: async (len: number|undefined): Promise<Uint8Array|undefined> => {
+			if (len === undefined) { return bytes.subarray(pos); }
+			if ((typeof len !== 'number') || (len < 0)) { throw new TypeError(
+				`Illegal length parameter given: ${len}`); }
+			const chunk = bytes.subarray(pos, pos+len);
+			pos += chunk.length;
+			return ((chunk.length === 0) ? undefined : chunk);
+		},
+		seek: async (newPos: number): Promise<void> => {
+			if ((typeof newPos !== 'number') || (newPos < 0)) {
+				throw new TypeError(`Illegal position given: ${newPos}`); }
+			if (newPos > bytes.length) { throw new Error(
+				`Position parameter is out of bound`); }
+			pos = newPos;
+		}
+	};
+	return src;
+}
+
+Object.freeze(exports);

package/ts-code/lib-common/bytes-equal.ts

@@ -0,0 +1,25 @@
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+	if (a.BYTES_PER_ELEMENT !== b.BYTES_PER_ELEMENT) { return false; }
+	if (a.length !== b.length) { return false; }
+	for (let i=0; i<a.length; i+=1) {
+		if (a[i] !== b[i]) { return false; }
+	}
+	return true;
+}

package/ts-code/lib-common/canonical-address.ts

@@ -0,0 +1,92 @@
+/*
+ Copyright (C) 2016, 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { toASCII } from 'punycode';
+
+/**
+ * @param address
+ * @return a canonical form of a given address.
+ * If given address is not ok, exception is thrown.
+ */
+export function toCanonicalAddress(address: string): string {
+	const indOfAt = address.indexOf('@');
+	let user: string;
+	let domain: string;
+	if (indOfAt < 0) {
+		domain = address;
+		user = '';
+	} else {
+		domain = address.substring(indOfAt+1);
+		user = address.substring(0, indOfAt).replace(whiteSpace, '');
+	}
+	checkDomainString(domain, address);
+	return (user+'@'+domain).toLowerCase();
+}
+
+const whiteSpace = /\s/g;
+const invalidInDomain = /[^a-zA-Z0-9\-\.]/;
+
+function checkDomainString(d: string, addrForErrMsg: string): void {
+	if (d.length === 0) { throw makeParseExc(addrForErrMsg, `Domain is empty`); }
+	if (d.startsWith('xn--')) { throw makeParseExc(addrForErrMsg,
+		`Domain can't be in puny code`); }
+	let ascii: string;
+	try {
+		ascii = toASCII(d);
+	} catch (err) {
+		throw makeParseExc(addrForErrMsg, err);
+	}
+	if (invalidInDomain.test(ascii)) {
+		throw makeParseExc(addrForErrMsg);
+	}
+}
+
+function makeParseExc(address: string, cause?: any): UserIdParseException {
+	return {
+		runtimeException: true,
+		type: 'user-id-parse',
+		address,
+		message: `Can't parse given address as valid user id`,
+		cause
+	};
+}
+
+export interface UserIdParseException extends web3n.RuntimeException {
+	type: 'user-id-parse';
+	address: string;
+}
+
+export function areAddressesEqual(a: string, b: string): boolean {
+	const canonicalA = toCanonicalAddress(a);
+	if (!canonicalA) { return false; }
+	const canonicalB = toCanonicalAddress(b);
+	if (!canonicalB) { return false; }
+	return (canonicalA === canonicalB);
+}
+
+/**
+ * @param address
+ * @return if given address is ok, its canonical form is returned.
+ * Otherwise, undefined is returned.
+ */
+export function checkAndTransformAddress(address: string): string|undefined {
+	try {
+		return toCanonicalAddress(address);
+	} catch (err) { }
+}
+
+Object.freeze(exports);

package/ts-code/lib-common/exceptions/error.ts

@@ -0,0 +1,44 @@
+/*
+ Copyright (C) 2016 - 2017 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export interface ErrorWithCause extends Error {
+	cause: any;
+}
+
+export function errWithCause(cause: any, message: string): ErrorWithCause {
+	const err = <ErrorWithCause> new Error(message);
+	err.cause = cause;
+	return err;
+}
+
+export function stringifyErr(err: any): string {
+	if ((err as web3n.RuntimeException).runtimeException || !err
+	|| (typeof err !== 'object')) {
+		return `${JSON.stringify(err, null, '  ')}
+`;
+	} else {
+		return `Error message: ${err.message}
+Error stack: ${err.stack}${
+	((err as ErrorWithCause).cause ? `
+Caused by:
+${stringifyErr((err as ErrorWithCause).cause)}` :
+	'')}
+`;
+	}
+}
+
+Object.freeze(exports);

package/ts-code/lib-common/exceptions/file.ts

@@ -0,0 +1,84 @@
+/*
+ Copyright (C) 2015 - 2017 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export const fileExceptionType = 'file';
+
+export const Code: web3n.files.exceptionCode = {
+	notFound: 'ENOENT',
+	alreadyExists: 'EEXIST',
+	notDirectory: 'ENOTDIR',
+	notFile: 'ENOTFILE',
+	notLink: 'not-link',
+	isDirectory: 'EISDIR',
+	notEmpty: 'ENOTEMPTY',
+	endOfFile: 'EEOF',
+	concurrentUpdate: 'concurrent-update'
+};
+Object.freeze(Code);
+
+export type FileException = web3n.files.FileException;
+
+export function makeFileException(code: string|undefined, path: string,
+		cause?: any): FileException {
+	const err: FileException = {
+		runtimeException: true,
+		type: fileExceptionType,
+		code,
+		path,
+		cause
+	};
+	if (code === Code.alreadyExists) {
+		err.alreadyExists = true;
+	} else if (code === Code.notFound) {
+		err.notFound = true;
+	} else if (code === Code.isDirectory) {
+		err.isDirectory = true;
+	} else if (code === Code.notDirectory) {
+		err.notDirectory = true;
+	} else if (code === Code.notFile) {
+		err.notFile = true;
+	} else if (code === Code.notLink) {
+		err.notLink = true;
+	} else if (code === Code.endOfFile) {
+		err.endOfFile = true;
+	} else if (code === Code.notEmpty) {
+		err.notEmpty = true;
+	} else if (code === Code.concurrentUpdate) {
+		err.concurrentUpdate = true;
+	}
+	return err;
+}
+
+export function maskPathInExc(pathPrefixMaskLen: number, exc: any):
+		FileException {
+	if (exc.runtimeException || !exc.code) { return exc; }
+	if (typeof exc.path === 'string') {
+		exc.path = exc.path.substring(pathPrefixMaskLen);
+	}
+	return exc;
+}
+
+export function ensureCorrectFS(fs: web3n.files.FS, type: web3n.files.FSType,
+		writable: boolean): void {
+	if (!fs) { throw new Error("No file system given."); }
+	if (fs.type !== type) { throw new Error(
+		`Expected ${type} file system, instead got ${fs.type} type.`); }
+	if (fs.writable !== writable) { throw new Error(
+		`Given file system is ${fs.writable ? '' : 'not'} writable, while it is expected to be ${writable ? '' : 'not'} writable`); }
+}
+
+Object.freeze(exports);

package/ts-code/lib-common/exceptions/http.ts

@@ -0,0 +1,69 @@
+/*
+ Copyright (C) 2015 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * This module contains some code and type declarations that are common for
+ * both main and worker processes.
+ */
+
+interface HTTPErrorDetails extends web3n.RuntimeException {
+	url: string;
+	method: string;
+	message?: string;
+}
+
+export interface ConnectException extends HTTPErrorDetails {
+	type: 'http-connect';
+}
+
+export interface HTTPException extends HTTPErrorDetails {
+	type: 'http-request';
+	status: number;
+}
+
+export function makeConnectionException(url: string|undefined,
+		method: string|undefined, msg?: string, cause?: any): ConnectException {
+	const exc: ConnectException = {
+		runtimeException: true,
+		type: 'http-connect',
+		url: url!,
+		method: method!,
+		cause
+	};
+	if (msg) {
+		exc.message = msg;
+	}
+	return exc;
+}
+
+export function makeHTTPException(url: string, method: string, status: number,
+		msg?: string, cause?: any): HTTPException {
+	const exc: HTTPException = {
+		runtimeException: true,
+		type: 'http-request',
+		url: url,
+		method: method,
+		status: status,
+		cause
+	};
+	if (msg) {
+		exc.message = msg;
+	}
+	return exc;
+}
+
+Object.freeze(exports);