reqrio 0.1.0-rc1

package/Response.js

@@ -0,0 +1,53 @@
+class Header {
+    constructor(json) {
+        if (!json) return
+        this.uri = json.uri;
+        this.method = json.method;
+        this.status = json.status;
+        this.agreement = json.agreement;
+        this.keys = json.keys
+        this.cookies = []
+
+        if (this.keys["Set-Cookie"]) {
+            for (let i = 0; i < this.keys["Set-Cookie"].length; i++) {
+                this.cookies.push(this.keys["Set-Cookie"][i])
+            }
+            delete this.keys["Set-Cookie"]
+        }
+        if (this.keys["set-cookie"]) {
+            for (let i = 0; i < this.keys["set-cookie"].length; i++) {
+                this.cookies.push(this.keys["set-cookie"][i])
+            }
+            delete this.keys["set-cookie"]
+        }
+
+
+    }
+}
+
+
+class Response {
+    constructor(bytes) {
+        let resp_text = bytes.toString('utf8')
+        try {
+            let resp_json = JSON.parse(resp_text);
+            this.header = new Header(resp_json.header);
+            this.body = Buffer.from(resp_json.body, 'hex')
+        } catch (e) {
+            throw resp_text
+        }
+    }
+
+    status_code() {
+        return this.header.status
+    }
+
+    text() {
+        return this.body.toString('utf8')
+    }
+}
+
+
+module.exports = {
+    Response, Header
+}

package/bindings.js

@@ -0,0 +1,73 @@
+const ffi = require('ffi-napi');
+const ref = require('ref-napi');
+
+const voidPtr = ref.refType(ref.types.void);
+const charPtr = ref.types.CString;
+const bytePtr = ref.refType(ref.types.char)
+
+const Method = {
+    GET: 0,
+    POST: 1,
+    PUT: 2,
+    HEAD: 3,
+    DELETE: 4,
+    OPTIONS: 5,
+    TRACE: 6,
+    CONNECT: 7,
+}
+
+const library = ffi.Library("./libreqrio.so", {
+    ScReq_new: [voidPtr, []],
+    ScReq_set_header_json: ['int', [voidPtr, charPtr]],
+    ScReq_add_header: ["int", [voidPtr, charPtr, charPtr]],
+    ScReq_set_alpn: ["int", [voidPtr, charPtr]],
+    ScReq_set_random_fingerprint: ["int", [voidPtr]],
+    ScReq_set_fingerprint: ["int", [voidPtr, charPtr]],
+    ScReq_set_ja3: ["int", [voidPtr, charPtr]],
+    ScReq_set_ja4: ['int', [voidPtr, charPtr]],
+    ScReq_set_proxy: ['int', [voidPtr, charPtr]],
+    ScReq_set_url: ['int', [voidPtr, charPtr]],
+    ScReq_add_param: ['int', [voidPtr, charPtr, charPtr]],
+    ScReq_set_data: ['int', [voidPtr, charPtr]],
+    ScReq_set_json: ['int', [voidPtr, charPtr]],
+    ScReq_set_bytes: ['int', [voidPtr, bytePtr, "uint32"]],
+    ScReq_set_text: ["int", [voidPtr, charPtr]],
+    ScReq_set_timeout: ["int", [voidPtr, charPtr]],
+    ScReq_set_cookie: ['int', [voidPtr, charPtr]],
+    ScReq_add_cookie: ['int', [voidPtr, charPtr, charPtr]],
+    ScReq_set_callback: ["int", [voidPtr, "pointer"]],
+    ScReq_reconnect: ['int', [voidPtr]],
+    ScReq_stream_io: ["pointer", [voidPtr, "int"]],
+    ScReq_drop: ['int', [voidPtr]],
+    char_free: ['int', [charPtr]],
+    ws_build: [voidPtr, []],
+    ws_add_header: ['int', [voidPtr, charPtr, charPtr]],
+    ws_set_proxy: ['int', [voidPtr, charPtr]],
+    ws_set_url: ['int', [voidPtr, charPtr]],
+    ws_set_uri: ['int', [voidPtr, charPtr]],
+    ws_open: [voidPtr, [voidPtr]],
+    ws_open_raw: [voidPtr, [charPtr, charPtr]],
+    ws_read: ['pointer', [voidPtr]],
+    ws_write: ['int', [voidPtr, 'int', 'bool', charPtr]],
+    ws_close: ['int', [voidPtr]]
+
+})
+
+function make_ScReq_callback(func) {
+    return ffi.Callback("void", ["pointer", "uint32"], function (ptr, len) {
+        const buffer = ref.reinterpret(ptr, len);
+        const data = Buffer.from(buffer);
+        func(data)
+    })
+}
+
+function read_to_string(ptr) {
+    return ref.readCString(ptr, 0)
+}
+
+module.exports = {
+    library,
+    Method,
+    make_ScReq_callback,
+    read_to_string
+}

