oracledb 6.7.2 → 6.8.0

package/lib/thin/sqlnet/networkSession.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -25,7 +25,7 @@
 //-----------------------------------------------------------------------------
 
 'use strict';
-
+const zlib = require('zlib');
 const Packet = require("./packet.js");
 const NTTCP = require("./ntTcp.js");
 const SessionAtts = require("./sessionAtts.js");
@@ -38,6 +38,7 @@ const EzConnect = require("./ezConnectResolver.js");
 const { NLParamParser, tnsnamesFilePath } = require("./paramParser.js");
 const process = require('process');
 const downHostInstance = require("./connStrategy.js").SOLE_INST_DHCACHE;
+const {ANO} = require("./ANO.js");
 /**
  *
  * @param {string} userConfig
@@ -138,6 +139,7 @@ class NetworkSession {
     this.isBreak = false;
     this.isReset = false;
     this.breakPosted = false;
+    this.compressionEnabled = false;
   }
 
   async getAddress(addressNode, userConfig) {
@@ -149,7 +151,7 @@ class NetworkSession {
     this.sAtts = new SessionAtts(uuid);
     this.sAtts.setFrom(userConfig);
     this.sAtts.setFrom(address.desc.params);  /* Resolve attributes from Connect String */
-    await this.sAtts.prepare(address.protocol);
+    await this.sAtts.prepare(address.protocol, userConfig);
 
     /* Insert Connection ID */
     const rootNVPair = createNVPair(address.CNdata.join(""));
