spec-3nweb-server 1.8.4 → 1.8.6

package/ts-code/asmail/routes/config/param-setter.ts

@@ -0,0 +1,49 @@
+/*
+ Copyright (C) 2015 - 2016, 2025 - 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 { SetParam, SC as recipSC } from '../../resources/recipients';
+import { PARAM_SC, ERR_SC } from '../../../lib-common/service-api/asmail/config';
+import { Request } from '../../resources/sessions';
+import { InboxParams } from '../../resources/inbox';
+
+export function setParam<P extends keyof InboxParams>(paramSetter: SetParam<P>): RequestHandler {
+	return async (req: Request, res, next) => {
+
+		const session = req.session;
+		const userId = session.params.userId;
+		const pValue: InboxParams[P] = 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 === recipSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send("Recipient disappeared from the system.");
+				session.close();
+			} else {
+				next(err);
+			}
+
+		}
+
+	};
+}

package/ts-code/asmail/routes/delivery/finalize-delivery.ts

@@ -0,0 +1,50 @@
+/*
+ Copyright (C) 2015 - 2016, 2025 - 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 recipSC, MsgDelivery } from '../../resources/recipients';
+import { Request } from '../../resources/delivery-sessions';
+import { completion as api, ERR_SC } from '../../../lib-common/service-api/asmail/delivery';
+
+export function finalizeDelivery(finDelivFunc: MsgDelivery['finalizeDelivery']): RequestHandler {
+	return async (req: Request, res, next) => {
+		const session = req.session;
+		const recipient = session.params.recipient;
+		const msgId = session.params.msgId;
+
+		try {
+			await finDelivFunc(recipient, msgId);
+			session.close();
+			res.status(api.SC.ok).send();
+		} catch (err) {
+			if ('string' !== typeof err) {
+				next(err);
+			} else if (err === recipSC.USER_UNKNOWN) {
+				session.close();
+				res.status(ERR_SC.server).send("Recipient disappeared from the system.");
+			} else if (err === recipSC.MSG_UNKNOWN) {
+				session.close();
+				res.status(ERR_SC.server).send("Message disappeared from the system.");
+			} else {
+				next(new Error("Unhandled storage error code: "+err));
+			}
+		}
+
+	};
+}
+
+Object.freeze(exports);

package/ts-code/asmail/routes/delivery/pre-flight.ts

@@ -0,0 +1,132 @@
+/*
+ Copyright (C) 2015 - 2017, 2025 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 { SC as recipSC, MsgDelivery } from '../../resources/recipients';
+import { preFlight as api, ERR_SC, ErrorReply } from '../../../lib-common/service-api/asmail/delivery';
+import { Request } from '../../resources/delivery-sessions';
+import { Redirect } from './start-session';
+import { checkAndTransformAddress } from '../../../lib-common/canonical-address';
+
+/**
+ * This creates a pre-flight route handler.
+ * @param allowedMsgSizeFunc is a function returning promises, that may resolve to
+ * (1) undefined, if recipient is unknown,
+ * (2) zero (0), if leaving mail is forbidden,
+ * (3) greater than zero maximum message length, and
+ * (4) -1, if mail cannot be accepted due to full mail box.
+ * @param redirectFunc is an optional function that returns a promise,
+ * resolvable to
+ * (1) string with URI for ASMail service, which is serving given recipient,
+ * (2) undefined, if it is this server should service given recipient. 
+ */
+export function preFlight(
+	allowedMsgSizeFunc: MsgDelivery['allowedMaxMsgSize'], redirectFunc?: Redirect
+): RequestHandler {
+		
+	async function serveRequestHere(
+		recipient: string, sender: string|undefined,
+		invitation: string|undefined, res: Response
+	): Promise<void> {
+		const msgSize = await allowedMsgSizeFunc(recipient, sender, invitation);
+		if (msgSize > 0) {
+			res.status(api.SC.ok).json( <api.Reply> {
+				maxMsgLength: msgSize
+			});
+		} else if (msgSize === 0) {
+			res.status(api.SC.senderNotAllowed).json( <ErrorReply> {
+				error: `${sender ? sender : "Anonymous sender "} is not allowed to leave mail for ${recipient}`
+			});
+		} else if (msgSize === -1) {
+			res.status(api.SC.inboxFull).json( <ErrorReply> {
+				error: `Mail box for ${recipient} is full.`
+			});
+		} else {
+			throw new Error(`Unrecognized code ${msgSize} for message size limits.`);
+		}
+	}
+
+	return async (req: Request, res, next) => {
+
+		const rb: api.Request = req.body;
+		const recipient = checkAndTransformAddress(rb.recipient);
+		let sender = rb.sender;
+		const invitation = rb.invitation;
+		const session = req.session;
+
+		// already existing session indicates repeated call, which should be bounced off
+		if (session) {
+			res.status(ERR_SC.duplicateReq).json( <ErrorReply> {
+				error: "This protocol request has already been served."
+			});
+			return;
+		}
+
+		// missing recipient makes a bad request
+		if (!recipient) {
+			res.status(ERR_SC.malformed).json( <ErrorReply> {
+				error: "Recipient is either missing in the request, or is malformed"
+			});
+			return;
+		}
+
+		// if sender is given, we canonicalize the address
+		if (sender) {
+			sender = checkAndTransformAddress(sender);
+			if (!sender) {
+				res.status(ERR_SC.malformed).json( <ErrorReply> {
+					error: "Sender field is malformed"
+				});
+				return;
+			}
+		}
+
+		// check invitation field
+		if ((invitation !== undefined) && (typeof invitation !== 'string')) {
+			res.status(ERR_SC.malformed).json( <ErrorReply> {
+				error: "Inviation field is malformed"
+			});
+			return;
+		}
+
+	 	try {
+			if (redirectFunc) {
+				const redirectTo = await redirectFunc(recipient);
+				if (redirectTo) {
+					res.status(api.SC.redirect).json(<api.RedirectReply> {
+						redirect: redirectTo
+					});
+				} else {
+					await serveRequestHere(recipient, sender, invitation, res);
+				}
+			} else {
+				await serveRequestHere(recipient, sender, invitation, res);
+			}
+		} catch (err) {
+			if (err === recipSC.USER_UNKNOWN) {
+				res.status(api.SC.unknownRecipient).json( <ErrorReply> {
+					error: `Recipient ${recipient} is unknown.`
+				});
+			} else {
+				next(err);
+			}
+		}
+
+	};
+}
+
+Object.freeze(exports);