package/index.js

@@ -0,0 +1,10 @@
+const {Session, Response, Method, ALPN} = require('session')
+const {Websocket} = require("ws")
+
+module.exports = {
+    Session,
+    Response,
+    Method,
+    ALPN,
+    Websocket
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "reqrio",
+  "version": "0.1.0-rc1",
+  "description": "A lightweight, high concurrency HTTP request library",
+  "main": "index.js",
+  "keywords": [
+    "http",
+    "lightweight",
+    "tls fingerprint"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xllgl2017/reqrio.git"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "xllgl2017"
+  },
+  "dependencies": {
+    "ref-napi": "^3.0.3"
+  }
+}

package/session.js

@@ -0,0 +1,175 @@
+const {library, Method, make_ScReq_callback, read_to_string} = require("bindings");
+const {Response} = require("Response")
+
+const ALPN = Object.freeze({
+    HTTP10: "http/1.0",
+    HTTP11: "http/1.1",
+    HTTP20: "h2"
+})
+
+const registry = new FinalizationRegistry(req => {
+    library.ScReq_drop(req)
+})
+
+class Session {
+    constructor(alpn, rand_tls) {
+        this.req = library.ScReq_new();
+        if (alpn) {
+            let ret = library.ScReq_set_alpn(this.req, alpn)
+            if (ret === -1) throw "set_alpn error"
+        }
+        if (rand_tls) {
+            let ret = library.ScReq_set_random_fingerprint(this.req);
+            if (ret === -2) throw "free user, set_random_fingerprint can't be used"
+            if (ret === -1) throw "set_random_fingerprint error"
+        }
+        registry.register(this, this.req)
+    }
+
+    set_fingerprint(fingerprint) {
+        let ret = library.ScReq_set_fingerprint(this.req, fingerprint);
+        if (ret === -2) throw "free user, set_fingerprint can't be used"
+        if (ret === -1) throw "set_fingerprint error"
+    }
+
+    set_ja3(ja3) {
+        let ret = library.ScReq_set_ja3(this.req, ja3);
+        if (ret === -2) throw "free user, set_ja3 can't be used"
+        if (ret === -1) throw "set_ja3 error"
+
+    }
+
+    set_ja4(ja4) {
+        let ret = library.ScReq_set_ja4(this.req, ja4);
+        if (ret === -2) throw "free user, set_ja4 can't be used"
+        if (ret === -1) throw "set_ja4 error"
+
+    }
+
+    set_header_json(header) {
+        let header_str = JSON.stringify(header);
+        let ret = library.ScReq_set_header_json(this.req, header_str)
+        if (ret === -1) throw "set_header_json error"
+    }
+
+    add_header(name, value) {
+        let ret = library.ScReq_add_header(name, value)
+        if (ret === -1) throw "add_header error"
+    }
+
+    set_proxy(proxy) {
+        let ret = library.ScReq_set_proxy(this.req, proxy);
+        if (ret === -1) throw "add_header error"
+    }
+
+
+    set_url(url) {
+        let ret = library.ScReq_set_url(this.req, url)
+        if (ret === -1) throw "set_url error"
+    }
+
+    add_param(name, value) {
+        let ret = library.ScReq_add_param(this.req, name, value);
+        if (ret === -1) throw "add_param error"
+    }
+
+    set_data(data) {
+        let data_str = JSON.stringify(data)
+        let ret = library.ScReq_set_data(data_str);
+        if (ret === -1) throw "set_data error"
+    }
+
+    set_json(json) {
+        let json_str = JSON.stringify(this.req, json);
+        let ret = library.ScReq_set_header_json(this.req, json_str);
+        if (ret === -1) throw "set_json error"
+    }
+
+    set_bytes(buffer) {
+        let ret = library.ScReq_set_bytes(this.req, buffer, buffer.length);
+        if (ret === -1) throw "set_bytes error"
+    }
+
+    set_text(text) {
+        let ret = library.ScReq_set_text(this.req, text);
+        if (ret === -1) throw "set_text error"
+    }
+
+    /*
+    Timeout{
+        connect:3000,
+        read:3000,
+        write:3000,
+        handle:30000,
+        connect_times:3,
+        handle_times:3
+    }
+     */
+    set_timeout(timeout) {
+        let timeout_str = JSON.stringify(timeout);
+        let ret = library.ScReq_set_timeout(this.req, timeout_str);
+        if (ret === -1) throw "set_timeout error"
+    }
+
+    set_cookie(cookie) {
+        let ret = library.ScReq_set_cookie(this.req, cookie)
+        if (ret === -1) throw "set_cookie error"
+    }
+
+    add_cookie(name, value) {
+        let ret = library.ScReq_add_cookie(this.req, name, value)
+        if (ret === -1) throw "add_cookie error"
+    }
+
+    reconnect() {
+        let ret = library.ScReq_reconnect(this.req)
+        if (ret === -1) throw "reconnect error"
+    }
+
+    set_callback(func) {
+        let callback = make_ScReq_callback(func)
+        library.ScReq_set_callback(this.req, callback)
+    }
+
+    send(method) {
+        let resp = library.ScReq_stream_io(this.req, Method.GET)
+        let buffer = Buffer.from(read_to_string(resp), "hex");
+        let response = new Response(buffer);
+        response.header.method = method;
+        library.char_free(resp)//；这里需要手动释放吗
+        return response;
+    }
+
+    get() {
+        return this.send(Method.GET)
+    }
+
+    post() {
+        return this.send(Method.POST)
+    }
+
+    options() {
+        return this.send(Method.OPTIONS)
+    }
+
+    head() {
+        return this.send(Method.HEAD)
+    }
+
+    trace() {
+        return this.send(Method.TRACE)
+    }
+
+    delete() {
+        return this.send(Method.DELETE)
+    }
+
+    close() {
+        registry.unregister(this);
+        library.ScReq_drop(this.req)
+    }
+}
+
+module.exports = {
+    Session, ALPN, Method, Response
+}

