@celilo/e2e 0.1.0

package/simulators/greenwave/server.ts

@@ -0,0 +1,164 @@
+/**
+ * Greenwave C4000XG Router Simulator
+ *
+ * Implements the REST API subset used by celilo's greenwave module:
+ *   POST /cgi/cgi_action  — Login/logout
+ *   GET  /cgi/cgi_get     — Read config objects (public IP, port mappings)
+ *   POST /cgi/cgi_set     — Add/modify port forwarding rules
+ *
+ * Port forwards are actually applied via iptables, making them
+ * functional in the simulated Docker network.
+ */
+
+import {
+  addPortMapping,
+  getDhcpPool,
+  getPublicIp,
+  isAuthenticated,
+  listPortMappings,
+  login,
+  logout,
+  setDhcpPool,
+} from './state';
+import type { CgiResponse } from './types';
+
+const PORT = 443;
+
+function getSessionId(req: Request): string | null {
+  const cookie = req.headers.get('cookie') || '';
+  const match = cookie.match(/Session-Id=([^;]+)/);
+  return match ? match[1] : null;
+}
+
+function parseUrlEncoded(body: string): Record<string, string> {
+  const params: Record<string, string> = {};
+  for (const pair of body.split('&')) {
+    const [key, ...rest] = pair.split('=');
+    if (key) params[decodeURIComponent(key)] = decodeURIComponent(rest.join('='));
+  }
+  return params;
+}
+
+function jsonResponse(data: CgiResponse, status = 200): Response {
+  return Response.json(data, { status });
+}
+
+// Generate self-signed TLS cert for HTTPS
+const tlsOptions = (() => {
+  try {
+    const { execSync } = require('node:child_process');
+    const { readFileSync, existsSync } = require('node:fs');
+
+    if (!existsSync('/tmp/router-cert.pem')) {
+      execSync(
+        'openssl req -x509 -newkey rsa:2048 -keyout /tmp/router-key.pem -out /tmp/router-cert.pem -days 365 -nodes -subj "/CN=router.local"',
+        { timeout: 10000 },
+      );
+    }
+
+    return {
+      cert: readFileSync('/tmp/router-cert.pem'),
+      key: readFileSync('/tmp/router-key.pem'),
+    };
+  } catch {
+    console.warn('[greenwave] Failed to generate TLS cert, falling back to HTTP');
+    return undefined;
+  }
+})();
+
+// Bind to internal interface only (like a real router's management UI)
+// The external interface should only handle port-forwarded traffic via iptables
+const BIND_HOST = process.env.ROUTER_BIND_HOST || '192.168.0.1';
+
+const server = Bun.serve({
+  port: PORT,
+  hostname: BIND_HOST,
+  tls: tlsOptions,
+
+  async fetch(req) {
+    const url = new URL(req.url);
+
+    // --- POST /cgi/cgi_action (login/logout) ---
+    if (url.pathname === '/cgi/cgi_action' && req.method === 'POST') {
+      const body = await req.text();
+      const params = parseUrlEncoded(body);
+
+      // Logout
+      if (params.logout === 'true') {
+        const sessionId = getSessionId(req);
+        if (sessionId) logout(sessionId);
+        return new Response('OK', { status: 200 });
+      }
+
+      // Login
+      const { username, password } = params;
+      if (!username || !password) {
+        return new Response('Missing credentials', { status: 400 });
+      }
+
+      const sessionId = login(username, password);
+      if (!sessionId) {
+        return new Response('Invalid credentials', { status: 444 });
+      }
+
+      return new Response(JSON.stringify({ SessionId: sessionId }), {
+        status: 200,
+        headers: {
+          'Content-Type': 'application/json',
+          'Set-Cookie': `Session-Id=${sessionId}; Path=/`,
+        },
+      });
+    }
+
+    // --- GET /cgi/cgi_get (read objects) ---
+    if (url.pathname === '/cgi/cgi_get' && req.method === 'GET') {
+      const sessionId = getSessionId(req);
+      if (!isAuthenticated(sessionId)) {
+        return new Response('Unauthorized', { status: 403 });
+      }
+
+      const objectPath = url.searchParams.get('Object') || '';
+
+      if (objectPath.startsWith('Device.IP.Interface.3.IPv4Address')) {
+        return jsonResponse({ Objects: [getPublicIp()] });
+      }
+
+      if (objectPath.startsWith('Device.NAT.PortMapping')) {
+        return jsonResponse({ Objects: listPortMappings() });
+      }
+
+      if (objectPath.startsWith('Device.DHCPv4.Server.Pool.1')) {
+        return jsonResponse({ Objects: [getDhcpPool()] });
+      }
+
+      return jsonResponse({ Objects: [] });
+    }
+
+    // --- POST /cgi/cgi_set (modify objects) ---
+    if (url.pathname === '/cgi/cgi_set' && req.method === 'POST') {
+      const sessionId = getSessionId(req);
+      if (!isAuthenticated(sessionId)) {
+        return new Response('Unauthorized', { status: 403 });
+      }
+
+      const body = await req.text();
+      const params = parseUrlEncoded(body);
+
+      if (params.Operation === 'Add' && params.Object?.startsWith('Device.NAT.PortMapping')) {
+        const result = addPortMapping(params);
+        return jsonResponse({ Objects: result });
+      }
+
+      if (params.Object?.startsWith('Device.DHCPv4.Server.Pool.1')) {
+        const result = setDhcpPool(params);
+        return jsonResponse({ Objects: result });
+      }
+
+      return jsonResponse({ Objects: [] });
+    }
+
+    return new Response('Not Found', { status: 404 });
+  },
+});
+
+console.log(`[greenwave] C4000XG simulator listening on ${BIND_HOST}:${server.port} (${tlsOptions ? 'HTTPS' : 'HTTP'})`);

