oracledb 6.1.0 → 6.2.0

package/lib/thin/protocol/buffer.js

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

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

@@ -448,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/withData.js

@@ -57,6 +57,7 @@ class MessageWithData extends Message {
     this.inFetch = false;
     this.parseOnly = false;
     this.resultSetsToSetup = [];
+    this.deferredErr = null;
   }
 
   /**
@@ -116,8 +117,8 @@ class MessageWithData extends Message {
       this.errorOccurred = false;
       this.statement.moreRowsToFetch = false;
     } else if (this.errorInfo.num !== 0 && this.errorInfo.cursorId !== 0) {
-      this.connection._addCursorToClose(this.statement.cursorId);
       this.connection.statementCache.delete(this.statement.sql);
+      this.statement.returnToCache = false;
     }
     if (this.errorInfo.batchErrors) {
       this.errorOccurred = false;
@@ -472,7 +473,7 @@ class MessageWithData extends Message {
       if (actualNumBytes < 0 && oraTypeNum === constants.TNS_DATA_TYPE_BOOLEAN) {
         colValue = null;
       } else if (actualNumBytes !== 0 && colValue !== null) {
-        errors.throwErr(errors.ERR_INSUFFICIENT_BUFFER_FOR_BINDS);
+        this.saveDeferredErr(errors.ERR_INSUFFICIENT_BUFFER_FOR_BINDS);
       }
     } else if (oraTypeNum === constants.TNS_DATA_TYPE_LONG || oraTypeNum === constants.TNS_DATA_TYPE_LONG_RAW || variable.maxSize > buf.caps.maxStringSize) {
       buf.skipSB4();                            // null indicator
@@ -525,11 +526,15 @@ class MessageWithData extends Message {
   }
 
   async postProcess() {
+    if (this.deferredErr) {
+      throw this.deferredErr;
+    }
+
     if (this.outVariables) {
       for (const variable of this.outVariables) {
         if (variable.isArray) {
-          for (let pos = 0; pos < variable.numElementsInArray; pos++) {
-            if (variable.outConverter) {
+          if (variable.outConverter) {
+            for (let pos = 0; pos < variable.numElementsInArray; pos++) {
               variable.values[0][pos] = await variable.outConverter(variable.values[0][pos]);
             }
           }

package/lib/thin/protocol/oson.js

@@ -416,10 +416,11 @@ class OsonTreeSegment extends GrowableBuffer {
   //---------------------------------------------------------------------------
   _encodeArray(value, fnamesSeg) {
     this._encodeContainer(constants.TNS_JSON_TYPE_ARRAY, value.length);
-    let offsetsBufPos = 0;
-    const offsetsBuf = this.reserveBytes(value.length * 4);
+    const len = value.length * 4;
+    const pos = this.reserveBytes(len);
+    let offsetsBufPos = pos;
     for (const element of value) {
-      offsetsBuf.writeUInt32BE(this.pos, offsetsBufPos);
+      this.buf.writeUInt32BE(this.pos, offsetsBufPos);
       offsetsBufPos += 4;
       this.encodeNode(element, fnamesSeg);
     }
@@ -456,19 +457,21 @@ class OsonTreeSegment extends GrowableBuffer {
   _encodeObject(value, fnamesSeg) {
     const numChildren = value.values.length;
     this._encodeContainer(constants.TNS_JSON_TYPE_OBJECT, numChildren);
-    let fieldIdOffset = 0;
-    let valueOffset = numChildren * fnamesSeg.fieldIdSize;
-    const buf = this.reserveBytes(numChildren * (fnamesSeg.fieldIdSize + 4));
+    const len = numChildren * (fnamesSeg.fieldIdSize + 4);
+    const pos = this.reserveBytes(len);
+    let fieldIdOffset = pos;
+    let valueOffset = pos + (numChildren * fnamesSeg.fieldIdSize);
+
     for (let i = 0; i < value.fields.length; i++) {
       const fieldName = fnamesSeg.fieldNamesMap.get(value.fields[i]);
       if (fnamesSeg.fieldIdSize == 1) {
-        buf[fieldIdOffset] = fieldName.fieldId;
+        this.buf[fieldIdOffset] = fieldName.fieldId;
       } else if (fnamesSeg.fieldIdSize == 2) {
-        buf.writeUInt16BE(fieldName.fieldId, fieldIdOffset);
+        this.buf.writeUInt16BE(fieldName.fieldId, fieldIdOffset);
       } else {
-        buf.writeUInt32BE(fieldName.fieldId, fieldIdOffset);
+        this.buf.writeUInt32BE(fieldName.fieldId, fieldIdOffset);
       }
-      buf.writeUInt32BE(this.pos, valueOffset);
+      this.buf.writeUInt32BE(this.pos, valueOffset);
       fieldIdOffset += fnamesSeg.fieldIdSize;
       valueOffset += 4;
       this.encodeNode(value.values[i], fnamesSeg);

package/lib/thin/protocol/packet.js

@@ -35,7 +35,6 @@ const errors = require("../../errors.js");
 
 const TNS_BASE64_ALPHABET_ARRAY = Buffer.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", 'utf8');
 
-
 /**
  * Class used for byte chunks used in the ChunkedBytesBuffer.
  */
