oracledb 6.0.3 → 6.2.0

package/lib/thin/pool.js

@@ -36,6 +36,7 @@ const thinUtil = require('./util.js');
 const {getConnectionInfo} = require('./sqlnet/networkSession.js');
 const crypto = require('crypto');
 const EventEmitter = require('events');
+const Timers = require('timers');
 
 class ThinPoolImpl extends PoolImpl {
 
@@ -69,30 +70,33 @@ class ThinPoolImpl extends PoolImpl {
     this._privateKey = params.privateKey;
     this._obfuscatedPrivateKey = [];
     this._schedulerJob = null;
+    this._poolCloseWaiter = null;
+    this._pendingRequests = [];
+
     // password obfuscation
     if (this._password !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._password);
+      const obj = protocolUtil.setObfuscatedValue(this._password);
       this._password = obj.value;
       this._obfuscatedPassword = obj.obfuscatedValue;
       this._userConfig.password = null;
     }
     // wallet password obfuscation
     if (this._walletPassword !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._walletPassword);
+      const obj = protocolUtil.setObfuscatedValue(this._walletPassword);
       this._walletPassword = obj.value;
       this._obfuscatedWalletPassword = obj.obfuscatedValue;
       this._userConfig.walletPassword = null;
     }
     // token obfuscation
     if (this._token !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._token);
+      const obj = protocolUtil.setObfuscatedValue(this._token);
       this._token = obj.value;
       this._obfuscatedToken = obj.obfuscatedValue;
       this._userConfig.token = null;
     }
     // privateKey obfuscation
     if (this._privateKey !== undefined) {
-      let obj = protocolUtil.setObfuscatedValue(this._privateKey);
+      const obj = protocolUtil.setObfuscatedValue(this._privateKey);
       this._privateKey = obj.value;
       this._obfuscatedPrivateKey = obj.obfuscatedValue;
       this._userConfig.privateKey = null;
@@ -121,8 +125,9 @@ class ThinPoolImpl extends PoolImpl {
       this._generateConnectionClass();
     }
 
-    // create minimum connections
-    await this._growPool(this._poolMin);
+    // create a background task. It will create minimum connections in the pool
+    // and expand the pool as required.
+    this.bgThreadFunc();
   }
 
   //---------------------------------------------------------------------------
