spec-3nweb-server 1.8.5 → 1.8.7

package/ts-code/3nstorage/routes/owner/get-current-obj.ts

@@ -0,0 +1,124 @@
+/*
+ Copyright (C) 2017, 2020, 2026 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 { RequestHandler } from 'express';
+import { GetCurrentObj, SC as storeSC } from '../../resources/users';
+import { GetObjQueryOpts, ERR_SC, HTTP_HEADER, BIN_TYPE, currentObj as api } from '../../../lib-common/service-api/3nstorage/owner';
+import { Request } from '../../resources/sessions';
+import { errWithCause, stringifyErr } from '../../../lib-common/exceptions/error';
+import { EMPTY_BUFFER } from '../../../lib-common/buffer-utils';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
+
+function extractQueryOptions(req: Request): undefined|{
+	header: boolean; limit: number|undefined; ofs: number;
+	ver: number|undefined;
+} {
+	// query fields are string or undefined, yet, type info helps the show
+	const query: GetObjQueryOpts = req.query;
+
+	const header = ((query.header as any) === 'true');
+
+	const ofs = (query.ofs ? parseInt(query.ofs as any) : 0);
+	if (isNaN(ofs) ||
+			(ofs < 0) ||
+			(header && (ofs > 0))) { return; }
+
+	const limit = (query.limit ? parseInt(query.limit as any) : undefined);
+	if (limit !== undefined) {
+		if (isNaN(limit) ||
+				(limit < 0) ||
+				(!header && (limit === 0))) { return; }
+	}
+
+	let ver = (query.ver ? parseInt(query.ver as any) : undefined);
+	if (ver !== undefined) {
+		if (isNaN(ver!)) {
+			ver = undefined;
+		} else if (ver < 1) {
+			return;
+		}
+	}
+
+	return { header, limit, ofs, ver };
+}
+
+export function getCurrentObj(
+	root: boolean, getCurrentObjFunc: GetCurrentObj
+): RequestHandler {
+
+	return async (req: Request, res, next) => {
+		
+		const userId = req.session.params.userId;
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
+		
+		const opts = extractQueryOptions(req);
+		if (!opts) {
+			res.status(ERR_SC.malformed).send("Bad query parameters");
+			return;
+		}
+		
+		try {
+			const { version, reader } = await getCurrentObjFunc(userId, objId,
+				opts.header, opts.ofs, opts.limit);
+			if (opts.ver) {
+				if (opts.ver !== version) {
+					res.set(HTTP_HEADER.objVersion, `${version}`);
+					res.status(api.SC.unknownObjVer).send();
+					return;
+				}
+			} else {
+				res.set(HTTP_HEADER.objVersion, `${version}`);
+			}
+			res.status(api.SC.okGet);
+			res.set(HTTP_HEADER.contentType, BIN_TYPE);
+			res.set(HTTP_HEADER.contentLength, `${reader.len}`);
+			if (opts.header) {
+				res.set(HTTP_HEADER.objHeaderLength, `${reader.headerLen}`);
+			}
+			res.set(HTTP_HEADER.objSegmentsLength, `${reader.segsLen}`);
+			if (reader.len > 0) {
+				try {
+					await reader.pipe!(res);
+				} catch (err) {
+					console.error(stringifyErr(errWithCause(err, `Wasn't able to complete sending segments due to error in piping`)));
+				} finally {
+					res.end();
+				}
+			} else {
+				res.send(EMPTY_BUFFER);
+			}
+		} catch (err) {
+			if ("string" !== typeof err) {
+				next(err);
+			} else if ((err === storeSC.OBJ_UNKNOWN)
+			|| (err === storeSC.OBJ_VER_UNKNOWN)) {
+				replyWithErr(api.SC.unknownObj, (objId ? `Object ${objId} is unknown.` : `Root object is not set.`), res);
+			} else if (err === storeSC.USER_UNKNOWN) {
+				replyWithErr(ERR_SC.server, `Recipient disappeared from the system.`, res);
+				req.session.close();
+			} else {
+				next(new Error(`Unhandled storage error code: ${err}`));
+			}
+		}
+		
+	};
+};
+
+Object.freeze(exports);

package/ts-code/3nstorage/routes/owner/get-obj-status.ts

@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2022, 2026 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 { RequestHandler } from 'express';
+import { GetObjStatus, SC as storeSC } from '../../resources/users';
+import { objStatus as api, ERR_SC } from '../../../lib-common/service-api/3nstorage/owner';
+import { Request } from '../../resources/sessions';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
+
+export function getObjStatus(
+	root: boolean, getObjStatusFunc: GetObjStatus
+): RequestHandler {
+
+	return async (req: Request, res, next) => {
+
+		const userId = req.session.params.userId;
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res);
+		}
+		
+		try {
+			const lst = await getObjStatusFunc(userId, objId);
+			res.status(api.SC.ok).json(lst);
+		} catch (err) {
+			if ("string" !== typeof err) {
+				next(err);
+			} else if (err === storeSC.OBJ_UNKNOWN) {
+				replyWithErr(api.SC.unknownObj, (root ? `Root object is set.` : `Object ${objId} is unknown.`), res);
+			} else if (err === storeSC.USER_UNKNOWN) {
+				replyWithErr(ERR_SC.server, "Recipient disappeared from the system.", res);
+				req.session.close();
+			} else {
+				next(new Error("Unhandled storage error code: "+err));
+			}
+		}
+		
+	};
+};
+
+Object.freeze(exports);

package/ts-code/3nstorage/routes/owner/param-getter.ts

@@ -0,0 +1,51 @@
+/*
+ Copyright (C) 2015 - 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/>.
+*/
+
+import { RequestHandler } from 'express';
+import { SC as storeSC } from '../../resources/users';
+import { PARAM_SC, ERR_SC } from '../../../lib-common/service-api/3nstorage/owner';
+import { Request } from '../../resources/sessions';
+
+export function getParam<T>(
+	paramGetter: (userId: string) => Promise<T>
+): RequestHandler {
+	
+	if ('function' !== typeof paramGetter) { throw new TypeError(
+			"Given argument 'paramGetter' must be function, but is not."); }
+	
+	return async (req: Request, res, next) => {
+		
+		const session = req.session;
+		const userId = session.params.userId;
+		
+		try{
+			const value = await paramGetter(userId);
+			res.status(PARAM_SC.ok).json(value);
+		} catch (err) {
+			if (err === storeSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send(
+					"Recipient disappeared from the system.");
+				session.close();
+			} else {
+				next(err);
+			}
+		}
+		
+	};
+	
+}
+Object.freeze(exports);

