Run Jasmin in both directions: message_payload, data_sm and a multipart deadlock confirmed against a production gateway

2026-09-06 02:24:32 +02:00
parent db02f0058d
commit 66b49ebfb3
7 changed files with 1858 additions and 1 deletions
@@ -0,0 +1,705 @@
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import test, { after, describe } from 'node:test';
+import type { Dlr } from '../src/dlr.ts';
+import type { EncodingName } from '../src/defs/encodings.ts';
+import type { PduObject } from '../src/pdu.ts';
+import type { Session } from '../src/session.ts';
+import type { Sms } from '../src/sms.ts';
+import { ConcatReference } from '../src/udh.ts';
+import { client } from '../src/client.ts';
+import { closeAfter } from '../test/teardown.ts';
+import { paramText } from '../src/defs/types.ts';
+import { server } from '../src/server.ts';
+import { splitMessage } from '../src/message.ts';
+import { submitSmParams } from '../src/send-sms.ts';
+
+const PEER_HOST = process.env.PEER_HOST ?? 'jasmin';
+const PEER_PORT = Number(process.env.PEER_PORT ?? '2775');
+const DATASM_HOST = process.env.DATASM_HOST ?? 'jasmin-datasm';
+const HTTP_API_HOST = process.env.HTTP_API_HOST ?? 'jasmin';
+const HTTP_API_PORT = Number(process.env.HTTP_API_PORT ?? '1401');
+const UPSTREAM_PORT = Number(process.env.UPSTREAM_PORT ?? '2777');
+const CALLBACK_PORT = Number(process.env.CALLBACK_PORT ?? '8080');
+
+const USERNAME = 'esme1';
+const PASSWORD = 'esme1pw';
+const THROTTLED_USERNAME = 'esme2';
+const THROTTLED_PASSWORD = 'esme2pw';
+const UPSTREAM_USERNAME = 'upstreamesme';
+const UPSTREAM_DATASM_USERNAME = 'upstreamdsesme';
+const FROM = '46701113311';
+const TO = '46709771337';
+
+function delay(ms: number): Promise<void> {
+	return new Promise(resolve => { setTimeout(resolve, ms); });
+}
+
+/** Polls until `get()` stops returning undefined, or the budget runs out. */
+async function waitFor<T>(get: () => T | undefined, budget = 8000): Promise<T | undefined> {
+	const deadline = Date.now() + budget;
+	let value = get();
+
+	while (value === undefined && Date.now() < deadline) {
+		await delay(20);
+		value = get();
+	}
+
+	return value;
+}
+
+async function bind(username: string, password: string, options: Parameters<typeof client>[0] = {}): ReturnType<typeof client> {
+	return client({ host: PEER_HOST, password, port: PEER_PORT, username, ...options });
+}
+
+// --- Shared infra: the fake upstream real-world SMSC that Jasmin's own smppc connector(s) bind
+// out to (host `node`, port UPSTREAM_PORT - Jasmin resolves `node` via --use-aliases), and the HTTP
+// listener that receives Jasmin's DLR-thrower webhook (S7). Both are wired once for the whole file,
+// mirroring kannel.test.ts's shared-infra shape - every Jasmin variant dials in from container
+// start, independent of when a given test runs. ---
+
+type UpstreamVariant = 'datasm' | 'main';
+
+const upstreamSessions = new Map<UpstreamVariant, Session>();
+const upstreamSms: { sms: Sms; variant: UpstreamVariant }[] = [];
+
+function variantFromSystemId(systemId: string): UpstreamVariant | undefined {
+	if (systemId === UPSTREAM_USERNAME) return 'main';
+	if (systemId === UPSTREAM_DATASM_USERNAME) return 'datasm';
+
+	return undefined;
+}
+
+const { err: upstreamErr, server: upstream } = await server({
+	authenticate: ({ password, systemId }) => {
+		// <=8 chars: Jasmin's own bind-PDU encoder enforces SMPP's 8-char password maximum strictly
+		// (see bootstrap.py) - a longer one made every single connector bind attempt throw.
+		if (password !== 'upstrmpw') return false;
+
+		const variant = variantFromSystemId(systemId);
+
+		return variant ? { userData: { variant } } : false;
+	},
+	// Jasmin's connector sends enquire_link every elink_interval (30s); this host's own contention
+	// (rabbitmq/redis under load) sometimes delays it past our server's 40s default idleTimeout,
+	// dropping the one long-lived connector session. A dropped connection strands whatever submit_sm
+	// was already in flight for Jasmin's own requeue_delay (120s default) before it retries - far past
+	// any per-test wait budget here - so this is generous specifically to never be the trigger.
+	idleTimeout: 300_000,
+	port: UPSTREAM_PORT,
+});
+
+assert.equal(upstreamErr, undefined);
+assert.ok(upstream);
+
+const upstreamServer = upstream;
+
+upstreamServer.on('session', session => {
+	// `session` fires on raw connect, before authenticate() has run - session.userData is not set
+	// yet, so the map is populated off the bind PDU itself (like kannel.test.ts's bindPdus), not off
+	// userData; userData is only read later, from 'sms', where authenticate() has long since run.
+	session.on('incomingPduObj', pduObj => {
+		if (!pduObj.cmdName.startsWith('bind_')) return;
+
+		const variant = variantFromSystemId(paramText(pduObj.params.system_id));
+
+		if (variant) upstreamSessions.set(variant, session);
+	});
+
+	session.on('sms', sms => {
+		const variant = (session.userData as { variant?: UpstreamVariant } | undefined)?.variant;
+
+		if (variant) upstreamSms.push({ sms, variant });
+
+		void (async () => {
+			await sms.sendResp();
+
+			if (sms.dlr) {
+				await delay(150);
+				await sms.sendDlr('DELIVERED');
+			}
+		})();
+	});
+});
+
+async function waitForUpstreamSession(variant: UpstreamVariant, budget = 20_000): Promise<Session> {
+	const found = await waitFor(() => upstreamSessions.get(variant), budget);
+
+	assert.ok(found, `Jasmin's ${variant} connector never bound to our fake upstream within ${String(budget)}ms`);
+
+	return found;
+}
+
+type DlrCallback = { id: string; messageStatus: string };
+
+const dlrCallbacks: DlrCallback[] = [];
+
+const httpServer = http.createServer((req, res) => {
+	const url = new URL(req.url ?? '/', 'http://node');
+
+	if (url.pathname === '/dlr') {
+		dlrCallbacks.push({
+			id: url.searchParams.get('id') ?? '',
+			messageStatus: url.searchParams.get('message_status') ?? '',
+		});
+		res.writeHead(200);
+		res.end();
+
+		return;
+	}
+
+	res.writeHead(404);
+	res.end();
+});
+
+await new Promise<void>(resolve => { httpServer.listen(CALLBACK_PORT, resolve); });
+
+after(async () => {
+	await upstreamServer.close();
+	await new Promise<void>(resolve => { httpServer.close(() => { resolve(); }); });
+});
+
+/** dlr-level 1 (SMSC-ack) fires once, immediately, with message_status ESME_ROK - not a terminal
+ * state - so a caller after the final DELIVRD needs dlr-level 3 (both) and its own status filter. */
+async function waitForDlrCallback(id: string, status: string, budget = 15_000): Promise<DlrCallback> {
+	const found = await waitFor(() => dlrCallbacks.find(callback => callback.id === id && callback.messageStatus === status), budget);
+
+	assert.ok(found, `no dlr callback for id=${id} status=${status} arrived (seen: ${JSON.stringify(dlrCallbacks)})`);
+
+	return found;
+}
+
+/** Jasmin's HTTP send API (`/send`): `to` must be digits only, `content` is the message body. */
+async function httpSend(params: Record<string, string>): Promise<{ body: string; status: number }> {
+	const url = new URL(`http://${HTTP_API_HOST}:${String(HTTP_API_PORT)}/send`);
+
+	url.search = new URLSearchParams({ password: PASSWORD, username: USERNAME, ...params }).toString();
+
+	const response = await fetch(url, { method: 'POST' });
+	const body = await response.text();
+
+	return { body, status: response.status };
+}
+
+const sarReference = new ConcatReference();
+
+/** Splits into SAR segments: `splitMessage()`'s own encoding/chunking, its UDH stripped back off. */
+function sarPayloads(message: string, encoding?: EncodingName): Buffer[] {
+	const reference = sarReference.next();
+	const segments = splitMessage(message, encoding === undefined ? { reference } : { encoding, reference });
+
+	return segments.length > 1 ? segments.map(segment => segment.subarray(6)) : segments;
+}
+
+/** Pushes a long MO into Jasmin over `session` (Jasmin's smppc connector bound to us) as
+ * `sar_msg_ref_num`/`sar_total_segments`/`sar_segment_seqnum` segments - Jasmin's own documented
+ * default MT segmentation (target 3). */
+async function sendSarMo(session: Session, opts: { from: string; message: string; to: string }): Promise<void> {
+	const payloads = sarPayloads(opts.message);
+	const refNum = sarReference.next();
+
+	for (const [index, payload] of payloads.entries()) {
+		const sent = await session.send({
+			cmdName: 'deliver_sm',
+			params: {
+				destination_addr: opts.to,
+				short_message: payload,
+				source_addr: opts.from,
+			},
+			tlvs: {
+				sar_msg_ref_num: { tagValue: refNum },
+				sar_segment_seqnum: { tagValue: index + 1 },
+				sar_total_segments: { tagValue: payloads.length },
+			},
+		});
+
+		assert.equal(sent.err, undefined);
+		assert.ok(sent.pduObj);
+		assert.equal(sent.pduObj.cmdStatus, 'ESME_ROK');
+	}
+}
+
+/** As `sendSarMo`, but UDH concatenation (esm_class 0x40) - the same shape `sendSms()` emits, and
+ * Jasmin's documented "older system compatibility" alternative. */
+async function sendUdhMo(session: Session, opts: { from: string; message: string; to: string }): Promise<void> {
+	const reference = sarReference.next();
+	const segments = splitMessage(opts.message, { reference });
+	const multipart = segments.length > 1;
+
+	for (const segment of segments) {
+		const params = submitSmParams({ from: opts.from, message: opts.message, to: opts.to }, segment, { encoding: 'ASCII', multipart });
+		const sent = await session.send({ cmdName: 'deliver_sm', params });
+
+		assert.equal(sent.err, undefined);
+		assert.ok(sent.pduObj);
+		assert.equal(sent.pduObj.cmdStatus, 'ESME_ROK');
+	}
+}
+
+/** A `deliver_sm` with `sm_length` 0 and the body in `message_payload` (target 2). */
+async function sendMessagePayloadMo(session: Session, opts: { from: string; message: string; to: string }): ReturnType<Session['send']> {
+	return session.send({
+		cmdName: 'deliver_sm',
+		params: {
+			destination_addr: opts.to,
+			short_message: Buffer.alloc(0),
+			source_addr: opts.from,
+		},
+		tlvs: {
+			message_payload: { tagValue: Buffer.from(opts.message, 'latin1') },
+		},
+	});
+}
+
+describe('C1 - bind, enquire_link, unbind', () => {
+	test('binds transceiver, sees Jasmin\'s own enquire_link, unbinds clean', async () => {
+		// Jasmin's own enquireLinkTimerSecs (30) is an idle timer, not a strict period: our client's
+		// own default 20s keepalive counts as activity and resets it, so Jasmin's probe never has a
+		// chance to fire on its own. Disabling ours (and widening idleTimeout, which defaults off
+		// enquireLinkInterval and would otherwise become 0) leaves the link quiet long enough to see it.
+		const { err, session } = await bind(USERNAME, PASSWORD, { enquireLinkInterval: 0, idleTimeout: 60_000 });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+
+		const incoming: PduObject[] = [];
+		const closes: true[] = [];
+		const sessionErrors: Error[] = [];
+
+		session.on('incomingPduObj', pduObj => { incoming.push(pduObj); });
+		session.on('close', () => { closes.push(true); });
+		session.on('sessionError', sessionError => { sessionErrors.push(sessionError); });
+
+		// enquireLinkTimerSecs is 30 in Jasmin's default [smpp-server] config.
+		const theirs = await waitFor(() => incoming.find(pduObj => pduObj.cmdName === 'enquire_link'), 35_000);
+
+		assert.ok(theirs, 'expected Jasmin to send its own enquire_link within 35s');
+
+		const ours = await session.send({ cmdName: 'enquire_link' });
+
+		assert.equal(ours.err, undefined);
+		assert.ok(ours.pduObj);
+		assert.equal(ours.pduObj.cmdStatus, 'ESME_ROK');
+
+		const unbound = await session.unbind();
+
+		assert.equal(unbound.err, undefined);
+		assert.ok(await waitFor(() => (closes.length > 0 ? true : undefined), 5000), 'expected a clean close after unbind');
+		assert.deepEqual(sessionErrors, []);
+	});
+
+	test('binds transmitter', async t => {
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'transmitter' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+		assert.equal(session.boundAs, 'transmitter');
+	});
+
+	test('binds receiver', async t => {
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'receiver' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+		assert.equal(session.boundAs, 'receiver');
+	});
+});
+
+describe('C13 - maxOutstanding 1 with 10 parallel sends', () => {
+	test('every send is answered, none lost, order preserved at the fake upstream', async t => {
+		await waitForUpstreamSession('main');
+
+		const { err, session } = await bind(USERNAME, PASSWORD, { maxOutstanding: 1 });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		const before = upstreamSms.length;
+		const texts = Array.from({ length: 10 }, (_, i) => `c13-order-${String(i).padStart(2, '0')}`);
+
+		const results = await Promise.all(texts.map(async message => session.sendSms({ from: FROM, message, to: TO })));
+
+		const ids: string[] = [];
+
+		for (const result of results) {
+			assert.equal(result.err, undefined);
+			assert.equal(result.smsIds.length, 1);
+
+			const [smsId] = result.smsIds;
+
+			assert.ok(smsId);
+			ids.push(smsId);
+		}
+
+		assert.equal(new Set(ids).size, ids.length, 'expected 10 distinct message ids, none lost or duplicated');
+
+		const arrivedOrder = await waitFor(() => {
+			const seen = upstreamSms.slice(before).filter(e => e.variant === 'main').map(e => e.sms.message);
+
+			return texts.every(text => seen.includes(text)) ? seen : undefined;
+		}, 60_000);
+
+		assert.ok(arrivedOrder, 'not all 10 messages reached the fake upstream');
+
+		const ordered = arrivedOrder.filter(m => texts.includes(m));
+
+		assert.deepEqual(ordered, texts, 'maxOutstanding:1 should serialise sends end to end, in order');
+	});
+});
+
+describe('S7 - Jasmin as the ESME against our server (HTTP send API, DLR callback)', () => {
+	test('a message pushed through /send arrives as submit_sm at our server; our receipt fires Jasmin\'s DLR webhook', async () => {
+		const before = upstreamSms.length;
+		// No printf-style placeholders (unlike Kannel's %d/%F): DLRThrower appends its own fixed
+		// query args - id, level, message_status, connector - to this bare URL (confirmed from
+		// jasmin/routing/throwers.py). dlr-method=get puts them in the query string; POST (Jasmin's
+		// own default) would need a form-body reader instead.
+		const dlrUrl = `http://node:${String(CALLBACK_PORT)}/dlr`;
+
+		const sent = await httpSend({
+			content: 's7 http send test',
+			dlr: 'yes',
+			// Level 3 (both): level 1 alone fires once, immediately, with message_status ESME_ROK -
+			// the SMSC-ack, not a terminal state - so proving Jasmin parses our own receipt needs the
+			// terminal-level callback too, which only follows the sendDlr('DELIVERED') below.
+			'dlr-level': '3',
+			'dlr-method': 'get',
+			'dlr-url': dlrUrl,
+			from: FROM,
+			to: TO,
+		});
+
+		assert.match(sent.body, /Success/i);
+
+		const arrived = await waitFor(() => upstreamSms.slice(before).find(e => e.variant === 'main' && e.sms.message === 's7 http send test'), 60_000);
+
+		assert.ok(arrived, 'expected the HTTP-submitted message to arrive as submit_sm at our server()');
+
+		// Our server() already answered (sendResp) and sent the DLR (sendDlr('DELIVERED')) from the
+		// shared session handler above - Jasmin's own DLR pipeline should throw the HTTP callback.
+		const msgidMatch = /Success "([^"]+)"/i.exec(sent.body);
+		const msgid = msgidMatch?.[1];
+
+		assert.ok(msgid, `expected /send's response to carry a message id: ${sent.body}`);
+
+		const ack = await waitForDlrCallback(msgid, 'ESME_ROK', 15_000);
+
+		assert.equal(ack.id, msgid);
+
+		const final = await waitForDlrCallback(msgid, 'DELIVRD', 15_000);
+
+		assert.equal(final.id, msgid);
+	});
+
+	test('a long GSM message from our server reassembles at Jasmin (or is recorded as fragments)', async () => {
+		const upstreamSession = await waitForUpstreamSession('main');
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'receiver' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+
+		const sms: Sms[] = [];
+
+		session.on('sms', s => { sms.push(s); });
+
+		const text = `s7-long-${'p'.repeat(300)}`;
+
+		await sendUdhMo(upstreamSession, { from: TO, message: text, to: FROM });
+
+		const whole = await waitFor(() => sms.find(s => s.message === text), 10_000);
+
+		await session.close({ signal: AbortSignal.abort() });
+		assert.ok(whole ?? sms.length > 0, 'expected the long message to arrive whole or as recorded fragments');
+	});
+
+	test('a UCS-2 message with 一 and an emoji from our server (or is recorded as fragments)', async () => {
+		const upstreamSession = await waitForUpstreamSession('main');
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'receiver' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+
+		const sms: Sms[] = [];
+
+		session.on('sms', s => { sms.push(s); });
+
+		const text = `一😀${'q'.repeat(60)}`;
+
+		await sendSarMo(upstreamSession, { from: TO, message: text, to: FROM });
+
+		const whole = await waitFor(() => sms.find(s => s.message === text), 10_000);
+
+		await session.close({ signal: AbortSignal.abort() });
+		assert.ok(whole ?? sms.length > 0, 'expected the UCS-2 message to arrive whole or as recorded fragments');
+	});
+});
+describe('C3+C7 - long MT through the fake upstream, receipts and id consistency', () => {
+	const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}(-\d+)?$/i;
+
+	const cases: { encoding?: 'UCS2'; expectedSegments: number; label: string; message: string }[] = [
+		{ expectedSegments: 1, label: 'single-segment GSM with extension chars', message: '€[]~single segment' },
+		{ expectedSegments: 2, label: '2-segment GSM with extension chars', message: `€[]~${'g'.repeat(200)}` },
+		{ expectedSegments: 3, label: '3-segment GSM with extension chars', message: `€[]~${'g'.repeat(400)}` },
+		{ expectedSegments: 10, label: '10-segment GSM with extension chars', message: `€[]~${'g'.repeat(1450)}` },
+		{ encoding: 'UCS2', expectedSegments: 2, label: '2-segment UCS2 with 一 and an emoji', message: `一😀${'x'.repeat(70)}` },
+	];
+
+	for (const testCase of cases) {
+		test(testCase.label, async t => {
+			await waitForUpstreamSession('main');
+
+			const { err, session } = await bind(USERNAME, PASSWORD);
+
+			assert.equal(err, undefined);
+			assert.ok(session);
+			closeAfter(t, session);
+
+			const dlrs: { dlr: Dlr; pduObj: PduObject }[] = [];
+			const messageDlrs: unknown[] = [];
+
+			session.on('dlr', (dlr, pduObj) => { dlrs.push({ dlr, pduObj }); });
+			session.on('messageDlr', merged => { messageDlrs.push(merged); });
+
+			const sent = await session.sendSms({
+				dlr: true,
+				from: FROM,
+				message: testCase.message,
+				to: TO,
+				...(testCase.encoding ? { encoding: testCase.encoding } : {}),
+			});
+
+			assert.equal(sent.err, undefined);
+			assert.equal(sent.smsIds.length, testCase.expectedSegments);
+
+			for (const id of sent.smsIds) {
+				assert.match(id, uuidPattern, 'expected a UUID-shaped message id from Jasmin\'s submit_sm_resp');
+
+				// The full round trip - submit_sm to Jasmin's smpps, mtrouter, AMQP, the connector bind,
+				// our fake upstream's ack+DLR, AMQP again, DLRLookup, deliver_sm back - is slower than a
+				// single-segment send's, and visibly so under load; a generous budget beats a flaky one.
+				const received = await waitFor(() => dlrs.find(r => r.dlr.smsId === id), 25_000);
+
+				assert.ok(received, `no receipt for id ${id}`);
+				assert.equal(received.dlr.statusMsg, 'DELIVERED');
+			}
+
+			// Jasmin relays each segment as its own independent submit_sm to the connector (no MT-side
+			// UDH reassembly observed here - see findings), so the ids Jasmin hands back are whatever
+			// the fake upstream's own server() assigned per segment of ITS OWN reassembled view. That
+			// is this library's own <base>-<n> convention on both ends of this harness, which is why
+			// messageDlr can fire here - not evidence of Jasmin producing that convention itself; see
+			// findings/03-jasmin.md for what a real, independent upstream SMSC would hand back instead.
+			void messageDlrs;
+		});
+	}
+});
+
+describe('C8 (target 3) - long MO from an upstream SMSC, SAR vs UDH segmentation', () => {
+	test('SAR-segmented deliver_sm from the fake upstream', async () => {
+		const upstreamSession = await waitForUpstreamSession('main');
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'receiver' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+
+		const sms: Sms[] = [];
+
+		session.on('sms', s => { sms.push(s); });
+
+		const text = `sar-mo-${'m'.repeat(300)}`;
+
+		await sendSarMo(upstreamSession, { from: TO, message: text, to: FROM });
+
+		// Recorded either way, per the task: one whole `sms` (Jasmin reassembled the SAR segments
+		// before forwarding) or several fragments (it relayed them, and our SAR-blind reassembler -
+		// keyed on UDH only - never groups them; see findings for which happened and the reproducer).
+		const whole = await waitFor(() => sms.find(s => s.message === text), 10_000);
+		const fragments = sms.filter(s => text.includes(s.message) && s.message !== '');
+
+		await session.close({ signal: AbortSignal.abort() });
+
+		assert.ok(whole ?? fragments.length > 0, 'expected either a reassembled sms or SAR fragments to arrive');
+	});
+
+	test('UDH-segmented deliver_sm from the fake upstream', async () => {
+		const upstreamSession = await waitForUpstreamSession('main');
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'receiver' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+
+		const sms: Sms[] = [];
+
+		session.on('sms', s => { sms.push(s); });
+
+		const text = `udh-mo-${'n'.repeat(300)}`;
+
+		await sendUdhMo(upstreamSession, { from: TO, message: text, to: FROM });
+
+		const whole = await waitFor(() => sms.find(s => s.message === text), 10_000);
+		const fragments = sms.filter(s => text.includes(s.message) && s.message !== '');
+
+		await session.close({ signal: AbortSignal.abort() });
+
+		assert.ok(whole ?? fragments.length > 0, 'expected either a reassembled sms or UDH fragments to arrive');
+	});
+});
+
+describe('C8 (target 2) - message_payload with sm_length 0', () => {
+	test('a deliver_sm carrying message_payload instead of short_message', async () => {
+		const upstreamSession = await waitForUpstreamSession('main');
+		const { err, session } = await bind(USERNAME, PASSWORD, { bindType: 'receiver' });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+
+		const sms: Sms[] = [];
+
+		session.on('sms', s => { sms.push(s); });
+
+		const text = 'message-payload only, sm_length 0';
+		const pushed = await sendMessagePayloadMo(upstreamSession, { from: TO, message: text, to: FROM });
+
+		assert.equal(pushed.err, undefined, 'expected Jasmin to accept a message_payload-only deliver_sm from its connector');
+
+		const arrived = await waitFor(() => sms.find(s => s.message === ''), 5000);
+
+		await session.close({ signal: AbortSignal.abort() });
+
+		// Confirmed (target 2): Jasmin relays message_payload faithfully (sm_length 0, the real text
+		// in the TLV) - our own incoming-requests.ts reads short_message only, so the sms that arrives
+		// here has the right envelope (from/to) but an empty message, never the text carried in the
+		// TLV. See findings/03-jasmin.md for the reproducer.
+		assert.ok(arrived, 'expected an sms to arrive (with an empty message, per target 2) for the message_payload push');
+	});
+});
+
+describe('C9 (target 4) - DLR as data_sm against the jasmin-datasm instance', () => {
+	test('a receipt thrown as data_sm is not read as a dlr; the raw PDU still arrives', async t => {
+		await waitForUpstreamSession('datasm');
+
+		const { err, session } = await client({ host: DATASM_HOST, password: PASSWORD, port: PEER_PORT, username: USERNAME });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		const dlrs: Dlr[] = [];
+		const incomingDataSm: PduObject[] = [];
+
+		session.on('dlr', dlr => { dlrs.push(dlr); });
+		session.on('incomingPduObj', pduObj => { if (pduObj.cmdName === 'data_sm') incomingDataSm.push(pduObj); });
+
+		const sent = await session.sendSms({ dlr: true, from: FROM, message: 'data_sm dlr test', to: TO });
+
+		assert.equal(sent.err, undefined);
+
+		const arrived = await waitFor(() => incomingDataSm[0], 15_000);
+
+		assert.ok(arrived, 'expected Jasmin to throw the receipt as data_sm (dlr_pdu = data_sm)');
+
+		await delay(2000);
+		assert.deepEqual(dlrs, [], 'data_sm is answered ESME_RINVCMDID and never reaches the dlr event (target 4)');
+	});
+});
+
+describe('C11 - bind refusal and reconnect backoff', () => {
+	test('wrong password: one attempt, no retry', async () => {
+		const refusals: { cmdStatus: unknown }[] = [];
+		const log = {
+			debug: () => undefined,
+			error: () => undefined,
+			info: (msg: string, metadata?: Record<string, boolean | number | string>) => {
+				if (msg === 'client - bind refused') refusals.push({ cmdStatus: metadata?.cmdStatus });
+			},
+			verbose: () => undefined,
+			warn: () => undefined,
+		};
+
+		const { err, session } = await bind(USERNAME, 'wrong-password', { log, reconnect: { maxDelay: 4000, minDelay: 1000 } });
+
+		assert.ok(err);
+		assert.equal(session, undefined);
+		await delay(2000);
+		assert.equal(refusals.length, 1, 'expected exactly one bind attempt, never a retry');
+		assert.equal(refusals[0]?.cmdStatus, 'ESME_RINVPASWD');
+	});
+
+	test('a rebind refused after a live link drops: backs off, never floods', async t => {
+		const options: Parameters<typeof client>[0] = {
+			host: PEER_HOST,
+			password: PASSWORD,
+			port: PEER_PORT,
+			reconnect: { maxDelay: 4000, minDelay: 1000 },
+			username: USERNAME,
+		};
+		const { err, session } = await client(options);
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		const disconnectedAt: number[] = [];
+
+		session.on('disconnected', () => { disconnectedAt.push(Date.now()); });
+		options.password = 'wrong-after-drop';
+		session.sock.destroy();
+
+		await delay(12_000);
+
+		assert.ok(disconnectedAt.length >= 2 && disconnectedAt.length <= 8, `expected a handful of attempts, got ${String(disconnectedAt.length)}`);
+
+		for (let i = 1; i < disconnectedAt.length; i++) {
+			const previous = disconnectedAt[i - 1];
+			const current = disconnectedAt[i];
+
+			assert.ok(previous !== undefined && current !== undefined);
+			assert.ok(current - previous >= 150, 'expected each retry to wait at least close to minDelay');
+		}
+	});
+});
+
+describe('C12 - throttling (esme2\'s smpps_throughput quota)', () => {
+	test('flooding submits past the quota gets an err naming the status; the session stays bound; a later send works', async t => {
+		await waitForUpstreamSession('main');
+
+		const { err, session } = await bind(THROTTLED_USERNAME, THROTTLED_PASSWORD, { maxOutstanding: 20 });
+
+		assert.equal(err, undefined);
+		assert.ok(session);
+		closeAfter(t, session);
+
+		const results = await Promise.all(
+			Array.from({ length: 15 }, async (_unused, index) => session.sendSms({ from: FROM, message: `throttle-${String(index)}`, to: TO })),
+		);
+
+		const refused = results.filter(r => r.err !== undefined);
+
+		assert.ok(refused.length > 0, 'expected the 0.1/s quota to refuse at least one of 15 parallel sends');
+		assert.match(refused[0]?.err?.message ?? '', /ESME_RTHROTTLED/);
+
+		const keepalive = await session.send({ cmdName: 'enquire_link' });
+
+		assert.equal(keepalive.err, undefined);
+		assert.ok(keepalive.pduObj);
+		assert.equal(keepalive.pduObj.cmdStatus, 'ESME_ROK');
+
+		// 0.1/s is one slot every 10s, so a single fixed delay is either wasteful or flaky - polling
+		// finds the next open slot instead of guessing it.
+		const deadline = Date.now() + 25_000;
+		let later: Awaited<ReturnType<typeof session.sendSms>> | undefined;
+
+		while (!later && Date.now() < deadline) {
+			const attempt = await session.sendSms({ from: FROM, message: 'after the burst', to: TO });
+
+			if (!attempt.err) later = attempt;
+			else await delay(500);
+		}
+
+		assert.ok(later, 'expected a later send to succeed once the quota\'s next slot opened');
+	});
+});
+