whistle 2.9.109 → 2.10.1

package/lib/inspectors/res.js

@@ -29,6 +29,7 @@ var LIKE_JSON_RE = /^\s*[\{\[]/;
 var NO_STORE_RE = /^no-store$/i;
 var NO_CACHE_RE = /^(?:no|no-cache|no-store)$/i;
 var X_RE = /^x/;
+var clientIpKey = config.CLIENT_IP_HEADER;
 var BODY_PROTOCOLS = [
   'attachment',
   'resReplace',
@@ -218,15 +219,10 @@ module.exports = function (req, res, next) {
                 ? util.rule.getMatcher(proxyRule)
                 : null;
             var headers = req.headers;
-            var curUrl,
-              auth,
-              isInternalProxy,
-              isHttpsProxy,
-              origPath,
-              origProxy;
+            var auth, isInternalProxy, isHttpsProxy, origPath, origProxy;
             if (!hostIp) {
-              if (options.localDNS && net.isIP(options.host)) {
-                curUrl = options.host;
+              if (options.localDNS) {
+                req.curUrl = '';
               } else if (proxyUrl) {
                 isHttpsProxy = proxyRule.isHttps;
                 isInternalProxy = proxyRule.isInternal || util.isInternalProxy(req);
@@ -240,84 +236,73 @@ module.exports = function (req, res, next) {
                 } else if (proxyRule.isHttp2https) {
                   options.protocol = 'https:';
                 }
-                curUrl = 'http:' + util.removeProtocol(proxyUrl);
+                req.curUrl = 'http:' + util.removeProtocol(proxyUrl);
               } else {
-                curUrl = options.href;
+                req.curUrl = options.href;
               }
             }
-            req.curUrl = curUrl;
-            req.setServerPort =
-              req.setServerPort ||
-              function (serverPort) {
-                req.serverPort = serverPort;
+            if (!req.setServerPort) {
+              req.setServerPort = function (port) {
+                req.serverPort = port;
               };
-            rules.resolveHost(
-              req,
-              function (err, ip, port, hostRule) {
-                var setHostsInfo = function (_ip, _port, _host, withPort) {
-                  ip = _ip || '127.0.0.1';
-                  port = _port;
-                  req.dnsTime = Date.now() - now;
-                  req.hostIp = util.joinIpPort(_ip, withPort && _port);
-                  if (_host) {
-                    resRules.host = _host;
-                  }
-                };
-                if (proxyUrl && proxyRule && hostRule) {
-                  proxyRule.host = hostRule;
-                  hostRule = null;
+            }
+            rules.resolveHost(req, function (err, ip, port, hostRule) {
+              var setHostsInfo = function (_ip, _port, _host, withPort) {
+                ip = _ip || '127.0.0.1';
+                port = _port;
+                req.dnsTime = Date.now() - now;
+                req.hostIp = util.joinIpPort(_ip, withPort && _port);
+                if (_host) {
+                  resRules.host = _host;
                 }
-                setHostsInfo(hostIp || ip, hostPort || port, hostRule);
-                if (err) {
-                  showDnsError(res, err);
-                  return;
+              };
+              if (proxyUrl && proxyRule && hostRule) {
+                proxyRule.host = hostRule;
+                hostRule = null;
+              }
+              setHostsInfo(hostIp || ip, hostPort || port, hostRule);
+              if (err) {
+                showDnsError(res, err);
+                return;
+              }
+              if (req.disable.keepalive) {
+                req.disable.keepAlive = true;
+              }
+              var isHttps = options.protocol == 'https:';
+              var proxyOptions, isProxyPort, isSocks;
+              var setAgent = function (disable) {
+                if (disable || req.disable.keepAlive || (isHttps && cert)) {
+                  options.agent = false;
+                } else {
+                  options.agent = isHttps ? config.httpsAgent : config.httpAgent;
                 }
-                if (req.disable.keepalive) {
-                  req.disable.keepAlive = true;
+              };
+              checkH2(req, isHttps);
+              if (proxyUrl) {
+                proxyOptions = parseUrl(proxyUrl);
+                proxyOptions.host = ip;
+                proxyOptions.auth = proxyOptions.auth || req._pacAuth;
+                isSocks = proxyRule.isSocks;
+                var proxyPort = proxyOptions.port;
+                if (!proxyPort) {
+                  proxyPort = proxyOptions.port = isSocks ? 1080 : isHttpsProxy ? 443 : 80;
                 }
-                var isHttps = options.protocol == 'https:';
-                var proxyOptions, isProxyPort, isSocks;
-                var setAgent = function (disable) {
-                  if (disable || req.disable.keepAlive || (isHttps && cert)) {
-                    options.agent = false;
-                  } else {
-                    options.agent = isHttps
-                      ? config.httpsAgent
-                      : config.httpAgent;
-                  }
-                };
-                checkH2(req, isHttps);
-                if (proxyUrl) {
-                  proxyOptions = parseUrl(proxyUrl);
-                  proxyOptions.host = ip;
-                  proxyOptions.auth = proxyOptions.auth || req._pacAuth;
-                  isSocks = proxyRule.isSocks;
-                  var proxyPort = proxyOptions.port;
-                  if (!proxyPort) {
-                    proxyPort = proxyOptions.port = isSocks
-                      ? 1080
-                      : isHttpsProxy
-                      ? 443
-                      : 80;
-                  }
-                  if (proxyOptions.auth) {
-                    auth =
-                      'Basic ' +
-                      util.toBuffer(proxyOptions.auth + '').toString('base64');
-                  } else {
-                    auth = headers['proxy-authorization'];
-                  }
-                  if (
+                if (proxyOptions.auth) {
+                  auth = 'Basic ' + util.toBuffer(proxyOptions.auth + '').toString('base64');
+                } else {
+                  auth = headers['proxy-authorization'];
+                }
+                if (
                     isHttps ||
                     (req.useH2 && !isInternalProxy) ||
                     isSocks ||
                     isHttpsProxy ||
                     req._phost
                   ) {
-                    isProxyPort = util.isProxyPort(proxyPort);
-                    if (isProxyPort && util.isLocalAddress(ip)) {
-                      req.setServerPort(config.port);
-                      res.response(
+                  isProxyPort = util.isProxyPort(proxyPort);
+                  if (isProxyPort && util.isLocalAddress(ip)) {
+                    req.setServerPort(config.port);
+                    res.response(
                         util.wrapResponse({
                           statusCode: 302,
                           headers: {
@@ -328,105 +313,105 @@ module.exports = function (req, res, next) {
                           }
                         })
                       );
-                    } else {
-                      var curServerPort = options.port || (isHttps ? 443 : 80);
-                      var proxyHeaders = {
-                        host: util.joinIpPort(options.hostname, curServerPort),
-                        'proxy-connection': req.disable.proxyConnection
+                  } else {
+                    var curServerPort = options.port || (isHttps ? 443 : 80);
+                    var proxyHeaders = {
+                      host: util.joinIpPort(options.hostname, curServerPort),
+                      'proxy-connection': req.disable.proxyConnection
                           ? 'close'
                           : 'keep-alive'
-                      };
-                      pluginMgr.getTunnelKeys().forEach(function (k) {
-                        var val = headers[k];
-                        if (val) {
-                          proxyHeaders[k] = val;
-                        }
-                      });
-                      if (auth) {
-                        proxyHeaders['proxy-authorization'] = auth;
-                      }
-                      if (req.disable.proxyUA) {
-                        delete proxyHeaders['user-agent'];
-                      } else if (headers['user-agent']) {
-                        proxyHeaders['user-agent'] = headers['user-agent'];
-                      }
-                      if (!util.isLocalAddress(req.clientIp)) {
-                        proxyHeaders[config.CLIENT_IP_HEAD] = req.clientIp;
-                      }
-                      if (isHttps || req.useH2) {
-                        util.checkIfAddInterceptPolicy(proxyHeaders, headers);
-                      }
-                      if (isProxyPort) {
-                        proxyHeaders[config.WEBUI_HEAD] = 1;
-                      }
-                      if (util.isProxyPort(curServerPort) || util.isLocalPHost(req, isHttps)) {
-                        headers[config.WEBUI_HEAD] = 1;
-                      }
-                      var clientId = req.headers[config.CLIENT_ID_HEADER];
-                      if (clientId) {
-                        proxyHeaders[config.CLIENT_ID_HEADER] = clientId;
+                    };
+                    pluginMgr.getTunnelKeys().forEach(function (k) {
+                      var val = headers[k];
+                      if (val) {
+                        proxyHeaders[k] = val;
                       }
-                      util.setClientId(
+                    });
+                    if (auth) {
+                      proxyHeaders['proxy-authorization'] = auth;
+                    }
+                    if (req.disable.proxyUA) {
+                      delete proxyHeaders['user-agent'];
+                    } else if (headers['user-agent']) {
+                      proxyHeaders['user-agent'] = headers['user-agent'];
+                    }
+                    if (!util.isLocalAddress(req.clientIp)) {
+                      proxyHeaders[clientIpKey] = req.clientIp;
+                    }
+                    if (isHttps || req.useH2) {
+                      util.checkIfAddInterceptPolicy(proxyHeaders, headers);
+                    }
+                    if (isProxyPort) {
+                      proxyHeaders[config.WEBUI_HEAD] = 1;
+                    }
+                    if (util.isProxyPort(curServerPort) || util.isLocalPHost(req, isHttps)) {
+                      headers[config.WEBUI_HEAD] = 1;
+                    }
+                    var clientId = req.headers[config.CLIENT_ID_HEADER];
+                    if (clientId) {
+                      proxyHeaders[config.CLIENT_ID_HEADER] = clientId;
+                    }
+                    util.setClientId(
                         proxyHeaders,
                         req.enable,
                         req.disable,
                         req.clientIp,
                         isInternalProxy
                       );
-                      var phost = req._phost;
-                      var opts = {
-                        isSocks: isSocks,
-                        isHttps: isHttps,
-                        _phost: phost,
-                        proxyServername: isHttpsProxy
+                    var phost = req._phost;
+                    var opts = {
+                      isSocks: isSocks,
+                      isHttps: isHttps,
+                      _phost: phost,
+                      proxyServername: isHttpsProxy
                           ? proxyOptions.hostname
                           : null,
-                        proxyHost: ip,
-                        clientIp: proxyHeaders[config.CLIENT_IP_HEAD],
-                        proxyPort: proxyPort,
-                        url: options.href,
-                        auth: proxyOptions.auth,
-                        headers: proxyHeaders
-                      };
-                      if (phost) {
-                        options.host = phost.hostname;
-                        if (phost.port > 0) {
-                          options.port = phost.port;
-                        } else if (!options.port) {
-                          options.port = isHttps ? 443 : 80;
-                        }
-                        proxyHeaders.host = util.joinIpPort(options.host, options.port);
-                      } else {
-                        options.host = options.hostname;
+                      proxyHost: ip,
+                      clientIp: proxyHeaders[clientIpKey],
+                      proxyPort: proxyPort,
+                      url: options.href,
+                      auth: proxyOptions.auth,
+                      headers: proxyHeaders
+                    };
+                    if (phost) {
+                      options.host = phost.hostname;
+                      if (phost.port > 0) {
+                        options.port = phost.port;
+                      } else if (!options.port) {
+                        options.port = isHttps ? 443 : 80;
                       }
-                      options._proxyOptions = opts;
-                      opts.proxyType = isSocks
+                      proxyHeaders.host = util.joinIpPort(options.host, options.port);
+                    } else {
+                      options.host = options.hostname;
+                    }
+                    options._proxyOptions = opts;
+                    opts.proxyType = isSocks
                         ? 'socks'
                         : isHttpsProxy
                         ? 'https'
                         : 'http';
-                      options._proxyPort = opts.proxyPort;
-                      origProxy = opts;
-                      request(options);
-                    }
-                    return;
+                    options._proxyPort = opts.proxyPort;
+                    origProxy = opts;
+                    request(options);
                   }
+                  return;
+                }
 
-                  if (auth) {
-                    headers['proxy-authorization'] = auth;
-                  }
+                if (auth) {
+                  headers['proxy-authorization'] = auth;
                 }
+              }
 
-                req.hostIp = util.joinIpPort(ip, port);
-                port = proxyOptions ? proxyOptions.port : port || options.port;
-                options.host = ip; //设置ip
-                var curPort = port || (isHttps ? 443 : 80);
-                isProxyPort = util.isProxyPort(curPort);
-                var isLocalAddress = util.isLocalAddress(options.host);
-                if (isProxyPort && isLocalAddress) {
-                  var redirectHost = config.customLocalUIHost || ip;
-                  var redirectPort = config.realPort || config.port;
-                  res.response(
+              req.hostIp = util.joinIpPort(ip, port);
+              port = proxyOptions ? proxyOptions.port : port || options.port;
+              options.host = ip; //设置ip
+              var curPort = port || (isHttps ? 443 : 80);
+              isProxyPort = util.isProxyPort(curPort);
+              var isLocalAddress = util.isLocalAddress(options.host);
+              if (isProxyPort && isLocalAddress) {
+                var redirectHost = config.customLocalUIHost || ip;
+                var redirectPort = config.realPort || config.port;
+                res.response(
                     util.wrapResponse({
                       statusCode: 302,
                       headers: {
@@ -437,137 +422,137 @@ module.exports = function (req, res, next) {
                       }
                     })
                   );
-                } else {
-                  if (
+              } else {
+                if (
                     isProxyPort ||
                     util.isProxyPort(options.port || (isHttps ? 443 : 80)) ||
                     util.isLocalPHost(req, isHttps)
                   ) {
-                    headers[config.WEBUI_HEAD] = 1;
-                  }
-                  setAgent(isLocalAddress);
-                  request(options, port, true);
+                  headers[config.WEBUI_HEAD] = 1;
                 }
-                function request(options, serverPort, direct) {
-                  options.headers = headers;
-                  options.method = req.method;
-                  util.setRejectUnauthorized(req, options);
-                  if (
+                setAgent(isLocalAddress);
+                request(options, port, true);
+              }
+              function request(options, serverPort, direct) {
+                options.headers = headers;
+                options.method = req.method;
+                util.setRejectUnauthorized(req, options);
+                if (
                     !options.isPlugin &&
                     !req._customHost &&
                     (req.fullUrl !== req.realUrl || !headers.host)
                   ) {
-                    headers.host = originHost;
-                  }
-                  if (req.disable.keepAlive) {
-                    headers.connection = 'close';
-                  }
-                  if (direct) {
-                    options.port = serverPort;
-                    if (proxyUrl) {
-                      origPath = options.path || '';
-                    }
+                  headers.host = originHost;
+                }
+                if (req.disable.keepAlive) {
+                  headers.connection = 'close';
+                }
+                if (direct) {
+                  options.port = serverPort;
+                  if (proxyUrl) {
+                    origPath = options.path || '';
                   }
+                }
 
-                  delete options.hostname; //防止自动dns
-                  delete options.protocol;
-                  if (isHttps && !req.disable.servername) {
-                    options.servername = util.parseHost(headers.host)[0];
-                  }
-                  var piped;
-                  var maxRetryCount = 1;
-                  var retryCount = 0;
-                  var retryXHost = 0;
-                  var resetCount = 0;
-                  var curClient, timer, newIp;
-                  var setProxyAgent = function (options, proxyOpts) {
-                    proxyOpts.cacheKey = options.cacheKey;
-                    proxyOpts.proxyTunnelPath = util.getProxyTunnelPath(
+                delete options.hostname; //防止自动dns
+                delete options.protocol;
+                if (isHttps && !req.disable.servername) {
+                  options.servername = util.parseHost(headers.host)[0];
+                }
+                var piped;
+                var maxRetryCount = 1;
+                var retryCount = 0;
+                var retryXHost = 0;
+                var resetCount = 0;
+                var curClient, timer, newIp;
+                var setProxyAgent = function (options, proxyOpts) {
+                  proxyOpts.cacheKey = options.cacheKey;
+                  proxyOpts.proxyTunnelPath = util.getProxyTunnelPath(
                       req,
                       isHttps
                     );
-                    proxyOpts.enableIntercept = true;
-                    options.agent = proxyOpts.isSocks
+                  proxyOpts.enableIntercept = true;
+                  options.agent = proxyOpts.isSocks
                       ? config.getSocksAgent(proxyOpts)
                       : config.getHttpsAgent(proxyOpts, options);
-                  };
-                  var retry = function (err) {
-                    clearTimeout(timer);
-                    timer = null;
-                    if (curClient) {
-                      curClient.removeListener('error', retry);
-                      curClient.removeListener('close', retry);
-                      curClient.on('error', util.noop);
-                      curClient.destroy();
-                      curClient = null;
-                    }
-                    if (req._hasError || req._hasRespond) {
-                      return;
-                    }
-                    if (err) {
+                };
+                var retry = function (err) {
+                  clearTimeout(timer);
+                  timer = null;
+                  if (curClient) {
+                    curClient.removeListener('error', retry);
+                    curClient.removeListener('close', retry);
+                    curClient.on('error', util.noop);
+                    curClient.destroy();
+                    curClient = null;
+                  }
+                  if (req._hasError || req._hasRespond) {
+                    return;
+                  }
+                  if (err) {
                       // Chrome 浏览器自动兼容 127.0.0.1 和 ::1
-                      if (util.notStarted(err)) {
-                        if (!newIp && (newIp = util.getLocalhostIP(err, req, originDomain, options.host))) {
-                          options.host = newIp;
-                          setHostsInfo(newIp);
-                        }
-                      } else if (isHttps && !options.ciphers && util.isCiphersError(err)) {
-                        extend(options, util.getTlsOptions(resRules));
-                        return send();
+                    if (util.notStarted(err)) {
+                      if (!newIp && (newIp = util.getLocalhostIP(err, req, originDomain, options.host))) {
+                        options.host = newIp;
+                        setHostsInfo(newIp);
                       }
+                    } else if (isHttps && !options.ciphers && util.isCiphersError(err)) {
+                      extend(options, util.getTlsOptions(resRules));
+                      return send();
                     }
-                    if (retryCount >= maxRetryCount) {
-                      var toHttp;
-                      if (
+                  }
+                  if (retryCount >= maxRetryCount) {
+                    var toHttp;
+                    if (
                         isHttps &&
                         (!piped || req.noReqBody) &&
                         util.checkTlsError(err) &&
                         util.checkAuto2Http(req, ip, proxyUrl)
                       ) {
-                        isHttps = false;
-                        toHttp = true;
-                        req.httpsTime = req.httpsTime || Date.now();
-                        req.useHttp = true;
-                        if (origProxy) {
-                          origProxy.isHttps = false;
-                          if (req._phost && !req._phost.port) {
-                            options.port = 80;
-                            origProxy.headers.host =
+                      isHttps = false;
+                      toHttp = true;
+                      req.httpsTime = req.httpsTime || Date.now();
+                      req.useHttp = true;
+                      if (origProxy) {
+                        origProxy.isHttps = false;
+                        if (req._phost && !req._phost.port) {
+                          options.port = 80;
+                          origProxy.headers.host =
                               req._phost.hostname + ':80';
-                          }
-                          setProxyAgent(options, origProxy);
-                        } else {
-                          setAgent(util.isLocalAddress(ip));
                         }
+                        setProxyAgent(options, origProxy);
+                      } else {
+                        setAgent(util.isLocalAddress(ip));
                       }
-                      var code = err && err.code;
-                      if (
+                    }
+                    var code = err && err.code;
+                    if (
                         !toHttp &&
                         (resetCount > 1 ||
                           (code !== 'EPROTO' && code !== 'ECONNRESET') ||
                           (piped && !req.noReqBody))
                       ) {
-                        var stack = util.getErrorStack(
+                      var stack = util.getErrorStack(
                           err || new Error('socket connect timeout')
                         );
-                        res.response(util.wrapGatewayError(stack));
-                      } else {
-                        ++resetCount;
-                        send();
-                      }
-                      return;
+                      res.response(util.wrapGatewayError(stack));
+                    } else {
+                      ++resetCount;
+                      send();
                     }
-                    ++retryCount;
-                    if (proxyUrl) {
-                      if (X_RE.test(proxyUrl)) {
-                        proxyUrl = '';
-                        req._phost = undefined;
-                        if (isInternalProxy) {
-                          isHttps = origProto === 'https:';
-                        }
-                        req.curUrl = req.realUrl;
-                        delete options._proxyPort;
-                        rules.resolveHost(
+                    return;
+                  }
+                  ++retryCount;
+                  if (proxyUrl) {
+                    if (X_RE.test(proxyUrl)) {
+                      proxyUrl = '';
+                      req._phost = undefined;
+                      if (isInternalProxy) {
+                        isHttps = origProto === 'https:';
+                      }
+                      req.curUrl = req.realUrl;
+                      delete options._proxyPort;
+                      rules.resolveHost(
                           req,
                           function (_err, _ip, _port, _host) {
                             setAgent(util.isLocalAddress(_ip));
@@ -582,101 +567,101 @@ module.exports = function (req, res, next) {
                             send();
                           }
                         );
-                        return;
-                      }
-                    } else if (
+                      return;
+                    }
+                  } else if (
                       retryXHost < 2 &&
                       req.rules.host &&
                       X_RE.test(req.rules.host.matcher)
                     ) {
-                      ++maxRetryCount;
-                      ++retryXHost;
-                      if (retryXHost > 1) {
-                        req.curUrl = req.realUrl;
-                        delete options._proxyPort;
-                        rules.lookupHost(req, function (_err, _ip) {
-                          setHostsInfo(_ip);
-                          if (_err) {
-                            showDnsError(res, _err);
-                            return;
-                          }
-                          options.host = ip;
-                          options.port = originPort;
-                          send();
-                        });
-                        return;
-                      }
-                    } else if (
+                    ++maxRetryCount;
+                    ++retryXHost;
+                    if (retryXHost > 1) {
+                      req.curUrl = req.realUrl;
+                      delete options._proxyPort;
+                      rules.lookupHost(req, function (_err, _ip) {
+                        setHostsInfo(_ip);
+                        if (_err) {
+                          showDnsError(res, _err);
+                          return;
+                        }
+                        options.host = ip;
+                        options.port = originPort;
+                        send();
+                      });
+                      return;
+                    }
+                  } else if (
                       isHttps &&
                       util.checkAuto2Http(req, ip, proxyUrl)
                     ) {
-                      ++maxRetryCount;
-                      if (maxRetryCount > 2 || util.checkTlsError(err)) {
-                        isHttps = false;
-                        req.httpsTime = req.httpsTime || Date.now();
-                        req.useHttp = true;
-                        setAgent(util.isLocalAddress(options.host));
-                      }
+                    ++maxRetryCount;
+                    if (maxRetryCount > 2 || util.checkTlsError(err)) {
+                      isHttps = false;
+                      req.httpsTime = req.httpsTime || Date.now();
+                      req.useHttp = true;
+                      setAgent(util.isLocalAddress(options.host));
                     }
-                    send();
-                  };
-                  var send = function (sock) {
-                    if (req._hasError) {
-                      return;
-                    }
-                    req.useH2 = false;
-                    req.setServerPort(
+                  }
+                  send();
+                };
+                var send = function (sock) {
+                  if (req._hasError) {
+                    return;
+                  }
+                  req.useH2 = false;
+                  req.setServerPort(
                       options._proxyPort || options.port || (isHttps ? 443 : 80)
                     );
-                    if (origPath != null && proxyUrl) {
-                      origPath = null;
-                      options.path =
+                  if (origPath != null && proxyUrl) {
+                    origPath = null;
+                    options.path =
                         (isHttps ? 'https:' : 'http:') +
                         '//' +
                         (headers.host || options.host) +
                         (options.path || '/');
-                    }
-                    var useHttps = isHttps;
-                    if (sock) {
-                      options.agent = null;
-                      options.createConnection = function () {
-                        return sock;
-                      };
-                    } else {
-                      var proxyOpts = options._proxyOptions;
-                      if (proxyOpts) {
-                        if (!req.useHttpH2 || proxyOpts._phost) {
-                          setProxyAgent(options, proxyOpts);
-                        } else {
-                          options.host = proxyOpts.proxyHost;
-                          options.port = proxyOpts.proxyPort;
-                          useHttps = useHttps || isHttpsProxy;
-                        }
-                        delete options._proxyOptions;
+                  }
+                  var useHttps = isHttps;
+                  if (sock) {
+                    options.agent = null;
+                    options.createConnection = function () {
+                      return sock;
+                    };
+                  } else {
+                    var proxyOpts = options._proxyOptions;
+                    if (proxyOpts) {
+                      if (!req.useHttpH2 || proxyOpts._phost) {
+                        setProxyAgent(options, proxyOpts);
+                      } else {
+                        options.host = proxyOpts.proxyHost;
+                        options.port = proxyOpts.proxyPort;
+                        useHttps = useHttps || isHttpsProxy;
                       }
+                      delete options._proxyOptions;
                     }
-                    options.protocol = useHttps ? 'https:' : 'http:';
-                    if (useHttps && !req.disable.secureOptions) {
-                      util.setSecureOptions(options);
-                    }
-                    try {
-                      var client = (useHttps ? https : http).request(
+                  }
+                  options.protocol = useHttps ? 'https:' : 'http:';
+                  if (useHttps && !req.disable.secureOptions) {
+                    util.setSecureOptions(options);
+                  }
+                  try {
+                    var client = (useHttps ? https : http).request(
                         options,
                         res.response
                       );
-                      curClient = client;
-                      req._clientReq = client;
-                      client.once('error', retry);
-                      client.once('socket', function (socket) {
-                        if (socket.connecting || socket._connecting) {
-                          if (TIMEOUT) {
-                            timer = setTimeout(function () {
-                              socket.destroy();
-                              timer = null;
-                              retry();
-                            }, TIMEOUT);
-                          }
-                          socket.once(
+                    curClient = client;
+                    req._clientReq = client;
+                    client.once('error', retry);
+                    client.once('socket', function (socket) {
+                      if (socket.connecting || socket._connecting) {
+                        if (TIMEOUT) {
+                          timer = setTimeout(function () {
+                            socket.destroy();
+                            timer = null;
+                            retry();
+                          }, TIMEOUT);
+                        }
+                        socket.once(
                             isHttpsProxy || isHttps
                               ? 'secureConnect'
                               : 'connect',
@@ -689,30 +674,30 @@ module.exports = function (req, res, next) {
                               pipeClient(req, client);
                             }
                           );
-                        } else {
-                          retryCount = maxRetryCount;
-                          piped = true;
-                          pipeClient(req, client);
-                          socket.resume();
-                        }
-                      });
-                    } catch (e) {
-                      res.response(
+                      } else {
+                        retryCount = maxRetryCount;
+                        piped = true;
+                        pipeClient(req, client);
+                        socket.resume();
+                      }
+                    });
+                  } catch (e) {
+                    res.response(
                         util.wrapGatewayError(util.getErrorStack(e))
                       );
-                    }
-                  };
-                  if (req.disable.clientIp || req.disable.clientIP) {
-                    delete headers[config.CLIENT_IP_HEAD];
-                  } else {
-                    var forwardedFor = util.getMatcherValue(
+                  }
+                };
+                if (req.disable.clientIp || req.disable.clientIP) {
+                  delete headers[clientIpKey];
+                } else {
+                  var forwardedFor = util.getMatcherValue(
                       resRules.forwardedFor
                     );
-                    if (net.isIP(forwardedFor)) {
-                      headers[config.CLIENT_IP_HEAD] = forwardedFor;
-                    } else if (net.isIP(req._customXFF)) {
-                      headers[config.CLIENT_IP_HEAD] = req._customXFF;
-                    } else if (
+                  if (net.isIP(forwardedFor)) {
+                    headers[clientIpKey] = forwardedFor;
+                  } else if (req._customXFF) {
+                    headers[clientIpKey] = req._customXFF;
+                  } else if (
                       (!options.isPlugin &&
                         !req.enable.clientIp &&
                         !req.enable.clientIP &&
@@ -720,76 +705,76 @@ module.exports = function (req, res, next) {
                         (isHttps || isSocks || !proxyUrl)) ||
                       util.isLocalAddress(req.clientIp)
                     ) {
-                      delete headers[config.CLIENT_IP_HEAD];
-                    } else {
-                      headers[config.CLIENT_IP_HEAD] = req.clientIp;
-                    }
+                    delete headers[clientIpKey];
+                  } else {
+                    headers[clientIpKey] = req.clientIp;
                   }
-                  util.deleteReqHeaders(req);
-                  var optHeaders = options.headers;
-                  var transfer =
+                }
+                util.deleteReqHeaders(req);
+                var optHeaders = options.headers;
+                var transfer =
                     options.method === 'DELETE' &&
                     optHeaders['transfer-encoding'];
-                  if (transfer) {
-                    delete optHeaders['transfer-encoding'];
+                if (transfer) {
+                  delete optHeaders['transfer-encoding'];
+                }
+                var clientId = optHeaders[config.CLIENT_ID_HEADER];
+                if (clientId) {
+                  if (!options.isPlugin && !req._customClientId && !util.isKeepClientId(req, proxyUrl)) {
+                    req._origClientId = clientId;
+                    util.removeClientId(optHeaders);
                   }
-                  var clientId = optHeaders[config.CLIENT_ID_HEADER];
-                  if (clientId) {
-                    if (!options.isPlugin && !req._customClientId && !util.isKeepClientId(req, proxyUrl)) {
-                      req._origClientId = clientId;
-                      util.removeClientId(optHeaders);
-                    }
-                    req.setClientId && req.setClientId(clientId);
-                  } else {
-                    util.setClientId(
+                  req.setClientId && req.setClientId(clientId);
+                } else {
+                  util.setClientId(
                       optHeaders,
                       req.enable,
                       req.disable,
                       req.clientIp,
                       isInternalProxy
                     );
-                  }
-                  if (
+                }
+                if (
                     req.useH2 &&
                     (isInternalProxy ||
                       headers[config.HTTPS_FIELD] ||
                       options.isPlugin)
                   ) {
-                    headers[config.ALPN_PROTOCOL_HEADER] = 'h2';
-                  }
-                  options.headers = optHeaders = formatHeaders(
+                  headers[config.ALPN_PROTOCOL_HEADER] = 'h2';
+                }
+                options.headers = optHeaders = formatHeaders(
                     optHeaders,
                     req.rawHeaderNames
                   );
-                  delete headers[config.WEBUI_HEAD];
-                  delete headers[config.HTTPS_FIELD];
-                  delete headers[config.ALPN_PROTOCOL_HEADER];
-                  if (transfer) {
-                    optHeaders['Transfer-Encoding'] = transfer;
-                  }
-                  if (options.isPlugin) {
-                    optHeaders[config.PLUGIN_HOOK_NAME_HEADER] =
+                delete headers[config.WEBUI_HEAD];
+                delete headers[config.HTTPS_FIELD];
+                delete headers[config.ALPN_PROTOCOL_HEADER];
+                if (transfer) {
+                  optHeaders['Transfer-Encoding'] = transfer;
+                }
+                if (options.isPlugin) {
+                  optHeaders[config.PLUGIN_HOOK_NAME_HEADER] =
                       config.PLUGIN_HOOKS.HTTP;
-                  }
-                  req.noReqBody = !util.hasRequestBody(req);
-                  if (
+                }
+                req.noReqBody = !util.hasRequestBody(req);
+                if (
                     req.method === 'DELETE' &&
                     (req._hasInjectBody ||
                       req.headers['transfer-encoding'] ||
                       req.headers['content-length'] > 0)
                   ) {
-                    req.useH2 = false;
-                  }
-                  req.setServerPort(
+                  req.useH2 = false;
+                }
+                req.setServerPort(
                     options._proxyPort || options.port || (isHttps ? 443 : 80)
                   );
-                  req.options = options;
-                  isHttps &&
+                req.options = options;
+                isHttps &&
                     util.setClientCert(options, key, cert, isPfx, cacheKey);
-                  util.addMatchedRules(req);
-                  h2.request(req, res, send);
-                }
-              },
+                util.addMatchedRules(req);
+                h2.request(req, res, send);
+              }
+            },
               req.pluginRules,
               req.rulesFileMgr,
               req.headerRulesMgr
@@ -833,7 +818,7 @@ module.exports = function (req, res, next) {
       delete headers[config.PROXY_ID_HEADER];
     }
     if (req.disable.additionalHeaders) {
-      delete headers[config.ADDITIONAL_HEAD];
+      delete headers[util.ADDITIONAL_HEAD];
     }
     util.drain(req, function () {
       readFirstChunk(req, res, _res, function (firstChunk) {
@@ -1140,12 +1125,12 @@ module.exports = function (req, res, next) {
 
                 var bodyFile = hasResBody
                     ? getWriterFile(
-                        util.getRuleFile(resRules.resWrite),
+                        util.getWriteFilePath(resRules.resWrite),
                         _res.statusCode
                       )
                     : null;
                 var rawFile = getWriterFile(
-                    util.getRuleFile(resRules.resWriteRaw),
+                    util.getWriteFilePath(resRules.resWriteRaw),
                     _res.statusCode
                   );
                 util.getFileWriters(