package/ts-code/3nstorage/routes/owner/param-setter.ts

@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2015 - 2016, 2026 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 { RequestHandler } from 'express';
+import { SC as storeSC } from '../../resources/users';
+import { PARAM_SC, ERR_SC } from '../../../lib-common/service-api/3nstorage/owner';
+import { Request } from '../../resources/sessions';
+
+export function setParam<T>(
+	paramSetter: (userId: string, param: T) => Promise<boolean>
+): RequestHandler {
+
+	return async (req: Request, res, next) => {
+
+		const session = req.session;
+		const userId = session.params.userId;
+		const pValue: T = req.body;
+
+		try{
+			const valChanged = await paramSetter(userId, pValue)
+			if (valChanged) {
+				res.status(PARAM_SC.ok).send();
+			} else {
+				res.status(ERR_SC.malformed).send('Malformed parameter value.');
+			}
+		} catch (err) {
+			if (err === storeSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send("Recipient disappeared from the system.");
+				session.close();
+			} else {
+				next(err);
+			}
+		}
+	};
+
+}

package/ts-code/3nstorage/routes/owner/put-current-obj.ts

@@ -0,0 +1,257 @@
+/*
+ Copyright (C) 2017, 2019 - 2020, 2026 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 { RequestHandler, Response } from 'express';
+import { SaveNewObjVersion, SC as saveSC, MismatchedObjVerException } from '../../resources/users';
+import { currentObj as api, ERR_SC, HTTP_HEADER, BIN_TYPE, PutObjFirstQueryOpts, PutObjSecondQueryOpts, DiffInfo, sanitizedDiff, ErrorReply } from '../../../lib-common/service-api/3nstorage/owner';
+import { stringToNumOfBytes } from '../../../lib-server/conf-util';
+import { Request } from '../../resources/sessions';
+import { attachByteDrainToRequest } from '../../../lib-server/middleware/body-parsers';
+import { Readable as ReadableStream } from 'stream';
+import { BytesFIFOBuffer } from '../../../lib-common/byte-streaming/common';
+import { defer, Deferred } from '../../../lib-common/processes';
+import { utf8 } from '../../../lib-common/buffer-utils';
+import { getObjIdFromParams, replyWithErr } from '../../resources/utils';
+
+export function saveCurrentObj(
+	root: boolean, saveObjFunc: SaveNewObjVersion, chunkLimit: string|number
+): RequestHandler {
+	if ('function' !== typeof saveObjFunc) { throw new TypeError(
+		"Given argument 'saveObjFunc' must be function, but is not."); }
+	const maxChunkSize = stringToNumOfBytes(chunkLimit);
+
+	return async (req: Request, res, next) => {
+		
+		if (!req.is(BIN_TYPE)) {
+			return replyWithErr(ERR_SC.wrongContentType, `Content-Type must be ${BIN_TYPE} for this call.`, res, req);
+		}
+
+		// get and check Content-Length, implicitly sending replies for bad length
+		let len = getContentLenOrSendError(req, res, maxChunkSize);
+		if (len === undefined) {
+			return;
+		}
+	
+		const userId = req.session.params.userId;
+		const { objId, objIdParseErr } = getObjIdFromParams(root, req);
+		if (objIdParseErr) {
+			return replyWithErr(ERR_SC.malformed, objIdParseErr, res, req);
+		}
+		
+		// extract and check query parameters
+		const opts = extractQueryOptions(req);
+		if (!opts) {
+			return replyWithErr(ERR_SC.malformed, "Bad query parameters", res, req);
+		}
+		const { fstReq, sndReq } = opts;
+
+		let diff: DiffInfo|undefined;
+
+		if (fstReq) {
+
+			// cross-check given lengths
+			const diffAndHeader = fstReq.header + (fstReq.diff ? fstReq.diff : 0);
+			if (diffAndHeader > len) {
+				return replyWithErr(ERR_SC.malformed, "Bad query parameters", res, req);
+			}
+
+			// read diff, if it is expected
+			if (fstReq.diff) {
+				let diffBytes = await readChunkFrom(req, fstReq.diff).catch(noop);
+				if (diffBytes) {
+					len -= fstReq.diff;
+				} else {
+				return replyWithErr(ERR_SC.malformed, "Cannot read diff bytes", res, req);
+				}
+				try {
+					const diffFromReq = JSON.parse(utf8.open(diffBytes));
+					diff = sanitizedDiff(diffFromReq, fstReq.ver);
+					if (!diff) {
+						return replyWithErr(ERR_SC.malformed, "Malformed diff info", res, req);
+					}
+				} catch (err) {
+					return replyWithErr(ERR_SC.malformed, "Malformed diff info", res, req);
+				}
+			}
+
+		} else if (sndReq) {
+
+			if ((len === 0) && !sndReq.last) {
+				return replyWithErr(ERR_SC.malformed, "No segment bytes", res, req);
+			}
+
+		}
+
+		try {
+			const transactionId = await saveObjFunc(userId, objId, fstReq, diff, sndReq, len, req);
+			const reply: api.ReplyToPut = (transactionId ? { transactionId } : {});
+			res.status(api.SC.okPut).json(reply);
+		} catch (err) {
+			if ("string" !== typeof err) {
+				if ((err as MismatchedObjVerException).type === 'mismatched-obj-ver') {
+					const rep: api.MismatchedObjVerReply = {
+						error: "Current object version doesn't match assumed one.",
+						current_version: (err as MismatchedObjVerException).current_version
+					};
+					res.set(HTTP_HEADER.objVersion, `${rep.current_version}`);
+					res.status(api.SC.mismatchedObjVer).json(rep);
+				} else {
+					next(err);
+				}
+			} else if ((err === saveSC.OBJ_UNKNOWN)
+			|| (err === saveSC.OBJ_VER_UNKNOWN)) {
+				replyWithErr(api.SC.unknownObj, `Unknown object ${objId}.`, res);
+			} else if (err === saveSC.TRANSACTION_UNKNOWN) {
+				replyWithErr(api.SC.unknownTransaction, "Unknown transaction.", res);
+			} else if ((err === saveSC.OBJ_EXIST)
+			|| (err === saveSC.OBJ_VER_EXIST)) {
+				replyWithErr(api.SC.objAlreadyExists, "Object already exists.", res);
+			} else if (err === saveSC.CONCURRENT_TRANSACTION) {
+				replyWithErr(api.SC.concurrentTransaction, `Object ${objId} is currently under a transaction.`, res);
+			} else if (err === saveSC.USER_UNKNOWN) {
+				replyWithErr(ERR_SC.server, "Recipient disappeared from the system.", res);
+				req.session.close();
+			} else if (err === saveSC.NOT_ENOUGH_SPACE) {
+				replyWithErr(ERR_SC.noSpace, "Reached storage limits.", res);
+			} else if (err === saveSC.OBJ_FILE_INCOMPLETE) {
+				replyWithErr(api.SC.objIncomplete, "Object version file is incomplete.", res);
+			} else {
+				next(new Error(`Unhandled storage error code: ${err}`));
+			}
+		}
+	};
+}
+
+function extractQueryOptions(req: Request): undefined|{
+	fstReq?: PutObjFirstQueryOpts; sndReq?: PutObjSecondQueryOpts;
+} {
+	if ((req.query as any as PutObjSecondQueryOpts).trans) {
+		// this is the second (not first) request
+		// query fields are string or undefined, yet, type info helps the show
+		const query = req.query as any as PutObjSecondQueryOpts;
+
+		const trans = query.trans;
+
+		const last = ((query.last as any) === 'true');
+
+		const ofs = parseInt(query.ofs as any);
+		if (isNaN(ofs))  { return; }
+
+		return { sndReq: { last, ofs, trans } };
+
+	} else {
+		// this is the first request
+		// query fields are string or undefined, yet, type info helps the show
+		const query = req.query as any as PutObjFirstQueryOpts;
+
+		const ver = parseInt(query.ver as any);
+		if (isNaN(ver) || (ver < 1)) { return; }
+
+		const diff = (query.diff ? parseInt(query.diff as any) : undefined);
+		if (diff !== undefined) {
+			if (isNaN(diff) || (diff < 2) || (diff > 1024)) { return; }
+		}
+
+		const header = parseInt(query.header as any);
+		if (isNaN(header) || (header < 1)) { return; }
+
+		const last = ((query.last as any) === 'true');
+
+		return { fstReq: { diff, header, last, ver } };
+		
+	}
+}
+
+function getContentLenOrSendError(
+	req: Request, res: Response, maxChunkSize: number
+): number|undefined {
+	const contentLength = parseInt(req.get(HTTP_HEADER.contentLength)!);
+	if (isNaN(contentLength)) {
+		replyWithErr(ERR_SC.contentLenMissing, "Content-Length header is required with proper number.", res, req);
+	} else if (contentLength > maxChunkSize) {
+		replyWithErr(ERR_SC.contentTooLong, "Request body is too long.", res, req);
+	} else {
+		return contentLength;
+	}
+	return;
+}
+
+const EARLY_END_OF_STREAM_ERR_STR = `Unexpected end of stream`;
+
+/**
+ * This returns a promise of bytes, read from a given stream.
+ * Given stream will be paused, when bytes are read. Beware.
+ * @param stream
+ * @param bytesToRead is a number of bytes to read from a stream. Error is
+ * thrown, if stream ends too early.
+ */
+function readChunkFrom(
+	stream: ReadableStream, bytesToRead: number
+): Promise<Uint8Array> {
+	if (bytesToRead < 1) {
+		throw new Error(`Illegal number of bytes to read from stream: ${bytesToRead}`);
+	}
+	
+	const buffer = new BytesFIFOBuffer();
+	let deferred: Deferred<Uint8Array>|undefined = defer<Uint8Array>();
+
+	const complete = (bytes?: Uint8Array, err?: any) => {
+		if (!deferred) { return; }
+		if (bytes) {
+			deferred.resolve(bytes);
+		} else {
+			deferred.reject(err);
+			buffer.clear();
+		}
+		deferred = undefined;
+		stream.removeListener('data', onData);
+		stream.removeListener('error', onError);
+		stream.removeListener('end', onEnd);
+	};
+	
+	const onData = (data: Buffer) => {
+		if (!deferred) { return; }
+		buffer.push(data);
+		if (buffer.length < bytesToRead) { return; }
+		stream.pause();
+		complete(buffer.getBytes(bytesToRead));
+		if (buffer.length === 0) { return; }
+		const bytesToUnshift = buffer.getBytes(undefined)!;
+		stream.unshift(Buffer.from(
+			bytesToUnshift.buffer as ArrayBuffer, bytesToUnshift.byteOffset, bytesToUnshift.length));
+	};
+
+	const onEnd = () => {
+		if (!deferred) { return; }
+		complete(undefined, EARLY_END_OF_STREAM_ERR_STR);
+	};
+
+	const onError = (err?: any) => {
+		if (!deferred) { return; }
+		complete(undefined, err);
+	};
+
+	stream.on('data', onData);
+	stream.on('error', onError);
+	stream.on('end', onEnd);
+
+	return deferred.promise;
+}
+
+function noop() {}
+
+Object.freeze(exports);

