birdpack 1.0.0

package/lib/tools.js

@@ -0,0 +1,330 @@
+const crypto = require('crypto');
+
+const tools = {
+    wwwform:(byteData)=>{
+        if(typeof byteData == 'object'){
+            byteData = new TextDecoder('utf8').decode(byteData);
+        }
+
+        let output = {};
+        if(typeof byteData == 'string'){
+            for(let x of byteData.split('&')){
+                var data = x.search('=');
+                let name = '';
+                let value = '';
+                if(data == -1){
+                    name = decodeURIComponent(x.trim());
+                    value = '';
+                }else{
+                    try{
+                        name = decodeURIComponent(x.substring(0, data).trim());
+                        value = decodeURIComponent(x.substr(data + 1));
+                    }catch(e){
+                        this.server.log('error',`${util.format(e)}`);
+                    }
+                }
+                if(typeof output[name] == 'undefined'){
+                    output[name] = [value];
+                }else{
+                    output[name].push(value);
+                }
+            }
+        }
+        return output;
+    },
+    formdata:(byteData, key)=>{
+        byteData = Buffer.concat([Buffer.from('\r\n'),byteData]);
+        key = `\r\n--${key}`;
+
+        let endIndex = 0;
+        let startIndex = 0;
+        let check = true;
+        let output = {}
+        let keyLength = key.length + 2;
+        while(check){
+            startIndex = byteData.indexOf(key, endIndex) + keyLength;
+            endIndex = byteData.indexOf(key, startIndex);
+            if(endIndex > 0){
+                let data;
+                let content = byteData.slice(startIndex,endIndex);
+
+                let rawData = content.slice(content.indexOf('\r\n\r\n') + 4);
+                
+                let fileName = content.indexOf(' filename="');
+                if(fileName != -1){
+                    fileName += 11;
+                    fileName = content.slice(fileName,content.indexOf('"',fileName)).toString();
+                    
+                    let fileType = content.indexOf('Content-Type: ') + 14;
+                    fileType = content.slice(fileType,content.indexOf('\r\n',fileType)).toString();
+
+                    data = {
+                        name:fileName,
+                        type:fileType,
+                        data:rawData
+                    };
+                }else{
+                    data = new TextDecoder('utf8').decode(rawData);
+                }
+
+                let name=content.indexOf(' name="') + 7;
+                name = content.slice(name,content.indexOf('"',name)).toString();
+                
+                if(typeof output[name] == 'undefined'){
+                    output[name] = [data];
+                }else{
+                    output[name].push(data);
+                }
+            }else{
+                check = false;
+            }
+        }
+        return output;
+    },
+    generateKey:(key)=>{
+        return crypto.createHash('sha1')
+        .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+        .digest('base64');
+    },
+    encodeFrame:(payload, opcode = 1)=>{
+        let payloadBuffer;
+
+        if(Buffer.isBuffer(payload)){
+            payloadBuffer = payload;
+        }else if(typeof payload == 'string'){
+            payloadBuffer = Buffer.from(payload);
+        }else{
+            payloadBuffer = Buffer.alloc(0);
+        }
+
+        const payloadLength = payloadBuffer.length;
+        let frame;
+
+        if(payloadLength <= 125){
+            frame = Buffer.alloc(2 + payloadLength);
+            frame[1] = payloadLength;
+        }else if (payloadLength <= 65535){
+            frame = Buffer.alloc(4 + payloadLength);
+            frame[1] = 126;
+            frame.writeUInt16BE(payloadLength, 2);
+        }else{
+            frame = Buffer.alloc(10 + payloadLength);
+            frame[1] = 127;
+            frame.writeBigUInt64BE(BigInt(payloadLength), 2);
+        }
+
+        frame[0] = 0x80 | opcode;
+        payloadBuffer.copy(frame, frame.length - payloadLength);
+        return frame;
+    },
+    decodeFrame: class{
+        constructor(callback){
+            this.status = 0;
+            this.section = [];
+            this.callback = callback;
+        }
+        decode(buffer){
+            let raw;
+            while(true){
+                if(this.status === 0){
+                    let head = this.header(buffer);
+                    if (typeof head.type !== 'string' || head.type === false){
+                        delete this.section;
+                        this.section = [];
+                        
+                        break;
+                    }
+
+                    this.status = 1;
+
+                    this.fin = head.fin;
+                    this.opcode = head.opcode;
+                    this.isMasked = head.isMasked;
+                    this.length = head.length;
+                    this.key = head.key;
+                    if(head.type !== true){
+                        this.type = head.type;
+                    }
+
+                    raw = head.raw;
+                    this.payloadReset();
+                    if(raw.length == 0){
+                        if(this.fin === 1){
+                            this.status = 0;
+                            delete this.section;
+                            this.section = [];
+                            this.callback({
+                                type: this.type,
+                                payload: this.type === 'utf8' ? raw.toString('utf8') : raw
+                            });
+                        }
+                        break;
+                    }
+                }else{
+                    raw = buffer;
+                }
+
+                let size = this.payloadLength + raw.length;
+                if(this.length === size){
+                    if(this.isMasked){
+                        let data = this.mask(this.key, raw, this.payloadLength);
+                        this.payloadAdd(data);
+                    }else{
+                        this.payloadAdd(raw);
+                    }
+
+                    this.section.push(this.payloadGet());
+                    this.status = 0;
+                }else if(this.length < size){
+                    let count = this.length - this.payloadLength;
+                    let next = raw.slice(count);
+                    raw = raw.slice(0, count);
+                    
+                    if(this.isMasked){
+                        let data = this.mask(this.key, raw, this.payloadLength);
+                        this.payloadAdd(data);
+                    }else{
+                        this.payloadAdd(raw);
+                    }
+                    this.section.push(this.payloadGet());
+                    this.status = 0;
+                    if(this.fin === 1 && this.length === this.payloadLength){
+                        let data = Buffer.concat(this.section);
+                        delete this.section;
+                        this.section = [];
+                        this.callback({
+                            type: this.type,
+                            payload: this.type === 'utf8' ? data.toString('utf8') : data
+                        });
+                    }
+                    
+                    buffer = next;
+                    if(next.length > 0){
+                        continue;
+                    }
+                }else{
+                    if(this.isMasked){
+                        let data = this.mask(this.key, raw, this.payloadLength);
+                        this.payloadAdd(data);
+                    }else{
+                        this.payloadAdd(raw);
+                    }
+
+                    if (this.length === this.payloadLength) {
+                        this.section.push(this.payloadGet());
+                        this.status = 0;
+                    }
+                }
+                
+                if(this.fin === 1 && this.length === this.payloadLength){
+                    let data = Buffer.concat(this.section);
+                    delete this.section;
+                    this.section = [];
+                    this.callback({
+                        type: this.type,
+                        payload: this.type === 'utf8' ? data.toString('utf8') : data
+                    });
+                }
+                break;
+            }
+        }
+        payloadReset(){
+            delete this.payload;
+            this.payload = [];
+            this.payloadLength = 0;
+        }
+        payloadAdd(buffer){
+            this.payload.push(buffer);
+            this.payloadLength += buffer.length;
+        }
+        payloadGet(){
+            return Buffer.concat(this.payload);
+        }
+        header(buffer){
+            if (buffer.length < 2) return false;
+
+            const firstByte = buffer[0];
+            const secondByte = buffer[1];
+            let offset = 2;
+
+            let fin = firstByte >> 7;
+            let opcode = firstByte & 0x0F;
+            let isMasked = secondByte >> 7;
+            let length = secondByte & 0x7F;
+
+            if (length === 126) {
+                if (buffer.length < 4) return false;
+                length = buffer.readUInt16BE(offset);
+                offset += 2;
+            } else if (length === 127) {
+                if (buffer.length < 10) return false;
+                length = Number(buffer.readBigUInt64BE(offset));
+                offset += 8;
+            }
+
+            let key = isMasked ? buffer.slice(offset, offset + 4) : Buffer.alloc(0);
+            offset += isMasked ? 4 : 0;
+
+            let raw = buffer.slice(offset);
+            let type = this.getOpcodeType(opcode);
+
+            return {
+                fin,
+                opcode,
+                isMasked,
+                length,
+                key,
+                raw,
+                type
+            };
+        }
+        getOpcodeType(opcode){
+            switch (opcode) {
+                case 1: return 'utf8';
+                case 2: return 'binary';
+                case 8: return 'close';
+                case 9: return 'ping';
+                case 10: return 'pong';
+                case 0: return true;
+                default:  return null;
+            }
+        }
+        mask(key, raw, start){
+            let unmasked = Buffer.allocUnsafe(raw.length);
+            for (let i = 0; i < raw.length; i++) {
+                unmasked[i] = raw[i] ^ key[(start+i) % 4];
+            }
+            return unmasked;
+        }
+    },
+    statusText:(code)=>{
+        const statusTexts = {
+          200: 'OK',
+          301: 'Moved Permanently',
+          400: 'Bad Request',
+          404: 'Not Found',
+          500: 'Internal Server Error',
+          101: 'Switching Protocols',
+        };
+        return statusTexts[code] || 'Unknown Status';
+    },
+    head2line:(header)=>{
+        const headerLines = [];
+        for(const [key, value] of Object.entries(header)) {
+            if (Array.isArray(value)) {
+                value.forEach((val) => headerLines.push(`${key}: ${val}`));
+            } else {
+                headerLines.push(`${key}: ${value}`);
+            }
+        }
+        return headerLines.join('\r\n');
+    },
+    createID:()=>{
+        return crypto.randomBytes(64)
+        .toString('base64')
+        .replace(/[^a-zA-Z0-9]/g, '')
+        .slice(0, 64);
+    }
+};
+
+module.exports = tools;

