oracledb 6.0.1 → 6.0.3

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

@@ -139,7 +139,7 @@ class MessageWithData extends Message {
 
     let numBytes = buf.readUB4();
     if (numBytes > 0) {
-      buf.skipBytes(numBytes + 1);              // current date
+      buf.skipBytesChunked();                   // current date
     }
     buf.skipUB4();                              // dcbflag
     buf.skipUB4();                              // dcbmdbz
@@ -147,7 +147,7 @@ class MessageWithData extends Message {
     buf.skipUB4();                              // dcbmxpr
     numBytes = buf.readUB4();
     if (numBytes > 0) {
-      buf.skipBytes(numBytes + 1);
+      buf.skipBytesChunked();
     }
 
     this.resultSetsToSetup.push(resultSet);
@@ -173,7 +173,7 @@ class MessageWithData extends Message {
     let oid;
     let numBytes = buf.readUB4();               // OID
     if (numBytes > 0) {
-      oid = buf.readBytesWithLength();
+      oid = Buffer.from(buf.readBytesWithLength());
     }
     buf.skipUB2();                              // version
     buf.skipUB2();                              // character set id
@@ -190,17 +190,17 @@ class MessageWithData extends Message {
     let name;
     numBytes = buf.readUB4();
     if (numBytes > 0) {
-      name = buf.readStr(constants.TNS_CS_IMPLICIT);
+      name = buf.readStr(constants.CSFRM_IMPLICIT);
     }
     let schema;
     numBytes = buf.readUB4();
     if (numBytes > 0) {
-      schema = buf.readStr(constants.TNS_CS_IMPLICIT);
+      schema = buf.readStr(constants.CSFRM_IMPLICIT);
     }
     numBytes = buf.readUB4();
     let typeName;
     if (numBytes > 0) {
-      typeName = buf.readStr(constants.TNS_CS_IMPLICIT);
+      typeName = buf.readStr(constants.CSFRM_IMPLICIT);
     }
     buf.skipUB2();                              // column position
     buf.skipUB4();                              // uds flag
@@ -316,10 +316,11 @@ class MessageWithData extends Message {
   processIOVector(buf) {
     let numBytes;
     buf.skipUB1();                              // flag
-    const numBinds = buf.readUB2();             // num requests
-    this.rowIndex = buf.readUB4();              // iter num
+    const temp16 = buf.readUB2();              // num requests
+    const temp32 = buf.readUB4();              // iter num
+    const numBinds = temp32 * 256 + temp16;
     buf.skipUB4();                              // num iters this time
-    buf.readUB2();                              // uac buffer length
+    buf.skipUB2();                              // uac buffer length
     numBytes = buf.readUB2();                   // bit vector for fast fetch
     if (numBytes > 0) {
       buf.skipBytes(numBytes);
@@ -355,7 +356,7 @@ class MessageWithData extends Message {
       oraTypeNum === constants.TNS_DATA_TYPE_CHAR ||
       oraTypeNum === constants.TNS_DATA_TYPE_LONG
     ) {
-      if (csfrm === constants.TNS_CS_NCHAR) {
+      if (csfrm === constants.CSFRM_NCHAR) {
         buf.caps.checkNCharsetId();
       }
       colValue = buf.readStr(csfrm);
@@ -378,9 +379,9 @@ class MessageWithData extends Message {
       const useLocalTime = (oraTypeNum === constants.TNS_DATA_TYPE_DATE ||
         oraTypeNum === constants.TNS_DATA_TYPE_TIMESTAMP);
       colValue = buf.readOracleDate(useLocalTime);
-    }  else if (oraTypeNum === constants.TNS_DATA_TYPE_ROWID) {
+    } else if (oraTypeNum === constants.TNS_DATA_TYPE_ROWID) {
       if (!this.inFetch) {
-        colValue = buf.readStr(constants.TNS_CS_IMPLICIT);
+        colValue = buf.readStr(constants.CSFRM_IMPLICIT);
       } else {
         let numBytes = buf.readUInt8();
         if (isNullLength(numBytes)) {
@@ -392,7 +393,7 @@ class MessageWithData extends Message {
       }
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_UROWID) {
       if (!this.inFetch) {
-        colValue = buf.readStr(constants.TNS_CS_IMPLICIT);
+        colValue = buf.readStr(constants.CSFRM_IMPLICIT);
       } else {
         colValue = buf.readURowID();
       }
@@ -478,7 +479,7 @@ class MessageWithData extends Message {
     for (let i = 0; i < numParams; i++) {
       numBytes = buf.readUB2();                 // key
       if (numBytes > 0) {
-        keyTextValue = buf.readStr(constants.TNS_CS_IMPLICIT);
+        keyTextValue = buf.readStr(constants.CSFRM_IMPLICIT);
       }
       numBytes = buf.readUB2();                 // value
       if (numBytes > 0) {
@@ -546,6 +547,7 @@ class MessageWithData extends Message {
             variable.maxSize = constants.TNS_MAX_LONG_LENGTH;
           }
           resultSet.statement.requiresDefine = true;
+          resultSet.statement.noPrefetch = true;
         }
       }
     }
@@ -563,7 +565,7 @@ class MessageWithData extends Message {
 
     if (this.statement.isQuery) {
       this.inFetch = true;
-      if (this.statement.queryVars)  {
+      if (this.statement.queryVars) {
         this.outVariables = [];
         for (let i = 0; i < this.statement.queryVars.length; i++) {
           this.outVariables.push(this.statement.queryVars[i]);
@@ -582,7 +584,7 @@ class MessageWithData extends Message {
   }
 
   getBitVector(buf, numBytes) {
-    this.bitVector = buf.readBytes(numBytes);
+    this.bitVector = Buffer.from(buf.readBytes(numBytes));
   }
 
   processBindParams(buf, params) {
@@ -607,7 +609,7 @@ class MessageWithData extends Message {
       // NCHAR, NVARCHAR reports ORA-01460: unimplemented or unreasonable
       // conversion requested if maxSize is not multiplied by the
       // bufferSizeFactor
-      if (variable.type._csfrm === constants.TNS_CS_NCHAR) {
+      if (variable.type._csfrm === constants.CSFRM_NCHAR) {
         maxSize *= variable.type._bufferSizeFactor;
       }
       if ([constants.TNS_DATA_TYPE_ROWID, constants.TNS_DATA_TYPE_UROWID].includes(oraTypeNum)) {
@@ -731,7 +733,7 @@ class MessageWithData extends Message {
       oraTypeNum === constants.TNS_DATA_TYPE_LONG ||
       oraTypeNum === constants.TNS_DATA_TYPE_RAW ||
       oraTypeNum === constants.TNS_DATA_TYPE_LONG_RAW) {
-      if (variable.type._csfrm === constants.TNS_CS_NCHAR) {
+      if (variable.type._csfrm === constants.CSFRM_NCHAR) {
         buf.caps.checkNCharsetId();
         value = Buffer.from(value, constants.TNS_ENCODING_UTF16).swap16();
       } else {

package/lib/thin/protocol/packet.js

@@ -220,12 +220,17 @@ class ReadPacket extends BaseBuffer {
     }
 
     // the requested bytes are split across multiple packets; if a chunked read
-    // is not in progress one is implicitly started; copy the bytes from the
-    // end of this packet
-    if (!inChunkedRead) {
-      this.chunkedBytesBuf.startChunkedRead();
+    // is in progress, a chunk is acquired that will accommodate the requested
+    // bytes; otherwise, a separate buffer will be allocated to accommodate the
+    // requested bytes
+    let buf;
+    if (inChunkedRead) {
+      buf = this.chunkedBytesBuf.getBuf(numBytes);
+    } else {
+      buf = Buffer.alloc(numBytes);
     }
-    const buf = this.chunkedBytesBuf.getBuf(numBytes);
+
+    // copy the bytes to the buffer from the remainder of this packet
     let offset = 0;
     this.buf.copy(buf, offset, this.pos, this.pos + numBytesLeft);
     offset += numBytesLeft;
@@ -241,10 +246,7 @@ class ReadPacket extends BaseBuffer {
       numBytes -= numSplitBytes;
     }
 
-    // if not in a chunked bytes read, return the buffer directly
-    if (!inChunkedRead) {
-      return this.chunkedBytesBuf.endChunkedRead();
-    }
+    return buf;
 
   }
 
@@ -252,46 +254,48 @@ class ReadPacket extends BaseBuffer {
    * Receives a packet from the adapter.
    */
   receivePacket() {
-    if (this.savedBufferPos === this.savedBuffers.length) {
+    if (this.savedPacketPos === this.savedPackets.length) {
       const packet = this.nsi.syncRecvPacket();
-      if (!packet)
+      if (!packet || this.nsi.isBreak)
         throw new utils.OutOfPacketsError();
-      this.savedBuffers.push(packet.buf);
+      this.savedPackets.push(packet);
     }
-    this.startPacket(this.savedBuffers[this.savedBufferPos++]);
+    this.startPacket(this.savedPackets[this.savedPacketPos++]);
   }
 
   restorePoint() {
-    this.savedBufferPos = 0;
-    this.startPacket(this.savedBuffers[this.savedBufferPos++]);
+    this.savedPacketPos = 0;
+    this.startPacket(this.savedPackets[this.savedPacketPos++]);
     this.pos = this.savedPos;
   }
 
   savePoint() {
-    if (this.savedBuffers) {
-      this.savedBuffers = this.savedBuffers.splice(this.savedBufferPos - 1);
+    if (this.savedPackets) {
+      this.savedPackets = this.savedPackets.splice(this.savedPacketPos - 1);
     } else {
-      this.savedBuffers = [this.buf];
+      this.savedPackets = [this.packet];
     }
-    this.savedBufferPos = 1;
+    this.savedPacketPos = 1;
     this.savedPos = this.pos;
   }
 
-  startPacket(buf) {
-    this.buf = buf;
+  startPacket(packet) {
+    this.packet = packet;
+    this.buf = packet.buf;
     this.pos = 10;                      // skip packet heaader and data flags
-    this.size = buf.length;
+    this.size = packet.buf.length;
+    this.packetNum = packet.num;
   }
 
   async waitForPackets() {
     const packet = await this.nsi.recvPacket();
-    if (!this.savedBuffers) {
-      this.savedBuffers = [packet.buf];
-      this.savedBufferPos = 0;
+    if (!this.savedPackets) {
+      this.savedPackets = [packet];
+      this.savedPacketPos = 0;
     } else {
-      this.savedBuffers.push(packet.buf);
+      this.savedPackets.push(packet);
     }
-    this.startPacket(this.savedBuffers[this.savedBufferPos++]);
+    this.startPacket(this.savedPackets[this.savedPacketPos++]);
   }
 
   /**

package/lib/thin/protocol/protocol.js

@@ -71,6 +71,7 @@ class Protocol {
     while (true) {     // eslint-disable-line
       if (this.nsi.isBreak) {
         await this.resetMessage();
+        delete this.readBuf.savedBuffers;
         await this.readBuf.waitForPackets();
       }
       try {
@@ -78,8 +79,10 @@ class Protocol {
         break;
       } catch (err) {
         if (err instanceof utils.OutOfPacketsError) {
-          await this.readBuf.waitForPackets();
-          this.readBuf.restorePoint();
+          if (!this.nsi.isBreak) {
+            await this.readBuf.waitForPackets();
+            this.readBuf.restorePoint();
+          }
           continue;
         }
         throw (err);
@@ -108,7 +111,7 @@ class Protocol {
     this.writeBuf.endRequest();
   }
 
-  async _recoverFromError(message) {
+  async _recoverFromError(caughtErr, message) {
     /*
      * We have NJS error(protocol related) detected during packet write/read
      * operation.  Issue a break and reset to clear channel . We receive the
@@ -121,10 +124,12 @@ class Protocol {
       await this.readBuf.waitForPackets();
       message.decode(this.readBuf);
     } catch (err) { // Recovery failed
-    // TODO: throw different error indicating that reset failed, probably
-    // put inside resetMessage()
       this.nsi.disconnect();
-      errors.throwErr(errors.ERR_CONNECTION_CLOSED);
+      const newErr = errors.getErr(errors.ERR_CONNECTION_CLOSED);
+      caughtErr.message = newErr.message +
+        "\nError recovery failed: " + err.message +
+        "\nOriginal error: " + caughtErr.message;
+      throw caughtErr;
     }
   }
 
@@ -150,7 +155,7 @@ class Protocol {
     } catch (err) {
       if (!this.connInProgress &&
           err.code !== errors.ERR_CONNECTION_CLOSED_CODE) {
-        await this._recoverFromError(message);
+        await this._recoverFromError(err, message);
       }
       throw err;
     } finally {

package/lib/thin/sqlnet/connStrategy.js

@@ -28,8 +28,7 @@
 
 const { NavAddress, NavAddressList, NavDescription, NavDescriptionList } = require("./navNodes.js");
 const { createNVPair } = require("./nvStrToNvPair.js");
-
-
+const errors = require("../../errors.js");
 
 /**
  * Class that holds all possible attributes under Description
@@ -166,6 +165,9 @@ async function createNode(str) {
     case "DESCRIPTION_LIST":
       navobj = new NavDescriptionList();
       break;
+    default:
+      errors.throwErr(errors.ERR_INVALID_CONNECT_STRING_PARAMETERS,
+        `unknown top element ${arg}`);
   }
   navobj.initFromNVPair(nvpair);
   let cs = new ConnStrategy();

package/lib/thin/sqlnet/ezConnectResolver.js

@@ -39,8 +39,7 @@ Test Case in oracle_private/ezconnectTest.js
 const HOSTNAMES_PATTERN = new RegExp("((?=(?<hostnames>(((\\[[A-z0-9:]+\\])|([A-z0-9][A-z0-9._-]+))[,]?)+)))\\k<hostnames>(:(?<port>\\d+)?)?", 'g');
 
 // The EZConnect pattern without the extended settings part.
-const EZ_URL_PATTERN = new RegExp("^((?<protocol>tcp|tcps):)?"
-    + "(//)?"
+const EZ_URL_PATTERN = new RegExp("^(((?<protocol>[A-z0-9]+):)?//)?"
     + "(?<hostinfo>(" + HOSTNAMES_PATTERN.source + "(?=([,]|[;]|[/]|[:]|$))([,]|[;])?)+)"
     + "(/(?<servicename>[A-z0-9][A-z0-9,-.]+)?)"
     + "?(:(?<servermode>dedicated|shared|pooled))"
@@ -145,8 +144,9 @@ class EZConnectResolver {
     if (protocol == null) {
       if (!(url.includes("//")))
         protocol = 'TCP';
+    } else if (protocol.toLowerCase() != 'tcp' && protocol.toLowerCase() != 'tcps') {
+      errors.throwErr(errors.ERR_INVALID_EZCONNECT_SYNTAX, 'Unsupported protocol in thin mode', protocol);
     }
-
     // Try to get the proxy information from URL properties
     const proxyHost = this.urlProps.get("HTTPS_PROXY");
     const proxyPort = this.urlProps.get("HTTPS_PROXY_PORT");
@@ -216,8 +216,12 @@ class EZConnectResolver {
     let ipcnt = 0;
     let builder = new Array();
     let proxyInfo = '';
-    if (proxyHost != null && proxyPort != null) {
-      proxyInfo = `(HTTPS_PROXY=${proxyHost})(HTTPS_PROXY_PORT=${proxyPort})`;
+    if (proxyHost != null) {
+      if (proxyPort != null) {
+        proxyInfo = `(HTTPS_PROXY=${proxyHost})(HTTPS_PROXY_PORT=${proxyPort})`;
+      } else {
+        proxyInfo = `(HTTPS_PROXY=${proxyHost})`;
+      }
     }
 
     if (protocol == null) protocol = 'TCP';

package/lib/thin/sqlnet/navNodes.js

@@ -32,6 +32,7 @@ const os = require("os");
 const net = require('net');
 const dns = require('dns');
 const dnsPromises = dns.promises;
+const cInfo = require("../util.js").CLIENT_INFO;
 
 const SchemaObjectFactoryInterface = {
   ADDR:0,
@@ -443,7 +444,6 @@ const NavSchemaObject = {
   LB: "(LOAD_BALANCE=yes)",
   NFO: "(FAILOVER=false)",
   CD: "(CONNECT_DATA=",
-  CID: `(CID=(PROGRAM=nodejs)(HOST=${os.hostname()})(USER=${os.userInfo().username}))`,
   CONID: "(CONNECTION_ID="
 };
 const options = {
@@ -770,10 +770,10 @@ class NavDescription extends Description {
       if (this.connectData == null) {
         this.connectData = "(SERVICE_NAME=)";
       }
-
+      const cid = `(CID=(PROGRAM=${cInfo.program})(HOST=${cInfo.hostName})(USER=${cInfo.userName}))`;
       cOpts[i].CNdata.push(NavSchemaObject.CD);
       cOpts[i].CNdata.push(this.connectData);
-      cOpts[i].CNdata.push(NavSchemaObject.CID);
+      cOpts[i].CNdata.push(cid);
       cOpts[i].CNdata.push(")");
 
       if (this.SID != null) {

package/lib/thin/sqlnet/networkSession.js

@@ -165,6 +165,9 @@ class NetworkSession {
    * Make the transport level connection
    */
   async transportConnect(address) {
+    if (address.protocol.toUpperCase() == 'TCP' && address.httpsProxy) {
+      errors.throwErr(errors.ERR_INVALID_CONNECT_STRING_PARAMETERS, 'https proxy requires protocol as', 'tcps ');
+    }
     if (address.protocol && (address.protocol.toUpperCase() == 'TCP' || address.protocol.toUpperCase() == 'TCPS')) {
       this.ntAdapter = new NTTCP(this.sAtts.nt);
     } else {
@@ -173,8 +176,8 @@ class NetworkSession {
     await this.ntAdapter.connect(address);
     this.ntAdapter.startRead();
     this.sAtts.ntCha = this.ntAdapter.cha;
-    this.sndDatapkt = new Packet.DataPacket(this.sAtts.sdu, this.sAtts.largeSDU);
-    this.rcvDatapkt = new Packet.DataPacket(this.sAtts.sdu, this.sAtts.largeSDU);
+    this.sndDatapkt = new Packet.DataPacket(this.sAtts.largeSDU);
+    this.rcvDatapkt = new Packet.DataPacket(this.sAtts.largeSDU);
   }
 
   /**
@@ -280,17 +283,16 @@ class NetworkSession {
         }
 
         connectPkt = new Packet.ConnectPacket(redirConnData, this.sAtts, constants.NSPFRDR);
+        this.sndDatapkt = new Packet.DataPacket(this.sAtts.largeSDU);
         this._sendConnect(connectPkt);
       }
     }
 
     /* Accepted  */
     this.connected = true;
-    this.rcvDatapkt = new Packet.DataPacket(this.sAtts.sdu, this.sAtts.largeSDU);
-    this.rcvDatapkt.offset = this.rcvDatapkt.dataPtr;
-    this.rcvDatapkt.len = this.rcvDatapkt.dataPtr;
-    this.sndDatapkt = new Packet.DataPacket(this.sAtts.sdu, this.sAtts.largeSDU);
-    this.sndDatapkt.createPacket();
+    this.cData = null;
+    this.sndDatapkt = new Packet.DataPacket(this.sAtts.largeSDU);
+    this.sndDatapkt.createPacket(constants.NSPDADAT); //Currently only used for disconnect
     this.sndDatapkt.offset = this.sndDatapkt.dataPtr;
     this.sndDatapkt.len = this.sndDatapkt.bufLen;
     this.markerPkt = new Packet.MarkerPacket(this.sAtts.largeSDU);
@@ -466,7 +468,7 @@ class NetworkSession {
     let bytesCopied = 0;
 
     this.sndDatapkt.dataLen = this.sndDatapkt.offset;
-    if (this.sndDatapkt.dataLen < this.sndDatapkt.bufLen) {
+    if (this.sndDatapkt.dataLen < this.sndDatapkt.bufLen || !this.sndDatapkt.bufLen) {
       bytesCopied = this.sndDatapkt.fillBuf(userBuf, offset, len);
       len -= bytesCopied;
       offset += bytesCopied;
@@ -591,7 +593,6 @@ class NetworkSession {
     let error = 0;
     if (this.controlPkt.errno) {     /* Control pkt already read */
       error = this.controlPkt.errno;
-      this.controlPkt.clear(); /* Clear error */
       return (error);
     } else if (!this.getOption(constants.HEALTHCHECK)) {
       return errors.ERR_CONNECTION_CLOSED;
@@ -602,7 +603,6 @@ class NetworkSession {
         if (packet.type == constants.NSPTCNL) {
           this.controlPkt.fromPacket(packet);
           error = this.controlPkt.errno;
-          this.controlPkt.clear(); /* Clear error */
           return (error);
         } else {
           this.ntAdapter.packets.unshift(packet); /* Push packet back */

package/lib/thin/sqlnet/ntTcp.js

@@ -47,6 +47,8 @@ const TCPCHA = 1 << 1 |    /* ASYNC support */
   1 << 9 |    /* Full Duplex support */
   1 << 12;    /* SIGPIPE Support */
 
+let streamNum = 1;
+
 /**
  * Network Transport TCP/TCPS adapter
  * @param {Address} address Destination Address
@@ -63,6 +65,8 @@ class NTTCP {
     this.numPacketsSinceLastWait = 0;
     this.secure = false;
     this.largeSDU = false;
+    this.streamNum = streamNum++;
+    this.packetNum = 1;
   }
 
   /**
@@ -240,7 +244,8 @@ class NTTCP {
     }
     this.stream = null;
     this.connected = false;
-    this.waiter = null;
+    this.drainWaiter = null;
+    this.readWaiter = null;
   }
 
   /**
@@ -318,21 +323,19 @@ class NTTCP {
   send(buf) {
     this.checkErr();
     if (process.env.NODE_ORACLEDB_DEBUG_PACKETS)
-      this.printPacket("Sending packet", buf);
+      this.printPacket(`Sending packet ${this.packetNum} on stream ${this.streamNum}`, buf);
     const result = this.stream.write(buf, (err) => {
       if (err) {
         this.savedErr = err;
         this.err = true;
-        if (this.waiter) {
-          this.waiter();
-          this.waiter = null;
-        }
+        this._notifyWaiters();
       }
     });
     if (!result) {
       this.needsDrain = true;
     }
     this.numPacketsSinceLastWait++;
+    this.packetNum++;
   }
 
   /**
@@ -353,11 +356,7 @@ class NTTCP {
     this.checkErr();
     if (this.needsDrain) {
       await new Promise((resolve) => {
-        this.waiter = resolve;
-        this.stream.once('drain', () => {
-          resolve();
-          this.waiter = null;
-        });
+        this.drainWaiter = resolve;
       });
       this.checkErr();
     } else {
@@ -400,15 +399,16 @@ class NTTCP {
         const packet = {
           buf: tempBuf.subarray(0, len),
           type: tempBuf[4],
-          flags: tempBuf[5]
+          flags: tempBuf[5],
+          num : this.packetNum++
         };
         this.packets.push(packet);
-        if (this.waiter) {
-          this.waiter();
-          this.waiter = null;
+        if (this.readWaiter) {
+          this.readWaiter();
+          this.readWaiter = null;
         }
         if (process.env.NODE_ORACLEDB_DEBUG_PACKETS)
-          this.printPacket("Receiving packet", packet.buf);
+          this.printPacket(`Receiving packet ${packet.num} on stream ${this.streamNum}`, packet.buf);
 
         // if the packet consumed all of the bytes (most common scenario), then
         // simply clear the temporary buffer; otherwise, retain whatever bytes
@@ -442,7 +442,7 @@ class NTTCP {
     if (this.packets.length === 0) {
       this.checkErr();
       await new Promise((resolve) => {
-        this.waiter = resolve;
+        this.readWaiter = resolve;
         this.numPacketsSinceLastWait = 0;
       });
       this.checkErr();
@@ -478,26 +478,25 @@ class NTTCP {
     this.stream.on('error', (err) => {
       this.savedErr = err;
       this.err = true;
-      if (this.waiter) {
-        this.waiter();
-        this.waiter = null;
-      }
+      this._notifyWaiters();
     });
 
     this.stream.on('end', () => {
       this.err = true;
-      if (this.waiter) {
-        this.waiter();
-        this.waiter = null;
-      }
+      this._notifyWaiters();
     });
 
     this.stream.on('close', () => {
       this.connected = false;
+      this._notifyWaiters();
     });
 
     this.stream.on('drain', () => {
       this.needsDrain = false;
+      if (this.drainWaiter) {
+        this.drainWaiter();
+        this.drainWaiter = null;
+      }
     });
 
   }
@@ -522,6 +521,20 @@ class NTTCP {
     }
   }
 
+  /**
+   * Notify the waiters (drain and read) and reset them, if applicable.
+   */
+  _notifyWaiters() {
+    if (this.drainWaiter) {
+      this.drainWaiter();
+      this.drainWaiter = null;
+    }
+    if (this.readWaiter) {
+      this.readWaiter();
+      this.readWaiter = null;
+    }
+  }
+
 }
 
 module.exports = NTTCP;

package/lib/thin/sqlnet/packet.js

@@ -52,7 +52,7 @@ function ConnectPacket(connectData, sAtts, flags = 0) {
   }
 
   /* Building Connect Packet */
-  this.buf = Buffer.alloc(size);
+  this.buf = Buffer.allocUnsafe(size).fill(0);
   this.buf.writeUInt16BE(size, constants.NSPHDLEN);
   this.buf.writeUInt8(flags, constants.NSPHDFLGS);
   this.buf.writeUInt8(constants.NSPTCN, constants.NSPHDTYP);
@@ -142,24 +142,24 @@ function ConnectPacket(connectData, sAtts, flags = 0) {
  * @param {int} size of Data Packet
  * @param {boolean} isLargeSDU Large SDU
  */
-function DataPacket(size, isLargeSDU) {
+function DataPacket(isLargeSDU) {
   this.dataPtr = 0; /* data offset start */
   this.dataLen = 0; /* data offset end */
-  this.bufLen = size; /* Length of buffer */
   this.offset = 0; /* Offset for buffer read/write (fastpath) */
   this.len = 0; /* Length of buffer read/write (fastpath) */
+  this.bufLen = 0; /* Length of buffer */
 
   /**
    * Create the Data Packet(Internal)
    */
-  this.createPacket = function() {
+  this.createPacket = function(len) {
     /* Building Data Packet */
     this.dataPtr = constants.NSPDADAT;
     this.dataLen = constants.NSPDADAT;
-
-    this.buf = Buffer.alloc(size);
+    this.buf = Buffer.allocUnsafe(len).fill(0);
     this.buf.writeUInt8(0, constants.NSPHDFLGS);
     this.buf.writeUInt8(constants.NSPTDA, constants.NSPHDTYP);
+    this.bufLen = len; /* Length of buffer */
   };
 
   /**
@@ -173,7 +173,7 @@ function DataPacket(size, isLargeSDU) {
     let bytes2Copy;
 
     if (!this.buf) {
-      this.createPacket();
+      this.createPacket(len + constants.NSPDADAT); //Currently NS data packets are being used only in the connect/disconnect phase
     }
 
     if (len > this.bufLen - this.dataLen) {
@@ -377,7 +377,7 @@ function ControlPacket() {
         } else if (err1 == NSESENDMESG) {
           this.errno = err1;
           this.notifLen = err2;
-          this.notif = Buffer.alloc(err2 + 1);
+          this.notif = Buffer.allocUnsafe(err2 + 1).fill(0);
           this.buf.copy(this.notif, 0, constants.NSPCTLDAT + 12, constants.NSPCTLDAT + 12 + err2);
         } else {
           this.errno = err1;