external-ips 0.0.1

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Hkey1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,69 @@
+# External IPs
+This is Node.js module to use many IPs in HTTP(s) requests or WS.
+It may be useful to avoid rate limits in some external IPs or when you parsed some site.
+
+## Usage
+You need buy additionals IPs in hosting
+Then add it in Linux: https://askubuntu.com/questions/585468/how-do-i-add-an-additional-ip-address-to-an-interface-in-ubuntu-14
+
+
+### Base
+```js
+  const IPs  = require('external-ips');
+  
+  console.log('all',  IPs.length);
+  console.log('IPv4', IPs.v4.length);
+  console.log('IPv6', IPs.v6.length);
+  
+  console.log(IPs.v4.next());
+  console.log(IPs.v4.next());
+  
+  console.log(IPs.v4.random());  
+```
+
+### HTTP/HTTPs
+```js
+  const http = require('node:http');
+  ...
+  http.request(url, {
+    localAddress: IPs.v4.next(),
+             //or IPs.v4.random(),
+    })
+  });
+```
+
+### WS
+```js
+  ...	
+  const WS = require('ws');
+  ...  
+  new WS(address, protocols, {
+	localAddress: IPs.v4.next()
+  })
+```
+
+### Agent
+```js
+  ...  
+  const agent = new https.Agent();
+  ...
+  IPs.v4.patchAgent(agent);
+```
+
+#### multi family
+```js
+  ...
+  IPs.patchAgent(agent, 4); 
+```
+
+
+#### Fixed IPs
+
+```js
+  ...  
+  const agent1 = new http.Agent();
+  const agent2 = new http.Agent();
+  ...
+  IPs.v4._next().patchAgent(agent1); //or _random()
+  IPs.v4._next().patchAgent(agent2); //or _random()  
+```

package/index.js

@@ -0,0 +1,160 @@
+const os     = require('node:os');
+const assert = require('node:assert');
+
+function normalizeFamily(family){
+	if(family==='IPv6' || family==='v6' || family==='6' || family===6){
+		return 6;
+	} else if(family==='IPv4' || family==='v4' || family==='4' || family===4){
+		return 4;
+	} else if(family===false || family===null || family===undefined){
+		return false;
+	} else throw new Error('bad family='+family);
+}
+
+class AbstractObject {
+	constructor(family){
+		assert(this.constructor!==AbstractObject); //Abstract
+		assert.equal(typeof this.__next,   'function');
+		assert.equal(typeof this.__random, 'function');
+		this.family = normalizeFamily(family);
+	}
+	patchAgent(agent, defaultFamily=false){
+		defaultFamily = normalizeFamily(defaultFamily);
+		assert.equal(typeof agent,                  'object');
+		assert.equal(typeof agent.createConnection, 'function');
+		const old = agent.createConnection;
+		agent.createConnection = (options, callback)=>{
+			const family = normalizeFamily(options.family) || defaultFamily;
+			if(!family || !this.family || this.family===family){
+				options.localAddress ||= this.next().address;
+			}
+			return old.call(this.agent, options, callback);
+		}
+	}
+	checkFamily(family){
+		family = normalizeFamily(family);
+		family===false || this.family===false || assert.equal(family, this.family);
+		return family;
+	}
+	random(family){
+		return this._random(family).address; 
+	}
+	next(family){
+		return this._next(family).address; 
+	}
+	_random(family){
+		return this.__random(this.checkFamily(family)) 
+	}
+	_next(family){
+		return this.__next(this.checkFamily(family))
+	}
+};
+
+class IP extends AbstractObject{
+	constructor(info){
+		assert(info.address); assert(info.family);
+		super(info.family);
+		assert(this.family)
+		this.info    = info;
+		this.address = info.address;
+	}
+	toString(){
+		return this.address;
+	}
+	__random(){return this}
+	__next(){return this}	
+};
+
+class FamilyList extends AbstractObject{
+	ips = [];
+	constructor(family){
+		super(family);
+		Object.defineProperty(this, 'lastIndex', {
+			value: 0,
+			enumerable: false,
+			writable  : true,
+		})
+	}
+	push(...ips){
+		ips.forEach(ip=>{
+			assert(ip instanceof IP);
+			assert(ip.family)
+			this.checkFamily(ip.family)
+		});
+		return this.ips.push(...ips);
+	}
+	get length(){
+		return this.ips.length;
+	}
+	__random(){
+		return this[Math.floor(this.length*Math.random())]
+	}
+	__next(){
+		const res      = this[this.lastIndex];
+		this.lastIndex = (this.lastIndex+1)%this.length;
+		return res;
+	}
+	print(){
+		console.log('v'+(this.family || '*'), this.length, this.ips.map(ip=>ip+''))
+	}
+};
+
+
+class MainList extends AbstractObject{
+	constructor(){
+		super(false);
+		this.all = new FamilyList(false);
+		this.v4  = new FamilyList(4);
+		this.v6  = new FamilyList(6);
+		Object.defineProperty(this, 'byFamily', {
+			value     : {
+				false : this.all,
+				4     : this.v4,
+				6     : this.v6,
+			},
+			enumerable: false,
+			writable  : false,
+		});		
+	}
+	get length(){
+		return this.all.length;
+	}
+	get ips(){
+		return this.all.ips;
+	}
+	__random(family){
+		return this.byFamily[family].random(family);
+	}
+	__next(){
+		return this.byFamily[family].random(family);
+	}
+	push(...ips){
+		ips.forEach(ip=>assert(ip instanceof IP));
+		if(ips.length===1){
+			const ip = ips[0];
+			this.all.push(ip);
+			this.byFamily[ip.family].push(ip);
+		} else {
+			ips.forEach(ip=>this.push(ip))
+		}
+	}
+	print(){
+		this.v4.print();
+		this.v6.print();
+	}
+};
+
+const mainList = new MainList();
+Object.values(os.networkInterfaces()).forEach(arr=>{
+	mainList.push(...arr.filter(ip=>!ip.internal).map(ip=>new IP(ip)))
+});
+
+//mainList.print();
+
+mainList.MainList       = MainList;
+mainList.IP             = IP;
+mainList.AbstractObject = AbstractObject;
+mainList.FamilyList     = FamilyList;
+
+
+module.exports = mainList;

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "external-ips",
+    "version": "0.0.1",
+    "main": "./index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "Andrey Belousoff <a.v.belousoff@gmail.com>",
+    "license": "MIT",
+    "description": "any IPs in HTTP(s) requests or WS",
+    "keywords": ["ips", "ip"],
+    "dependencies": {
+    },
+    "engines": {
+        "node": ">=0.1.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Hkey1/external-ips"
+    },
+    "readme":"External IPs",
+    "readmeFilename": "README.md",
+    "bugs": {
+        "url": "https://github.com/Hkey1/external-ips/issues"
+    },
+    "homepage": "https://github.com/Hkey1/external-ips"
+}