@@ -131,13 +136,13 @@ class ThinPoolImpl extends PoolImpl {
   setAccessToken(params) {
     if (params.token) {
       this._token = params.token;
-      let objToken = protocolUtil.setObfuscatedValue(this._token);
+      const objToken = protocolUtil.setObfuscatedValue(this._token);
       this._token = objToken.value;
       this._obfuscatedToken = objToken.obfuscatedValue;
     }
     if (params.privateKey) {
       this._privateKey = params.privateKey;
-      let objKey = protocolUtil.setObfuscatedValue(this._privateKey);
+      const objKey = protocolUtil.setObfuscatedValue(this._privateKey);
       this._privateKey = objKey.value;
       this._obfuscatedPrivateKey = objKey.obfuscatedValue;
     }
@@ -151,15 +156,21 @@ class ThinPoolImpl extends PoolImpl {
   async _getConnAttrs() {
     let accessToken;
     const clonedAttrs = Object.assign({}, this._userConfig);
+    // deobfuscate password
     if (clonedAttrs.password === null) {
       clonedAttrs.password = protocolUtil.getDeobfuscatedValue(this._password,
         this._obfuscatedPassword);
     }
+
+    // deobfuscate wallet password
     if (clonedAttrs.walletPassword === null) {
       clonedAttrs.walletPassword =
         protocolUtil.getDeobfuscatedValue(this._walletPassword,
           this._obfuscatedWalletPassword);
     }
+
+    // deobfuscate token and private key
+    // check for token expiry
     if (clonedAttrs.token === null) {
       clonedAttrs.token =
         protocolUtil.getDeobfuscatedValue(this._token, this._obfuscatedToken);
@@ -173,7 +184,7 @@ class ThinPoolImpl extends PoolImpl {
               errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
             } else {
               // update pool with OAuth2 token
-              let obj = protocolUtil.setObfuscatedValue(clonedAttrs.token);
+              const obj = protocolUtil.setObfuscatedValue(clonedAttrs.token);
               this._token = obj.value;
               this._obfuscatedToken = obj.obfuscatedValue;
             }
@@ -185,11 +196,11 @@ class ThinPoolImpl extends PoolImpl {
               errors.throwErr(errors.ERR_TOKEN_HAS_EXPIRED);
             } else {
               // update pool with IAM token and private key
-              let objToken = protocolUtil.setObfuscatedValue(clonedAttrs.token);
+              const objToken = protocolUtil.setObfuscatedValue(clonedAttrs.token);
               this._token = objToken.value;
               this._obfuscatedToken = objToken.obfuscatedValue;
 
-              let objKey = protocolUtil.setObfuscatedValue(clonedAttrs.privateKey);
+              const objKey = protocolUtil.setObfuscatedValue(clonedAttrs.privateKey);
               this._privateKey = objKey.value;
               this._obfuscatedPrivateKey = objKey.obfuscatedValue;
             }
@@ -228,13 +239,34 @@ class ThinPoolImpl extends PoolImpl {
   //---------------------------------------------------------------------------
   // close pool by destroying available connections
   //---------------------------------------------------------------------------
-  async close(obj) {
+  async close() {
+
+    // wait till background task for pool expansion is finished; if it is not
+    // currently running, wake it up!
+    await new Promise((resolve) => {
+      this._poolCloseWaiter = resolve;
+      if (this.bgWaiter) {
+        this.bgWaiter();
+      }
+    });
+
     // clear scheduled job
     if (this._schedulerJob) {
       clearTimeout(this._schedulerJob);
       this._schedulerJob = null;
     }
-    return await this.destroyAllNow(obj);
+
+    // destroy all free connections
+    for (const conn of this._freeConnectionList) {
+      await this._destroy(conn);
+    }
+
+    // destroy all used connections
+    for (const conn of this._usedConnectionList) {
+      await this._destroy(conn);
+    }
+
+    this.eventEmitter.removeAllListeners();
   }
 
   //---------------------------------------------------------------------------
@@ -307,25 +339,6 @@ class ThinPoolImpl extends PoolImpl {
     return this._stmtCacheSize;
   }
 
-  //---------------------------------------------------------------------------
-  // _growPool()
-  //
-  // Grows the pool to include the specified number of connections.
-  //---------------------------------------------------------------------------
-  async _growPool(numConns) {
-    const clonedAttrs = await this._getConnAttrs();
-    while (numConns > 0) {
-      const conn = new ThinConnectionImpl();
-      conn._pool = this;
-      await conn.connect(clonedAttrs);
-      conn._newSession = true;
-      conn._dropSess = false;
-      conn._lastTimeUsed = Date.now();
-      this._freeConnectionList.push(conn);
-      numConns--;
-    }
-  }
-
   //---------------------------------------------------------------------------
   // _setScheduler()
   //
@@ -363,6 +376,94 @@ class ThinPoolImpl extends PoolImpl {
     this._setScheduler();
   }
 
+  //---------------------------------------------------------------------------
+  // _getNumConns()
+  //
+  // get number of connections need to be created
+  //---------------------------------------------------------------------------
+  _getNumConns() {
+    const usedConns = this._freeConnectionList.length + this._usedConnectionList.size;
+    // less connections in the pool than poolMin? restore to poolMin
+    if (usedConns < this._poolMin) {
+      return this._poolMin - usedConns;
+    // connections need to be created? create up to poolIncrement without exceeding poolMax
+    } else if (this._pendingRequests.length > 0) {
+      return Math.min(this._poolIncrement, this._poolMax - usedConns);
+    // no pending requests and we are already at poolMin so nothing to do!
+    } else {
+      return 0;
+    }
+  }
+
+  //---------------------------------------------------------------------------
+  // bgThreadFunc()
+  //
+  // method which runs in a background thread and is used to create connections.
+  // When first started, it creates poolMin connections. After that, it creates
+  // poolIncrement connections up to the value of poolMax when needed.
+  // The thread terminates automatically when the pool is closed.
+  //---------------------------------------------------------------------------
+  async bgThreadFunc() {
+
+    // continue until a close request is received
+    while (!this._poolCloseWaiter) {
+      // get count for connections to be created
+      const numConns = this._getNumConns();
+
+      // connection creation is going on serially and not concurrently
+      for (let i = 0; i < numConns; i++) {
+        try {
+          // get deobfuscated value
+          const config = await this._getConnAttrs();
+          const conn = new ThinConnectionImpl();
+          conn._pool = this;
+          await conn.connect(config);
+          conn._newSession = true;
+          conn._dropSess = false;
+          conn._lastTimeUsed = Date.now();
+          this._freeConnectionList.push(conn);
+        } catch (err) {
+          this._bgErr = err;
+        }
+
+        if (this._poolIncrement > 1 && (this._poolMax - this._usedConnectionList.size
+            - this._freeConnectionList.length) > 1) {
+          this._setScheduler();
+        }
+
+        // resolve pending request
+        if (this._pendingRequests.length > 0) {
+          const payload = this._pendingRequests.shift();
+          payload.resolve();
+        }
+
+        // give an opportunity for other "threads" to do their work.
+        await new Promise((resolve) => Timers.setImmediate(resolve));
+
+        // break loop when pool is closing
+        if (this._poolCloseWaiter) {
+          break;
+        }
+      }
+
+      // when pool is closing, break from while loop
+      if (this._poolCloseWaiter) {
+        break;
+      }
+
+      // if no pending requests, wait for pending requests to appear!
+      if (this._pendingRequests.length == 0 || this._bgErr) {
+        await new Promise((resolve) => {
+          this.bgWaiter = resolve;
+        });
+        this.bgWaiter = null;
+      }
+    }
+
+    // notify the closer that the close can actually take place
+    this._poolCloseWaiter();
+  }
+
   //---------------------------------------------------------------------------
   // acquire()
   //
@@ -410,17 +511,28 @@ class ThinPoolImpl extends PoolImpl {
 
     // no free connections exist at this point; if less than poolMin
     // connections exist, grow the pool to poolMin again; otherwise, increase
-    // the pool by poolIncrement up to poolMax
-    if (this._usedConnectionList.size < this._poolMin) {
-      await this._growPool(this._poolMin - this._usedConnectionList.size);
-    } else {
-      const sizeAvailable = this._poolMax - this._usedConnectionList.size;
-      await this._growPool(Math.min(this._poolIncrement, sizeAvailable));
-      if (this._poolIncrement > 1 && sizeAvailable > 1) {
-        this._setScheduler();
+    // the pool by poolIncrement up to poolMax. We are deferring this
+    // to the background thread function!
+    await new Promise((resolve) => {
+      this._pendingRequests.push({resolve: resolve});
+      if (this.bgWaiter) {
+        // this wakes up the function to do some more work
+        this.bgWaiter();
       }
-    }
+    });
+
+    if (this._bgErr) {
+      const err = this._bgErr;
+      this._bgErr = null;
 
+      // if an error has occurred in the background thread we clear it and then,
+      // if there are more pending requests we request the background thread
+      // function to try again.
+      if (this._pendingRequests.length > 0 && this.bgWaiter) {
+        this.bgWaiter();
+      }
+      throw err;
+    }
     // return a connection from the ones that were just built
     const conn = this._freeConnectionList.pop();
     this._usedConnectionList.add(conn);
@@ -438,33 +550,6 @@ class ThinPoolImpl extends PoolImpl {
     this._setScheduler();
   }
 
-  //---------------------------------------------------------------------------
-  // destroyAllNow()
-  //
-  // called during pool close operation and close any available connection
-  // available in connection pool
-  //---------------------------------------------------------------------------
-  async destroyAllNow(obj) {
-    let conn;
-    while (this._freeConnectionList.length !== 0) {
-      conn = this._freeConnectionList.pop();
-      await this._destroy(conn);
-    }
-
-    if (obj.forceClose) {
-      for (const item of this._usedConnectionList) {
-        await this._destroy(item);
-        this._usedConnectionList.delete(item);
-      }
-    }
-
-    if (this._usedConnectionList.size !== 0) {
-      errors.throwErr(errors.ERR_POOL_HAS_BUSY_CONNECTIONS);
-    }
-
-    this.eventEmitter.removeAllListeners();
-  }
-
   //---------------------------------------------------------------------------
   // _generateConnectionClass()
   //

package/lib/thin/protocol/buffer.js

@@ -49,7 +49,7 @@ class BaseBuffer {
       this.buf = Buffer.alloc(initializer);
       this.size = 0;
       this.maxSize = initializer;
-    } else {
+    } else if (initializer) {
       this.buf = initializer;
       this.size = this.maxSize = initializer.length;
     }
@@ -548,11 +548,12 @@ class BaseBuffer {
   // remain in the buffer, the buffer is grown.
   //---------------------------------------------------------------------------
   reserveBytes(numBytes) {
-    if (numBytes > this.numBytesLeft())
+    if (numBytes > this.numBytesLeft()) {
       this._grow(this.pos + numBytes);
-    const buf = this.buf.subarray(this.pos, this.pos + numBytes);
+    }
+    const pos = this.pos;
     this.pos += numBytes;
-    return buf;
+    return pos;
   }
 
   //---------------------------------------------------------------------------
@@ -618,20 +619,20 @@ class BaseBuffer {
   //---------------------------------------------------------------------------
   writeBinaryDouble(n) {
     this.writeUInt8(8);
-    const buf = this.reserveBytes(8);
-    buf.writeDoubleBE(n);
-    if ((buf[0] & 0x80) === 0) {
-      buf[0] |= 0x80;
+    const pos = this.reserveBytes(8);
+    this.buf.writeDoubleBE(n, pos);
+    if ((this.buf[pos] & 0x80) === 0) {
+      this.buf[pos] |= 0x80;
     } else {
       // We complement the bits for a negative number
-      buf[0] ^= 0xff;
-      buf[1] ^= 0xff;
-      buf[2] ^= 0xff;
-      buf[3] ^= 0xff;
-      buf[4] ^= 0xff;
-      buf[5] ^= 0xff;
-      buf[6] ^= 0xff;
-      buf[7] ^= 0xff;
+      this.buf[pos] ^= 0xff;
+      this.buf[pos + 1] ^= 0xff;
+      this.buf[pos + 2] ^= 0xff;
+      this.buf[pos + 3] ^= 0xff;
+      this.buf[pos + 4] ^= 0xff;
+      this.buf[pos + 5] ^= 0xff;
+      this.buf[pos + 6] ^= 0xff;
+      this.buf[pos + 7] ^= 0xff;
     }
   }
 
@@ -642,16 +643,16 @@ class BaseBuffer {
   //---------------------------------------------------------------------------
   writeBinaryFloat(n) {
     this.writeUInt8(4);
-    const buf = this.reserveBytes(4);
-    buf.writeFloatBE(n);
-    if ((buf[0] & 0x80) === 0) {
-      buf[0] |= 0x80;
+    const pos = this.reserveBytes(4);
+    this.buf.writeFloatBE(n, pos);
+    if ((this.buf[pos] & 0x80) === 0) {
+      this.buf[pos] |= 0x80;
     } else {
       // We complement the bits for a negative number
-      buf[0] ^= 0xff;
-      buf[1] ^= 0xff;
-      buf[2] ^= 0xff;
-      buf[3] ^= 0xff;
+      this.buf[pos] ^= 0xff;
+      this.buf[pos + 1] ^= 0xff;
+      this.buf[pos + 2] ^= 0xff;
+      this.buf[pos + 3] ^= 0xff;
     }
   }
 
@@ -745,31 +746,31 @@ class BaseBuffer {
     if (writeLength) {
       this.writeUInt8(length);
     }
-    const ptr = this.reserveBytes(length);
+    const pos = this.reserveBytes(length);
     if (type === types.DB_TYPE_DATE || type == types.DB_TYPE_TIMESTAMP) {
       const year = date.getFullYear();
-      ptr[0] = Math.trunc(year / 100) + 100;
-      ptr[1] = year % 100 + 100;
-      ptr[2] = date.getMonth() + 1;
-      ptr[3] = date.getDate();
-      ptr[4] = date.getHours() + 1;
-      ptr[5] = date.getMinutes() + 1;
-      ptr[6] = date.getSeconds() + 1;
+      this.buf[pos] = Math.trunc(year / 100) + 100;
+      this.buf[pos + 1] = year % 100 + 100;
+      this.buf[pos + 2] = date.getMonth() + 1;
+      this.buf[pos + 3] = date.getDate();
+      this.buf[pos + 4] = date.getHours() + 1;
+      this.buf[pos + 5] = date.getMinutes() + 1;
+      this.buf[pos + 6] = date.getSeconds() + 1;
     } else {
       const year = date.getUTCFullYear();
-      ptr[0] = Math.trunc(year / 100) + 100;
-      ptr[1] = year % 100 + 100;
-      ptr[2] = date.getUTCMonth() + 1;
-      ptr[3] = date.getUTCDate();
-      ptr[4] = date.getUTCHours() + 1;
-      ptr[5] = date.getUTCMinutes() + 1;
-      ptr[6] = date.getUTCSeconds() + 1;
+      this.buf[pos] = Math.trunc(year / 100) + 100;
+      this.buf[pos + 1] = year % 100 + 100;
+      this.buf[pos + 2] = date.getUTCMonth() + 1;
+      this.buf[pos + 3] = date.getUTCDate();
+      this.buf[pos + 4] = date.getUTCHours() + 1;
+      this.buf[pos + 5] = date.getUTCMinutes() + 1;
+      this.buf[pos + 6] = date.getUTCSeconds() + 1;
     }
     if (length > 7) {
-      ptr.writeInt32BE(fsec, 7);
+      this.buf.writeInt32BE(fsec, pos + 7);
       if (length > 11) {
-        ptr[11] = constants.TZ_HOUR_OFFSET;
-        ptr[12] = constants.TZ_MINUTE_OFFSET;
+        this.buf[pos + 11] = constants.TZ_HOUR_OFFSET;
+        this.buf[pos + 12] = constants.TZ_MINUTE_OFFSET;
       }
     }
   }
@@ -843,19 +844,19 @@ class BaseBuffer {
     } else if (value.length === 0 && exponent === 0) {
       exponentOnWire = 128;
     }
-    const buf = this.reserveBytes(numPairs + 2 + appendSentinel);
-    buf[0] = numPairs + 1 + appendSentinel;
-    buf[1] = exponentOnWire;
-    for (let i = 0, pos = 2; i < value.length; i += 2, pos++) {
-      let base100Digit = Number(value.substring(i, i + 2));
+    let pos = this.reserveBytes(numPairs + 2 + appendSentinel);
+    this.buf[pos++] = numPairs + 1 + appendSentinel;
+    this.buf[pos++] = exponentOnWire;
+    for (let i = 0; i < value.length; i += 2) {
+      const base100Digit = Number(value.substring(i, i + 2));
       if (isNegative) {
-        buf[pos] = 101 - base100Digit;
+        this.buf[pos++] = 101 - base100Digit;
       } else {
-        buf[pos] = base100Digit + 1;
+        this.buf[pos++] = base100Digit + 1;
       }
     }
     if (appendSentinel) {
-      buf[buf.length - 1] = 102;
+      this.buf[pos] = 102;
     }
 
   }
@@ -898,8 +899,8 @@ class BaseBuffer {
   // Writes a signed 32-bit integer to the buffer in big endian order.
   //---------------------------------------------------------------------------
   writeInt32BE(n) {
-    const buf = this.reserveBytes(4);
-    buf.writeInt32BE(n);
+    const pos = this.reserveBytes(4);
+    this.buf.writeInt32BE(n, pos);
   }
 
   //---------------------------------------------------------------------------
@@ -923,6 +924,24 @@ class BaseBuffer {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // writeUB2()
+  //
+  // Writes an unsigned integer (up to 2 bytes in length) in variable length
+  // format to the buffer.
+  //---------------------------------------------------------------------------
+  writeUB2(value) {
+    if (value === 0) {
+      this.writeUInt8(0);
+    } else if (value <= 0xff) {
+      this.writeUInt8(1);
+      this.writeUInt8(value);
+    } else {
+      this.writeUInt8(2);
+      this.writeUInt16BE(value);
+    }
+  }
+
   //---------------------------------------------------------------------------
   // writeUB8()
   //
@@ -953,8 +972,8 @@ class BaseBuffer {
   // Writes an unsigned 8-bit integer to the buffer.
   //---------------------------------------------------------------------------
   writeUInt8(n) {
-    const buf = this.reserveBytes(1);
-    buf[0] = n;
+    const pos = this.reserveBytes(1);
+    this.buf[pos] = n;
   }
 
   //---------------------------------------------------------------------------
@@ -963,8 +982,8 @@ class BaseBuffer {
   // Writes an unsigned 16-bit integer to the buffer in big endian order.
   //---------------------------------------------------------------------------
   writeUInt16BE(n) {
-    const buf = this.reserveBytes(2);
-    buf.writeUInt16BE(n);
+    const pos = this.reserveBytes(2);
+    this.buf.writeUInt16BE(n, pos);
   }
 
   //---------------------------------------------------------------------------
@@ -973,8 +992,8 @@ class BaseBuffer {
   // Writes an unsigned 32-bit integer to the buffer in big endian order.
   //---------------------------------------------------------------------------
   writeUInt32BE(n) {
-    const buf = this.reserveBytes(4);
-    buf.writeUInt32BE(n);
+    const pos = this.reserveBytes(4);
+    this.buf.writeUInt32BE(n, pos);
   }
 
   //---------------------------------------------------------------------------
@@ -985,9 +1004,9 @@ class BaseBuffer {
   // higher order bits are simply written as 0.
   //---------------------------------------------------------------------------
   writeUInt64BE(n) {
-    const buf = this.reserveBytes(8);
-    buf.writeUInt32BE(0);
-    buf.writeUInt32BE(n, 4);
+    const pos = this.reserveBytes(8);
+    this.buf.writeUInt32BE(0, pos);
+    this.buf.writeUInt32BE(n, pos + 4);
   }
 
   //---------------------------------------------------------------------------
@@ -996,8 +1015,8 @@ class BaseBuffer {
   // Writes an unsigned 16-bit integer to the buffer in little endian order.
   //---------------------------------------------------------------------------
   writeUInt16LE(n) {
-    const buf = this.reserveBytes(2);
-    buf.writeUInt16LE(n);
+    const pos = this.reserveBytes(2);
+    this.buf.writeUInt16LE(n, pos);
   }
 
 }
@@ -1030,7 +1049,7 @@ class GrowableBuffer extends BaseBuffer {
     if (remainder > 0) {
       numBytes += (constants.BUFFER_CHUNK_SIZE - remainder);
     }
-    const buf = Buffer.alloc(numBytes);
+    const buf = Buffer.allocUnsafe(numBytes);
     this.buf.copy(buf);
     this.buf = buf;
     this.maxSize = this.size = numBytes;

package/lib/thin/protocol/constants.js

@@ -89,10 +89,6 @@ module.exports = {
   TNS_PACKET_TYPE_MARKER: 12,
   TNS_PACKET_TYPE_CONTROL: 14,
 
-  // marker types
-  TNS_MARKER_TYPE_BREAK: 1,
-  TNS_MARKER_TYPE_RESET: 2,
-
   // data types
   TNS_DATA_TYPE_DEFAULT: 0,
   TNS_DATA_TYPE_VARCHAR: 1,
@@ -429,8 +425,10 @@ module.exports = {
   TNS_MSG_TYPE_FLUSH_OUT_BINDS: 19,
   TNS_MSG_TYPE_BIT_VECTOR: 21,
   TNS_MSG_TYPE_SERVER_SIDE_PIGGYBACK: 23,
-  TNS_MSG_TYPE_IMPLICIT_RESULTSET: 27,
   TNS_MSG_TYPE_ONEWAY_FN: 26,
+  TNS_MSG_TYPE_IMPLICIT_RESULTSET: 27,
+  TNS_MSG_TYPE_RENEGOTIATE: 28,
+  TNS_MSG_TYPE_COOKIE: 30,
 
   // parameter keyword numbers,
   TNS_KEYWORD_NUM_CURRENT_SCHEMA: 168,
@@ -557,18 +555,9 @@ module.exports = {
   TNS_END_TO_END_MODULE: 0x0008,
 
   // versions
-  TNS_VERSION_DESIRED: 316,
-  TNS_VERSION_MINIMUM: 300,
   TNS_VERSION_MIN_ACCEPTED: 315,
   TNS_VERSION_MIN_LARGE_SDU: 315,
 
-  // other connection constants
-  TNS_SERVICE_OPTIONS: 0xc01,
-  TNS_PROTOCOL_CHARACTERISTICS: 0x4f98,
-  TNS_CONNECT_FLAGS: 0x8080,
-  TNS_CAN_RECV_ATTENTION: 0x0400,
-  TNS_CHECK_OOB: 0x01,
-
   // TTC functions
   TNS_FUNC_AUTH_PHASE_ONE: 118,
   TNS_FUNC_AUTH_PHASE_TWO: 115,