penguins-eggs 9.2.6 → 9.2.9

package/dist/dhcpd/packet/converters.js

@@ -0,0 +1,377 @@
+"use strict";
+/**
+ * converters.js
+ */
+var utils = require('../utils');
+var sprintf = require('../sprintf');
+var converters = {
+    // option 1: subnet mask
+    1: {
+        encode: utils.writeIp,
+        decode: utils.readIp
+    },
+    // option 2: time offset
+    2: {
+        encode: function encode(buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 4;
+            utils.writeInt32(buf, value, offset);
+            return offset + 4;
+        },
+        decode: function decode(buf) {
+            return utils.readInt32(buf, 0);
+        }
+    },
+    // option 3: routers
+    3: {
+        decode: function decode(buf) {
+            var 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) {
+            var 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) {
+            var 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) {
+            var 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: utils.writeString,
+        decode: utils.readString
+    },
+    // option 15: dns domain name
+    15: {
+        encode: utils.writeString,
+        decode: utils.readString
+    },
+    // option 28: broadcast address
+    28: {
+        encode: utils.writeIp,
+        decode: utils.readIp
+    },
+    // option 31: router discovery
+    31: {
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 1;
+            utils.writeInt8(buf, value, offset);
+            return offset + 1;
+        },
+        decode: function (buf) {
+            return utils.readInt8(buf, 0);
+        }
+    },
+    // option 33: static routes
+    33: {
+        decode: function decode(buf) {
+            var 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) {
+            var 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) {
+            var records = [];
+            var i = 0;
+            var len = buf.length;
+            while (i < len) {
+                records.push(sprintf("%02x", buf[i]));
+                i++;
+            }
+            return records.join(':');
+        },
+        encode: function (buf, num, data, offset) {
+            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) {
+            var 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) {
+            var 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: utils.writeString,
+        decode: utils.readString
+    },
+    // option 50: requested ip address
+    50: {
+        encode: utils.writeIp,
+        decode: utils.readIp
+    },
+    // option 51: lease time
+    51: {
+        decode: function (buf) {
+            return utils.readInt32(buf, 0);
+        },
+        encode: function (buf, num, value, offset) {
+            buf[offset++] = num;
+            buf[offset++] = 4;
+            utils.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: utils.writeIp,
+        decode: function decode(buf) {
+            return utils.readIp(buf, 0);
+        }
+    },
+    // option 55: parameter request list
+    55: {
+        decode: function decode(buf) {
+            var records = [];
+            var i = 0;
+            var 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;
+            utils.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;
+            utils.writeInt16(buf, value, offset);
+            return offset + 2;
+        },
+        decode: function (buf) {
+            return utils.readInt16(buf, 0);
+        }
+    },
+    // option 60: vendor class identifier
+    60: {
+        encode: utils.writeString,
+        decode: utils.readString
+    },
+    // option 61: client identifier
+    61: {
+        encode: function (buf, num, value, offset) {
+            return offset;
+        },
+        decode: function (buf) {
+            var 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: utils.writeString,
+        decode: utils.readString
+    },
+    // option 77: user class information
+    77: {
+        encode: utils.writeString,
+        decode: function (buf) {
+            var records = [];
+            var offset = 0;
+            while (buf[offset]) {
+                var uc_len = buf[offset];
+                var 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) {
+            var ret;
+            ret = "";
+            ret += sprintf("%d", buf[0]) + "-";
+            ret += sprintf("%d", buf[1]) + "-";
+            ret += sprintf("%d", buf[2]) + " ";
+            ret += utils.toString(buf.slice(3));
+            return ret;
+        }
+    },
+    // option 175: etherboot
+    175: {
+        encode: function (buf, num, value, offset) {
+            return offset;
+        },
+        decode: function (buf) {
+            var 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) {
+            utils.writeInt8(buf, 255, offset);
+            return offset + 1;
+        },
+        decode: function (buf) {
+            return undefined;
+        }
+    }
+};
+var 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;
+    }
+};
+module.exports = function (i) {
+    //console.log("GET CONVERTER FOR " + i);
+    return (i in converters) ? converters[i] : stub;
+};

package/dist/dhcpd/packet/options.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = ["pad", "Subnet mask", "Time offset", "Routers", "Time server", "Name server", "DNS server", "Log server", "Cookie server", "LPR server", "Impress server", "Resource location server", "Host name", "Boot file size", "Merit dump file", "Domainname", "Swap server", "Root path", "Extensions path", "IP forwarding", "Non-local source routing", "Policy filter", "Maximum datagram reassembly size", "Default IP TTL", "Path MTU aging timeout", "Path MTU plateau table", "Interface MTU", "All subnets local", "Broadcast address", "Perform mask discovery", "Mask supplier", "Perform router discovery", "Router solicitation", "Static route", "Trailer encapsulation", "ARP cache timeout", "Ethernet encapsulation", "TCP default TTL", "TCP keepalive interval", "TCP keepalive garbage", "NIS domain", "NIS servers", "NTP servers", "Vendor specific info", "NetBIOS name server", "NetBIOS datagram distribution server", "NetBIOS node type", "NetBIOS scope", "X Window System font server", "X Window System display server", "Request IP address", "IP address leasetime", "Option overload", "DHCP message type", "Server identifier", "Parameter Request List", "Message", "Maximum DHCP message size", "T1", "T2", "Vendor class identifier", "Client-identifier", "Netware/IP domain name", "Netware/IP domain information", "NIS+ domain", "NIS+ servers", "TFTP server name", "Bootfile name", "Mobile IP home agent", "SMTP server", "POP3 server", "NNTP server", "WWW server", "Finger server", "IRC server", "StreetTalk server", "StreetTalk directory assistance server", "User-class Identification", "SLP-directory-agent", "SLP-service-scope", "Naming Authority", "Client FQDN", "Relay Agent Information", "Agent Remote ID", "Agent Subnet Mask", "NDS server", "NDS tree name", "NDS context", "IEEE 1003.1 POSIX", "FQDN", "Authentication", "Vines TCP/IP", "Server Selection", "Client System", "Client NDI", "LDAP", "IPv6 Transitions", "UUID/GUID", "UPA servers", "???", "Printer Name", "MDHCP", "???", "???", "???", "???", "???", "???", "Swap Path", "???", "IPX Compatability", "???", "Netinfo Address", "Netinfo Tag", "URL", "DHCP Failover", "DHCP Autoconfiguration", "Name Service Search", "Subnet selection", "Domain Search", "SIP Servers DHCP Option", "Classless Static Route", "???", "???", "???", "???", "Extension", "Extension", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "HP - TFTP file", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "Authenticate", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "???", "MSFT - Classless route", "???", "???", "MSFT - WinSock Proxy Auto Detect", "???", "???", "End"];

package/dist/dhcpd/packet/types.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = ["unknown dhcp message type", "DHCPDISCOVER", "DHCPOFFER", "DHCPREQUEST", "DHCPDECLINE", "DHCPACK", "DHCPNAK", "DHCPRELEASE", "DHCPINFORM"];

package/dist/dhcpd/packet.js

@@ -0,0 +1,251 @@
+"use strict";
+var utils = require('./utils');
+var get_convert = require('./packet/converters');
+/**
+ *
+ */
+class Packet {
+    constructor(array) {
+        var key;
+        for (key in array) {
+            if (array.hasOwnProperty(key)) {
+                this[key] = array[key];
+            }
+        }
+    }
+    /**
+     *
+     * @returns
+     */
+    getRequestedIPAddress() {
+        return this.options[50];
+    }
+    /**
+     *
+     * @param {*} op
+     * @returns
+     */
+    op(op) {
+        this.op = op;
+        return this;
+    }
+    /**
+     *
+     * @param {*} htype
+     * @returns
+     */
+    htype(htype) {
+        this.htype = htype;
+        return this;
+    }
+    /**
+     *
+     * @param {*} hlen
+     * @returns
+     */
+    hlen(hlen) {
+        this.hlen = hlen;
+        return this;
+    }
+    hops(hops) {
+        this.hops = hops;
+        return this;
+    }
+    /**
+     *
+     * @param {*} xid
+     * @returns
+     */
+    xid(xid) {
+        this.xid = xid;
+        return this;
+    }
+    /**
+     *
+     * @param {*} secs
+     * @returns
+     */
+    secs(secs) {
+        this.secs = secs;
+        return this;
+    }
+    flags(flags) {
+        this.flags = flags;
+        return this;
+    }
+    /**
+     *
+     * @param {*} ciaddr
+     * @returns
+     */
+    ciaddr(ciaddr) {
+        this.ciaddr = ciaddr !== null ? ciaddr : '0.0.0.0';
+        return this;
+    }
+    /**
+     *
+     * @param {*} yiaddr
+     * @returns
+     */
+    yiaddr(yiaddr) {
+        this.yiaddr = yiaddr !== null ? yiaddr : '0.0.0.0';
+        return this;
+    }
+    /**
+     *
+     * @param {*} siaddr
+     * @returns
+     */
+    siaddr(siaddr) {
+        this.siaddr = siaddr !== null ? siaddr : '0.0.0.0';
+        return this;
+    }
+    /**
+     *
+     * @param {*} giaddr
+     * @returns
+     */
+    giaddr(giaddr) {
+        this.giaddr = giaddr !== null ? giaddr : '0.0.0.0';
+        return this;
+    }
+    /**
+     *
+     * @param {*} chaddr
+     * @returns
+     */
+    chaddr(chaddr) {
+        this.chaddr = chaddr;
+        return this;
+    }
+    /**
+     *
+     * @param {*} sname
+     * @returns
+     */
+    sname(sname) {
+        this.sname = sname;
+        return this;
+    }
+    /**
+     *
+     * @param {*} fname
+     * @returns
+     */
+    fname(fname) {
+        this.fname = fname;
+        return this;
+    }
+    /**
+     *
+     * @param {*} options
+     * @returns
+     */
+    options(options) {
+        this.options = options;
+        return this;
+    }
+}
+/**
+ *
+ * @param {*} str
+ * @returns
+ */
+function stripBinNull(str) {
+    var pos;
+    pos = str.indexOf('\u0000');
+    if (pos === -1) {
+        return str;
+    }
+    else {
+        return str.substr(0, pos);
+    }
+}
+var fromBuffer = function (b) {
+    var i, optLen, optNum, optVal, options, ret, _ref;
+    ret = {
+        op: b[0],
+        htype: b[1],
+        hlen: b.readUInt8(2),
+        hops: b.readUInt8(3),
+        xid: b.readUInt32BE(4),
+        secs: b.readUInt16BE(8),
+        flags: b.readUInt16BE(10),
+        ciaddr: utils.readIp(b, 12),
+        yiaddr: utils.readIp(b, 16),
+        siaddr: utils.readIp(b, 20),
+        giaddr: utils.readIp(b, 24),
+        chaddr: utils.readMacAddress(b.slice(28, 28 + b.readUInt8(2))),
+        sname: stripBinNull(b.toString('ascii', 44, 108)),
+        fname: stripBinNull(b.toString('ascii', 108, 236)),
+        options: {}
+    };
+    _ref = [0, b.slice(240)];
+    i = _ref[0];
+    options = _ref[1];
+    while (i < options.length && options[i] !== 255) {
+        optNum = parseInt(options[i++], 10);
+        optLen = parseInt(options[i++], 10);
+        var converter = get_convert(optNum);
+        optVal = converter.decode(options.slice(i, i + optLen), optNum);
+        ret.options[optNum] = optVal;
+        i += optLen;
+    }
+    return new Packet(ret);
+};
+var toBuffer = function () {
+    var buffer, hex, i, key, octet, opt, padded, pos, value, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref, _ref1, _ref2, _ref3;
+    buffer = new Buffer.alloc(512, 0x00, 'ascii');
+    buffer[0] = this.op;
+    buffer[1] = this.htype;
+    buffer.writeUInt8(this.hlen, 2);
+    buffer.writeUInt8(this.hops, 3);
+    buffer.writeUInt32BE(this.xid, 4);
+    buffer.writeUInt16BE(this.secs, 8);
+    buffer.writeUInt16BE(this.flags, 10);
+    pos = 12;
+    _ref = ["ciaddr", "yiaddr", "siaddr", "giaddr"];
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        key = _ref[_i];
+        _ref1 = (this[key] || "0.0.0.0").split(".");
+        for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+            octet = _ref1[_j];
+            buffer.writeUInt8(parseInt(octet, 10), pos++);
+        }
+    }
+    _ref2 = this.chaddr.split(':');
+    for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
+        hex = _ref2[_k];
+        buffer[pos++] = parseInt(hex, 16);
+    }
+    buffer.fill(0, 43, 235);
+    buffer.write(this.sname, 43, 64, 'ascii');
+    if (typeof this.fname === 'string' || this.fname instanceof String) {
+        buffer.write(this.fname, 108, 128, 'ascii');
+    }
+    pos = 236;
+    _ref3 = [99, 130, 83, 99];
+    for (_l = 0, _len3 = _ref3.length; _l < _len3; _l++) {
+        i = _ref3[_l];
+        buffer[pos++] = i;
+    }
+    pos = 240;
+    for (opt in this.options) {
+        if (this.options.hasOwnProperty(opt)) {
+            value = this.options[opt];
+            var converter = get_convert(opt);
+            pos = converter.encode(buffer, opt, value, pos);
+        }
+    }
+    buffer[pos] = 255;
+    padded = new Buffer.alloc(pos, 0x00, 'ascii');
+    buffer.copy(padded, 0, 0, pos);
+    return padded;
+};
+Packet.fromBuffer = fromBuffer;
+Packet.prototype.toBuffer = toBuffer;
+module.exports = {
+    Packet: Packet,
+    fromBuffer: fromBuffer,
+    toBuffer: toBuffer
+};