package/ts-code/asmail/routes/delivery/provide-recipient-pubkey.ts

@@ -0,0 +1,58 @@
+/*
+ Copyright (C) 2015 - 2016, 2025 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 recipSC, MsgDelivery } from '../../resources/recipients';
+import { initPubKey as api, ERR_SC } from '../../../lib-common/service-api/asmail/delivery';
+import { Request } from '../../resources/delivery-sessions';
+
+/**
+ * This creates a get-init-pub-key route handler.
+ * @param pkeyProvidingFunc is a function that provides recipient's public key
+ * for use in this communication. 
+ */
+export function getRecipientPubKey(
+	pkeyProvidingFunc: MsgDelivery['getPubKey']
+): RequestHandler {
+	return async (req: Request, res, next) => {
+
+		const session = req.session;
+
+		try{
+			const certs = await pkeyProvidingFunc(session.params.recipient);
+			if (certs) {
+				res.status(api.SC.ok).json(certs);
+			} else {
+				res.status(api.SC.pkeyNotRegistered).send('No public key registered for the recipient.');
+				session.close();
+			}
+		} catch (err) {
+			if (typeof err !== "string") {
+				next(err);
+			} else if (err === recipSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send(
+					"Recipient disappeared from the system.");
+				session.close();
+			} else {
+				next(new Error("Unhandled storage error code: "+err));
+			}
+		}
+
+	};
+}
+
+Object.freeze(exports);

package/ts-code/asmail/routes/delivery/put-metadata.ts

