2015-12-10 13:58:50 +01:00
|
|
|
/**
|
2017-01-11 16:24:33 +01:00
|
|
|
* Copyright JS Foundation and other contributors, http://js.foundation
|
2015-12-10 13:58:50 +01:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
**/
|
|
|
|
|
|
|
|
module.exports = function(RED) {
|
|
|
|
"use strict";
|
2021-04-23 15:19:15 +02:00
|
|
|
const got = require("got");
|
|
|
|
const {CookieJar} = require("tough-cookie");
|
|
|
|
const { HttpProxyAgent, HttpsProxyAgent } = require('hpagent');
|
|
|
|
const FormData = require('form-data');
|
|
|
|
const { v4: uuid } = require('uuid');
|
|
|
|
const crypto = require('crypto');
|
|
|
|
const URL = require("url").URL
|
2015-12-10 13:58:50 +01:00
|
|
|
var mustache = require("mustache");
|
|
|
|
var querystring = require("querystring");
|
2017-06-05 12:33:24 +02:00
|
|
|
var cookie = require("cookie");
|
2017-06-27 12:23:13 +02:00
|
|
|
var hashSum = require("hash-sum");
|
2015-12-10 13:58:50 +01:00
|
|
|
|
2021-07-21 17:22:28 +02:00
|
|
|
|
|
|
|
// Cache a reference to the existing https.request function
|
|
|
|
// so we can compare later to see if an old agent-base instance
|
|
|
|
// has been required.
|
|
|
|
// This is generally okay as the core nodes are required before
|
|
|
|
// any contrib nodes. Where it will fail is if the agent-base module
|
|
|
|
// is required via the settings file or outside of Node-RED before it
|
|
|
|
// is started.
|
|
|
|
// If there are other modules that patch the function, they will get undone
|
|
|
|
// as well. Not much we can do about that right now. Patching core
|
|
|
|
// functions is bad.
|
|
|
|
const HTTPS_MODULE = require("https");
|
|
|
|
const HTTPS_REQUEST = HTTPS_MODULE.request;
|
|
|
|
|
|
|
|
function checkNodeAgentPatch() {
|
2021-07-22 12:19:25 +02:00
|
|
|
if (HTTPS_MODULE.request !== HTTPS_REQUEST && HTTPS_MODULE.request.length === 2) {
|
2021-07-21 17:22:28 +02:00
|
|
|
RED.log.warn(`
|
|
|
|
|
|
|
|
---------------------------------------------------------------------
|
|
|
|
Patched https.request function detected. This will break the
|
|
|
|
HTTP Request node. The original code has now been restored.
|
|
|
|
|
|
|
|
This is likely caused by a contrib node including an old version of
|
|
|
|
the 'agent-base@<5.0.0' module.
|
|
|
|
|
|
|
|
You can identify what node is at fault by running:
|
|
|
|
npm list agent-base
|
|
|
|
in your Node-RED user directory (${RED.settings.userDir}).
|
|
|
|
---------------------------------------------------------------------
|
|
|
|
`);
|
|
|
|
HTTPS_MODULE.request = HTTPS_REQUEST
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-10 13:58:50 +01:00
|
|
|
function HTTPRequest(n) {
|
|
|
|
RED.nodes.createNode(this,n);
|
2021-07-21 17:22:28 +02:00
|
|
|
checkNodeAgentPatch();
|
2016-04-27 13:31:54 +02:00
|
|
|
var node = this;
|
2015-12-10 13:58:50 +01:00
|
|
|
var nodeUrl = n.url;
|
|
|
|
var isTemplatedUrl = (nodeUrl||"").indexOf("{{") != -1;
|
|
|
|
var nodeMethod = n.method || "GET";
|
2020-02-26 20:45:01 +01:00
|
|
|
var paytoqs = false;
|
|
|
|
var paytobody = false;
|
2021-04-23 15:19:15 +02:00
|
|
|
var redirectList = [];
|
|
|
|
|
2019-08-12 21:52:00 +02:00
|
|
|
var nodeHTTPPersistent = n["persist"];
|
2016-04-27 13:31:54 +02:00
|
|
|
if (n.tls) {
|
|
|
|
var tlsNode = RED.nodes.getNode(n.tls);
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
this.ret = n.ret || "txt";
|
2019-02-27 23:15:31 +01:00
|
|
|
this.authType = n.authType || "basic";
|
2016-02-15 10:45:58 +01:00
|
|
|
if (RED.settings.httpRequestTimeout) { this.reqTimeout = parseInt(RED.settings.httpRequestTimeout) || 120000; }
|
|
|
|
else { this.reqTimeout = 120000; }
|
2015-12-10 13:58:50 +01:00
|
|
|
|
2020-02-26 20:45:01 +01:00
|
|
|
if (n.paytoqs === true || n.paytoqs === "query") { paytoqs = true; }
|
|
|
|
else if (n.paytoqs === "body") { paytobody = true; }
|
|
|
|
|
|
|
|
|
2015-12-10 13:58:50 +01:00
|
|
|
var prox, noprox;
|
2019-11-03 10:54:23 +01:00
|
|
|
if (process.env.http_proxy) { prox = process.env.http_proxy; }
|
|
|
|
if (process.env.HTTP_PROXY) { prox = process.env.HTTP_PROXY; }
|
|
|
|
if (process.env.no_proxy) { noprox = process.env.no_proxy.split(","); }
|
|
|
|
if (process.env.NO_PROXY) { noprox = process.env.NO_PROXY.split(","); }
|
2015-12-10 13:58:50 +01:00
|
|
|
|
2018-10-03 02:58:25 +02:00
|
|
|
var proxyConfig = null;
|
|
|
|
if (n.proxy) {
|
|
|
|
proxyConfig = RED.nodes.getNode(n.proxy);
|
|
|
|
prox = proxyConfig.url;
|
|
|
|
noprox = proxyConfig.noproxy;
|
|
|
|
}
|
|
|
|
|
2019-08-14 16:54:06 +02:00
|
|
|
this.on("input",function(msg,nodeSend,nodeDone) {
|
2021-07-21 17:22:28 +02:00
|
|
|
checkNodeAgentPatch();
|
2021-05-11 10:56:22 +02:00
|
|
|
//reset redirectList on each request
|
|
|
|
redirectList = [];
|
2015-12-10 13:58:50 +01:00
|
|
|
var preRequestTimestamp = process.hrtime();
|
|
|
|
node.status({fill:"blue",shape:"dot",text:"httpin.status.requesting"});
|
2017-04-09 01:43:15 +02:00
|
|
|
var url = nodeUrl || msg.url;
|
2015-12-10 13:58:50 +01:00
|
|
|
if (msg.url && nodeUrl && (nodeUrl !== msg.url)) { // revert change below when warning is finally removed
|
|
|
|
node.warn(RED._("common.errors.nooverride"));
|
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2015-12-10 13:58:50 +01:00
|
|
|
if (isTemplatedUrl) {
|
|
|
|
url = mustache.render(nodeUrl,msg);
|
|
|
|
}
|
|
|
|
if (!url) {
|
|
|
|
node.error(RED._("httpin.errors.no-url"),msg);
|
2019-08-14 16:54:06 +02:00
|
|
|
nodeDone();
|
2017-05-20 03:35:41 +02:00
|
|
|
return;
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
|
|
|
|
|
2015-12-10 13:58:50 +01:00
|
|
|
// url must start http:// or https:// so assume http:// if not set
|
2017-05-15 23:04:47 +02:00
|
|
|
if (url.indexOf("://") !== -1 && url.indexOf("http") !== 0) {
|
|
|
|
node.warn(RED._("httpin.errors.invalid-transport"));
|
|
|
|
node.status({fill:"red",shape:"ring",text:"httpin.errors.invalid-transport"});
|
2019-08-14 16:54:06 +02:00
|
|
|
nodeDone();
|
2017-05-15 23:04:47 +02:00
|
|
|
return;
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
if (!((url.indexOf("http://") === 0) || (url.indexOf("https://") === 0))) {
|
2016-04-27 13:31:54 +02:00
|
|
|
if (tlsNode) {
|
|
|
|
url = "https://"+url;
|
|
|
|
} else {
|
|
|
|
url = "http://"+url;
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
2021-07-26 15:21:52 +02:00
|
|
|
|
|
|
|
// The Request module used in Node-RED 1.x was tolerant of query strings that
|
|
|
|
// were partially encoded. For example - "?a=hello%20there&b=20%"
|
|
|
|
// The GOT module doesn't like that.
|
|
|
|
// The following is an attempt to normalise the url to ensure it is properly
|
|
|
|
// encoded. We cannot just encode it directly as we don't want any valid
|
|
|
|
// encoded entity to end up doubly encoded.
|
|
|
|
if (url.indexOf("?") > -1) {
|
|
|
|
// Only do this if there is a query string to deal with
|
|
|
|
const [hostPath, ...queryString] = url.split("?")
|
|
|
|
const query = queryString.join("?");
|
|
|
|
if (query) {
|
|
|
|
// Look for any instance of % not followed by two hex chars.
|
|
|
|
// Replace any we find with %25.
|
|
|
|
const escapedQueryString = query.replace(/(%.?.?)/g, function(v) {
|
|
|
|
if (/^%[a-f0-9]{2}/i.test(v)) {
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
return v.replace(/%/,"%25")
|
|
|
|
})
|
|
|
|
url = hostPath+"?"+escapedQueryString;
|
|
|
|
}
|
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2015-12-10 13:58:50 +01:00
|
|
|
var method = nodeMethod.toUpperCase() || "GET";
|
|
|
|
if (msg.method && n.method && (n.method !== "use")) { // warn if override option not set
|
|
|
|
node.warn(RED._("common.errors.nooverride"));
|
|
|
|
}
|
|
|
|
if (msg.method && n.method && (n.method === "use")) {
|
|
|
|
method = msg.method.toUpperCase(); // use the msg parameter
|
|
|
|
}
|
2019-11-03 12:08:24 +01:00
|
|
|
|
2021-05-11 10:56:22 +02:00
|
|
|
// var isHttps = (/^https/i.test(url));
|
2019-11-03 12:08:24 +01:00
|
|
|
|
2018-05-23 10:16:20 +02:00
|
|
|
var opts = {};
|
2019-11-03 12:08:24 +01:00
|
|
|
// set defaultport, else when using HttpsProxyAgent, it's defaultPort of 443 will be used :(.
|
2021-05-11 10:56:22 +02:00
|
|
|
// Had to remove this to get http->https redirect to work
|
|
|
|
// opts.defaultPort = isHttps?443:80;
|
2018-05-23 10:16:20 +02:00
|
|
|
opts.timeout = node.reqTimeout;
|
2021-07-23 00:48:30 +02:00
|
|
|
opts.throwHttpErrors = false;
|
2021-07-23 09:57:44 +02:00
|
|
|
// TODO: add UI option to auto decompress. Setting to false for 1.x compatibility
|
|
|
|
opts.decompress = false;
|
2015-12-10 13:58:50 +01:00
|
|
|
opts.method = method;
|
|
|
|
opts.headers = {};
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.retry = 0;
|
|
|
|
opts.responseType = 'buffer';
|
2018-05-23 10:16:20 +02:00
|
|
|
opts.maxRedirects = 21;
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.cookieJar = new CookieJar();
|
2021-07-21 15:09:15 +02:00
|
|
|
opts.ignoreInvalidCookies = true;
|
2019-08-09 20:23:28 +02:00
|
|
|
opts.forever = nodeHTTPPersistent;
|
2019-04-02 21:00:25 +02:00
|
|
|
if (msg.requestTimeout !== undefined) {
|
2018-11-01 22:27:04 +01:00
|
|
|
if (isNaN(msg.requestTimeout)) {
|
2018-11-01 22:32:25 +01:00
|
|
|
node.warn(RED._("httpin.errors.timeout-isnan"));
|
2019-04-02 21:00:25 +02:00
|
|
|
} else if (msg.requestTimeout < 1) {
|
2018-11-01 22:32:25 +01:00
|
|
|
node.warn(RED._("httpin.errors.timeout-isnegative"));
|
2018-11-01 22:27:04 +01:00
|
|
|
} else {
|
|
|
|
opts.timeout = msg.requestTimeout;
|
|
|
|
}
|
|
|
|
}
|
2021-07-23 10:55:32 +02:00
|
|
|
const originalHeaderMap = {};
|
2021-04-23 15:19:15 +02:00
|
|
|
|
|
|
|
opts.hooks = {
|
2021-07-23 10:55:32 +02:00
|
|
|
beforeRequest: [
|
|
|
|
options => {
|
|
|
|
// Whilst HTTP headers are meant to be case-insensitive,
|
|
|
|
// in the real world, there are servers that aren't so compliant.
|
|
|
|
// GOT will lower case all headers given a chance, so we need
|
|
|
|
// to restore the case of any headers the user has set.
|
|
|
|
Object.keys(options.headers).forEach(h => {
|
|
|
|
if (originalHeaderMap[h] && originalHeaderMap[h] !== h) {
|
|
|
|
options.headers[originalHeaderMap[h]] = options.headers[h];
|
|
|
|
delete options.headers[h];
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
],
|
2021-04-23 15:19:15 +02:00
|
|
|
beforeRedirect: [
|
|
|
|
(options, response) => {
|
|
|
|
let redirectInfo = {
|
|
|
|
location: response.headers.location
|
|
|
|
}
|
|
|
|
if (response.headers.hasOwnProperty('set-cookie')) {
|
|
|
|
redirectInfo.cookies = extractCookies(response.headers['set-cookie']);
|
|
|
|
}
|
|
|
|
redirectList.push(redirectInfo)
|
|
|
|
}
|
|
|
|
]
|
|
|
|
}
|
|
|
|
|
2016-09-30 23:12:33 +02:00
|
|
|
var ctSet = "Content-Type"; // set default camel case
|
|
|
|
var clSet = "Content-Length";
|
2015-12-10 13:58:50 +01:00
|
|
|
if (msg.headers) {
|
2017-06-27 12:23:13 +02:00
|
|
|
if (msg.headers.hasOwnProperty('x-node-red-request-node')) {
|
|
|
|
var headerHash = msg.headers['x-node-red-request-node'];
|
|
|
|
delete msg.headers['x-node-red-request-node'];
|
|
|
|
var hash = hashSum(msg.headers);
|
|
|
|
if (hash === headerHash) {
|
|
|
|
delete msg.headers;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (msg.headers) {
|
|
|
|
for (var v in msg.headers) {
|
|
|
|
if (msg.headers.hasOwnProperty(v)) {
|
|
|
|
var name = v.toLowerCase();
|
|
|
|
if (name !== "content-type" && name !== "content-length") {
|
|
|
|
// only normalise the known headers used later in this
|
|
|
|
// function. Otherwise leave them alone.
|
|
|
|
name = v;
|
|
|
|
}
|
|
|
|
else if (name === 'content-type') { ctSet = v; }
|
|
|
|
else { clSet = v; }
|
|
|
|
opts.headers[name] = msg.headers[v];
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2018-03-29 09:28:44 +02:00
|
|
|
if (msg.hasOwnProperty('followRedirects')) {
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.followRedirect = !!msg.followRedirects;
|
2018-09-10 03:47:05 +02:00
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2018-09-10 03:47:05 +02:00
|
|
|
if (opts.headers.hasOwnProperty('cookie')) {
|
2019-01-30 11:24:19 +01:00
|
|
|
var cookies = cookie.parse(opts.headers.cookie, {decode:String});
|
2018-09-10 03:47:05 +02:00
|
|
|
for (var name in cookies) {
|
2021-07-21 15:09:15 +02:00
|
|
|
opts.cookieJar.setCookie(cookie.serialize(name, cookies[name], {encode:String}), url, {ignoreError: true});
|
2018-03-29 09:28:44 +02:00
|
|
|
}
|
2018-09-10 03:47:05 +02:00
|
|
|
delete opts.headers.cookie;
|
|
|
|
}
|
2017-06-05 12:33:24 +02:00
|
|
|
if (msg.cookies) {
|
|
|
|
for (var name in msg.cookies) {
|
|
|
|
if (msg.cookies.hasOwnProperty(name)) {
|
|
|
|
if (msg.cookies[name] === null || msg.cookies[name].value === null) {
|
|
|
|
// This case clears a cookie for HTTP In/Response nodes.
|
|
|
|
// Ignore for this node.
|
|
|
|
} else if (typeof msg.cookies[name] === 'object') {
|
2019-02-01 09:15:07 +01:00
|
|
|
if(msg.cookies[name].encode === false){
|
|
|
|
// If the encode option is false, the value is not encoded.
|
2021-07-21 15:09:15 +02:00
|
|
|
opts.cookieJar.setCookie(cookie.serialize(name, msg.cookies[name].value, {encode: String}), url, {ignoreError: true});
|
2019-02-01 09:15:07 +01:00
|
|
|
} else {
|
|
|
|
// The value is encoded by encodeURIComponent().
|
2021-07-21 15:09:15 +02:00
|
|
|
opts.cookieJar.setCookie(cookie.serialize(name, msg.cookies[name].value), url, {ignoreError: true});
|
2019-02-01 09:15:07 +01:00
|
|
|
}
|
2017-06-05 12:33:24 +02:00
|
|
|
} else {
|
2021-07-21 15:09:15 +02:00
|
|
|
opts.cookieJar.setCookie(cookie.serialize(name, msg.cookies[name]), url, {ignoreError: true});
|
2017-06-05 12:33:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-07-15 19:32:51 +02:00
|
|
|
var parsedURL = new URL(url)
|
2021-07-16 09:47:30 +02:00
|
|
|
this.credentials = this.credentials || {}
|
|
|
|
if (parsedURL.username && !this.credentials.user) {
|
2021-07-15 19:32:51 +02:00
|
|
|
this.credentials.user = parsedURL.username
|
|
|
|
}
|
2021-07-16 09:47:30 +02:00
|
|
|
if (parsedURL.password && !this.credentials.password) {
|
2021-07-15 19:32:51 +02:00
|
|
|
this.credentials.password = parsedURL.password
|
|
|
|
}
|
2021-07-15 18:35:03 +02:00
|
|
|
if (Object.keys(this.credentials).length != 0) {
|
2019-02-27 23:15:31 +01:00
|
|
|
if (this.authType === "basic") {
|
2021-06-11 15:48:41 +02:00
|
|
|
// Workaround for https://github.com/sindresorhus/got/issues/1169
|
2021-06-11 15:25:18 +02:00
|
|
|
var cred = ""
|
2019-02-27 23:15:31 +01:00
|
|
|
if (this.credentials.user) {
|
2021-06-11 15:25:18 +02:00
|
|
|
// opts.username = this.credentials.user;
|
|
|
|
cred = this.credentials.user
|
2021-07-21 15:09:15 +02:00
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
if (this.credentials.password) {
|
2021-06-11 15:25:18 +02:00
|
|
|
// opts.password = this.credentials.password;
|
|
|
|
cred += ":" + this.credentials.password
|
2021-07-21 15:09:15 +02:00
|
|
|
}
|
2021-06-11 15:25:18 +02:00
|
|
|
// build own basic auth header
|
|
|
|
opts.headers.Authorization = "Basic " + Buffer.from(cred).toString("base64");
|
2021-04-23 15:19:15 +02:00
|
|
|
} else if (this.authType === "digest") {
|
|
|
|
let digestCreds = this.credentials;
|
|
|
|
let sentCreds = false;
|
|
|
|
opts.hooks.afterResponse = [(response, retry) => {
|
|
|
|
if (response.statusCode === 401) {
|
|
|
|
if (sentCreds) {
|
|
|
|
return response
|
|
|
|
}
|
|
|
|
const requestUrl = new URL(response.request.requestUrl);
|
|
|
|
const options = response.request.options;
|
|
|
|
const normalisedHeaders = {};
|
|
|
|
Object.keys(response.headers).forEach(k => {
|
|
|
|
normalisedHeaders[k.toLowerCase()] = response.headers[k]
|
|
|
|
})
|
|
|
|
if (normalisedHeaders['www-authenticate']) {
|
|
|
|
let authHeader = buildDigestHeader(digestCreds.user,digestCreds.password, options.method, requestUrl.pathname, normalisedHeaders['www-authenticate'])
|
2021-07-23 10:55:32 +02:00
|
|
|
options.headers.Authorization = authHeader;
|
2021-04-23 15:19:15 +02:00
|
|
|
}
|
|
|
|
sentCreds = true;
|
|
|
|
return retry(options);
|
|
|
|
}
|
|
|
|
return response
|
|
|
|
}];
|
2019-02-27 23:15:31 +01:00
|
|
|
} else if (this.authType === "bearer") {
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.headers.Authorization = `Bearer ${this.credentials.password||""}`
|
2019-02-27 23:15:31 +01:00
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
|
|
|
var payload = null;
|
|
|
|
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2018-02-01 00:54:06 +01:00
|
|
|
if (method !== 'GET' && method !== 'HEAD' && typeof msg.payload !== "undefined") {
|
2019-06-08 21:42:14 +02:00
|
|
|
if (opts.headers['content-type'] == 'multipart/form-data' && typeof msg.payload === "object") {
|
2021-04-23 15:19:15 +02:00
|
|
|
let formData = new FormData();
|
2019-06-08 21:42:14 +02:00
|
|
|
for (var opt in msg.payload) {
|
|
|
|
if (msg.payload.hasOwnProperty(opt)) {
|
|
|
|
var val = msg.payload[opt];
|
|
|
|
if (val !== undefined && val !== null) {
|
|
|
|
if (typeof val === 'string' || Buffer.isBuffer(val)) {
|
2021-04-23 15:19:15 +02:00
|
|
|
formData.append(opt, val);
|
2019-06-08 21:42:14 +02:00
|
|
|
} else if (typeof val === 'object' && val.hasOwnProperty('value')) {
|
2021-04-23 15:19:15 +02:00
|
|
|
formData.append(opt,val.value,val.options || {});
|
2019-06-08 21:42:14 +02:00
|
|
|
} else {
|
2021-04-23 15:19:15 +02:00
|
|
|
formData.append(opt,JSON.stringify(val));
|
2019-06-08 21:42:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
// GOT will only set the content-type header with the correct boundary
|
|
|
|
// if the header isn't set. So we delete it here, for GOT to reset it.
|
|
|
|
delete opts.headers['content-type'];
|
|
|
|
opts.body = formData;
|
2015-12-10 13:58:50 +01:00
|
|
|
} else {
|
2019-03-05 16:55:21 +01:00
|
|
|
if (typeof msg.payload === "string" || Buffer.isBuffer(msg.payload)) {
|
|
|
|
payload = msg.payload;
|
|
|
|
} else if (typeof msg.payload == "number") {
|
|
|
|
payload = msg.payload+"";
|
2015-12-10 13:58:50 +01:00
|
|
|
} else {
|
2019-03-05 16:55:21 +01:00
|
|
|
if (opts.headers['content-type'] == 'application/x-www-form-urlencoded') {
|
|
|
|
payload = querystring.stringify(msg.payload);
|
|
|
|
} else {
|
|
|
|
payload = JSON.stringify(msg.payload);
|
|
|
|
if (opts.headers['content-type'] == null) {
|
|
|
|
opts.headers[ctSet] = "application/json";
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
|
|
|
}
|
2019-03-05 16:55:21 +01:00
|
|
|
if (opts.headers['content-length'] == null) {
|
|
|
|
if (Buffer.isBuffer(payload)) {
|
|
|
|
opts.headers[clSet] = payload.length;
|
|
|
|
} else {
|
|
|
|
opts.headers[clSet] = Buffer.byteLength(payload);
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
2019-03-05 16:55:21 +01:00
|
|
|
opts.body = payload;
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
|
|
|
}
|
2018-11-15 18:11:27 +01:00
|
|
|
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2019-02-04 22:30:11 +01:00
|
|
|
if (method == 'GET' && typeof msg.payload !== "undefined" && paytoqs) {
|
2018-11-15 18:11:27 +01:00
|
|
|
if (typeof msg.payload === "object") {
|
2019-02-04 22:30:11 +01:00
|
|
|
try {
|
2021-04-23 15:19:15 +02:00
|
|
|
if (url.indexOf("?") !== -1) {
|
|
|
|
url += (url.endsWith("?")?"":"&") + querystring.stringify(msg.payload);
|
2019-02-04 22:30:11 +01:00
|
|
|
} else {
|
2021-04-23 15:19:15 +02:00
|
|
|
url += "?" + querystring.stringify(msg.payload);
|
2019-02-04 22:30:11 +01:00
|
|
|
}
|
|
|
|
} catch(err) {
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2019-02-04 22:30:11 +01:00
|
|
|
node.error(RED._("httpin.errors.invalid-payload"),msg);
|
2019-08-14 16:54:06 +02:00
|
|
|
nodeDone();
|
2019-02-04 22:30:11 +01:00
|
|
|
return;
|
2018-11-15 18:11:27 +01:00
|
|
|
}
|
|
|
|
} else {
|
2021-04-23 15:19:15 +02:00
|
|
|
|
2018-11-15 18:11:27 +01:00
|
|
|
node.error(RED._("httpin.errors.invalid-payload"),msg);
|
2019-08-14 16:54:06 +02:00
|
|
|
nodeDone();
|
2018-11-15 18:11:27 +01:00
|
|
|
return;
|
2021-04-07 15:35:29 +02:00
|
|
|
}
|
2020-02-25 22:28:15 +01:00
|
|
|
} else if ( method == "GET" && typeof msg.payload !== "undefined" && paytobody) {
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.allowGetBody = true;
|
2020-02-25 22:28:15 +01:00
|
|
|
if (typeof msg.payload === "object") {
|
|
|
|
opts.body = JSON.stringify(msg.payload);
|
|
|
|
} else if (typeof msg.payload == "number") {
|
|
|
|
opts.body = msg.payload+"";
|
|
|
|
} else if (typeof msg.payload === "string" || Buffer.isBuffer(msg.payload)) {
|
|
|
|
opts.body = msg.payload;
|
2018-11-15 18:11:27 +01:00
|
|
|
}
|
|
|
|
}
|
2019-02-04 22:30:11 +01:00
|
|
|
|
2016-09-30 23:12:33 +02:00
|
|
|
// revert to user supplied Capitalisation if needed.
|
|
|
|
if (opts.headers.hasOwnProperty('content-type') && (ctSet !== 'content-type')) {
|
|
|
|
opts.headers[ctSet] = opts.headers['content-type'];
|
|
|
|
delete opts.headers['content-type'];
|
|
|
|
}
|
|
|
|
if (opts.headers.hasOwnProperty('content-length') && (clSet !== 'content-length')) {
|
|
|
|
opts.headers[clSet] = opts.headers['content-length'];
|
|
|
|
delete opts.headers['content-length'];
|
|
|
|
}
|
2021-04-07 15:35:29 +02:00
|
|
|
|
2015-12-10 13:58:50 +01:00
|
|
|
var noproxy;
|
|
|
|
if (noprox) {
|
2019-11-18 18:14:38 +01:00
|
|
|
for (var i = 0; i < noprox.length; i += 1) {
|
2015-12-10 13:58:50 +01:00
|
|
|
if (url.indexOf(noprox[i]) !== -1) { noproxy=true; }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (prox && !noproxy) {
|
2021-04-23 15:19:15 +02:00
|
|
|
var match = prox.match(/^(https?:\/\/)?(.+)?:([0-9]+)?/i);
|
2015-12-10 13:58:50 +01:00
|
|
|
if (match) {
|
2021-04-23 15:19:15 +02:00
|
|
|
let proxyAgent;
|
2021-05-11 00:01:29 +02:00
|
|
|
let proxyURL = new URL(prox);
|
2021-05-11 10:56:22 +02:00
|
|
|
//set username/password to null to stop empty creds header
|
2021-04-23 15:19:15 +02:00
|
|
|
let proxyOptions = {
|
2021-05-11 00:01:29 +02:00
|
|
|
proxy: {
|
|
|
|
protocol: proxyURL.protocol,
|
|
|
|
hostname: proxyURL.hostname,
|
|
|
|
port: proxyURL.port,
|
|
|
|
username: null,
|
|
|
|
password: null
|
|
|
|
},
|
2021-04-23 15:19:15 +02:00
|
|
|
maxFreeSockets: 256,
|
|
|
|
maxSockets: 256,
|
2021-05-11 10:56:22 +02:00
|
|
|
keepAlive: true
|
2021-04-23 15:19:15 +02:00
|
|
|
}
|
|
|
|
if (proxyConfig && proxyConfig.credentials) {
|
|
|
|
let proxyUsername = proxyConfig.credentials.username || '';
|
|
|
|
let proxyPassword = proxyConfig.credentials.password || '';
|
|
|
|
if (proxyUsername || proxyPassword) {
|
2021-05-11 00:01:29 +02:00
|
|
|
proxyOptions.proxy.username = proxyUsername;
|
2021-05-11 10:56:22 +02:00
|
|
|
proxyOptions.proxy.password = proxyPassword;
|
2021-04-23 15:19:15 +02:00
|
|
|
}
|
2021-06-08 15:22:20 +02:00
|
|
|
} else if (proxyURL.username || proxyURL.password){
|
|
|
|
proxyOptions.proxy.username = proxyURL.username;
|
|
|
|
proxyOptions.proxy.password = proxyURL.password;
|
2021-04-23 15:19:15 +02:00
|
|
|
}
|
2021-05-12 12:08:57 +02:00
|
|
|
//need both incase of http -> https redirect
|
2021-05-11 10:56:22 +02:00
|
|
|
opts.agent = {
|
|
|
|
http: new HttpProxyAgent(proxyOptions),
|
|
|
|
https: new HttpsProxyAgent(proxyOptions)
|
|
|
|
};
|
2021-07-21 15:09:15 +02:00
|
|
|
|
2018-05-23 10:16:20 +02:00
|
|
|
} else {
|
|
|
|
node.warn("Bad proxy url: "+ prox);
|
2018-10-03 02:58:25 +02:00
|
|
|
}
|
|
|
|
}
|
2016-04-27 13:31:54 +02:00
|
|
|
if (tlsNode) {
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.https = {};
|
|
|
|
tlsNode.addTLSOptions(opts.https);
|
2021-07-26 11:25:06 +02:00
|
|
|
if (opts.https.ca) {
|
|
|
|
opts.https.certificateAuthority = opts.https.ca;
|
|
|
|
delete opts.https.ca;
|
|
|
|
}
|
2021-07-27 23:19:35 +02:00
|
|
|
if (opts.https.cert) {
|
|
|
|
opts.https.certificate = opts.https.cert;
|
2021-07-28 09:52:35 +02:00
|
|
|
delete opts.https.cert;
|
2021-07-27 23:19:35 +02:00
|
|
|
}
|
2017-03-23 20:48:48 +01:00
|
|
|
} else {
|
|
|
|
if (msg.hasOwnProperty('rejectUnauthorized')) {
|
2021-04-23 15:19:15 +02:00
|
|
|
opts.https = { rejectUnauthorized: msg.rejectUnauthorized };
|
2017-03-23 20:48:48 +01:00
|
|
|
}
|
2016-04-27 13:31:54 +02:00
|
|
|
}
|
2021-07-23 10:55:32 +02:00
|
|
|
|
|
|
|
// Now we have established all of our own headers, take a snapshot
|
|
|
|
// of their case so we can restore it prior to the request being sent.
|
|
|
|
if (opts.headers) {
|
|
|
|
Object.keys(opts.headers).forEach(h => {
|
|
|
|
originalHeaderMap[h.toLowerCase()] = h
|
|
|
|
})
|
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
got(url,opts).then(res => {
|
|
|
|
msg.statusCode = res.statusCode;
|
|
|
|
msg.headers = res.headers;
|
2021-05-12 12:08:57 +02:00
|
|
|
msg.responseUrl = res.url;
|
2021-04-23 15:19:15 +02:00
|
|
|
msg.payload = res.body;
|
|
|
|
msg.redirectList = redirectList;
|
|
|
|
msg.retry = 0;
|
|
|
|
|
|
|
|
if (msg.headers.hasOwnProperty('set-cookie')) {
|
|
|
|
msg.responseCookies = extractCookies(msg.headers['set-cookie']);
|
|
|
|
}
|
|
|
|
msg.headers['x-node-red-request-node'] = hashSum(msg.headers);
|
|
|
|
// msg.url = url; // revert when warning above finally removed
|
|
|
|
if (node.metric()) {
|
|
|
|
// Calculate request time
|
|
|
|
var diff = process.hrtime(preRequestTimestamp);
|
|
|
|
var ms = diff[0] * 1e3 + diff[1] * 1e-6;
|
|
|
|
var metricRequestDurationMillis = ms.toFixed(3);
|
|
|
|
node.metric("duration.millis", msg, metricRequestDurationMillis);
|
|
|
|
if (res.client && res.client.bytesRead) {
|
|
|
|
node.metric("size.bytes", msg, res.client.bytesRead);
|
2017-03-04 10:29:38 +01:00
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
}
|
2017-05-24 12:18:52 +02:00
|
|
|
|
2021-04-23 15:19:15 +02:00
|
|
|
// Convert the payload to the required return type
|
|
|
|
if (node.ret !== "bin") {
|
|
|
|
msg.payload = msg.payload.toString('utf8'); // txt
|
2017-05-24 12:18:52 +02:00
|
|
|
|
2021-04-23 15:19:15 +02:00
|
|
|
if (node.ret === "obj") {
|
|
|
|
try { msg.payload = JSON.parse(msg.payload); } // obj
|
|
|
|
catch(e) { node.warn(RED._("httpin.errors.json-error")); }
|
2017-07-19 23:37:29 +02:00
|
|
|
}
|
2018-05-23 10:16:20 +02:00
|
|
|
}
|
2021-04-23 15:19:15 +02:00
|
|
|
node.status({});
|
|
|
|
nodeSend(msg);
|
|
|
|
nodeDone();
|
|
|
|
}).catch(err => {
|
|
|
|
if(err.code === 'ETIMEDOUT' || err.code === 'ESOCKETTIMEDOUT') {
|
|
|
|
node.error(RED._("common.notification.errors.no-response"), msg);
|
|
|
|
node.status({fill:"red", shape:"ring", text:"common.notification.errors.no-response"});
|
|
|
|
}else{
|
|
|
|
node.error(err,msg);
|
|
|
|
node.status({fill:"red", shape:"ring", text:err.code});
|
|
|
|
}
|
|
|
|
msg.payload = err.toString() + " : " + url;
|
|
|
|
msg.statusCode = err.code || (err.response?err.response.statusCode:undefined);
|
|
|
|
nodeSend(msg);
|
|
|
|
nodeDone();
|
2015-12-10 13:58:50 +01:00
|
|
|
});
|
|
|
|
});
|
2016-10-10 12:08:06 +02:00
|
|
|
|
|
|
|
this.on("close",function() {
|
|
|
|
node.status({});
|
|
|
|
});
|
2018-12-04 16:39:01 +01:00
|
|
|
|
|
|
|
function extractCookies(setCookie) {
|
|
|
|
var cookies = {};
|
|
|
|
setCookie.forEach(function(c) {
|
|
|
|
var parsedCookie = cookie.parse(c);
|
|
|
|
var eq_idx = c.indexOf('=');
|
|
|
|
var key = c.substr(0, eq_idx).trim()
|
|
|
|
parsedCookie.value = parsedCookie[key];
|
|
|
|
delete parsedCookie[key];
|
|
|
|
cookies[key] = parsedCookie;
|
|
|
|
});
|
|
|
|
return cookies;
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
RED.nodes.registerType("http request",HTTPRequest,{
|
|
|
|
credentials: {
|
|
|
|
user: {type:"text"},
|
|
|
|
password: {type: "password"}
|
|
|
|
}
|
|
|
|
});
|
2021-04-23 15:19:15 +02:00
|
|
|
|
|
|
|
const md5 = (value) => { return crypto.createHash('md5').update(value).digest('hex') }
|
|
|
|
|
|
|
|
function ha1Compute(algorithm, user, realm, pass, nonce, cnonce) {
|
|
|
|
/**
|
|
|
|
* RFC 2617: handle both MD5 and MD5-sess algorithms.
|
|
|
|
*
|
|
|
|
* If the algorithm directive's value is "MD5" or unspecified, then HA1 is
|
|
|
|
* HA1=MD5(username:realm:password)
|
|
|
|
* If the algorithm directive's value is "MD5-sess", then HA1 is
|
|
|
|
* HA1=MD5(MD5(username:realm:password):nonce:cnonce)
|
|
|
|
*/
|
|
|
|
var ha1 = md5(user + ':' + realm + ':' + pass)
|
|
|
|
if (algorithm && algorithm.toLowerCase() === 'md5-sess') {
|
|
|
|
return md5(ha1 + ':' + nonce + ':' + cnonce)
|
|
|
|
} else {
|
|
|
|
return ha1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function buildDigestHeader(user, pass, method, path, authHeader) {
|
|
|
|
var challenge = {}
|
|
|
|
var re = /([a-z0-9_-]+)=(?:"([^"]+)"|([a-z0-9_-]+))/gi
|
|
|
|
for (;;) {
|
|
|
|
var match = re.exec(authHeader)
|
|
|
|
if (!match) {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
challenge[match[1]] = match[2] || match[3]
|
|
|
|
}
|
|
|
|
var qop = /(^|,)\s*auth\s*($|,)/.test(challenge.qop) && 'auth'
|
|
|
|
var nc = qop && '00000001'
|
|
|
|
var cnonce = qop && uuid().replace(/-/g, '')
|
|
|
|
var ha1 = ha1Compute(challenge.algorithm, user, challenge.realm, pass, challenge.nonce, cnonce)
|
|
|
|
var ha2 = md5(method + ':' + path)
|
|
|
|
var digestResponse = qop
|
|
|
|
? md5(ha1 + ':' + challenge.nonce + ':' + nc + ':' + cnonce + ':' + qop + ':' + ha2)
|
|
|
|
: md5(ha1 + ':' + challenge.nonce + ':' + ha2)
|
|
|
|
var authValues = {
|
|
|
|
username: user,
|
|
|
|
realm: challenge.realm,
|
|
|
|
nonce: challenge.nonce,
|
|
|
|
uri: path,
|
|
|
|
qop: qop,
|
|
|
|
response: digestResponse,
|
|
|
|
nc: nc,
|
|
|
|
cnonce: cnonce,
|
|
|
|
algorithm: challenge.algorithm,
|
|
|
|
opaque: challenge.opaque
|
|
|
|
}
|
|
|
|
|
|
|
|
authHeader = []
|
|
|
|
for (var k in authValues) {
|
|
|
|
if (authValues[k]) {
|
|
|
|
if (k === 'qop' || k === 'nc' || k === 'algorithm') {
|
|
|
|
authHeader.push(k + '=' + authValues[k])
|
|
|
|
} else {
|
|
|
|
authHeader.push(k + '="' + authValues[k] + '"')
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
authHeader = 'Digest ' + authHeader.join(', ')
|
|
|
|
return authHeader
|
|
|
|
}
|
2015-12-10 13:58:50 +01:00
|
|
|
}
|