oracledb 6.9.0 → 7.0.0

package/lib/thin/protocol/encryptDecrypt.js

@@ -1,4 +1,4 @@
-// Copyright (c) 2022, 2023, Oracle and/or its affiliates.
+// Copyright (c) 2022, 2026, Oracle and/or its affiliates.
 
 //-----------------------------------------------------------------------------
 //
@@ -28,8 +28,43 @@
 
 const { Buffer } = require('buffer');
 const crypto = require('crypto');
+const errors = require('../../errors.js');
+
+const MAX_PBKDF2_ITERATIONS = 100_000;
+
+function getPBKDF2Iterations(sessionData, key) {
+  const iterations = Number(sessionData[key]);
+  if (!Number.isInteger(iterations) || iterations < 1 ||
+      iterations > MAX_PBKDF2_ITERATIONS) {
+    errors.throwErr(errors.ERR_INVALID_SERVER_RESPONSE);
+  }
+  return iterations;
+}
+
+function resolveCipherKey(key) {
+  if (!Buffer.isBuffer(key)) {
+    errors.throwErr(errors.ERR_INTERNAL,
+      'Encryption key must be a Buffer');
+  }
+
+  let cipherAlg;
+  switch (key.length) {
+    case 16:
+      cipherAlg = 'aes-128-cbc';
+      break;
+    case 24:
+      cipherAlg = 'aes-192-cbc';
+      break;
+    case 32:
+      cipherAlg = 'aes-256-cbc';
+      break;
+    default:
+      errors.throwErr(errors.ERR_UNSUPPORTED_KEY_LENGTH, key.length);
+  }
+
+  return cipherAlg;
+}
 
