oracledb 6.0.3 → 6.1.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

@@ -847,7 +847,7 @@ class BaseBuffer {
     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));
+      const base100Digit = Number(value.substring(i, i + 2));
       if (isNegative) {
         buf[pos] = 101 - base100Digit;
       } else {
@@ -923,6 +923,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()
   //

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,

package/lib/thin/protocol/encryptDecrypt.js

@@ -50,9 +50,9 @@ class EncryptDecrypt {
   }
 
   _encrypt(key, val, padding) {
-    let block_size = 16;
+    const block_size = 16;
     const iv = Buffer.alloc(block_size, 0);
-    let n = block_size - (val.length % block_size);
+    const n = block_size - (val.length % block_size);
     const nv = Buffer.alloc(n, n);
     if (n > 0) {
       if (padding) {
@@ -73,15 +73,15 @@ class EncryptDecrypt {
 
   // Encrypt password and newPassword using comboKey
   _setEncryptedPasswordBuffers(passwordBytes, newPasswordBytes, comboKey, authObj) {
-    let salt = Buffer.alloc(16);
+    const salt = Buffer.alloc(16);
     crypto.randomFillSync(salt, 0, 16);
-    let temp = Buffer.concat([salt, passwordBytes]);
+    const temp = Buffer.concat([salt, passwordBytes]);
     authObj.encodedPassword = this._encrypt(comboKey, temp);
     temp.fill(0);
     authObj.encodedPassword = authObj.encodedPassword.slice().toString('hex').toUpperCase();
 
     if (newPasswordBytes) {
-      let newPasswordWithSalt = Buffer.concat([salt, newPasswordBytes]);
+      const newPasswordWithSalt = Buffer.concat([salt, newPasswordBytes]);
       authObj.encodedNewPassword = this._encrypt(comboKey, newPasswordWithSalt);
       newPasswordWithSalt.fill(0);
       authObj.encodedNewPassword = authObj.encodedNewPassword.slice().toString('hex').toUpperCase();
@@ -106,10 +106,10 @@ class EncryptDecrypt {
     let keyLen = 32;
     let hashAlg = 'sha512';
 
-    let verifierData = Buffer.from(sessionData['AUTH_VFR_DATA'], 'hex');
-    let encodedServerKey = Buffer.from(sessionData['AUTH_SESSKEY'], 'hex');
+    const verifierData = Buffer.from(sessionData['AUTH_VFR_DATA'], 'hex');
+    const encodedServerKey = Buffer.from(sessionData['AUTH_SESSKEY'], 'hex');
     let iterations = Number(sessionData['AUTH_PBKDF2_VGEN_COUNT']);
-    let passwordBytes = Buffer.from(password, 'utf8');
+    const passwordBytes = Buffer.from(password, 'utf8');
     let passwordHash;
     let passwordKey;
 
@@ -117,18 +117,18 @@ class EncryptDecrypt {
       algorithm = 'aes-192-cbc';
       keyLen = 24;
       hashAlg = 'sha1';
-      let h = crypto.createHash(hashAlg);
+      const h = crypto.createHash(hashAlg);
       h.update(passwordBytes);
       h.update(verifierData);
-      let ph = h.digest();
+      const ph = h.digest();
       passwordHash = Buffer.alloc(ph.length + 4);
       ph.copy(passwordHash, 0, 0, ph.length);
     } else {
       algorithm = 'aes-256-cbc';
-      let temp = Buffer.from('AUTH_PBKDF2_SPEEDY_KEY', 'utf8');
-      let salt = Buffer.concat([verifierData, temp]);
+      const temp = Buffer.from('AUTH_PBKDF2_SPEEDY_KEY', 'utf8');
+      const salt = Buffer.concat([verifierData, temp]);
       passwordKey = crypto.pbkdf2Sync(passwordBytes, salt, iterations, 64, 'sha512');
-      let h = crypto.createHash(hashAlg);
+      const h = crypto.createHash(hashAlg);
       h.update(passwordKey);
       h.update(verifierData);
       passwordHash = h.digest().slice(0, keyLen);
@@ -163,10 +163,10 @@ class EncryptDecrypt {
         iterations, keyLen, 'sha512');
     }
 
-    let salt = Buffer.alloc(16);
+    const salt = Buffer.alloc(16);
     if (!verifier11G) {
       crypto.randomFillSync(salt, 0, 16);
-      let temp = Buffer.concat([salt, passwordKey]);
+      const temp = Buffer.concat([salt, passwordKey]);
       authObj.speedyKey = this._encrypt(authObj.comboKey, temp);
       authObj.speedyKey = authObj.speedyKey.slice(0, 80).toString('hex').toUpperCase();
     }
@@ -184,7 +184,7 @@ class EncryptDecrypt {
   }
 
   updatePasswordsWithComboKey(password, newPassword, comboKey, authObj) {
-    let passwordBytes = Buffer.from(password, 'utf8');
+    const passwordBytes = Buffer.from(password, 'utf8');
     let newPasswordBytes;
     if (newPassword) {
       newPasswordBytes = Buffer.from(newPassword, 'utf8');
@@ -193,5 +193,5 @@ class EncryptDecrypt {
   }
 }
 
-let encryptDecryptInst = new EncryptDecrypt();
+const encryptDecryptInst = new EncryptDecrypt();
 module.exports = encryptDecryptInst;

package/lib/thin/protocol/messages/auth.js

@@ -103,32 +103,32 @@ class AuthMessage extends Message {
     }
     this.serviceName = this.conn.serviceName;
     this.remoteAddress = this.conn.remoteAddress;
-    this.setAuthMode();
+    this.setAuthMode(config);
   }
 
-  setAuthMode() {
+  setAuthMode(config) {
     if (!this.newPassword) {
       this.authMode = constants.TNS_AUTH_MODE_LOGON;
     }
-    if (this.conn.privilege & constants.SYSDBA) {
+    if (config.privilege & constants.SYSDBA) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSDBA;
     }
-    if (this.conn.privilege & constants.SYSOPER) {
+    if (config.privilege & constants.SYSOPER) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSOPER;
     }
-    if (this.conn.privilege & constants.SYSASM) {
+    if (config.privilege & constants.SYSASM) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSASM;
     }
-    if (this.conn.privilege & constants.SYSBKP) {
+    if (config.privilege & constants.SYSBKP) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSBKP;
     }
-    if (this.conn.privilege & constants.SYSDG) {
+    if (config.privilege & constants.SYSDG) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSDGD;
     }
-    if (this.conn.privilege & constants.SYSKM) {
+    if (config.privilege & constants.SYSKM) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSKMT;
     }
-    if (this.conn.privilege & constants.SYSRAC) {
+    if (config.privilege & constants.SYSRAC) {
       this.authMode |= constants.TNS_AUTH_MODE_SYSRAC;
     }
     if (this.privateKey) {
@@ -221,7 +221,7 @@ class AuthMessage extends Message {
         if (this.privateKey) {
           numPairs += 2;
         }
-        if (this.conn.connClass) {
+        if (this.conn.connectionClass) {
           numPairs += 1;
         }
         if (this.conn.purity) {
@@ -268,8 +268,8 @@ class AuthMessage extends Message {
       if (this.encodedNewPassword) {
         buf.writeKeyValue("AUTH_NEWPASSWORD", this.encodedNewPassword);
       }
-      if (this.conn.connClass) {
-        buf.writeKeyValue("AUTH_KPPL_CONN_CLASS", this.conn.connClass);
+      if (this.conn.connectionClass) {
+        buf.writeKeyValue("AUTH_KPPL_CONN_CLASS", this.conn.connectionClass);
       }
       if (this.conn.purity) {
         buf.writeKeyValue("AUTH_KPPL_PURITY", '' + this.conn.purity);
@@ -278,11 +278,11 @@ class AuthMessage extends Message {
         const currentDate = new Date();
         const currentDateFormatted = currentDate.toGMTString();
 
-        let header = "date: " + currentDateFormatted + "\n" +
+        const header = "date: " + currentDateFormatted + "\n" +
           "(request-target): " + this.serviceName  + "\n" +
           "host: " + this.remoteAddress;
 
-        let signature = crypto.createSign('RSA-SHA256')
+        const signature = crypto.createSign('RSA-SHA256')
           .update(header)
           .sign(this.privateKey, 'base64');
 
@@ -297,16 +297,16 @@ class AuthMessage extends Message {
   }
 
   processReturnParameter(buf) {
-    let numParams = buf.readUB2();
+    const numParams = buf.readUB2();
     for (let i = 0; i < numParams;i++) {
       buf.skipUB4();
-      let key = buf.readStr(constants.CSFRM_IMPLICIT);
+      const key = buf.readStr(constants.CSFRM_IMPLICIT);
       let value = "";
-      let numBytes = buf.readUB4();
+      const numBytes = buf.readUB4();
       if (numBytes > 0) {
         value = buf.readStr(constants.CSFRM_IMPLICIT);
       }
-      let flag = buf.readUB4();
+      const flag = buf.readUB4();
       if (key === "AUTH_VFR_DATA") {
         this.verifierType = flag;
       }
@@ -316,16 +316,14 @@ class AuthMessage extends Message {
     if (this.functionCode === constants.TNS_FUNC_AUTH_PHASE_ONE) {
       this.functionCode = constants.TNS_FUNC_AUTH_PHASE_TWO;
     } else {
-      let versionNum;
       let releaseNum;
       let updateNum;
       let portReleaseNum;
       let portUpdateNum;
 
-      this.conn.sessionID = this.sessionData['AUTH_SESSION_ID'];
-      this.conn.serialNum = this.sessionData['AUTH_SERIAL_NUM'];
-      let fullVersionNum = Number(this.sessionData['AUTH_VERSION_NO']);
-      versionNum = (fullVersionNum >> 24) & 0xFF;
+      this.conn.instanceName = this.sessionData['AUTH_INSTANCENAME'];
+      const fullVersionNum = Number(this.sessionData['AUTH_VERSION_NO']);
+      const versionNum = (fullVersionNum >> 24) & 0xFF;
       if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_18_1_EXT_1) {
         releaseNum = (fullVersionNum >> 16) & 0xFF;
         updateNum = (fullVersionNum >> 12) & 0x0F;