relpipe/relpipe-in-asn1table.cpp: comparison src/lib/BasicASN1Reader.h

equal deleted inserted replaced

-:bf2c546f49d1
+:caed9146f72f
 		}
 		return h;
 	}
-	void readNext() {
+	const std::string readString(size_t length) {
+		std::string result;
+		for (size_t remaining = length; remaining;) {
+			size_t current = std::min(remaining, (size_t) 3);
+			result.resize(result.size() + current);
+			read((uint8_t*) result.data() + result.size() - current, current);
+			remaining -= current;
+		}
+		return result;
+	}
+	const std::vector<uint8_t> readVector(size_t length) {
+		std::vector<uint8_t> result;
+		std::string s = readString(length); // TODO: read directly to the vector
+		result.resize(length);
+		for (size_t i = 0; i < length; i++) result[i] = (uint8_t) s[i];
+		return result;
+	}
+	void processNext() {
 		using TagClass = ASN1ContentHandler::TagClass;
 		using PC = ASN1ContentHandler::PC;
 		checkRemainingItems();
 		BasicHeader typeHeader = readHeader();
 		} else if (typeHeader.tag == UniversalType::Boolean && typeHeader.definiteLength && typeHeader.length == 1) {
 			bool value;
 			read((uint8_t*) & value, 1);
 			handlers->writeBoolean(typeHeader, value);
 		} else if (typeHeader.tag == UniversalType::Integer && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
-			// TODO: check available bytes before allocating buffer
+			std::vector<uint8_t> value = readVector(typeHeader.length);
-			std::vector<uint8_t> value(typeHeader.length, 0x00);
-			read(value.data(), typeHeader.length);
 			handlers->writeInteger(typeHeader, ASN1ContentHandler::Integer(value));
 		} else if (typeHeader.tag == UniversalType::ObjectIdentifier && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
 			std::vector<uint8_t> value(typeHeader.length, 0x00);
 			read(value.data(), typeHeader.length);
 			handlers->writeOID(typeHeader,{value});
 		} else if (typeHeader.tag == UniversalType::UTF8String && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
-			// TODO: check available bytes before allocating buffer
+			std::string s = readString(typeHeader.length);
-			std::string s;
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			handlers->writeTextString(typeHeader, s);
 		} else if (typeHeader.tag == UniversalType::PrintableString && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
 			// TODO: check encoding
-			// TODO: check available bytes before allocating buffer
+			std::string s = readString(typeHeader.length);
-			std::string s;
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			handlers->writeTextString(typeHeader, s);
 		} else if (typeHeader.tag == UniversalType::OctetString && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
-			// TODO: check available bytes before allocating buffer
+			std::string s = readString(typeHeader.length);
-			std::string s;
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			if (processEncapsulatedContent(typeHeader, s) == false) handlers->writeOctetString(typeHeader, s);
 		} else if (typeHeader.tag == UniversalType::BitString && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
-			// TODO: check available bytes before allocating buffer
+			std::string s = readString(typeHeader.length);
-			std::string s;
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			if (processEncapsulatedContent(typeHeader, s) == false) {
 				std::vector<bool> bits;
 				// TODO: throw exception on wrong padding or insufficient length?
 				if (s.size() > 1) {
 					uint8_t padding = s[0];
 					for (size_t i = s.size() - 2; i > 0; i--) for (uint8_t j = 0; j < 8; j++) bits.push_back(s[i] & 1 << j);
 				}
 				handlers->writeBitString(typeHeader, bits);
 			}
 		} else if (typeHeader.tag == UniversalType::UTCTime && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
-			// TODO: check available bytes before allocating buffer
 			// TODO: check encoding
-			std::string s;
+			std::string s = readString(typeHeader.length);
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			ASN1ContentHandler::DateTime dateTime;
 			std::smatch match;
 			if (std::regex_match(s, match, std::regex("([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})?(Z|([+-][0-9]{2})([0-9]{2}))"))) {
 			} else {
 				throw std::invalid_argument("Unsupported UTCTime format: " + s); // TODO: better exception
 			}
 		} else if (typeHeader.tag == UniversalType::GeneralizedTime && typeHeader.tagClass == TagClass::Universal && typeHeader.definiteLength) {
-			// TODO: check available bytes before allocating buffer
+			std::string s = readString(typeHeader.length);
-			std::string s;
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			ASN1ContentHandler::DateTime dateTime;
 			std::smatch match;
 			if (std::regex_match(s, match, std::regex("([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})(\\.([0-9]{1,3}))?(Z|([+-][0-9]{2})([0-9]{2}))"))) {
 				throw std::invalid_argument("Unsupported GeneralizedTime format: " + s); // TODO: better exception
 			}
 		} else {
 			// TODO: do not skip, parse
-			// TODO: check available bytes before allocating buffer
+			std::string s = readString(typeHeader.length);
-			std::string s;
-			s.resize(typeHeader.length);
-			read((uint8_t*) s.data(), typeHeader.length);
 			handlers->writeSpecific(typeHeader, s);
 		}
 		commit();
 	}
 	}
 protected:
 	void update() override {
-		while (true) readNext();
+		while (true) processNext();
 	}
 public:
 	void close() override {

branch	v_0
changeset 36	caed9146f72f
parent 35	bf2c546f49d1
child 37	0845ca3636b6