IPPressure

Source/Client.js

@@ -17,6 +17,10 @@ function Client()
     this.rooms = new Set();
     this.pairs = new Set();
     this.requiredPair = false;
+
+    this.APNumber = 0;
+    this.APShortCode = 0;
+    this.APIPAddress = 0;
 };
 /**
  * @type {Map<string, Client>}

Source/Services/IPPressure.js

@@ -0,0 +1,301 @@
+const { Client } = require("../Client");
+let {addService, addListener} = require("../WebSocket.js");
+let {
+    randomBytes
+} = require("node:crypto");
+
+class APNumber{
+    /**
+     * @type {Map<Number, Client>}
+     */
+    static busyNumbers = new Map();
+    /**
+     * @type {number}
+     */
+    static lock()
+    {
+        let c = 24;
+        while(true){
+            if(!APNumber.busyNumbers.has(c))
+            {
+                APNumber.busyNumbers.set(c,true);
+                return c;
+            }
+            c++;
+        }
+    }
+    /**
+     * @param {number} num 
+     */
+    static release(num)
+    {
+        APNumber.busyNumbers.delete(num);
+    }
+    static whois(num){
+        return APNumber.busyNumbers.get(num)?.id;
+    }
+}
+
+class APShortCode{
+    /**
+     * @type {Map<string, Client>}
+     */
+    static busyCodes = new Map();
+    /**
+     * 
+     * @param {Client} client 
+     * @returns 
+     */
+    static lock(client){
+        let firstLetter = new ShortCodeLetter();
+        let secondLetter = new ShortCodeLetter();
+        let thirdLetter = new ShortCodeLetter();
+        while(1)
+        {
+            let code = [firstLetter.code,secondLetter.code,thirdLetter.code].join('');
+            if(APShortCode.busyCodes.has(code) == false)
+            {
+                APShortCode.busyCodes.set(code, client);
+                return code.join('');
+            }
+            if(!thirdLetter.end())
+            {
+                thirdLetter.next()
+            }else{
+                thirdLetter.reset()
+                if(!secondLetter.end())
+                {
+                    secondLetter.next();
+                }else{
+                    secondLetter.reset();
+                    if(!firstLetter.end())
+                    {
+                        firstLetter.next();
+                    }else{
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    static release(code){
+        APShortCode.busyCodes.delete(code);
+    }
+    static whois(num){
+        return APShortCode.busyCodes.get(num)?.id;
+    }
+};
+class ShortCodeLetter{
+    chars = 'ABCDEFGHIKLMNOPRSTVXYZ'.split('');
+    now = 0;
+    code = 'A';
+    next(){
+        this.now++
+        this.code = this.chars.at(this.now);
+        return this.code;
+    }
+    reset(){
+        this.now = 0;
+        this.code = 'A';
+    }
+    end(){
+        return !this.chars.at(this.now + 1)
+    }
+}
+
+class APIPAddress{
+    /**
+     * @type {Map<[number,number,number,number], Client>}
+     */
+    static busyIP = new Map();
+    /**
+     * @param {Client} client
+     */
+    static lock(client){
+        let A = 10;
+        let B = 0;
+        let C = 0;
+        let D = 1;
+        while(1)
+        {
+            let code = [A,B,C,D].join('.');
+            if(APIPAddress.busyIP.has(code) == false)
+            {
+                APIPAddress.busyIP.set(code, client);
+                return code;
+            }
+            if(D != 255)
+            {
+                D++;
+                continue;
+            }else{
+                D = 0;
+            }
+            if(C != 255)
+            {
+                C++;
+                continue;
+            }else{
+                C = 0;
+            }
+            if(B != 255)
+            {
+                B++;
+                continue;
+            }else{
+                B = 0;
+            }
+            if(A != 255)
+            {
+                A++;
+                continue;
+            }else{
+                A = 0;
+            }
+            return;
+        }
+    }
+    static release(code){
+        APIPAddress.busyCodes.delete(code);
+    }
+    static whois(num){
+        return APIPAddress.busyIP.get(num)?.id;
+    }
+};
+
+exports.APNumber = APNumber;
+exports.APShortCode = APShortCode;
+exports.APIPAddress = APIPAddress;
+
+
+addService(({
+    client,
+    message,
+    end,
+    next
+})=>{
+    let {type,whois} = message;
+    switch(type)
+    {
+        case "alloc/APIPAddress":{
+            let value = APIPAddress.lock(client);
+            end({
+                status : "sucess",
+                ip : value
+            })
+            break;
+        }
+        case "alloc/APNumber":{
+            let value = APNumber.lock(client);
+            end({
+                status : "sucess",
+                number : value
+            })
+            break;
+        }
+        case "alloc/APShortCode":{
+            let value = APShortCode.lock(client);
+            end({
+                status : "sucess",
+                code : value
+            })
+            break;
+        }
+        case "realloc/APIPAddress":{
+            APIPAddress.release(client.APIPAddress);
+            let value = APIPAddress.lock(client);
+            end({
+                status : "sucess",
+                ip : value
+            })
+            break;
+        }
+        case "realloc/APNumber":{
+            APNumber.release(client.APNumber);
+            let value = APNumber.lock(client);
+            end({
+                status : "sucess",
+                number : value
+            })
+            break;
+        }
+        case "realloc/APShortCode":{
+            APShortCode.release(client.APShortCode);
+            let value = APShortCode.lock(client);
+            end({
+                status : "sucess",
+                code : value
+            })
+            break;
+        }
+        case "release/APIPAddress":{
+            APIPAddress.release(client.APIPAddress);
+            end({
+                status : "sucess"
+            })
+            break;
+        }
+        case "release/APNumber":{
+            APNumber.release(client.APNumber);
+            end({
+                status : "sucess"
+            })
+            break;
+        }
+        case "release/APShortCode":{
+            APShortCode.release(client.APShortCode);
+            end({
+                status : "sucess"
+            })
+            break;
+        }
+        case "whois/APIPAddress":{
+            let socketId = APIPAddress.whois(whois);
+            if(socketId)
+            {
+                end({
+                    status : "sucess",
+                    socket : socketId
+                })
+            }
+            break;
+        }
+        case "whois/APNumber":{
+            let socketId = APNumber.whois(whois);
+            if(socketId)
+            {
+                end({
+                    status : "sucess",
+                    socket : socketId
+                })
+            }
+            break;
+        }
+        case "whois/APShortCode":{
+            let socketId = APShortCode.whois(whois);
+            if(socketId)
+            {
+                end({
+                    status : "sucess",
+                    socket : socketId
+                })
+            }
+            break;
+        }
+    }
+})
+
+addListener('disconnect',(global, client)=>{
+    if(client.APIPAddress != 0)
+    {
+        APIPAddress.release(client.APIPAddress);
+    }
+    if(client.APNumber != 0)
+    {
+        APNumber.release(client.APNumber);
+    }
+    if(client.APShortCode != 0)
+    {
+        APShortCode.release(client.APShortCode);
+    }
+});

frontend/Peer.ts

@@ -84,4 +84,4 @@ export default class Peer extends EventTarget
         this.mwse.peers.delete(this.socketId as string);
         this.mwse.pairs.delete(this.socketId as string);
     }
-}
+}