@sirena-lwm2m/coap 0.8.0

package/examples/slice-3-psk.ts

@@ -0,0 +1,70 @@
+import tls from 'node:tls';
+import { createServer, Response, stringToBytes, encodeMessage, decodeMessage, stringToCode } from '@sirena-lwm2m/coap';
+
+const PSK_IDENTITY = 'device-001';
+const PSK_KEY = Buffer.from('s3cr3t');
+
+const server = createServer({
+  listen: ['coaps://127.0.0.1:5684'],
+  security: {
+    mode: 'psk',
+    psk: (identity) => identity === PSK_IDENTITY ? PSK_KEY : null,
+  },
+});
+
+server.on('request', async (_req, ctx) => {
+  console.log('ctx.peer:', ctx.peer);
+  const identity = ctx.peer.mode === 'psk' ? ctx.peer.identity : 'unknown';
+  await ctx.respond(Response.ok(stringToBytes(identity)));
+});
+
+await server.start();
+console.log('Server listening on:', server.listenerSummary());
+
+const port = server.listenerSummary()[0].port;
+
+function pskGet(host: string, port: number): Promise<string> {
+  const packet = Buffer.from(encodeMessage({
+    version: 1,
+    type: 'CON',
+    token: new Uint8Array([0x01]),
+    code: stringToCode('0.01'),
+    messageId: 1,
+    options: [],
+    payload: new Uint8Array(0),
+  }));
+
+  return new Promise((resolve, reject) => {
+    const sock = tls.connect({
+      host,
+      port,
+      pskCallback: () => ({ psk: PSK_KEY, identity: PSK_IDENTITY }),
+      rejectUnauthorized: false,
+    });
+
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error('timeout')); }, 5000);
+
+    sock.once('secureConnect', () => {
+      sock.write(packet);
+    });
+
+    sock.once('data', (chunk: Buffer) => {
+      clearTimeout(timer);
+      sock.destroy();
+      const decoded = decodeMessage(new Uint8Array(chunk));
+      resolve(Buffer.from(decoded.payload).toString('utf8'));
+    });
+
+    sock.once('error', (err) => { clearTimeout(timer); reject(err); });
+  });
+}
+
+const body = await pskGet('127.0.0.1', port);
+console.log('Response body:', body);
+
+if (body !== PSK_IDENTITY) {
+  throw new Error(`Expected '${PSK_IDENTITY}', got '${body}'`);
+}
+
+await server.stop();
+console.log('Server stopped cleanly.');

package/examples/slice-3-x509.ts

@@ -0,0 +1,85 @@
+import tls from 'node:tls';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createServer, Response, stringToBytes, stringToCode } from '@sirena-lwm2m/coap';
+import { encodeTcpFrame, decodeTcpFrame } from '../dist/transport/index.js';
+
+const FIXTURES_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'test', 'fixtures', 'tls');
+
+const CA_CERT     = fs.readFileSync(path.join(FIXTURES_DIR, 'ca.cert.pem'));
+const SERVER_KEY  = fs.readFileSync(path.join(FIXTURES_DIR, 'server.key.pem'));
+const SERVER_CERT = fs.readFileSync(path.join(FIXTURES_DIR, 'server.cert.pem'));
+const CLIENT_KEY  = fs.readFileSync(path.join(FIXTURES_DIR, 'client.key.pem'));
+const CLIENT_CERT = fs.readFileSync(path.join(FIXTURES_DIR, 'client.cert.pem'));
+
+const server = createServer({
+  listen: ['coaps+tcp://127.0.0.1:5685'],
+  security: {
+    mode: 'x509',
+    key: SERVER_KEY,
+    cert: SERVER_CERT,
+    ca: CA_CERT,
+    requestClientCert: true,
+  },
+});
+
+server.on('request', async (_req, ctx) => {
+  console.log('ctx.peer:', ctx.peer);
+  await ctx.respond(Response.ok(stringToBytes('authenticated')));
+});
+
+await server.start();
+console.log('Server listening on:', server.listenerSummary());
+
+const port = server.listenerSummary()[0].port;
+
+function x509Get(host: string, port: number): Promise<string> {
+  const frame = Buffer.from(encodeTcpFrame({
+    code: stringToCode('0.01'),
+    token: new Uint8Array([0x01]),
+    options: [],
+    payload: new Uint8Array(0),
+  }));
+
+  return new Promise((resolve, reject) => {
+    const sock = tls.connect({
+      host,
+      port,
+      key: CLIENT_KEY,
+      cert: CLIENT_CERT,
+      ca: CA_CERT,
+    });
+
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error('timeout')); }, 5000);
+
+    sock.once('secureConnect', () => {
+      sock.write(frame);
+    });
+
+    let buf = Buffer.alloc(0);
+    const onData = (chunk: Buffer) => {
+      buf = Buffer.concat([buf, chunk]);
+      const result = decodeTcpFrame(buf);
+      if (result !== null && result.frame.payload.length > 0) {
+        clearTimeout(timer);
+        sock.removeListener('data', onData);
+        sock.destroy();
+        resolve(Buffer.from(result.frame.payload).toString('utf8'));
+      }
+    };
+    sock.on('data', onData);
+
+    sock.once('error', (err) => { clearTimeout(timer); reject(err); });
+  });
+}
+
+const body = await x509Get('127.0.0.1', port);
+console.log('Response body:', body);
+
+if (body !== 'authenticated') {
+  throw new Error(`Expected 'authenticated', got '${body}'`);
+}
+
+await server.stop();
+console.log('Server stopped cleanly.');