@@ -52,7 +51,7 @@ class BytesChunk {
     if (remainder > 0) {
       this.allocLen += (constants.CHUNKED_BYTES_CHUNK_SIZE - remainder);
     }
-    this.buf = Buffer.alloc(this.allocLen);
+    this.buf = Buffer.allocUnsafe(this.allocLen);
     this.actualLen = 0;
   }
 
@@ -133,6 +132,7 @@ class ChunkedBytesBuffer {
  *
  * @class ReadPacket
  */
+
 class ReadPacket extends BaseBuffer {
 
   /**
@@ -140,8 +140,9 @@ class ReadPacket extends BaseBuffer {
    * @param {Object} adapter used for sending/receiving data
    * @param {Object} capabilities
    */
+
   constructor(nsi, caps) {
-    super(nsi.sAtts.sdu);
+    super();
     this.nsi = nsi;
     this.caps = caps;
     this.chunkedBytesBuf = new ChunkedBytesBuffer();
@@ -228,7 +229,7 @@ class ReadPacket extends BaseBuffer {
     if (inChunkedRead) {
       buf = this.chunkedBytesBuf.getBuf(numBytes);
     } else {
-      buf = Buffer.alloc(numBytes);
+      buf = Buffer.allocUnsafe(numBytes);
     }
 
     // copy the bytes to the buffer from the remainder of this packet
@@ -341,7 +342,7 @@ class ReadPacket extends BaseBuffer {
       outputLen += 3;
     }
 
-    const outputValue =  Buffer.alloc(outputLen);
+    const outputValue =  Buffer.allocUnsafe(outputLen);
     inputLen -= 1;
     outputValue[0] = 42;
     outputOffset += 1;

package/lib/thin/protocol/utils.js

@@ -43,7 +43,7 @@ function _convertBase64(result, value, size, offset) {
 function encodeRowID(rowID) {
   let offset = 0;
   if (rowID.rba !== 0 || rowID.partitionID !== 0 || rowID.blockNum !== 0 || rowID.slotNum != 0) {
-    const result = Buffer.alloc(constants.TNS_MAX_ROWID_LENGTH);
+    const result = Buffer.allocUnsafe(constants.TNS_MAX_ROWID_LENGTH);
     offset = _convertBase64(result, rowID.rba, 6, offset);
     offset = _convertBase64(result, rowID.partitionID, 3, offset);
     offset = _convertBase64(result, rowID.blockNum, 6, offset);

package/lib/thin/sqlnet/ezConnectResolver.js

@@ -26,7 +26,6 @@
 
 'use strict';
 
-const {lookup} = require('dns').promises;
 const errors = require("../../errors.js");
 
 // The host information pattern of the EZConnect URL format.
@@ -71,14 +70,7 @@ const DESCRIPTION_PARAMS = ["ENABLE", "FAILOVER", "LOAD_BALANCE",
 class EZConnectResolver {
   constructor(url) {
     this.URL_PROPS_ALIAS = this.initializeUrlAlias();
-    const jdbcUrlPrefix = url.indexOf('@');
-    if (jdbcUrlPrefix != -1) {
-      this.url = url.substring(jdbcUrlPrefix + 1);
-      this.urlPrefix = url.substring(0, jdbcUrlPrefix + 1);
-    } else {
-      this.url = url;
-      this.urlPrefix = "";
-    }
+    this.url = url;
     this.resolvedUrl = '';
     this.connectionProps = new Map();
     this.urlProps = new Map();
@@ -89,8 +81,8 @@ class EZConnectResolver {
  * Returns the resolved long TNS String.
  * @return Resolved TNS URL.
  */
-  async getResolvedUrl() {
-    await this.parse();
+  getResolvedUrl() {
+    this.parse();
     return this.resolvedUrl;
   }
 
@@ -99,29 +91,22 @@ class EZConnectResolver {
    * After parsing the extended settings if the remaining part of the URL is in
    * EZConnectURL format then resolve it to long TNS url format.
    */
-  async parse() {
+  parse() {
     // First try to parse the extended settings part of the URL.
     let parsedUrl = this.parseExtendedSettings(this.url);
     if (this.connectionProps.size === 0 && this.urlProps.size === 0) {
       // If we have not parsed anything then use the received url as is.
       parsedUrl = this.url;
     }
-
-    if (parsedUrl.startsWith("(")) {
-      // Skip resolve the URL if it is in TNS format,
-      // TNS format starts with '('
-      this.resolvedUrl = this.urlPrefix + parsedUrl;
-    } else {
-      // Try to resolve the EZConnectURL to Long TNS URL.
-      this.resolvedUrl = this.urlPrefix + await this.resolveToLongURLFormat(parsedUrl);
-    }
+    // Try to resolve the EZConnectURL to Long TNS URL.
+    this.resolvedUrl = this.resolveToLongURLFormat(parsedUrl);
   }
   /**
   * Translate the given ezconnect url format to Long TNS format.
   * @param url EZConnect URL
   * @return Returns resolved TNS url.
   */
-  async resolveToLongURLFormat(url) {
+  resolveToLongURLFormat(url) {
     // URL is in the following format
     // [protocol://]host1[,host13][:port1][,host2:port2][/service_name][:server][/instance_name]
 
@@ -151,7 +136,7 @@ class EZConnectResolver {
     const proxyHost = this.urlProps.get("HTTPS_PROXY");
     const proxyPort = this.urlProps.get("HTTPS_PROXY_PORT");
     const addressInfo =
-      await this.buildAddressList(hostInfo, protocol, proxyHost, proxyPort);
+      this.buildAddressList(hostInfo, protocol, proxyHost, proxyPort);
 
     const connectionIdPrefix =
       this.urlProps.get("CONNECTION_ID_PREFIX");
@@ -210,10 +195,8 @@ class EZConnectResolver {
 * @param proxyPort proxy server port [optional].
 * @return address information of the DESCRIPTION node.
 */
-  async buildAddressList(hostInfo, protocol,
+  buildAddressList(hostInfo, protocol,
     proxyHost, proxyPort) {
-    let shost = '';
-    let ipcnt = 0;
     const builder = new Array();
     let proxyInfo = '';
     if (proxyHost != null) {
@@ -235,11 +218,10 @@ class EZConnectResolver {
         const hostnames = (match.groups.hostnames).split(',');
         let port = match.groups.port;
         if (port == null) {
-          port = '1521' + '';
+          port = '1521';    //default port
         }
         for (const hname in hostnames) {
           addressListBuilder.push(this.getAddrStr(hostnames[hname], port, protocol, proxyInfo));
-          shost = hostnames[hname];
           addressNodeCount++;
         }
       }
@@ -253,21 +235,6 @@ class EZConnectResolver {
       else
         builder.push(parts.join(''));
     }
-    if (naddr == 1) {
-      shost = shost.trim();
-      // If it is IPV6 format address then remove the enclosing '[' and ']'
-      if (shost.startsWith("[") && shost.endsWith("]"))
-        shost = shost.substring(1, shost.length - 1);
-      try {
-        await lookup(shost);
-        ipcnt++;
-      } catch {
-        // nothing
-      }
-      if (ipcnt == 0) {
-        errors.throwErr(errors.ERR_INVALID_EZCONNECT_SYNTAX, 'could not resolve hostname', shost);
-      }
-    }
 
     if (addressLists.length < 2 && naddr > 1) {
       this.lb = true;

package/lib/thin/sqlnet/navNodes.js

@@ -77,7 +77,7 @@ class Address {
     const httpsProxyPortNVP = findNVPairRecurse(nvp, 'https_proxy_port');
 
     if (portnvp)
-      this.port = portnvp.atom;
+      this.port = Number(portnvp.atom);
 
     if (hostnvp)
       this.host = hostnvp.atom;
@@ -88,7 +88,7 @@ class Address {
     if (httpsProxyNVP)
       this.httpsProxy = httpsProxyNVP.atom;
     if (httpsProxyPortNVP)
-      this.httpsProxyPort = httpsProxyPortNVP.atom;
+      this.httpsProxyPort = Number(httpsProxyPortNVP.atom);
 
     this.addr = nvp.toString();
   }

package/lib/thin/sqlnet/networkSession.js

@@ -71,29 +71,23 @@ async function resolveConnectStr(connectString, configDir) {
   const connStr = connectString.trim();
   let resolvedVal = connStr;
   if ((connStr.indexOf(')') == -1) || (connStr.indexOf('(') != 0)) {
-    try {
-      /* Try through ezconnect */
+    if ((connStr.indexOf(':') != -1) || (connStr.indexOf('/') != -1)) {
       const ezcnObj = new EzConnect(connStr);
-      resolvedVal = await ezcnObj.getResolvedUrl();
-    } catch (err) {
-      try {
-        /* try tns alias */
-        const namesFilePath = tnsnamesFilePath(configDir);
-        const p = await nlParamParser.initializeNlpa(namesFilePath);
-        resolvedVal = p.get(connStr.toUpperCase());
-        if (!resolvedVal)
-          errors.throwErr(errors.ERR_TNS_ENTRY_NOT_FOUND, connStr, configDir ? configDir + '/tnsnames.ora' : process.env.TNS_ADMIN + '/tnsnames.ora');
-        resolvedVal = resolvedVal.getListElement(0);
-      } catch (err1) {
-        if ((connStr.indexOf(':') != -1) || (connStr.indexOf('/') != -1)) {
-          throw err;
-        } else {
-          throw err1;
-        }
-      }
+      resolvedVal = ezcnObj.getResolvedUrl();
+      return resolvedVal;
+    } else {
+      //try tns alias
+      const namesFilePath = tnsnamesFilePath(configDir);
+      const p = await nlParamParser.initializeNlpa(namesFilePath);
+      resolvedVal = p.get(connStr.toUpperCase());
+      if (!resolvedVal)
+        errors.throwErr(errors.ERR_TNS_ENTRY_NOT_FOUND, connStr, configDir ? configDir + '/tnsnames.ora' : process.env.TNS_ADMIN + '/tnsnames.ora');
+      resolvedVal = resolvedVal.getListElement(0);
     }
+
   }
   return resolvedVal;
+
 }
 
 async function resolveAddress(connStr, configDir) {

package/lib/thin/sqlnet/packet.js

@@ -299,7 +299,7 @@ function RedirectPacket(packet) {
  */
 function MarkerPacket(isLargeSDU) {
   this.len = constants.NSPMKDAT + 1; /* Packet length */
-  this.buf = Buffer.alloc(constants.NSPMKDAT + 1); /* Packet Buffer */
+  this.buf = Buffer.allocUnsafe(constants.NSPMKDAT + 1); /* Packet Buffer */
 
   if (isLargeSDU) {
     this.buf.writeUInt32BE(this.len, constants.NSPHDLEN);