oracledb 6.0.2 → 6.1.0

package/lib/thin/protocol/constants.js

@@ -40,7 +40,12 @@ module.exports = {
     constants.VERSION_MAJOR << 24 |
     constants.VERSION_MINOR << 20 |
     constants.VERSION_PATCH << 12,
+  CSFRM_IMPLICIT: constants.CSFRM_IMPLICIT,
+  CSFRM_NCHAR: constants.CSFRM_NCHAR,
   DRIVER_NAME: constants.DEFAULT_DRIVER_NAME + ' thn',
+  PURITY_DEFAULT: constants.PURITY_DEFAULT,
+  PURITY_NEW: constants.PURITY_NEW,
+  PURITY_SELF: constants.PURITY_SELF,
   SYSASM: constants.SYSASM,
   SYSBKP: constants.SYSBKP,
   SYSDBA: constants.SYSDBA,
@@ -84,14 +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,
-
-  // charset forms
-  TNS_CS_IMPLICIT: 1,
-  TNS_CS_NCHAR: 2,
-
   // data types
   TNS_DATA_TYPE_DEFAULT: 0,
   TNS_DATA_TYPE_VARCHAR: 1,
@@ -428,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,
@@ -556,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

@@ -29,12 +29,11 @@
 const { Buffer } = require('buffer');
 const constants = require("../constants.js");
 const errors = require("../../../errors.js");
-const os = require("os");
 const process = require("process");
 const ED = require("../encryptDecrypt.js");
 const Message = require("./base.js");
 const util = require("../../util.js");
-
+const cInfo = util.CLIENT_INFO;
 const crypto = require('crypto');
 
 /**
@@ -104,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) {
@@ -184,11 +183,10 @@ class AuthMessage extends Message {
         buf.writeBytesWithLength(Buffer.from(this.username));
       }
       buf.writeKeyValue("AUTH_TERMINAL", "unknown");
-      buf.writeKeyValue("AUTH_PROGRAM_NM", process.argv0);
-      buf.writeKeyValue("AUTH_MACHINE", os.hostname());
-      buf.writeKeyValue("AUTH_PID", process.pid.toString());
-      buf.writeKeyValue("AUTH_SID", os.userInfo().username);
-
+      buf.writeKeyValue("AUTH_PROGRAM_NM", cInfo.program);
+      buf.writeKeyValue("AUTH_MACHINE", cInfo.hostName);
+      buf.writeKeyValue("AUTH_PID", cInfo.pid);
+      buf.writeKeyValue("AUTH_SID", cInfo.userName);
     } else {
       let numPairs = 0;
 
@@ -223,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) {
@@ -270,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);
@@ -280,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');
 
@@ -299,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.TNS_CS_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.TNS_CS_IMPLICIT);
+        value = buf.readStr(constants.CSFRM_IMPLICIT);
       }
-      let flag = buf.readUB4();
+      const flag = buf.readUB4();
       if (key === "AUTH_VFR_DATA") {
         this.verifierType = flag;
       }
@@ -318,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;

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

@@ -30,37 +30,13 @@ const { Buffer } = require('buffer');
 const constants = require("../constants.js");
 const errors = require("../../../errors.js");
 
-class OracleErrorInfo {
-  constructor() {
-    this.num = 0;
-    this.cursorId = 0;
-    this.pos = 0;
-    this.rowCount = 0;
-    this.message = "";
-    this.rowID = null;
-    this.batchErrors;
-  }
-}
-
-class Error {
-  constructor(num, message = "", context = "", isRecoverable = false, isWarning = false, code = 0, offset = 0) {
-    this.num = num;
-    this.message = message;
-    this.context = context;
-    this.isRecoverable = isRecoverable;
-    this.isWarning = isWarning;
-    this.code = code;
-    this.offset = offset;
-  }
-}
-
 /**
  *
  * Base class for all the RPC messages to support encode/decode functions
  */
 class Message {
   constructor(connection) {
-    this.errorInfo = new OracleErrorInfo();
+    this.errorInfo = {};
     this.connection = connection;
     this.messageType = constants.TNS_MSG_TYPE_FUNCTION;
     this.functionCode = 0;
@@ -106,7 +82,7 @@ class Message {
     buf.skipUB1();                              // call number
     buf.skipUB2();                              // padding
     buf.skipUB4();                              // success iters
-    let numBytes = buf.readUB4();               // oerrdd (logical rowid)
+    const numBytes = buf.readUB4();               // oerrdd (logical rowid)
     if (numBytes > 0) {
       buf.skipBytesChunked();
     }
@@ -114,12 +90,12 @@ class Message {
     let numEntries = buf.readUB2();             // batch error codes array
     if (numEntries > 0) {
       this.errorInfo.batchErrors = [];
-      let firstByte = buf.readUInt8();
+      const firstByte = buf.readUInt8();
       for (let i = 0; i < numEntries; i++) {
         if (firstByte === constants.TNS_LONG_LENGTH_INDICATOR) {
           buf.skipUB4();                        // chunk length ignored
         }
-        let errorCode = buf.readUB2();
+        const errorCode = buf.readUB2();
         this.errorInfo.batchErrors.push(new Error(errorCode));
       }
       if (firstByte === constants.TNS_LONG_LENGTH_INDICATOR) {
@@ -130,7 +106,7 @@ class Message {
     // batch error offset
     numEntries = buf.readUB2();                 // batch error row offset array
     if (numEntries > 0) {
-      let firstByte = buf.readUInt8();
+      const firstByte = buf.readUInt8();
       for (let i = 0; i < numEntries; i++) {
         if (firstByte === constants.TNS_LONG_LENGTH_INDICATOR) {
           buf.skipUB4();                        // chunk length ignored
@@ -149,7 +125,7 @@ class Message {
       for (let i = 0; i < numEntries; i++) {
         buf.skipUB2();                          // skip chunk length
 
-        this.errorInfo.batchErrors[i].message = buf.readStr(constants.TNS_CS_IMPLICIT);
+        this.errorInfo.batchErrors[i].message = buf.readStr(constants.CSFRM_IMPLICIT);
         buf.skipBytes(2);                       // ignore end marker
       }
     }
@@ -158,7 +134,7 @@ class Message {
     this.errorInfo.rowCount = buf.readUB8();    // row number (extended)
     if (this.errorInfo.num !== 0) {
       this.errorOccurred = true;
-      this.errorInfo.message = buf.readStr(constants.TNS_CS_IMPLICIT);
+      this.errorInfo.message = buf.readStr(constants.CSFRM_IMPLICIT);
       /*
        * Remove ending newline from ORA error message
        */
@@ -172,10 +148,10 @@ class Message {
 
   processWarningInfo(buf) {
     this.errorInfo.num = buf.readUB2();         // error number
-    let numBytes = buf.readUB2();               // length of error message
+    const numBytes = buf.readUB2();               // length of error message
     buf.skipUB2();                              // flags
     if (this.errorInfo.num != 0 && numBytes > 0) {
-      this.errorInfo.message = buf.readStr(constants.TNS_CS_IMPLICIT);
+      this.errorInfo.message = buf.readStr(constants.CSFRM_IMPLICIT);
     }
     this.errorInfo.isWarning = true;
   }
@@ -215,7 +191,7 @@ class Message {
     } else if (messageType === constants.TNS_MSG_TYPE_SERVER_SIDE_PIGGYBACK) {
       this.processServerSidePiggyBack(buf);
     } else {
-      errors.throwErr(errors.ERR_UNEXPECTED_MESSAGE_TYPE, messageType);
+      errors.throwErr(errors.ERR_UNEXPECTED_MESSAGE_TYPE, messageType, buf.pos, buf.packetNum);
     }
   }
 
@@ -224,43 +200,44 @@ class Message {
     if (opcode === constants.TNS_SERVER_PIGGYBACK_LTXID) {
       const num_bytes = buf.readUB4();
       if (num_bytes > 0) {
-        buf.skipBytes(num_bytes);
+        buf.skipBytesChunked();
       }
     } else if ((opcode === constants.TNS_SERVER_PIGGYBACK_QUERY_CACHE_INVALIDATION)
      || (opcode === constants.TNS_SERVER_PIGGYBACK_TRACE_EVENT)) {
       // pass
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_OS_PID_MTS) {
-      const nb = buf.readUB2();
-      buf.skipBytes(nb + 1);
+      const numDtys = buf.readUB2();
+      buf.skipUB1();
+      buf.skipBytes(numDtys);
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_SYNC) {
       buf.skipUB2();                            // skip number of DTYs
       buf.skipUB1();                            // skip length of DTYs
-      const num_elements = buf.readUB2();
+      const num_elements = buf.readUB4();
       buf.skipBytes(1);                         // skip length
       for (let i = 0; i < num_elements; i++) {
         let temp16 = buf.readUB2();
         if (temp16 > 0) {                       // skip key
-          buf.skipBytes(temp16 + 1);
+          buf.skipBytesChunked();
         }
         temp16 = buf.readUB2();
         if (temp16 > 0) {                       // skip value
-          buf.skipBytes(temp16 + 1);
+          buf.skipBytesChunked();
         }
         buf.skipUB2();                          // skip flags
-        buf.skipUB4();                          // skip overall flags
       }
+      buf.skipUB4();                            // skip overall flags
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_EXT_SYNC) {
       buf.skipUB2();
       buf.skipUB1();
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_AC_REPLAY_CONTEXT) {
       buf.skipUB2();                            // skip number of DTYs
-      buf.skipUB1(1);                           // skip length of DTYs
+      buf.skipUB1();                            // skip length of DTYs
       buf.skipUB4();                            // skip flags
       buf.skipUB4();                            // skip error code
       buf.skipUB1();                            // skip queue
       const num_bytes = buf.readUB4();          // skip replay context
       if (num_bytes > 0) {
-        buf.skipBytes(num_bytes);
+        buf.skipBytesChunked();
       }
     } else if (opcode === constants.TNS_SERVER_PIGGYBACK_SESS_RET) {
       buf.skipUB2();
@@ -271,11 +248,11 @@ class Message {
         for (let i = 0; i < num_elements; ++i) {
           let temp16 = buf.readUB2();
           if (temp16 > 0) {                     // skip key
-            buf.skipBytes(temp16 + 1);
+            buf.skipBytesChunked();
           }
           temp16 = buf.readUB2();
           if (temp16 > 0) {                     // skip value
-            buf.skipBytes(temp16 + 1);
+            buf.skipBytesChunked();
           }
           buf.skipUB2();                        // skip flags
         }
@@ -283,7 +260,7 @@ class Message {
       const flags = buf.readUB4();              // session flags
       if (flags & constants.TNS_SESSGET_SESSION_CHANGED) {
         if (this.connection._drcpEstablishSession) {
-          this.connection.resetStatmentCache();
+          this.connection.resetStatementCache();
         }
       }
       this.connection._drcpEstablishSession = false;
@@ -335,8 +312,8 @@ class Message {
   }
 
   writeCloseTempLobsPiggyback(buf) {
-    let lobsToClose = this.connection._tempLobsToClose;
-    let opCode = constants.TNS_LOB_OP_FREE_TEMP | constants.TNS_LOB_OP_ARRAY;
+    const lobsToClose = this.connection._tempLobsToClose;
+    const opCode = constants.TNS_LOB_OP_FREE_TEMP | constants.TNS_LOB_OP_ARRAY;
 
     this.writePiggybackHeader(buf, constants.TNS_FUNC_LOB_OP);
 
@@ -406,9 +383,9 @@ class Message {
     buf.writeUInt8(0);                  // pointer (cidser)
     buf.writeUB4(flags);
 
-    let clientIdentifierBytes = this.writeEndEndTraceValue(buf, this.connection._clientIdentifier, this.connection._clientIdentifierModified);
-    let moduleBytes = this.writeEndEndTraceValue(buf, this.connection._module, this.connection._moduleModified);
-    let actionBytes = this.writeEndEndTraceValue(buf, this.connection._action, this.connection._actionModified);
+    const clientIdentifierBytes = this.writeEndEndTraceValue(buf, this.connection._clientIdentifier, this.connection._clientIdentifierModified);
+    const moduleBytes = this.writeEndEndTraceValue(buf, this.connection._module, this.connection._moduleModified);
+    const actionBytes = this.writeEndEndTraceValue(buf, this.connection._action, this.connection._actionModified);
 
     // write unsupported bits
     buf.writeUInt8(0);                  // pointer (cideci)
@@ -416,13 +393,13 @@ class Message {
     buf.writeUInt8(0);                  // cidcct
     buf.writeUB4(0);                    // cidecs
 
-    let clientInfoBytes = this.writeEndEndTraceValue(buf, this.connection._clientInfo, this.connection._clientInfoModified);
+    const clientInfoBytes = this.writeEndEndTraceValue(buf, this.connection._clientInfo, this.connection._clientInfoModified);
     // write unsupported bits
     buf.writeUInt8(0);                  // pointer (cideci)
     buf.writeUB4(0);                    // length (cideci)
     buf.writeUInt8(0);                  // cidcct
     buf.writeUB4(0);                    // cidecs
-    let dbOpBytes = this.writeEndEndTraceValue(buf, this.connection._dbOp, this.connection._dbOpModified);
+    const dbOpBytes = this.writeEndEndTraceValue(buf, this.connection._dbOp, this.connection._dbOpModified);
 
     // write strings
     if (this.connection._clientIdentifierModified && this.connection._clientIdentifier) {

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

@@ -0,0 +1,76 @@
+// Copyright (c) 2023 Oracle and/or its affiliates.
+
+//-----------------------------------------------------------------------------
+//
+// This software is dual-licensed to you under the Universal Permissive License
+// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
+// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
+// either license.
+//
+// If you elect to accept the software under the Apache License, Version 2.0,
+// the following applies:
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const constants = require("../constants.js");
+const Message = require("./base.js");
+
+/**
+ * Executes a Fast Negotiation RPC function.
+ * It sends Protocol Negotiation, Cookie Message, Datatype Negotiation
+ * and OSESS Key RPC in single round trip.
+ *
+ * @class ConnectionCookieMessage
+ * @extends {Message}
+ */
+class ConnectionCookieMessage extends Message {
+
+  /**
+   * Serializes the ConnectionCookieMessage function arguments
+   *
+   * @param {object} buf input arguments
+   */
+  encode(buf) {
+    this.protocolMessage.encode(buf);
+    buf.writeUInt8(constants.TNS_MSG_TYPE_COOKIE);
+    buf.writeUInt8(1);                  // cookie version
+    buf.writeUInt8(this.cookie.protocolVersion);
+    buf.writeUInt16LE(this.cookie.charsetID);
+    buf.writeUInt8(this.cookie.flags);
+    buf.writeUInt16LE(this.cookie.ncharsetID);
+    buf.writeBytesWithLength(this.cookie.serverBanner);
+    buf.writeBytesWithLength(this.cookie.compileCaps);
+    buf.writeBytesWithLength(this.cookie.runtimeCaps);
+    this.dataTypeMessage.encode(buf);
+    this.authMessage.encode(buf);
+  }
+
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_RENEGOTIATE) {
+      this.cookie.populated = false;
+    } else if (messageType === constants.TNS_MSG_TYPE_PROTOCOL) {
+      this.protocolMessage.processMessage(buf, messageType);
+    } else if (messageType === constants.TNS_MSG_TYPE_DATA_TYPES) {
+      this.dataTypeMessage.processMessage(buf, messageType);
+    } else {
+      this.authMessage.processMessage(buf, messageType);
+    }
+  }
+
+}
+
+module.exports = ConnectionCookieMessage;

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

@@ -38,14 +38,18 @@ const Message = require("./base.js");
  */
 class DataTypeMessage extends Message {
 
-  processMessage(buf) {
-    while (true) {        // eslint-disable-line
-      const dataType = buf.readUInt16BE();
-      if (dataType === 0)
-        break;
-      const convDataType = buf.readUInt16BE();
-      if (convDataType !== 0)
-        buf.skipBytes(4);
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_DATA_TYPES) {
+      while (true) {        // eslint-disable-line
+        const dataType = buf.readUInt16BE();
+        if (dataType === 0)
+          break;
+        const convDataType = buf.readUInt16BE();
+        if (convDataType !== 0)
+          buf.skipBytes(4);
+      }
+    } else {
+      super.processMessage(buf, messageType);
     }
   }
 
@@ -57,7 +61,7 @@ class DataTypeMessage extends Message {
       constants.TNS_ENCODING_CONV_LENGTH);
     buf.writeBytesWithLength(buf.caps.compileCaps);
     buf.writeBytesWithLength(buf.caps.runtimeCaps);
-    for (let val of dataTypes) {
+    for (const val of dataTypes) {
       buf.writeUInt16BE(val[0]);
       buf.writeUInt16BE(val[1]);
       buf.writeUInt16BE(val[2]);