oracledb 6.0.3 → 6.2.0

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;

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
@@ -172,7 +148,7 @@ 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.CSFRM_IMPLICIT);
@@ -224,18 +200,19 @@ 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) {
-      buf.skipUB2();
-      buf.skipBytesChunked();
+      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();
@@ -247,20 +224,20 @@ class Message {
           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();
@@ -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) {
@@ -471,6 +448,13 @@ class Message {
     }
     return writtenBytes;
   }
+
+  // Called when an error is encountered during decode of RPC
+  saveDeferredErr() {
+    if (!this.deferredErr) {
+      this.deferredErr = errors.getErr(...arguments);
+    }
+  }
 }
 
 module.exports = Message;

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]);

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

@@ -65,8 +65,8 @@ class ExecuteMessage extends MessageWithData {
     let numParams = 0;
     let numIters = 1;
     // Configuring the options field thats send to the server
-    let stmt = this.statement;
-    let params = stmt.bindInfoList;
+    const stmt = this.statement;
+    const params = stmt.bindInfoList;
 
     if (!stmt.requiresDefine && !this.parseOnly && params) {
       numParams = params.length;
@@ -223,7 +223,7 @@ class ExecuteMessage extends MessageWithData {
   // Write the message header for a re-execute and return the bind parameters.
   //-------------------------------------------------------------------------
   writeReExecuteMessage(buf) {
-    let stmt = this.statement;
+    const stmt = this.statement;
     let params = stmt.bindInfoList;
     let execFlag1 = 0, execFlag2 = 0, numIters;
     if (params !== undefined) {
@@ -236,7 +236,7 @@ class ExecuteMessage extends MessageWithData {
         });
       }
 
-      let tmpparams = [];
+      const tmpparams = [];
       params.forEach(info => {
         if (info.bindDir !== constants.TNS_BIND_DIR_OUTPUT && !info.isReturnBind) {
           tmpparams.push(info);
@@ -274,9 +274,9 @@ class ExecuteMessage extends MessageWithData {
 
     // no rows have yet been sent so the header information needs to be sent
     if (this.currentRow === 0) {
-      let stmt = this.statement;
-      if (stmt.cursorId !== 0 && !stmt.requiresFullExecute && !this.parseOnly && !stmt.requiresDefine && !stmt.isDdl && !this.batchErrors) {
-        if (stmt.isQuery && !stmt.requiresDefine && !stmt.noPrefetch && this.options.prefetchRows > 0) {
+      const stmt = this.statement;
+      if (stmt.cursorId !== 0 && !stmt.requiresFullExecute && !this.parseOnly && !stmt.requiresDefine && !stmt.noPrefetch && !stmt.isDdl && !this.batchErrors) {
+        if (stmt.isQuery && this.options.prefetchRows > 0) {
           this.functionCode = constants.TNS_FUNC_REEXECUTE_AND_FETCH;
         } else {
           this.functionCode = constants.TNS_FUNC_REEXECUTE;

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

@@ -37,10 +37,12 @@ const PingMessage = require('./ping.js');
 const ProtocolMessage = require('./protocol.js');
 const RollbackMessage = require('./rollback.js');
 const SessionReleaseMessage = require('./sessionRelease.js');
+const ConnectionCookieMessage = require('./connectionCookie.js');
 
 module.exports = {
   AuthMessage,
   CommitMessage,
+  ConnectionCookieMessage,
   DataTypeMessage,
   ExecuteMessage,
   FetchMessage,

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

@@ -50,26 +50,37 @@ class ProtocolMessage extends Message {
     buf.writeUInt8(0);
   }
 
-  decode(buf) {
-    let message_type = buf.readUInt8();
-    if (message_type === constants.TNS_MSG_TYPE_PROTOCOL) {
-      buf.skipBytes(2);                         // skip protocol array
-      let x = buf.readUInt8();
-      while (x !== 0) {                         // skip server banner
-        x = buf.readUInt8();
-      }
-      buf.skipBytes(2);                         // character set ID
-      buf.skipUB1(1);                           // skip server flags
-      let num_elem = buf.readUInt16LE();
-      if (num_elem > 0) {                       // skip elements
-        buf.skipBytes(num_elem * 5);
-      }
-      let fdoLen = buf.readUInt16BE();
-      let fdo = buf.readBytes(fdoLen);
-      let ix = 6 + fdo[5] + fdo[6];
-      buf.caps.nCharsetId = (fdo[ix + 3] << 8) + fdo[ix + 4];
-      buf.caps.adjustForServerCompileCaps(buf.readBytesWithLength());
-      buf.caps.adjustForServerRuntimeCaps(buf.readBytesWithLength());
+  processMessage(buf, messageType) {
+    if (messageType === constants.TNS_MSG_TYPE_PROTOCOL) {
+      this.processProtocolInfo(buf);
+    } else {
+      super.processMessage(buf, messageType);
+    }
+  }
+
+  processProtocolInfo(buf) {
+    this.serverVersion = buf.readUInt8();
+    buf.skipUB1();
+    this.serverBanner = buf.readNullTerminatedBytes(48);
+    buf.caps.charSetID = buf.readUInt16LE();
+    this.serverFlags = buf.readUInt8();
+    const num_elem = buf.readUInt16LE();
+    if (num_elem > 0) {                       // skip elements
+      buf.skipBytes(num_elem * 5);
+    }
+    const fdoLen = buf.readUInt16BE();
+    const fdo = buf.readBytes(fdoLen);
+    const ix = 6 + fdo[5] + fdo[6];
+    buf.caps.nCharsetId = (fdo[ix + 3] << 8) + fdo[ix + 4];
+    const serverCompileCaps = buf.readBytesWithLength();
+    if (serverCompileCaps) {
+      this.serverCompileCaps = Buffer.from(serverCompileCaps);
+      buf.caps.adjustForServerCompileCaps(this.serverCompileCaps);
+    }
+    const serverRunTimeCaps = buf.readBytesWithLength();
+    if (serverRunTimeCaps) {
+      this.serverRunTimeCaps = Buffer.from(serverRunTimeCaps);
+      buf.caps.adjustForServerRuntimeCaps(this.serverRunTimeCaps);
     }
   }