cloudcms-server 0.9.270 → 0.9.271

package/temp/node-http-proxy/dist/http-proxy/passes/web-outgoing.js

@@ -0,0 +1,135 @@
+"use strict";
+const url = require('url'), common = require('../common');
+const redirectRegex = /^201|30(1|2|7|8)$/;
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+module.exports = {
+    // <--
+    /**
+     * If is a HTTP 1.0 request, remove chunk headers
+     *
+     * @param {ClientRequest} req Request object
+     * @param {IncomingMessage} res Response object
+     * @param {proxyResponse} proxyRes Response object from the proxy request
+     *
+     * @api private
+     */
+    removeChunked: function removeChunked(req, res, proxyRes) {
+        if (req.httpVersion === '1.0') {
+            delete proxyRes.headers['transfer-encoding'];
+        }
+    },
+    /**
+     * If is a HTTP 1.0 request, set the correct connection header
+     * or if connection header not present, then use `keep-alive`
+     *
+     * @param {ClientRequest} req Request object
+     * @param {IncomingMessage} res Response object
+     * @param {proxyResponse} proxyRes Response object from the proxy request
+     *
+     * @api private
+     */
+    setConnection: function setConnection(req, res, proxyRes) {
+        if (req.httpVersion === '1.0') {
+            proxyRes.headers.connection = req.headers.connection || 'close';
+        }
+        else if (req.httpVersion !== '2.0' && !proxyRes.headers.connection) {
+            proxyRes.headers.connection = req.headers.connection || 'keep-alive';
+        }
+    },
+    setRedirectHostRewrite: function setRedirectHostRewrite(req, res, proxyRes, options) {
+        if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) &&
+            proxyRes.headers['location'] &&
+            redirectRegex.test(proxyRes.statusCode)) {
+            const target = url.parse(options.target);
+            const u = url.parse(proxyRes.headers['location']);
+            // make sure the redirected host matches the target host before rewriting
+            if (target.host != u.host) {
+                return;
+            }
+            if (options.hostRewrite) {
+                u.host = options.hostRewrite;
+            }
+            else if (options.autoRewrite) {
+                u.host = req.headers['host'];
+            }
+            if (options.protocolRewrite) {
+                u.protocol = options.protocolRewrite;
+            }
+            proxyRes.headers['location'] = u.format();
+        }
+    },
+    /**
+     * Copy headers from proxyResponse to response
+     * set each header in response object.
+     *
+     * @param {ClientRequest} req Request object
+     * @param {IncomingMessage} res Response object
+     * @param {proxyResponse} proxyRes Response object from the proxy request
+     * @param {Object} options options.cookieDomainRewrite: Config to rewrite cookie domain
+     *
+     * @api private
+     */
+    writeHeaders: function writeHeaders(req, res, proxyRes, options) {
+        let rewriteCookieDomainConfig = options.cookieDomainRewrite, rewriteCookiePathConfig = options.cookiePathRewrite, rawHeaderKeyMap;
+        const preserveHeaderKeyCase = options.preserveHeaderKeyCase, setHeader = function (key, header) {
+            if (header == undefined)
+                return;
+            if (rewriteCookieDomainConfig && key.toLowerCase() === 'set-cookie') {
+                header = common.rewriteCookieProperty(header, rewriteCookieDomainConfig, 'domain');
+            }
+            if (rewriteCookiePathConfig && key.toLowerCase() === 'set-cookie') {
+                header = common.rewriteCookieProperty(header, rewriteCookiePathConfig, 'path');
+            }
+            res.setHeader(String(key).trim(), header);
+        };
+        if (typeof rewriteCookieDomainConfig === 'string') {
+            //also test for ''
+            rewriteCookieDomainConfig = { '*': rewriteCookieDomainConfig };
+        }
+        if (typeof rewriteCookiePathConfig === 'string') {
+            //also test for ''
+            rewriteCookiePathConfig = { '*': rewriteCookiePathConfig };
+        }
+        // message.rawHeaders is added in: v0.11.6
+        // https://nodejs.org/api/http.html#http_message_rawheaders
+        if (preserveHeaderKeyCase && proxyRes.rawHeaders != undefined) {
+            rawHeaderKeyMap = {};
+            for (let i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+                const key = proxyRes.rawHeaders[i];
+                rawHeaderKeyMap[key.toLowerCase()] = key;
+            }
+        }
+        Object.keys(proxyRes.headers).forEach(function (key) {
+            const header = proxyRes.headers[key];
+            if (preserveHeaderKeyCase && rawHeaderKeyMap) {
+                key = rawHeaderKeyMap[key] || key;
+            }
+            setHeader(key, header);
+        });
+    },
+    /**
+     * Set the statusCode from the proxyResponse
+     *
+     * @param {ClientRequest} req Request object
+     * @param {IncomingMessage} res Response object
+     * @param {proxyResponse} proxyRes Response object from the proxy request
+     *
+     * @api private
+     */
+    writeStatusCode: function writeStatusCode(req, res, proxyRes) {
+        // From Node.js docs: response.writeHead(statusCode[, statusMessage][, headers])
+        if (proxyRes.statusMessage) {
+            res.statusCode = proxyRes.statusCode;
+            res.statusMessage = proxyRes.statusMessage;
+        }
+        else {
+            res.statusCode = proxyRes.statusCode;
+        }
+    },
+};

