237 lines
8.4 KiB
TypeScript
237 lines
8.4 KiB
TypeScript
import https, { RequestOptions } from 'https';
|
|
import tls from 'tls';
|
|
import http, { ClientRequest, IncomingMessage } from 'http';
|
|
import { URL } from 'url';
|
|
import { getCookies, setCookie, uploadCookie } from './cookie';
|
|
/**
|
|
* Types for Proxy
|
|
*/
|
|
export type Proxy = ProxyOpts | string;
|
|
|
|
interface ProxyOpts {
|
|
host: string;
|
|
port: number;
|
|
authentication?: {
|
|
username: string;
|
|
password: string;
|
|
};
|
|
}
|
|
|
|
interface ProxyOutput {
|
|
statusCode: number;
|
|
head: string[];
|
|
body: string;
|
|
}
|
|
|
|
interface RequestOpts extends RequestOptions {
|
|
body?: string;
|
|
method?: 'GET' | 'POST';
|
|
proxies?: Proxy[];
|
|
cookies? : boolean
|
|
}
|
|
/**
|
|
* Main module that play-dl uses for making a https request
|
|
* @param req_url URL to make https request to
|
|
* @param options Request options for https request
|
|
* @returns Incoming Message from the https request
|
|
*/
|
|
function https_getter(req_url: string, options: RequestOpts = {}): Promise<IncomingMessage> {
|
|
return new Promise((resolve, reject) => {
|
|
const s = new URL(req_url);
|
|
options.method ??= 'GET';
|
|
const req_options: RequestOptions = {
|
|
host: s.hostname,
|
|
path: s.pathname + s.search,
|
|
headers: options.headers ?? {},
|
|
method: options.method
|
|
};
|
|
|
|
const req = https.request(req_options, resolve);
|
|
req.on('error', (err) => {
|
|
reject(err);
|
|
});
|
|
if (options.method === 'POST') req.write(options.body);
|
|
req.end();
|
|
});
|
|
}
|
|
/**
|
|
* Chooses one random number between max and min number.
|
|
* @param min Minimum number
|
|
* @param max Maximum number
|
|
* @returns Random Number
|
|
*/
|
|
function randomIntFromInterval(min: number, max: number): number {
|
|
let x = Math.floor(Math.random() * (max - min + 1) + min);
|
|
if (x === 0) return 0;
|
|
else return x - 1;
|
|
}
|
|
/**
|
|
* Main module that play-dl uses for proxy.
|
|
* @param req_url URL to make https request to
|
|
* @param req_proxy Proxies array
|
|
* @returns Object with statusCode, head and body
|
|
*/
|
|
async function proxy_getter(req_url: string, req_proxy: Proxy[]): Promise<ProxyOutput> {
|
|
return new Promise((resolve, reject) => {
|
|
const proxy: string | ProxyOpts = req_proxy[randomIntFromInterval(0, req_proxy.length)];
|
|
const parsed_url = new URL(req_url);
|
|
let opts: ProxyOpts;
|
|
if (typeof proxy === 'string') {
|
|
const parsed = new URL(proxy);
|
|
opts = {
|
|
host: parsed.hostname,
|
|
port: Number(parsed.port),
|
|
authentication: {
|
|
username: parsed.username,
|
|
password: parsed.password
|
|
}
|
|
};
|
|
} else opts = proxy;
|
|
let req: ClientRequest;
|
|
if (opts.authentication?.username.length === 0) {
|
|
req = http.request({
|
|
host: opts.host,
|
|
port: opts.port,
|
|
method: 'CONNECT',
|
|
path: `${parsed_url.host}:443`
|
|
});
|
|
} else {
|
|
req = http.request({
|
|
host: opts.host,
|
|
port: opts.port,
|
|
method: 'CONNECT',
|
|
path: `${parsed_url.host}:443`,
|
|
headers: {
|
|
'Proxy-Authorization': `Basic ${Buffer.from(
|
|
`${opts.authentication?.username}:${opts.authentication?.password}`
|
|
).toString('base64')}`
|
|
}
|
|
});
|
|
}
|
|
|
|
req.on('connect', function (res, socket, head) {
|
|
console.log('Connected');
|
|
const tlsConnection = tls.connect(
|
|
{
|
|
host: parsed_url.hostname,
|
|
port: 443,
|
|
socket: socket,
|
|
rejectUnauthorized: false
|
|
},
|
|
function () {
|
|
tlsConnection.write(
|
|
`GET ${parsed_url.pathname}${parsed_url.search} HTTP/1.1\r\n` +
|
|
`Host : ${parsed_url.hostname}\r\n` +
|
|
'Connection: close\r\n' +
|
|
'\r\n'
|
|
);
|
|
}
|
|
);
|
|
|
|
tlsConnection.setEncoding('utf-8');
|
|
let data = '';
|
|
tlsConnection.once('error', (e) => reject(e));
|
|
tlsConnection.on('data', (c) => (data += c));
|
|
tlsConnection.on('end', () => {
|
|
const y = data.split('\r\n\r\n');
|
|
const head = y.shift() as string;
|
|
resolve({
|
|
statusCode: Number(head.split('\n')[0].split(' ')[1]),
|
|
head: head.split('\r\n'),
|
|
body: y.join('\n')
|
|
});
|
|
});
|
|
});
|
|
req.on('error', (e: Error) => reject(e));
|
|
req.end();
|
|
});
|
|
}
|
|
/**
|
|
* Main module which play-dl uses to make a proxy or normal request
|
|
* @param url URL to make https request to
|
|
* @param options Request options for https request
|
|
* @returns body of that request
|
|
*/
|
|
export async function request(url: string, options: RequestOpts = {}): Promise<string> {
|
|
return new Promise(async (resolve, reject) => {
|
|
if (!options?.proxies || options.proxies.length === 0) {
|
|
let data = '';
|
|
let cook = getCookies()
|
|
if (typeof cook === 'string' && options.headers) {
|
|
Object.assign(options.headers, { cookie : cook });
|
|
}
|
|
let res = await https_getter(url, options).catch((err: Error) => err);
|
|
if (res instanceof Error) {
|
|
reject(res);
|
|
return;
|
|
}
|
|
if(res.headers && res.headers['set-cookie'] && cook){
|
|
res.headers['set-cookie'].forEach((x) => {
|
|
x.split(';').forEach((x) => {
|
|
const [key, value] = x.split('=');
|
|
if (!value) return;
|
|
setCookie(key, value);
|
|
});
|
|
})
|
|
uploadCookie()
|
|
}
|
|
if (Number(res.statusCode) >= 300 && Number(res.statusCode) < 400) {
|
|
res = await https_getter(res.headers.location as string, options);
|
|
} else if (Number(res.statusCode) > 400) {
|
|
reject(new Error(`Got ${res.statusCode} from the request`));
|
|
}
|
|
res.setEncoding('utf-8');
|
|
res.on('data', (c) => (data += c));
|
|
res.on('end', () => resolve(data));
|
|
} else {
|
|
let cook = getCookies()
|
|
if (typeof cook === 'string' && options.headers) {
|
|
Object.assign(options.headers, { cookie : cook });
|
|
}
|
|
let res = await proxy_getter(url, options.proxies).catch((e: Error) => e);
|
|
if (res instanceof Error) {
|
|
reject(res);
|
|
return;
|
|
}
|
|
if(res.head && cook){
|
|
let cookies = res.head.filter((x) => x.toLocaleLowerCase().startsWith('set-cookie: '));
|
|
cookies.forEach((x) => {
|
|
x.toLocaleLowerCase().split('set-cookie: ')[1].split(';').forEach((y) => {
|
|
let [key, value] = y.split('=');
|
|
if (!value)
|
|
return;
|
|
setCookie(key, value);
|
|
});
|
|
});
|
|
uploadCookie()
|
|
}
|
|
if (res.statusCode >= 300 && res.statusCode < 400) {
|
|
let url = res.head.filter((x) => x.startsWith('Location: '));
|
|
res = await proxy_getter(url[0].split('\n')[0], options.proxies);
|
|
} else if (res.statusCode > 400) {
|
|
reject(new Error(`GOT ${res.statusCode} from proxy request`));
|
|
}
|
|
resolve(res.body);
|
|
}
|
|
});
|
|
}
|
|
/**
|
|
* Main module which play-dl uses to make a request to stream url.
|
|
* @param url URL to make https request to
|
|
* @param options Request options for https request
|
|
* @returns IncomingMessage from the request
|
|
*/
|
|
export async function request_stream(url: string, options?: RequestOpts): Promise<IncomingMessage> {
|
|
return new Promise(async (resolve, reject) => {
|
|
let res = await https_getter(url, options).catch((err: Error) => err);
|
|
if (res instanceof Error) {
|
|
reject(res);
|
|
return;
|
|
}
|
|
if (Number(res.statusCode) >= 300 && Number(res.statusCode) < 400) {
|
|
res = await https_getter(res.headers.location as string, options);
|
|
}
|
|
resolve(res);
|
|
});
|
|
}
|