package/test.js

@@ -0,0 +1,17 @@
+const {Session, ALPN, Websocket} = require('index')
+
+let session = new Session(ALPN.HTTP20, false);
+session.set_url("https://m.so.com");
+session.set_callback(function (data) {
+    console.log(data.length)
+})
+let resp = session.get();
+console.log(resp.status_code())
+console.log(resp.header)
+session.close();
+
+
+let ws = new Websocket();
+ws.set_url("https://alive.github.com")
+ws.open()
+ws.read()

package/ws.js

@@ -0,0 +1,58 @@
+const {library, read_to_string} = require("./bindings");
+const registry = new FinalizationRegistry(ws => {
+    library.ws_close(ws)
+})
+
+class Websocket {
+    constructor() {
+        this.build = library.ws_build();
+        this.ws = null;
+    }
+
+    add_header(name, value) {
+        let ret = library.ws_add_header(this.build, name, value)
+        if (ret === -1) throw "add header error"
+    }
+
+    set_proxy(proxy) {
+        let ret = library.ws_set_proxy(this.build, proxy);
+        if (ret === -1) throw "set proxy error"
+    }
+
+    set_url(url) {
+        let ret = library.ws_set_url(this.build, url)
+        if (ret === -1) throw "set url error"
+    }
+
+    set_uri(uri) {
+        let ret = library.ws_set_uri(this.build, uri)
+        if (ret === -1) throw "set uri error"
+    }
+
+    open(url) {
+        if (url) this.set_url(url)
+        this.ws = library.ws_open(this.build)
+        registry.register(this, this.ws)
+    }
+
+    read() {
+        let ptr = library.ws_read(this.ws)
+        let s = read_to_string(ptr)
+        library.char_free(ptr)
+        return JSON.parse(s)
+    }
+
+    write(opcode, mask, msg) {
+        let ret = library.ws_write(this.ws, opcode, mask, msg)
+        if (ret === -1) throw "ws write error"
+    }
+
+    close() {
+        registry.unregister(this);
+    }
+}
+
+
+module.exports = {
+    Websocket
+}