package/examples/slice-4.ts

@@ -0,0 +1,45 @@
+import { createServer, stringToCode, Response, stringToBytes } from '@sirena-lwm2m/coap';
+import { createApp } from '@sirena-lwm2m/coap/router';
+import type { Middleware } from '@sirena-lwm2m/coap/router';
+
+// Custom option number for Authorization (non-critical, safe to use in demo)
+const OPTION_AUTHORIZATION = 65000;
+
+const server = createServer({
+  listen: [{ host: '127.0.0.1', port: 5683 }],
+});
+
+const router = createApp({ server, discovery: true });
+
+// Auth middleware: rejects requests missing the Authorization option with 4.01
+const authMiddleware: Middleware = (req, ctx, next) => {
+  const authOpt = ctx.options.find(o => o.number === OPTION_AUTHORIZATION);
+  if (authOpt === undefined) {
+    ctx.abort(stringToCode('4.01'));
+    return;
+  }
+  return next();
+};
+
+router.use(authMiddleware);
+
+router.add({
+  path: '/3/{iid}',
+  method: 'GET',
+  handler: (_req, ctx) => {
+    ctx.respond(new Response(stringToCode('2.05'), stringToBytes('device-object')));
+  },
+});
+
+router.add({
+  path: '/3/{iid}/{rid}',
+  method: 'PUT',
+  handler: (_req, ctx) => {
+    ctx.respond(new Response(stringToCode('2.04')));
+  },
+});
+
+await server.start();
+console.log('CoAP server listening on:', server.listenerSummary());
+console.log('Registered routes: GET /3/{iid}, PUT /3/{iid}/{rid}');
+console.log('Discovery enabled at /.well-known/core');

package/examples/slice-5-firmware.ts

