penguins-eggs 10.1.1 → 25.7.7

package/dist/dhcpd-proxy/interfaces/i-pxe.js

@@ -0,0 +1 @@
+export {};

package/dist/dhcpd-proxy/lib/packet/converters.d.ts

@@ -0,0 +1,11 @@
+export default function (i: any): any;
+/**
+ * error TS7053: Element implicitly has an 'any' type because expression
+ * of type 'any' can't be used to index type:
+{
+  '1': { encode: [Function: writeIp], decode: [Function: readIp] },
+  '2': { encode: [Function: encode], decode: [Function: decode] },
+  ...
+  '255': { encode: [Function: encode], decode: [Function: decode] }
+}
+*/

package/dist/dhcpd-proxy/lib/packet/converters.js

@@ -0,0 +1,395 @@
+/**
+ * converters.js
+ *
+ * used by dhcpd-proxy
+ */
+import { writeIp, readIp, writeInt32, readInt32, writeString, readString, writeInt8, readInt8, writeBytes, writeInt16, readInt16, } from "../utils.js";
+import sprintf from "../sprintf.js";
+/**
+ * converters
+ */
+const converters = {
+    // option 1: subnet mask
+    1: {
+        encode: writeIp,
+        decode: readIp,
+    },
+    // option 2: time offset
+    2: {
+        encode: function encode(buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 4;
+            writeInt32(buf, value, offset);
+            return offset + 4;
+        },
+        decode: function decode(buf) {
+            return readInt32(buf, 0);
+        },
+    },
+    // option 3: routers
+    3: {
+        decode: function decode(buf) {
+            let i, numRecords, pos, records;
+            numRecords = buf.length / 4;
+            pos = 0;
+            records = [];
+            i = 0;
+            while (i < numRecords) {
+                records.push(sprintf("%d.%d.%d.%d", buf[pos++], buf[pos++], buf[pos++], buf[pos++]));
+                i++;
+            }
+            return records;
+        },
+        encode: function encode(buf, num, data, offset) {
+            let routers;
+            routers = data;
+            buf[offset++] = num;
+            buf[offset++] = routers.length * 4;
+            routers.forEach(function (ip) {
+                return ip.split(".").forEach(function (item) {
+                    buf[offset++] = item;
+                });
+            });
+            return offset;
+        },
+    },
+    // option 6: dns servers
+    6: {
+        decode: function (buf) {
+            let i, numRecords, pos, records;
+            numRecords = buf.length / 4;
+            pos = 0;
+            records = [];
+            i = 0;
+            while (i < numRecords) {
+                records.push(sprintf("%d.%d.%d.%d", buf[pos++], buf[pos++], buf[pos++], buf[pos++]));
+                i++;
+            }
+            return records;
+        },
+        encode: function (buf, num, data, offset) {
+            let routers;
+            routers = data.split(",");
+            buf[offset++] = num;
+            buf[offset++] = routers.length * 4;
+            routers.forEach(function (ip) {
+                return ip.split(".").forEach(function (item) {
+                    buf[offset++] = item;
+                });
+            });
+            return offset;
+        },
+    },
+    /*
+      // option 119: dns search list
+      119: {
+        encode: null,
+        decode: null
+      },
+      */
+    // option 12: hostname
+    12: {
+        encode: writeString,
+        decode: readString,
+    },
+    // option 15: dns domain name
+    15: {
+        encode: writeString,
+        decode: readString,
+    },
+    // option 28: broadcast address
+    28: {
+        encode: writeIp,
+        decode: readIp,
+    },
+    // option 31: router discovery
+    31: {
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 1;
+            writeInt8(buf, value, offset);
+            return offset + 1;
+        },
+        decode: function (buf) {
+            return readInt8(buf, 0);
+        },
+    },
+    // option 33: static routes
+    33: {
+        decode: function decode(buf) {
+            let i, numRecords, pos, records;
+            numRecords = buf.length / 4;
+            pos = 0;
+            records = [];
+            i = 0;
+            while (i < numRecords) {
+                records.push(sprintf("%d.%d.%d.%d", buf[pos++], buf[pos++], buf[pos++], buf[pos++]));
+                i++;
+            }
+            return records;
+        },
+        encode: function encode(buf, num, data, offset) {
+            let routers;
+            routers = data.split(",");
+            buf[offset++] = num;
+            buf[offset++] = routers.length * 4;
+            routers.forEach(function (ip) {
+                return ip.split(".").forEach(function (item) {
+                    buf[offset++] = item;
+                });
+            });
+            return offset;
+        },
+    },
+    // option 43: vendor specific information
+    43: {
+        decode: function (buf) {
+            const records = [];
+            let i = 0;
+            const len = buf.length;
+            while (i < len) {
+                records.push(sprintf("%02x", buf[i]));
+                i++;
+            }
+            return records.join(":");
+        },
+        encode: function (buf, num, data, offset) {
+            const vendorinfo = data.split(":");
+            buf[offset++] = num;
+            buf[offset++] = vendorinfo.length;
+            vendorinfo.forEach(function (hex) {
+                buf[offset++] = parseInt(hex, 16);
+            });
+            return offset;
+        },
+    },
+    // option 44: netbios name servers
+    44: {
+        decode: function (buf) {
+            let i, numRecords, pos, records;
+            numRecords = buf.length / 4;
+            pos = 0;
+            records = [];
+            i = 0;
+            while (i < numRecords) {
+                records.push(sprintf("%d.%d.%d.%d", buf[pos++], buf[pos++], buf[pos++], buf[pos++]));
+                i++;
+            }
+            return records;
+        },
+        encode: function (buf, num, data, offset) {
+            let routers;
+            routers = data.split(",");
+            buf[offset++] = num;
+            buf[offset++] = routers.length * 4;
+            routers.forEach(function (ip) {
+                return ip.split(".").forEach(function (item) {
+                    buf[offset++] = item;
+                });
+            });
+            return offset;
+        },
+    },
+    // option 46: netbios node type
+    46: {
+        decode: function (buf) {
+            return parseInt(buf[0], 16);
+        },
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 1;
+            buf[offset++] = parseInt(buf[0], 10).toString(16);
+            return offset;
+        },
+    },
+    // option 47: netbios node type
+    47: {
+        encode: writeString,
+        decode: readString,
+    },
+    // option 50: requested ip address
+    50: {
+        encode: writeIp,
+        decode: readIp,
+    },
+    // option 51: lease time
+    51: {
+        decode: function (buf) {
+            return readInt32(buf, 0);
+        },
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 4;
+            writeInt32(buf, value, offset);
+            return offset + 4;
+        },
+    },
+    // option 53: message type
+    53: {
+        decode: function (buf) {
+            return parseInt(buf[0], 10);
+        },
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = 53;
+            buf[offset++] = 1;
+            buf[offset++] = value;
+            return offset;
+        },
+    },
+    // option 54: server identifier
+    54: {
+        encode: writeIp,
+        decode: function decode(buf) {
+            return readIp(buf, 0);
+        },
+    },
+    // option 55: parameter request list
+    55: {
+        decode: function decode(buf) {
+            const records = [];
+            let i = 0;
+            const len = buf.length;
+            while (i < len) {
+                records[i] = buf[i];
+                i++;
+            }
+            return records;
+        },
+        encode: function encode(buf, num, data, offset) {
+            buf[offset++] = num;
+            buf[offset++] = data.length;
+            writeBytes(buf, data, offset);
+            //      var i = 0;
+            //      while(i < data.length) {
+            //        utils.writeBytes(buf, data[i], offset);
+            //        i++;
+            //        offset++;
+            //      }
+            return offset;
+        },
+    },
+    // option 57: max message size
+    57: {
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = 57;
+            buf[offset++] = 2;
+            writeInt16(buf, value, offset);
+            return offset + 2;
+        },
+        decode: function (buf) {
+            return readInt16(buf, 0);
+        },
+    },
+    // option 60: vendor class identifier
+    60: {
+        encode: writeString,
+        decode: readString,
+    },
+    // option 61: client identifier
+    61: {
+        encode: function (buf, num, value, offset) {
+            return offset;
+        },
+        decode: function (buf) {
+            let j, s, type;
+            s = [];
+            type = buf[0];
+            j = 1;
+            while (j < buf.length) {
+                s.push(sprintf("%02x", buf[j]));
+                j++;
+            }
+            return [type, s.join(":")];
+        },
+    },
+    // option 67: bootfile name
+    67: {
+        encode: writeString,
+        decode: readString,
+    },
+    // option 77: user class information
+    77: {
+        encode: writeString,
+        decode: function (buf) {
+            const records = [];
+            let offset = 0;
+            while (buf[offset]) {
+                const uc_len = buf[offset];
+                const uc_data = buf.slice(offset++, uc_len);
+                offset += uc_len;
+                records.push(uc_data.toString("ascii"));
+            }
+            return records.join(":");
+        },
+    },
+    // option 83: client fqdn
+    83: {
+        encode: function (buf, num, value, offset) {
+            return offset;
+        },
+        decode: function (buf) {
+            let ret;
+            ret = "";
+            ret += sprintf("%d", buf[0]) + "-";
+            ret += sprintf("%d", buf[1]) + "-";
+            ret += sprintf("%d", buf[2]) + " ";
+            // CHECK
+            //ret += utils.toString(buf.slice(3));
+            ret += buf.slice(3).toString();
+            return ret;
+        },
+    },
+    // option 175: etherboot
+    175: {
+        encode: function (buf, num, value, offset) {
+            return offset;
+        },
+        decode: function (buf) {
+            let j, s;
+            s = [];
+            j = 1;
+            while (j < buf.length) {
+                s.push(sprintf("%02x", buf[j]));
+                j++;
+            }
+            return s.join(":");
+        },
+    },
+    // option 255: end
+    255: {
+        encode: function (buf, num, value, offset) {
+            writeInt8(buf, 255, offset);
+            return offset + 1;
+        },
+        decode: function (buf) {
+            return undefined;
+        },
+    },
+};
+const stub = {
+    encode: function (buf, num, value, offset) {
+        //    console.error("[dhcproxy] encoder for option " + num + " not found");
+        return offset;
+    },
+    decode: function (buf, num) {
+        //    console.error("[dhcproxy] decoder for option  " + num + " not found");
+        //    console.log("  buffer:", buf);
+        return null;
+    },
+};
+export default function (i) {
+    if (i == 67 || i == 66) {
+        console.log("GET CONVERTER FOR " + i);
+    }
+    return i in converters ? converters[i] : stub;
+}
+/**
+ * error TS7053: Element implicitly has an 'any' type because expression
+ * of type 'any' can't be used to index type:
+{
+  '1': { encode: [Function: writeIp], decode: [Function: readIp] },
+  '2': { encode: [Function: encode], decode: [Function: decode] },
+  ...
+  '255': { encode: [Function: encode], decode: [Function: decode] }
+}
+*/

