File vmime-all4debian.diff of Package libvmime_zarafa7

Overview Repositories Revisions Requests Users Attributes Meta

File vmime-all4debian.diff of Package libvmime_zarafa7

Index: vmime/src/base.cpp
===================================================================
--- vmime.orig/src/base.cpp
+++ vmime/src/base.cpp
@@ -74,7 +74,7 @@ const string libname() { return (VMIME_P
   *
   * @return library version
   */
-const string libversion() { return (VMIME_VERSION " (" __DATE__ " " __TIME__ ")"); }
+const string libversion() { return (VMIME_VERSION " ()"); }
 
 /** Return the library API version (eg: "6:1:6").
   *
Index: vmime/src/constants.cpp
===================================================================
--- vmime.orig/src/constants.cpp
+++ vmime/src/constants.cpp
@@ -80,6 +80,7 @@ namespace encodingTypes
 	const string::value_type* const QUOTED_PRINTABLE = "quoted-printable";
 	const string::value_type* const BINARY = "binary";
 	const string::value_type* const UUENCODE = "uuencode";
+	const string::value_type* const X_UUENCODE = "x-uuencode";
 }
 
 
Index: vmime/src/headerField.cpp
===================================================================
--- vmime.orig/src/headerField.cpp
+++ vmime/src/headerField.cpp
@@ -132,7 +132,9 @@ ref <headerField> headerField::parseNext
 				                  buffer.begin() + nameEnd);
 
 				// Skip ':' character
-				++pos;
+				// Patch: don't just skip one colon, but any and all, if available. NS 2 December 2013
+				while ((pos < end) && (buffer[pos] == ':'))
+				    ++pos;
 
 				// Skip spaces between ':' and the field contents
 				while (pos < end && (buffer[pos] == ' ' || buffer[pos] == '\t'))
@@ -157,14 +159,12 @@ ref <headerField> headerField::parseNext
 					{
 						contentsEnd = pos;
 						pos += 2;
-						break;
 					}
 					else if (c == '\n')
 					{
 						contentsEnd = pos;
 						++pos;
-						break;
-					}
+					} else {
 
 					while (pos < end)
 					{
@@ -186,24 +186,13 @@ ref <headerField> headerField::parseNext
 
 						++pos;
 					}
+					}
 
 					// Handle the case of folded lines
 					if (buffer[pos] == ' ' || buffer[pos] == '\t')
 					{
 						// This is a folding white-space: we keep it as is and
 						// we continue with contents parsing...
-
-						// If the line contains only space characters, we assume it is
-						// the end of the headers. This is not strictly standard-compliant
-						// but, hey, we can't fail when parsing some malformed mails...
-						while (pos < end && (buffer[pos] == ' ' || buffer[pos] == '\t'))
-							++pos;
-
-						if ((pos < end && buffer[pos] == '\n') ||
-						    (pos + 1 < end && buffer[pos] == '\r' && buffer[pos + 1] == '\n'))
-						{
-							break;
-						}
 					}
 					else
 					{
Index: vmime/src/mailboxList.cpp
===================================================================
--- vmime.orig/src/mailboxList.cpp
+++ vmime/src/mailboxList.cpp
@@ -22,6 +22,7 @@
 //
 
 #include "vmime/mailboxList.hpp"
+#include "vmime/mailboxGroup.hpp"
 #include "vmime/exception.hpp"
 
 
@@ -199,7 +200,34 @@ const std::vector <ref <const component>
 void mailboxList::parse(const string& buffer, const string::size_type position,
 	const string::size_type end, string::size_type* newPosition)
 {
-	m_list.parse(buffer, position, end, newPosition);
+	string::size_type pos = position;
+
+	while (pos < end)
+	{
+		ref <address> parsedAddress = address::parseNext(buffer, pos, end, &pos);
+
+		if (parsedAddress != NULL)
+		{
+			if (parsedAddress->isGroup())
+			{
+				ref <mailboxGroup> group = parsedAddress.staticCast <mailboxGroup>();
+
+				for (size_t i = 0 ; i < group->getMailboxCount() ; ++i)
+				{
+					m_list.appendAddress(group->getMailboxAt(i));
+				}
+			}
+			else
+			{
+				m_list.appendAddress(parsedAddress);
+			}
+		}
+	}
+
+	setParsedBounds(position, end);
+
+	if (newPosition)
+		*newPosition = end;
 }
 
 
Index: vmime/src/parameter.cpp
===================================================================
--- vmime.orig/src/parameter.cpp
+++ vmime/src/parameter.cpp
@@ -240,7 +240,17 @@ void parameter::parse(const std::vector
 				value << t.getWholeBuffer();
 
 				if (!foundCharsetChunk)
-					ch = t.getWordAt(0)->getCharset();
+					// this is still wrong. each word can have its
+					// own charset, and can be mixed (eg. iso-8859-1
+					// and iso-2022-jp), but very unlikely.
+					// real fix is to have parameters store a
+					// vmime::text instead of a vmime::word in
+					// m_value.  but that changes the interface
+					for (size_t i = 0; i < t.getWordCount(); i++)
+						if (t.getWordAt(i)->getCharset() != ch && ch == charsets::US_ASCII) {
+							ch = t.getWordAt(i)->getCharset();
+							break;
+						}
 			}
 		}
 	}
@@ -390,7 +400,9 @@ void parameter::generate(utility::output
 
 	// Also generate an extended parameter if the value contains 8-bit characters
 	// or is too long for a single line
-	if (extended || cutValue)
+
+	// Disable RFC-2231 header generation. Some email clients have bad reactions to it.
+	if ((extended || cutValue) && false)
 	{
 
 #if VMIME_ALWAYS_GENERATE_7BIT_PARAMETER
Index: vmime/src/parameterizedHeaderField.cpp
===================================================================
--- vmime.orig/src/parameterizedHeaderField.cpp
+++ vmime/src/parameterizedHeaderField.cpp
@@ -97,7 +97,7 @@ void parameterizedHeaderField::parse(con
 	// Advance up to ';', if any
 	string::size_type valueLength = 0;
 
-	while (p < pend && *p != ';')  // FIXME: support ";" inside quoted or RFC-2047-encoded text
+	while (p < pend && *p != ';' && (!parserHelpers::isSpace(*p)))  // FIXME: support ";" inside quoted or RFC-2047-encoded text
 	{
 		++p;
 		++valueLength;
@@ -118,6 +118,10 @@ void parameterizedHeaderField::parse(con
 	{
 		std::map <string, paramInfo> params;
 
+		if (*p != ';')
+			while (p < pend && *p != ';')  // FIXME: support ";" inside quoted or RFC-2047-encoded text
+				++p;
+
 		while (*p == ';')
 		{
 			// Skip ';'
Index: vmime/src/platforms/posix/posixHandler.cpp
===================================================================
--- vmime.orig/src/platforms/posix/posixHandler.cpp
+++ vmime/src/platforms/posix/posixHandler.cpp
@@ -153,11 +153,7 @@ const vmime::charset posixHandler::getLo
 {
 	const PLockHelper lock;
 
-	const char* prevLocale = ::setlocale(LC_ALL, "");
-	vmime::charset ch(::nl_langinfo(CODESET));
-	::setlocale(LC_ALL, prevLocale);
-
-	return (ch);
+	return vmime::charset(::nl_langinfo(CODESET));
 }
 
 
Index: vmime/src/utility/encoder/encoderFactory.cpp
===================================================================
--- vmime.orig/src/utility/encoder/encoderFactory.cpp
+++ vmime/src/utility/encoder/encoderFactory.cpp
@@ -43,6 +43,7 @@ encoderFactory::encoderFactory()
 	registerName <b64Encoder>("base64");
 	registerName <qpEncoder>("quoted-printable");
 	registerName <uuEncoder>("uuencode");
+	registerName <uuEncoder>("x-uuencode");
 	registerName <sevenBitEncoder>("7bit");
 	registerName <eightBitEncoder>("8bit");
 	registerName <binaryEncoder>("binary");
Index: vmime/src/word.cpp
===================================================================
--- vmime.orig/src/word.cpp
+++ vmime/src/word.cpp
@@ -64,8 +64,7 @@ word::word(const string& buffer, const c
 
 
 ref <word> word::parseNext(const string& buffer, const string::size_type position,
-	const string::size_type end, string::size_type* newPosition,
-	bool prevIsEncoded, bool* isEncoded, bool isFirst)
+	const string::size_type end, string::size_type* newPosition, parserState* state)
 {
 	string::size_type pos = position;
 
@@ -73,11 +72,14 @@ ref <word> word::parseNext(const string&
 	//   - before the first word
 	//   - between two encoded words
 	//   - after the last word
+	// Always ignore newlines
 	string whiteSpaces;
 
 	while (pos < end && parserHelpers::isSpace(buffer[pos]))
 	{
 		whiteSpaces += buffer[pos];
+		if(buffer[pos] != '\r' && buffer[pos] != '\n') // do not include newlines
+			whiteSpaces += buffer[pos];
 		++pos;
 	}
 
@@ -118,7 +120,7 @@ ref <word> word::parseNext(const string&
 
 			if (!unencoded.empty())
 			{
-				if (prevIsEncoded)
+				if (state->prevIsEncoded && !state->isFirst)
 					unencoded = whiteSpaces + unencoded;
 
 				ref <word> w = vmime::create <word>(unencoded, charset(charsets::US_ASCII));
@@ -127,8 +129,8 @@ ref <word> word::parseNext(const string&
 				if (newPosition)
 					*newPosition = pos;
 
-				if (isEncoded)
-					*isEncoded = false;
+				state->prevIsEncoded = false;
+				state->isFirst = false;
 
 				return (w);
 			}
@@ -179,13 +181,13 @@ ref <word> word::parseNext(const string&
 			pos += 2; // ?=
 
 			ref <word> w = vmime::create <word>();
-			w->parse(buffer, wordStart, pos, NULL);
+			w->parseWithState(buffer, wordStart, pos, NULL, state);
 
 			if (newPosition)
 				*newPosition = pos;
 
-			if (isEncoded)
-				*isEncoded = true;
+			state->prevIsEncoded = true;
+			state->isFirst = false;
 
 			return (w);
 		}
@@ -193,7 +195,7 @@ ref <word> word::parseNext(const string&
 		++pos;
 	}
 
-	if (startPos != end && !isFirst && prevIsEncoded)
+	if (startPos != end && !state->isFirst && state->prevIsEncoded)
 		unencoded += whiteSpaces;
 
 	if (startPos != end)
@@ -208,8 +210,8 @@ ref <word> word::parseNext(const string&
 		if (newPosition)
 			*newPosition = end;
 
-		if (isEncoded)
-			*isEncoded = false;
+		state->prevIsEncoded = false;
+		state->isFirst = false;
 
 		return (w);
 	}
@@ -226,9 +228,9 @@ const std::vector <ref <word> > word::pa
 
 	string::size_type pos = position;
 
-	bool prevIsEncoded = false;
+	parserState state;
 
-	while ((w = word::parseNext(buffer, pos, end, &pos, prevIsEncoded, &prevIsEncoded, (w == NULL))) != NULL)
+	while ((w = word::parseNext(buffer, pos, end, &pos, &state)) != NULL)
 		res.push_back(w);
 
 	if (newPosition)
@@ -241,6 +243,14 @@ const std::vector <ref <word> > word::pa
 void word::parse(const string& buffer, const string::size_type position,
 	const string::size_type end, string::size_type* newPosition)
 {
+	parseWithState(buffer, position, end, newPosition, NULL);
+}
+
+
+void word::parseWithState
+	(const string& buffer, const size_t position,
+	 const size_t end, size_t* newPosition, parserState* state)
+{
 	if (position + 6 < end && // 6 = "=?(.+)?(.*)?="
 	    buffer[position] == '=' && buffer[position + 1] == '?')
 	{
@@ -287,12 +297,20 @@ void word::parse(const string& buffer, c
 					if (theEncoder)
 					{
 						// Decode text
+						string encodedBuffer(dataPos, dataEnd);
 						string decodedBuffer;
 
-						utility::inputStreamStringAdapter ein(string(dataPos, dataEnd));
+
+                                                if (state && !state->undecodedBytes.empty())
+                                                {
+                                                        encodedBuffer = state->undecodedBytes + encodedBuffer;
+                                                        state->undecodedBytes.clear();
+                                                }
+ 
+                                                utility::inputStreamStringAdapter ein(encodedBuffer);
 						utility::outputStreamStringAdapter eout(decodedBuffer);
 
-						theEncoder->decode(ein, eout);
+						const size_t decodedLen = theEncoder->decode(ein, eout);
 						delete (theEncoder);
 
 						m_buffer = decodedBuffer;
@@ -303,6 +321,21 @@ void word::parse(const string& buffer, c
 						if (newPosition)
 							*newPosition = (p - buffer.begin());
 
+						// For Base64 encoding, ensure all bytes have been decoded.
+						// If there are remaining bytes, keep them for the next run.
+						//
+						// This allows decoding some insanities like:
+						//     =?utf-8?B?5Lit5?= =?utf-8?B?paH?=
+						if (*encPos == 'B' || *encPos == 'b')
+						{
+							const size_t actualEncodedLen = encodedBuffer.length();
+							const size_t theoricalEncodedLen =
+								((decodedLen + ((decodedLen % 3) ? (3 - (decodedLen % 3)) : 0) ) / 3) * 4;
+
+							if (state && actualEncodedLen != theoricalEncodedLen)
+								state->undecodedBytes.assign(dataPos + theoricalEncodedLen, dataEnd);
+						}
+
 						return;
 					}
 				}
@@ -690,9 +723,19 @@ bool word::operator!=(const word& w) con
 
 const string word::getConvertedText(const charset& dest) const
 {
+        if (dest == m_charset) {
+                return m_buffer;  // no conversion needed
+        }
+
 	string out;
 
+	try {
 	charset::convert(m_buffer, out, m_charset, dest);
+	}
+	catch (vmime::exception &e) {
+		// copy 'word' as text
+		out = m_buffer;
+	}
 
 	return (out);
 }
Index: vmime/src/wordEncoder.cpp
===================================================================
--- vmime.orig/src/wordEncoder.cpp
+++ vmime/src/wordEncoder.cpp
@@ -239,6 +239,13 @@ bool wordEncoder::isEncodingNeeded(const
 	if (buffer.find_first_of("\n\r") != string::npos)
 		return true;
 
+	// If the string contains a QP string, we need to encode this.
+	// Not a 100% check, but we'd only get more encoded strings.
+	std::string::size_type pos = buffer.find("=?");
+	std::string::size_type end = buffer.find("?=");
+	if (pos != string::npos && end != string::npos && end > pos)
+		return true;
+
 	return false;
 }
 
Index: vmime/vmime/address.hpp
===================================================================
--- vmime.orig/vmime/address.hpp
+++ vmime/vmime/address.hpp
@@ -65,7 +65,6 @@ public:
 
 	virtual ref <component> clone() const = 0;
 
-protected:
 
 	/** Parse an address from an input buffer.
 	  *
Index: vmime/vmime/word.hpp
===================================================================
--- vmime.orig/vmime/word.hpp
+++ vmime/vmime/word.hpp
@@ -125,6 +125,20 @@ public:
 		bool prevWordIsEncoded;
 		bool lastCharIsSpace;
 	};
+
+	class parserState
+	{
+	public:
+
+		parserState()
+			: prevIsEncoded(false), isFirst(true)
+		{
+		}
+
+		bool prevIsEncoded;
+		bool isFirst;
+		std::string undecodedBytes;
+	};
 #endif
 
 
@@ -134,13 +148,20 @@ public:
 	void parse(const string& buffer, const string::size_type position, const string::size_type end, string::size_type* newPosition = NULL);
 	void generate(utility::outputStream& os, const string::size_type maxLineLength = lineLengthLimits::infinite, const string::size_type curLinePos = 0, string::size_type* newLinePos = NULL) const;
 
+       void parseWithState
+               (const string& buffer,
+                const size_t position,
+                const size_t end,
+                size_t* newPosition,
+                parserState* state);
+
 	void generate(utility::outputStream& os, const string::size_type maxLineLength, const string::size_type curLinePos, string::size_type* newLinePos, const int flags, generatorState* state) const;
 
 	const std::vector <ref <const component> > getChildComponents() const;
 
 private:
 
-	static ref <word> parseNext(const string& buffer, const string::size_type position, const string::size_type end, string::size_type* newPosition, bool prevIsEncoded, bool* isEncoded, bool isFirst);
+	static ref <word> parseNext(const string& buffer, const string::size_type position, const string::size_type end, string::size_type* newPosition, parserState* state);
 
 	static const std::vector <ref <word> > parseMultiple(const string& buffer, const string::size_type position, const string::size_type end, string::size_type* newPosition);

Places

File vmime-all4debian.diff of Package libvmime_zarafa7

Places