node-firebird 2.3.4 → 2.4.1

package/lib/messages.js

@@ -1,162 +1,135 @@
-var fs = require('fs');
-
-const
-    //ISC_MASK   = 0x14000000, // Defines the code as a valid ISC code
-    FAC_MASK   = 0x00FF0000, // Specifies the facility where the code is located
-    CODE_MASK  = 0x0000FFFF, // Specifies the code in the message file
-    CLASS_MASK = 0xF0000000; // Defines the code as warning, error, info, or other
-
-var msgNumber = exports.msgNumber = function(facility, code) {
-    return (facility * 10000 + code);
-};
-
-var getCode = exports.getCode = function(code) {
-    return (code & CODE_MASK)
-};
-
-var getFacility = exports.getFacility =  function(code) {
-    return (code & FAC_MASK) >> 16;
-};
-
-exports.getClass = function(code) {
-    return (code & CLASS_MASK) >> 28;
-};
-
-exports.lookupMessages = function(status, messageFile, callback){
-
-    var handle;
-    var bucket_size;
-    var top_tree;
-    var levels;
-    var buffer;
-
-    function lookup(item, callback) {
-
-        var code = msgNumber(getFacility(item.gdscode), getCode(item.gdscode));
-
-        function readIndex(stackSize, position) {
-
-            function readNode(from) {
-                var ret = {};
-                ret.code = buffer.readUInt32LE(from);
-                ret.seek = buffer.readUInt32LE(from + 4);
-                return ret;
-            }
-
-            fs.read(handle, buffer, 0, bucket_size, position, function(err, bufferSize) {
-
-                if (bufferSize <= 0) {
-                    callback();
-                    return;
-                }
-
-                if (stackSize === levels) {
-                    search();
-                    return;
-                }
-
-                var from = 0;
-                var node = readNode(from);
-
-                while (true) {
-
-                    if (node.code >= code)
-                    {
-                        readIndex(stackSize + 1, node.seek);
-                        break;
-                    }
-
-                    from += 8;
-                    if (from >= bufferSize)
-                    {
-                        callback();
-                        break;
-                    }
-
-                    node = readNode(from);
-                }
-            });
-        }
-
-        function search() {
-
-            function readRec(from) {
-
-                function align(v) {
-                    return (v + 3) & ~3;
-                }
-
-                var ret = {};
-                ret.code = buffer.readUInt32LE(from);
-                ret.length = buffer.readUInt16LE(from + 4);
-
-                if (ret.code == code){
-                    from += 8;
-                    ret.text = buffer.toString(undefined, from, from + ret.length);
-                } else
-                    ret.seek = from + align(8 + ret.length, 4);
-
-                return ret;
-            }
-
-            var rec = readRec(0);
-
-            while (rec.seek) {
-                if (rec.seek >= buffer.length)
-                    break;
-                else
-                    rec = readRec(rec.seek);
-            }
-
-            var str = rec.text;
-            if (item.params) {
-                for (var i = 0; i < item.params.length; i++)
-                    str = str.replace('@' + String(i+1), item.params[i]);
-            }
-
-            callback(str);
-        }
-
-        readIndex(1, top_tree);
-    }
-
-    fs.open(messageFile, 'r', function(err, h) {
-
-        if (!h) {
-            callback();
-            return;
-        }
-
-        buffer = Buffer.alloc(14);
-        fs.read(h, buffer, 0, 14, 0, function(){
-
-            handle = h;
-            bucket_size = buffer.readUInt16LE(2);
-            top_tree = buffer.readUInt32LE(4);
-            levels = buffer.readUInt16LE(12);
-            buffer = Buffer.alloc(bucket_size);
-
-            var i = 0;
-            var text;
-
-            function loop() {
-                lookup(status[i], function(line) {
-                    if (text)
-                        text = text + ', ' + line
-                    else
-                        text = line;
-
-                    if (i === status.length - 1) {
-                        fs.closeSync(handle);
-                        callback(text);
-                    } else {
-                        i++;
-                        loop();
-                    }
-                });
-            }
-
-            loop(0);
-        });
-    });
-};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupMessages = exports.getClass = exports.getFacility = exports.getCode = exports.msgNumber = void 0;
+const fs_1 = __importDefault(require("fs"));
+const 
+//ISC_MASK   = 0x14000000, // Defines the code as a valid ISC code
+FAC_MASK = 0x00FF0000, // Specifies the facility where the code is located
+CODE_MASK = 0x0000FFFF, // Specifies the code in the message file
+CLASS_MASK = 0xF0000000; // Defines the code as warning, error, info, or other
+const msgNumber = function (facility, code) {
+    return (facility * 10000 + code);
+};
+exports.msgNumber = msgNumber;
+const getCode = function (code) {
+    return (code & CODE_MASK);
+};
+exports.getCode = getCode;
+const getFacility = function (code) {
+    return (code & FAC_MASK) >> 16;
+};
+exports.getFacility = getFacility;
+const getClass = function (code) {
+    return (code & CLASS_MASK) >> 28;
+};
+exports.getClass = getClass;
+const lookupMessages = function (status, messageFile, callback) {
+    var handle;
+    var bucket_size;
+    var top_tree;
+    var levels;
+    var buffer;
+    function lookup(item, callback) {
+        var code = (0, exports.msgNumber)((0, exports.getFacility)(item.gdscode), (0, exports.getCode)(item.gdscode));
+        function readIndex(stackSize, position) {
+            function readNode(from) {
+                var ret = {};
+                ret.code = buffer.readUInt32LE(from);
+                ret.seek = buffer.readUInt32LE(from + 4);
+                return ret;
+            }
+            fs_1.default.read(handle, buffer, 0, bucket_size, position, function (err, bufferSize) {
+                if (bufferSize <= 0) {
+                    callback();
+                    return;
+                }
+                if (stackSize === levels) {
+                    search();
+                    return;
+                }
+                var from = 0;
+                var node = readNode(from);
+                while (true) {
+                    if (node.code >= code) {
+                        readIndex(stackSize + 1, node.seek);
+                        break;
+                    }
+                    from += 8;
+                    if (from >= bufferSize) {
+                        callback();
+                        break;
+                    }
+                    node = readNode(from);
+                }
+            });
+        }
+        function search() {
+            function readRec(from) {
+                function align(v) {
+                    return (v + 3) & ~3;
+                }
+                var ret = {};
+                ret.code = buffer.readUInt32LE(from);
+                ret.length = buffer.readUInt16LE(from + 4);
+                if (ret.code == code) {
+                    from += 8;
+                    ret.text = buffer.toString(undefined, from, from + ret.length);
+                }
+                else
+                    ret.seek = from + align(8 + ret.length);
+                return ret;
+            }
+            var rec = readRec(0);
+            while (rec.seek) {
+                if (rec.seek >= buffer.length)
+                    break;
+                else
+                    rec = readRec(rec.seek);
+            }
+            var str = rec.text;
+            if (item.params) {
+                for (var i = 0; i < item.params.length; i++)
+                    str = str.replace('@' + String(i + 1), item.params[i]);
+            }
+            callback(str);
+        }
+        readIndex(1, top_tree);
+    }
+    fs_1.default.open(messageFile, 'r', function (err, h) {
+        if (!h) {
+            callback();
+            return;
+        }
+        buffer = Buffer.alloc(14);
+        fs_1.default.read(h, buffer, 0, 14, 0, function () {
+            handle = h;
+            bucket_size = buffer.readUInt16LE(2);
+            top_tree = buffer.readUInt32LE(4);
+            levels = buffer.readUInt16LE(12);
+            buffer = Buffer.alloc(bucket_size);
+            var i = 0;
+            var text;
+            function loop() {
+                lookup(status[i], function (line) {
+                    if (text)
+                        text = text + ', ' + line;
+                    else
+                        text = line;
+                    if (i === status.length - 1) {
+                        fs_1.default.closeSync(handle);
+                        callback(text);
+                    }
+                    else {
+                        i++;
+                        loop();
+                    }
+                });
+            }
+            loop();
+        });
+    });
+};
+exports.lookupMessages = lookupMessages;

