@apocaliss92/scrypted-reolink-native 0.1.0 → 0.1.2

package/src/stream-utils.ts

@@ -20,6 +20,16 @@ export interface StreamManagerOptions {
      */
     createStreamClient: () => Promise<ReolinkBaichuanApi>;
     getLogger: () => Console;
+    /**
+     * Credentials to include in the TCP stream (username, password).
+     * Uses the same credentials as the main connection.
+     */
+    credentials: {
+        username: string;
+        password: string;
+    };
+    /** If true, the stream client is shared with the main connection. Default: false. */
+    sharedConnection?: boolean;
 }
 
 export function parseStreamProfileFromId(id: string | undefined): StreamProfile | undefined {
@@ -207,7 +217,7 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
 }): Promise<MediaObject> {
     const { streamManager, channel, profile, streamKey, expectedVideoType, selected, sourceId, onDetectedCodec } = params;
 
-    const { host, port, sdp, audio } = await streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType);
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcStream(channel, profile, streamKey, expectedVideoType);
 
     // Update cached stream options with the detected codec (helps prebuffer/NVR avoid mismatch).
     try {
@@ -230,8 +240,13 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
         mso.audio.channels = audio.channels;
     }
 
+    // Build URL with credentials: tcp://username:password@host:port
+    const encodedUsername = encodeURIComponent(username || '');
+    const encodedPassword = encodeURIComponent(password || '');
+    const url = `tcp://${encodedUsername}:${encodedPassword}@${host}:${port}`;
+
     const rfc = {
-        url: `tcp://${host}:${port}`,
+        url,
         sdp,
         mediaStreamOptions: mso as ResponseMediaStreamOptions,
     };
@@ -241,9 +256,18 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
     });
 }
 
+type RfcServerInfo = {
+    host: string;
+    port: number;
+    sdp: string;
+    audio?: { codec: string; sampleRate: number; channels: number };
+    username: string;
+    password: string;
+};
+
 export class StreamManager {
     private nativeRfcServers = new Map<string, ScryptedRfc4571TcpServer>();
-    private nativeRfcServerCreatePromises = new Map<string, Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }>>();
+    private nativeRfcServerCreatePromises = new Map<string, Promise<RfcServerInfo>>();
 
     constructor(private opts: StreamManagerOptions) {
     }
@@ -257,7 +281,7 @@ export class StreamManager {
         channel: number,
         profile: StreamProfile,
         expectedVideoType?: 'H264' | 'H265',
-    ): Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }> {
+    ): Promise<RfcServerInfo> {
         const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
         if (existingCreate) {
             return await existingCreate;
@@ -272,7 +296,14 @@ export class StreamManager {
                     );
                 }
                 else {
-                    return { host: cached.host, port: cached.port, sdp: cached.sdp, audio: cached.audio };
+                    return {
+                        host: cached.host,
+                        port: cached.port,
+                        sdp: cached.sdp,
+                        audio: cached.audio,
+                        username: (cached as any).username || this.opts.credentials.username,
+                        password: (cached as any).password || this.opts.credentials.password,
+                    };
                 }
             }
 
@@ -288,13 +319,22 @@ export class StreamManager {
 
             const api = await this.opts.createStreamClient();
             const { createScryptedRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
+
+            // Use the same credentials as the main connection
+            const { username, password } = this.opts.credentials;
+
+            // If connection is shared, don't close it when stream teardown happens
+            const closeApiOnTeardown = !(this.opts.sharedConnection ?? false);
+
             const created = await createScryptedRfc4571TcpServer({
                 api,
                 channel,
                 profile,
                 logger: this.getLogger(),
                 expectedVideoType: expectedVideoType as VideoType | undefined,
-                closeApiOnTeardown: true,
+                closeApiOnTeardown,
+                username,
+                password,
             });
 
             this.nativeRfcServers.set(streamKey, created);
@@ -303,7 +343,14 @@ export class StreamManager {
                 if (current?.server === created.server) this.nativeRfcServers.delete(streamKey);
             });
 
-            return { host: created.host, port: created.port, sdp: created.sdp, audio: created.audio };
+            return {
+                host: created.host,
+                port: created.port,
+                sdp: created.sdp,
+                audio: created.audio,
+                username: (created as any).username || this.opts.credentials.username,
+                password: (created as any).password || this.opts.credentials.password,
+            };
         })();
 
         this.nativeRfcServerCreatePromises.set(streamKey, createPromise);
