Add pcap output feature

Change-Id: Ic2471c3bf7c2808d096a0aea90d49e81bdebf023

Author: Hexxeh

src/Interface.test.ts

@@ -6,6 +6,9 @@ import PPPFrame from './ppp/PPPFrame';
 import LCPEncapsulation from './ppp/LCPEncapsulation';
 import { ControlCode } from './ppp/ControlProtocol';
 import { encode } from './encodingUtil';
+import { PcapPacketDirection } from './PcapWriter';
+
+jest.mock('./PcapWriter');
 
 let intf: Interface;
 let sink: BufferSink;
@@ -198,3 +201,25 @@ describe('getLink()', () => {
 
   // TODO: check ping failure triggers LCP restart
 });
+
+describe('pcap writing', () => {
+  let packetWriteSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    intf = Interface.create(sink, '/tmp/not/a/real/path');
+    // eslint-disable-next-line
+    packetWriteSpy = jest.spyOn((intf as any).pcapWriter, 'writePacket');
+  });
+
+  it('writes a received packet', () => {
+    const packet = PPPFrame.build(0xabcd, encode('hello recv!'));
+    intf.write(packet);
+    expect(packetWriteSpy).toBeCalledWith(PcapPacketDirection.IN, packet);
+  });
+
+  it('writes a sent packet', () => {
+    const packet = PPPFrame.build(0xabcd, encode('hello send!'));
+    intf.sendPacket(0xabcd, encode('hello send!'));
+    expect(packetWriteSpy).toBeCalledWith(PcapPacketDirection.OUT, packet);
+  });
+});

src/Interface.ts

@@ -9,10 +9,11 @@ import Event from './util/event';
 import { FrameDecoder } from './framing/decoder';
 import { FrameEncoder } from './framing/encoder';
 import { FrameSplitter } from './framing/splitter';
