Ejemplo n.º 1
0
// static
ref <X509Certificate> X509Certificate::import(utility::inputStream& is)
{
	byteArray bytes;
	utility::stream::value_type chunk[4096];

	while (!is.eof())
	{
		const int len = is.read(chunk, sizeof(chunk));
		bytes.insert(bytes.end(), chunk, chunk + len);
	}

	return import(&bytes[0], bytes.size());
}
Ejemplo n.º 2
0
// static
shared_ptr <X509Certificate> X509Certificate::import(utility::inputStream& is)
{
	byteArray bytes;
	byte_t chunk[4096];

	while (!is.eof())
	{
		const size_t len = is.read(chunk, sizeof(chunk));
		bytes.insert(bytes.end(), chunk, chunk + len);
	}

	return import(&bytes[0], bytes.size());
}
void charsetConverter_Win::convert(utility::inputStream& in, utility::outputStream& out)
{
    char s8_Buffer[32000];

    string s_In, s_Out;
    while (!in.eof())
    {
        size_t len = in.read(s8_Buffer, sizeof(s8_Buffer));
        s_In.append(s8_Buffer, len);
    }

    convert(s_In, s_Out);

    out.write(s_Out.data(), s_Out.length());
}
Ejemplo n.º 4
0
size_t qpEncoder::decode(
	utility::inputStream& in,
	utility::outputStream& out,
	utility::progressListener* progress
) {

	in.reset();  // may not work...

	// Process the data
	const bool rfc2047 = getProperties().getProperty <bool>("rfc2047", false);

	byte_t buffer[16384];
	size_t bufferLength = 0;
	size_t bufferPos = 0;

	byte_t outBuffer[16384];
	size_t outBufferPos = 0;

	size_t total = 0;
	size_t inTotal = 0;

	while (bufferPos < bufferLength || !in.eof()) {

		// Flush current output buffer
		if (outBufferPos >= sizeof(outBuffer)) {

			QP_WRITE(out, outBuffer, outBufferPos);

			total += outBufferPos;
			outBufferPos = 0;
		}

		// Need to get more data?
		if (bufferPos >= bufferLength) {

			bufferLength = in.read(buffer, sizeof(buffer));
			bufferPos = 0;

			// No more data
			if (bufferLength == 0) {
				break;
			}
		}

		// Decode the next sequence (hex-encoded byte or printable character)
		byte_t c = buffer[bufferPos++];

		++inTotal;

		switch (c) {

			case '=': {

				if (bufferPos >= bufferLength) {
					bufferLength = in.read(buffer, sizeof(buffer));
					bufferPos = 0;
				}

				if (bufferPos < bufferLength) {

					c = buffer[bufferPos++];

					++inTotal;

					switch (c) {

						// Ignore soft line break ("=\r\n" or "=\n")
						case '\r':

							// Read one byte more
							if (bufferPos >= bufferLength) {
								bufferLength = in.read(buffer, sizeof(buffer));
								bufferPos = 0;
							}

							if (bufferPos < bufferLength) {
								++bufferPos;
								++inTotal;
							}

							break;

						case '\n':

							break;

						// Hex-encoded char
						default:
						{
							// We need another byte...
							if (bufferPos >= bufferLength) {
								bufferLength = in.read(buffer, sizeof(buffer));
								bufferPos = 0;
							}

							if (bufferPos < bufferLength) {

								const byte_t next = buffer[bufferPos++];

								++inTotal;

								const byte_t value = static_cast <byte_t>(
									sm_hexDecodeTable[c] * 16 + sm_hexDecodeTable[next]
								);

								outBuffer[outBufferPos++] = value;

							} else {

								// Premature end-of-data
							}

							break;
						}

					}

				} else {

					// Premature end-of-data
				}

				break;
			}
			case '_': {

				if (rfc2047) {

					// RFC-2047, Page 5, 4.2. The "Q" encoding:
					// << Note that the "_" always represents hexadecimal 20, even if the SPACE
					// character occupies a different code position in the character set in use. >>
					outBuffer[outBufferPos++] = 0x20;
					break;
				}

				outBuffer[outBufferPos++] = c;
				break;
			}
			default: {

				outBuffer[outBufferPos++] = c;
				break;
			}

		}

		if (progress) {
			progress->progress(inTotal, inTotal);
		}
	}

	// Flush remaining output buffer
	if (outBufferPos != 0) {
		QP_WRITE(out, outBuffer, outBufferPos);
		total += outBufferPos;
	}

	if (progress) {
		progress->stop(inTotal);
	}

	return total;
}
Ejemplo n.º 5
0
size_t qpEncoder::encode(
	utility::inputStream& in,
	utility::outputStream& out,
	utility::progressListener* progress
) {

	in.reset();  // may not work...

	const size_t propMaxLineLength =
		getProperties().getProperty <size_t>("maxlinelength", static_cast <size_t>(-1));

	const bool rfc2047 = getProperties().getProperty <bool>("rfc2047", false);
	const bool text = getProperties().getProperty <bool>("text", false);  // binary mode by default

	const bool cutLines = (propMaxLineLength != static_cast <size_t>(-1));
	const size_t maxLineLength = std::min(propMaxLineLength, static_cast <size_t>(74));

	// Process the data
	byte_t buffer[16384];
	size_t bufferLength = 0;
	size_t bufferPos = 0;

	size_t curCol = 0;

	byte_t outBuffer[16384];
	size_t outBufferPos = 0;

	size_t total = 0;
	size_t inTotal = 0;

	if (progress) {
		progress->start(0);
	}

	while (bufferPos < bufferLength || !in.eof()) {

		// Flush current output buffer
		if (outBufferPos + 6 >= static_cast <int>(sizeof(outBuffer))) {

			QP_WRITE(out, outBuffer, outBufferPos);

			total += outBufferPos;
			outBufferPos = 0;
		}

		// Need to get more data?
		if (bufferPos >= bufferLength) {

			bufferLength = in.read(buffer, sizeof(buffer));
			bufferPos = 0;

			// No more data
			if (bufferLength == 0) {
				break;
			}
		}

		// Get the next char and encode it
		const byte_t c = buffer[bufferPos++];

		if (rfc2047) {

			if (c >= 128 || sm_RFC2047EncodeTable[c] != 0) {

				if (c == 32) {  // space

					// RFC-2047, Page 5, 4.2. The "Q" encoding:
					// << The 8-bit hexadecimal value 20 (e.g., ISO-8859-1 SPACE) may be
					// represented as "_" (underscore, ASCII 95.). >>
					outBuffer[outBufferPos++] = '_';
					++curCol;

				} else {

					// Other characters: '=' + hexadecimal encoding
					QP_ENCODE_HEX(c);
				}

			} else {

				// No encoding
				outBuffer[outBufferPos++] = c;
				++curCol;
			}

		} else {

			switch (c) {

				case 46: {  // .

					if (curCol == 0) {
						// If a '.' appears at the beginning of a line, we encode it to
						// to avoid problems with SMTP servers... ("\r\n.\r\n" means the
						// end of data transmission).
						QP_ENCODE_HEX('.');
						continue;
					}

					outBuffer[outBufferPos++] = '.';
					++curCol;
					break;
				}
				case 32: {  // space

					// Need to get more data?
					if (bufferPos >= bufferLength) {
						bufferLength = in.read(buffer, sizeof(buffer));
						bufferPos = 0;
					}

					// Spaces cannot appear at the end of a line. So, encode the space.
					if (bufferPos >= bufferLength ||
					    (buffer[bufferPos] == '\r' || buffer[bufferPos] == '\n')) {

						QP_ENCODE_HEX(' ');

					} else {

						outBuffer[outBufferPos++] = ' ';
						++curCol;
					}

					break;
				}
				case 9: {   // TAB

					QP_ENCODE_HEX(c);
					break;
				}
				case 13:    // CR
				case 10: {  // LF

					// RFC-2045/6.7(4)

					// Text data
					if (text && !rfc2047) {

						outBuffer[outBufferPos++] = c;
						++curCol;

						if (c == 10) {
							curCol = 0;  // reset current line length
						}

					// Binary data
					} else {

						QP_ENCODE_HEX(c);
					}

					break;
				}
				case 61: {  // =

					QP_ENCODE_HEX('=');
					break;
				}
				/*
					Rule #2: (Literal representation) Octets with decimal values of 33
					through 60 inclusive, and 62 through 126, inclusive, MAY be
					represented as the ASCII characters which correspond to those
					octets (EXCLAMATION POINT through LESS THAN, and GREATER THAN
					through TILDE, respectively).
				*/
				default:

					//if ((c >= 33 && c <= 60) || (c >= 62 && c <= 126))
					if (c >= 33 && c <= 126 && c != 61 && c != 63) {

						outBuffer[outBufferPos++] = c;
						++curCol;

					// Other characters: '=' + hexadecimal encoding
					} else {

						QP_ENCODE_HEX(c);
					}

					break;

			} // switch (c)

			// Soft line break : "=\r\n"
			if (cutLines && curCol >= maxLineLength - 1) {

				outBuffer[outBufferPos] = '=';
				outBuffer[outBufferPos + 1] = '\r';
				outBuffer[outBufferPos + 2] = '\n';

				outBufferPos += 3;
				curCol = 0;
			}

		} // !rfc2047

		++inTotal;

		if (progress) {
			progress->progress(inTotal, inTotal);
		}
	}

	// Flush remaining output buffer
	if (outBufferPos != 0) {
		QP_WRITE(out, outBuffer, outBufferPos);
		total += outBufferPos;
	}

	if (progress) {
		progress->stop(inTotal);
	}

	return total;
}
Ejemplo n.º 6
0
void charsetConverter::convert(utility::inputStream& in, utility::outputStream& out)
{
	if (m_desc == NULL)
		throw exceptions::charset_conv_error("Cannot initialize converter.");

	const iconv_t cd = *static_cast <iconv_t*>(m_desc);

	char inBuffer[32768];
	char outBuffer[32768];
	size_t inPos = 0;

	bool prevIsInvalid = false;

	while (true)
	{
		// Fullfill the buffer
		size_t inLength = static_cast <size_t>(in.read(inBuffer + inPos, sizeof(inBuffer) - inPos) + inPos);
		size_t outLength = sizeof(outBuffer);

		const char* inPtr = inBuffer;
		char* outPtr = outBuffer;

		// Convert input bytes
		if (iconv(cd, ICONV_HACK(&inPtr), &inLength,
			      &outPtr, &outLength) == static_cast <size_t>(-1))
		{
			// Illegal input sequence or input sequence has no equivalent
			// sequence in the destination charset.
			if (prevIsInvalid)
			{
				// Write successfully converted bytes
				out.write(outBuffer, sizeof(outBuffer) - outLength);

				// Output a special character to indicate we don't known how to
				// convert the sequence at this position
				out.write("?", 1);

				// Skip a byte and leave unconverted bytes in the input buffer
				std::copy(const_cast <char*>(inPtr + 1), inBuffer + sizeof(inBuffer), inBuffer);
				inPos = inLength - 1;
			}
			else
			{
				// Write successfully converted bytes
				out.write(outBuffer, sizeof(outBuffer) - outLength);

				// Leave unconverted bytes in the input buffer
				std::copy(const_cast <char*>(inPtr), inBuffer + sizeof(inBuffer), inBuffer);
				inPos = inLength;

				if (errno != E2BIG)
					prevIsInvalid = true;
			}
		}
		else
		{
			// Write successfully converted bytes
			out.write(outBuffer, sizeof(outBuffer) - outLength);

			inPos = 0;
			prevIsInvalid = false;
		}

		// Check for end of data
		if (in.eof() && inPos == 0)
			break;
	}
}
Ejemplo n.º 7
0
void charsetConverter_icu::convert
	(utility::inputStream& in, utility::outputStream& out, status* st)
{
	UErrorCode err = U_ZERO_ERROR;

	ucnv_reset(m_from);
	ucnv_reset(m_to);

	if (st)
		new (st) status();

	// From buffers
	byte_t cpInBuffer[16]; // stream data put here
	const size_t outSize = ucnv_getMinCharSize(m_from) * sizeof(cpInBuffer) * sizeof(UChar);
	std::vector <UChar> uOutBuffer(outSize); // Unicode chars end up here

	// To buffers
	// converted (char) data end up here
	const size_t cpOutBufferSz = ucnv_getMaxCharSize(m_to) * outSize;
	std::vector <char> cpOutBuffer(cpOutBufferSz);

	// Tell ICU what to do when encountering an illegal byte sequence
	if (m_options.silentlyReplaceInvalidSequences)
	{
		// Set replacement chars for when converting from Unicode to codepage
		icu::UnicodeString substString(m_options.invalidSequence.c_str());
		ucnv_setSubstString(m_to, substString.getTerminatedBuffer(), -1, &err);

		if (U_FAILURE(err))
			throw exceptions::charset_conv_error("[ICU] Error when setting substitution string.");
	}
	else
	{
		// Tell ICU top stop (and return an error) on illegal byte sequences
		ucnv_setToUCallBack
			(m_from, UCNV_TO_U_CALLBACK_STOP, UCNV_SUB_STOP_ON_ILLEGAL, NULL, NULL, &err);

		if (U_FAILURE(err))
			throw exceptions::charset_conv_error("[ICU] Error when setting ToU callback.");

		ucnv_setFromUCallBack
			(m_to, UCNV_FROM_U_CALLBACK_STOP, UCNV_SUB_STOP_ON_ILLEGAL, NULL, NULL, &err);

		if (U_FAILURE(err))
			throw exceptions::charset_conv_error("[ICU] Error when setting FromU callback.");
	}

	// Input data available
	while (!in.eof())
	{
		// Read input data into buffer
		size_t inLength = in.read(cpInBuffer, sizeof(cpInBuffer));

		// Beginning of read data
		const char* source = reinterpret_cast <const char*>(&cpInBuffer[0]);
		const char* sourceLimit = source + inLength; // end + 1

		UBool flush = in.eof();  // is this last run?

		UErrorCode toErr;

		// Loop until all source has been processed
		do
		{
			// Set up target pointers
			UChar* target = &uOutBuffer[0];
			UChar* targetLimit = &target[0] + outSize;

			toErr = U_ZERO_ERROR;
			ucnv_toUnicode(m_from, &target, targetLimit,
			               &source, sourceLimit, NULL, flush, &toErr);

			if (st)
				st->inputBytesRead += (source - reinterpret_cast <const char*>(&cpInBuffer[0]));

			if (toErr != U_BUFFER_OVERFLOW_ERROR && U_FAILURE(toErr))
			{
				if (toErr == U_INVALID_CHAR_FOUND ||
				    toErr == U_TRUNCATED_CHAR_FOUND ||
				    toErr == U_ILLEGAL_CHAR_FOUND)
				{
					// Error will be thrown later (*)
				}
				else
				{
					throw exceptions::charset_conv_error("[ICU] Error converting to Unicode from " + m_source.getName());
				}
			}

			// The Unicode source is the buffer just written and the limit
			// is where the previous conversion stopped (target is moved in the conversion)
			const UChar* uSource = &uOutBuffer[0];
			UChar* uSourceLimit = &target[0];
			UErrorCode fromErr;

			// Loop until converted chars are fully written
			do
			{
				char* cpTarget = &cpOutBuffer[0];
				const char* cpTargetLimit = &cpOutBuffer[0] + cpOutBufferSz;

				fromErr = U_ZERO_ERROR;

				// Write converted bytes (Unicode) to destination codepage
				ucnv_fromUnicode(m_to, &cpTarget, cpTargetLimit,
				                 &uSource, uSourceLimit, NULL, flush, &fromErr);

				if (st)
				{
					// Decrement input bytes count by the number of input bytes in error
					char errBytes[16];
					int8_t errBytesLen = sizeof(errBytes);
					UErrorCode errBytesErr = U_ZERO_ERROR;

	 				ucnv_getInvalidChars(m_from, errBytes, &errBytesLen, &errBytesErr);

					st->inputBytesRead -= errBytesLen;
					st->outputBytesWritten += cpTarget - &cpOutBuffer[0];
				}

				// (*) If an error occurred while converting from input charset, throw it now
				if (toErr == U_INVALID_CHAR_FOUND ||
				    toErr == U_TRUNCATED_CHAR_FOUND ||
				    toErr == U_ILLEGAL_CHAR_FOUND)
				{
					throw exceptions::illegal_byte_sequence_for_charset();
				}

				if (fromErr != U_BUFFER_OVERFLOW_ERROR && U_FAILURE(fromErr))
				{
					if (fromErr == U_INVALID_CHAR_FOUND ||
					    fromErr == U_TRUNCATED_CHAR_FOUND ||
					    fromErr == U_ILLEGAL_CHAR_FOUND)
					{
						throw exceptions::illegal_byte_sequence_for_charset();
					}
					else
					{
						throw exceptions::charset_conv_error("[ICU] Error converting from Unicode to " + m_dest.getName());
					}
				}

				// Write to destination stream
				out.write(&cpOutBuffer[0], (cpTarget - &cpOutBuffer[0]));

			} while (fromErr == U_BUFFER_OVERFLOW_ERROR);

		} while (toErr == U_BUFFER_OVERFLOW_ERROR);
	}
}