penguins-eggs 9.2.5 → 9.2.9

package/dist/dhcpd/proxy.js

@@ -0,0 +1,152 @@
+"use strict";
+var util = require('util');
+var dhcp = require('./index');
+var Socket = require('dgram').Socket;
+/**
+ *
+ */
+class DHCPProxy {
+    constructor(type, opts) {
+        var _this = this;
+        DHCPProxy.super_.apply(this, [type]);
+        _this.broadcast = opts.broadcast;
+        this.on('error', function (err) {
+            console.dir(err);
+        });
+        this.on('message', function (buffer, remote) {
+            var event_name, packet, type;
+            packet = dhcp.Packet.fromBuffer(buffer);
+            if (packet.op === 1) {
+                type = {
+                    id: packet.options[53] || 0,
+                    name: dhcp.MessageTypes[packet.options[53] || 0]
+                };
+                util.log(("Proxy: Got " + type.name + " from") + (" " + remote.address + ":" + remote.port + " (" + packet.chaddr + ") ") + (" with packet length of " + buffer.length + " bytes"));
+                event_name = type.name.replace('DHCP', '').toLowerCase();
+                packet.remote = remote;
+                return _this._emitPacket(event_name, packet);
+            }
+            else {
+                return console.log("  Unsupported message format");
+            }
+        });
+        return _this;
+    }
+    /**
+     *
+     * @param {*} port
+     * @param {*} addr
+     * @param {*} cb
+     * @returns
+     */
+    bind(port, addr, cb) {
+        var self = this;
+        var res;
+        res = DHCPProxy.super_.prototype.bind.call(this, port, addr, function () {
+            this.setBroadcast(true);
+            if (cb instanceof Function)
+                cb();
+        });
+        return res;
+    }
+    /**
+     *
+     * @param {*} event_name
+     * @param {*} ip
+     * @param {*} packet
+     * @returns
+     */
+    _send(event_name, ip, packet) {
+        var buffer, _this = this;
+        buffer = packet.toBuffer();
+        util.log(("Proxy: Sending " + dhcp.MessageTypes[packet.options[53]]) + (" to " + ip + ":" + packet.remote.port + " (" + packet.chaddr + ")") + (" with packet length of " + buffer.length + " bytes"));
+        this.emit(event_name, packet);
+        return this.send(buffer, 0, buffer.length, packet.remote.port, ip, function (err, bytes) {
+            if (err) {
+                return _this.emit("" + event_name + "Error", err, packet);
+            }
+            else {
+                return _this.emit("" + event_name + "Sent", bytes, packet);
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} message_type
+     * @param {*} packet
+     * @returns
+     */
+    _emitPacket(message_type, packet) {
+        return this.emit(message_type, packet, packet.options[50] || null);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     */
+    discover(packet, params) {
+        console.log('Proxy: Got DHCP DISCOVER');
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    offer(packet, params) {
+        if (params) {
+            packet.yiaddr = params.yiaddr;
+            packet.siaddr = params.siaddr;
+            packet.options = params.options;
+        }
+        packet.op = packet.options[53] = 2;
+        return this._send('offer', this.broadcast, packet);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    ack(packet, params) {
+        if (params) {
+            packet.yiaddr = params.yiaddr;
+            packet.siaddr = params.siaddr;
+            packet.options = params.options;
+        }
+        packet.op = 2;
+        packet.options[53] = 5;
+        //  return this._send('ack', this.broadcast, packet);
+        return this._send('ack', packet.ciaddr, packet);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    nak(packet, params) {
+        packet.op = 2;
+        packet.options[53] = 6;
+        return this._send('nak', packet.ciaddr, packet);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    inform(packet, params) {
+        if (params) {
+            packet.yiaddr = params.yiaddr;
+            packet.siaddr = params.siaddr;
+            packet.options = params.options;
+        }
+        packet.op = 2;
+        packet.options[53] = 5;
+        return this._send('inform', packet.ciaddr, packet);
+    }
+}
+util.inherits(DHCPProxy, Socket);
+DHCPProxy.Packet = dhcp.Packet;
+module.exports = DHCPProxy;

package/dist/dhcpd/server.js

@@ -0,0 +1,152 @@
+"use strict";
+var util = require('util');
+var dhcp = require('./index');
+var Socket = require('dgram').Socket;
+/**
+ *
+ */
+class DHCPServer {
+    constructor(type, opts) {
+        var _this = this;
+        DHCPServer.super_.apply(this, [type]);
+        _this.broadcast = opts.broadcast;
+        this.on('error', function (err) {
+            console.dir(err);
+        });
+        this.on('message', function (buffer, remote) {
+            var event_name, packet, type;
+            packet = dhcp.Packet.fromBuffer(buffer);
+            if (packet.op === 1) {
+                type = {
+                    id: packet.options[53] || 0,
+                    name: dhcp.MessageTypes[packet.options[53] || 0]
+                };
+                util.log(("Got " + type.name + " from") + (" " + remote.address + ":" + remote.port + " (" + packet.chaddr + ") ") + (" with packet length of " + buffer.length + " bytes"));
+                event_name = type.name.replace('DHCP', '').toLowerCase();
+                packet.remote = remote;
+                return _this._emitPacket(event_name, packet);
+            }
+            else {
+                return console.log("  Unsupported message format");
+            }
+        });
+        return _this;
+    }
+    /**
+     *
+     * @param {*} port
+     * @param {*} addr
+     * @param {*} cb
+     * @returns
+     */
+    bind(port, addr, cb) {
+        var self = this;
+        var res;
+        res = DHCPServer.super_.prototype.bind.call(this, port, addr, function () {
+            this.setBroadcast(true);
+            if (cb instanceof Function)
+                cb();
+        });
+        return res;
+    }
+    /**
+     *
+     * @param {*} event_name
+     * @param {*} ip
+     * @param {*} packet
+     * @returns
+     */
+    _send(event_name, ip, packet) {
+        var buffer, _this = this;
+        buffer = packet.toBuffer();
+        util.log(("Sending " + dhcp.MessageTypes[packet.options[53]]) + (" to " + ip + ":68 (" + packet.chaddr + ")") + (" with packet length of " + buffer.length + " bytes"));
+        this.emit(event_name, packet);
+        return this.send(buffer, 0, buffer.length, 68, ip, function (err, bytes) {
+            if (err) {
+                return _this.emit("" + event_name + "Error", err, packet);
+            }
+            else {
+                return _this.emit("" + event_name + "Sent", bytes, packet);
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} message_type
+     * @param {*} packet
+     * @returns
+     */
+    _emitPacket(message_type, packet) {
+        return this.emit(message_type, packet, packet.options[50] || null);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     */
+    discover(packet, params) {
+        console.log('Got DHCP DISCOVER');
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    offer(packet, params) {
+        if (params) {
+            packet.yiaddr = params.yiaddr;
+            packet.siaddr = params.siaddr;
+            packet.options = params.options;
+        }
+        packet.op = packet.options[53] = 2;
+        //return this._send('offer', this.broadcast, packet);
+        return this._send('offer', '255.255.255.255', packet);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    ack(packet, params) {
+        if (params) {
+            packet.yiaddr = params.yiaddr;
+            packet.siaddr = params.siaddr;
+            packet.options = params.options;
+        }
+        packet.op = 2;
+        packet.options[53] = 5;
+        return this._send('ack', this.broadcast, packet);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    nak(packet, params) {
+        packet.op = 2;
+        packet.options[53] = 6;
+        return this._send('nak', packet.ciaddr, packet);
+    }
+    /**
+     *
+     * @param {*} packet
+     * @param {*} params
+     * @returns
+     */
+    inform(packet, params) {
+        if (params) {
+            packet.yiaddr = params.yiaddr;
+            packet.siaddr = params.siaddr;
+            packet.options = params.options;
+        }
+        packet.op = 2;
+        packet.options[53] = 5;
+        return this._send('inform', packet.ciaddr, packet);
+    }
+}
+util.inherits(DHCPServer, Socket);
+DHCPServer.Packet = dhcp.Packet;
+module.exports = DHCPServer;

package/dist/dhcpd/sprintf.js

@@ -0,0 +1,170 @@
+"use strict";
+function sprintf() {
+    // Return a formatted string
+    //
+    // version: 1107.2516
+    // discuss at: http://phpjs.org/functions/sprintf    // +   original by: Ash Searle (http://hexmen.com/blog/)
+    // + namespaced by: Michael White (http://getsprink.com)
+    // +    tweaked by: Jack
+    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // +      input by: Paulo Freitas    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // +      input by: Brett Zamir (http://brett-zamir.me)
+    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // *     example 1: sprintf("%01.2f", 123.1);
+    // *     returns 1: 123.10    // *     example 2: sprintf("[%10s]", 'monkey');
+    // *     returns 2: '[    monkey]'
+    // *     example 3: sprintf("[%'#10s]", 'monkey');
+    // *     returns 3: '[####monkey]'
+    var regex = /%%|%(\d+\$)?([\-+\'#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;
+    var a = arguments, i = 0, format = a[i++];
+    // pad()
+    var pad = function (str, len, chr, leftJustify) {
+        if (!chr) {
+            chr = ' ';
+        }
+        var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);
+        return leftJustify ? str + padding : padding + str;
+    };
+    // justify()
+    var justify = function (value, prefix, leftJustify, minWidth, zeroPad, customPadChar) {
+        var diff = minWidth - value.length;
+        if (diff > 0) {
+            if (leftJustify || !zeroPad) {
+                value = pad(value, minWidth, customPadChar, leftJustify);
+            }
+            else {
+                value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
+            }
+        }
+        return value;
+    };
+    // formatBaseX()
+    var formatBaseX = function (value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
+        // Note: casts negative numbers to positive ones
+        var number = value >>> 0;
+        prefix = prefix && number && {
+            '2': '0b',
+            '8': '0',
+            '16': '0x'
+        }[base] || '';
+        value = prefix + pad(number.toString(base), precision || 0, '0', false);
+        return justify(value, prefix, leftJustify, minWidth, zeroPad);
+    };
+    // formatString()
+    var formatString = function (value, leftJustify, minWidth, precision, zeroPad, customPadChar) {
+        if (precision !== null) {
+            value = value.slice(0, precision);
+        }
+        return justify(value, '', leftJustify, minWidth, zeroPad, customPadChar);
+    };
+    // doFormat()
+    var doFormat = function (substring, valueIndex, flags, minWidth, _, precision, type) {
+        var number;
+        var prefix;
+        var method;
+        var textTransform;
+        var value;
+        if (substring == '%%') {
+            return '%';
+        }
+        // parse flags
+        var leftJustify = false, positivePrefix = '', zeroPad = false, prefixBaseX = false, customPadChar = ' ';
+        var flagsl = flags.length;
+        for (var j = 0; flags && j < flagsl; j++) {
+            switch (flags.charAt(j)) {
+                case ' ':
+                    positivePrefix = ' ';
+                    break;
+                case '+':
+                    positivePrefix = '+';
+                    break;
+                case '-':
+                    leftJustify = true;
+                    break;
+                case "'":
+                    customPadChar = flags.charAt(j + 1);
+                    break;
+                case '0':
+                    zeroPad = true;
+                    break;
+                case '#':
+                    prefixBaseX = true;
+                    break;
+            }
+        }
+        // parameters may be null, undefined, empty-string or real valued
+        // we want to ignore null, undefined and empty-string values
+        if (!minWidth) {
+            minWidth = 0;
+        }
+        else if (minWidth == '*') {
+            minWidth = +a[i++];
+        }
+        else if (minWidth.charAt(0) == '*') {
+            minWidth = +a[minWidth.slice(1, -1)];
+        }
+        else {
+            minWidth = +minWidth;
+        }
+        // Note: undocumented perl feature:
+        if (minWidth < 0) {
+            minWidth = -minWidth;
+            leftJustify = true;
+        }
+        if (!isFinite(minWidth)) {
+            throw new Error('sprintf: (minimum-)width must be finite');
+        }
+        if (!precision) {
+            precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : undefined;
+        }
+        else if (precision == '*') {
+            precision = +a[i++];
+        }
+        else if (precision.charAt(0) == '*') {
+            precision = +a[precision.slice(1, -1)];
+        }
+        else {
+            precision = +precision;
+        }
+        // grab value using valueIndex if required?
+        value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];
+        switch (type) {
+            case 's':
+                return formatString(String(value), leftJustify, minWidth, precision, zeroPad, customPadChar);
+            case 'c':
+                return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
+            case 'b':
+                return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'o':
+                return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'x':
+                return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'X':
+                return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
+            case 'u':
+                return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
+            case 'i':
+            case 'd':
+                number = (+value) | 0;
+                prefix = number < 0 ? '-' : positivePrefix;
+                value = prefix + pad(String(Math.abs(number)), precision, '0', false);
+                return justify(value, prefix, leftJustify, minWidth, zeroPad);
+            case 'e':
+            case 'E':
+            case 'f':
+            case 'F':
+            case 'g':
+            case 'G':
+                number = +value;
+                prefix = number < 0 ? '-' : positivePrefix;
+                method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
+                textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];
+                value = prefix + Math.abs(number)[method](precision);
+                return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
+            default:
+                return substring;
+        }
+    };
+    return format.replace(regex, doFormat);
+}
+module.exports = sprintf;

package/dist/dhcpd/utils.js

@@ -0,0 +1,190 @@
+"use strict";
+var sprintf;
+sprintf = require("./sprintf");
+module.exports = {
+    /*
+      Writes an array with bytes to the packets Buffer from the current position
+  
+      @param {Array} byteArray A simple array with uint8 values ([0x00, 0xFF])
+      @return {Packet}
+    */
+    writeBytes: function (_buffer, byteArray, offset) {
+        var i, _bytesWritten;
+        i = 0;
+        while (i < byteArray.length) {
+            _buffer[offset++] = byteArray[i];
+            i++;
+        }
+        if (offset > _bytesWritten) {
+            _bytesWritten = offset;
+        }
+        return this;
+    },
+    /*
+      Write a 4-byte integer
+  
+      @param {integer} integer The value to write to the packet
+      @return {Packet}
+    */
+    writeInt32: function (_buffer, integer, offset) {
+        _buffer[offset++] = integer >>> 24;
+        _buffer[offset++] = integer >>> 16;
+        _buffer[offset++] = integer >>> 8;
+        _buffer[offset++] = integer;
+        return offset;
+    },
+    /*
+      Write a 2-byte integer
+  
+      @param {integer} integer The value to write to the packet
+      @return {Packet}
+    */
+    writeInt16: function (_buffer, integer, offset) {
+        _buffer[offset++] = integer >>> 8;
+        _buffer[offset++] = integer;
+        return offset;
+    },
+    /*
+      Write a 1-byte integer
+  
+      @param {integer} integer The value to write to the packet
+      @return {Packet}
+    */
+    writeInt8: function (_buffer, integer, offset) {
+        _buffer[offset++] = integer;
+        return offset;
+    },
+    /*
+      Reads the given length of bytes from the packets Buffer
+      and optionally (if the copy argument is true) creates a real copy of the Buffer
+  
+      @param {Integer} length
+      @param {Boolean} copy
+      @return {Buffer}
+    */
+    readBytes: function (_buffer, length, copy, offset) {
+        var bufCopy;
+        if (copy) {
+            bufCopy = new Buffer(length);
+            _buffer.copy(bufCopy, 0, offset, (offset += length));
+            return bufCopy;
+        }
+        else {
+            return _buffer.slice(offset, (offset += length));
+        }
+    },
+    /*
+      Reads a 4-byte integer from the packet
+  
+      @return {Integer}
+    */
+    readInt32: function (_buffer, offset) {
+        return (_buffer[offset++] << 24) | (_buffer[offset++] << 16) | (_buffer[offset++] << 8) | _buffer[offset++];
+    },
+    /*
+      Reads a 2-byte integer from the packet
+  
+      @return {Integer}
+    */
+    readInt16: function (_buffer, offset) {
+        return (_buffer[offset++] << 8) | _buffer[offset++];
+    },
+    /*
+      Reads a 1-byte integer from the packet
+  
+      @return {Integer}
+    */
+    readInt8: function (_buffer, offset) {
+        return _buffer[offset++];
+    },
+    readString: function (buf) {
+        var j, s;
+        s = "";
+        j = 0;
+        while (j < buf.length) {
+            s += String.fromCharCode(buf[j]);
+            j++;
+        }
+        return s;
+    },
+    readHex: function (buf) {
+        var j, s;
+        s = "";
+        j = 0;
+        while (j < buf.length) {
+            s += sprintf("%02x", b[j]);
+            j++;
+        }
+        return s;
+    },
+    readHexAddress: function (buf) {
+        var j, s;
+        s = [];
+        j = 0;
+        while (j < buf.length) {
+            s.push(sprintf("%02d", buf[j]));
+            j++;
+        }
+        return s.join(":");
+    },
+    readIp: function (buffer, offset) {
+        var stop;
+        if (offset === null) {
+            offset = 0;
+        }
+        if (offset > buffer.length) {
+            return undefined;
+        }
+        if (0 === buffer.readUInt8(offset)) {
+            return undefined;
+        }
+        else {
+            stop = offset + 4;
+            return ((function () {
+                var _results;
+                _results = [];
+                while (offset < stop) {
+                    _results.push(buffer.readUInt8(offset++));
+                }
+                return _results;
+            })()).join('.');
+        }
+    },
+    readMacAddress: function (buffer) {
+        var byte;
+        return ((function () {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = buffer.length; _i < _len; _i++) {
+                byte = buffer[_i];
+                _results.push((byte + 0x100).toString(16).substr(-2));
+            }
+            return _results;
+        })()).join(':');
+    },
+    writeTimeOffset: function (buf, num, offsetHours, offset) {
+        buf[offset++] = 0;
+        return offset;
+    },
+    writeIp: function (buf, num, ip, offset) {
+        buf[offset++] = num;
+        buf[offset++] = 4;
+        if ((typeof ip !== 'string' && !(ip instanceof String)) || ip.indexOf('.') === -1) {
+            ip = "0.0.0.0";
+        }
+        ip.split(".").forEach(function (item) {
+            buf[offset++] = item;
+        });
+        return offset;
+    },
+    writeString: function (buf, num, hostname, offset) {
+        var charArr;
+        charArr = hostname.split("");
+        buf[offset++] = num;
+        buf[offset++] = charArr.length;
+        charArr.forEach(function (chr) {
+            buf[offset++] = chr.charCodeAt();
+        });
+        return offset;
+    }
+};