@@ -0,0 +1,207 @@
+import dgram from 'node:dgram';
+import { createServer, stringToCode, Response } from '@sirena-lwm2m/coap';
+import { createApp } from '@sirena-lwm2m/coap/router';
+import { blockwiseMiddleware } from '@sirena-lwm2m/coap/blockwise';
+import { encodeMessage, decodeMessage } from '@sirena-lwm2m/coap';
+import { OptionNumber, uintToBytes } from '@sirena-lwm2m/coap';
+import { encodeBlockOption, decodeBlockOption } from '@sirena-lwm2m/coap/blockwise';
+
+const PORT = 5685;
+const HOST = '127.0.0.1';
+
+// ── Server ────────────────────────────────────────────────────────────────────
+
+const server = createServer({
+  listen: [{ host: HOST, port: PORT }],
+});
+
+const router = createApp({ server });
+
+router.use(blockwiseMiddleware());
+
+// PUT /firmware — handler only sees the fully-assembled body
+router.add({
+  path: '/firmware',
+  method: 'PUT',
+  handler: async (req, ctx) => {
+    let byteCount = 0;
+    if (req.body) {
+      const reader = req.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        byteCount += value?.length ?? 0;
+      }
+    }
+    console.log(`firmware bytes received: ${byteCount}`);
+    await ctx.respond(new Response(stringToCode('2.04')));
+  },
+});
+
+// GET /manifest — 500-byte JSON manifest, chunked transparently via Block2
+const MANIFEST = Buffer.from(
+  JSON.stringify({ version: '1.2.3', size: 8_388_608, crc32: 'deadbeef' }).padEnd(500, ' '),
+);
+
+router.add({
+  path: '/manifest',
+  method: 'GET',
+  handler: async (_req, ctx) => {
+    await ctx.respond(new Response(stringToCode('2.05'), MANIFEST));
+  },
+});
+
+await server.start();
+console.log('CoAP server listening on:', server.listenerSummary());
+
+// ── Self-test client ──────────────────────────────────────────────────────────
+
+// CON PUT with Block1 option — sends one UDP datagram and awaits ACK/response
+function sendBlock1(
+  sock: dgram.Socket,
+  token: Uint8Array,
+  msgId: number,
+  num: number,
+  szx: number,
+  m: boolean,
+  chunk: Uint8Array,
+): Promise<{ code: number; options: { number: number; value: Uint8Array }[] }> {
+  return new Promise((resolve, reject) => {
+    const uriPathBytes = new TextEncoder().encode('firmware');
+    const packet = encodeMessage({
+      version: 1,
+      type: 'CON',
+      token,
+      code: stringToCode('0.03'), // PUT
+      messageId: msgId,
+      options: [
+        { number: OptionNumber.UriPath, value: uriPathBytes },
+        { number: OptionNumber.Block1, value: encodeBlockOption({ num, szx, m }) },
+      ],
+      payload: chunk,
+    });
+
+    const timer = setTimeout(() => reject(new Error(`Block1 NUM=${num} timeout`)), 5000);
+
+    const onMessage = (msg: Buffer) => {
+      const decoded = decodeMessage(msg);
+      if (decoded.messageId === msgId) {
+        clearTimeout(timer);
+        sock.off('message', onMessage);
+        resolve({ code: decoded.code, options: decoded.options });
+      }
+    };
+
+    sock.on('message', onMessage);
+    sock.send(packet, PORT, HOST);
+  });
+}
+
+// GET with Block2 option — requests a specific block number
+function sendBlock2Get(
+  sock: dgram.Socket,
+  token: Uint8Array,
+  msgId: number,
+  path: string,
+  num: number,
+  szx: number,
+): Promise<{ code: number; payload: Uint8Array; m: boolean; options: { number: number; value: Uint8Array }[] }> {
+  return new Promise((resolve, reject) => {
+    const uriPathBytes = new TextEncoder().encode(path);
+    const packet = encodeMessage({
+      version: 1,
+      type: 'CON',
+      token,
+      code: stringToCode('0.01'), // GET
+      messageId: msgId,
+      options: [
+        { number: OptionNumber.UriPath, value: uriPathBytes },
+        { number: OptionNumber.Block2, value: encodeBlockOption({ num, szx, m: false }) },
+      ],
+      payload: new Uint8Array(0),
+    });
+
+    const timer = setTimeout(() => reject(new Error(`Block2 NUM=${num} timeout`)), 5000);
+
+    const onMessage = (msg: Buffer) => {
+      const decoded = decodeMessage(msg);
+      if (decoded.messageId === msgId) {
+        clearTimeout(timer);
+        sock.off('message', onMessage);
+        const block2Opt = decoded.options.find(o => o.number === OptionNumber.Block2);
+        const m = block2Opt ? decodeBlockOption(block2Opt.value).m : false;
+        resolve({ code: decoded.code, payload: decoded.payload, m, options: decoded.options });
+      }
+    };
+
+    sock.on('message', onMessage);
+    sock.send(packet, PORT, HOST);
+  });
+}
+
+const sock = dgram.createSocket('udp4');
+await new Promise<void>((resolve) => sock.bind(0, HOST, resolve));
+
+// Test 1: 8 MiB Block1 PUT /firmware
+const FIRMWARE_SIZE = 8 * 1024 * 1024; // 8 MiB
+const firmware = Buffer.alloc(FIRMWARE_SIZE, 0xab);
+
+const SZX = 6; // block size = 2^(6+4) = 1024 bytes
+const BLOCK_SIZE = 1024;
+const totalChunks = Math.ceil(FIRMWARE_SIZE / BLOCK_SIZE);
+
+const block1Token = new Uint8Array([0x01, 0x02, 0x03, 0x04]);
+let msgId = 1;
+
+console.log(`Uploading ${FIRMWARE_SIZE} bytes in ${totalChunks} × ${BLOCK_SIZE}-byte blocks…`);
+
+for (let num = 0; num < totalChunks; num++) {
+  const start = num * BLOCK_SIZE;
+  const end = Math.min(start + BLOCK_SIZE, FIRMWARE_SIZE);
+  const chunk = firmware.subarray(start, end);
+  const m = num < totalChunks - 1;
+
+  const resp = await sendBlock1(sock, block1Token, msgId++, num, SZX, m, chunk);
+
+  if (m) {
+    // Expect 2.31 Continue (0x5f)
+    if (resp.code !== 0x5f) {
+      throw new Error(`Expected 2.31 Continue for chunk ${num}, got 0x${resp.code.toString(16)}`);
+    }
+  } else {
+    // Final chunk — expect 2.04 Changed (0x44)
+    if (resp.code !== stringToCode('2.04')) {
+      throw new Error(`Expected 2.04 Changed for final chunk, got 0x${resp.code.toString(16)}`);
+    }
+    console.log('Block1 PUT /firmware: 2.04 Changed ✓');
+  }
+}
+
+// Test 2: Block2 GET /manifest — reassemble all chunks
+const block2Token = new Uint8Array([0x05, 0x06, 0x07, 0x08]);
+const manifestChunks: Uint8Array[] = [];
+let blockNum = 0;
+const GET_SZX = 5; // 512-byte blocks for manifest
+
+while (true) {
+  const resp = await sendBlock2Get(sock, block2Token, msgId++, 'manifest', blockNum, GET_SZX);
+  if (resp.code !== stringToCode('2.05')) {
+    throw new Error(`Expected 2.05 Content for manifest block ${blockNum}, got 0x${resp.code.toString(16)}`);
+  }
+  manifestChunks.push(resp.payload);
+  if (!resp.m) break;
+  blockNum++;
+}
+
+const manifestBytes = Buffer.concat(manifestChunks);
+if (manifestBytes.length !== MANIFEST.length) {
+  throw new Error(`Manifest length mismatch: expected ${MANIFEST.length}, got ${manifestBytes.length}`);
+}
+if (!manifestBytes.equals(MANIFEST)) {
+  throw new Error('Manifest content mismatch');
+}
+console.log(`Block2 GET /manifest: ${manifestBytes.length} bytes received, content verified ✓`);
+
+sock.close();
+await server.stop();
+console.log('All self-tests passed.');

