MeshCentral-Dokploy/rdp/protocol/t125/per.js

/*
 * Copyright (c) 2014-2015 Sylvain Peyrefitte
 *
 * This file is part of node-rdpjs.
 *
 * node-rdpjs is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

var type = require('../../core').type;
var error = require('../../core').error;

/**
 * @param s {type.Stream} read value from stream
 * @returns read length from per format
 */
function readLength(s) {
	var byte = new type.UInt8().read(s).value;
	var size = 0;
	if(byte & 0x80) {
		byte &= ~0x80;
		size = byte << 8;
		size += new type.UInt8().read(s).value;
	}
	else {
		size = byte;
	}
	return size;
}

/**
 * @param value {raw} value to convert to per format
 * @returns type objects per encoding value
 */
function writeLength(value) {
	if(value > 0x7f) {
		return new type.UInt16Be(value | 0x8000);
	}
	else {
		return new type.UInt8(value);
	}
}

/**
 * @param s {type.Stream}
 * @returns {integer} choice decoding from per encoding
 */
function readChoice(s) {
	return new type.UInt8().read(s).value;
}

/**
 * @param choice {integer}
 * @returns {type.UInt8} choice per encoded
 */
function writeChoice(choice) {
	return new type.UInt8(choice);
}

/**
 * @param s {type.Stream}
 * @returns {integer} number represent selection
 */
function readSelection(s) {
	return new type.UInt8().read(s).value;
}

/**
 * @param selection {integer}
 * @returns {type.UInt8} per encoded selection
 */
function writeSelection(selection) {
	return new type.UInt8(selection);
}

/**
 * @param s {type.Stream}
 * @returns {integer} number of sets
 */
function readNumberOfSet(s) {
	return new type.UInt8().read(s).value;
}

/**
 * @param numberOfSet {integer}
 * @returns {type.UInt8} per encoded nuimber of sets
 */
function writeNumberOfSet(numberOfSet) {
	return new type.UInt8(numberOfSet);
}

/**
 * @param s {type.Stream}
 * @returns {integer} enumerates number
 */
function readEnumerates(s) {
	return new type.UInt8().read(s).value;
}

/**
 * @param enumerate {integer}
 * @returns {type.UInt8} per encoded enumerate
 */
function writeEnumerates(enumerate) {
	return new type.UInt8(enumerate);
}

/**
 * @param s {type.Stream}
 * @returns {integer} integer per decoded
 */
function readInteger(s) {
	var result;
	var size = readLength(s);
	switch(size) {
	case 1:
		result = new type.UInt8();
		break;
	case 2:
		result = new type.UInt16Be();
		break;
	case 4:
		result = new type.UInt32Be();
		break;
	default:
		throw new error.UnexpectedFatalError('NODE_RDP_PROTOCOL_T125_PER_BAD_INTEGER_LENGTH');
	}
	return result.read(s).value;
}

/**
 * @param value {integer}
 * @returns {type.Component} per encoded integer
 */
function writeInteger(value) {
	if(value <= 0xff) {
		return new type.Component([writeLength(1), new type.UInt8(value)]);
	}
	else if(value < 0xffff) {
		return new type.Component([writeLength(2), new type.UInt16Be(value)]);
	}
	else {
		return new type.Component([writeLength(4), new type.UInt32Be(value)]);
	}
}

/**
 * @param s {type.Stream}
 * @param minimum {integer} increment (default 0)
 * @returns {integer} per decoded integer 16 bits
 */
function readInteger16(s, minimum) {
	return new type.UInt16Be().read(s).value + (minimum || 0);
}

/**
 * @param value {integer}
 * @param minimum {integer} decrement (default 0)
 * @returns {type.UInt16Be} per encoded integer 16 bits
 */
function writeInteger16(value, minimum) {
	return new type.UInt16Be(value - (minimum || 0));
}

/**
 * Check object identifier
 * @param s {type.Stream}
 * @param oid {array} object identifier to check
 */