package/lib/pool.d.ts

@@ -0,0 +1,23 @@
+/***************************************
+ *
+ *   Simple Pooling
+ *
+ ***************************************/
+import type { Callback } from './callback';
+type AttachFn = (options: any, callback: Callback) => void;
+declare class Pool {
+    attach: AttachFn;
+    internaldb: any[];
+    pooldb: any[];
+    dbinuse: number;
+    _creating: number;
+    max: number;
+    pending: Callback[];
+    options: any;
+    _destroyed: boolean;
+    constructor(attach: AttachFn, max: number, options: any);
+    get(callback: Callback): this;
+    check(): this;
+    destroy(callback?: (err?: any) => void): void;
+}
+export = Pool;

package/lib/pool.js

@@ -1,22 +1,21 @@
+"use strict";
 /***************************************
  *
  *   Simple Pooling
  *
  ***************************************/
-
 class Pool {
     constructor(attach, max, options) {
-        this.attach    = attach;
+        this.attach = attach;
         this.internaldb = []; // connections created by the pool (for destroy)
-        this.pooldb    = []; // connections available in the pool (idle)
-        this.dbinuse   = 0;  // connections currently handed out to callers
-        this._creating = 0;  // connections currently being created (attach in flight)
-        this.max       = max || 4;
-        this.pending   = []; // callbacks waiting for a free slot
-        this.options   = options;
+        this.pooldb = []; // connections available in the pool (idle)
+        this.dbinuse = 0; // connections currently handed out to callers
+        this._creating = 0; // connections currently being created (attach in flight)
+        this.max = max || 4;
+        this.pending = []; // callbacks waiting for a free slot
+        this.options = options;
         this._destroyed = false; // true after destroy() — prevents further use
     }
-
     get(callback) {
         // [Fix 2] Reject immediately if the pool has already been destroyed.
         if (this._destroyed) {
@@ -28,16 +27,13 @@ class Pool {
         self.check();
         return self;
     }
-
     check() {
         var self = this;
-
         // [Fix 2] Do not serve requests on a destroyed pool.
-        if (self._destroyed) return self;
-
+        if (self._destroyed)
+            return self;
         if ((self.dbinuse + self._creating) >= self.max)
             return self;
-
         var cb = self.pending.shift();
         if (!cb)
             return self;
@@ -46,7 +42,8 @@ class Pool {
             // Discard connections that have been closed or destroyed while idle
             if (db.connection && (db.connection._isClosed || db.connection._isDetach || !db.connection._socket || db.connection._socket.destroyed)) {
                 var idx = self.internaldb.indexOf(db);
-                if (idx !== -1) self.internaldb.splice(idx, 1);
+                if (idx !== -1)
+                    self.internaldb.splice(idx, 1);
                 self.pending.unshift(cb);
                 setImmediate(function () { self.check(); });
                 return self;
@@ -54,13 +51,12 @@ class Pool {
             // Idle connection available — hand it out immediately.
             self.dbinuse++;
             cb(null, db);
-        } else {
+        }
+        else {
             // No idle connection — create a new one via attach().
             self._creating++;
-
             var timedOut = false;
-            var timer    = null;
-
+            var timer = null;
             // [Fix 1] Optional per-attach timeout.
             // If attach() does not call back within connectTimeout ms (e.g. because
             // the server accepted TCP but stalled on the Firebird wire protocol), we
@@ -70,16 +66,12 @@ class Pool {
                 timer = setTimeout(function () {
                     timedOut = true;
                     self._creating--;
-                    cb(new Error(
-                        'Connection timeout after ' + self.options.connectTimeout + 'ms'
-                    ), null);
+                    cb(new Error('Connection timeout after ' + self.options.connectTimeout + 'ms'), null);
                     // Free the slot so the next pending request can be served.
                     setImmediate(function () { self.check(); });
                 }, self.options.connectTimeout);
             }
-
             this.attach(self.options, function (err, db) {
-
                 // [Fix 1] Timeout already fired — discard this late connection.
                 // Without this guard the socket would stay open until the OS-level
                 // TCP timeout (potentially minutes), leaking a file descriptor.
@@ -88,28 +80,30 @@ class Pool {
                         try {
                             // _pooled = false forces a real op_detach / socket close
                             // instead of a silent pool-return emit.
-                            if (db.connection) db.connection._pooled = false;
+                            if (db.connection)
+                                db.connection._pooled = false;
                             db.detach();
-                        } catch (e) { /* ignore cleanup errors */ }
+                        }
+                        catch (e) { /* ignore cleanup errors */ }
                     }
                     return;
                 }
-
-                if (timer) clearTimeout(timer);
+                if (timer)
+                    clearTimeout(timer);
                 self._creating--;
-
                 // [Fix 3] Pool was destroyed while attach() was in flight.
                 if (self._destroyed) {
                     if (db) {
                         try {
-                            if (db.connection) db.connection._pooled = false;
+                            if (db.connection)
+                                db.connection._pooled = false;
                             db.detach();
-                        } catch (e) { /* ignore cleanup errors */ }
+                        }
+                        catch (e) { /* ignore cleanup errors */ }
                     }
                     cb(new Error('Pool has been destroyed'), null);
                     return;
                 }
-
                 if (!err) {
                     self.dbinuse++;
                     self.internaldb.push(db);
@@ -122,41 +116,36 @@ class Pool {
                             self.internaldb.splice(self.internaldb.indexOf(db), 1);
                         else
                             self.pooldb.push(db);
-
                         self.dbinuse--;
                         self.check();
                     });
                 }
-
                 cb(err, db);
             });
         }
-        setImmediate(function() {
+        setImmediate(function () {
             self.check();
         });
-
         return self;
     }
-
     destroy(callback) {
         var self = this;
         self._destroyed = true;
-
         // [Fix 4] Drain pending callbacks so callers are not left hanging.
         // This is critical when destroy() is called as a recovery measure after
         // a timeout: without draining, every concurrent pool.get() that had not
         // yet received a slot would hang until the process exits.
         var draining = self.pending.splice(0);
         draining.forEach(function (cb) {
-            try { cb(new Error('Pool is being destroyed'), null); } catch (e) { /* ignore */ }
+            try {
+                cb(new Error('Pool is being destroyed'), null);
+            }
+            catch (e) { /* ignore */ }
         });
-
         var connectionCount = this.internaldb.length;
-
         if (connectionCount === 0 && callback) {
             callback();
         }
-
         function detachCallback(err) {
             if (err) {
                 if (callback) {
@@ -164,14 +153,12 @@ class Pool {
                 }
                 return;
             }
-
             connectionCount--;
             if (connectionCount === 0 && callback) {
                 callback();
             }
         }
-
-        this.internaldb.forEach(function(db) {
+        this.internaldb.forEach(function (db) {
             if (db.connection._pooled === false) {
                 detachCallback();
                 return;
@@ -182,7 +169,8 @@ class Pool {
                 self.pooldb.splice(_db_in_pool, 1);
                 db.connection._pooled = false;
                 db.detach(detachCallback);
-            } else {
+            }
+            else {
                 // [Fix 5] Connection is currently in use (dbinuse > 0).
                 // The caller is responsible for releasing it via detach().
                 // Count it down here so the destroy() callback is not blocked forever.
@@ -191,5 +179,4 @@ class Pool {
         });
     }
 }
-
 module.exports = Pool;

package/lib/srp.d.ts

@@ -0,0 +1,51 @@
+export interface KeyPair {
+    public: bigint;
+    private: bigint;
+}
+export interface ClientProof {
+    clientSessionKey: bigint;
+    authData: bigint;
+}
+/**
+ * Generate a client key pair.
+ *
+ * @param a BigInt Client private key.
+ * @returns {{private: BigInt, public: BigInt}}
+ */
+export declare function clientSeed(a?: bigint): KeyPair;
+/**
+ * Generate a server key pair.
+ *
+ * @param user string Connection username.
+ * @param password string Connection password.
+ * @param salt BigInt Connection salt.
+ * @param b BigInt Server private key.
+ * @returns {{private: BigInt, public: BigInt}}
+ */
+export declare function serverSeed(user: string, password: string, salt: Buffer, b?: bigint | string, hashAlgo?: string): KeyPair;
+/**
+ * Server session secret.
+ *
+ * @param user string Connection username.
+ * @param password string Connection password.
+ * @param salt BigInt Connection salt.
+ * @param A BigInt Client public key.
+ * @param B BigInt Server public key.
+ * @param b BigInt Server private key.
+ * @returns {BigInt}
+ */
+export declare function serverSession(user: string, password: string, salt: Buffer, A: bigint, B: bigint, b: bigint, hashAlgo?: string): bigint;
+/**
+ * M = H(H(N) xor H(g), H(I), s, A, B, K)
+ */
+export declare function clientProof(user: string, password: string, salt: Buffer, A: bigint, B: bigint, a: bigint, hashAlgo?: string): ClientProof;
+/**
+ *  Pad hex string.
+ */
+export declare function hexPad(hex: string): string;
+/**
+ * The SRP prime modulus N (1024-bit, same value used by Firebird).
+ * Exported so tests and tooling can assert key-size invariants without
+ * duplicating the constant.
+ */
+export declare const PRIME_N: bigint;