package/examples/slice-6-temperature.ts

@@ -0,0 +1,163 @@
+// RFC 7641 Observe — temperature sensor example
+//
+// Server: publishes /temperature as an observable resource (fake sensor, updates every 500 ms).
+// Client: registers via GET+Observe:0, logs 5 notifications, then deregisters via GET+Observe:1.
+//
+// Run: node --experimental-strip-types examples/slice-6-temperature.ts
+
+import dgram from 'node:dgram';
+import { createServer, Response } from '@sirena-lwm2m/coap';
+import { createApp } from '@sirena-lwm2m/coap/router';
+import { encodeMessage, decodeMessage, stringToCode } from '@sirena-lwm2m/coap';
+import { OptionNumber, uintToBytes, bytesToUint } from '@sirena-lwm2m/coap';
+import type { Observable, Observer, Unsubscribe } from '@sirena-lwm2m/coap';
+
+const PORT = 5686;
+const HOST = '127.0.0.1';
+
+// ── Observable temperature subject ───────────────────────────────────────────
+
+function makeSubject<T>(): { observable: Observable<T>; next(v: T): void; complete(): void } {
+  const subscribers = new Set<Observer<T>>();
+  return {
+    observable: {
+      subscribe(observer: Observer<T>): Unsubscribe {
+        subscribers.add(observer);
+        return () => { subscribers.delete(observer); };
+      },
+    },
+    next(v: T) {
+      for (const obs of subscribers) obs.next(v);
+    },
+    complete() {
+      for (const obs of subscribers) obs.complete?.();
+      subscribers.clear();
+    },
+  };
+}
+
+// ── Server ────────────────────────────────────────────────────────────────────
+
+const server = createServer({ listen: [{ host: HOST, port: PORT }] });
+const router = createApp({ server });
+
+const tempSubject = makeSubject<Uint8Array>();
+
+router.add({
+  path: '/temperature',
+  method: 'GET',
+  handler: async (_req, ctx) => {
+    const initialReading = encodeTemperature(20.0);
+    await ctx.respond(Response.ok(initialReading));
+    // ctx.observe() is a no-op for non-Observe GET requests; safe to call unconditionally
+    ctx.observe(tempSubject.observable);
+  },
+});
+
+await server.start();
+console.log('CoAP server listening on', server.listenerSummary());
+
+// ── Fake temperature sensor (updates every 500 ms) ────────────────────────────
+
+function encodeTemperature(celsius: number): Uint8Array {
+  const buf = Buffer.alloc(4);
+  buf.writeFloatBE(celsius, 0);
+  return buf;
+}
+
+function decodeTemperature(payload: Uint8Array): number {
+  return Buffer.from(payload).readFloatBE(0);
+}
+
+let temp = 20.0;
+const sensorInterval = setInterval(() => {
+  temp += (Math.random() - 0.5) * 0.5;
+  tempSubject.next(encodeTemperature(temp));
+}, 500);
+
+// ── Client ────────────────────────────────────────────────────────────────────
+
+const sock = dgram.createSocket('udp4');
+await new Promise<void>((resolve) => sock.bind(0, HOST, resolve));
+
+const TOKEN = new Uint8Array([0xca, 0xfe, 0xbe, 0xef]);
+let msgId = 100;
+
+function buildObservePacket(deregister: boolean): Uint8Array {
+  // Options must be in ascending numeric order per RFC 7252.
+  // Observe = 6, UriPath = 11 — Observe goes first.
+  return encodeMessage({
+    version: 1,
+    type: 'CON',
+    token: TOKEN,
+    code: stringToCode('0.01'), // GET
+    messageId: msgId++,
+    options: [
+      { number: OptionNumber.Observe, value: uintToBytes(deregister ? 1 : 0) },
+      { number: OptionNumber.UriPath, value: new TextEncoder().encode('temperature') },
+    ],
+    payload: new Uint8Array(0),
+  });
+}
+
+function sendAck(messageId: number): void {
+  const ack = encodeMessage({
+    version: 1,
+    type: 'ACK',
+    token: TOKEN,
+    code: stringToCode('0.00'), // Empty ACK
+    messageId,
+    options: [],
+    payload: new Uint8Array(0),
+  });
+  sock.send(ack, PORT, HOST);
+}
+
+// Register (GET + Observe:0)
+const registerPacket = buildObservePacket(false);
+sock.send(registerPacket, PORT, HOST);
+console.log('Client: sent Observe registration (GET + Observe:0)');
+
+// Collect 5 notifications then deregister
+let notificationCount = 0;
+
+await new Promise<void>((resolve, reject) => {
+  const timeout = setTimeout(() => reject(new Error('Timed out waiting for 5 notifications')), 15_000);
+
+  sock.on('message', (msg: Buffer) => {
+    const decoded = decodeMessage(msg);
+
+    // ACK any CON notification so the server can send the next one
+    if (decoded.type === 'CON') {
+      sendAck(decoded.messageId);
+    }
+
+    const observeOpt = decoded.options.find(o => o.number === OptionNumber.Observe);
+    if (observeOpt === undefined) return; // skip non-Observe responses
+
+    const seq = bytesToUint(observeOpt.value);
+    const tempC = decodeTemperature(decoded.payload);
+    notificationCount++;
+
+    console.log(`Notification #${notificationCount}: seq=${seq}, temp=${tempC.toFixed(2)}°C`);
+
+    if (notificationCount === 5) {
+      clearTimeout(timeout);
+      resolve();
+    }
+  });
+});
+
+// Deregister (GET + Observe:1)
+const deregisterPacket = buildObservePacket(true);
+sock.send(deregisterPacket, PORT, HOST);
+console.log('Client: sent deregistration (GET + Observe:1)');
+
+// Brief pause to allow the server to process the deregistration, then clean up
+await new Promise(r => setTimeout(r, 300));
+
+clearInterval(sensorInterval);
+tempSubject.complete();
+sock.close();
+await server.stop();
+console.log('Done — received 5 notifications and deregistered cleanly.');