@@ -189,7 +191,7 @@ class NetworkSession {
    * @param {object} connectPkt Connect Packet
    */
   _sendConnect(connectPkt) {
-    this._sendPacket(connectPkt.buf);
+    this.sendPacket(connectPkt.buf);
     if (connectPkt.overflow) {
       this._send(connectPkt.connectData, 0, connectPkt.connectDataLen);
       this.flush();
@@ -295,17 +297,28 @@ class NetworkSession {
     }
 
     /* Accepted  */
+
     this.connected = true;
     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);
     this.controlPkt = new Packet.ControlPacket();
     this.ntAdapter.largeSDU = this.sAtts.largeSDU;
     this.sAtts.clearWallet();
     this.sAtts.nt.walletPassword = null;
+
+    if (!this.sAtts.noNA) {
+      const NAContext = new ANO(this.sAtts);
+      const buf = NAContext.sendPacket();
+      this._send(buf, 0, buf.length);
+      this.flush();
+      const packet = await this._recvPacket();
+      NAContext.processPacket(packet.buf);
+    }
+
+    this.sndDatapkt.createPacket(constants.NSPDADAT); //Currently only used for disconnect
+    this.sndDatapkt.offset = this.sndDatapkt.dataPtr;
+    this.sndDatapkt.len = this.sndDatapkt.bufLen;
     return (true);
   }
 
@@ -353,9 +366,36 @@ class NetworkSession {
    */
   _processPacket(packet) {
     switch (packet.type) {
-      case constants.NSPTDA: /* DATA packet */
+      case constants.NSPTDA: { /* DATA packet */
+        const size = packet.buf.length;
+        const dataFlags = packet.buf.readUInt16BE(constants.NSPDAFLG);
+        if ((dataFlags & constants.NSPDAFCMP) != 0) { // compression enabled
+          const packetHeader = packet.buf.subarray(0, constants.NSPDADAT);
+          const buffertoDeCompress = packet.buf.subarray(constants.NSPDADAT, size);
+          let deCompressedDataBuffer;
+          try {
+            if (this.sAtts.firstCompressedPacket) {
+              deCompressedDataBuffer = zlib.inflateSync(buffertoDeCompress, {finishFlush: zlib.constants.Z_SYNC_FLUSH});
+              this.sAtts.firstCompressedPacket = 0;
+            } else {
+              deCompressedDataBuffer = zlib.inflateRawSync(buffertoDeCompress, {finishFlush: zlib.constants.Z_SYNC_FLUSH});
+            }
+          } catch (err) {
+            errors.throwErr(errors.ERR_DATA_COMPRESSION, err.message);
+          }
+          const resultLength = deCompressedDataBuffer.length;
+          //concatenate packet header with decompressed data
+          packet.buf = Buffer.concat([packetHeader, deCompressedDataBuffer]);
+          const length = resultLength + constants.NSPDADAT;
+          if (this.sAtts.largeSDU) {
+            packet.buf.writeUInt32BE(length, constants.NSPHDLEN);
+          } else {
+            packet.buf.writeUInt16BE(length, constants.NSPHDLEN);
+          }
+        }
         this.rcvDatapkt.fromPacket(packet);
         break;
+      }
       case constants.NSPTMK: /* MARKER packet */
         this.markerPkt.fromPacket(packet, this);
         break;
@@ -394,16 +434,48 @@ class NetworkSession {
       const packet = await this.ntAdapter.receive();
       if (!packet)
         break;
+
       this._processPacket(packet);
-      if (packet.type !== constants.NSPTCNL)
+      if (packet.type !== constants.NSPTCNL) {
         return packet;
+      }
     }
   }
 
   /**
    * Send data (Internal)
    */
-  _sendPacket(buf) {
+  sendPacket(buf) {
+    const packetType = buf.readUInt8(constants.NSPHDTYP);
+    // only data packets need to be compressed
+    if (packetType == constants.NSPTDA) {
+      const size = buf.length;
+      let dataFlags = buf.readUInt16BE(constants.NSPDAFLG);
+      if (this.sAtts.networkCompressionEnabled && size > this.sAtts.networkCompressionThreshold) {
+        this.compressionEnabled = true;
+        const buffertoCompress = buf.subarray(constants.NSPDADAT, size);
+        const bufferHeader = buf.subarray(0, constants.NSPDADAT);
+        let compressedDataBuffer;
+        try {
+          compressedDataBuffer = zlib.deflateSync(buffertoCompress, {finishFlush: zlib.constants.Z_SYNC_FLUSH});
+        } catch (err) {
+          errors.throwErr(errors.ERR_DATA_COMPRESSION, err.message);
+        }
+        const resultLength = compressedDataBuffer.length;
+        if (resultLength < size - constants.NSPDADAT) {
+          dataFlags |= constants.NSPDAFCMP;
+          // concatenate buffer header with the compressed data
+          buf = Buffer.concat([bufferHeader, compressedDataBuffer]);
+          buf.writeUInt16BE(dataFlags, constants.NSPDAFLG);
+          const pktOffset = resultLength + constants.NSPDADAT;
+          if (this.sAtts.largeSDU) {
+            buf.writeUInt32BE(pktOffset, constants.NSPHDLEN);
+          } else {
+            buf.writeUInt16BE(pktOffset, constants.NSPHDLEN);
+          }
+        }
+      }
+    }
     this.ntAdapter.send(buf);
   }
 
@@ -422,7 +494,7 @@ class NetworkSession {
 
     this.isBreak = true;
     this.markerPkt.prepare(constants.NSPMKTD1, constants.NIQIMARK);
-    this._sendPacket(this.markerPkt.buf);
+    this.sendPacket(this.markerPkt.buf);
   }
 
   /**
@@ -432,12 +504,12 @@ class NetworkSession {
     /* If posted send Break */
     if (this.breakPosted) {
       this.markerPkt.prepare(constants.NSPMKTD1, constants.NIQBMARK);
-      this._sendPacket(this.markerPkt.buf);
+      this.sendPacket(this.markerPkt.buf);
       this.breakPosted = false;
     }
     /* Send Reset */
     this.markerPkt.prepare(constants.NSPMKTD1, constants.NIQRMARK);
-    this._sendPacket(this.markerPkt.buf);
+    this.sendPacket(this.markerPkt.buf);
 
     /* Await Reset */
     while (!this.isReset) {
@@ -491,7 +563,7 @@ class NetworkSession {
     }
 
     while (len) {
-      this._sendPacket(this.sndDatapkt.dataBuf);
+      this.sendPacket(this.sndDatapkt.dataBuf);
 
       /* If break throw error now */
       if (this.isBreak) {
@@ -516,7 +588,7 @@ class NetworkSession {
     }
     this.sndDatapkt.dataLen = this.sndDatapkt.offset;
     this.sndDatapkt.prepare2Send();
-    this._sendPacket(Buffer.from(this.sndDatapkt.dataBuf));
+    this.sendPacket(Buffer.from(this.sndDatapkt.dataBuf));
     this.sndDatapkt.dataLen = this.sndDatapkt.dataPtr;
     this.sndDatapkt.offset = this.sndDatapkt.dataPtr;
   }
@@ -569,7 +641,7 @@ class NetworkSession {
       /* Send EOF packet */
       this.sndDatapkt.dataLen = this.sndDatapkt.offset;
       this.sndDatapkt.prepare2Send(constants.NSPDAFEOF);
-      this._sendPacket(this.sndDatapkt.dataBuf);
+      this.sendPacket(this.sndDatapkt.dataBuf);
     }
     this.ntAdapter.disconnect(type);
     this.ntAdapter = null;

package/lib/thin/sqlnet/ntTcp.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -34,7 +34,7 @@ const http = require("http");
 const Timers = require('timers');
 const constants = require("./constants.js");
 const errors = require("../../errors.js");
-const { findValue } = require("./nvStrToNvPair.js");
+const { findValue, findNVPair } = require("./nvStrToNvPair.js");
 
 const PACKET_HEADER_SIZE = 8;
 const DEFAULT_PORT = 1521;
@@ -48,6 +48,12 @@ const TCPCHA = 1 << 1 |    /* ASYNC support */
   1 << 9 |    /* Full Duplex support */
   1 << 12;    /* SIGPIPE Support */
 
+const sniAllowedCDParams = ["SERVICE_NAME", "INSTANCE_NAME", "SERVER", "COLOCATION_TAG", "CONNECTION_ID", "POOL_BOUNDARY",
+  "POOL_PURITY", "POOL_CONNECTION_CLASS", "POOL_NAME", "SERVICE_TAG", "CID"];
+const sniParams = ["SERVICE_NAME", "INSTANCE_NAME", "SERVER", "COLOCATION_TAG"];
+const sniMap = ['S', 'I', 'T', 'C'];
+const SNI_MAX_BYTES = 256;
+
 let streamNum = 1;
 
 /**
@@ -113,10 +119,13 @@ class NTTCP {
    */
   async tlsConnect(secureContext, connStream) {
     this.stream.removeAllListeners();
-    let connectErrCause;
+    let connectErrCause, sni = null;
+    if (this.atts.useSNI)
+      sni = this.generateSNI();
     const tlsOptions = {
       host: this.host,
       socket: connStream,
+      servername: sni,
       rejectUnauthorized: true,
       secureContext: secureContext,
       enableTrace: false,
@@ -557,6 +566,44 @@ class NTTCP {
     }
   }
 
+  /**
+   * Generate SNI data.
+   */
+  generateSNI() {
+    /* No SNI if source route is set */
+    if ((findValue(this.atts.cDataNVPair, ["DESCRIPTION", "SOURCE_ROUTE"]) == "yes") ||
+       (findValue(this.atts.cDataNVPair, ["DESCRIPTION", "ADDRESS_LIST", "SOURCE_ROUTE"]) == "yes"))
+      return null;
+
+    const cdnvp = findNVPair(this.atts.cDataNVPair, "CONNECT_DATA");
+    /* Loop through the list of params */
+    for (let i = 0; i < cdnvp.getListSize(); i++) {
+      const child = cdnvp.getListElement(i);
+      if (!sniAllowedCDParams.includes(child.name.toUpperCase()))
+        return null; /* No SNI for unsupported Connect Data params */
+    }
+
+    /* Generate SNI */
+    let value, sni = "";
+    for (let i = 0; i < sniParams.length; i++) {
+      if ((value = findValue(this.atts.cDataNVPair, ["DESCRIPTION", "CONNECT_DATA", sniParams[i]]))) {
+        if (sniParams[i] == 'SERVER') /* For server type just pick the first letter */
+          sni += sniMap[i] + "1" + "." + value[0] + ".";
+        else
+          sni += sniMap[i] + value.length + "." + value + ".";
+      }
+    }
+    sni += "V3." + constants.TNS_VERSION_DESIRED; /* Version */
+
+    const match_pattern = new RegExp("^[A-Za-z0-9._-]+$");
+    if (!(sni.match(match_pattern)))
+      return null; /* No SNI if special characters are present */
+
+    if (sni.length > SNI_MAX_BYTES)
+      return null; /* Max allowed length */
+
+    return sni;
+  }
 }
 
 module.exports = NTTCP;

package/lib/thin/sqlnet/packet.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -108,12 +108,12 @@ function ConnectPacket(connectData, sAtts, flags = 0) {
   ); /* Connect data offset */
 
   this.buf.writeUInt8(
-    constants.NSISUPSECRENEG | constants.NSINADISABLEDFORCONNECTION,
+    sAtts.NAFlags,
     constants.NSPCNFL0
   ); /* NA disabled */
 
   this.buf.writeUInt8(
-    constants.NSISUPSECRENEG | constants.NSINADISABLEDFORCONNECTION,
+    sAtts.NAFlags,
     constants.NSPCNFL1
   ); /* NA disabled *
 
@@ -125,7 +125,21 @@ function ConnectPacket(connectData, sAtts, flags = 0) {
 
   this.buf.writeUInt32BE(sAtts.sdu, constants.NSPCNLSD); /* SDU */
   this.buf.writeUInt32BE(sAtts.tdu, constants.NSPCNLTD); /* TDU */
-  this.buf.writeUInt32BE(0, constants.NSPCNCFL); /* Compression not supported */
+  let compressionFieldBuilder = 0; // we will be using just the last 2 bytes
+  /*
+     * For the 2 byte field, the first bit represent ON/OFF , second is empty
+      * After that every 4 bits represent a value in the user preference of sch
+  eme
+     * scheme values are 1 = LZO, 2 = ZLIB, 3 = GZIP ( only ZLIB supported in node-oracledb) */
+
+  if (sAtts.networkCompression) {
+    compressionFieldBuilder = constants.NSPACCFON << 8 ; // set the ON bit
+    const schemeShiftCounter = 10; // shifting by 10 puts the 4 bit field in the right place
+    if (sAtts.networkCompressionLevels.includes('high'))
+      compressionFieldBuilder |= constants.NETWORK_COMPRESSION_ZLIB << schemeShiftCounter;
+  }
+
+  this.buf.writeUInt16BE(compressionFieldBuilder, constants.NSPCNCFL); /* Compression field added */
 
   this.buf.writeUInt32BE(
     0,
@@ -240,12 +254,25 @@ function AcceptPacket(packet, sAtts) {
     sAtts.sdu = packet.buf.readUInt32BE(constants.NSPACLSD);
     sAtts.tdu = packet.buf.readUInt32BE(constants.NSPACLTD);
     sAtts.largeSDU = true;
+    this.cflag = packet.buf.readUInt8(constants.NSPACCFL); // 00001000
+    if ((this.cflag & constants.NSPACCFON) != 0) { // compression ON
+      sAtts.negotiatedNetworkCompressionScheme = (this.cflag & 0x3c) >> 2; // 0x3c
+      sAtts.networkCompressionEnabled = true;
+      sAtts.firstCompressedPacket = true;
+    } else {
+      sAtts.networkCompressionEnabled = false;
+    }
   }
 
   /* Accept flags */
   this.flag0 = packet.buf.readUInt8(constants.NSPACFL0);
   this.flag1 = packet.buf.readUInt8(constants.NSPACFL1);
 
+  sAtts.noNA = ((this.flag1 & constants.NSINANOSERVICES) == constants.NSINANOSERVICES);
+  if (!sAtts.noNA)
+    sAtts.noNA = ((this.flag0 & constants.NSINADISABLEDFORCONNECTION) == constants.NSINADISABLEDFORCONNECTION);
+
+
   if (sAtts.version >= constants.TNS_VERSION_MIN_DATA_FLAGS) {
     packet.flags = packet.buf.readUInt32BE(constants.NSPACFL2);
   }

package/lib/thin/sqlnet/sessionAtts.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -30,6 +30,7 @@ const crypto = require('crypto');
 const path = require('path');
 const constants = require("./constants.js");
 const fs = require("fs");
+const {getFlags} = require("./ANO.js");
 
 /**
    * Generate UUID (Used for Connection ID)
@@ -60,6 +61,7 @@ class SessionAtts {
     this.uuid = uuid;
     this.nt.sslServerDNMatch = true;
     this.nt.sslAllowWeakDNMatch = false;
+    this.nt.useSNI = false;
   }
 
   /**
@@ -71,6 +73,22 @@ class SessionAtts {
       if (params.sdu > 0) {
         this.sdu = parseInt(params.sdu);
       }
+      if (typeof params.networkCompression == 'boolean') {
+        this.networkCompression = params.networkCompression;
+        this.networkCompressionLevels = [];
+        if (params.networkCompressionLevels) {
+          if (params.networkCompressionLevels.includes('high'))
+            this.networkCompressionLevels.push('high');
+          if (params.networkCompressionLevels.length == 0)
+            this.networkCompressionLevels.push('high');
+        }
+      }
+      if (params.networkCompressionThreshold >= 200) {
+        this.networkCompressionThreshold = parseInt(params.networkCompressionThreshold);
+      } else
+        this.networkCompressionThreshold = 1024;
+
+
       if (typeof params.walletLocation === 'string') {
         this.nt.walletFile = path.join(params.walletLocation, constants.PEM_WALLET_FILE_NAME);
       }
@@ -119,6 +137,9 @@ class SessionAtts {
       if (params.httpsProxyPort >= 0) {
         this.nt.httpsProxyPort = parseInt(params.httpsProxyPort);
       }
+      if (typeof params.useSNI === 'boolean') {
+        this.nt.useSNI = params.useSNI;
+      }
     }
   }
 
@@ -151,7 +172,7 @@ class SessionAtts {
    * Prepare attributes for connection, Generate Connection ID and read Wallet file
    *
    */
-  async prepare(protocol) {
+  async prepare(protocol, userConfig) {
     if (!this.uuid) {
       this.uuid = await genuuid();
       this.uuid = this.uuid.toString('base64');
@@ -169,6 +190,8 @@ class SessionAtts {
 
     if (!this.connectTimeout && !this.transportConnectTimeout)
       this.transportConnectTimeout = constants.DEFAULT_TRANSPORT_CONNECT_TIMEOUT; /* Default to 20 secs */
+
+    this.NAFlags = getFlags(protocol, userConfig);
   }
 
 }

package/lib/thin/util.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -152,9 +152,7 @@ function checkProxyUserValidity(userName) {
     index++;
   }
 
-  if (proxyUser.length === 0) {
-    return result;
-  } else {
+  if (proxyUser.length != 0) {
     result.proxyUser = proxyUser;
   }
 
@@ -229,10 +227,7 @@ function checkProxyUserValidity(userName) {
 // Check Credentials for Password Authentication
 //---------------------------------------------------------------------------
 function checkCredentials(params) {
-  if (params.token === undefined) {
-    if (params.externalAuth === true) {
-      errors.throwErr(errors.ERR_NOT_IMPLEMENTED, 'External Authentication');
-    }
+  if (params.externalAuth === false) {
     if (params.password === undefined) {
       errors.throwErr(errors.ERR_MISSING_CREDENTIALS);
     }

package/lib/transformer.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2023, 2024, Oracle and/or its affiliates.
+// Copyright (c) 2023, 2025, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -89,7 +89,8 @@ function transformJsonValue(value) {
   if (value === undefined || value === null ||
     typeof value === 'number' || typeof value === 'string' ||
     typeof value === 'boolean' || Buffer.isBuffer(value) ||
-    util.types.isDate(value) || nodbUtil.isVectorValue(value))
+    util.types.isDate(value) || nodbUtil.isVectorValue(value) ||
+    value instanceof types.IntervalYM || value instanceof types.IntervalDS)
     return value;
 
   // arrays are transformed to a new array with processed values
@@ -197,6 +198,16 @@ function transformValueIn(info, value, options) {
       types.DB_TYPE_DATE);
     return value;
 
+  // handle intervals
+  } else if (value instanceof types.IntervalYM) {
+    checkType(info, options,
+      types.DB_TYPE_INTERVAL_YM);
+    return value;
+  } else if (value instanceof types.IntervalDS) {
+    checkType(info, options,
+      types.DB_TYPE_INTERVAL_DS);
+    return value;
+
   // handle binding buffers
   } else if (Buffer.isBuffer(value)) {
     checkType(info, options,