package/temp/node-http-proxy/dist/http-proxy/passes/ws-incoming.js

@@ -0,0 +1,141 @@
+"use strict";
+const http = require('http'), https = require('https'), common = require('../common');
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, socket, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+/*
+ * Websockets Passes
+ *
+ */
+module.exports = {
+    /**
+     * WebSocket requests must have the `GET` method and
+     * the `upgrade:websocket` header
+     *
+     * @param {ClientRequest} req Request object
+     * @param {Socket} socket
+     *
+     * @api private
+     */
+    checkMethodAndHeader: function checkMethodAndHeader(req, socket) {
+        if (req.method !== 'GET' || !req.headers.upgrade) {
+            socket.destroy();
+            return true;
+        }
+        if (req.headers.upgrade.toLowerCase() !== 'websocket') {
+            socket.destroy();
+            return true;
+        }
+    },
+    /**
+     * Sets `x-forwarded-*` headers if specified in config.
+     *
+     * @param {ClientRequest} req Request object
+     * @param {Socket} socket
+     * @param {Object} options Config object passed to the proxy
+     *
+     * @api private
+     */
+    XHeaders: function XHeaders(req, socket, options) {
+        if (!options.xfwd)
+            return;
+        const values = {
+            for: req.connection.remoteAddress || req.socket.remoteAddress,
+            port: common.getPort(req),
+            proto: common.hasEncryptedConnection(req) ? 'wss' : 'ws',
+        };
+        ['for', 'port', 'proto'].forEach(function (header) {
+            req.headers['x-forwarded-' + header] =
+                (req.headers['x-forwarded-' + header] || '') +
+                    (req.headers['x-forwarded-' + header] ? ',' : '') +
+                    values[header];
+        });
+    },
+    /**
+     * Does the actual proxying. Make the request and upgrade it
+     * send the Switching Protocols request and pipe the sockets.
+     *
+     * @param {ClientRequest} req Request object
+     * @param {Socket} socket
+     * @param {Object} options Config object passed to the proxy
+     *
+     * @api private
+     */
+    stream: function stream(req, socket, options, head, server, clb) {
+        const createHttpHeader = function (line, headers) {
+            return (Object.keys(headers)
+                .reduce(function (head, key) {
+                const value = headers[key];
+                if (!Array.isArray(value)) {
+                    head.push(key + ': ' + value);
+                    return head;
+                }
+                for (let i = 0; i < value.length; i++) {
+                    head.push(key + ': ' + value[i]);
+                }
+                return head;
+            }, [line])
+                .join('\r\n') + '\r\n\r\n');
+        };
+        common.setupSocket(socket);
+        if (head && head.length)
+            socket.unshift(head);
+        const proxyReq = (common.isSSL.test(options.target.protocol) ? https : http).request(common.setupOutgoing(options.ssl || {}, options, req));
+        // Enable developers to modify the proxyReq before headers are sent
+        if (server) {
+            server.emit('proxyReqWs', proxyReq, req, socket, options, head);
+        }
+        // Error Handler
+        proxyReq.on('error', onOutgoingError);
+        proxyReq.on('response', function (res) {
+            // if upgrade event isn't going to happen, close the socket
+            if (!res.upgrade) {
+                socket.write(createHttpHeader('HTTP/' +
+                    res.httpVersion +
+                    ' ' +
+                    res.statusCode +
+                    ' ' +
+                    res.statusMessage, res.headers));
+                res.pipe(socket);
+            }
+        });
+        proxyReq.on('upgrade', function (proxyRes, proxySocket, proxyHead) {
+            proxySocket.on('error', onOutgoingError);
+            // Allow us to listen when the websocket has completed
+            proxySocket.on('end', function () {
+                server.emit('close', proxyRes, proxySocket, proxyHead);
+            });
+            // The pipe below will end proxySocket if socket closes cleanly, but not
+            // if it errors (eg, vanishes from the net and starts returning
+            // EHOSTUNREACH). We need to do that explicitly.
+            socket.on('error', function () {
+                proxySocket.end();
+            });
+            common.setupSocket(proxySocket);
+            if (proxyHead && proxyHead.length)
+                proxySocket.unshift(proxyHead);
+            //
+            // Remark: Handle writing the headers to the socket when switching protocols
+            // Also handles when a header is an array
+            //
+            socket.write(createHttpHeader('HTTP/1.1 101 Switching Protocols', proxyRes.headers));
+            proxySocket.pipe(socket).pipe(proxySocket);
+            server.emit('open', proxySocket);
+            server.emit('proxySocket', proxySocket); //DEPRECATED.
+        });
+        return proxyReq.end(); // XXX: CHECK IF THIS IS THIS CORRECT
+        function onOutgoingError(err) {
+            if (clb) {
+                clb(err, req, socket);
+            }
+            else {
+                server.emit('error', err, req, socket);
+            }
+            socket.end();
+        }
+    },
+};

