node-netlink 0.0.1 → 0.0.2

package/README.md

@@ -1,2 +1,3 @@
 # node-netlink
+[![Build Status](https://travis-ci.org/k13-engineering/node-netlink.svg?branch=master)](https://travis-ci.org/k13-engineering/node-netlink)<br/>
 netlink bindings for node.js

package/lib/error.js

@@ -0,0 +1,50 @@
+const knownErrors = {
+  EPERM: {
+    code: 1,
+    message: "Operation not permitted",
+  },
+  ENOENT: {
+    code: 2,
+    message: "No such file or directory",
+  },
+  EAGAIN: {
+    code: 11,
+    message: "Resource temporarily unavailable",
+  },
+  EEXIST: {
+    code: 17,
+    message: "File already exists",
+  },
+  ENODEV: {
+    code: 19,
+    message: "No such device",
+  },
+  EINVAL: {
+    code: 22,
+    message: "Invalid argument",
+  },
+  ENOTSUP: {
+    code: 48,
+    message: "Operation not supported",
+  },
+};
+
+const createFromErrorCode = ({ errorCode, message }) => {
+  const knownErrorKey = Object.keys(knownErrors).find((key) => {
+    return knownErrors[key].code === errorCode;
+  });
+
+  if (knownErrorKey) {
+    const knownError = knownErrors[knownErrorKey];
+    const errorObject = new Error(`${message ? `${message}: ` : ""}${knownError.message}`);
+    errorObject.code = knownError.code;
+    errorObject.errno = errorCode;
+    return errorObject;
+  } else {
+    return new Error(`${message ? `${message}: ` : ""}unknown error code ${errorCode}`);
+  }
+};
+
+export default {
+  createFromErrorCode,
+};

package/lib/index.js

@@ -0,0 +1,259 @@
+import socket from "po6-socket";
+import EventEmitter from "events";
+
+import structures from "./structures.js";
+import netlinkParser from "./parser.js";
+import errorFactory from "./error.js";
+
+const AF_NETLINK = 16n;
+const SOCK_DGRAM = 2n;
+
+const NLM_F_ECHO = 8n;
+const NLM_F_REQUEST = 1n;
+const NLM_F_MULTI = 2n;
+const NLM_F_MATCH = 0x200n;
+const NLM_F_DUMP = 0x300n;
+const NLM_F_ACK = 4n;
+const NLM_F_CREATE = 0x400n;
+const NLM_F_EXCL = 0x200n;
+
+const NLMSG_ERROR = 2n;
+const NLMSG_DONE = 3n;
+
+const open = ({ family, pid, groups }) => {
+  const emitter = new EventEmitter();
+
+  return socket
+    .create({
+      domain: AF_NETLINK,
+      type: SOCK_DGRAM,
+      protocol: BigInt(family),
+    })
+    .then((sock) => {
+      const netlinkAddress = structures.sockaddr_nl.format({
+        nl_family: AF_NETLINK,
+        nl_pid: BigInt(pid || 0),
+        nl_groups: BigInt(groups || 0),
+      });
+
+      const close = () => {
+        return sock.close();
+      };
+
+      sock.on("message", ({ data }) => {
+        const parsedPackets = netlinkParser.parseMessage({ message: data });
+
+        parsedPackets.forEach((packet) => {
+          emitter.emit("message", packet);
+        });
+      });
+
+      let seq = 1n;
+
+      const send = ({ header: requestedHeader, payload }) => {
+        let header = Object.assign({}, requestedHeader);
+
+        if (header.nlmsg_seq === undefined) {
+          header = Object.assign({}, header, {
+            nlmsg_seq: seq,
+          });
+          seq += 1n;
+        }
+
+        if (header.nlmsg_pid === undefined) {
+          header = Object.assign({}, header, {
+            // "nlmsg_pid": nl_pid
+          });
+        }
+
+        header = Object.assign({}, header, {
+          nlmsg_len: BigInt(structures.nlmsghdr.size) + BigInt(payload.length),
+        });
+
+        const headerAsBuf = structures.nlmsghdr.format(header);
+
+        const data = Buffer.concat([headerAsBuf, payload]);
+
+        const destBuffer = structures.sockaddr_nl.format({
+          nl_family: AF_NETLINK,
+        });
+
+        // TODO: flags
+
+        return sock.sendmsg({
+          data,
+          msghdr: {
+            msg_name: destBuffer,
+          },
+        });
+      };
+
+      let requested = {};
+
+      const maybeAppendMessageToResponse = ({ message }) => {
+        const { header } = message;
+
+        if (header.nlmsg_type === NLMSG_DONE) {
+          return;
+        }
+
+        requested = {
+          [header.nlmsg_seq]: {
+            ...requested[header.nlmsg_seq],
+            msgs: [...(requested[header.nlmsg_seq]?.msgs || []), message],
+          },
+        };
+      };
+
+      const maybeFinishRequest = ({ message }) => {
+        const { header } = message;
+        const req = requested[header.nlmsg_seq];
+
+        const isLast =
+          header.nlmsg_type === NLMSG_ERROR || header.nlmsg_type === NLMSG_DONE;
+
+        if (isLast) {
+          clearTimeout(req.schedule);
+          req.resolve(req.msgs);
+
+          const { [header.nlmsg_seq]: unused, ...other } = requested;
+          requested = other;
+        }
+      };
+
+      const processResponse = ({ message }) => {
+        const { header } = message;
+        const req = requested[header.nlmsg_seq];
+
+        if (!req) {
+          console.warn(
+            `could not find pending request for seq=${header.nlmsg_seq}`
+          );
+          console.warn(`nlmsg_type = ${header.nlmsg_type}`);
+
+          return;
+        }
+
+        maybeAppendMessageToResponse({ message });
+        maybeFinishRequest({ message });
+      };
+
+      emitter.on("message", (message) => {
+        const { header } = message;
+
+        if (header.nlmsg_flags & NLM_F_REQUEST) {
+          return;
+        }
+
+        if (header.nlmsg_seq === 0) {
+          return;
+        }
+
+        processResponse({ message });
+      });
+
+      const tryTalk = (message, { timeout = 10000 } = {}) => {
+        if (!(message.header.nlmsg_flags & NLM_F_ACK)) {
+          throw new Error(`talk only supports requests with NLM_F_ACK set`);
+        }
+
+        return Promise.resolve()
+          .then(() => {
+            return new Promise((resolve, reject) => {
+              const header = Object.assign({}, message.header, {
+                nlmsg_seq: seq,
+              });
+              seq += 1n;
+
+              const schedule = setTimeout(() => {
+                const { [header.nlmsg_seq]: unused, ...other } = requested;
+                requested = other;
+
+                reject(new Error("timeout reached"));
+              }, timeout);
+
+              requested = {
+                ...requested,
+                [header.nlmsg_seq]: {
+                  msgs: [],
+                  schedule,
+                  resolve,
+                },
+              };
+
+              send({
+                header,
+                payload: message.payload,
+              }).catch(reject);
+            });
+          })
+          .then((packets) => {
+            let errorCode = 0;
+
+            const packetsWithoutError = packets.filter((pkt) => {
+              if (pkt.header.nlmsg_type === NLMSG_ERROR) {
+                const packetErrorCode = pkt.payload.readInt32LE(0);
+                if (packetErrorCode !== 0) {
+                  errorCode = -packetErrorCode;
+                }
+                return false;
+              } else {
+                return true;
+              }
+            });
+
+            return {
+              errorCode,
+              packets: packetsWithoutError,
+            };
+          });
+      };
+
+      const talk = (obj, options) => {
+        return tryTalk(obj, options).then(({ errorCode, packets }) => {
+          if (errorCode !== 0) {
+            throw errorFactory.createFromErrorCode({ errorCode });
+          }
+
+          return packets;
+        });
+      };
+
+      return sock
+        .bind({
+          sockaddr: netlinkAddress,
+        })
+        .then(() => {
+          return sock.getsockname();
+        })
+        .then((actualAddressBuffer) => {
+          const { nl_pid } = structures.sockaddr_nl.parse(actualAddressBuffer);
+
+          return {
+            nl_pid,
+
+            talk,
+            tryTalk,
+            close,
+            on: emitter.on.bind(emitter),
+          };
+        });
+    });
+};
+
+export default {
+  NLM_F_ECHO,
+  NLM_F_REQUEST,
+  NLM_F_MULTI,
+  NLM_F_DUMP,
+  NLM_F_ACK,
+  NLM_F_CREATE,
+  NLM_F_EXCL,
+  NLM_F_MATCH,
+
+  NLMSG_DONE,
+  NLMSG_ERROR,
+
+  open,
+  createErrorFromErrorCode: errorFactory.createFromErrorCode,
+};

package/lib/parser.js

@@ -0,0 +1,55 @@
+import structures from "./structures.js";
+
+const align4 = (addr) => {
+  return (addr + 3) & ~3;
+};
+
+const parseNetlinkMessage = ({ message }) => {
+  const parsed = structures.nlmsghdr.parse(message);
+
+  const header = {
+    nlmsg_type: parsed.nlmsg_type,
+    nlmsg_flags: parsed.nlmsg_flags,
+    nlmsg_seq: parsed.nlmsg_seq,
+    nlmsg_pid: parsed.nlmsg_pid
+  };
+
+  const payloadOffset = align4(structures.nlmsghdr.size);
+  const payloadLength = parsed.nlmsg_len - BigInt(payloadOffset);
+
+  if (payloadLength < 0) {
+    throw new Error("negative payload length, packet malformed");
+  }
+
+  const payload = message.slice(payloadOffset, payloadOffset + Number(payloadLength));
+  const space = align4(payloadOffset + payload.length);
+
+  return {
+    header,
+    payload,
+    space
+  };
+};
+
+const parseMessage = ({ message }) => {
+  let result = [];
+
+  let remaining = message;
+  while (remaining.length > 0) {
+    const { header, payload, space } = parseNetlinkMessage({ message: remaining });
+    const parsed = {
+      header,
+      payload
+    };
+
+    result = [...result, parsed ];
+
+    remaining = remaining.slice(space);
+  }
+
+  return result;
+};
+
+export default {
+  parseMessage
+};

package/lib/structures.js

@@ -0,0 +1,21 @@
+import struct from "ya-struct";
+
+const sockaddr_nl = struct.define(({ field }) => {
+  field.UInt16("nl_family");
+  field.UInt16("nl_pad");
+  field.UInt32("nl_pid");
+  field.UInt32("nl_groups");
+}).forHost();
+
+const nlmsghdr = struct.define(({ field }) => {
+  field.UInt32("nlmsg_len");
+  field.UInt16("nlmsg_type");
+  field.UInt16("nlmsg_flags");
+  field.UInt32("nlmsg_seq");
+  field.UInt32("nlmsg_pid");
+}).forHost();
+
+export default {
+  sockaddr_nl,
+  nlmsghdr
+};

package/package.json

@@ -1,23 +1,28 @@
 {
   "name": "node-netlink",
-  "version": "0.0.1",
+  "type": "module",
+  "version": "0.0.2",
   "description": "netlink bindings for node.js",
-  "main": "index.js",
+  "main": "lib/index.js",
   "scripts": {
-    "test": "mocha"
+    "test": "c8 --reporter lcov --reporter html --reporter text mocha",
+    "eslint": "eslint ."
   },
   "dependencies": {
-    "nan": "^2.10.0"
+    "po6-socket": "^0.0.1",
+    "ya-struct": "^0.0.4"
   },
   "devDependencies": {
-    "mocha": "^5.2.0"
+    "c8": "^7.10.0",
+    "eslint": "^7.32.0",
+    "mocha": "^9.1.3"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/k13-engineering/node-netlink.git"
   },
   "author": "Simon Kadisch",
-  "license": "GPL-3.0",
+  "license": "LGPL 2.1",
   "bugs": {
     "url": "https://github.com/k13-engineering/node-netlink/issues"
   },

package/samples/test.js

@@ -0,0 +1,11 @@
+import netlink from "../lib/index.js";
+
+const NETLINK_ROUTE = 0;
+
+netlink.open({
+  family: NETLINK_ROUTE
+}).then((nl) => {
+  nl.close();
+}).catch((err) => {
+  console.error(err);
+});

package/test/base.js

@@ -1,4 +1,7 @@
-const netlink = require("../index.js");
+/* global describe */
+/* global it */
+
+import netlink from "../lib/index.js";
 
 const NETLINK_ROUTE = 0;
 
@@ -7,10 +10,11 @@ describe("opening", function () {
 
   describe("normal case", () => {
     it("should open without error", () => {
-      const nl = netlink.open({
-        "family": NETLINK_ROUTE
+      netlink.open({
+        family: NETLINK_ROUTE
+      }).then((nl) => {
+        return nl.close();
       });
-      nl.close();
     });
   });
 });

package/.npmignore

@@ -1,61 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-bower_components
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules/
-jspm_packages/
-
-# Typescript v1 declaration files
-typings/
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# dotenv environment variables file
-.env
-
-build/
-package-lock.json

package/binding.gyp

@@ -1,11 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "netlink-native",
-      "sources": [ "native/netlink.cc" ],
-      "include_dirs": [
-        "<!(node -e \"require('nan')\")"
-      ]
-    }
-  ]
-}

package/index.js

@@ -1,150 +0,0 @@
-const assert = require("assert");
-const fs = require("fs");
-const EventEmitter = require("events");
-
-const native = require("./build/Release/netlink-native.node");
-
-const AF_NETLINK = 16;
-const SOCK_DGRAM = 2;
-
-const NLM_F_ECHO = 8;
-const NLM_F_REQUEST = 1;
-const NLM_F_MULTI = 2;
-const NLM_F_DUMP = 0x300;
-const NLM_F_ACK = 4;
-const NLM_F_CREATE = 0x400;
-const NLM_F_EXCL = 0x200;
-
-const NLMSG_ERROR = 2;
-const NLMSG_DONE = 3;
-
-const open = (opts) => {
-  const family = opts.family;
-  assert(typeof family === "number" && !isNaN(family) && family >= 0, "opts.family should be a positive integer");
-
-  const emitter = new EventEmitter();
-
-  const n = new native.NetlinkSocket(opts.family, (msg) => {
-    emitter.emit("message", msg);
-  });
-
-  let requested = {};
-
-  emitter.on("message", (msg) => {
-    // console.log("msg =", msg);
-
-    msg.forEach((part) => {
-      if (!(part.header.nlmsg_flags & NLM_F_REQUEST)) {
-        if (part.header.nlmsg_seq > 0) {
-          const req = requested[part.header.nlmsg_seq];
-
-          if (req) {
-            req.multi |= part.header.nlmsg_flags & NLM_F_MULTI;
-
-            if (part.header.nlmsg_type === NLMSG_ERROR) {
-              const err = part.payload.readInt32LE(0);
-
-              if (err === 0) {
-                req.cb(null, []);
-              } else {
-                req.cb(err);
-              }
-            } else {
-              if (req.multi) {
-                req.msgs = req.msgs.concat([part]);
-
-                if (part.header.nlmsg_type === NLMSG_DONE) {
-                  req.cb(null, req.msgs);
-                }
-              } else {
-                req.cb(null, [part]);
-              }
-            }
-          } else {
-            console.warn("could not find pending request for seq=" + part.header.nlmsg_seq);
-          }
-        }
-      }
-    });
-  });
-
-  let seq = 1;
-
-  const send = (obj) => new Promise((resolve, reject) => {
-    assert(typeof obj.header === "object" &&
-      !Buffer.isBuffer(obj.header) &&
-      !Array.isArray(obj.header), "header must be an object");
-
-    let header = Object.assign({}, obj.header);
-
-    if (header.nlmsg_seq === undefined) {
-      header = Object.assign({}, header, {
-        "nlmsg_seq": seq
-      });
-      seq += 1;
-    }
-
-    n.send(header, obj.payload, obj.flags, (err) => {
-      resolve();
-    });
-  });
-
-  const talk = (obj) => {
-    return new Promise((resolve, reject) => {
-      const header = Object.assign({}, obj.header, {
-        "nlmsg_seq": seq
-      });
-      seq += 1;
-
-      const schedule = setTimeout(() => {
-        Reflect.deleteProperty(requested, header.nlmsg_seq);
-        reject(new Error("timeout reached"));
-      }, obj.timeout || 10000);
-
-      requested[header.nlmsg_seq] = {
-        "msgs": [],
-        "multi": false,
-        "schedule": schedule,
-        "cb": (err, data) => {
-          clearTimeout(schedule);
-          Reflect.deleteProperty(requested, header.nlmsg_seq);
-
-          if (err) {
-            reject(err);
-          } else {
-            resolve(data);
-          }
-        }
-      };
-
-      send({
-        "header": header,
-        "payload": obj.payload
-      }).catch(reject);
-    });
-  };
-
-
-  return Object.freeze({
-    send,
-    talk,
-    "on": emitter.on.bind(emitter),
-    "once": emitter.once.bind(emitter),
-    "close": () => n.close()
-  });
-};
-
-module.exports = {
-  NLM_F_ECHO,
-  NLM_F_REQUEST,
-  NLM_F_MULTI,
-  NLM_F_DUMP,
-  NLM_F_ACK,
-  NLM_F_CREATE,
-  NLM_F_EXCL,
-  
-  NLMSG_DONE,
-  NLMSG_ERROR,
-
-  open
-};