package/lib/websocket.js

@@ -0,0 +1,312 @@
+const tools = require('./tools');
+
+module.exports = class{
+    status = 0
+    header = {}
+    cookie = {}
+    body = {}
+    host = ''
+    url = ''
+    query = {}
+    method = ''
+    callback = ()=>{}
+    constructor({req, socket, head}){
+        this.req = req;
+        this.socket = socket;
+        this.head = head;
+
+        if(this.req.headers.upgrade === 'websocket'){
+            this.socket.on('data', (buffer) => {
+                this.frame.decode(buffer);
+            })
+            .on('end', () => {
+                this.req.destroy();
+            })
+            .on('close', () => {
+                this.userOut();
+                this.callback(this, 'close');
+            })
+            .on('error', (e) => {
+                console.log(e);
+            });
+            
+            this.process();
+            this.readFrame();
+        }
+    }
+    process(){
+        if(!this.req.headers.host){
+            this.error(400, 'Invalid Host.');
+            return false;
+        }
+
+        const findHost = this.req.headers.host.indexOf(':');
+        this.host = findHost === -1 ? this.req.headers.host : this.req.headers.host.slice(0, findHost);
+
+        this.method = this.req.headers.upgrade === 'websocket' ? 'websocket' : this.req.method.toLowerCase();
+
+        const url = this.req.url.split('?');
+        this.path = url[0];
+        if(url[1]){
+            this.query = tools.wwwform(url[1]);
+        }
+
+        if(this.req.headers.hasOwnProperty('cookie')){
+            let cookie = [];
+            if(Array.isArray(this.req.headers.cookie)){
+                cookie = this.req.headers.cookie;
+            }else{
+                cookie.push(this.req.headers.cookie);
+            }
+
+            for(let x of cookie){
+                for(let i of x.split('; ')){
+                    let index = i.indexOf('=');
+                    let key = i.slice(0, index);
+                    let value = i.slice(index + 1);
+
+                    try{
+                        key = decodeURIComponent(key);
+                        value = decodeURIComponent(value);
+                    }catch(e){}
+
+                    this.cookie[key] = value;
+                }
+            }
+        }
+        return true;
+    }
+    update(call){
+        this.callback = call;
+    }
+
+    code(status){
+        this.status = status;
+        return this;
+    }
+    set(key, value){
+        if(this.header.hasOwnProperty(key)){
+            this.header[key].push(value);
+        }else{
+            this.header[key] = [value];
+        }
+        return this;
+    }
+    get(key){
+        if(this.req.headers.hasOwnProperty(key)){
+            let header = this.req.headers[key];
+            if(typeof header == 'string'){
+                return header;
+            }else if(Array.isArray(header)){
+                return header[header.length - 1];
+            }
+        }
+        return false;
+    }
+    look(keys){
+        for(let x of keys.split(/[\s]*,[\s]*/)){
+            if(!this.query.hasOwnProperty(x)){
+                return false;
+            }
+        }
+        return true;
+    }
+    u(key){
+        if(this.query.hasOwnProperty(key)){
+            if(Array.isArray(this.query[key])){
+                return this.query[key][this.query[key].length - 1];
+            }else{
+                return this.query[key];
+            }
+        }
+        return false;
+    }
+    scookie = (name, value, option) => {
+        let text = [`${name}=${encodeURI((value || '').toString())}`];
+        for(let x in option){
+            if(['domain', 'expires', 'httponly', 'max-age', 'partitioned', 'path', 'secure', 'sameSite'].includes(x)){
+                if(['string','number'].includes(typeof option[x])){
+                    text.push(`${x}=${encodeURI(option[x].toString())}`);
+                }else{
+                    text.push(`${x}`);
+                }
+            }
+        }
+        this.set('set-cookie', text.join('; '));
+        return this;
+    }
+    rcookie(name, option){
+        if(typeof option != 'object'){
+            option = {};
+        }
+        option['max-age'] = '-1';
+        this.scookie(name, '', option);
+        return this;
+    }
+
+    writeHead(){
+        this.header['x-powered-by'] = `R938`;
+
+        const head = tools.head2line(this.header);
+        const statusLine = `HTTP/1.1 ${this.status} ${tools.statusText(this.status)}`;
+        const headLine = `${statusLine}\r\n${head}\r\n\r\n`;
+        this.write(Buffer.from(headLine));
+
+        return this;
+    }
+    write(data, callback){
+        if(this.socket.writable){
+            this.socket.write(data, callback);
+        }else if(this.req.destroyed){
+            this.req.destroy();
+        }
+    }
+    end(data, callback){
+        if(this.socket.writable){
+            this.socket.end(data, callback);
+        }else if(this.req.destroyed){
+            this.req.destroy();
+        }
+    }
+    error(status){
+        this.code(status)
+        .writeHead()
+        .end();
+    }
+
+    readFrame(){
+        this.frame = new tools.decodeFrame((data)=>{
+            this.body = data;
+
+            if(data.type == 'utf8'){
+                if((data.payload[0] == '{' && data.payload[data.payload.length - 1] == '}') || (data.payload[0] == '[' && data.payload[data.payload.length - 1] == ']')){
+                    try{
+                        data.json = JSON.parse(data.payload);
+                    }catch(e){
+                        data.json = {};
+                    }
+                }
+                this.callback(this, 'data');
+            }else if(data.type == 'binary'){
+                this.callback(this, 'data');
+            }else if(data.type == 'close'){
+                this.stop();
+            }else if(data.type == 'ping'){
+                this.callback(this, 'ping');
+            }else if(data.type == 'pong'){
+                this.callback(this, 'pong');
+            }else{
+                this.callback(this, 'error');
+            }
+        });
+    }
+    start(uid){
+        let seckey = this.get('sec-websocket-key');
+        let protocol = this.get('sec-websocket-protocol');
+        let version = parseInt(this.get('sec-websocket-version') || 0);
+        let acceptKey = tools.generateKey(seckey);
+
+        if(typeof seckey != 'string' || version != 13){
+            return this.error(400,`Accept key exchange failed.`);
+        }
+
+        let checkUser = this.userHas(uid);
+        if(checkUser !== false){
+            checkUser.userOut();
+            checkUser.stop();
+        }
+        
+        this.uid = uid;
+        this.userIn();
+
+        this.code(101)
+        .set('upgrade','websocket')
+        .set('connection','Upgrade')
+        .set('sec-websocket-accept',acceptKey);
+
+        if(protocol){
+            this.set('sec-websocket-protocol',protocol);
+        }
+
+        this.writeHead();
+    }
+    stop(data, callback){
+        this.req.destroy();
+    }
+    
+    userEach(callback){
+        if(!this.callback.users)return false;
+        for(let x in this.callback.users.member){
+            if(callback(this.callback.users.member[x])){
+                break;
+            }
+        }
+    };
+    userLength(){
+        if(!this.callback.users)return 0;
+        return this.callback.users.length;
+    };
+    userHas(uid){
+        if(!this.callback.users)return false;
+        if(this.callback.users.member.hasOwnProperty(uid)){
+            return this.callback.users.member[uid];
+        }
+        return false;
+    }
+    userIn(){
+        if(!this.callback.users)return false;
+        if(!this.callback.users.member.hasOwnProperty(this.uid)){
+            this.callback.users.member[this.uid] = this;
+            this.callback.users.length++;
+            this.userIn = ()=>{};
+            return true;
+        }
+        return false;
+    }
+    userOut(){
+        if(!this.callback.users)return false;
+        if(this.callback.users.member.hasOwnProperty(this.uid)){
+            delete this.callback.users.member[this.uid];
+            this.callback.users.length--;
+            this.userOut = ()=>{};
+            return true;
+        }
+        return false;
+    }
+    pong(){
+        let encode = tools.encodeFrame('pong', 10);
+        this.write(encode);
+    };
+    send = (text, opcode = 1) => {
+        let encode = tools.encodeFrame(text, opcode); 
+        this.write(encode);
+    };
+    sends = (text, opcode = 1) => {
+        let encode = tools.encodeFrame(text, opcode); 
+        this.userEach((user)=>{
+            user.write(encode);
+        });
+    };
+    json(json){
+        this.send(JSON.stringify(json), 1);
+    }
+    jsons(json){
+        this.sends(JSON.stringify(json), 1);
+    }
+    sendto(uid, text, opcode = 1){
+        let user = this.userHas(uid);
+        if(user !== false){
+            user.send(text, opcode = 1);
+            return true;
+        }
+        return false;
+    };
+    jsonto(uid, json){
+        let user = this.userHas(uid);
+        if(user !== false){
+            user.json(json);
+            return true;
+        }
+        return false;
+    };
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name":"birdpack",
+    "description": "BirdPack framework is a tool for web server via TCP HTTP supporting websocket focusing on speed.",
+    "author":"R938",
+    "license":"r938-birdpack-2025",
+    "version":"1.0.0",
+    "type": "module",
+    "main": "lib/server.js",
+    "exports": {
+        ".": "./lib/server.js"
+    },
+    "directories": {
+    },
+    "scripts": {
+        "dev": "node app.js -u http -p 8000"
+    }
+}