diff options
Diffstat (limited to 'protocols/MSN/src/msn_mime.cpp')
| -rw-r--r-- | protocols/MSN/src/msn_mime.cpp | 534 |
1 files changed, 534 insertions, 0 deletions
diff --git a/protocols/MSN/src/msn_mime.cpp b/protocols/MSN/src/msn_mime.cpp new file mode 100644 index 0000000000..b925e101bb --- /dev/null +++ b/protocols/MSN/src/msn_mime.cpp @@ -0,0 +1,534 @@ +/*
+Plugin of Miranda IM for communicating with users of the MSN Messenger protocol.
+Copyright (c) 2006-2012 Boris Krasnovskiy.
+Copyright (c) 2003-2005 George Hazan.
+Copyright (c) 2002-2003 Richard Hughes (original version).
+
+This program 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 2
+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/>.
+*/
+
+#include "msn_global.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// constructors and destructor
+
+MimeHeaders::MimeHeaders() :
+ mCount(0),
+ mAllocCount(0),
+ mVals(NULL)
+{
+}
+
+MimeHeaders::MimeHeaders(unsigned iInitCount) :
+ mCount(0)
+{
+ mAllocCount = iInitCount;
+ mVals = (MimeHeader*)mir_alloc(iInitCount * sizeof(MimeHeader));
+}
+
+MimeHeaders::~MimeHeaders()
+{
+ clear();
+ mir_free(mVals);
+}
+
+void MimeHeaders::clear(void)
+{
+ for (unsigned i=0; i < mCount; i++)
+ {
+ MimeHeader& H = mVals[i];
+ if (H.flags & 1) mir_free((void*)H.name);
+ if (H.flags & 2) mir_free((void*)H.value);
+ }
+ mCount = 0;
+}
+
+unsigned MimeHeaders::allocSlot(void)
+{
+ if (++mCount >= mAllocCount)
+ {
+ mAllocCount += 10;
+ mVals = (MimeHeader*)mir_realloc(mVals, sizeof(MimeHeader) * mAllocCount);
+ }
+ return mCount - 1;
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// add various values
+
+void MimeHeaders::addString(const char* name, const char* szValue, unsigned flags)
+{
+ if (szValue == NULL) return;
+
+ MimeHeader& H = mVals[allocSlot()];
+ H.name = name;
+ H.value = szValue;
+ H.flags = flags;
+}
+
+void MimeHeaders::addLong(const char* name, long lValue, unsigned flags)
+{
+ MimeHeader& H = mVals[allocSlot()];
+ H.name = name;
+
+ char szBuffer[20];
+ _ltoa(lValue, szBuffer, 10);
+ H.value = mir_strdup(szBuffer);
+ H.flags = 2 | flags;
+}
+
+void MimeHeaders::addULong(const char* name, unsigned lValue)
+{
+ MimeHeader& H = mVals[allocSlot()];
+ H.name = name;
+
+ char szBuffer[20];
+ _ultoa(lValue, szBuffer, 10);
+ H.value = mir_strdup(szBuffer);
+ H.flags = 2;
+}
+
+void MimeHeaders::addBool(const char* name, bool lValue)
+{
+ MimeHeader& H = mVals[allocSlot()];
+ H.name = name;
+ H.value = lValue ? "true" : "false";
+ H.flags = 0;
+}
+
+char* MimeHeaders::flipStr(const char* src, size_t len, char* dest)
+{
+ if (len == -1) len = strlen(src);
+
+ if (src == dest)
+ {
+ const unsigned b = (unsigned)len-- / 2;
+ for (unsigned i = 0; i < b; i++)
+ {
+ const char c = dest[i];
+ dest[i] = dest[len - i];
+ dest[len - i] = c;
+ }
+ ++len;
+ }
+ else
+ {
+ for (unsigned i = 0; i < len; i++)
+ dest[i] = src[len - 1 - i];
+ dest[len] = 0;
+ }
+
+ return dest + len;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// write all values to a buffer
+
+size_t MimeHeaders::getLength(void)
+{
+ size_t iResult = 0;
+ for (unsigned i=0; i < mCount; i++)
+ {
+ MimeHeader& H = mVals[i];
+ iResult += strlen(H.name) + strlen(H.value) + 4;
+ }
+
+ return iResult + (iResult ? 2 : 0);
+}
+
+char* MimeHeaders::writeToBuffer(char* dest)
+{
+ for (unsigned i=0; i < mCount; i++)
+ {
+ MimeHeader& H = mVals[i];
+ if (H.flags & 4)
+ {
+ dest = flipStr(H.name, -1, dest);
+
+ *(dest++) = ':';
+ *(dest++) = ' ';
+
+ dest = flipStr(H.value, -1, dest);
+
+ *(dest++) = '\r';
+ *(dest++) = '\n';
+ *dest = 0;
+ }
+ else
+ dest += sprintf(dest, "%s: %s\r\n", H.name, H.value);
+ }
+
+ if (mCount)
+ {
+ *(dest++) = '\r';
+ *(dest++) = '\n';
+ *dest = 0;
+ }
+
+ return dest;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// read set of values from buffer
+
+char* MimeHeaders::readFromBuffer(char* src)
+{
+ clear();
+
+ while (*src)
+ {
+ char* peol = strchr(src, '\n');
+
+ if (peol == NULL)
+ return strchr(src, 0);
+ else if (peol == src)
+ return src + 1;
+ else if (peol == (src + 1) && *src == '\r')
+ return src + 2;
+
+ *peol = 0;
+
+ char* delim = strchr(src, ':');
+ if (delim)
+ {
+ *delim = 0;
+
+ MimeHeader& H = mVals[allocSlot()];
+
+ H.name = lrtrimp(src);
+ H.value = lrtrimp(delim + 1);
+ H.flags = 0;
+ }
+
+ src = peol + 1;
+ }
+
+ return src;
+}
+
+const char* MimeHeaders::find(const char* szFieldName)
+{
+ size_t i;
+ for (i = 0; i < mCount; i++)
+ {
+ MimeHeader& MH = mVals[i];
+ if (_stricmp(MH.name, szFieldName) == 0)
+ return MH.value;
+ }
+
+ const size_t len = strlen(szFieldName);
+ char* szFieldNameR = (char*)alloca(len + 1);
+ flipStr(szFieldName, len, szFieldNameR);
+
+ for (i = 0; i < mCount; i++)
+ {
+ MimeHeader& MH = mVals[i];
+ if (_stricmp(MH.name, szFieldNameR) == 0 && (MH.flags & 3) == 0)
+ {
+ strcpy((char*)MH.name, szFieldNameR);
+ flipStr(MH.value, -1, (char*)MH.value);
+ return MH.value;
+ }
+ }
+
+ return NULL;
+}
+
+static const struct _tag_cpltbl
+{
+ unsigned cp;
+ const char* mimecp;
+} cptbl[] =
+{
+ { 37, "IBM037" }, // IBM EBCDIC US-Canada
+ { 437, "IBM437" }, // OEM United States
+ { 500, "IBM500" }, // IBM EBCDIC International
+ { 708, "ASMO-708" }, // Arabic (ASMO 708)
+ { 720, "DOS-720" }, // Arabic (Transparent ASMO); Arabic (DOS)
+ { 737, "ibm737" }, // OEM Greek (formerly 437G); Greek (DOS)
+ { 775, "ibm775" }, // OEM Baltic; Baltic (DOS)
+ { 850, "ibm850" }, // OEM Multilingual Latin 1; Western European (DOS)
+ { 852, "ibm852" }, // OEM Latin 2; Central European (DOS)
+ { 855, "IBM855" }, // OEM Cyrillic (primarily Russian)
+ { 857, "ibm857" }, // OEM Turkish; Turkish (DOS)
+ { 858, "IBM00858" }, // OEM Multilingual Latin 1 + Euro symbol
+ { 860, "IBM860" }, // OEM Portuguese; Portuguese (DOS)
+ { 861, "ibm861" }, // OEM Icelandic; Icelandic (DOS)
+ { 862, "DOS-862" }, // OEM Hebrew; Hebrew (DOS)
+ { 863, "IBM863" }, // OEM French Canadian; French Canadian (DOS)
+ { 864, "IBM864" }, // OEM Arabic; Arabic (864)
+ { 865, "IBM865" }, // OEM Nordic; Nordic (DOS)
+ { 866, "cp866" }, // OEM Russian; Cyrillic (DOS)
+ { 869, "ibm869" }, // OEM Modern Greek; Greek, Modern (DOS)
+ { 870, "IBM870" }, // IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2
+ { 874, "windows-874" }, // ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows)
+ { 875, "cp875" }, // IBM EBCDIC Greek Modern
+ { 932, "shift_jis" }, // ANSI/OEM Japanese; Japanese (Shift-JIS)
+ { 936, "gb2312" }, // ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312)
+ { 949, "ks_c_5601-1987" }, // ANSI/OEM Korean (Unified Hangul Code)
+ { 950, "big5" }, // ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5)
+ { 1026, "IBM1026" }, // IBM EBCDIC Turkish (Latin 5)
+ { 1047, "IBM01047" }, // IBM EBCDIC Latin 1/Open System
+ { 1140, "IBM01140" }, // IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro)
+ { 1141, "IBM01141" }, // IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro)
+ { 1142, "IBM01142" }, // IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro)
+ { 1143, "IBM01143" }, // IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro)
+ { 1144, "IBM01144" }, // IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro)
+ { 1145, "IBM01145" }, // IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro)
+ { 1146, "IBM01146" }, // IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro)
+ { 1147, "IBM01147" }, // IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro)
+ { 1148, "IBM01148" }, // IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro)
+ { 1149, "IBM01149" }, // IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro)
+ { 1250, "windows-1250" }, // ANSI Central European; Central European (Windows)
+ { 1251, "windows-1251" }, // ANSI Cyrillic; Cyrillic (Windows)
+ { 1252, "windows-1252" }, // ANSI Latin 1; Western European (Windows)
+ { 1253, "windows-1253" }, // ANSI Greek; Greek (Windows)
+ { 1254, "windows-1254" }, // ANSI Turkish; Turkish (Windows)
+ { 1255, "windows-1255" }, // ANSI Hebrew; Hebrew (Windows)
+ { 1256, "windows-1256" }, // ANSI Arabic; Arabic (Windows)
+ { 1257, "windows-1257" }, // ANSI Baltic; Baltic (Windows)
+ { 1258, "windows-1258" }, // ANSI/OEM Vietnamese; Vietnamese (Windows)
+ { 20127, "us-ascii" }, // US-ASCII (7-bit)
+ { 20273, "IBM273" }, // IBM EBCDIC Germany
+ { 20277, "IBM277" }, // IBM EBCDIC Denmark-Norway
+ { 20278, "IBM278" }, // IBM EBCDIC Finland-Sweden
+ { 20280, "IBM280" }, // IBM EBCDIC Italy
+ { 20284, "IBM284" }, // IBM EBCDIC Latin America-Spain
+ { 20285, "IBM285" }, // IBM EBCDIC United Kingdom
+ { 20290, "IBM290" }, // IBM EBCDIC Japanese Katakana Extended
+ { 20297, "IBM297" }, // IBM EBCDIC France
+ { 20420, "IBM420" }, // IBM EBCDIC Arabic
+ { 20423, "IBM423" }, // IBM EBCDIC Greek
+ { 20424, "IBM424" }, // IBM EBCDIC Hebrew
+ { 20838, "IBM-Thai" }, // IBM EBCDIC Thai
+ { 20866, "koi8-r" }, // Russian (KOI8-R); Cyrillic (KOI8-R)
+ { 20871, "IBM871" }, // IBM EBCDIC Icelandic
+ { 20880, "IBM880" }, // IBM EBCDIC Cyrillic Russian
+ { 20905, "IBM905" }, // IBM EBCDIC Turkish
+ { 20924, "IBM00924" }, // IBM EBCDIC Latin 1/Open System (1047 + Euro symbol)
+ { 20932, "EUC-JP" }, // Japanese (JIS 0208-1990 and 0121-1990)
+ { 21025, "cp1025" }, // IBM EBCDIC Cyrillic Serbian-Bulgarian
+ { 21866, "koi8-u" }, // Ukrainian (KOI8-U); Cyrillic (KOI8-U)
+ { 28591, "iso-8859-1" }, // ISO 8859-1 Latin 1; Western European (ISO)
+ { 28592, "iso-8859-2" }, // ISO 8859-2 Central European; Central European (ISO)
+ { 28593, "iso-8859-3" }, // ISO 8859-3 Latin 3
+ { 28594, "iso-8859-4" }, // ISO 8859-4 Baltic
+ { 28595, "iso-8859-5" }, // ISO 8859-5 Cyrillic
+ { 28596, "iso-8859-6" }, // ISO 8859-6 Arabic
+ { 28597, "iso-8859-7" }, // ISO 8859-7 Greek
+ { 28598, "iso-8859-8" }, // ISO 8859-8 Hebrew; Hebrew (ISO-Visual)
+ { 28599, "iso-8859-9" }, // ISO 8859-9 Turkish
+ { 28603, "iso-8859-13" }, // ISO 8859-13 Estonian
+ { 28605, "iso-8859-15" }, // ISO 8859-15 Latin 9
+ { 38598, "iso-8859-8-i" }, // ISO 8859-8 Hebrew; Hebrew (ISO-Logical)
+ { 50220, "iso-2022-jp" }, // ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS)
+ { 50221, "csISO2022JP" }, // ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana)
+ { 50222, "iso-2022-jp" }, // ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI)
+ { 50225, "iso-2022-kr" }, // ISO 2022 Korean
+ { 50227, "ISO-2022-CN" }, // ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022)
+ { 50229, "ISO-2022-CN-EXT" }, // ISO 2022 Traditional Chinese
+ { 51932, "euc-jp" }, // EUC Japanese
+ { 51936, "EUC-CN" }, // EUC Simplified Chinese; Chinese Simplified (EUC)
+ { 51949, "euc-kr" }, // EUC Korean
+ { 52936, "hz-gb-2312" }, // HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ)
+ { 54936, "GB18030" }, // Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030)
+};
+
+
+static unsigned FindCP(const char* mimecp)
+{
+ unsigned cp = CP_ACP;
+ for (unsigned i = 0; i < SIZEOF(cptbl); ++i)
+ {
+ if (_stricmp(mimecp, cptbl[i].mimecp) == 0)
+ {
+ cp = cptbl[i].cp;
+ break;
+ }
+ }
+ return cp;
+}
+
+
+static int SingleHexToDecimal(char c)
+{
+ if (c >= '0' && c <= '9') return c-'0';
+ if (c >= 'a' && c <= 'f') return c-'a'+10;
+ if (c >= 'A' && c <= 'F') return c-'A'+10;
+ return -1;
+}
+
+static void PQDecode(char* str)
+{
+ char* s = str, *d = str;
+
+ while(*s)
+ {
+ switch (*s)
+ {
+ case '=':
+ {
+ int digit1 = SingleHexToDecimal(s[1]);
+ if (digit1 != -1)
+ {
+ int digit2 = SingleHexToDecimal(s[2]);
+ if (digit2 != -1)
+ {
+ s += 3;
+ *d++ = (char)((digit1 << 4) | digit2);
+ }
+ }
+ break;
+ }
+
+ case '_':
+ *d++ = ' '; ++s;
+ break;
+
+ default:
+ *d++ = *s++;
+ break;
+ }
+ }
+ *d = 0;
+}
+
+static size_t utf8toutf16(char* str, wchar_t* res)
+{
+ wchar_t *dec = mir_utf8decodeW(str);
+ if (dec == NULL) dec = mir_a2u(str);
+ wcscpy(res, dec);
+ mir_free(dec);
+ return wcslen(res);
+}
+
+
+wchar_t* MimeHeaders::decode(const char* val)
+{
+ size_t ssz = strlen(val) * 2 + 1;
+ char* tbuf = (char*)alloca(ssz);
+ memcpy(tbuf, val, ssz);
+
+ wchar_t* res = (wchar_t*)mir_alloc(ssz * sizeof(wchar_t));
+ wchar_t* resp = res;
+
+ char *p = tbuf;
+ while (*p)
+ {
+ char *cp = strstr(p, "=?");
+ if (cp == NULL) break;
+ *cp = 0;
+
+ size_t sz = utf8toutf16(p, resp);
+ ssz -= sz; resp += sz;
+ cp += 2;
+
+ char *enc = strchr(cp, '?');
+ if (enc == NULL) break;
+ *(enc++) = 0;
+
+ char *fld = strchr(enc, '?');
+ if (fld == NULL) break;
+ *(fld++) = 0;
+
+ char *pe = strstr(fld, "?=");
+ if (pe == NULL) break;
+ *pe = 0;
+
+ switch (*enc)
+ {
+ case 'b':
+ case 'B':
+ {
+ char* dec = MSN_Base64Decode(fld);
+ strcpy(fld, dec);
+ mir_free(dec);
+ break;
+ }
+
+ case 'q':
+ case 'Q':
+ PQDecode(fld);
+ break;
+ }
+
+ if (_stricmp(cp, "UTF-8") == 0)
+ {
+ sz = utf8toutf16(fld, resp);
+ ssz -= sz; resp += sz;
+ }
+ else
+ {
+ int sz = MultiByteToWideChar(FindCP(cp), 0, fld, -1, resp, (int)ssz);
+ if (sz == 0)
+ sz = MultiByteToWideChar(CP_ACP, 0, fld, -1, resp, (int)ssz);
+ ssz -= --sz; resp += sz;
+ }
+ p = pe + 2;
+ }
+
+ utf8toutf16(p, resp);
+
+ return res;
+}
+
+
+char* MimeHeaders::decodeMailBody(char* msgBody)
+{
+ char* res;
+ const char *val = find("Content-Transfer-Encoding");
+ if (val && _stricmp(val, "base64") == 0)
+ {
+ char *src = msgBody, *dst = msgBody;
+ while (*src != 0)
+ {
+ if (isspace(*src)) ++src;
+ else *(dst++) = *(src++);
+ }
+ *dst = 0;
+ res = MSN_Base64Decode(msgBody);
+ }
+ else
+ {
+ res = mir_strdup(msgBody);
+ if (val && _stricmp(val, "quoted-printable") == 0)
+ PQDecode(res);
+ }
+ return res;
+}
+
+
+int sttDivideWords(char* parBuffer, int parMinItems, char** parDest)
+{
+ int i;
+ for (i=0; i < parMinItems; i++)
+ {
+ parDest[i] = parBuffer;
+
+ size_t tWordLen = strcspn(parBuffer, " \t");
+ if (tWordLen == 0)
+ return i;
+
+ parBuffer += tWordLen;
+ if (*parBuffer != '\0')
+ {
+ size_t tSpaceLen = strspn(parBuffer, " \t");
+ memset(parBuffer, 0, tSpaceLen);
+ parBuffer += tSpaceLen;
+ } }
+
+ return i;
+}
|