package/dist/dhcpd-proxy/lib/packet/message-types.d.ts

@@ -0,0 +1,10 @@
+export declare enum DhcpMessageType {
+    DHCPDISCOVER = 1,
+    DHCPOFFER = 2,
+    DHCPREQUEST = 3,
+    DHCPDECLINE = 4,
+    DHCPACK = 5,
+    DHCPNAK = 6,
+    DHCPRELEASE = 7,
+    DHCPINFORM = 8
+}

package/dist/dhcpd-proxy/lib/packet/message-types.js

@@ -0,0 +1,12 @@
+// etrick/src/lib/packet/message-types.ts
+export var DhcpMessageType;
+(function (DhcpMessageType) {
+    DhcpMessageType[DhcpMessageType["DHCPDISCOVER"] = 1] = "DHCPDISCOVER";
+    DhcpMessageType[DhcpMessageType["DHCPOFFER"] = 2] = "DHCPOFFER";
+    DhcpMessageType[DhcpMessageType["DHCPREQUEST"] = 3] = "DHCPREQUEST";
+    DhcpMessageType[DhcpMessageType["DHCPDECLINE"] = 4] = "DHCPDECLINE";
+    DhcpMessageType[DhcpMessageType["DHCPACK"] = 5] = "DHCPACK";
+    DhcpMessageType[DhcpMessageType["DHCPNAK"] = 6] = "DHCPNAK";
+    DhcpMessageType[DhcpMessageType["DHCPRELEASE"] = 7] = "DHCPRELEASE";
+    DhcpMessageType[DhcpMessageType["DHCPINFORM"] = 8] = "DHCPINFORM";
+})(DhcpMessageType || (DhcpMessageType = {}));

package/dist/dhcpd-proxy/lib/packet/options.d.ts

@@ -0,0 +1,8 @@
+/**
+ * options.ts
+ *
+ * used in dhcpd
+ *
+ */
+declare const _default: string[];
+export default _default;