Change endpoint from persons to people

backend/apis/nodejs/node_modules/nodemailer/lib/smtp-connection/data-stream.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const stream = require('stream');
+const Transform = stream.Transform;
+
+/**
+ * Escapes dots in the beginning of lines. Ends the stream with <CR><LF>.<CR><LF>
+ * Also makes sure that only <CR><LF> sequences are used for linebreaks
+ *
+ * @param {Object} options Stream options
+ */
+class DataStream extends Transform {
+    constructor(options) {
+        super(options);
+        // init Transform
+        this.options = options || {};
+        this._curLine = '';
+
+        this.inByteCount = 0;
+        this.outByteCount = 0;
+        this.lastByte = false;
+    }
+
+    /**
+     * Escapes dots
+     */
+    _transform(chunk, encoding, done) {
+        let chunks = [];
+        let chunklen = 0;
+        let i,
+            len,
+            lastPos = 0;
+        let buf;
+
+        if (!chunk || !chunk.length) {
+            return done();
+        }
+
+        if (typeof chunk === 'string') {
+            chunk = Buffer.from(chunk);
+        }
+
+        this.inByteCount += chunk.length;
+
+        for (i = 0, len = chunk.length; i < len; i++) {
+            if (chunk[i] === 0x2e) {
+                // .
+                if ((i && chunk[i - 1] === 0x0a) || (!i && (!this.lastByte || this.lastByte === 0x0a))) {
+                    buf = chunk.slice(lastPos, i + 1);
+                    chunks.push(buf);
+                    chunks.push(Buffer.from('.'));
+                    chunklen += buf.length + 1;
+                    lastPos = i + 1;
+                }
+            } else if (chunk[i] === 0x0a) {
+                // .
+                if ((i && chunk[i - 1] !== 0x0d) || (!i && this.lastByte !== 0x0d)) {
+                    if (i > lastPos) {
+                        buf = chunk.slice(lastPos, i);
+                        chunks.push(buf);
+                        chunklen += buf.length + 2;
+                    } else {
+                        chunklen += 2;
+                    }
+                    chunks.push(Buffer.from('\r\n'));
+                    lastPos = i + 1;
+                }
+            }
+        }
+
+        if (chunklen) {
+            // add last piece
+            if (lastPos < chunk.length) {
+                buf = chunk.slice(lastPos);
+                chunks.push(buf);
+                chunklen += buf.length;
+            }
+
+            this.outByteCount += chunklen;
+            this.push(Buffer.concat(chunks, chunklen));
+        } else {
+            this.outByteCount += chunk.length;
+            this.push(chunk);
+        }
+
+        this.lastByte = chunk[chunk.length - 1];
+        done();
+    }
+
+    /**
+     * Finalizes the stream with a dot on a single line
+     */
+    _flush(done) {
+        let buf;
+        if (this.lastByte === 0x0a) {
+            buf = Buffer.from('.\r\n');
+        } else if (this.lastByte === 0x0d) {
+            buf = Buffer.from('\n.\r\n');
+        } else {
+            buf = Buffer.from('\r\n.\r\n');
+        }
+        this.outByteCount += buf.length;
+        this.push(buf);
+        done();
+    }
+}
+
+module.exports = DataStream;

backend/apis/nodejs/node_modules/nodemailer/lib/smtp-connection/http-proxy-client.js

@@ -0,0 +1,143 @@
+'use strict';
+
+/**
+ * Minimal HTTP/S proxy client
+ */
+
+const net = require('net');
+const tls = require('tls');
+const urllib = require('url');
+
+/**
+ * Establishes proxied connection to destinationPort
+ *
+ * httpProxyClient("http://localhost:3128/", 80, "google.com", function(err, socket){
+ *     socket.write("GET / HTTP/1.0\r\n\r\n");
+ * });
+ *
+ * @param {String} proxyUrl proxy configuration, etg "http://proxy.host:3128/"
+ * @param {Number} destinationPort Port to open in destination host
+ * @param {String} destinationHost Destination hostname
+ * @param {Function} callback Callback to run with the rocket object once connection is established
+ */
+function httpProxyClient(proxyUrl, destinationPort, destinationHost, callback) {
+    let proxy = urllib.parse(proxyUrl);
+
+    // create a socket connection to the proxy server
+    let options;
+    let connect;
+    let socket;
+
+    options = {
+        host: proxy.hostname,
+        port: Number(proxy.port) ? Number(proxy.port) : proxy.protocol === 'https:' ? 443 : 80
+    };
+
+    if (proxy.protocol === 'https:') {
+        // we can use untrusted proxies as long as we verify actual SMTP certificates
+        options.rejectUnauthorized = false;
+        connect = tls.connect.bind(tls);
+    } else {
+        connect = net.connect.bind(net);
+    }
+
+    // Error harness for initial connection. Once connection is established, the responsibility
+    // to handle errors is passed to whoever uses this socket
+    let finished = false;
+    let tempSocketErr = err => {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        try {
+            socket.destroy();
+        } catch (E) {
+            // ignore
+        }
+        callback(err);
+    };
+
+    let timeoutErr = () => {
+        let err = new Error('Proxy socket timed out');
+        err.code = 'ETIMEDOUT';
+        tempSocketErr(err);
+    };
+
+    socket = connect(options, () => {
+        if (finished) {
+            return;
+        }
+
+        let reqHeaders = {
+            Host: destinationHost + ':' + destinationPort,
+            Connection: 'close'
+        };
+        if (proxy.auth) {
+            reqHeaders['Proxy-Authorization'] = 'Basic ' + Buffer.from(proxy.auth).toString('base64');
+        }
+
+        socket.write(
+            // HTTP method
+            'CONNECT ' +
+                destinationHost +
+                ':' +
+                destinationPort +
+                ' HTTP/1.1\r\n' +
+                // HTTP request headers
+                Object.keys(reqHeaders)
+                    .map(key => key + ': ' + reqHeaders[key])
+                    .join('\r\n') +
+                // End request
+                '\r\n\r\n'
+        );
+
+        let headers = '';
+        let onSocketData = chunk => {
+            let match;
+            let remainder;
+
+            if (finished) {
+                return;
+            }
+
+            headers += chunk.toString('binary');
+            if ((match = headers.match(/\r\n\r\n/))) {
+                socket.removeListener('data', onSocketData);
+
+                remainder = headers.substr(match.index + match[0].length);
+                headers = headers.substr(0, match.index);
+                if (remainder) {
+                    socket.unshift(Buffer.from(remainder, 'binary'));
+                }
+
+                // proxy connection is now established
+                finished = true;
+
+                // check response code
+                match = headers.match(/^HTTP\/\d+\.\d+ (\d+)/i);
+                if (!match || (match[1] || '').charAt(0) !== '2') {
+                    try {
+                        socket.destroy();
+                    } catch (E) {
+                        // ignore
+                    }
+                    return callback(new Error('Invalid response from proxy' + ((match && ': ' + match[1]) || '')));
+                }
+
+                socket.removeListener('error', tempSocketErr);
+                socket.removeListener('timeout', timeoutErr);
+                socket.setTimeout(0);
+
+                return callback(null, socket);
+            }
+        };
+        socket.on('data', onSocketData);
+    });
+
+    socket.setTimeout(httpProxyClient.timeout || 30 * 1000);
+    socket.on('timeout', timeoutErr);
+
+    socket.once('error', tempSocketErr);
+}
+
+module.exports = httpProxyClient;