package/temp/node-http-proxy/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/*!
+ * Caron dimonio, con occhi di bragia
+ * loro accennando, tutte le raccoglie;
+ * batte col remo qualunque s’adagia
+ *
+ * Charon the demon, with the eyes of glede,
+ * Beckoning to them, collects them all together,
+ * Beats with his oar whoever lags behind
+ *
+ *          Dante - The Divine Comedy (Canto III)
+ */
+module.exports = './http-proxy';

package/temp/node-http-proxy/lib/http-proxy/common.js

@@ -0,0 +1,265 @@
+const common = exports,
+  url = require('url'),
+  extend = require('util')._extend,
+  required = require('requires-port');
+
+const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i,
+  isSSL = /^https|wss/;
+
+/**
+ * Simple Regex for testing if protocol is https
+ */
+common.isSSL = isSSL;
+/**
+ * Copies the right headers from `options` and `req` to
+ * `outgoing` which is then used to fire the proxied
+ * request.
+ *
+ * Examples:
+ *
+ *    common.setupOutgoing(outgoing, options, req)
+ *    // => { host: ..., hostname: ...}
+ *
+ * @param {Object} Outgoing Base object to be filled with required properties
+ * @param {Object} Options Config object passed to the proxy
+ * @param {ClientRequest} Req Request Object
+ * @param {String} Forward String to select forward or target
+ *
+ * @return {Object} Outgoing Object with all required properties set
+ *
+ * @api private
+ */
+
+common.setupOutgoing = function (outgoing, options, req, forward) {
+  outgoing.port =
+    options[forward || 'target'].port ||
+    (isSSL.test(options[forward || 'target'].protocol) ? 443 : 80);
+
+  [
+    'host',
+    'hostname',
+    'socketPath',
+    'pfx',
+    'key',
+    'passphrase',
+    'cert',
+    'ca',
+    'ciphers',
+    'secureProtocol',
+  ].forEach(function (e) {
+    outgoing[e] = options[forward || 'target'][e];
+  });
+
+  outgoing.method = options.method || req.method;
+  outgoing.headers = extend({}, req.headers);
+
+  if (options.headers) {
+    extend(outgoing.headers, options.headers);
+  }
+
+  if (options.auth) {
+    outgoing.auth = options.auth;
+  }
+
+  if (options.ca) {
+    outgoing.ca = options.ca;
+  }
+
+  if (isSSL.test(options[forward || 'target'].protocol)) {
+    outgoing.rejectUnauthorized =
+      typeof options.secure === 'undefined' ? true : options.secure;
+  }
+
+  outgoing.agent = options.agent || false;
+  outgoing.localAddress = options.localAddress;
+
+  //
+  // Remark: If we are false and not upgrading, set the connection: close. This is the right thing to do
+  // as node core doesn't handle this COMPLETELY properly yet.
+  //
+  if (!outgoing.agent) {
+    outgoing.headers = outgoing.headers || {};
+    if (
+      typeof outgoing.headers.connection !== 'string' ||
+      !upgradeHeader.test(outgoing.headers.connection)
+    ) {
+      outgoing.headers.connection = 'close';
+    }
+  }
+
+  // the final path is target path + relative path requested by user:
+  const target = options[forward || 'target'];
+  const targetPath =
+    target && options.prependPath !== false ? target.path || '' : '';
+
+  //
+  // Remark: Can we somehow not use url.parse as a perf optimization?
+  //
+  let outgoingPath = !options.toProxy ? url.parse(req.url).path || '' : req.url;
+
+  //
+  // Remark: ignorePath will just straight up ignore whatever the request's
+  // path is. This can be labeled as FOOT-GUN material if you do not know what
+  // you are doing and are using conflicting options.
+  //
+  outgoingPath = !options.ignorePath ? outgoingPath : '';
+
+  outgoing.path = common.urlJoin(targetPath, outgoingPath);
+
+  if (options.changeOrigin) {
+    outgoing.headers.host =
+      required(outgoing.port, options[forward || 'target'].protocol) &&
+      !hasPort(outgoing.host)
+        ? outgoing.host + ':' + outgoing.port
+        : outgoing.host;
+  }
+  return outgoing;
+};
+
+/**
+ * Set the proper configuration for sockets,
+ * set no delay and set keep alive, also set
+ * the timeout to 0.
+ *
+ * Examples:
+ *
+ *    common.setupSocket(socket)
+ *    // => Socket
+ *
+ * @param {Socket} Socket instance to setup
+ *
+ * @return {Socket} Return the configured socket.
+ *
+ * @api private
+ */
+
+common.setupSocket = function (socket) {
+  socket.setTimeout(0);
+  socket.setNoDelay(true);
+
+  socket.setKeepAlive(true, 0);
+
+  return socket;
+};
+
+/**
+ * Get the port number from the host. Or guess it based on the connection type.
+ *
+ * @param {Request} req Incoming HTTP request.
+ *
+ * @return {String} The port number.
+ *
+ * @api private
+ */
+common.getPort = function (req) {
+  const res = req.headers.host ? req.headers.host.match(/:(\d+)/) : '';
+
+  return res ? res[1] : common.hasEncryptedConnection(req) ? '443' : '80';
+};
+
+/**
+ * Check if the request has an encrypted connection.
+ *
+ * @param {Request} req Incoming HTTP request.
+ *
+ * @return {Boolean} Whether the connection is encrypted or not.
+ *
+ * @api private
+ */
+common.hasEncryptedConnection = function (req) {
+  return Boolean(req.connection.encrypted || req.connection.pair);
+};
+
+/**
+ * OS-agnostic join (doesn't break on URLs like path.join does on Windows)>
+ *
+ * @return {String} The generated path.
+ *
+ * @api private
+ */
+
+common.urlJoin = function () {
+  //
+  // We do not want to mess with the query string. All we want to touch is the path.
+  //
+  const args = Array.prototype.slice.call(arguments),
+    lastIndex = args.length - 1,
+    last = args[lastIndex],
+    lastSegs = last.split('?');
+
+  args[lastIndex] = lastSegs.shift();
+
+  //
+  // Join all strings, but remove empty strings so we don't get extra slashes from
+  // joining e.g. ['', 'am']
+  //
+  const retSegs = [
+    args
+      .filter(Boolean)
+      .join('/')
+      .replace(/\/+/g, '/')
+      .replace('http:/', 'http://')
+      .replace('https:/', 'https://'),
+  ];
+
+  // Only join the query string if it exists so we don't have trailing a '?'
+  // on every request
+
+  // Handle case where there could be multiple ? in the URL.
+  retSegs.push.apply(retSegs, lastSegs);
+
+  return retSegs.join('?');
+};
+
+/**
+ * Rewrites or removes the domain of a cookie header
+ *
+ * @param {String|Array} header
+ * @param {Object} config, mapping of domain to rewritten domain.
+ *                 '*' key to match any domain, null value to remove the domain.
+ *
+ * @api private
+ */
+common.rewriteCookieProperty = function rewriteCookieProperty(
+  header,
+  config,
+  property,
+) {
+  if (Array.isArray(header)) {
+    return header.map(function (headerElement) {
+      return rewriteCookieProperty(headerElement, config, property);
+    });
+  }
+  return header.replace(
+    new RegExp('(;\\s*' + property + '=)([^;]+)', 'i'),
+    function (match, prefix, previousValue) {
+      let newValue;
+      if (previousValue in config) {
+        newValue = config[previousValue];
+      } else if ('*' in config) {
+        newValue = config['*'];
+      } else {
+        //no match, return previous value
+        return match;
+      }
+      if (newValue) {
+        //replace value
+        return prefix + newValue;
+      } else {
+        //remove value
+        return '';
+      }
+    },
+  );
+};
+
+/**
+ * Check the host and see if it potentially has a port in it (keep it simple)
+ *
+ * @returns {Boolean} Whether we have one or not
+ *
+ * @api private
+ */
+function hasPort(host) {
+  return !!~host.indexOf(':');
+}