+import PcapWriter, { PcapPacketDirection } from './PcapWriter';
 
 export default class Interface extends stream.Duplex {
-  static create(phy: stream.Duplex): Interface {
-    const intf = new Interface();
+  static create(phy: stream.Duplex, pcapPath?: string): Interface {
+    const intf = new Interface(pcapPath);
     const splitter = new FrameSplitter();
     const decoder = new FrameDecoder();
     const encoder = new FrameEncoder();
@@ -24,9 +25,13 @@ export default class Interface extends stream.Duplex {
     return intf;
   }
 
-  constructor() {
+  constructor(pcapPath?: string) {
     super({ objectMode: true, allowHalfOpen: false });
 
+    if (pcapPath) {
+      this.pcapWriter = new PcapWriter(pcapPath, PcapWriter.linkTypePPPWithDir);
+    }
+
     this.lcp.addListener('linkUp', this.onLinkUp.bind(this));
     this.lcp.addListener('linkDown', this.onLinkDown.bind(this));
 
@@ -41,11 +46,16 @@ export default class Interface extends stream.Duplex {
   private lcp = new LinkControlProtocol(this);
   private link?: Link;
   private linkAvailable = new Event();
+  private pcapWriter?: PcapWriter;
 
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   _read(): void {}
 
   _write(chunk: Buffer, _: string, callback: (err?: Error) => void): void {
+    if (this.pcapWriter) {
+      this.pcapWriter.writePacket(PcapPacketDirection.IN, chunk);
+    }
+
     let frame: PPPFrame;
     try {
       frame = PPPFrame.parse(chunk);
@@ -100,6 +110,9 @@ export default class Interface extends stream.Duplex {
       )}`,
     );
     const datagram = PPPFrame.build(protocol, packet);
+    if (this.pcapWriter) {
+      this.pcapWriter.writePacket(PcapPacketDirection.OUT, datagram);
+    }
     this.push(datagram);
   }
 

src/PcapWriter.test.ts

@@ -0,0 +1,59 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import PcapWriter, { PcapPacketDirection } from './PcapWriter';
+import { encode } from './encodingUtil';
+
+const tmpPath = path.join(os.tmpdir(), 'test.cap');
+
+let writer: PcapWriter;
+
+beforeEach(() => {
+  writer = new PcapWriter(tmpPath, 0xcafef00d);
+});
+
+afterEach(() => {
+  writer.close();
+});
+
+it('writes the requested link type in the header', () => {
+  const header = fs.readFileSync(tmpPath);
+  expect(header).toEqual(
+    encode(
+      '\xa1\xb2\xc3\xd4\x00\x02\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xca\xfe\xf0\x0d',
+    ),
+  );
+});
+
+it('writes a received packet to the pcap file', () => {
+  const data = encode('hello world!');
+  const dateNowSpy = jest.spyOn(Date, 'now');
+  dateNowSpy.mockReturnValueOnce(1638452221234);
+  writer.writePacket(PcapPacketDirection.IN, data);
+  const packet = fs.readFileSync(tmpPath).slice(24);
+  expect(packet).toEqual(
+    encode(
+      '\x61\xa8\xcb\xfd\x00\x03\x92\x10\x00\x00\x00\x0c\x00\x00\x00\x0c\x00hello world!',
+    ),
+  );
+});
+
+it('writes a sent packet to the pcap file', () => {
+  const data = encode('hello world!');
+  const dateNowSpy = jest.spyOn(Date, 'now');
+  dateNowSpy.mockReturnValueOnce(1638452221234);
+  writer.writePacket(PcapPacketDirection.OUT, data);
+  const packet = fs.readFileSync(tmpPath).slice(24);
+  expect(packet).toEqual(
+    encode(
+      '\x61\xa8\xcb\xfd\x00\x03\x92\x10\x00\x00\x00\x0c\x00\x00\x00\x0c\x01hello world!',
+    ),
+  );
+});
+
+it('writing a packet larger than 65k throws', () => {
+  expect(() =>
+    writer.writePacket(PcapPacketDirection.OUT, Buffer.alloc(0x10000)),
+  ).toThrowError('Data too large to write to pcap file');
+});

src/PcapWriter.ts

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+
+export enum PcapPacketDirection {
+  IN = 0,
+  OUT = 1,
+}
+export default class PcapWriter {
+  static linkTypePPPWithDir = 204;
+
+  private fd: number;
+
+  constructor(path: string, linkType: number) {
+    this.fd = fs.openSync(path, 'w');
+    this.writeHeader(linkType);
+  }
+
+  public close(): void {
+    fs.closeSync(this.fd);
+  }
+
+  private writeHeader(linkType: number): void {
+    const buf = Buffer.alloc(24);
+    let offset = 0;
+
+    // magic_number
+    buf.writeUInt32BE(0xa1b2c3d4, offset);
+    offset += 4;
+
+    // version_major
+    buf.writeUInt16BE(2, offset);
+    offset += 2;
+
+    // version_minor
+    buf.writeUInt16BE(4, offset);
+    offset += 2;
+
+    // thiszone (GMT to local time correction)
+    buf.writeInt32BE(0, offset);
+    offset += 4;
+
+    // sigfigs (accuracy of timestamps)
+    buf.writeUInt32BE(0, offset);
+    offset += 4;
+
+    // snaplen (max length of captured packets, in octets)
+    buf.writeUInt32BE(65535, offset);
+    offset += 4;
+
+    // network
+    buf.writeUInt32BE(linkType, offset);
+
+    fs.writeSync(this.fd, buf);
+  }
+
+  writePacket(direction: PcapPacketDirection, data: Buffer): void {
+    if (data.byteLength > 0xffff) {
+      throw new Error('Data too large to write to pcap file');
+    }
+
+    const buf = Buffer.alloc(17);
+
+    const timestamp = Date.now();
+    const seconds = Math.floor(timestamp / 1000);
+    const microseconds = (timestamp - seconds * 1000) * 1000;
+
+    let offset = buf.writeUInt32BE(seconds);
+    offset = buf.writeUInt32BE(microseconds, offset);
+    offset = buf.writeUInt32BE(data.byteLength, offset);
+    offset = buf.writeUInt32BE(data.byteLength, offset);
+    buf.writeUInt8(direction, offset);
+
+    fs.writeSync(this.fd, buf);
+    fs.writeSync(this.fd, data);
+  }
+}