package/ts-code/3nstorage/routes/owner/session-params.ts

@@ -0,0 +1,50 @@
+/*
+ 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/>.
+*/
+
+import { RequestHandler } from 'express';
+import { SC as storeSC } from '../../resources/users';
+import { sessionParams as api, ERR_SC } from '../../../lib-common/service-api/3nstorage/owner';
+import { stringToNumOfBytes } from '../../../lib-server/conf-util';
+import { Request } from '../../resources/sessions';
+
+export function sessionParams(maxChunk: number|string): RequestHandler {
+	const maxChunkSize = stringToNumOfBytes(maxChunk);
+
+	return async (req: Request, res, next) => {
+		
+		// XXX currently session params are same for all, hence, userId is unused, but, this whole
+		//     thing must be within a session
+		const userId = req.session.params.userId;
+		
+		try {
+			const reply: api.Reply = { maxChunkSize };
+			res.status(api.SC.ok).json(reply);
+		} catch (err) {
+			if ("string" !== typeof err) {
+				next(err);
+			} else if (err === storeSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send("Recipient disappeared from the system.");
+				req.session.close();
+			} else {
+				next(new Error("Unhandled storage error code: "+err));
+			}
+		}
+		
+	};
+};
+
+Object.freeze(exports);

package/ts-code/3nstorage/shared.ts

@@ -0,0 +1,43 @@
+/*
+ Copyright (C) 2015 - 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/>.
+*/
+
+import * as express from 'express';
+import { json as parseJSON } from '../lib-server/middleware/body-parsers';
+import { Factory as UsersFactory } from './resources/users';
+import { SessionsFactory } from './resources/sessions';
+//import * as api from '../../lib-common/service-api/3nstorage/shared';
+
+export function makeSharedStorageApp(
+	sessions: SessionsFactory, users: UsersFactory
+): express.Express {
+	
+	const app = express();
+	app.disable('etag');
+	
+	// TODO add sharing routes with proper session creation for authorities/capabilities
+	// If capacity needs only PKL entry, then manipulations can be done anonymously.
+	// If in addition to PKL, MailerId is required, then it sort of let's server
+	//  protect against loosing capabilities by user's peers, but at a cost of
+	//  anonymity.
+	// Should we allow MailerId-only authenticating capabilities? No,
+	//  since sharing peer will anyway need to have a file to store long names
+	//  and file keys.
+	
+	return app;
+}
+
+Object.freeze(exports);