penguins-eggs 25.10.23 → 25.10.24

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;

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

@@ -0,0 +1,264 @@
+/**
+ * options.ts
+ *
+ * used in dhcpd
+ *
+ */
+export default [
+    "pad", // riempie lo zero
+    /*  1 */ "Subnet mask",
+    /*  2 */ "Time offset",
+    /*  3 */ "Routers",
+    /*  4 */ "Time server",
+    /*  5 */ "Name server",
+    /*  6 */ "DNS server",
+    /*  7 */ "Log server",
+    /*  8 */ "Cookie server",
+    /*  9 */ "LPR server",
+    /* 10 */ "Impress server",
+    /* 11 */ "Resource location server",
+    /* 12 */ "Host name",
+    /* 13 */ "Boot file size",
+    /* 14 */ "Merit dump file",
+    /* 15 */ "Domainname",
+    /* 16 */ "Swap server",
+    /* 17 */ "Root path",
+    /* 18 */ "Extensions path",
+    /* 19 */ "IP forwarding",
+    /* 20 */ "Non-local source routing",
+    /* 21 */ "Policy filter",
+    /* 22 */ "Maximum datagram reassembly size",
+    /* 23 */ "Default IP TTL",
+    /* 24 */ "Path MTU aging timeout",
+    /* 25 */ "Path MTU plateau table",
+    /* 26 */ "Interface MTU",
+    /* 27 */ "All subnets local",
+    /* 28 */ "Broadcast address",
+    /* 29 */ "Perform mask discovery",
+    /* 30 */ "Mask supplier",
+    /* 31 */ "Perform router discovery",
+    /* 32 */ "Router solicitation",
+    /* 33 */ "Static route",
+    /* 34 */ "Trailer encapsulation",
+    /* 35 */ "ARP cache timeout",
+    /* 36 */ "Ethernet encapsulation",
+    /* 37 */ "TCP default TTL",
+    /* 38 */ "TCP keepalive interval",
+    /* 39 */ "TCP keepalive garbage",
+    /* 40 */ "NIS domain",
+    /* 41 */ "NIS servers",
+    /* 42 */ "NTP servers",
+    /* 43 */ "Vendor specific info",
+    /* 44 */ "NetBIOS name server",
+    /* 45 */ "NetBIOS datagram distribution server",
+    /* 46 */ "NetBIOS node type",
+    /* 47 */ "NetBIOS scope",
+    /* 48 */ "X Window System font server",
+    /* 49 */ "X Window System display server",
+    /* 50 */ "Request IP address",
+    /* 51 */ "IP address leasetime",
+    /* 52 */ "Option overload",
+    /* 53 */ "DHCP message type",
+    /* 54 */ "Server identifier",
+    /* 55 */ "Parameter Request List",
+    /* 56 */ "Message",
+    /* 57 */ "Maximum DHCP message size",
+    /* 58 */ "T1",
+    /* 59 */ "T2",
+    /* 60 */ "Vendor class identifier",
+    /* 61 */ "Client-identifier",
+    /* 62 */ "Netware/IP domain name",
+    /* 63 */ "Netware/IP domain information",
+    /* 64 */ "NIS+ domain",
+    /* 65 */ "NIS+ servers",
+    /* 66 */ "TFTP server name",
+    /* 67 */ "Bootfile name",
+    /* 68 */ "Mobile IP home agent",
+    /* 69 */ "SMTP server",
+    /* 70 */ "POP3 server",
+    /* 71 */ "NNTP server",
+    /* 72 */ "WWW server",
+    /* 73 */ "Finger server",
+    /* 74 */ "IRC server",
+    /* 75 */ "StreetTalk server",
+    /* 76 */ "StreetTalk directory assistance server",
+    /* 77 */ "User-class Identification",
+    /* 78 */ "SLP-directory-agent",
+    /* 79 */ "SLP-service-scope",
+    /* 80 */ "Naming Authority",
+    /* 81 */ "Client FQDN",
+    /* 82 */ "Relay Agent Information",
+    /* 83 */ "Agent Remote ID",
+    /* 84 */ "Agent Subnet Mask",
+    /* 85 */ "NDS server",
+    /* 86 */ "NDS tree name",
+    /* 87 */ "NDS context",
+    /* 88 */ "IEEE 1003.1 POSIX",
+    /* 89 */ "FQDN",
+    /* 90 */ "Authentication",
+    /* 91 */ "Vines TCP/IP",
+    /* 92 */ "Server Selection",
+    /* 93 */ "Client System",
+    /* 94 */ "Client NDI",
+    /* 95 */ "LDAP",
+    /* 96 */ "IPv6 Transitions",
+    /* 97 */ "UUID/GUID",
+    /* 98 */ "UPA servers",
+    /* 99 */ "???",
+    /*100 */ "Printer Name",
+    /*101 */ "MDHCP",
+    /*102 */ "???",
+    /*103 */ "???",
+    /*104 */ "???",
+    /*105 */ "???",
+    /*106 */ "???",
+    /*107 */ "???",
+    /*108 */ "Swap Path",
+    /*109 */ "???",
+    /*110 */ "IPX Compatability",
+    /*111 */ "???",
+    /*112 */ "Netinfo Address",
+    /*113 */ "Netinfo Tag",
+    /*114 */ "URL",
+    /*115 */ "DHCP Failover",
+    /*116 */ "DHCP Autoconfiguration",
+    /*117 */ "Name Service Search",
+    /*118 */ "Subnet selection",
+    /*119 */ "Domain Search",
+    /*120 */ "SIP Servers DHCP Option",
+    /*121 */ "Classless Static Route",
+    /*122 */ "???",
+    /*123 */ "???",
+    /*124 */ "???",
+    /*125 */ "???",
+    /*126 */ "Extension",
+    /*127 */ "Extension",
+    /*128 */ "???",
+    /*129 */ "???",
+    /*130 */ "???",
+    /*131 */ "???",
+    /*132 */ "???",
+    /*133 */ "???",
+    /*134 */ "???",
+    /*135 */ "???",
+    /*136 */ "???",
+    /*137 */ "???",
+    /*138 */ "???",
+    /*139 */ "???",
+    /*140 */ "???",
+    /*141 */ "???",
+    /*142 */ "???",
+    /*143 */ "???",
+    /*144 */ "HP - TFTP file",
+    /*145 */ "???",
+    /*146 */ "???",
+    /*147 */ "???",
+    /*148 */ "???",
+    /*149 */ "???",
+    /*150 */ "???",
+    /*151 */ "???",
+    /*152 */ "???",
+    /*153 */ "???",
+    /*154 */ "???",
+    /*155 */ "???",
+    /*156 */ "???",
+    /*157 */ "???",
+    /*158 */ "???",
+    /*159 */ "???",
+    /*160 */ "???",
+    /*161 */ "???",
+    /*162 */ "???",
+    /*163 */ "???",
+    /*164 */ "???",
+    /*165 */ "???",
+    /*166 */ "???",
+    /*167 */ "???",
+    /*168 */ "???",
+    /*169 */ "???",
+    /*170 */ "???",
+    /*171 */ "???",
+    /*172 */ "???",
+    /*173 */ "???",
+    /*174 */ "???",
+    /*175 */ "???",
+    /*176 */ "???",
+    /*177 */ "???",
+    /*178 */ "???",
+    /*179 */ "???",
+    /*180 */ "???",
+    /*181 */ "???",
+    /*182 */ "???",
+    /*183 */ "???",
+    /*184 */ "???",
+    /*185 */ "???",
+    /*186 */ "???",
+    /*187 */ "???",
+    /*188 */ "???",
+    /*189 */ "???",
+    /*190 */ "???",
+    /*191 */ "???",
+    /*192 */ "???",
+    /*193 */ "???",
+    /*194 */ "???",
+    /*195 */ "???",
+    /*196 */ "???",
+    /*197 */ "???",
+    /*198 */ "???",
+    /*199 */ "???",
+    /*200 */ "???",
+    /*201 */ "???",
+    /*202 */ "???",
+    /*203 */ "???",
+    /*204 */ "???",
+    /*205 */ "???",
+    /*206 */ "???",
+    /*207 */ "???",
+    /*208 */ "???",
+    /*209 */ "???",
+    /*210 */ "Authenticate",
+    /*211 */ "???",
+    /*212 */ "???",
+    /*213 */ "???",
+    /*214 */ "???",
+    /*215 */ "???",
+    /*216 */ "???",
+    /*217 */ "???",
+    /*218 */ "???",
+    /*219 */ "???",
+    /*220 */ "???",
+    /*221 */ "???",
+    /*222 */ "???",
+    /*223 */ "???",
+    /*224 */ "???",
+    /*225 */ "???",
+    /*226 */ "???",
+    /*227 */ "???",
+    /*228 */ "???",
+    /*229 */ "???",
+    /*230 */ "???",
+    /*231 */ "???",
+    /*232 */ "???",
+    /*233 */ "???",
+    /*234 */ "???",
+    /*235 */ "???",
+    /*236 */ "???",
+    /*237 */ "???",
+    /*238 */ "???",
+    /*239 */ "???",
+    /*240 */ "???",
+    /*241 */ "???",
+    /*242 */ "???",
+    /*243 */ "???",
+    /*244 */ "???",
+    /*245 */ "???",
+    /*246 */ "???",
+    /*247 */ "???",
+    /*248 */ "???",
+    /*249 */ "MSFT - Classless route",
+    /*250 */ "???",
+    /*251 */ "???",
+    /*252 */ "MSFT - WinSock Proxy Auto Detect",
+    /*253 */ "???",
+    /*254 */ "???",
+    /*255 */ "End",
+];

package/dist/dhcpd-proxy/lib/sprintf.d.ts

@@ -0,0 +1,6 @@
+/**
+ * sprintf.ts
+ *
+ * Converted to a pure, strictly-typed TypeScript module.
+ */
+export default function sprintf(format: string, ...args: any[]): string;