function readObjectIdentifier(s, oid) {
	var size = readLength(s);
	if(size !== 5) {
		return false;
	}

	var a_oid = [0, 0, 0, 0, 0, 0];
	var t12 = new type.UInt8().read(s).value;
	a_oid[0] = t12 >> 4;
	a_oid[1] = t12 & 0x0f;
	a_oid[2] = new type.UInt8().read(s).value;
	a_oid[3] = new type.UInt8().read(s).value;
	a_oid[4] = new type.UInt8().read(s).value;
	a_oid[5] = new type.UInt8().read(s).value;

	for(var i in oid) {
		if(oid[i] !== a_oid[i]) return false;
	}

	return true;
}

/**
 * @param oid {array} oid to write
 * @returns {type.Component} per encoded object identifier
 */
function writeObjectIdentifier(oid) {
	return new type.Component([new type.UInt8(5), new type.UInt8((oid[0] << 4) & (oid[1] & 0x0f)), new type.UInt8(oid[2]), new type.UInt8(oid[3]), new type.UInt8(oid[4]), new type.UInt8(oid[5])]);
}

/**
 * Read as padding...
 * @param s {type.Stream}
 * @param minValue
 */
function readNumericString(s, minValue) {
    var length = readLength(s);
    length = (length + minValue + 1) / 2;
    s.readPadding(length);
}

/**
 * @param nStr {String}
 * @param minValue {integer}
 * @returns {type.Component} per encoded numeric string
 */
function writeNumericString(nStr, minValue) {
    var length = nStr.length;
    var mlength = minValue;
    if(length - minValue >= 0) {
        mlength = length - minValue;
    }
    
    var result = [];
    
    for(var i = 0; i < length; i += 2) {
        var c1 = nStr.charCodeAt(i);
    	var c2 = 0;
        if(i + 1 < length) {
            c2 = nStr.charCodeAt(i + 1);
        }
        else {
            c2 = 0x30;
        }
        c1 = (c1 - 0x30) % 10;
        c2 = (c2 - 0x30) % 10;
        
        result[result.length] = new type.UInt8((c1 << 4) | c2);
    }
    
    return new type.Component([writeLength(mlength), new type.Component(result)]);
}

/**
 * @param s {type.Stream}
 * @param length {integer} length of padding
 */
function readPadding(s, length) {
    s.readPadding(length);
}

/**
 * @param length {integer} length of padding
 * @returns {type.BinaryString} per encoded padding
 */
function writePadding(length) {
    return new type.BinaryString(Buffer.from(Array(length + 1).join("\x00")));
}

/**
 * @param s {type.Stream}
 * @param octetStream {String}
 * @param minValue {integer} default 0
 * @returns {Boolean} true if read octectStream is equal to octetStream
 */
function readOctetStream(s, octetStream, minValue) {
    var size = readLength(s) + (minValue || 0);
    if(size !== octetStream.length) {
        return false;
    }
    for(var i = 0; i < size; i++) {
        var c = new type.UInt8().read(s);
        if(octetStream.charCodeAt(i) !== c.value) {
            return false;
        }
    }
        
    return true;
}

/**
 * @param oStr {String}
 * @param minValue {integer} default 0
 * @returns {type.Component} per encoded octet stream
 */
function writeOctetStream(oStr, minValue) {
	minValue = minValue || 0;
    var length = oStr.length;
    var mlength = minValue;
    
    if(length - minValue >= 0) {
        mlength = length - minValue;
    }
    
    result = [];
    for(var i = 0; i < length; i++) {
        result[result.length] = new type.UInt8(oStr[i]);
    }
    
    return new type.Component([writeLength(mlength), new type.Component(result)]);
}

/**
 * Module exports
 */
module.exports = {
	readLength : readLength,
	writeLength : writeLength,
	readChoice : readChoice,
	writeChoice : writeChoice,
	readSelection : readSelection,
	writeSelection : writeSelection,
	readNumberOfSet : readNumberOfSet,
	writeNumberOfSet : writeNumberOfSet,
	readEnumerates : readEnumerates,
	writeEnumerates : writeEnumerates,
	readInteger : readInteger,
	writeInteger : writeInteger,
	readInteger16 : readInteger16,
	writeInteger16 : writeInteger16,
	readObjectIdentifier : readObjectIdentifier,
	writeObjectIdentifier : writeObjectIdentifier,
	readNumericString : readNumericString,
	writeNumericString : writeNumericString,
	readPadding : readPadding,
	writePadding : writePadding,
	readOctetStream : readOctetStream,
	writeOctetStream : writeOctetStream
};