oracledb 6.6.0 → 6.7.0

package/lib/thin/connection.js

@@ -169,12 +169,27 @@ class ThinConnectionImpl extends ConnectionImpl {
   //---------------------------------------------------------------------------
   async _execute(statement, numIters, binds, options, executeManyFlag) {
 
+    // Throw error if executeMany is not called on a DML statement or PL/SQL
+    if (executeManyFlag && statement.isQuery) {
+      errors.throwErr(errors.ERR_EXECMANY_NOT_ALLOWED_ON_QUERIES);
+    }
     // perform binds
-    const numBinds = statement.bindInfoList.length;
-    const numVars = binds.length;
-    if (numBinds !== numVars && (numVars === 0 || !binds[0].name)) {
-      errors.throwErr(errors.ERR_WRONG_NUMBER_OF_POSITIONAL_BINDS, numBinds, numVars);
+    const numStmtBinds = statement.bindInfoList.length;
+    const numUserBinds = binds.length;
+    if (numStmtBinds !== numUserBinds) {
+      if (!binds[0]?.name) {
+        // positional bind mismatch or zero binds
+        errors.throwErr(errors.ERR_WRONG_NUMBER_OF_BINDS, numStmtBinds, numUserBinds);
+      }
+
+      // named bind mismatch
+      // Find the number of distinct named bind placeholders and see
+      // if they match the bind values
+      const numDistinctStmtBinds = statement.bindInfoDict.size;
+      if (numDistinctStmtBinds !== numUserBinds)
+        errors.throwErr(errors.ERR_WRONG_NUMBER_OF_BINDS, numStmtBinds, numUserBinds);
     }
+
     for (let i = 0; i < binds.length; i++) {
       await this._bind(statement, binds[i], i + 1);
     }
@@ -404,6 +419,79 @@ class ThinConnectionImpl extends ConnectionImpl {
     }
   }
 
+  //---------------------------------------------------------------------------
+  // _populateRowTypeInfo()
+  //
+  // Get column and datatype information in case of %ROWTYPE handling.
+  //---------------------------------------------------------------------------
+  async _populateRowTypeInfo(info, options, result) {
+    const getColumnsSQL = `
+      SELECT
+        column_name,
+        data_type,
+        data_type_owner,
+        case
+          when data_type in
+            ('CHAR', 'NCHAR', 'VARCHAR2', 'NVARCHAR2', 'RAW')
+          then data_length
+          else 0
+        end,
+        nvl(data_precision, 0),
+        nvl(data_scale, 0)
+      from all_tab_cols
+      where owner = :owner
+        and table_name = :name
+        and hidden_column != 'YES'
+      order by column_id`;
+
+    const bindVal = [
+      {
+        name: "owner",
+        type: types.DB_TYPE_VARCHAR,
+        maxSize: 128,
+        dir: constants.BIND_IN,
+        values: [result.outBinds.schema],
+      },
+      {
+        name: "name",
+        type: types.DB_TYPE_VARCHAR,
+        maxSize: 128,
+        dir: constants.BIND_IN,
+        values: [info.name.substring(0, info.name.length - 8)]
+      }
+    ];
+    const val = await this.execute(
+      getColumnsSQL, 1, bindVal, options, false
+    );
+    try {
+      const attrRows = await val.resultSet._getAllRows();
+      info.attributes = [];
+      for (const row of attrRows) {
+        const metaData = {
+          name: row[0],
+          dataType: row[1],
+          dataTypeOwner: row[2],
+          maxSize: row[3],
+          dataPrecision: row[4],
+          dataScale: row[5],
+        };
+        if (!metaData.dataTypeOwner) {
+          const startPos = row[1].indexOf('(');
+          const endPos = row[1].indexOf(')');
+          if (endPos > startPos) {
+            metaData.dataType = metaData.dataType.substring(0, startPos) +
+              metaData.dataType.substring(
+                endPos + 1, metaData.dataType.length
+              );
+          }
+        }
+        this._addAttr(info.attributes, metaData);
+      }
+    } finally {
+      val.resultSet.close();
+    }
+  }
+
   //---------------------------------------------------------------------------
   // _populateDbObjectTypeInfo()
   //
@@ -449,26 +537,6 @@ class ThinConnectionImpl extends ConnectionImpl {
           end if;
       end;`;
 
-    // get column and datatype information in case of %ROWTYPE handling.
-    const getColumnsSQL = `
-      SELECT
-        column_name,
-        data_type,
-        data_type_owner,
-        case
-          when data_type in
-            ('CHAR', 'NCHAR', 'VARCHAR2', 'NVARCHAR2', 'RAW')
-          then data_length
-          else 0
-        end,
-        nvl(data_precision, 0),
-        nvl(data_scale, 0)
-      from all_tab_cols
-      where owner = :owner
-        and table_name = :name
-        and hidden_column != 'YES'
-      order by column_id`;
-
     const binds = [
       {
         name: "full_name",
@@ -540,78 +608,42 @@ class ThinConnectionImpl extends ConnectionImpl {
       errors.throwErr(errors.ERR_INVALID_OBJECT_TYPE_NAME, name);
     }
 
-    // check cache; if already present, nothing more to do!
-    const info = this._getDbObjectType(result.outBinds.schema,
-      result.outBinds.name, result.outBinds.package_name, result.outBinds.oid);
-    if (!info.partial)
-      return info;
-
-    // process TDS and attributes cursor
-    if (info.name.endsWith('%ROWTYPE')) {
-      const bindVal = [
-        {
-          name: "owner",
-          type: types.DB_TYPE_VARCHAR,
-          maxSize: 128,
-          dir: constants.BIND_IN,
-          values: [result.outBinds.schema],
-        },
-        {
-          name: "name",
-          type: types.DB_TYPE_VARCHAR,
-          maxSize: 128,
-          dir: constants.BIND_IN,
-          values: [info.name.substring(0, info.name.length - 8)]
-        }
-      ];
-      const val = await this.execute(
-        getColumnsSQL, 1, bindVal, options, false
-      );
-      const attrRows = await val.resultSet._getAllRows();
-      info.attributes = [];
-      for (const row of attrRows) {
-        const metaData = {
-          name: row[0],
-          dataType: row[1],
-          dataTypeOwner: row[2],
-          maxSize: row[3],
-          dataPrecision: row[4],
-          dataScale: row[5],
-        };
-        if (!metaData.dataTypeOwner) {
-          const startPos = row[1].indexOf('(');
-          const endPos = row[1].indexOf(')');
-          if (endPos > startPos) {
-            metaData.dataType = metaData.dataType.substring(0, startPos) +
-              metaData.dataType.substring(
-                endPos + 1, metaData.dataType.length
-              );
-          }
-        }
-        this._addAttr(info.attributes, metaData);
+    try {
+      // check cache; if already present, nothing more to do!
+      const info = this._getDbObjectType(result.outBinds.schema,
+        result.outBinds.name, result.outBinds.package_name, result.outBinds.oid);
+      if (!info.partial) {
+        return info;
       }
-    } else {
-      info.version = result.outBinds.version;
-      const attrRows = await result.outBinds.attrs_rc._getAllRows();
-      if (attrRows.length > 0) {
+
+      // process TDS and attributes cursor
+      if (info.name.endsWith('%ROWTYPE')) {
+        await this._populateRowTypeInfo(info, options, result);
+      } else {
+        info.version = result.outBinds.version;
+        const attrRows = await result.outBinds.attrs_rc._getAllRows();
+        if (attrRows.length > 0) {
         // Its an object not a collection.
-        info.attributes = [];
-        for (const row of attrRows) {
-          const metaData = {
-            name: row[1],
-            dataType: row[3],
-            dataTypeOwner: row[4],
-            packageName: row[5],
-            oid: row[6]
-          };
-          this._addAttr(info.attributes, metaData);
-        }
+          info.attributes = [];
+          for (const row of attrRows) {
+            const metaData = {
+              name: row[1],
+              dataType: row[3],
+              dataTypeOwner: row[4],
+              packageName: row[5],
+              oid: row[6]
+            };
+            this._addAttr(info.attributes, metaData);
+          }
 
+        }
+        await this._parseTDS(result.outBinds.tds, info);
       }
-      await this._parseTDS(result.outBinds.tds, info);
+      info.partial = false;
+      return info;
+    } finally {
+      result.outBinds.attrs_rc.close();
     }
-    info.partial = false;
-    return info;
 
   }
 
@@ -797,8 +829,14 @@ class ThinConnectionImpl extends ConnectionImpl {
           await this._protocol._processMessage(authMessage);
         }
       } else {
+        // When Fast Auth is explicitly disabled on servers > 23ai,
+        // we dont rely on message type TNS_MSG_TYPE_END_OF_REQUEST too
+        // for protocolMessage and dataTypeMessage.
+        const endOfRequestSupport = this.nscon.endOfRequestSupport;
+        this.nscon.endOfRequestSupport = false;
         await this._protocol._processMessage(protocolMessage);
         await this._protocol._processMessage(dataTypeMessage);
+        this.nscon.endOfRequestSupport = endOfRequestSupport;
         await this._protocol._processMessage(authMessage);
       }
       if (!params.token) { // non-token Authentication
@@ -1239,6 +1277,27 @@ class ThinConnectionImpl extends ConnectionImpl {
     return this.dbDomain;
   }
 
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database host name associated with the connection.
+  //---------------------------------------------------------------------------
+  getHostName() {
+    return this.nscon.ntAdapter.hostName;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the Oracle Database port number associated with the connection.
+  //---------------------------------------------------------------------------
+  getPort() {
+    return this.nscon.ntAdapter.port;
+  }
+
+  //---------------------------------------------------------------------------
+  // Returns the protocol associated with the connection.
+  //---------------------------------------------------------------------------
+  getProtocol() {
+    return (this.nscon.ntAdapter.secure) ? 'TCPS' : 'TCP';
+  }
+
   //---------------------------------------------------------------------------
   // Returns the Oracle Database name associated with the connection.
   //---------------------------------------------------------------------------

package/lib/thin/pool.js

@@ -44,6 +44,9 @@ class ThinPoolImpl extends PoolImpl {
     if (!params.homogeneous) {
       errors.throwErr(errors.ERR_NOT_IMPLEMENTED, 'Heterogeneous Pooling');
     }
+    if (!params.connectString) {
+      errors.throwErr(errors.ERR_EMPTY_CONNECT_STRING);
+    }
     thinUtil.checkCredentials(params);
 
     this._availableObjects = [];

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

@@ -102,6 +102,11 @@ class AuthMessage extends Message {
     }
     this.serviceName = this.conn.serviceName;
     this.remoteAddress = this.conn.remoteAddress;
+    this.driverName = config.driverName;
+    this.machine = config.machine;
+    this.osUser = config.osUser;
+    this.program = config.program;
+    this.terminal = config.terminal;
     this.setAuthMode(config);
   }
 
@@ -181,11 +186,11 @@ class AuthMessage extends Message {
       if (this.userByteLen > 0) {
         buf.writeBytesWithLength(Buffer.from(this.username));
       }
-      buf.writeKeyValue("AUTH_TERMINAL", cInfo.terminal);
-      buf.writeKeyValue("AUTH_PROGRAM_NM", cInfo.program);
-      buf.writeKeyValue("AUTH_MACHINE", cInfo.hostName);
+      buf.writeKeyValue("AUTH_TERMINAL", this.terminal ?? cInfo.terminal);
+      buf.writeKeyValue("AUTH_PROGRAM_NM", this.program ?? cInfo.program);
+      buf.writeKeyValue("AUTH_MACHINE", this.machine ?? cInfo.hostName);
       buf.writeKeyValue("AUTH_PID", cInfo.pid);
-      buf.writeKeyValue("AUTH_SID", cInfo.userName);
+      buf.writeKeyValue("AUTH_SID", this.osUser ?? cInfo.userName);
     } else {
       let numPairs = 0;
 
@@ -253,7 +258,8 @@ class AuthMessage extends Message {
       }
       if (!this.changePassword) {
         buf.writeKeyValue("SESSION_CLIENT_CHARSET", "873");
-        buf.writeKeyValue("SESSION_CLIENT_DRIVER_NAME", constants.DRIVER_NAME);
+        buf.writeKeyValue("SESSION_CLIENT_DRIVER_NAME",
+          this.driverName ?? constants.DRIVER_NAME);
         buf.writeKeyValue("SESSION_CLIENT_VERSION",
           constants.CLIENT_VERSION.toString());
         buf.writeKeyValue("AUTH_ALTER_SESSION", this.getAlterTimezoneStatement(), 1);
@@ -321,7 +327,7 @@ class AuthMessage extends Message {
       let portUpdateNum;
 
       this.conn.dbDomain = this.sessionData['AUTH_SC_DB_DOMAIN'];
-      this.conn.dbName = this.sessionData['AUTH_SC_DBUNIQUE_NAME'];
+      this.conn.dbName = this.sessionData['AUTH_DBNAME'];
       this.conn.maxOpenCursors = Number(this.sessionData['AUTH_MAX_OPEN_CURSORS'] || 0);
       this.conn.serviceName = this.sessionData['AUTH_SC_SERVICE_NAME'];
       this.conn.instanceName = this.sessionData['AUTH_INSTANCENAME'];

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

@@ -296,6 +296,9 @@ class Message {
       this._writeCurrentSchemaPiggyback(buf);
     }
     if (this.connection.statementCache._cursorsToClose.size > 0 && !this.connection._drcpEstablishSession) {
+      // skip closing cursors when '_drcpEstablishSession = true' Since we don't know whether the same session
+      // is in use. We can not send the information across until after the session information has been returned
+      // (on the first round trip).
       this.writeCloseCursorsPiggyBack(buf);
     }
     if (

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

@@ -45,6 +45,7 @@ class SessionReleaseMessage extends Message {
   }
 
   encode(buf) {
+    this.writePiggybacks(buf);
     this.writeFunctionHeader(buf);
     buf.writeUInt8(0); // pointer (tag name)
     buf.writeUInt8(0); // tag name length

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

@@ -67,7 +67,6 @@ class MessageWithData extends Message {
     if (messageType === constants.TNS_MSG_TYPE_DESCRIBE_INFO) {
       buf.skipBytesChunked();
       const prevQueryVars = this.statement.queryVars;
-      this.statement.queryVars = [];
       this.statement.numQueryVars = 0;
       this.statement.bufferRowCount = 0;
       this.statement.bufferRowIndex = 0;
@@ -512,9 +511,7 @@ class MessageWithData extends Message {
       const bvalue = buf.readUB4();
       if (bvalue > 0) { // Non Null data in column
         colValue = new ThinLobImpl();
-        if (oraTypeNum === constants.TNS_DATA_TYPE_BFILE) {
-          buf.skipUB4();
-        } else {
+        if (oraTypeNum !== constants.TNS_DATA_TYPE_BFILE) {
           length = buf.readUB8();
           chunkSize = buf.readUB4();
         }
@@ -633,7 +630,6 @@ class MessageWithData extends Message {
         if (variable.type === types.DB_TYPE_CLOB ||
             variable.type === types.DB_TYPE_NCLOB ||
             variable.type === types.DB_TYPE_BLOB ||
-            variable.type === types.DB_TYPE_BFILE ||
             variable.type === types.DB_TYPE_JSON ||
             variable.type === types.DB_TYPE_VECTOR) {
           if (variable.type !== variable.fetchInfo.fetchType) {
@@ -715,8 +711,7 @@ class MessageWithData extends Message {
       let contFlag = 0;
       if (variable.type === types.DB_TYPE_BLOB ||
           variable.type === types.DB_TYPE_CLOB ||
-          variable.type === types.DB_TYPE_NCLOB ||
-          variable.type === types.DB_TYPE_BFILE) {
+          variable.type === types.DB_TYPE_NCLOB) {
         contFlag = constants.TNS_LOB_PREFETCH_FLAG;
       } else if (variable.type === types.DB_TYPE_JSON) {
         contFlag = constants.TNS_LOB_PREFETCH_FLAG;

package/lib/thin/protocol/protocol.js

@@ -31,6 +31,7 @@ const Capabilities = require("./capabilities.js");
 const {WritePacket, ReadPacket} = require("./packet.js");
 const errors = require("../../errors");
 const utils = require("./utils.js");
+const traceHandler = require('../../traceHandler.js');
 
 /**
  * Handles protocol details.
@@ -141,6 +142,13 @@ class Protocol {
   async _processMessage(message) {
     let callTimer;
     let callTimeoutExpired = false;
+    let traceInstance, traceContext;
+    const traceEnabled = traceHandler.isEnabled();
+
+    if (traceEnabled) {
+      traceContext = { additionalConfig: {} };
+      traceInstance = traceHandler.getTraceInstance();
+    }
     try {
       if (this.callTimeout > 0) {
         callTimer = setTimeout(() => {
@@ -148,6 +156,10 @@ class Protocol {
           this.breakMessage();
         }, this.callTimeout);
       }
+      if (traceEnabled) {
+        traceContext.operation = `oracledb.${message.constructor.name}`;
+        traceInstance.onBeginRoundTrip(traceContext);
+      }
       await this._encodeMessage(message);
       if (message.messageType !== constants.TNS_MSG_TYPE_ONEWAY_FN) {
         await this._decodeMessage(message);
@@ -157,9 +169,20 @@ class Protocol {
           err.code !== errors.ERR_CONNECTION_CLOSED_CODE) {
         await this._recoverFromError(err, message);
       }
+      if (traceEnabled) {
+        traceContext.error = err;
+      }
       throw err;
     } finally {
       clearTimeout(callTimer);
+      if (traceEnabled) {
+        traceContext.callLevelConfig = message.connection._callLevelTraceData;
+        traceContext.connectLevelConfig = message.connection._getConnectTraceConfig();
+        if (message.callStatus & constants.TNS_EOCS_FLAGS_SESS_RELEASE) {
+          traceContext.additionalConfig.implicitRelease = true;
+        }
+        traceInstance.onEndRoundTrip(traceContext);
+      }
     }
     if (message.flushOutBinds) {
       await this.flushOutBindMessage(message);

package/lib/thin/sqlnet/connStrategy.js

@@ -29,6 +29,7 @@
 const { NavAddress, NavAddressList, NavDescription, NavDescriptionList } = require("./navNodes.js");
 const { createNVPair } = require("./nvStrToNvPair.js");
 const errors = require("../../errors.js");
+const constants = require("./constants.js");
 
 /**
  * Class that holds all possible attributes under Description
@@ -114,6 +115,8 @@ class ConnStrategy {
       if (config != null) {
         if ((delay == 0 || delay == undefined) && config.retryDelay > 0) {
           delay = config.retryDelay * 1000;
+        } else if (!delay) {
+          delay = constants.DEFAULT_RETRY_DELAY; // 1 sec default
         }
       }
       for (let i = this.lastRetryCounter; i <= this.retryCount; ++i) {
@@ -157,7 +160,7 @@ function sleep(time) {
  * @param {string} str - input description string
  * @returns {object} - returns a connection strategy object.
  */
-async function createNode(str) {
+async function createNode(str, userConfig) {
   let nvpair;
   if (typeof str === 'string')
     nvpair = createNVPair(str);
@@ -185,6 +188,11 @@ async function createNode(str) {
   }
   navobj.initFromNVPair(nvpair);
   const cs = new ConnStrategy();
+  cs.driverName = userConfig.driverName;
+  cs.machine = userConfig.machine;
+  cs.terminal = userConfig.terminal;
+  cs.osUser = userConfig.osUser;
+  cs.program = userConfig.program;
   await navobj.navigate(cs);
   return cs;
 }

package/lib/thin/sqlnet/constants.js

@@ -187,6 +187,8 @@ module.exports =  {
   DISABLE_OOB_STR: 'DISABLE_OOB', // disable OOB parameter
   EXPIRE_TIME: 'EXPIRE_TIME', // expire Time
   PEM_WALLET_FILE_NAME: 'ewallet.pem',
+  DEFAULT_TRANSPORT_CONNECT_TIMEOUT: 20000, //default transport connect timeout
+  DEFAULT_RETRY_DELAY: 1000, //default retry delay
 
   /* Get/Set options */
   NT_MOREDATA: 1, // More Data in Transport available

package/lib/thin/sqlnet/navNodes.js

@@ -777,8 +777,20 @@ class NavDescription extends Description {
       if (this.connectData == null) {
         this.connectData = "(SERVICE_NAME=)";
       }
-      const pgmName = "\"'" + cInfo.program + "'\"";
-      const cid = `(CID=(PROGRAM=${pgmName})(HOST=${cInfo.hostName})(USER=${cInfo.userName}))`;
+
+      let pgmName = cInfo.program;
+      if (cs.program) {
+        pgmName = cs.program;
+      }
+      let hostName = cInfo.hostName;
+      if (cs.machine) {
+        hostName = cs.machine;
+      }
+      let userName = cInfo.userName;
+      if (cs.osUser) {
+        userName = cs.osUser;
+      }
+      const cid = `(CID=(PROGRAM=${pgmName})(HOST=${hostName})(USER=${userName}))`;
       cOpts[i].CNdata.push(NavSchemaObject.CD);
       cOpts[i].CNdata.push(this.connectData);
       cOpts[i].CNdata.push(cid);

package/lib/thin/sqlnet/networkSession.js

@@ -46,7 +46,7 @@ const downHostInstance = require("./connStrategy.js").SOLE_INST_DHCACHE;
 
 async function getConnectionInfo(userConfig) {
   const connStr = await resolveConnectStr(userConfig.connectString, userConfig.configDir);
-  const addressNode = await createNode(connStr);
+  const addressNode = await createNode(connStr, userConfig);
   let nvpair;
   if (typeof connStr === 'string')
     nvpair = createNVPair(connStr);
@@ -97,9 +97,9 @@ async function resolveConnectStr(connectString, configDir) {
 
 }
 
-async function resolveAddress(connStr, configDir) {
-  const connstr = await resolveConnectStr(connStr, configDir);
-  return createNode(connstr);
+async function resolveAddress(connStr, userConfig) {
+  const connstr = await resolveConnectStr(connStr, userConfig.configDir);
+  return createNode(connstr, userConfig);
 }
 
 /**
@@ -199,7 +199,7 @@ class NetworkSession {
    * Establish network session .Make transport level connection, send NSPTCN(connect packet) and read the response.
    * @returns NetError.(connection successfully established(NetError.CONNECTED) or reason for failure)
    */
-  async connect2(address) {
+  async connect2(address, userConfig) {
     /* Sanitise SDU */
     if (this.sAtts.sdu) {
       if (this.sAtts.sdu > constants.NSPABSSDULN) {
@@ -269,7 +269,7 @@ class NetworkSession {
           redirConnData = this.cData;
         }
 
-        const redirAddressNode = await resolveAddress(adrStr);
+        const redirAddressNode = await resolveAddress(adrStr, userConfig);
         const host = address.hostname;
         address = await redirAddressNode.execute();
         if (address.desc)
@@ -314,10 +314,10 @@ class NetworkSession {
     do {
       try {
         if (this.sAtts.connectTimeout) {
-          const asyncPromise = this.connect2(address);
+          const asyncPromise = this.connect2(address, userConfig);
           connected = await timeout(asyncPromise, this.sAtts.connectTimeout, "connectTimeout", address, this.sAtts.connectionId);
         } else {
-          connected = await this.connect2(address);
+          connected = await this.connect2(address, userConfig);
         }
       } catch (err) {
         if (err.message.startsWith('NJS-510') && !this.ntAdapter.connected) {
@@ -528,7 +528,7 @@ class NetworkSession {
       addressNode = userConfig._connInfo[5];
       addressNode.reset();
     } else {
-      addressNode = await resolveAddress(connStr, userConfig.configDir);
+      addressNode = await resolveAddress(connStr, userConfig);
     }
     let address;
     try {

package/lib/thin/sqlnet/ntTcp.js

@@ -234,7 +234,7 @@ class NTTCP {
             ca: this.atts.wallet,
           });
         } catch (err) {
-          errors.throwErr(errors.ERR_TLS_INIT_FAILURE);
+          errors.throwErr(errors.ERR_TLS_INIT_FAILURE, err.message);
         }
         await this.tlsConnect(secureContext, this.stream);
       }

package/lib/thin/sqlnet/sessionAtts.js

@@ -168,7 +168,7 @@ class SessionAtts {
     }
 
     if (!this.connectTimeout && !this.transportConnectTimeout)
-      this.transportConnectTimeout = 60 * 1000; /* Default to 60 secs */
+      this.transportConnectTimeout = constants.DEFAULT_TRANSPORT_CONNECT_TIMEOUT; /* Default to 20 secs */
   }
 
 }

package/lib/thin/util.js

@@ -29,6 +29,7 @@
 const constants = require('../constants');
 const errors = require('../errors.js');
 const os = require('os');
+const nodbUtil = require('../util.js');
 
 //---------------------------------------------------------------------------
 // populateClientInfo()
@@ -36,15 +37,15 @@ const os = require('os');
 // Populates client process information
 //---------------------------------------------------------------------------
 function populateClientInfo() {
-  this.program = process.argv0;
+  this.program = nodbUtil.sanitize(process.argv0);
   this.terminal = "unknown";
   this.pid = process.pid.toString();
   try {
-    this.userName = os.userInfo().username;
+    this.userName = nodbUtil.sanitize(os.userInfo().username);
   } catch {
     this.userName = "unknown";
   }
-  this.hostName = os.hostname();
+  this.hostName = nodbUtil.sanitize(os.hostname());
 }
 // Initialize client data on startup.
 const CLIENT_INFO = new populateClientInfo();