package/simulators/greenwave/state.ts

@@ -0,0 +1,206 @@
+import { execSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import type { CgiObject, CgiParam, PortMapping, Session } from './types';
+
+const VALID_USERNAME = process.env.ROUTER_USERNAME || 'admin';
+const VALID_PASSWORD = process.env.ROUTER_PASSWORD || 'admin';
+const PUBLIC_IP = process.env.ROUTER_PUBLIC_IP || '100.100.0.100';
+
+// The network interface facing the ISP (isp-external network)
+const EXTERNAL_INTERFACE = process.env.EXTERNAL_INTERFACE || 'eth1';
+
+const sessions = new Map<string, Session>();
+const portMappings: PortMapping[] = [];
+let nextIndex = 1;
+
+// DHCP pool state
+const dhcpPool: Record<string, string> = {
+  Alias: 'cpe-Pool-1',
+  Enable: 'true',
+  MinAddress: '192.168.0.2',
+  MaxAddress: '192.168.0.150',
+  SubnetMask: '255.255.255.0',
+  IPRouters: '192.168.0.1',
+  DNSServers: '192.168.0.1',
+  DomainName: '',
+  LeaseTime: '3600',
+  Status: 'Enabled',
+};
+
+export function login(username: string, password: string): string | null {
+  if (username !== VALID_USERNAME || password !== VALID_PASSWORD) {
+    return null;
+  }
+  const sessionId = `sim-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  sessions.set(sessionId, { username, createdAt: Date.now() });
+  return sessionId;
+}
+
+export function logout(sessionId: string): void {
+  sessions.delete(sessionId);
+}
+
+export function isAuthenticated(sessionId: string | null): boolean {
+  if (!sessionId) return false;
+  return sessions.has(sessionId);
+}
+
+export function getPublicIp(): CgiObject {
+  return {
+    ObjName: 'Device.IP.Interface.3.IPv4Address.1.',
+    Param: [{ ParamName: 'IPAddress', ParamValue: PUBLIC_IP }],
+  };
+}
+
+export function listPortMappings(): CgiObject[] {
+  return portMappings.map((pm) => ({
+    ObjName: pm.objName,
+    Param: mappingToParams(pm),
+  }));
+}
+
+export function addPortMapping(params: Record<string, string>): CgiObject[] {
+  const index = nextIndex++;
+  const objName = `Device.NAT.PortMapping.${index}.`;
+
+  const mapping: PortMapping = {
+    objName,
+    externalPort: params.ExternalPort || '',
+    externalPortEndRange: params.ExternalPortEndRange || params.ExternalPort || '',
+    internalPort: params.InternalPort || '',
+    internalClient: params.InternalClient || '',
+    enable: params.Enable || '1',
+    description: params.Description || '',
+    protocol: params.Protocol || 'TCP',
+    via: params.X_GWS_Via || 'UI',
+    remoteHost: params.RemoteHost || '',
+  };
+
+  portMappings.push(mapping);
+
+  // Actually apply the iptables rule so port forwarding works
+  applyIptablesRule(mapping);
+
+  console.log(
+    `[greenwave] Added port forward: ${mapping.externalPort} -> ${mapping.internalClient}:${mapping.internalPort} (${mapping.protocol})`,
+  );
+
+  return [{ ObjName: objName, Param: mappingToParams(mapping) }];
+}
+
+export function getDhcpPool(): CgiObject {
+  const params: CgiParam[] = Object.entries(dhcpPool).map(([key, value]) => ({
+    ParamName: key,
+    ParamValue: value,
+  }));
+  return {
+    ObjName: 'Device.DHCPv4.Server.Pool.1.',
+    Param: params,
+  };
+}
+
+export function setDhcpPool(params: Record<string, string>): CgiObject[] {
+  let dhcpChanged = false;
+  for (const [key, value] of Object.entries(params)) {
+    if (key === 'Object' || key === 'Operation') continue;
+    if (key in dhcpPool) {
+      dhcpPool[key] = value;
+      console.log(`[greenwave] DHCP pool: ${key} = ${value}`);
+      if (key === 'DNSServers' || key === 'DomainName') {
+        dhcpChanged = true;
+      }
+    }
+  }
+
+  // Update running dnsmasq when DNS/domain settings change
+  if (dhcpChanged) {
+    rewriteDnsmasqConfig();
+  }
+
+  return [{ ObjName: 'Device.DHCPv4.Server.Pool.1.', Param: [{ ParamName: 'Success', ParamValue: 'Success' }] }];
+}
+
+function rewriteDnsmasqConfig(): void {
+  const dnsServers = dhcpPool.DNSServers || '192.168.0.1';
+  const domainName = dhcpPool.DomainName || '';
+
+  const lines = [
+    '# Auto-generated by greenwave simulator',
+    'port=0',
+    'interface=eth0',
+    'bind-interfaces',
+    'dhcp-range=192.168.0.200,192.168.0.220,255.255.255.0,60s',
+    'dhcp-option=option:router,192.168.0.1',
+    `dhcp-option=option:dns-server,${dnsServers}`,
+    'dhcp-lease-max=20',
+    'log-dhcp',
+  ];
+
+  if (domainName) {
+    lines.push(`dhcp-option=option:domain-name,${domainName}`);
+  }
+
+  try {
+    writeFileSync('/etc/dnsmasq.d/e2e.conf', `${lines.join('\n')}\n`);
+    // dnsmasq requires full restart to re-read config files (SIGHUP only reloads /etc/hosts)
+    try {
+      execSync('pkill -9 dnsmasq; sleep 0.5; dnsmasq --conf-dir=/etc/dnsmasq.d --log-facility=/dev/stderr', {
+        timeout: 5000,
+        shell: '/bin/bash',
+      });
+    } catch {}
+    console.log(`[greenwave] dnsmasq restarted: DNS=${dnsServers}, domain=${domainName}`);
+  } catch (err) {
+    console.error('[greenwave] Failed to update dnsmasq:', err);
+  }
+}
+
+function applyIptablesRule(mapping: PortMapping): void {
+  const proto = mapping.protocol === 'TCP/UDP' ? 'tcp' : mapping.protocol.toLowerCase();
+  const extPort = mapping.externalPort;
+  const intIp = mapping.internalClient;
+  const intPort = mapping.internalPort;
+
+  try {
+    // DNAT incoming traffic on external interface destined for our public IP
+    execSync(
+      `iptables -t nat -A PREROUTING -i ${EXTERNAL_INTERFACE} -d ${PUBLIC_IP} -p ${proto} --dport ${extPort} -j DNAT --to-destination ${intIp}:${intPort}`,
+      { timeout: 5000 },
+    );
+    // Allow forwarded traffic
+    execSync(
+      `iptables -A FORWARD -p ${proto} -d ${intIp} --dport ${intPort} -j ACCEPT`,
+      { timeout: 5000 },
+    );
+
+    // If protocol is TCP/UDP, also add UDP rules
+    if (mapping.protocol === 'TCP/UDP') {
+      execSync(
+        `iptables -t nat -A PREROUTING -i ${EXTERNAL_INTERFACE} -d ${PUBLIC_IP} -p udp --dport ${extPort} -j DNAT --to-destination ${intIp}:${intPort}`,
+        { timeout: 5000 },
+      );
+      execSync(
+        `iptables -A FORWARD -p udp -d ${intIp} --dport ${intPort} -j ACCEPT`,
+        { timeout: 5000 },
+      );
+    }
+  } catch (err) {
+    console.error(`[greenwave] Failed to apply iptables rule:`, err);
+  }
+}
+
+function mappingToParams(pm: PortMapping): CgiParam[] {
+  return [
+    { ParamName: 'ExternalPort', ParamValue: pm.externalPort },
+    { ParamName: 'ExternalPortEndRange', ParamValue: pm.externalPortEndRange },
+    { ParamName: 'InternalPort', ParamValue: pm.internalPort },
+    { ParamName: 'InternalClient', ParamValue: pm.internalClient },
+    { ParamName: 'Enable', ParamValue: pm.enable },
+    { ParamName: 'Description', ParamValue: pm.description },
+    { ParamName: 'Protocol', ParamValue: pm.protocol },
+    { ParamName: 'X_GWS_Via', ParamValue: pm.via },
+    { ParamName: 'RemoteHost', ParamValue: pm.remoteHost },
+    { ParamName: 'X_LANTIQ_COM_INTERFACE', ParamValue: 'wan' },
+    { ParamName: 'AllInterfaces', ParamValue: '0' },
+  ];
+}

package/simulators/greenwave/types.ts

@@ -0,0 +1,31 @@
+export interface PortMapping {
+  objName: string;
+  externalPort: string;
+  externalPortEndRange: string;
+  internalPort: string;
+  internalClient: string;
+  enable: string;
+  description: string;
+  protocol: string;
+  via: string;
+  remoteHost: string;
+}
+
+export interface Session {
+  username: string;
+  createdAt: number;
+}
+
+export interface CgiParam {
+  ParamName: string;
+  ParamValue: string;
+}
+
+export interface CgiObject {
+  ObjName: string;
+  Param: CgiParam[];
+}
+
+export interface CgiResponse {
+  Objects: CgiObject[];
+}

package/simulators/namecheap-ddns/server.ts

@@ -0,0 +1,97 @@
+/**
+ * Namecheap Dynamic DNS Simulator
+ *
+ * Mimics the real Namecheap DDNS endpoint:
+ *   GET /update?host=<host>&domain=<domain>&password=<password>&ip=<ip>
+ *
+ * On success, updates the Knot zone file and reloads the zone.
+ * Returns XML matching the real Namecheap response format.
+ */
+
+import { updateZone } from './zone-updater';
+import type { DdnsRecord } from './types';
+
+const VALID_PASSWORD = process.env.DDNS_PASSWORD || 'test123';
+const PORT = Number(process.env.DDNS_PORT) || 8080;
+
+// Track registered records for debugging
+const records: Map<string, DdnsRecord> = new Map();
+
+function xmlResponse(errCount: number, ip: string, errors: string[]): Response {
+  const errorElements = errors
+    .map((e, i) => `<Err${i + 1}>${e}</Err${i + 1}>`)
+    .join('\n    ');
+
+  const xml = `<?xml version="1.0" encoding="utf-16"?>
+<interface-response>
+  <Command>SETDNSHOST</Command>
+  <Language>eng</Language>
+  <IP>${ip}</IP>
+  <ErrCount>${errCount}</ErrCount>
+  ${errorElements}
+  <ResponseCount>0</ResponseCount>
+  <Done>true</Done>
+  <debug><![CDATA[]]></debug>
+</interface-response>`;
+
+  return new Response(xml, {
+    status: 200,
+    headers: { 'Content-Type': 'application/xml' },
+  });
+}
+
+function getSourceIp(req: Request): string {
+  // In Docker, the source IP comes through headers or we fall back to a default
+  const forwarded = req.headers.get('x-forwarded-for');
+  if (forwarded) return forwarded.split(',')[0].trim();
+
+  // Bun's server provides the remote address via the second argument to fetch
+  // but it's not easily accessible here. Default to returning a placeholder
+  // that callers should override via the ip= parameter.
+  return '0.0.0.0';
+}
+
+const server = Bun.serve({
+  port: PORT,
+  fetch(req) {
+    const url = new URL(req.url);
+
+    if (url.pathname === '/update') {
+      const host = url.searchParams.get('host');
+      const domain = url.searchParams.get('domain');
+      const password = url.searchParams.get('password');
+      const ip = url.searchParams.get('ip') || getSourceIp(req);
+
+      if (!host || !domain) {
+        return xmlResponse(1, '', ['Missing required parameters: host, domain']);
+      }
+
+      if (password !== VALID_PASSWORD) {
+        return xmlResponse(1, ip, ['Passwords do not match']);
+      }
+
+      try {
+        updateZone(domain, host, ip);
+        records.set(`${host}.${domain}`, { host, ip, updatedAt: new Date() });
+        console.log(`[ddns] Updated ${host}.${domain} -> ${ip}`);
+        return xmlResponse(0, ip, []);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[ddns] Failed to update zone: ${msg}`);
+        return xmlResponse(1, ip, [`Zone update failed: ${msg}`]);
+      }
+    }
+
+    // Health check / status endpoint
+    if (url.pathname === '/status') {
+      const status = Object.fromEntries(
+        [...records.entries()].map(([k, v]) => [k, { ip: v.ip, updatedAt: v.updatedAt }]),
+      );
+      return Response.json({ ok: true, records: status });
+    }
+
+    return new Response('Not Found', { status: 404 });
+  },
+});
+
+console.log(`[ddns] Namecheap DDNS simulator listening on port ${server.port}`);