-let algorithm = 'aes-256-cbc';
 const _appendBuffer = Buffer.from([0x00, 0x01]);
 
 /**
@@ -40,9 +75,10 @@ class EncryptDecrypt {
 
   // Key length is dependent on the algorithm. In this case for aes192, it is
   // 24 bytes (192 bits).
-  _decrypt(key, val) {
+  decrypt(key, val) {
     const iv = Buffer.alloc(16, 0); // Initialization vector, same is used in server
-    const decipher = crypto.createDecipheriv(algorithm, key, iv);
+    const cipherAlg = resolveCipherKey(key);
+    const decipher = crypto.createDecipheriv(cipherAlg, key, iv);
     decipher.setAutoPadding(false);
     let decrypted = decipher.update(val);
     decrypted = Buffer.concat([decrypted, decipher.final()]);
@@ -61,7 +97,8 @@ class EncryptDecrypt {
         val = Buffer.concat([val, nv]);
       }
     }
-    const cipher = crypto.createCipheriv(algorithm, key, iv);
+    const cipherAlg = resolveCipherKey(key);
+    const cipher = crypto.createCipheriv(cipherAlg, key, iv);
     let encrypted = cipher.update(val);
     encrypted = Buffer.concat([encrypted, cipher.final()]);
     if (!padding) {
@@ -108,13 +145,11 @@ class EncryptDecrypt {
 
     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']);
     const passwordBytes = Buffer.from(password, 'utf8');
     let passwordHash;
     let passwordKey;
 
     if (verifier11G) {
-      algorithm = 'aes-192-cbc';
       keyLen = 24;
       hashAlg = 'sha1';
       const h = crypto.createHash(hashAlg);
@@ -124,9 +159,9 @@ class EncryptDecrypt {
       passwordHash = Buffer.alloc(ph.length + 4);
       ph.copy(passwordHash, 0, 0, ph.length);
     } else {
-      algorithm = 'aes-256-cbc';
       const temp = Buffer.from('AUTH_PBKDF2_SPEEDY_KEY', 'utf8');
       const salt = Buffer.concat([verifierData, temp]);
+      const iterations = getPBKDF2Iterations(sessionData, 'AUTH_PBKDF2_VGEN_COUNT');
       passwordKey = crypto.pbkdf2Sync(passwordBytes, salt, iterations, 64, 'sha512');
       const h = crypto.createHash(hashAlg);
       h.update(passwordKey);
@@ -138,7 +173,7 @@ class EncryptDecrypt {
     if (newPassword) {
       newPasswordBytes = Buffer.from(newPassword, 'utf8');
     }
-    const sessionKeyParta = this._decrypt(passwordHash, encodedServerKey);
+    const sessionKeyParta = this.decrypt(passwordHash, encodedServerKey);
     const sessionKeyPartb = Buffer.alloc(sessionKeyParta.length);
     crypto.randomFillSync(sessionKeyPartb);
     const encodedClientKey = this._encrypt(passwordHash, sessionKeyPartb);
@@ -155,7 +190,7 @@ class EncryptDecrypt {
     } else {
       authObj.sessionKey = encodedClientKey.slice().toString('hex').toUpperCase().slice(0, 64);
       const mixingSalt = Buffer.from(sessionData['AUTH_PBKDF2_CSK_SALT'], 'hex');
-      iterations = Number(sessionData['AUTH_PBKDF2_SDER_COUNT']);
+      const iterations = getPBKDF2Iterations(sessionData, 'AUTH_PBKDF2_SDER_COUNT');
       const partABKey = Buffer.concat([sessionKeyPartb.slice(0, keyLen), sessionKeyParta.slice(0, keyLen)]);
       const partABKeyStr = partABKey.toString('hex').toUpperCase();
       const partABKeyBuffer = Buffer.from(partABKeyStr, 'utf8');

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

@@ -0,0 +1,238 @@
+// Copyright (c) 2025, 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.
+//
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// aqArray.js
+//
+// This file defines the messages that are sent to the database and the
+// responses that are received by the client for enqueuing and dequeuing
+// an array of AQ messages.
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const AqBaseMessage = require("./aqBase.js");
+const constants = require("../constants.js");
+const errors = require("../../../errors.js");
+
+class AqArrayMessage extends AqBaseMessage {
+
+  constructor(connImpl) {
+    super(connImpl);
+    this.functionCode = constants.TNS_FUNC_ARRAY_AQ;
+    this.numIters = 0;
+    this.propsImpls = [];
+    this.noMsgFound = false;
+  }
+
+  //--------------------------------------------------------------------------
+  // processReturnParameter()
+  //
+  // Process the return parameters of the AQ array enqueue/dequeue request.
+  // We recieve all the msg details in deq and in case of enq the msgIds.
+  //--------------------------------------------------------------------------
+  processReturnParameter(buf) {
+    const numIters = buf.readUB4();
+    for (let i = 0; i < numIters; i++) {
+      const propsImpl = this.propsImpls[i];
+      let temp16 = buf.readUB2();
+      if (temp16 > 0) {
+        buf.skipUB1();
+        this._processMsgProps(buf, propsImpl);
+      }
+      propsImpl.recipients = this._processRecipients(buf);
+      temp16 = buf.readUB2();
+      if (temp16 > 0) {
+        propsImpl.payload = this._processPayload(buf);
+      }
+      const msgId = buf.readBytesAndLength();// msgIds array
+      if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+        for (let j = 0; j < this.propsImpls.length; j++) {
+          this.propsImpls[j].msgId = Buffer.from(msgId.slice(j * 16, (j + 1) * 16));
+        }
+      } else {
+        propsImpl.msgId = Buffer.from(msgId);
+      }
+      temp16 = buf.readUB2();               // extensions len
+      if (temp16 > 0) {
+        errors.throwErr(errors.ERR_NOT_IMPLEMENTED);
+      }
+      buf.skipUB2();                        // output ack
+    }
+    if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+      this.numIters = buf.readUB4();
+    } else {
+      this.numIters = numIters;
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeArrayDeq()
+  //
+  // Writes to the buffer the fields specific to the array dequeue of AQ
+  // messages.
+  //--------------------------------------------------------------------------
+  _writeArrayDeq(buf) {
+    let consumerNameBytes = null;
+    let correlationBytes = null;
+    let conditionBytes = null;
+    const queueNameBytes = Buffer.from(this.queueImpl.name);
+    const deliveryMode = this.deqOptionsImpl.deliveryMode;
+    let flags = 0;
+
+    if (deliveryMode === constants.TNS_AQ_MSG_BUFFERED) {
+      flags |= constants.TNS_KPD_AQ_BUFMSG;
+    } else if (deliveryMode === constants.TNS_AQ_MSG_PERSISTENT_OR_BUFFERED) {
+      flags |= constants.TNS_KPD_AQ_EITHER;
+    }
+
+    if (this.deqOptionsImpl.consumerName) {
+      consumerNameBytes = Buffer.from(this.deqOptionsImpl.consumerName, 'utf-8');
+    }
+    if (this.deqOptionsImpl.condition) {
+      conditionBytes = Buffer.from(this.deqOptionsImpl.condition, 'utf-8');
+    }
+    if (this.deqOptionsImpl.correlation) {
+      correlationBytes = Buffer.from(this.deqOptionsImpl.correlation, 'utf-8');
+    }
+
+    for (const propsImpl of this.propsImpls) {
+      buf.writeUB4(queueNameBytes.length);
+      buf.writeBytesWithLength(queueNameBytes);
+      this._writeMsgProps(buf, propsImpl);
+      buf.writeUB4(0);                      // num recipients
+      this._writeValueWithLength(buf, consumerNameBytes);
+      buf.writeSB4(this.deqOptionsImpl.mode);
+      buf.writeSB4(this.deqOptionsImpl.navigation);
+      buf.writeSB4(this.deqOptionsImpl.visibility);
+      buf.writeSB4(this.deqOptionsImpl.wait);
+      this._writeValueWithLength(buf, this.deqOptionsImpl.msgid);
+      this._writeValueWithLength(buf, correlationBytes);
+      this._writeValueWithLength(buf, conditionBytes);
+      buf.writeUB4(0);                      // extensions
+      buf.writeUB4(0);                      // rel msg id
+      buf.writeSB4(0);                      // seq deviation
+      buf.writeUB4(16);                     // toid length
+      buf.writeBytesWithLength(this.queueImpl.payloadToid);
+      buf.writeUB2(constants.TNS_AQ_MESSAGE_VERSION);
+      buf.writeUB4(0);                      // payload length
+      buf.writeUB4(0);                      // raw pay length
+      buf.writeUB4(0);
+      buf.writeUB4(flags);                  // deliveryMode flag
+      buf.writeUB4(0);                      // extensions len
+      buf.writeUB4(0);                      // source seq len
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeArrayEnq()
+  //
+  // Writes input parameters in case of array enqueue.
+  //--------------------------------------------------------------------------
+  _writeArrayEnq(buf) {
+    const queueNameBytes = Buffer.from(this.queueImpl.name);
+    const deliveryMode = this.enqOptionsImpl.deliveryMode;
+    let flags = 0;
+
+    if (deliveryMode === constants.TNS_AQ_MSG_BUFFERED) {
+      flags |= constants.TNS_KPD_AQ_BUFMSG;
+    } else if (deliveryMode === constants.TNS_AQ_MSG_PERSISTENT_OR_BUFFERED) {
+      flags |= constants.TNS_KPD_AQ_EITHER;
+    }
+
+    buf.writeUB4(0);                        // rel msgid len
+    buf.writeUInt8(constants.TNS_MSG_TYPE_ROW_HEADER);
+    buf.writeUB4(queueNameBytes.length);
+    buf.writeBytesWithLength(queueNameBytes);
+    buf.writeBytes(this.queueImpl.payloadToid);
+    buf.writeUB2(constants.TNS_AQ_MESSAGE_VERSION);
+    buf.writeUB4(flags);
+
+    for (const propsImpl of this.propsImpls) {
+      buf.writeUInt8(constants.TNS_MSG_TYPE_ROW_DATA);
+      buf.writeUB4(flags);                  // aqi flags
+      this._writeMsgProps(buf, propsImpl);
+      if (propsImpl.recipients === null || propsImpl.recipients.length === 0) {
+        buf.writeUB4(0);                    // num recipients
+      } else {
+        buf.writeUB4(3 * propsImpl.recipients.length);
+        this._writeRecipients(buf, propsImpl);
+      }
+      buf.writeSB4(this.enqOptionsImpl.visibility);
+      buf.writeUB4(0);                      // relative msg id
+      buf.writeSB4(0);                      // seq deviation
+      if (!this.queueImpl.payloadTypeClass && !this.queueImpl.isJson) {
+        buf.writeUB4(propsImpl.payload.length);
+      }
+      this._writePayload(buf, propsImpl);
+    }
+    buf.writeUInt8(constants.TNS_MSG_TYPE_STATUS);
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeMessageBody()
+  //
+  // Writes the body of the message to the buffer.
+  //--------------------------------------------------------------------------
+  encode(buf) {
+    this.writeFunctionHeader(buf);
+    if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+      buf.writeUInt8(0);                    // input params
+      buf.writeUB4(0);                      // length
+    } else {
+      buf.writeUInt8(1);
+      buf.writeUB4(this.numIters);
+    }
+    buf.writeUB4(constants.TNS_AQ_ARRAY_FLAGS_RETURN_MESSAGE_ID);
+    if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+      buf.writeUInt8(1);                    // output params
+      buf.writeUInt8(0);                    // length
+    } else {
+      buf.writeUInt8(1);
+      buf.writeUInt8(1);
+    }
+    buf.writeSB4(this.operation);
+    if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+      buf.writeUInt8(1);                    // num iters (pointer)
+    } else {
+      buf.writeUInt8(0);
+    }
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_21_1) {
+      buf.writeUB4(0xffff);                 // shard id
+    }
+    if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+      buf.writeUB4(this.numIters);
+    }
+    if (this.operation === constants.TNS_AQ_ARRAY_ENQ) {
+      this._writeArrayEnq(buf);
+    } else {
+      this._writeArrayDeq(buf);
+    }
+  }
+
+}
+
+module.exports = AqArrayMessage;

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

@@ -0,0 +1,305 @@
+// Copyright (c) 2025, 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.
+//
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// aqBase.js
+//
+// This file defines the base class for messages that are sent to the
+// database and the responses that are received by the client for enqueuing and
+// dequeuing AQ messages.
+//-----------------------------------------------------------------------------
+
+'use strict';
+
+const constants = require("../constants.js");
+const errors = require("../../../errors.js");
+const BaseMessage = require("./base.js");
+const { ThinDbObjectImpl } = require("../../dbObject.js");
+const oson = require('../../../impl/datahandlers/oson.js');
+
+class AqBaseMessage extends BaseMessage {
+
+  constructor(connImpl) {
+    super(connImpl);
+    this.queueImpl = null;
+    this.deqOptionsImpl = null;
+    this.enqOptionsImpl = null;
+    this.noMsgFound = false;
+  }
+
+  //--------------------------------------------------------------------------
+  // _processDate()
+  //
+  // Processes a date found in the buffer.
+  //--------------------------------------------------------------------------
+  _processDate(buf) {
+    const numBytes = buf.readUB4();
+    if (numBytes > 0)
+      return buf.readOracleDate(true);
+  }
+
+  //--------------------------------------------------------------------------
+  // _processErrorInfo()
+  //
+  // Process error information from the buffer. If the error that indicates
+  // that no messages were received is detected, the error is cleared and
+  // the flag set so that the dequeue can handle that case.
+  //--------------------------------------------------------------------------
+  processErrorInfo(buf) {
+    super.processErrorInfo(buf);
+    if (this.errorInfo.num === constants.TNS_ERR_NO_MESSAGES_FOUND) {
+      this.errorInfo.num = 0;
+      this.errorOccurred = false;
+      this.noMsgFound = true;
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _processExtensions()
+  //
+  // Processes extensions to the message property object returned by the
+  // database.
+  //--------------------------------------------------------------------------
+  _processExtensions(buf, propsImpl) {
+    const numExtensions = buf.readUB4();
+    if (numExtensions > 0) {
+      buf.skipUB1();
+      for (let i = 0; i < numExtensions; i++) {
+        const textValue = buf.readBytesAndLength();
+        const binaryValue = buf.readBytesAndLength();
+        const value = textValue || binaryValue;
+        const keyword = buf.readUB2();
+        if (value) {
+          if (keyword === constants.TNS_AQ_EXT_KEYWORD_AGENT_NAME) {
+            propsImpl.senderAgentName = value;
+          } else if (keyword === constants.TNS_AQ_EXT_KEYWORD_AGENT_ADDRESS) {
+            propsImpl.senderAgentAddress = value;
+          } else if (keyword === constants.TNS_AQ_EXT_KEYWORD_AGENT_PROTOCOL) {
+            propsImpl.senderAgentProtocol = value[0];
+          } else if (keyword === constants.TNS_AQ_EXT_KEYWORD_ORIGINAL_MSGID) {
+            propsImpl.originalMsgId = value;
+          }
+        }
+      }
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _processMsgId()
+  //
+  // Reads a message id from the buffer and returns it.
+  //--------------------------------------------------------------------------
+  _processMsgId(buf) {
+    return Buffer.from(buf.readBytes(constants.TNS_AQ_MESSAGE_ID_LENGTH));
+  }
+
+  //--------------------------------------------------------------------------
+  // _processMsgProps()
+  //
+  // Processes a message property object returned by the database.
+  //--------------------------------------------------------------------------
+  _processMsgProps(buf, propsImpl) {
+    propsImpl.priority = buf.readSB4();
+    propsImpl.delay = buf.readSB4();
+    propsImpl.expiration = buf.readSB4();
+    propsImpl.correlation = buf.readStrAndLength();
+    propsImpl.numAttempts = buf.readSB4();
+    propsImpl.exceptionQueue = buf.readStrAndLength();
+    propsImpl.state = buf.readSB4();
+    propsImpl.enqTime = this._processDate(buf);
+    propsImpl.enqTxnId = buf.readBytesAndLength();
+    this._processExtensions(buf, propsImpl);
+    const temp32 = buf.readUB4();           // user properties
+    if (temp32 > 0) {
+      errors.throwErr(errors.ERR_NOT_IMPLEMENTED);
+    }
+    buf.skipUB4();                          // csn
+    buf.skipUB4();                          // dsn
+    const flags = buf.readUB4();
+    if (flags === constants.TNS_KPD_AQ_BUFMSG) {
+      propsImpl.deliveryMode = constants.TNS_AQ_MSG_BUFFERED;
+    } else {
+      propsImpl.deliveryMode = constants.TNS_AQ_MSG_PERSISTENT;
+    }
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_21_1) {
+      buf.skipUB4();                        // shard number
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _processPayload()
+  //
+  // Processes the payload for an enqueued message returned by the database.
+  //--------------------------------------------------------------------------
+  _processPayload(buf) {
+    const payloadData = buf.readDbObject();
+    if (this.queueImpl.payloadTypeClass) {
+      const obj = new this.queueImpl.payloadTypeClass();
+      const objImpl = new ThinDbObjectImpl(this.queueImpl.payloadTypeClass,
+        payloadData.packedData);
+      if (payloadData) {
+        objImpl.toid = payloadData.toid;
+        objImpl.oid = payloadData.oid;
+      }
+      obj._impl = objImpl;
+      return obj;
+    } else {
+      if (payloadData.packedData) {
+        const payload = Buffer.from(payloadData.packedData.slice(4));
+        if (this.queueImpl.isJson) {
+          const decoder =  new oson.OsonDecoder(payload);
+          return decoder.decode();
+        }
+        return payload;
+      } else if (!this.queueImpl.isJson) {
+        return Buffer.alloc(0);
+      }
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _processRecipients()
+  //
+  // Process recipients for a message.
+  //--------------------------------------------------------------------------
+  _processRecipients(buf) {
+    const numRecipients = buf.readUB4();
+    if (numRecipients > 0)
+      errors.throwNotImplemented('aq recipients');
+    return [];
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeMsgProps()
+  //
+  // Write a message property object to the buffer.
+  //--------------------------------------------------------------------------
+  _writeMsgProps(buf, propsImpl) {
+    buf.writeSB4(propsImpl.priority);
+    buf.writeSB4(propsImpl.delay);
+    buf.writeSB4(propsImpl.expiration);
+    this._writeValueWithLength(buf, propsImpl.correlation);
+    buf.writeUB4(0);                        // number of attempts
+    this._writeValueWithLength(buf, propsImpl.exceptionQueue);
+    buf.writeUB4(propsImpl.state);
+    buf.writeUB4(0);                        // enqueue time length
+    this._writeValueWithLength(buf, propsImpl.enqTxnId);
+    buf.writeUB4(4);                        // number of extensions
+    buf.writeUInt8(0x0e);                   // unknown extra byte
+
+    this._writeKeywordValuePair(buf, null, null,
+      constants.TNS_AQ_EXT_KEYWORD_AGENT_NAME);
+    this._writeKeywordValuePair(buf, null, null,
+      constants.TNS_AQ_EXT_KEYWORD_AGENT_ADDRESS);
+    this._writeKeywordValuePair(buf, null, Buffer.from([0x00]),
+      constants.TNS_AQ_EXT_KEYWORD_AGENT_PROTOCOL);
+    this._writeKeywordValuePair(buf, null, null,
+      constants.TNS_AQ_EXT_KEYWORD_ORIGINAL_MSGID);
+
+    buf.writeUB4(0);                        // user property
+    buf.writeUB4(0);                        // cscn
+    buf.writeUB4(0);                        // dscn
+    buf.writeUB4(0);                        // flags
+    if (buf.caps.ttcFieldVersion >= constants.TNS_CCAP_FIELD_VERSION_21_1) {
+      buf.writeUB4(0xffffffff);             // shard id
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _writePayload()
+  //
+  // Writes the payload of the message property object to the buffer.
+  //--------------------------------------------------------------------------
+  _writePayload(buf, propsImpl) {
+    if (this.queueImpl.isJson) {
+      buf.writeOson(propsImpl.payload, this.connection._osonMaxFieldNameSize,
+        false);
+    } else if (this.queueImpl.payloadTypeClass) {
+      buf.writeDbObject(propsImpl.payload);
+    } else {
+      buf.writeBytes(propsImpl.payload);
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeRecipients()
+  //
+  // Write the recipient list of the message property object to the buffer.
+  //--------------------------------------------------------------------------
+  _writeRecipients(buf, propsImpl) {
+    let index = 0;
+    for (const recipient of propsImpl.recipients) {
+      this._writeKeywordValuePair(buf, recipient, null, index);
+      this._writeKeywordValuePair(buf, null, null, index + 1);
+      this._writeKeywordValuePair(buf, null, Buffer.from([0x00]), index + 2);
+      index += 3;
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeValueWithLength()
+  //
+  // Write a string to the buffer, prefixed by a length.
+  //--------------------------------------------------------------------------
+  _writeValueWithLength(buf, value) {
+    if (!value) {
+      buf.writeUB4(0);
+    } else {
+      const valueBytes = Buffer.isBuffer(value) ?
+        value : Buffer.from(value, 'utf-8');
+      buf.writeUB4(valueBytes.length);
+      buf.writeBytesWithLength(valueBytes);
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // _writeKeywordValuePair()
+  //
+  // Writes a keyword value pair to the buffer.
+  //--------------------------------------------------------------------------
+  _writeKeywordValuePair(buf, textValue, binaryValue, keyword) {
+    let textValueBytes;
+    if (!textValue) {
+      buf.writeUB4(0);
+    } else {
+      textValueBytes = Buffer.from(textValue);
+      buf.writeUB4(textValueBytes.length);
+      buf.writeBytesWithLength(textValueBytes);
+    }
+    if (!binaryValue) {
+      buf.writeUB4(0);
+    } else {
+      buf.writeUB4(binaryValue.length);
+      buf.writeBytesWithLength(binaryValue);
+    }
+
+    buf.writeUB2(keyword);
+  }
+
+}
+
+
+module.exports = AqBaseMessage;