penguins-eggs 9.2.6 → 9.3.1

package/dist/commands/cuckoo.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * cuckoo: proxy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const network_1 = tslib_1.__importDefault(require("../classes/network"));
+const utils_1 = tslib_1.__importDefault(require("../classes/utils"));
+const pxe_1 = tslib_1.__importDefault(require("../classes/pxe"));
+const tftp = require('tftp');
+class Cuckoo extends core_1.Command {
+    async run(nest = '/home/eggs') {
+        const { args, flags } = await this.parse(Cuckoo);
+        utils_1.default.titles(this.id + ' ' + this.argv);
+        if (utils_1.default.isRoot()) {
+            const pxeRoot = nest + '/pxe';
+            const pxe = new pxe_1.default();
+            await pxe.fertilization();
+            await pxe.build();
+            const n = new network_1.default();
+            /**
+             * service proxy-dhcp
+             */
+            let dhcpOptions = {
+                subnet: n.cidr,
+                host: n.address,
+                tftpserver: n.address,
+                bios_filename: 'lpxelinux.0',
+                efi32_filename: 'ipxe32.efi',
+                efi64_filename: 'ipxe.efi'
+            };
+            pxe.dhcpStart(dhcpOptions);
+            /**
+             * service tftp
+             */
+            let tftpOptions = {
+                "host": n.address,
+                "port": 69,
+                "root": pxeRoot,
+                "denyPUT": true
+            };
+            await pxe.tftpStart(tftpOptions);
+            /**
+             * service http
+             */
+            await pxe.httpStart();
+        }
+        else {
+            utils_1.default.useRoot(this.id);
+        }
+    }
+}
+exports.default = Cuckoo;
+Cuckoo.description = 'PXE start with proxy-dhcp';
+Cuckoo.examples = [
+    `$ sudo eggs cuckoo
+start a PXE server with dhcp-proxy (can coexists with a real dhcp server)
+`,
+];
+Cuckoo.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+};

package/{lib → dist}/commands/install.js

