'use strict'
|
|
const readHexString = require('./read-hex-string')
|
const readEscapeSequence = require('./read-escape-sequence')
|
|
/**
|
* @typedef {object} ReadAttributeValueResult
|
* @property {number} endPos The position in the buffer that marks the end of
|
* the value.
|
* @property {string | import('@ldapjs/asn1').BerReader} value
|
*/
|
|
/**
|
* Read an attribute value string from a given {@link Buffer} and return it.
|
* If the value is an encoded octet string, it will be decoded and returned
|
* as a {@link Buffer}.
|
*
|
* @param {Buffer} searchBuffer
|
* @param {number} startPos
|
*
|
* @returns {ReadAttributeValueResult}
|
*
|
* @throws When there is a syntax error in the attribute value string.
|
*/
|
module.exports = function readAttributeValue ({ searchBuffer, startPos }) {
|
let pos = startPos
|
|
while (pos < searchBuffer.byteLength && searchBuffer[pos] === 0x20) {
|
// Skip over any leading whitespace before the '='.
|
pos += 1
|
}
|
|
if (pos >= searchBuffer.byteLength || searchBuffer[pos] !== 0x3d) {
|
throw Error('attribute value does not start with equals sign')
|
}
|
|
// Advance past the equals sign.
|
pos += 1
|
while (pos <= searchBuffer.byteLength && searchBuffer[pos] === 0x20) {
|
// Advance past any leading whitespace.
|
pos += 1
|
}
|
|
if (pos >= searchBuffer.byteLength) {
|
return { endPos: pos, value: '' }
|
}
|
|
if (searchBuffer[pos] === 0x23) {
|
const result = readHexString({ searchBuffer, startPos: pos + 1 })
|
pos = result.endPos
|
return { endPos: pos, value: result.berReader }
|
}
|
|
const readValueResult = readValueString({ searchBuffer, startPos: pos })
|
pos = readValueResult.endPos
|
return {
|
endPos: pos,
|
value: readValueResult.value.toString('utf8').trim()
|
}
|
}
|
|
/**
|
* @typedef {object} ReadValueStringResult
|
* @property {number} endPos
|
* @property {Buffer} value
|
* @private
|
*/
|
|
/**
|
* Read a series of bytes from the buffer as a plain string.
|
*
|
* @param {Buffer} searchBuffer
|
* @param {number} startPos
|
*
|
* @returns {ReadValueStringResult}
|
*
|
* @throws When the attribute value is malformed.
|
*
|
* @private
|
*/
|
function readValueString ({ searchBuffer, startPos }) {
|
let pos = startPos
|
let inQuotes = false
|
let endQuotePresent = false
|
|
const bytes = []
|
while (pos <= searchBuffer.byteLength) {
|
const char = searchBuffer[pos]
|
|
if (pos === searchBuffer.byteLength) {
|
if (inQuotes === true && endQuotePresent === false) {
|
throw Error('missing ending double quote for attribute value')
|
}
|
break
|
}
|
|
if (char === 0x22) {
|
// Handle the double quote (") character.
|
// RFC 2253 §4 allows for attribute values to be wrapped in double
|
// quotes in order to allow certain characters to be unescaped.
|
// We are not enforcing escaping of characters in this parser, so we only
|
// need to recognize that the quotes are present. Our RDN string encoder
|
// will escape characters as necessary.
|
if (inQuotes === true) {
|
pos += 1
|
endQuotePresent = true
|
|
// We should be at the end of the value.
|
while (pos < searchBuffer.byteLength) {
|
const nextChar = searchBuffer[pos]
|
if (isEndChar(nextChar) === true) {
|
break
|
}
|
if (nextChar !== 0x20) {
|
throw Error('significant rdn character found outside of quotes at position ' + pos)
|
}
|
pos += 1
|
}
|
|
break
|
}
|
|
if (pos !== startPos) {
|
throw Error('unexpected quote (") in rdn string at position ' + pos)
|
}
|
inQuotes = true
|
pos += 1
|
continue
|
}
|
|
if (isEndChar(char) === true && inQuotes === false) {
|
break
|
}
|
|
if (char === 0x5c) {
|
// We have encountered the start of an escape sequence.
|
const seqResult = readEscapeSequence({
|
searchBuffer,
|
startPos: pos
|
})
|
pos = seqResult.endPos
|
Array.prototype.push.apply(bytes, seqResult.parsed)
|
continue
|
}
|
|
bytes.push(char)
|
pos += 1
|
}
|
|
return {
|
endPos: pos,
|
value: Buffer.from(bytes)
|
}
|
}
|
|
function isEndChar (c) {
|
switch (c) {
|
case 0x2b: // +
|
case 0x2c: // ,
|
case 0x3b: // ; -- Allowed by RFC 2253 §4 in place of a comma.
|
return true
|
default:
|
return false
|
}
|
}
|