package/examples/slice-7-file-store.ts

@@ -0,0 +1,92 @@
+// Slice 7a — SqliteStore example with file-backed dedup store
+//
+// Demonstrates a CoAP server that uses SqliteStore for durable transaction
+// deduplication across restarts. The SQLite database is stored on disk so
+// the server can survive a crash and still correctly dedup retransmissions
+// that arrived before the restart.
+//
+// Run: node --experimental-strip-types examples/slice-7-file-store.ts
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import dgram from 'node:dgram';
+import { createServer, Response, encodeMessage, decodeMessage, stringToCode } from '@sirena-lwm2m/coap';
+import { createSqliteStore } from '@sirena-lwm2m/coap/store';
+
+// ── Persistent SQLite store ───────────────────────────────────────────────────
+
+const dbDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sirena-coap-'));
+const dbPath = path.join(dbDir, 'dedup.db');
+
+console.log(`Using SQLite dedup store at: ${dbPath}`);
+
+const store = await createSqliteStore({ path: dbPath });
+
+// ── Server ────────────────────────────────────────────────────────────────────
+
+const server = createServer({
+  listen: ['coap://127.0.0.1:5690'],
+  store,
+});
+
+let requestCount = 0;
+
+server.on('request', async (_req, ctx) => {
+  requestCount++;
+  console.log(`[server] request #${requestCount} from ${ctx.remote}`);
+  await ctx.respond(Response.ok(new TextEncoder().encode(`hello #${requestCount}`)));
+});
+
+await server.start();
+console.log('Server started:', server.listenerSummary());
+console.log('Store summary:', server.storeSummary());
+
+// ── Client: send same CON twice (dedup demo) ──────────────────────────────────
+
+const sock = dgram.createSocket('udp4');
+await new Promise<void>((resolve) => sock.bind(0, '127.0.0.1', resolve));
+
+const TOKEN = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+const MID = 0x1234;
+
+const request = encodeMessage({
+  version: 1,
+  type: 'CON',
+  token: TOKEN,
+  code: stringToCode('0.01'), // GET
+  messageId: MID,
+  options: [],
+  payload: new Uint8Array(0),
+});
+
+const responses: string[] = [];
+
+sock.on('message', (msg) => {
+  const decoded = decodeMessage(msg);
+  responses.push(new TextDecoder().decode(decoded.payload));
+  console.log(`[client] received: ${responses[responses.length - 1]}`);
+});
+
+// First transmission
+sock.send(request, 5690, '127.0.0.1');
+console.log('[client] sent CON request (first)');
+await new Promise(r => setTimeout(r, 50));
+
+// Retransmission of same MID — server should dedup and replay the cached response
+sock.send(request, 5690, '127.0.0.1');
+console.log('[client] retransmitted same CON request (should be deduped)');
+await new Promise(r => setTimeout(r, 50));
+
+console.log(`\nResult: ${requestCount} handler invocation(s) for 2 transmissions`);
+console.log(requestCount === 1
+  ? '✓ CON retransmission correctly deduped via SqliteStore'
+  : '✗ Dedup failed — handler was invoked more than once');
+
+// ── Cleanup ───────────────────────────────────────────────────────────────────
+
+sock.close();
+store.close();
+await server.stop();
+fs.rmSync(dbDir, { recursive: true, force: true });
+console.log('\nDone.');