package/simulators/namecheap-ddns/types.ts

@@ -0,0 +1,12 @@
+export interface DdnsUpdateRequest {
+  host: string;
+  domain: string;
+  password: string;
+  ip: string | null;
+}
+
+export interface DdnsRecord {
+  host: string;
+  ip: string;
+  updatedAt: Date;
+}

package/simulators/namecheap-ddns/zone-updater.ts

@@ -0,0 +1,49 @@
+import { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const ZONE_DIR = '/config';
+
+/**
+ * Update an A record in a Knot zone file and reload.
+ *
+ * If the host already has an A record, it's replaced.
+ * If not, a new one is appended before the end of the file.
+ * The SOA serial is incremented on every update.
+ */
+export function updateZone(domain: string, host: string, ip: string): void {
+  const zoneFile = `${ZONE_DIR}/${domain}.zone`;
+  let content = readFileSync(zoneFile, 'utf-8');
+
+  // Increment SOA serial (YYYYMMDDnn format — just increment the number)
+  content = content.replace(
+    /(\d{10})(\s+\d+\s+\d+\s+\d+\s+\d+\s*\))/,
+    (_match, serial, rest) => {
+      const newSerial = String(Number(serial) + 1);
+      return `${newSerial}${rest}`;
+    },
+  );
+
+  // Check if host already has an A record
+  const recordRegex = new RegExp(`^${escapeRegex(host)}\\s+IN\\s+A\\s+[\\d.]+`, 'm');
+
+  if (recordRegex.test(content)) {
+    // Replace existing record
+    content = content.replace(recordRegex, `${host}    IN A    ${ip}`);
+  } else {
+    // Append new record
+    content = content.trimEnd() + `\n${host}    IN A    ${ip}\n`;
+  }
+
+  writeFileSync(zoneFile, content);
+
+  // Reload the zone in Knot
+  try {
+    execSync(`knotc zone-reload ${domain}`, { timeout: 5000 });
+  } catch (err) {
+    console.error(`Failed to reload zone ${domain}:`, err);
+  }
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}