@@ -320,7 +367,26 @@ export class StreamManager {
         profile: StreamProfile,
         streamKey: string,
         expectedVideoType?: 'H264' | 'H265',
-    ): Promise<{ host: string; port: number; sdp: string; audio?: { codec: string; sampleRate: number; channels: number } }> {
+    ): Promise<RfcServerInfo> {
         return await this.ensureNativeRfcServer(streamKey, channel, profile, expectedVideoType);
     }
+
+    /**
+     * Close all active stream servers.
+     * Useful when the main connection is reset and streams need to be recreated.
+     */
+    async closeAllStreams(reason?: string): Promise<void> {
+        const servers = Array.from(this.nativeRfcServers.values());
+        this.nativeRfcServers.clear();
+        
+        await Promise.allSettled(
+            servers.map(async (server) => {
+                try {
+                    await server.close(reason || 'connection reset');
+                } catch (e) {
+                    this.getLogger().debug('Error closing stream server', e);
+                }
+            })
+        );
+    }
 }

package/pcap/analyze_json.py

@@ -1,248 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze Wireshark JSON exports to compare neolink vs scrypted UDP flows.
-"""
-import json
-import sys
-import struct
-from typing import List, Dict, Any
-
-BCUDP_MAGIC_DISCOVERY = 0x3acf872a
-BCUDP_MAGIC_DATA = 0x10cf872a
-BCUDP_MAGIC_ACK = 0x20cf872a
-
-def hex_to_bytes(hex_str: str) -> bytes:
-    """Convert hex string (e.g., '10:cf:87:2a') to bytes."""
-    try:
-        return bytes.fromhex(hex_str.replace(':', '').replace(' ', ''))
-    except:
-        return b''
-
-def parse_bcudp_packet(udp_data_hex: str) -> Dict[str, Any] | None:
-    """Parse BCUDP packet from hex string."""
-    try:
-        data = hex_to_bytes(udp_data_hex)
-        if len(data) < 4:
-            return None
-        
-        # Wireshark exports hex strings in the order they appear in the packet
-        # BCUDP magic numbers are stored as little-endian in the packet
-        # But when we convert hex string to bytes, we get the bytes in order
-        # So 3a:cf:87:2a becomes bytes [0x3a, 0xcf, 0x87, 0x2a]
-        # Reading as little-endian: 0x2a87cf3a (wrong)
-        # Reading as big-endian: 0x3acf872a (correct!)
-        # Actually wait - let me check the actual byte order in the hex string
-        # The hex shows "3a:cf:87:2a" which as bytes is [0x3a, 0xcf, 0x87, 0x2a]
-        # As little-endian uint32: 0x2a87cf3a
-        # As big-endian uint32: 0x3acf872a
-        # So we need big-endian for the magic comparison
-        magic = struct.unpack('>I', data[0:4])[0]
-        
-        if magic == BCUDP_MAGIC_DISCOVERY:
-            return {'type': 'discovery', 'magic': hex(magic), 'payload': udp_data_hex}
-        elif magic == BCUDP_MAGIC_DATA:
-            if len(data) < 20:
-                return None
-            connection_id = int.from_bytes(data[4:8], 'little', signed=True)
-            packet_id = int.from_bytes(data[12:16], 'little')
-            payload_len = int.from_bytes(data[16:20], 'little')
-            return {
-                'type': 'data',
-                'magic': hex(magic),
-                'connection_id': connection_id,
-                'packet_id': packet_id,
-                'payload_len': payload_len,
-                'payload_hex': udp_data_hex[:80]  # First 40 bytes hex
-            }
-        elif magic == BCUDP_MAGIC_ACK:
-            if len(data) < 28:
-                return None
-            connection_id = int.from_bytes(data[4:8], 'little', signed=True)
-            group_id = int.from_bytes(data[12:16], 'little')
-            packet_id = int.from_bytes(data[16:20], 'little')
-            return {
-                'type': 'ack',
-                'magic': hex(magic),
-                'connection_id': connection_id,
-                'group_id': group_id,
-                'packet_id': packet_id,
-                'payload_hex': udp_data_hex[:56]  # First 28 bytes hex
-            }
-    except Exception as e:
-        return None
-    
-    return None
-
-def extract_packets(json_file: str) -> List[Dict[str, Any]]:
-    """Extract BCUDP packets from Wireshark JSON export."""
-    packets = []
-    
-    with open(json_file, 'r') as f:
-        data = json.load(f)
-    
-    for entry in data:
-        source = entry.get('_source', {})
-        layers = source.get('layers', {})
-        
-        # Get frame info
-        frame = layers.get('frame', {})
-        frame_num = int(frame.get('frame.number', '0'))
-        frame_time = float(frame.get('frame.time_relative', '0'))
-        
-        # Get UDP info
-        udp = layers.get('udp', {})
-        if not udp:
-            continue
-        
-        src_port = int(udp.get('udp.srcport', '0'))
-        dst_port = int(udp.get('udp.dstport', '0'))
-        
-        # Get UDP data (from udp.payload field)
-        udp_data_hex = udp.get('udp.payload', '')
-        if not udp_data_hex:
-            continue
-        
-        # Get IP addresses to determine direction
-        ip = layers.get('ip', {})
-        src_ip = ip.get('ip.src', '')
-        dst_ip = ip.get('ip.dst', '')
-        
-        # Parse BCUDP packet
-        bcudp = parse_bcudp_packet(udp_data_hex)
-        if bcudp:
-            packets.append({
-                'frame_num': frame_num,
-                'time': frame_time,
-                'src_ip': src_ip,
-                'dst_ip': dst_ip,
-                'src_port': src_port,
-                'dst_port': dst_port,
-                'bcudp': bcudp
-            })
-    
-    return packets
-
-def print_flow_summary(packets: List[Dict[str, Any]], name: str, limit: int = 100):
-    """Print summary of packet flow."""
-    print(f"\n{'='*100}")
-    print(f"{name}: {len(packets)} BCUDP packets")
-    print(f"{'='*100}")
-    
-    # Count by type
-    discovery_count = sum(1 for p in packets if p['bcudp']['type'] == 'discovery')
-    data_count = sum(1 for p in packets if p['bcudp']['type'] == 'data')
-    ack_count = sum(1 for p in packets if p['bcudp']['type'] == 'ack')
-    
-    print(f"\nCounts: Discovery={discovery_count}, Data={data_count}, ACK={ack_count}")
-    
-    # Show first N packets
-    print(f"\nFirst {min(limit, len(packets))} packets:")
-    for i, pkt in enumerate(packets[:limit]):
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        
-        info = [f"#{pkt['frame_num']:4d}", f"{pkt['time']:8.3f}s", direction, pkt_type]
-        
-        if pkt_type == 'DATA':
-            info.append(f"conn={bcudp.get('connection_id', '?')}")
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-            info.append(f"len={bcudp.get('payload_len', '?')}")
-        elif pkt_type == 'ACK':
-            info.append(f"conn={bcudp.get('connection_id', '?')}")
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-            info.append(f"gid={bcudp.get('group_id', '?')}")
-        
-        info.append(f"{pkt['src_port']}→{pkt['dst_port']}")
-        
-        print(' '.join(info))
-        
-        if i < 20:  # Show hex for first 20 packets
-            if 'payload_hex' in bcudp:
-                print(f"      Hex: {bcudp['payload_hex']}")
-
-def compare_initial_sequence(neolink_packets: List[Dict[str, Any]], scrypted_packets: List[Dict[str, Any]]):
-    """Compare the initial sequence after discovery."""
-    print(f"\n{'='*100}")
-    print("INITIAL SEQUENCE COMPARISON (first 50 packets after discovery)")
-    print(f"{'='*100}")
-    
-    # Find first discovery completion (look for D2C_C_R response)
-    nl_discovery_end = None
-    for i, pkt in enumerate(neolink_packets):
-        if pkt['bcudp']['type'] == 'discovery':
-            # Check if it's a response (coming from camera)
-            if '192.168' in pkt['src_ip']:  # From camera
-                nl_discovery_end = i
-                break
-    
-    sc_discovery_end = None
-    for i, pkt in enumerate(scrypted_packets):
-        if pkt['bcudp']['type'] == 'discovery':
-            if '192.168' in pkt['src_ip']:  # From camera
-                sc_discovery_end = i
-                break
-    
-    print(f"\nDiscovery completed at:")
-    print(f"  Neolink:  packet #{nl_discovery_end}" if nl_discovery_end else "  Neolink:  not found")
-    print(f"  Scrypted: packet #{sc_discovery_end}" if sc_discovery_end else "  Scrypted: not found")
-    
-    # Get next 50 packets after discovery
-    nl_next = neolink_packets[nl_discovery_end+1:nl_discovery_end+51] if nl_discovery_end else []
-    sc_next = scrypted_packets[sc_discovery_end+1:sc_discovery_end+51] if sc_discovery_end else []
-    
-    print(f"\nNext 50 packets after discovery:")
-    print(f"  Neolink:  {len(nl_next)} packets")
-    print(f"  Scrypted: {len(sc_next)} packets")
-    
-    print(f"\nNeolink sequence:")
-    for i, pkt in enumerate(nl_next[:30]):
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        time_rel = pkt['time'] - (neolink_packets[nl_discovery_end]['time'] if nl_discovery_end else 0)
-        
-        info = [f"{time_rel:6.3f}s", direction, pkt_type]
-        if pkt_type == 'DATA':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        elif pkt_type == 'ACK':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        
-        print(' '.join(info))
-    
-    print(f"\nScrypted sequence:")
-    for i, pkt in enumerate(sc_next[:30]):
-        bcudp = pkt['bcudp']
-        direction = '→' if '192.168' in pkt['dst_ip'] else '←'
-        pkt_type = bcudp['type'].upper()
-        time_rel = pkt['time'] - (scrypted_packets[sc_discovery_end]['time'] if sc_discovery_end else 0)
-        
-        info = [f"{time_rel:6.3f}s", direction, pkt_type]
-        if pkt_type == 'DATA':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        elif pkt_type == 'ACK':
-            info.append(f"pid={bcudp.get('packet_id', '?')}")
-        
-        print(' '.join(info))
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python3 analyze_json.py <neolink.json> <scrypted.json>")
-        sys.exit(1)
-    
-    neolink_file = sys.argv[1]
-    scrypted_file = sys.argv[2]
-    
-    print("Loading neolink.json...")
-    neolink_packets = extract_packets(neolink_file)
-    
-    print("Loading scrypted.json...")
-    scrypted_packets = extract_packets(scrypted_file)
-    
-    print_flow_summary(neolink_packets, "NEOLINK", limit=50)
-    print_flow_summary(scrypted_packets, "SCRYPTED", limit=50)
-    compare_initial_sequence(neolink_packets, scrypted_packets)
-
-if __name__ == '__main__':
-    main()
-

package/pcap/analyze_pcap.py

@@ -1,135 +0,0 @@
-#!/usr/bin/env python3
-"""Simple PCAP analyzer to compare neolink vs scrypted UDP flows"""
-import sys
-import struct
-
-def read_pcap_header(f):
-    """Read PCAP file header (24 bytes)"""
-    magic = f.read(4)
-    if magic != b'\xd4\xc3\xb2\xa1':  # pcap magic number (little endian)
-        return None
-    version_major, version_minor = struct.unpack('<HH', f.read(4))
-    thiszone, sigfigs = struct.unpack('<II', f.read(8))
-    snaplen, network = struct.unpack('<II', f.read(8))
-    return {
-        'version_major': version_major,
-        'version_minor': version_minor,
-        'snaplen': snaplen,
-        'network': network
-    }
-
-def read_packet_header(f):
-    """Read PCAP packet header (16 bytes)"""
-    data = f.read(16)
-    if len(data) < 16:
-        return None
-    ts_sec, ts_usec, incl_len, orig_len = struct.unpack('<IIII', data)
-    return {
-        'ts_sec': ts_sec,
-        'ts_usec': ts_usec,
-        'incl_len': incl_len,
-        'orig_len': orig_len
-    }
-
-def analyze_pcap(filename):
-    """Basic analysis of UDP packets in PCAP"""
-    with open(filename, 'rb') as f:
-        header = read_pcap_header(f)
-        if not header:
-            print(f"Error: {filename} is not a valid PCAP file")
-            return
-        
-        packets = []
-        packet_num = 0
-        
-        while True:
-            pkt_header = read_packet_header(f)
-            if not pkt_header:
-                break
-            
-            packet_data = f.read(pkt_header['incl_len'])
-            if len(packet_data) < pkt_header['incl_len']:
-                break
-            
-            # Check if this is an Ethernet frame with IPv4 UDP
-            if len(packet_data) >= 42:  # Min Ethernet + IP + UDP headers
-                # Skip Ethernet header (14 bytes), check IP
-                ip_header = packet_data[14:34]
-                if ip_header[0] == 0x45:  # IPv4
-                    protocol = ip_header[9]
-                    if protocol == 17:  # UDP
-                        src_port = struct.unpack('>H', ip_header[20:22])[0]
-                        dst_port = struct.unpack('>H', ip_header[22:24])[0]
-                        udp_data = packet_data[42:]
-                        
-                        # Check for BCUDP magic numbers
-                        if len(udp_data) >= 4:
-                            magic = udp_data[:4]
-                            if magic == b'\x3a\xcf\x87\x2a':  # Discovery
-                                packets.append({
-                                    'num': packet_num,
-                                    'ts': pkt_header['ts_sec'] + pkt_header['ts_usec'] / 1000000,
-                                    'src_port': src_port,
-                                    'dst_port': dst_port,
-                                    'type': 'discovery',
-                                    'data': udp_data[:100]  # First 100 bytes
-                                })
-                            elif magic == b'\x20\xcf\x87\x2a':  # ACK
-                                packets.append({
-                                    'num': packet_num,
-                                    'ts': pkt_header['ts_sec'] + pkt_header['ts_usec'] / 1000000,
-                                    'src_port': src_port,
-                                    'dst_port': dst_port,
-                                    'type': 'ack',
-                                    'data': udp_data[:50]
-                                })
-                            elif magic == b'\x10\xcf\x87\x2a':  # DATA
-                                packets.append({
-                                    'num': packet_num,
-                                    'ts': pkt_header['ts_sec'] + pkt_header['ts_usec'] / 1000000,
-                                    'src_port': src_port,
-                                    'dst_port': dst_port,
-                                    'type': 'data',
-                                    'data': udp_data[:50]
-                                })
-            
-            packet_num += 1
-        
-        print(f"\n=== {filename} ===")
-        print(f"Total packets analyzed: {packet_num}")
-        print(f"BCUDP packets found: {len(packets)}")
-        
-        # Group by type
-        by_type = {}
-        for pkt in packets:
-            by_type.setdefault(pkt['type'], []).append(pkt)
-        
-        for pkt_type, pkts in by_type.items():
-            print(f"\n{pkt_type.upper()}: {len(pkts)} packets")
-            if pkts:
-                print(f"  First at {pkts[0]['ts']:.3f}s, last at {pkts[-1]['ts']:.3f}s")
-                print(f"  Ports: src={set(p['src_port'] for p in pkts)}, dst={set(p['dst_port'] for p in pkts)}")
-        
-        # Show first few discovery packets in detail
-        discovery_pkts = [p for p in packets if p['type'] == 'discovery']
-        if discovery_pkts:
-            print(f"\nFirst 5 discovery packets:")
-            for pkt in discovery_pkts[:5]:
-                print(f"  #{pkt['num']} at {pkt['ts']:.3f}s: {pkt['src_port']} -> {pkt['dst_port']}")
-                # Look for XML-like content
-                data_str = pkt['data'].decode('latin1', errors='ignore')
-                if 'C2D' in data_str or 'D2C' in data_str:
-                    # Try to extract XML tag
-                    start = data_str.find('<')
-                    if start >= 0:
-                        end = data_str.find('>', start)
-                        if end > start:
-                            tag = data_str[start:end+1]
-                            print(f"    Tag: {tag}")
-        
-        return packets
-
-if __name__ == '__main__':
-    neolink_packets = analyze_pcap('neolink.pcapng')
-    print("\n" + "="*60)
-    scrypted_packets = analyze_pcap('scrypted.pcapng')