@@ -21,7 +21,17 @@ class Install extends core_1.Command {
         utils_1.default.titles(this.id + ' ' + this.argv);
         const { flags } = await this.parse(Install);
         let unattended = flags.unattended;
+        // hostname
         let ip = flags.ip;
+        let random = flags.random;
+        let domain = '.local';
+        if (flags.domain) {
+            domain = flags.domain;
+        }
+        // swap
+        let suspend = flags.suspend;
+        let small = flags.small;
+        let none = flags.none;
         let crypted = flags.crypted;
         let pve = flags.pve;
         if (pve) {
@@ -31,7 +41,7 @@ class Install extends core_1.Command {
         if (utils_1.default.isRoot()) {
             if (utils_1.default.isLive()) {
                 const krill = new krill_prepare_1.default();
-                await krill.prepare(unattended, ip, crypted, pve, verbose);
+                await krill.prepare(unattended, ip, random, domain, suspend, small, none, crypted, pve, verbose);
             }
             else {
                 utils_1.default.warning('You are in an installed system!');
@@ -44,12 +54,23 @@ class Install extends core_1.Command {
 }
 exports.default = Install;
 Install.flags = {
-    unattended: core_1.Flags.boolean({ char: 'u', description: 'unattended CLI installation' }),
-    ip: core_1.Flags.boolean({ char: 'i', description: 'add ip to hostname' }),
-    crypted: core_1.Flags.boolean({ char: 'k', description: 'crypted CLI installation' }),
+    unattended: core_1.Flags.boolean({ char: 'u', description: 'Unattended installation' }),
+    // hostname
+    ip: core_1.Flags.boolean({ char: 'i', description: 'hostname as ip, eg: ip-192-168-1-33' }),
+    random: core_1.Flags.boolean({ char: 'r', description: 'Add random to hostname, eg: colibri-ay412dt' }),
+    // append: Flags.string({char: 'a', description: 'append to hostname: ip, random'}),
+    domain: core_1.Flags.string({ char: 'd', description: 'Domain name, defult: .local' }),
+    // swap
+    // swap: Flags.string({char: 's', description: 'swap: none, small, suspend'}),
+    suspend: core_1.Flags.boolean({ char: 'S', description: 'Swap suspend: RAM x 2' }),
+    small: core_1.Flags.boolean({ char: 's', description: 'Swap small: RAM' }),
+    none: core_1.Flags.boolean({ char: 'n', description: 'Swap none: 256M' }),
+    // 
+    crypted: core_1.Flags.boolean({ char: 'k', description: 'Crypted CLI installation' }),
     pve: core_1.Flags.boolean({ char: 'p', description: 'Proxmox VE install' }),
+    // generic
     help: core_1.Flags.help({ char: 'h' }),
-    verbose: core_1.Flags.boolean({ char: 'v', description: 'verbose' })
+    verbose: core_1.Flags.boolean({ char: 'v', description: 'Verbose' })
 };
 Install.description = 'command-line system installer - the egg became a penguin!';
 Install.examples = ['$ eggs install\nInstall the system using krill installer\n'];

package/dist/commands/tools/ppa.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * penguins-eggs-v7 based on Debian live
+ * author: Piero Proietti
+ * email: piero.proietti@gmail.com
+ * license: MIT
+ */
+const core_1 = require("@oclif/core");
+const distro_1 = tslib_1.__importDefault(require("../../classes/distro"));
+const utils_1 = tslib_1.__importDefault(require("../../classes/utils"));
+const utils_2 = require("../../lib/utils");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const fkey = `/etc/apt/trusted.gpg.d/penguins-eggs-key.gpg`;
+const flist = '/etc/apt/sources.list.d/penguins-eggs-ppa.list';
+/**
+ *
+ */
+class Ppa extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Ppa);
+        utils_1.default.titles(this.id + ' ' + this.argv);
+        let verbose = false;
+        if (flags.verbose) {
+            verbose = true;
+        }
+        const distro = new distro_1.default();
+        if (distro.familyId === 'debian') {
+            if (utils_1.default.isRoot()) {
+                if (flags.remove) {
+                    utils_1.default.warning(`Are you sure to remove ${flist} to your repositories?`);
+                    if (await utils_1.default.customConfirm('Select yes to continue...')) {
+                        await remove();
+                    }
+                }
+                if (flags.add) {
+                    utils_1.default.warning(`Are you sure to add ${flist} to your repositories?`);
+                    if (await utils_1.default.customConfirm('Select yes to continue...')) {
+                        await clean();
+                        await add();
+                    }
+                }
+            }
+        }
+        else {
+            utils_1.default.warning('you can use ppa only for debian family');
+        }
+    }
+}
+exports.default = Ppa;
+Ppa.description = 'add/remove PPA repositories (Debian family)';
+Ppa.flags = {
+    help: core_1.Flags.help({ char: 'h' }),
+    add: core_1.Flags.boolean({ char: 'a', description: 'add penguins-eggs PPA repository' }),
+    remove: core_1.Flags.boolean({ char: 'r', description: 'remove penguins-eggs PPA repository' }),
+    verbose: core_1.Flags.boolean({ char: 'v', description: 'verbose' })
+};
+/**
+ * add ppa
+ */
+async function add() {
+    await (0, utils_2.exec)(`curl -sS https://pieroproietti.github.io/penguins-eggs-ppa/KEY.gpg| gpg --dearmor | sudo tee ${fkey} > /dev/null`);
+    const content = `deb [signed-by=${fkey}] https://pieroproietti.github.io/penguins-eggs-ppa ./\n`;
+    fs_1.default.writeFileSync(flist, content);
+    await (0, utils_2.exec)(`apt-get update`);
+}
+/**
+ * remove ppa
+ */
+async function remove() {
+    await clean();
+    await (0, utils_2.exec)(`apt-get update`);
+}
+/**
+ *
+ */
+async function clean() {
+    await (0, utils_2.exec)(`rm -f    /etc/apt/trusted.gpg.d/penguins-eggs*`);
+    await (0, utils_2.exec)(`rm -f /etc/apt/sources.list.d/penguins-eggs*`);
+    await (0, utils_2.exec)(`rm -f /usr/share/keyrings/penguins-eggs*`);
+}

package/{lib → dist}/components/summary.js

@@ -38,13 +38,13 @@ function Summary({ name, password, rootPassword, hostname, region, zone, languag
                             react_1.default.createElement(ink_1.Text, null, "Installing "),
                             react_1.default.createElement(ink_1.Text, { color: "green" }, productName)),
                         react_1.default.createElement(ink_1.Box, null,
-                            react_1.default.createElement(ink_1.Text, null, "User "),
+                            react_1.default.createElement(ink_1.Text, null),
                             react_1.default.createElement(ink_1.Text, { color: "green" }, name),
                             react_1.default.createElement(ink_1.Text, null, "/"),
                             react_1.default.createElement(ink_1.Text, { color: "green" },
                                 password,
                                 " "),
-                            react_1.default.createElement(ink_1.Text, null, "root pwd "),
+                            react_1.default.createElement(ink_1.Text, null, "pwd root "),
                             react_1.default.createElement(ink_1.Text, { color: "green" },
                                 rootPassword,
                                 " "),

package/dist/dhcpd/dhcpd.js

@@ -0,0 +1,222 @@
+"use strict";
+var dhcp_server = require('./server');
+var dhcp_proxy = require('./proxy');
+var netmask = require('netmask').Netmask;
+var ee = require('events').EventEmitter;
+var util = require('util');
+const { file } = require('@oclif/core/lib/parser');
+const { createNoSubstitutionTemplateLiteral } = require('typescript');
+const { json } = require('stream/consumers');
+const BOOTREQUEST = 1, DHCP_MESSAGE_TYPE = 0x35, DHCP_SERVER_ID = 0x36, DHCP_DISCOVER = 1, DHCP_INFORM = 8, DHCP_MINTYPE = DHCP_DISCOVER, DHCP_MAXTYPE = DHCP_INFORM, DHCP_REQUESTED_IP = 0x32, DHCP_HOST_NAME = 0x0c;
+/**
+ *
+ * @param opts
+ * @returns
+ */
+class dhcpd {
+    /**
+     *
+     * @param opts
+     * @returns
+     */
+    constructor(opts) {
+        let self = this;
+        if (!(self instanceof dhcpd)) {
+            return new dhcpd(opts);
+        }
+        ee.call(self);
+        if (opts.subnet) {
+            var block = new netmask(opts.subnet);
+            if (block) {
+                self.network = block.base;
+                self.netmask = block.mask;
+                self.broadcast = block.broadcast;
+                self.host = opts.host;
+                self.tftpserver = opts.tftpserver;
+                self.bios_filename = opts.bios_filename;
+                self.efi32_filename = opts.efi32_filename;
+                self.efi64_filename = opts.efi64_filename;
+            }
+            else {
+                throw new Error("Unable to read subnet details from '" + opts.subnet + "'");
+            }
+        }
+        // Listen on port 67 for all the DHCP messages from clients
+        self.s = new dhcp_server('udp4', { broadcast: self.broadcast });
+        self.s.on('listening', function () {
+            var address = self.s.address();
+            console.log('server listening: ' + address.address + ':' + address.port);
+        });
+        self.s.on('discover', self.discover.bind(self));
+        self.s.on('request', self.request.bind(self));
+        self.s.on('inform', self.inform.bind(self));
+        self.s.bind(67, '0.0.0.0');
+        // Listen on port 4011 for clients asking for proxy DHCP
+        self.p = new dhcp_proxy('udp4', { broadcast: self.broadcast });
+        self.p.on('listening', function () {
+            var address = self.p.address();
+            console.log('proxy listening: ' + address.address + ':' + address.port);
+        });
+        self.p.on('request', self.proxy_request.bind(self));
+        self.p.bind(4011, '0.0.0.0');
+        return self;
+    }
+    /**
+     *
+     * @param {*} pkt
+     * @returns
+     */
+    pre_init(pkt) {
+        var self = this;
+        // Ignore malformed packets
+        if (pkt.hlen != 6)
+            return;
+        // Ignore if not a BOOTREQUEST
+        if (pkt.op != BOOTREQUEST)
+            return;
+        // Ignore if unknown message type
+        var state = _get_option(pkt, DHCP_MESSAGE_TYPE);
+        if (state == undefined || state['0'] < DHCP_MINTYPE || state['0'] > DHCP_MAXTYPE)
+            return;
+        // Ignore if DHCP message is not for us
+        var server_id_opt = _get_option(pkt, DHCP_SERVER_ID);
+        if (server_id_opt !== undefined && server_id_opt != self.host)
+            return;
+    }
+    /**
+     *
+     * @param {*} pkt
+     * @returns
+     */
+    discover(pkt) {
+        var self = this;
+        console.log("Received DHCP DISCOVER");
+        if (pkt.options['60'] !== undefined && pkt.options['60'].indexOf('PXEClient') === 0) {
+            // Check if we are really being asked for PXE boot information
+            // Signal the client that we are a proxy dhcp by sending an OFFER
+            var offer = {};
+            offer.siaddr = self.host;
+            offer.options = {};
+            offer.options['60'] = 'PXEClient';
+            offer.options['54'] = self.host;
+            offer.options['255'] = null;
+            self.pre_init(pkt);
+            return self.s.offer(pkt, offer);
+        }
+        else if (pkt.options['60'] !== undefined && pkt.options['60'].indexOf('AAPLBSDPC/i386') === 0) {
+            console.log('Mac OS X discovery, ignoring');
+            return;
+        }
+        else {
+            console.log('Ignoring discovery as it does not seam to be a boot request');
+            return;
+        }
+    }
+    /**
+     *
+     * @param {*} pkt
+     * @returns
+     */
+    request(pkt) {
+        var self = this;
+        console.log('Ignoring received REQUEST from ' + pkt.chaddr + ' as we are only a proxy');
+        return;
+        var offer = {};
+        offer.siaddr = self.host;
+        offer.options = {};
+        offer.options['54'] = self.host;
+        offer.options['255'] = null;
+        self.pre_init(pkt);
+        return self.s.ack(pkt, offer);
+    }
+    /**
+     *
+     * @param {*} pkt
+     * @returns
+     */
+    inform(pkt) {
+        var self = this;
+        if (pkt.options['60'] !== undefined && pkt.options['60'].indexOf('AAPLBSDPC/i386') === 0) {
+            var offer = {};
+            offer.siaddr = self.tftpserver;
+            offer.ciaddr = pkt.remote.address;
+            offer.options = {};
+            offer.options['54'] = self.host;
+            offer.options['60'] = 'AAPLBSDPC';
+            offer.options['255'] = null;
+            if (pkt.options['43'] !== undefined && pkt.options['43'].indexOf('01:01:01') === 0) {
+                // Mac OS X client: BSDP list
+                offer.options['43'] = '01:01:01:04:02:80:00:07:04:81:00:05:2a:08:04:81:00:05:2a:09:0d:81:00:05:2a:08:69:50:58:45:2d:46:4f:47';
+            }
+            else if (pkt.options['43'] !== undefined && pkt.options['43'].indexOf('01:01:02') === 0) {
+                // Mac OS X client: BSDP select
+                offer.options['43'] = '01:01:02:08:04:81:00:05:2a:82:0a:4e:65:74:42:6f:6f:74:30:30:31';
+                pkt.fname = self.efi64_filename;
+                pkt.sname = '141.62.66.114';
+            }
+            else {
+                console.log('Unknown BSDP request, not answering');
+                return;
+            }
+            return self.p.ack(pkt, offer);
+        }
+        else {
+            console.log('INFORM not by a Mac OS client, maybe Windows, ignoring');
+            return;
+        }
+    }
+    /**
+     *
+     * @param {*} pkt
+     * @returns
+     */
+    proxy_request(pkt) {
+        var self = this;
+        console.log("Received Proxy DHCP REQUEST");
+        var offer = {};
+        offer.siaddr = self.tftpserver;
+        offer.options = {};
+        offer.options['54'] = self.host;
+        offer.options['255'] = null;
+        if (pkt.options['60'] !== undefined) {
+            var arch = pkt.options['60'];
+            if (arch.indexOf('00009') === 15 || arch.indexOf('00007') === 15) {
+                // var next = '192.168.1.17'
+                var fname = self.efi64_filename;
+                if (pkt.options["77"] === "iPXE") {
+                    fname = `autoexec.ipxe`;
+                }
+                pkt.fname = fname;
+                // pkt.fname = self.efi_filename // vecchio
+                /*
+                console.log('====================================')
+                console.log('pkt: ' + JSON.stringify(pkt, '', 3))
+                console.log('====================================')
+                console.log('offer: ' + JSON.stringify(offer, '', 3))
+                console.log('====================================')
+                */
+            }
+            else if (arch.indexOf('00006') === 15) {
+                pkt.fname = self.efi32_filename;
+            }
+            else {
+                pkt.fname = self.bios_filename;
+            }
+        }
+        return self.p.ack(pkt, offer);
+    }
+}
+/**
+ *
+ */
+util.inherits(dhcpd, ee);
+/**
+ *
+ * @param {*} pkt
+ * @param {*} opt
+ * @returns
+ */
+function _get_option(pkt, opt) {
+    return (opt in pkt.options) ? pkt.options[opt] : undefined;
+}
+module.exports = dhcpd;

package/dist/dhcpd/index.js

@@ -0,0 +1,7 @@
+"use strict";
+// Generated by CoffeeScript 1.3.3
+module.exports = {
+    Packet: require('./packet'),
+    MessageTypes: require('./packet/types'),
+    Options: require('./packet/options')
+};