@@ -0,0 +1,94 @@
+/*
+ Copyright (C) 2015 - 2016, 2025 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 recipSC, MsgDelivery } from '../../resources/recipients';
+import { msgMeta as api, ERR_SC, ErrorReply } from '../../../lib-common/service-api/asmail/delivery';
+import * as confUtil from '../../../lib-server/conf-util';
+import { Request } from '../../resources/delivery-sessions';
+import { base64urlSafe } from '../../../lib-common/buffer-utils';
+
+function findProblemWithObjIds(ids: string[]): ErrorReply|undefined {
+	if (!Array.isArray(ids)) {
+		return {
+			error: "Object ids are missing."
+		};
+	}
+	const checkedIds = new Set<string>();
+	for (const objId of ids) {
+		if (checkedIds.has(objId)) {
+			return {
+				error: "Duplication of object ids."
+			};
+		}
+		if (!base64urlSafe.allCharsFromAlphabet(objId!)) {
+			return {
+				error: "Object id is invalid."
+			};
+		}
+		checkedIds.add(objId);
+	}
+	return;
+}
+
+export function saveMetadata(
+	setMsgStorageFunc: MsgDelivery['setMsgStorage'], maxChunk: string|number
+): RequestHandler {
+
+	const maxChunkSize = confUtil.stringToNumOfBytes(maxChunk);
+
+	return async (req: Request, res, next) => {
+		const session = req.session;
+		const msgMeta: api.Request = req.body;
+		const recipient = session.params.recipient;
+		const objIds = msgMeta.objIds;
+
+		if (session.params.msgId) {
+			res.status(ERR_SC.duplicateReq).json( <ErrorReply> {
+				error: "This protocol request has already been served."
+			});
+			return;
+		}
+
+		if (findProblemWithObjIds(objIds)) {
+			res.status(ERR_SC.malformed).json(findProblemWithObjIds(objIds));
+			return;
+		}
+
+		try {
+			const msgId = await setMsgStorageFunc(recipient, msgMeta,
+				session.params.sender, session.params.invite,
+				session.params.maxMsgLength);
+			session.params.msgId = msgId;
+			res.status(api.SC.ok).json( <api.Reply> {
+				msgId,
+				maxChunkSize
+			});
+		} catch (err) {
+			if ("string" !== typeof err) {
+				next(err);
+			} else if (err === recipSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send(
+					"Recipient disappeared from the system.");
+				session.close();
+			}
+		}
+
+	};
+}
+
+Object.freeze(exports);

package/ts-code/asmail/routes/delivery/put-obj.ts

@@ -0,0 +1,166 @@
+/*
+ Copyright (C) 2015 - 2017, 2019 - 2020, 2025 - 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 { SC as recipSC, MsgDelivery, BIN_TYPE } from '../../resources/recipients';
+import { msgObj as api, ERR_SC, HTTP_HEADER, PutObjFirstQueryOpts, PutObjSecondQueryOpts } from '../../../lib-common/service-api/asmail/delivery';
+import * as confUtil from '../../../lib-server/conf-util';
+import { Request } from '../../resources/delivery-sessions';
+import { attachByteDrainToRequest } from '../../../lib-server/middleware/body-parsers';
+
+export function saveMsgObj(saveObjFunc: MsgDelivery['saveObj'], chunkLimit: string|number): RequestHandler {
+
+	const maxChunkSize = confUtil.stringToNumOfBytes(chunkLimit);
+
+	return async (req: Request, res, next) => {
+
+		if (!req.is(BIN_TYPE)) {
+			attachByteDrainToRequest(req);
+			res.status(ERR_SC.wrongContentType).send(
+				`Content-Type must be ${BIN_TYPE} for this call.`
+			);
+			return;
+		}
+
+		const session = req.session;
+		const recipient = session.params.recipient;
+		const msgId = session.params.msgId;
+
+		if (!msgId) {
+			res.status(ERR_SC.earlyReq).send(
+				"Metadata has not been sent, yet."
+			);
+			return;
+		}
+
+		const objId: string = req.params.objId;
+
+		// get and check Content-Length, implicitly sending replies for bad length
+		let len = getContentLenOrSendError(req, res, maxChunkSize);
+		if (len === undefined) {
+			attachByteDrainToRequest(req);
+			return;
+		}
+
+		// extract and check query parameters
+		const opts = extractQueryOptions(req);
+		if (!opts) {
+			return replyToMalformed(req, "Bad query parameters", res);
+		}
+
+		if (opts.fstReq) {
+			// check options versus chunk length
+			if (opts.fstReq.header > len) {
+				return replyToMalformed(req, "Bad query parameters", res);
+			}
+		} else if (opts.sndReq) {
+			// check options versus chunk length
+			if ((len === 0) && !opts.sndReq.last) {
+				return replyToMalformed(req, "No segment bytes", res);
+			}
+		} else {
+			return next(new Error(`This place should not be reachable`));
+		}
+
+		// ensure that it is ok space-wise to save additional bytes
+		const allowedSpace =
+			(session.params.maxMsgLength - session.params.currentMsgLength);
+		if (len <= allowedSpace) {
+			session.params.currentMsgLength += len;
+		} else {
+			res.status(ERR_SC.contentTooLong).send(
+				"This request goes over the message limit."
+			);
+			return;
+		}
+
+		try {
+			await saveObjFunc(recipient, msgId, objId, opts.fstReq, opts.sndReq, len, req);
+			res.status(api.SC.ok).send();
+		} catch (err) {
+			session.params.currentMsgLength -= len;
+			if ("string" !== typeof err) {
+				next(err);
+			} else if (err === recipSC.USER_UNKNOWN) {
+				res.status(ERR_SC.server).send("Recipient disappeared from the system.");
+				session.close();
+			} else if (err === recipSC.OBJ_EXIST) {
+				res.status(api.SC.objAlreadyExists).send(`Object ${objId} already exists.`);
+			} else if (err === recipSC.MSG_UNKNOWN) {
+				res.status(ERR_SC.server).send("Message disappeared from the system.");
+				session.close();
+			} else if (err === recipSC.OBJ_UNKNOWN) {
+				res.status(api.SC.unknownObj).send(`Object ${objId} is unknown.`);
+			} else if (err === recipSC.WRONG_OBJ_STATE) {
+				res.status(ERR_SC.malformed).send(`Object ${objId} is not in a different state.`);
+			} else if (err === recipSC.OBJ_FILE_INCOMPLETE) {
+				res.status(ERR_SC.objIncomplete).send(`Object ${objId} is not complete.`);
+			} else {
+				next(new Error(`Unhandled storage error code: ${err}`));
+			}
+		}
+	};
+}
+
+function extractQueryOptions(req: Request): undefined|{
+	fstReq?: PutObjFirstQueryOpts; sndReq?: PutObjSecondQueryOpts;
+} {
+	if ((req.query as any as PutObjFirstQueryOpts).header) {
+		// 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 header = parseInt(query.header as any);
+		if (isNaN(header) || (header < 1)) { return; }
+
+		const last = ((query.last as any) === 'true');
+
+		return { fstReq: { header, last } };
+
+	} else {
+		// 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 last = ((query.last as any) === 'true');
+
+		const ofs = parseInt(query.ofs as any);
+		if (isNaN(ofs) || (ofs < 0)) { return; }
+
+		return { sndReq: { ofs, last } };
+
+	}
+}
+
+function getContentLenOrSendError(req: Request, res: Response, maxChunkSize: number): number|undefined {
+	const contentLength = parseInt(req.get(HTTP_HEADER.contentLength)!);
+	if (isNaN(contentLength)) {
+		res.status(ERR_SC.contentLenMissing).send("Content-Length header is required with proper number.");
+	} else if (contentLength > maxChunkSize) {
+		res.status(ERR_SC.contentTooLong).send("Request body is too long.");
+	} else {
+		return contentLength;
+	}
+	return;
+}
+
+function replyToMalformed(req: Request, msg: string, res: Response): void {
+	attachByteDrainToRequest(req);
+	res.status(ERR_SC.malformed).send(msg);
+}
+
+Object.freeze(exports);

package/ts-code/asmail/routes/delivery/restart-session.ts

@@ -0,0 +1,130 @@
+/*
+ Copyright (C) 2017, 2025 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 { SC as recipSC, MsgDelivery } from '../../resources/recipients';
+import { sessionRestart as api, ERR_SC, ErrorReply } from '../../../lib-common/service-api/asmail/delivery';
+import { Request, GenerateSession, GetSessionForMsg } from '../../resources/delivery-sessions';
+import { Redirect } from './start-session';
+import { checkAndTransformAddress } from '../../../lib-common/canonical-address';
+import * as confUtil from '../../../lib-server/conf-util';
+
+/**
+ * This creates a session restart route handler.
+ * @param sessionGenFunc is a promise returning function that generates new
+ * session objects.
+ * @param sessionForMsgFunc is a function that promises existing session for
+ * a known message in delivery.
+ * @param incompleteMsgFunc is a function that promises parameters of a message
+ * that is still in delivery.
+ * @param redirectFunc is an optional function that returns a promise,
+ * resolvable to
+ * (1) string with URI for ASMail service, which is serving given recipient,
+ * (2) undefined, if it is this server should service given recipient. 
+ */
+export function restartSession(
+	sessionGenFunc: GenerateSession,sessionForMsgFunc: GetSessionForMsg,
+	incompleteMsgFunc: MsgDelivery['incompleteMsgDeliveryParams'],
+	maxChunk: string|number, redirectFunc?: Redirect
+): RequestHandler {
+
+	const maxChunkSize = confUtil.stringToNumOfBytes(maxChunk);
+
+	async function serveRequestHere(
+		recipient: string, msgId: string, res: Response
+	): Promise<void> {
+		let session = await sessionForMsgFunc(recipient, msgId);
+		if (!session) {
+			const msgParams = await incompleteMsgFunc(recipient, msgId);
+			session = await sessionGenFunc();
+			session.isAuthorized = true;
+			session.params.recipient = recipient;
+			session.params.msgId = msgId;
+			session.params.currentMsgLength = msgParams.currentMsgLength;
+			session.params.maxMsgLength = msgParams.maxMsgLength;
+		}
+		res.status(api.SC.ok).json( <api.Reply> {
+			maxMsgLength: session.params.maxMsgLength,
+			sessionId: session.id,
+			maxChunkSize
+		});
+	}
+
+	return async (req: Request, res, next) => {
+
+		const rb: api.Request = req.body;
+		const recipient = checkAndTransformAddress(rb.recipient);
+		const msgId = rb.msgId;
+		const session = req.session;
+
+		// session is opened, and is even mentioned in a header
+		if (session) {
+			res.status(api.SC.ok).json( <api.Reply> {
+				maxMsgLength: session.params.maxMsgLength,
+				sessionId: session.id,
+				maxChunkSize
+			});
+			return;
+		}
+
+		// missing recipient makes a bad request
+		if (!recipient) {
+			res.status(ERR_SC.malformed).json( <ErrorReply> {
+				error: "Recipient is either missing in the request, or is malformed"
+			});
+			return;
+		}
+
+		// check message id
+		if (typeof msgId !== 'string') {
+			res.status(ERR_SC.malformed).json( <ErrorReply> {
+				error: "Message id is either missing, or is malformed"
+			});
+			return;
+		}
+
+	 	try {
+			if (redirectFunc) {
+				const redirectTo = await redirectFunc(recipient);
+				if (redirectTo) {
+					res.status(api.SC.redirect).json(<api.RedirectReply> {
+						redirect: redirectTo
+					});
+				} else {
+					await serveRequestHere(recipient, msgId, res);
+				}
+			} else {
+				await serveRequestHere(recipient, msgId, res);
+			}
+		} catch (err) {
+			if (err === recipSC.USER_UNKNOWN) {
+				res.status(api.SC.unknownRecipient).json( <ErrorReply> {
+					error: `Recipient ${recipient} is unknown.`
+				});
+			} else if (err === recipSC.MSG_UNKNOWN) {
+				res.status(api.SC.unknownMsg).json( <ErrorReply> {
+					error: `Recipient ${recipient} is unknown.`
+				});
+			} else {
+				next(err);
+			}
+		}
+
+	};
+}
+
+Object.freeze(exports);