// ------------------------------------------------------------------ // GoldED+ // Copyright (C) 1990-1999 Odinn Sorensen // Copyright (C) 1999-2000 Alexander S. Aganichev // ------------------------------------------------------------------ // 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, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, // MA 02111-1307 USA // ------------------------------------------------------------------ // $Id$ // ------------------------------------------------------------------ // Conversion of a raw message to a linked list of lines. // ------------------------------------------------------------------ #include #include #include #include #include #if defined(__USE_ALLOCA__) #include #endif #ifdef HAS_ICONV #include #endif // ------------------------------------------------------------------ #ifdef __UNIX__ #define GOLDMARK '^' // xwindow fonts has no square sign :( #else #define GOLDMARK '\xFD' #endif // ------------------------------------------------------------------ const int BODYLINE = 0; const int HEADERLINE = 1; const int USERDEFINED = 2; const int RFC_X = 3; enum { MASK_FTS = 0x1000, FTS_AREA, FTS_INTL, FTS_FMPT, FTS_TOPT, FTS_MSGID, FTS_REPLY, FTS_SEENBY, FTS_PATH, FTS_ZZZZ }; enum { MASK_FSC = 0x2000, FSC_CHARSET, FSC_CHRC, FSC_CHRS, FSC_CODEPAGE, FSC_DOMAIN, FSC_EID, FSC_ENC, FSC_ENCLFILE, FSC_FLAGS, FSC_FWDFROM, FSC_FWDORIG, FSC_FWDTO, FSC_FWDDEST, FSC_FWDSUBJ, FSC_FWDAREA, FSC_FWDMSGID, FSC_I51, FSC_MSGTO, FSC_PID, FSC_PTH, FSC_REPLYADDR, FSC_REPLYTO, FSC_SPLIT, FSC_SPTH, FSC_TID, FSC_ZZZZ }; enum { MASK_XXX = 0x8000, XXX_ACUPDATE, XXX_DESTADDR, XXX_ENCRYPTION, XXX_EOT, XXX_GATECHK, XXX_GID, XXX_GIF, XXX_GMD, XXX_GROUP, XXX_MOOD, XXX_MSGSEQ, XXX_NOTE, XXX_ORIGID, XXX_ORIGINAL, XXX_ORIGREF, XXX_RECD, XXX_RFC, XXX_RFD, XXX_RID, XXX_ROUTE, XXX_SN, XXX_SOT, XXX_TCL1, XXX_TCL2, XXX_TZUTCINFO, XXX_TZUTC, XXX_TZ, XXX_VIA, XXX_XID, XXX_ZZZZ }; enum { MASK_RFC = 0x4000, RFC_ALSO_CONTROL, RFC_APPARENTLY_TO, RFC_APPROVED, RFC_ARTICLE_NAMES, RFC_ARTICLE_UPDATES, RFC_BCC, RFC_CC, RFC_COMMENT, RFC_COMMENTS, RFC_CONTENT_DESCRIPTION, RFC_CONTENT_DISPOSITION, RFC_CONTENT_ID, RFC_CONTENT_LENGTH, RFC_CONTENT_TRANSFER_ENCODING, RFC_CONTENT_TYPE, RFC_CONTROL, RFC_DATE, RFC_DELIVERED_TO, RFC_DELIVERY_DATE, RFC_DISTRIBUTION, RFC_ENCRYPTED, RFC_ERRORS_TO, RFC_EXPIRES, RFC_FOLLOWUP_TO, RFC_FROM, RFC_FROMX, RFC_IN_REPLY_TO, RFC_KEYWORDS, RFC_LINES, RFC_MAILING_LIST, // This one is actually _not_ RFC RFC_MESSAGE_ID, RFC_MIME_VERSION, RFC_NEWSGROUPS, RFC_NEWS_SOFTWARE, RFC_NNTP_POSTING_DATE, RFC_NNTP_POSTING_HOST, RFC_NNTP_POSTING_USER, RFC_OLD_DATE, RFC_ORGANIZATION, RFC_ORIGINATOR, RFC_PATH, RFC_PRECEDENCE, RFC_PRIORITY, RFC_RECEIVED, RFC_REFERENCES, RFC_REPLY_TO, RFC_RETURN_PATH, RFC_RETURN_RECEIPT_TO, RFC_SEE_ALSO, RFC_SENDER, RFC_STATUS, RFC_SUBJECT, RFC_SUMMARY, RFC_SUPERSEDES, RFC_TO, RFC_VERSION, RFC_XREF, RFC_X_CHARSET, RFC_X_CHAR_ESC, RFC_X_FTN_TO, RFC_X_MAILER, RFC_X_NEWSREADER, RFC_X_TO, RFC_RNEWS, RFC_ZZZZ }; #define MASK_ALL (MASK_FTS|MASK_FSC|MASK_RFC|MASK_XXX) // ------------------------------------------------------------------ struct Kludges { char* key; uint num; byte req; }; // ------------------------------------------------------------------ const byte KCRQ_NONE = 0x0000; const byte KCRQ_COLON = 0x0001; const byte KCRQ_CASE = 0x0002; // ------------------------------------------------------------------ static const Kludges fts_list[] = { { "AREA" , FTS_AREA , KCRQ_CASE }, { "INTL" , FTS_INTL , KCRQ_CASE }, { "FMPT" , FTS_FMPT , KCRQ_CASE }, { "TOPT" , FTS_TOPT , KCRQ_CASE }, { "MSGID" , FTS_MSGID , KCRQ_CASE }, { "REPLY" , FTS_REPLY , KCRQ_CASE }, { "SEEN-BY" , FTS_SEENBY , KCRQ_CASE }, { "PATH" , FTS_PATH , KCRQ_CASE }, { "" , FTS_ZZZZ , KCRQ_NONE }, }; // ------------------------------------------------------------------ static const Kludges fsc_list[] = { { "CHARSET" , FSC_CHARSET , KCRQ_CASE }, { "CHRC" , FSC_CHRC , KCRQ_CASE }, { "CHRS" , FSC_CHRS , KCRQ_CASE }, { "CODEPAGE" , FSC_CODEPAGE , KCRQ_CASE }, { "DOMAIN" , FSC_DOMAIN , KCRQ_CASE }, { "EID" , FSC_EID , KCRQ_CASE }, { "ENC" , FSC_ENC , KCRQ_CASE }, { "ENCLFILE" , FSC_ENCLFILE , KCRQ_CASE }, { "FLAGS" , FSC_FLAGS , KCRQ_CASE }, { "FWDFROM" , FSC_FWDFROM , KCRQ_CASE }, { "FWDORIG" , FSC_FWDORIG , KCRQ_CASE }, { "FWDTO" , FSC_FWDTO , KCRQ_CASE }, { "FWDDEST" , FSC_FWDDEST , KCRQ_CASE }, { "FWDSUBJ" , FSC_FWDSUBJ , KCRQ_CASE }, { "FWDAREA" , FSC_FWDAREA , KCRQ_CASE }, { "FWDMSGID" , FSC_FWDMSGID , KCRQ_CASE }, { "I51" , FSC_I51 , KCRQ_CASE }, { "MSGTO" , FSC_MSGTO , KCRQ_CASE }, { "PID" , FSC_PID , KCRQ_CASE }, { "PTH" , FSC_PTH , KCRQ_CASE }, { "REPLYADDR" , FSC_REPLYADDR , KCRQ_CASE }, { "REPLYTO" , FSC_REPLYTO , KCRQ_CASE }, { "SPLIT" , FSC_SPLIT , KCRQ_CASE }, { "SPTH" , FSC_SPTH , KCRQ_CASE }, { "TID" , FSC_TID , KCRQ_CASE }, { "" , FSC_ZZZZ , KCRQ_NONE }, }; // ------------------------------------------------------------------ static const Kludges xxx_list[] = { { "ACUPDATE" , XXX_ACUPDATE , KCRQ_CASE }, { "DESTADDR" , XXX_DESTADDR , KCRQ_CASE }, { "ENCRYPTION" , XXX_ENCRYPTION , KCRQ_CASE }, { "EOT" , XXX_EOT , KCRQ_CASE }, { "GATECHK" , XXX_GATECHK , KCRQ_CASE }, { "GID" , XXX_GID , KCRQ_CASE }, { "GIF" , XXX_GIF , KCRQ_CASE }, { "GMD" , XXX_GMD , KCRQ_CASE }, { "GROUP" , XXX_GROUP , KCRQ_CASE }, { "MOOD" , XXX_MOOD , KCRQ_CASE }, { "MSGSEQ" , XXX_MSGSEQ , KCRQ_CASE }, { "NOTE" , XXX_NOTE , KCRQ_CASE }, { "ORIGID" , XXX_ORIGID , KCRQ_CASE }, { "Original" , XXX_ORIGINAL , KCRQ_NONE }, { "ORIGREF" , XXX_ORIGREF , KCRQ_CASE }, { "Recd" , XXX_RECD , KCRQ_CASE }, { "RFC" , XXX_RFC , KCRQ_CASE }, { "RFD" , XXX_RFD , KCRQ_CASE }, { "RID" , XXX_RID , KCRQ_CASE }, { "#ROUTE" , XXX_ROUTE , KCRQ_CASE }, { "SN" , XXX_SN , KCRQ_CASE }, { "SOT" , XXX_SOT , KCRQ_CASE }, { "TCL1" , XXX_TCL1 , KCRQ_CASE }, { "TCL2" , XXX_TCL2 , KCRQ_CASE }, { "TZUTCINFO" , XXX_TZUTCINFO , KCRQ_CASE }, { "TZUTC" , XXX_TZUTC , KCRQ_CASE }, { "TZ" , XXX_TZ , KCRQ_CASE }, { "Via" , XXX_VIA , KCRQ_NONE }, { "XID" , XXX_XID , KCRQ_CASE }, { "" , XXX_ZZZZ , KCRQ_NONE } }; // ------------------------------------------------------------------ static const Kludges rfc_list[] = { { "Also-Control" , RFC_ALSO_CONTROL , KCRQ_COLON }, { "Apparently-To" , RFC_APPARENTLY_TO , KCRQ_COLON }, { "Approved" , RFC_APPROVED , KCRQ_COLON }, { "Article-Names" , RFC_ARTICLE_NAMES , KCRQ_COLON }, { "Article-Updates" , RFC_ARTICLE_UPDATES , KCRQ_COLON }, { "Bcc" , RFC_BCC , KCRQ_COLON }, { "Cc" , RFC_CC , KCRQ_COLON }, { "Comment" , RFC_COMMENT , KCRQ_COLON }, { "Comments" , RFC_COMMENTS , KCRQ_COLON }, { "Content-Description" , RFC_CONTENT_DESCRIPTION , KCRQ_COLON }, { "Content-Disposition" , RFC_CONTENT_DISPOSITION , KCRQ_COLON }, { "Content-ID" , RFC_CONTENT_ID , KCRQ_COLON }, { "Content-Length" , RFC_CONTENT_LENGTH , KCRQ_COLON }, { "Content-Transfer-Encoding" , RFC_CONTENT_TRANSFER_ENCODING , KCRQ_COLON }, { "Content-Type" , RFC_CONTENT_TYPE , KCRQ_COLON }, { "Control" , RFC_CONTROL , KCRQ_COLON }, { "Date" , RFC_DATE , KCRQ_COLON }, { "Delivered-To" , RFC_DELIVERED_TO , KCRQ_COLON }, { "Delivery-Date" , RFC_DELIVERY_DATE , KCRQ_COLON }, { "Distribution" , RFC_DISTRIBUTION , KCRQ_COLON }, { "Encrypted" , RFC_ENCRYPTED , KCRQ_COLON }, { "Errors-To" , RFC_ERRORS_TO , KCRQ_COLON }, { "Expires" , RFC_EXPIRES , KCRQ_COLON }, { "Followup-To" , RFC_FOLLOWUP_TO , KCRQ_COLON }, { "From" , RFC_FROM , KCRQ_COLON }, { "From" , RFC_FROMX , KCRQ_NONE }, { "In-Reply-To" , RFC_IN_REPLY_TO , KCRQ_COLON }, { "Keywords" , RFC_KEYWORDS , KCRQ_COLON }, { "Lines" , RFC_LINES , KCRQ_COLON }, { "Message-ID" , RFC_MESSAGE_ID , KCRQ_COLON }, { "Mailing-List" , RFC_MAILING_LIST , KCRQ_COLON }, { "MIME-Version" , RFC_MIME_VERSION , KCRQ_COLON }, { "Newsgroups" , RFC_NEWSGROUPS , KCRQ_COLON }, { "News-Software" , RFC_NEWS_SOFTWARE , KCRQ_COLON }, { "NNTP-Posting-Date" , RFC_NNTP_POSTING_DATE , KCRQ_COLON }, { "NNTP-Posting-Host" , RFC_NNTP_POSTING_HOST , KCRQ_COLON }, { "NNTP-Posting-User" , RFC_NNTP_POSTING_USER , KCRQ_COLON }, { "Old-Date" , RFC_OLD_DATE , KCRQ_COLON }, { "Organization" , RFC_ORGANIZATION , KCRQ_COLON }, { "Originator" , RFC_ORIGINATOR , KCRQ_COLON }, { "Path" , RFC_PATH , KCRQ_COLON }, { "Precedence" , RFC_PRECEDENCE , KCRQ_COLON }, { "Priority" , RFC_PRIORITY , KCRQ_COLON }, { "Received" , RFC_RECEIVED , KCRQ_COLON }, { "References" , RFC_REFERENCES , KCRQ_COLON }, { "Reply-To" , RFC_REPLY_TO , KCRQ_COLON }, { "Return-Path" , RFC_RETURN_PATH , KCRQ_COLON }, { "Return-Receipt-To" , RFC_RETURN_RECEIPT_TO , KCRQ_COLON }, { "See-Also" , RFC_SEE_ALSO , KCRQ_COLON }, { "Sender" , RFC_SENDER , KCRQ_COLON }, { "Status" , RFC_STATUS , KCRQ_COLON }, { "Subject" , RFC_SUBJECT , KCRQ_COLON }, { "Summary" , RFC_SUMMARY , KCRQ_COLON }, { "Supersedes" , RFC_SUPERSEDES , KCRQ_COLON }, { "To" , RFC_TO , KCRQ_COLON }, { "Version" , RFC_VERSION , KCRQ_COLON }, { "Xref" , RFC_XREF , KCRQ_COLON }, { "X-Charset" , RFC_X_CHARSET , KCRQ_COLON }, { "X-Char-Esc" , RFC_X_CHAR_ESC , KCRQ_COLON }, { "X-FTN-To" , RFC_X_FTN_TO , KCRQ_COLON }, { "X-Mailer" , RFC_X_MAILER , KCRQ_COLON }, { "X-Mailreader" , RFC_X_MAILER , KCRQ_COLON }, { "X-Newsreader" , RFC_X_NEWSREADER , KCRQ_COLON }, { "X-To" , RFC_X_TO , KCRQ_COLON }, { "#!" , RFC_RNEWS , KCRQ_NONE }, { "" , RFC_ZZZZ , KCRQ_NONE }, }; char* mime_header_decode(char* decoded, const char* encoded, char *charset) { char dbuf[200], cbuf[100], ebuf[50], tbuf[200]; char* dptr = decoded; const char* eptr = encoded; if(charset) *charset = NUL; while(*eptr) { if(*eptr == '=') { const char* mptr = mime_crack_encoded_word(eptr, cbuf, ebuf, tbuf); if(mptr) { if(charset) { strxcpy(charset, cbuf, 100); charset = NULL; } bool okay = false; strchg(tbuf, '_', ' '); if(strieql(ebuf, "Q")) { quoted_printable_engine qb; qb.decode(dbuf, tbuf); dptr = stpcpy(dptr, dbuf); okay = true; } else if(strieql(ebuf, "B")) { base64_engine b64; b64.decode(dbuf, tbuf); dptr = stpcpy(dptr, dbuf); okay = true; } if(okay) { eptr = mptr; mptr = strskip_lwsp(mptr); if(mime_crack_encoded_word(mptr, cbuf, ebuf, tbuf)) eptr = mptr; continue; } } } *dptr++ = *eptr++; } *dptr = NUL; return decoded; } // ------------------------------------------------------------------ char* strxmimecpy(char* dest, const char* source, int level, int size, bool detect) { ISub buf, buf2; char charset[100]; int table = -1; strxcpy(buf, source, sizeof(buf)); mime_header_decode(buf2, buf, charset); if(charset[0] == NUL) detect = false; if(detect) { table = LoadCharset(NULL, NULL, 1); level = LoadCharset(charset, CFG->xlatlocalset); if(not level) { level = LoadCharset(AA->Xlatimport(), CFG->xlatlocalset); } } XlatStr(buf, buf2, level, CharTable); if(detect) { if(table == -1) LoadCharset("N/A", "N/A"); else LoadCharset(CFG->xlatcharset[table].imp, CFG->xlatcharset[table].exp); } strxcpy(dest, buf, size); return dest; } // ------------------------------------------------------------------ static void KludgeAREA(GMsg* msg, const char* echoid) { if(AA->Usearea()) { Area* ap = AL.AreaEchoToPtr(echoid); if(ap) msg->areakludgeid = ap->echoid(); } } // ------------------------------------------------------------------ static void KludgeINTL(GMsg* msg, const char* ptr) { char buf1[201], buf2[201]; word fmpt = msg->orig.point; word topt = msg->dest.point; sscanf(ptr, "%s %s", buf1, buf2); msg->dest.set(buf1); msg->orig.set(buf2); msg->orig.point = fmpt; msg->dest.point = topt; } // ------------------------------------------------------------------ static void KludgeFMPT(GMsg* msg, const char* ptr) { msg->orig.point = atow(ptr); } // ------------------------------------------------------------------ static void KludgeTOPT(GMsg* msg, const char* ptr) { msg->dest.point = atow(ptr); } // ------------------------------------------------------------------ static void KludgeMSGID(GMsg* msg, const char* ptr) { strxcpy(msg->msgids, ptr, sizeof(msg->msgids)); msg->msgid.reset(msg->msgids, msg->odom); } // ------------------------------------------------------------------ static void KludgeREPLY(GMsg* msg, const char* ptr) { strxcpy(msg->replys, ptr, sizeof(msg->replys)); } // ------------------------------------------------------------------ static void KludgeDOMAIN(GMsg* msg, const char* ptr) { char buf1[201], buf2[201]; sscanf(ptr, "%s %s %s %s", msg->ddom, buf1, msg->odom, buf2); msg->dest.reset(buf1); msg->orig.reset(buf2); } // ------------------------------------------------------------------ static void KludgeFLAGS(GMsg* msg, const char* ptr) { GetAttribstr(&msg->attr, ptr); } // ------------------------------------------------------------------ static void KludgeMSGTO(GMsg* msg, const char* ptr) { msg->dest.reset(ptr, msg->ddom); } // ------------------------------------------------------------------ static void KludgePID(GMsg* msg, const char* ptr) { strxcpy(msg->pid, ptr, sizeof(msg->pid)); if(CFG->gedhandshake) { // Recognize another GoldED msg if(striinc(__gver_name__, ptr) or striinc(__gver_shortname__, ptr)) goldmark = GOLDMARK; } } // ------------------------------------------------------------------ static void KludgeREPLYADDR(GMsg* msg, const char* ptr) { INam name; char *buf=throw_strdup(ptr); *name = NUL; ParseInternetAddr(buf, *msg->realby ? name : msg->realby, msg->iaddr); if(*name) strxcpy(msg->realby, name, sizeof(INam)); throw_free(buf); } // ------------------------------------------------------------------ static void KludgeREPLYTO(GMsg* msg, const char* ptr) { strcpy(msg->igate, ptr); } // ------------------------------------------------------------------ static void KludgeFROM(GMsg* msg, const char* ptr) { INam _fromname; IAdr _fromaddr; char* buf = throw_strdup(ptr); strxmimecpy(msg->ifrom, buf, 0, sizeof(msg->ifrom), true); ParseInternetAddr(buf, _fromname, _fromaddr); throw_free(buf); if(*_fromaddr) strcpy(msg->iorig, _fromaddr); if(*_fromname) strxcpy(msg->realby, _fromname, sizeof(msg->realby)); } // ------------------------------------------------------------------ static void KludgeTO(GMsg* msg, const char* ptr) { INam _toname; IAdr _toaddr; char* buf = throw_strdup(ptr); strxmimecpy(msg->ito, buf, 0, sizeof(msg->ito), true); ParseInternetAddr(buf, _toname, _toaddr); throw_free(buf); if(*_toaddr) strcpy(msg->idest, _toaddr); if(*_toname) strxcpy(msg->realto, _toname, sizeof(msg->realto)); } // ------------------------------------------------------------------ static void KludgeBCC(GMsg* msg, const char* ptr) { INam _toname; IAdr _toaddr, buf; gstrarray bccs; tokenize(bccs, ptr, ","); for(int i=0; i < bccs.size(); i++) { strxcpy(buf, strskip_wht(bccs[i].c_str()), sizeof(IAdr)); ParseInternetAddr(buf, _toname, _toaddr); if(*_toaddr and not striinc(_toaddr, msg->ibcc)) { if(*msg->ibcc) strxcat(msg->ibcc, ", ", sizeof(msg->ibcc)); if(_toname[0] != NUL) { IAdr buf2; mime_header_encode(buf2, _toname, msg); char quot[2] = "\""; if((buf2[0] == '\"') or (strpbrk(buf2, " \t") == NULL)) quot[0] = NUL; sprintf(buf, "%s%s%s <%s>", quot, buf2, quot, _toaddr); } else sprintf(buf, "%s", _toaddr); strxcat(msg->ibcc, buf, sizeof(msg->ibcc)); } } } // ------------------------------------------------------------------ static void KludgeCC(GMsg* msg, const char* ptr) { INam _toname; IAdr _toaddr, buf; gstrarray ccs; tokenize(ccs, ptr, ","); for(int i=0; i < ccs.size(); i++) { strxcpy(buf, strskip_wht(ccs[i].c_str()), sizeof(IAdr)); ParseInternetAddr(buf, _toname, _toaddr); if(*_toaddr and not striinc(_toaddr, msg->icc)) { if(*msg->icc) strxcat(msg->icc, ", ", sizeof(msg->icc)); if(_toname[0] != NUL) { IAdr buf2; mime_header_encode(buf2, _toname, msg); char quot[2] = "\""; if((buf[0] == '\"') or (strpbrk(buf2, " \t") == NULL)) quot[0] = NUL; sprintf(buf, "%s%s%s <%s>", quot, buf2, quot, _toaddr); } else sprintf(buf, "%s", _toaddr); strxcat(msg->icc, buf, sizeof(msg->icc)); } } } // ------------------------------------------------------------------ static void KludgeREPLY_TO(GMsg* msg, const char* ptr) { INam _rtname; IAdr _rtaddr; char *buf=throw_strdup(ptr); ParseInternetAddr(buf, _rtname, _rtaddr); throw_free(buf); if(*_rtaddr) strcpy(msg->ireplyto, _rtaddr); } // ------------------------------------------------------------------ static void KludgeSUBJECT(GMsg* msg, const char* ptr) { if(not (msg->attr.frq() or msg->attr.att() or msg->attr.urq())) strxmimecpy(msg->re, ptr, 0, sizeof(msg->re), true); } // ------------------------------------------------------------------ static void KludgeTZUTC(GMsg* msg, const char* ptr) { msg->tzutc = atoi(ptr); } // ------------------------------------------------------------------ void KludgeDATE(GMsg* msg, const char* ptr) { // RFC822 Date: BNF // // date-time = [ day "," ] date time ; dd mm yy // ; hh:mm:ss zzz // // day = "Mon" / "Tue" / "Wed" / "Thu" // / "Fri" / "Sat" / "Sun" // // date = 1*2DIGIT month 2DIGIT ; day month year // ; e.g. 20 Jun 82 // // month = "Jan" / "Feb" / "Mar" / "Apr" // / "May" / "Jun" / "Jul" / "Aug" // / "Sep" / "Oct" / "Nov" / "Dec" // // time = hour zone ; ANSI and Military // // hour = 2DIGIT ":" 2DIGIT [":" 2DIGIT] // ; 00:00:00 - 23:59:59 // // zone = "UT" / "GMT" ; Universal Time // ; North American : UT // / "EST" / "EDT" ; Eastern: - 5/ - 4 // / "CST" / "CDT" ; Central: - 6/ - 5 // / "MST" / "MDT" ; Mountain: - 7/ - 6 // / "PST" / "PDT" ; Pacific: - 8/ - 7 // / 1ALPHA ; Military: Z = UT; // ; A:-1; (J not used) // ; M:-12; N:+1; Y:+12 // / ( ("+" / "-") 4DIGIT ) ; Local differential // ; hours+min. (HHMM) bool date_ok = false; int year=0, month=0, day=0; int hour=0, minute=0, second=0; ptr = strskip_wht(ptr); if(not isdigit(*ptr)) { // Skip past weekday string ptr = strskip_wht(strskip_txt(ptr)); } if(*ptr) { if(isdigit(*ptr)) { day = atoi(ptr); ptr = strskip_wht(strskip_txt(ptr)); if(g_isalpha(*ptr)) { month = str2mon(ptr); if(month) { ptr = strskip_wht(strskip_txt(ptr)); if(isdigit(*ptr)) { year = atoi(ptr); ptr = strskip_wht(strskip_txt(ptr)); if(isdigit(*ptr)) { hour = atoi(ptr); ptr = strskip_digits(ptr); if(*ptr and isdigit(ptr[1])) { minute = atoi(++ptr); date_ok = true; // The seconds part is optional ptr = strskip_digits(ptr); if(*ptr and isdigit(ptr[1])) { second = atoi(++ptr); // Setting timezone ptr = strskip_wht(strskip_digits(ptr)); if(*ptr) { if(*ptr == '(' /*)*/ ) ++ptr; msg->tzutc = atoi(ptr); } } } } } } } } } if (date_ok) { struct tm t; t.tm_year = (year < 80) ? (year+100) : (year > 1900) ? (year-1900) : year; t.tm_mon = month - 1; t.tm_mday = day; t.tm_hour = hour; t.tm_min = minute; t.tm_sec = second; t.tm_isdst = -1; time32_t a = gmktime(&t); struct tm tp; ggmtime(&tp, &a); tp.tm_isdst = -1; time32_t b = gmktime(&tp); msg->written = a + a - b; } } // ------------------------------------------------------------------ static void KludgeMESSAGE_ID(GMsg* msg, const char* ptr) { char buf[201]; throw_free(msg->messageid); msg->messageid = throw_strdup(ptr); CvtMessageIDtoMSGID(ptr, buf, AA->echoid(), "MSGID"); strcpy(msg->msgids, buf+8); } // ------------------------------------------------------------------ static void KludgeREFERENCES(GMsg* msg, const char* ptr) { throw_free(msg->references); msg->references = throw_strdup(ptr); } // ------------------------------------------------------------------ static void KludgeIN_REPLY_TO(GMsg* msg, const char* ptr) { throw_free(msg->inreplyto); msg->inreplyto = throw_strdup(ptr); } // ------------------------------------------------------------------ static void KludgeORGANIZATION(GMsg* msg, const char* ptr) { strxcpy(msg->organization, ptr, sizeof(msg->organization)); } // ------------------------------------------------------------------ static void KludgeX_FTN_TO(GMsg* msg, const char* ptr) { strxmimecpy(msg->realto, ptr, 0, sizeof(msg->realto), true); } // ------------------------------------------------------------------ static void KludgeFWDFROM(GMsg* msg, const char* ptr) { if(AA->Usefwd()) strxcpy(msg->fwdfrom, ptr, sizeof(msg->fwdfrom)); } // ------------------------------------------------------------------ static void KludgeFWDORIG(GMsg* msg, const char* ptr) { if(AA->Usefwd()) msg->fwdorig.reset(ptr); } // ------------------------------------------------------------------ static void KludgeFWDTO(GMsg* msg, const char* ptr) { if(AA->Usefwd()) strxcpy(msg->fwdto, ptr, sizeof(msg->fwdto)); } // ------------------------------------------------------------------ static void KludgeFWDDEST(GMsg* msg, const char* ptr) { if(AA->Usefwd()) msg->fwddest.reset(ptr); } // ------------------------------------------------------------------ static void KludgeFWDSUBJ(GMsg* msg, const char* ptr) { if(AA->Usefwd()) strxcpy(msg->fwdsubj, ptr, sizeof(msg->fwdsubj)); } // ------------------------------------------------------------------ static void KludgeFWDAREA(GMsg* msg, const char* ptr) { if(AA->Usefwd()) strxcpy(msg->fwdarea, ptr, sizeof(msg->fwdarea)); } // ------------------------------------------------------------------ static void KludgeFWDMSGID(GMsg* msg, const char* ptr) { if(AA->Usefwd()) strxcpy(msg->fwdmsgid, ptr, sizeof(msg->fwdmsgid)); } // ------------------------------------------------------------------ char* UnwrapLine(Line* line, const char* ptr, int addspace = false) { if(line->type & GLINE_WRAP) { uint len = strlen(ptr); char* uptr = throw_strdup(ptr); while(line and (line->type & GLINE_WRAP)) { if(line->next) { uint nextlen = line->next->txt.length(); uptr = (char*)throw_realloc(uptr, len+nextlen+2); if(addspace and len and (uptr[len-1] != ' ')) { strcat(uptr, " "); len++; } strcpy(uptr+len, line->next->txt.c_str()); len += nextlen; } line = line->next; } return uptr; } return NULL; } // ------------------------------------------------------------------ static int HandleKludges(GMsg* msg, Line* line, int kludgenum, const char* ptr, int getvalue) { switch(kludgenum) { case FTS_AREA: line->kludge = GKLUD_AREA; if(getvalue) KludgeAREA(msg, ptr); return true; case FTS_INTL: line->kludge = GKLUD_INTL; if(getvalue) KludgeINTL(msg, ptr); return true; case FTS_FMPT: line->kludge = GKLUD_FMPT; if(getvalue) KludgeFMPT(msg, ptr); return true; case FTS_TOPT: line->kludge = GKLUD_TOPT; if(getvalue) KludgeTOPT(msg, ptr); return true; case FTS_MSGID: line->kludge = GKLUD_MSGID; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeMSGID(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case FTS_REPLY: line->kludge = GKLUD_REPLY; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeREPLY(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case FTS_SEENBY: line->kludge = GKLUD_SEENBY; return true; case FTS_PATH: line->kludge = GKLUD_PATH; return true; //////////////////////////////////////////////////////////// case FSC_CHARSET: line->kludge = GKLUD_CHARSET; return true; case FSC_CHRS: line->kludge = GKLUD_CHARSET; return true; case FSC_CODEPAGE: line->kludge = GKLUD_CHARSET; return true; case FSC_DOMAIN: //line->kludge = GKLUD_DOMAIN; if(getvalue) KludgeDOMAIN(msg, ptr); return true; case FSC_ENCLFILE: if(getvalue) strxcpy(msg->re, ptr, sizeof(msg->re)); return true; case FSC_FLAGS: line->kludge = GKLUD_FLAGS; if(getvalue) KludgeFLAGS(msg, ptr); return true; case FSC_I51: line->kludge = GKLUD_CHARSET; msg->i51 = true; return true; case FSC_MSGTO: //line->kludge = GKLUD_MSGTO; if(getvalue) KludgeMSGTO(msg, ptr); return true; case FSC_PID: line->kludge = GKLUD_PID; if(getvalue) KludgePID(msg, ptr); return true; case FSC_REPLYADDR: line->kludge = GKLUD_REPLYADDR; if(getvalue) KludgeREPLYADDR(msg, ptr); return true; case FSC_REPLYTO: line->kludge = GKLUD_REPLYTO; if(getvalue) KludgeREPLYTO(msg, ptr); return true; case FSC_FWDFROM: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDFROM(msg, ptr); return true; case FSC_FWDORIG: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDORIG(msg, ptr); return true; case FSC_FWDTO: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDTO(msg, ptr); return true; case FSC_FWDDEST: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDDEST(msg, ptr); return true; case FSC_FWDSUBJ: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDSUBJ(msg, ptr); return true; case FSC_FWDAREA: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDAREA(msg, ptr); return true; case FSC_FWDMSGID: line->kludge = GKLUD_FWD; if(getvalue) KludgeFWDMSGID(msg, ptr); return true; case FSC_CHRC: case FSC_EID: case FSC_ENC: case FSC_PTH: case FSC_SPLIT: case FSC_SPTH: case FSC_TID: // Recognized but not processed return true; //////////////////////////////////////////////////////////// case XXX_DESTADDR: //line->kludge = GKLUD_DESTADDR; if(getvalue) KludgeMSGTO(msg, ptr); return true; case XXX_TZUTCINFO: case XXX_TZUTC: line->kludge = GKLUD_KNOWN; if(getvalue) KludgeTZUTC(msg, ptr); return true; case XXX_ACUPDATE: case XXX_ENCRYPTION: case XXX_EOT: case XXX_GATECHK: case XXX_GID: case XXX_GIF: case XXX_GMD: case XXX_GROUP: case XXX_MOOD: case XXX_MSGSEQ: case XXX_NOTE: case XXX_ORIGID: case XXX_ORIGINAL: case XXX_ORIGREF: case XXX_RECD: case XXX_RFC: case XXX_RFD: case XXX_RID: case XXX_ROUTE: case XXX_SN: case XXX_SOT: case XXX_TCL1: case XXX_TCL2: case XXX_TZ: case XXX_VIA: case XXX_XID: // Recognized but not processed return true; } return false; } // ------------------------------------------------------------------ int HandleRFCs(GMsg* msg, Line* line, int kludgenum, const char* ptr, int getvalue) { switch(kludgenum) { case RFC_FROM: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeFROM(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_TO: case RFC_X_TO: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeTO(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_BCC: line->kludge = GKLUD_RFC; if(true /* getvalue */) { char* tmp = UnwrapLine(line, ptr); KludgeBCC(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_CC: line->kludge = GKLUD_RFC; if(true /* getvalue */) { char* tmp = UnwrapLine(line, ptr); KludgeCC(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_DATE: line->kludge = GKLUD_RFC; if(getvalue) KludgeDATE(msg, ptr); return true; case RFC_SUBJECT: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeSUBJECT(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_REPLY_TO: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeREPLY_TO(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_MESSAGE_ID: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeMESSAGE_ID(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_REFERENCES: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeREFERENCES(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_IN_REPLY_TO: line->kludge = GKLUD_RFC; if(getvalue) { char* tmp = UnwrapLine(line, ptr); KludgeIN_REPLY_TO(msg, tmp ? tmp : ptr); if(tmp) throw_free(tmp); } return true; case RFC_ORGANIZATION: line->kludge = GKLUD_RFC; if(getvalue) KludgeORGANIZATION(msg, ptr); return true; case RFC_X_FTN_TO: line->kludge = GKLUD_RFC; if(getvalue) KludgeX_FTN_TO(msg, ptr); return true; case RFC_X_MAILER: line->kludge = GKLUD_RFC; if(getvalue) KludgePID(msg, ptr); return true; case RFC_X_NEWSREADER: line->kludge = GKLUD_RFC; if(getvalue) KludgePID(msg, ptr); return true; case RFC_NEWSGROUPS: case RFC_SENDER: case RFC_CONTENT_TRANSFER_ENCODING: case RFC_CONTENT_TYPE: case RFC_MIME_VERSION: case RFC_X_CHARSET: case RFC_X_CHAR_ESC: // Mark RFC's that we add ourselves line->kludge = GKLUD_RFC; return true; case RFC_ALSO_CONTROL: case RFC_APPARENTLY_TO: case RFC_APPROVED: case RFC_ARTICLE_NAMES: case RFC_ARTICLE_UPDATES: case RFC_COMMENT: case RFC_COMMENTS: case RFC_CONTENT_DESCRIPTION: case RFC_CONTENT_DISPOSITION: case RFC_CONTENT_ID: case RFC_CONTENT_LENGTH: case RFC_CONTROL: case RFC_DELIVERED_TO: case RFC_DELIVERY_DATE: case RFC_DISTRIBUTION: case RFC_ENCRYPTED: case RFC_ERRORS_TO: case RFC_EXPIRES: case RFC_FOLLOWUP_TO: case RFC_FROMX: case RFC_KEYWORDS: case RFC_LINES: case RFC_MAILING_LIST: case RFC_NEWS_SOFTWARE: case RFC_NNTP_POSTING_DATE: case RFC_NNTP_POSTING_HOST: case RFC_NNTP_POSTING_USER: case RFC_OLD_DATE: case RFC_ORIGINATOR: case RFC_PATH: case RFC_PRECEDENCE: case RFC_PRIORITY: case RFC_RECEIVED: case RFC_RETURN_PATH: case RFC_RETURN_RECEIPT_TO: case RFC_SEE_ALSO: case RFC_STATUS: case RFC_SUMMARY: case RFC_SUPERSEDES: case RFC_VERSION: case RFC_XREF: case RFC_RNEWS: // Recognized but not processed return true; } return false; } // ------------------------------------------------------------------ int ScanCtrlList(const Kludges *k, const char *kludge, char endchar) { while(*k->key) { if((k->req & KCRQ_CASE) ? streql(kludge, k->key) : strieql(kludge, k->key)) { if(k->req & KCRQ_COLON) { if(endchar == ':') return k->num; } else { return k->num; } } k++; } return 0; } // ------------------------------------------------------------------ int ScanLine(GMsg* msg, Line* line, const char* ptr, int getvalue, int mask) { // Kludge number int kludgenum = 0; // Pointer to kludge id const char* kludge1 = ptr; // Skip past "RFC" string, if any if(strnieql(kludge1, "RFC", 3) and (kludge1[3] != ':')) { kludge1 += 3; if(not g_isalpha(*kludge1)) kludge1++; } // Keep copy of id terminating char while((*ptr != ' ') and (*ptr != ':') and *ptr) ptr++; char endchar = *ptr; #if defined(__USE_ALLOCA__) char *kludge = (char*)alloca(ptr-kludge1+1); #else __extension__ char kludge[ptr-kludge1+1]; #endif strxcpy(kludge, kludge1, ptr-kludge1+1); // Search for it in the known kludges list if(*kludge) { while(1) { if(mask & MASK_FTS) { kludgenum = ScanCtrlList(fts_list, kludge, endchar); if(kludgenum) break; } if(mask & MASK_FSC) { kludgenum = ScanCtrlList(fsc_list, kludge, endchar); if(kludgenum) break; } if(mask & MASK_RFC) { kludgenum = ScanCtrlList(rfc_list, kludge, endchar); if(kludgenum) break; } if(mask & MASK_XXX) { kludgenum = ScanCtrlList(xxx_list, kludge, endchar); if(kludgenum) break; } break; } } // Restore terminating char if(*ptr != ' ') ptr++; if(kludgenum) { ptr = strskip_wht(ptr); line->type |= GLINE_KLUD; if(kludgenum & (MASK_FTS|MASK_FSC|MASK_XXX)) HandleKludges(msg, line, kludgenum, ptr, getvalue); else if(kludgenum & MASK_RFC) HandleRFCs(msg, line, kludgenum, ptr, getvalue); } else { gstrarray::iterator k; for(k = CFG->kludge.begin(); k != CFG->kludge.end(); k++) { if(strnieql(kludge, k->c_str(), k->length())) { line->type |= GLINE_KLUD; kludgenum = USERDEFINED; break; } } if(not (line->type & GLINE_KLUD)) if((strnieql(kludge, "X-", 2) or strnieql(kludge, "Resent-", 7)) and (endchar == ':') and (mask & MASK_RFC)) { line->type |= GLINE_KLUD; kludgenum = RFC_X; } if(not (line->type & GLINE_KLUD)) kludgenum = (endchar == ':') ? HEADERLINE : BODYLINE; } return kludgenum; } // ------------------------------------------------------------------ Line* next_non_empty(Line *line) { Line* nl = line; while(nl) { if(nl->txt.empty()) nl = nl->next; else break; } return nl; } // ------------------------------------------------------------------ void ScanKludges(GMsg* msg, int getvalue) { const char* ptr; int tearlineno = INT_MAX; int originlineno = INT_MAX; int gotorig=NO, gottear=NO, gottag=NO; // Scan for kludge-, tear- and originlines msg->tzutc = -32767; // Default value, means TZUTC kludge was not found if(getvalue) goldmark = ' '; // Reset the "recognizer" code int lineno = 0; Line* line = LastLine(msg->lin); do { ptr = line->txt.c_str(); if(*ptr == CTRL_A) { // Set kludge/hidden color line->color = C_READK; int kludgenum = ScanLine(msg, line, ptr+1, getvalue, MASK_ALL); if((kludgenum == BODYLINE) or (kludgenum == HEADERLINE)) { line->type |= GLINE_HIDD; line->color = C_READKH; } } else { if(strneql(ptr, "AREA:", 5) and (line->prev == NULL or *line->prev->txt.c_str() == CTRL_A)) { line->color = C_READK; line->kludge = GKLUD_AREA; line->type |= GLINE_KLUD; const char* areakludgeptr = ptr+5; // Extract echoid from kludge areakludgeptr = strskip_wht(areakludgeptr); KludgeAREA(msg, areakludgeptr); } if(not (line->type & GLINE_KLUD)) { // Check if it is a tagline if(not gottag and (strneql("...", ptr, 3) or strneql("___", ptr, 3))) { // It's only a tagline if it's just above the tearline or origin. // Or if it's the last line in the message. if(not lineno or ((lineno-1) == tearlineno) or ((lineno-1) == originlineno)) { gottag = YES; line->type |= GLINE_TAGL; line->color = C_READG; if(AA->Taglinesupport()) strbtrim(strcpy(msg->tagline, ptr+3)); } } // Check if it's a tearline else if(not (gottear or gottag) and strneql("---", ptr, 3) and (ptr[3] == ' ' or ptr[3] == NUL)) { Line* tearln = line; int tearlnno = lineno; while (tearln->type & GLINE_WRAP) { tearln = tearln->next; tearlnno--; } Line* nnel = next_non_empty(tearln->next); if(not tearlnno or ((tearlnno-1) == originlineno) or not nnel or nnel->type & GLINE_KLUDGE) { // Found Tearline gottear = YES; tearlineno = lineno; for (tearln = line; tearln->type & GLINE_WRAP; tearln = tearln->next) { tearln->type |= GLINE_TEAR; tearln->color = C_READT; } tearln->type |= GLINE_TEAR; tearln->color = C_READT; strbtrim(strcpy(msg->tearline, ptr+3)); if(getvalue and CFG->gedhandshake) { char* tearid[] = { "GoldED", " GED ", " GED2 ", " GED3 ", " GED386 ", " GED/2 ", " GED/386 ", " GEDP16 ", " GEDP32 ", " GEDW32 ", " GEDLNX ", " GED/W32 ", NULL }; int n = 0; while(tearid[n]) { if(striinc(tearid[n], ptr)) { goldmark = GOLDMARK; // Recognize another GoldED msg break; } n++; } } } } // Check if it's an originline else if(not (gotorig or gottear or gottag) and strneql(" * Origin: ", ptr, 11)) { // Found Origin line bool cnd = line->next != NULL; Line* nnel = next_non_empty(line->next); bool nextkl = cnd ? not nnel or nnel->type & GLINE_KLUDGE : false; nnel = cnd ? next_non_empty(line->next->next) : NULL; bool nextor = cnd ? (not nnel or nnel->type & GLINE_KLUDGE) and (line->next->txt.find(/*(*/')') != line->next->txt.npos) : false; if(not line->next or nextkl or nextor) { gotorig = YES; originlineno = lineno; line->type |= GLINE_ORIG; line->color = C_READO; strcpy(msg->origin, line->txt.c_str()+11); if(nextor) { // Get the next line too strcat(msg->origin, line->next->txt.c_str()); line->next->color = C_READO; line->next->type |= GLINE_ORIG; // Mark next line as Origin too } } } else if(strneql(ptr, "SEEN-BY:", 8)) { line->kludge = GKLUD_SEENBY; line->color = C_READK; line->type |= GLINE_KLUD; } // Check if it's a signature indicator else if(AA->isinternet() or *msg->ito or *msg->ifrom) { if(streql(ptr, "-- ")) { for(Line* q = line; q; q = q->next) { if((q->type & (GLINE_KLUDGE|GLINE_ORIG|GLINE_TEAR)) == 0) { q->color = C_READS; q->type |= GLINE_SIGN; if(q != line) q->type |= GLINE_HARD; if(strneql("----", q->txt.c_str(), 4)) break; } } } } } } if(line->type & GLINE_WRAP) { Line* linep = line; while(linep and (linep->type & GLINE_WRAP)) { if(linep->next) { linep->next->type |= linep->type & GLINE_KLUDGE; linep->next->kludge = linep->kludge; linep->next->color = linep->color; } linep = linep->next; } } lineno++; } while((line = line->prev) != NULL); if(not gottag) *msg->tagline = NUL; if(not gottear) *msg->tearline = NUL; if(not gotorig) *msg->origin = NUL; if(getvalue) { // This is the new code (experimental) // It looks for an Origin before taking MSGID // Trust msg->orig if valid and we're in netmail area. // (msg->orig is already merged with INTL/FMPT/TOPT) if(not (AA->isnet() and msg->orig.valid())) { if(CFG->addresslookupfirst and msg->msgid.valid()) msg->orig = msg->msgid; else if((ptr = strrchr(msg->origin, '(' /*)*/ )) != NULL) { while(not isdigit(*ptr) and *ptr) ptr++; msg->orig.reset(ptr); } if(msg->msgid.valid()) msg->orig = msg->msgid; } if(msg->orig.zone == 0) msg->orig.zone = msg->msgid.zone ? msg->msgid.zone : AA->Aka().addr.zone; if(msg->dest.zone == 0) msg->dest.zone = msg->orig.zone; } } // ------------------------------------------------------------------ void Latin2Local(char *str) { if (!CFG->latin2local || !str) return; for (size_t i = 0; str[i]; i++) { byte chr = str[i]; byte xch = CFG->latintolocal[chr]; if (xch && (xch != chr)) { byte left = i ? str[i-1] : 0; byte right = str[i+1]; if (((left >= 0x80) && g_isalpha(left )) || ((right >= 0x80) && g_isalpha(right))) { str[i] = xch; for (size_t j = i-1; j < i; j--) { chr = str[j]; xch = CFG->latintolocal[chr]; if (xch && (xch != chr)) str[j] = xch; else break; } } } } } // ------------------------------------------------------------------ void Latin2Local(std::string &str) { #if defined(__USE_ALLOCA__) char *temp = (char *)alloca(str.length()+1); #else __extension__ char temp[str.length()+1]; #endif strcpy(temp, str.c_str()); Latin2Local(temp); str = temp; } // ------------------------------------------------------------------ #ifdef HAS_ICONV void IconvClear(void){ if( iconv_cd!=(iconv_t)(-1) ){ iconv_close(iconv_cd); iconv_cd = (iconv_t)(-1); } } #endif // ------------------------------------------------------------------ char* XlatStr(char* dest, const char* src, int level, Chs* chrtbl, int qpencoded, bool i51) { if( src==NULL ) return dest; if( not chrtbl #ifdef HAS_ICONV && iconv_cd==(iconv_t)(-1) #endif ) return stpcpy(dest, src); uint n; int clen; int translated; char* tptr; char* escp; const char* sptr = src; char* dptr = dest; char dochar; ChsTab* chrs = chrtbl ? chrtbl->t : (ChsTab*)NULL; #ifdef HAS_ICONV size_t iconvrc=-1; if( iconv_cd!=(iconv_t)(-1) ){ iconvrc=iconv( iconv_cd, NULL, NULL, NULL, NULL ); // init iconv } #endif while(*sptr) { switch(*sptr) { case 0x02: if(i51 and I51Table) { for(n=0; nsize; n++) { tptr = (char*)I51TP[n]; if(*(sptr+1) == tptr[0]) { if(*(sptr+2) == tptr[1]) { escp = &tptr[2]; if(*escp) { *dptr++ = *escp++; if(*escp) { *dptr++ = *escp++; if(*escp) { *dptr++ = *escp; } } } sptr += 2; n = (uint)-1; break; } } } if(n != (uint)-1) // I51 char not found, use fallback method sptr++; } sptr++; break; case 29: if(MNETable) { for(n=0; nsize; n++) { tptr = (char*)MNETP[n]; if(*(sptr+1) == tptr[0]) { if(*(sptr+2) == tptr[1]) { escp = &tptr[2]; if(*escp) { *dptr++ = *escp++; if(*escp) { *dptr++ = *escp++; if(*escp) { *dptr++ = *escp; } } } sptr += 2; n = (uint)-1; break; } } } if(n != (uint)-1) // MNEMONIC char not found, use fallback method sptr++; } sptr++; break; case SOFTCR: translated = false; if (CompTable and not WideDispsoftcr) { if(sptr > src) { if(not (isspace(*(sptr-1)) or isspace(*(sptr+1)))) { for(n=0; nsize; n++) { tptr = (char*)CompTP[n]; if(*(sptr-1) == tptr[0]) { if(*(sptr+1) == tptr[1]) { escp = &tptr[2]; if(*escp) { dptr--; *dptr++ = *escp++; if(*escp) { *dptr++ = *escp++; if(*escp) { *dptr++ = *escp; translated = true; } } } sptr += 2; break; } } } } } } else if (WideDispsoftcr) goto defaultchardo; if(not translated) *dptr++ = *sptr++; break; case '=': if(qpencoded) { if(isxdigit(sptr[1]) and isxdigit(sptr[2])) { dochar = (char)((xtoi(sptr[1]) << 4) | xtoi(sptr[2])); sptr += 3; goto chardo; } } goto defaultchardo; default: defaultchardo: dochar = *sptr++; chardo: // Translate level 1 and 2 #ifdef HAS_ICONV if( iconv_cd!=(iconv_t)(-1) ){ unsigned srcleft=1; unsigned dstleft=3; char* tsptr = &dochar; iconvrc=iconv( iconv_cd, &tsptr, &srcleft, &dptr, &dstleft ); if( iconvrc==((size_t)-1) ){ switch( errno ){ case EINVAL: LOG.printf("An incomplete multibyte sequence has been encountered before:"); LOG.printf("%s",sptr); case EILSEQ: LOG.printf("An invalid multibyte sequence has been encountered in the input before:"); LOG.printf("%s",sptr); case E2BIG: LOG.printf("There is not sufficient destination size before '%s'", sptr); default: LOG.printf("Unknown error %u in iconv() before %s", errno, sptr); } } } else #endif if (((level == 1) || (level == 2)) && chrs) { tptr = (char*)chrs[(byte)dochar]; clen = *tptr++; while(clen--) *dptr++ = *tptr++; } else { *dptr++ = dochar; } } } *dptr = NUL; return dptr; } // ------------------------------------------------------------------ int cmp_quotes(char* q1, char* q2) { q1--; q2--; do { q1 = spanspaces(++q1); q2 = spanspaces(++q2); if(*q1 != *q2) return NO; } while(*q1 and *q2); return *q1 == *q2; } // ------------------------------------------------------------------ void GMsg::TextToLines(int __line_width, bool getvalue, bool header_recode) { MakeLineIndex(this, __line_width, getvalue, header_recode); } // ------------------------------------------------------------------ static bool check_multipart(const char* ptr, char* boundary) { if(striinc("multipart", ptr)) { const char* boundptr = striinc("boundary=", ptr); if(boundptr) { boundptr += 9; const char* boundend; if(*boundptr == '\"') { boundptr++; boundend = strchr(boundptr, '\"'); } else { boundend = strpbrk(boundptr, " \r\n"); } if(boundend) { strxcpy(boundary, boundptr, 1+boundend-boundptr); return true; } } } return false; } // ------------------------------------------------------------------ inline bool put_on_new_line(const char *ptr, const char *prev_ptr) { if((*ptr == CR) or (*ptr == CTRL_A) or is_quote(ptr) or ((ptr[0] == ptr[1]) and (ptr[0] == ptr[2])) or (strneql(ptr, "-- ", 3) and (ptr[3] == CR)) or strneql(ptr, " * Origin: ", 11) /*or (ptr[0] == prev_ptr[0]) and (ptr[1] == prev_ptr[1])*/) return true; // Put RFC kludges and SEEN-BY on new line while(*ptr and (isxalnum(*ptr) or (*ptr == '-'))) ptr++; if(*ptr == ':') return true; return false; } // ------------------------------------------------------------------ void MakeLineIndex(GMsg* msg, int margin, bool getvalue, bool header_recode) { uint idx=0, idxadjust=0; uint len; int level=0; uint n; char ch, chln = 0, dochar; Line* line; Line* nextline=NULL; char* bp; char* btmp=NULL; char* tptr; char* escp; char* bptr; ISub buf; char qbuf[MAXQUOTELEN], qbuf2[MAXQUOTELEN], chsbuf[100]; char* ptr; char* qptr; char* tmp=NULL; char* linetmp=NULL; uint qlen=0, qlen2=0; int wraps=0, para=0, chslev; bool reflow = false, quoteflag = false; bool quotewraphard = AA->Quotewraphard(); bool qpencoded = getvalue and (IsQuotedPrintable(AA->Xlatimport()) or AA->StripHTML()); bool gotmime = false; bool gotmultipart = false; bool inheader = false; gstrarray boundary_set; char boundary[100]; *buf = *qbuf = *qbuf2 = NUL; if(margin < 0) { margin = -margin; quoteflag = true; } // Free all previously allocated lines line = msg->lin; while(line) { nextline = line->next; throw_xdelete(line); line = nextline; } msg->icc[0] = NUL; msg->ibcc[0] = NUL; msg->lines = 0; msg->lin = NULL; if(AA->attr().hex()) { // Make a complete hexdump as a list of message lines w_info(LNG->GenHexdump); throw_release(msg->txt); line = AA->MakeDumpMsg(msg, LNG->Hexdumphead); if(line and msg->txt) { line = AddLine(line, ""); line = AddLine(line, LNG->Hexdumptext); line = AddLine(line, ""); ptr = msg->txt; uint _size = strlen(msg->txt); if(streql(AA->basetype(), "OPUS") or streql(AA->basetype(), "FTS1")) idxadjust = 190; for(idx=0; idx < _size; ptr+=16,idx+=16) { sprintf(buf, "%04X ", idx+idxadjust); HexDump16(buf+7, ptr, MinV((int)(_size-idx), 16), HEX_DUMP2); line = AddLine(line, buf); } } w_info(NULL); } else { // Convert the message text to a list of separately allocated lines char prev_ptr[3] = {"\xFF\xFF"}; if(AA->StripHTML()) RemoveHTML(msg->txt); ptr = spanfeeds(msg->txt); // Set default conversion table for area if(getvalue) { if(not strieql(AA->Xlatimport(), CFG->xlatlocalset)) { strxcpy(msg->charset, AA->Xlatimport(), sizeof(msg->charset)); level = msg->charsetlevel = LoadCharset(msg->charset, CFG->xlatlocalset); } } if(*ptr != NUL) { line = msg->lin = new Line(); throw_xnew(line); // Alloc space for one line linetmp = (char*)throw_calloc(1, margin+512); while(*ptr) { bptr = linetmp; bp = bptr; len = 0; // Link previous line to this one if(line->prev) { line->prev->next = line; if((line->prev->type & (GLINE_HARD|GLINE_WRAP|GLINE_QUOT)) == (GLINE_HARD|GLINE_WRAP)) { line->prev->type &= ~GLINE_HARD; line->type |= GLINE_HARD; } } // Reflow quotes if(reflow) { len = qlen; qptr = qbuf; reflow = false; // Insert previous quotestring for(n=0; ntype |= GLINE_QUOT|GLINE_HARD; } // Get type of line int isq_flag1 = 0; bool isq_flag2 = false; if(wraps == 0) { if(gotmultipart) { if(*ptr == '-' and ptr[1] == '-') { gstrarray::iterator ib; for(ib = boundary_set.begin(); ib != boundary_set.end(); ib++) if(strneql(ptr+2, (*ib).c_str(), (*ib).length())) { inheader = true; break; } } else if(*ptr == '\n' or *ptr == '\r') inheader = false; } if(inheader and (*ptr != '-')) line->type |= GLINE_HIDD; para = 0; if(*ptr == CTRL_A or inheader) { // Found kludge/hidden line para = GLINE_KLUD; line->type |= GLINE_HARD; if(getvalue and not CFG->ignorecharset) { tptr = ptr; char* kludge = ptr + (*ptr == CTRL_A ? 1 : 0); if(strnieql(kludge, "RFC", 3)) { kludge += 3; if(not g_isalpha(*kludge)) kludge++; } while((*ptr != ' ') and (*ptr != ':') and *ptr) ptr++; char endchar = *ptr; *ptr = NUL; int kludgetype = -1; if(strieql(kludge, "I51")) kludgetype = FSC_I51; else if(strieql(kludge, "CHRS") or strieql(kludge, "CHARSET")) kludgetype = FSC_CHARSET; else if(strieql(kludge, "CODEPAGE")) kludgetype = FSC_CODEPAGE; else if(strieql(kludge, "Content-Type")) kludgetype = RFC_CONTENT_TYPE; else if(strieql(kludge, "Content-Transfer-Encoding")) kludgetype = RFC_CONTENT_TRANSFER_ENCODING; else if(strieql(kludge, "X-Charset")) kludgetype = RFC_X_CHARSET; else if(strieql(kludge, "X-Char-Esc")) kludgetype = RFC_X_CHAR_ESC; *ptr = endchar; if(*ptr != ' ') ptr++; ptr = strskip_wht(ptr); char* keptr = strpbrk(ptr, "\r\n"); if(keptr) { endchar = *keptr; *keptr = NUL; } if(kludgetype == FSC_I51) { msg->i51 = true; // Convert FSC-0051.003 to FSC-0054.003 strxcpy(chsbuf, "LATIN-1", sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); if(not chslev) { strxcpy(chsbuf, AA->Xlatimport(), sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); } if(chslev) { level = msg->charsetlevel = chslev; strcpy(msg->charset, chsbuf); } } else if((kludgetype == FSC_CHARSET) or (kludgetype == FSC_CODEPAGE)) { *chsbuf = NUL; qpencoded = IsQuotedPrintable(ptr); if(kludgetype == FSC_CODEPAGE) strxmerge(chsbuf, sizeof(chsbuf), "CP", ptr, NULL); else strxcpy(chsbuf, qpencoded ? ExtractPlainCharset(ptr) : ptr, sizeof(chsbuf)); // Workaround for buggy mailreaders which stores '_' in charset name strchg(chsbuf,'_',' '); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); if(not chslev) { strxcpy(chsbuf, AA->Xlatimport(), sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); } if(chslev) { level = msg->charsetlevel = chslev; strcpy(msg->charset, chsbuf); } if(*msg->charset == NUL) strcpy(msg->charset, chsbuf); } else if(kludgetype == RFC_CONTENT_TYPE) { // Content-Type: text/plain; charset="us-ascii" while(keptr and ((keptr[1] == ' ') or (keptr[1] == '\t'))) { *keptr = endchar; keptr = strpbrk(keptr+1, "\r\n"); if(keptr) { endchar = *keptr; *keptr = NUL; } } const char *mime_charset = striinc("charset=", ptr); if(mime_charset != NULL) { if(mime_charset[8] == '\"') { strxcpy(chsbuf, mime_charset+9, sizeof(chsbuf)); char *quote = strchr(chsbuf, '\"'); if(quote != NULL) *quote = NUL; } else strxcpy(chsbuf, strrword(mime_charset+8), sizeof(chsbuf)); if(striinc("8859", chsbuf)) ISO2Latin(chsbuf, chsbuf); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); if(not chslev) { strxcpy(chsbuf, AA->Xlatimport(), sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); } if(chslev) { level = msg->charsetlevel = chslev; strcpy(msg->charset, chsbuf); } if(*msg->charset == NUL) strcpy(msg->charset, chsbuf); gotmime = true; } else if(check_multipart(ptr, boundary)) { boundary_set.push_back(boundary); gotmultipart = true; gotmime = true; } } else if(kludgetype == RFC_CONTENT_TRANSFER_ENCODING) { if(striinc("quoted-printable", ptr)) { qpencoded = true; msg->charsetencoding |= GCHENC_QP; strcpy(chsbuf, MakeQuotedPrintable(msg->charset)); chslev = LoadCharset(msg->charset, CFG->xlatlocalset); if(not chslev) { strxcpy(chsbuf, AA->Xlatimport(), sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); } if(chslev) { level = msg->charsetlevel = chslev; strcpy(msg->charset, chsbuf); } } } else if(kludgetype == RFC_X_CHARSET) { if(not gotmime) { if(striinc("8859", ptr)) ISO2Latin(chsbuf, ptr); else strxcpy(chsbuf, ptr, sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); if(not chslev) { strxcpy(chsbuf, AA->Xlatimport(), sizeof(chsbuf)); chslev = LoadCharset(chsbuf, CFG->xlatlocalset); } if(chslev) { level = msg->charsetlevel = chslev; strcpy(msg->charset, chsbuf); } } } else if(kludgetype == RFC_X_CHAR_ESC) { if(not gotmime) msg->charsetencoding |= GCHENC_MNE; } if(keptr) *keptr = endchar; ptr = tptr; } } else if ((isq_flag1 = is_quote(ptr)) && (isq_flag2 = is_quote2(line, ptr))) { para = GLINE_QUOT; line->type |= GLINE_QUOT|GLINE_HARD; GetQuotestr(ptr, qbuf, &qlen); } } if (CFG->quoteusenewai && isq_flag1 && !isq_flag2) { uint bad_qlen; char bad_qbuf[MAXQUOTELEN]; char *bad_ptr; GetQuotestr(bad_ptr = ptr, bad_qbuf, &bad_qlen); while (true) { for (; *bad_ptr && (*bad_ptr != CR); bad_ptr++); if (!*bad_ptr) break; char *bad_head = bad_ptr; bad_ptr++; if (*bad_ptr == LF) bad_ptr++; if (strneql(bad_qbuf, bad_ptr, bad_qlen)) { *bad_head = ' '; memmove(bad_head+1, bad_ptr+bad_qlen, strlen(bad_ptr)); bad_ptr = bad_head; } else break; } } // Get one line ch = '\0'; tmp = NULL; while(*ptr and (len < (uint)margin)) { switch(*ptr) { case CR: do_cr: ch = CR; ptr = spanfeeds(ptr+1); if(wraps and not ((line->type & GLINE_HARD) and not (line->type & GLINE_QUOT))) { if(para != GLINE_QUOT) { if(quoteflag) { if(para == GLINE_KLUD) { wraps = 0; break; } if(put_on_new_line(ptr, prev_ptr)) { wraps = 0; break; } char* lp = ptr; while((*lp == ' ') or (*lp == '\t')) lp++; if(*lp == CR) { wraps = 0; break; } else { ptr = lp; if(*bp != ' ') { *(++bp) = ' '; len++; } } ch = '\0'; continue; } else { wraps=0; break; } } else { GetQuotestr(ptr, qbuf2, &qlen2); if((*ptr != CR) and cmp_quotes(qbuf2, qbuf)) { char* lp = ptr + qlen2; if(is_quote(lp)) { wraps = 0; para = 0; break; } else { ptr = lp; para = GLINE_QUOT; if((*ptr != ' ') and (*bp != ' ')) { if(put_on_new_line(ptr, prev_ptr)) { ptr -= qlen2; wraps = 0; break; } tmp = ptr-1; btmp = bp; *(++bp) = ' '; len++; } else if(*ptr == ' ') { ptr -= qlen2; wraps = 0; break; } ch = 0; continue; } } else { wraps = 0; para = 0; break; } } } break; case 0x02: // The I51 escape character if(msg->i51 and I51Table) { for(n=0; nsize; n++) { tptr = (char*)I51TP[n]; if(*(ptr+1) == tptr[0]) { if(*(ptr+2) == tptr[1]) { escp = &tptr[2]; if(*escp) { *(++bp) = *escp++; if(*escp) { *(++bp) = *escp++; len++; if(*escp) { *(++bp) = *escp; len++; } } } ptr += 2; n = (uint)-1; break; } } } if(n != (uint)-1) // I51 char not found, use fallback method ptr++; } ptr++; break; case 29: // The MNE escape character if(MNETable) { for(n=0; nsize; n++) { tptr = (char*)MNETP[n]; if(*(ptr+1) == tptr[0]) { if(*(ptr+2) == tptr[1]) { escp = &tptr[2]; if(*escp) { *(++bp) = *escp++; if(*escp) { *(++bp) = *escp++; len++; if(*escp) { *(++bp) = *escp; len++; } } } ptr += 2; n = (uint)-1; break; } } } if(n != (uint)-1) // MNE char not found, use fallback method ptr++; } ptr++; break; case SOFTCR: if (WideDispsoftcr) goto defaultchardo; else { if(CompTable) { if(not (isspace(*(ptr-1)) or isspace(*(ptr+1)))) { for(n=0; nsize; n++) { tptr = (char*)CompTP[n]; if(*(ptr-1) == tptr[0]) { if(*(ptr+1) == tptr[1]) { escp = &tptr[2]; if(*escp) { *(bp) = *escp++; if(*escp) { *(++bp) = *escp++; len++; if(*escp) { *(++bp) = *escp; len++; } } } ptr++; break; } } } } else if(para == GLINE_QUOT) { *ptr-- = CR; // Fake a CR } } else if(para == GLINE_QUOT) { *ptr-- = CR; // Fake a CR } ptr++; } break; case LF: ptr++; break; case CTRL_A: *(++bp) = *ptr++; ++len; break; case '=': if(qpencoded) { if(isxdigit(ptr[1]) and isxdigit(ptr[2])) { // Decode the character dochar = (char)((xtoi(ptr[1]) << 4) | xtoi(ptr[2])); ptr += 3; if(dochar == '\t') { if(len >= qlen) { tmp = ptr-3; btmp = bp; } goto do_ht; } else if(dochar == CR) goto do_cr; goto chardo; } else if((ptr[1] == CR) or (ptr[1] == LF)) { // Skip soft line break ptr = spanfeeds(ptr+2); break; } } goto defaultchardo; case '\t': if(len >= qlen) { tmp = ptr; btmp = bp; } ptr++; do_ht: if(CFG->disptabsize) { int llen = (int)(bp-linetmp); for(n=0; n<(CFG->disptabsize-(llen%CFG->disptabsize)); n++) { *(++bp) = ' '; len++; } } else { *(++bp) = ' '; len++; } break; case ' ': if(len >= qlen) { tmp = ptr; btmp = bp; } default: defaultchardo: dochar = *ptr++; chardo: // Translate level 1 and 2 if (((level == 1) || (level == 2)) && ChsTP) { tptr = (char*)ChsTP[(byte)dochar]; chln = *tptr++; while(chln--) { *(++bp) = *tptr++; ++len; } } else { *(++bp) = dochar; ++len; } break; } if(ch == CR) break; } if(len == (uint)margin) { if(*ptr == CR) { line->type |= GLINE_HARD; wraps = 0; ptr++; } else { wraps++; if(para == GLINE_QUOT) reflow = true; line->type |= GLINE_WRAP; ptr = spanfeeds(ptr); if((*bp == ' ') or (isspace(*ptr) and (*ptr != LF))) ptr = spanspaces(ptr); else { if(tmp) { bp = btmp+1; ptr = tmp+1; } } } } else line->type |= GLINE_HARD; *(++bp) = NUL; // Get line length uint tmplinelength = (uint)(bp-bptr); if(tmplinelength > (uint)(margin + 512)) { LOG.ErrPointer(); LOG.printf("! A message line length (%u bytes) exceeded an internal buffer limit of %u bytes", tmplinelength, margin+512); LOG.printf(": Message line text: %s", bptr+1); PointerErrorExit(); } // Store line line->txt = linetmp+1; prev_ptr[0] = line->txt.empty() ? 0xFF : line->txt[0]; prev_ptr[1] = line->txt.length() < 2 ? 0xFF : line->txt[1]; // Set line color and type if((line->type & GLINE_QUOT) and not is_quote(line->txt.c_str())) line->type ^= GLINE_QUOT; if(line->type & GLINE_QUOT) line->color = quotecolor(line->txt.c_str()); else if(inheader) line->color = C_READT; else line->color = C_READW; Line* prevline = line; line = new Line(); throw_xnew(line); line->prev = prevline; ptr = spanfeeds(ptr); } throw_release(linetmp); throw_xdelete(line); // Charset translate header fields if(header_recode) { strxmimecpy(msg->by, msg->by, level, sizeof(INam), true); strxmimecpy(msg->to, msg->to, level, sizeof(INam), true); if(not (msg->attr.frq() or msg->attr.att() or msg->attr.urq())) strxmimecpy(msg->re, msg->re, level, sizeof(ISub), true); } // Scan msg body top for RFC headerlines int irfcbody = AA->Internetrfcbody(); if(irfcbody != 0) { if(msg->lin) { Line* linep = msg->lin; int headerlines = 0; while(linep) { if(not linep->txt.empty()) { const char* tptr = linep->txt.c_str(); if(*tptr != CTRL_A) { int kludgetype = ScanLine(msg, linep, tptr, getvalue, MASK_RFC); if(kludgetype) { if(kludgetype == HEADERLINE) { linep->type |= GLINE_HIDD; } headerlines++; if(linep->type & GLINE_HIDD) linep->color = C_READKH; else linep->color = C_READK; if(linep->next) { char lwsp = *linep->next->txt.c_str(); while((lwsp == ' ') or (lwsp == '\t') or (linep->type & GLINE_WRAP)) { linep = linep->next; linep->type |= linep->prev->type & (GLINE_KLUD|GLINE_HIDD); linep->color = linep->prev->color; if(linep->next) lwsp = *linep->next->txt.c_str(); else break; } } } else break; } } else { if(headerlines) { linep->type |= GLINE_KLUD; linep->kludge = GKLUD_RFC; linep->color = C_READK; } if(--irfcbody == 0) break; } if(linep->type & GLINE_WRAP) { while(linep and (linep->type & GLINE_WRAP)) { linep = linep->next; if(linep) { linep->type |= linep->prev->type & (GLINE_KLUD|GLINE_HIDD); linep->color = linep->prev->color; } } } if(linep) linep = linep->next; } } } // Scan for kludge-, tear- and originlines ScanKludges(msg, getvalue); // Try to fix the following situation: // Messagebase From field: fido7@da.ru // @REPLYADDR: fido7@da.ru // @REPLYTO: 2:5020/52 Sergey Kitsya // From: fido7@da.ru if(getvalue and streql(msg->by, msg->iaddr) and not *msg->realby and *msg->igate) { ptr = strchr(msg->igate, ' '); if(ptr) { ptr = strskip_wht(ptr); if(not isuucp(ptr)) strcpy(msg->realby, ptr); } } } } // Make the index to the line index as allowed by config MsgLineReIndex(msg); } // ------------------------------------------------------------------ void MsgLineReIndex(GMsg* msg, int viewhidden, int viewkludge, int viewquote) { if(viewhidden == -1) viewhidden = AA->Viewhidden(); if(viewkludge == -1) viewkludge = AA->Viewkludge(); if(viewquote == -1) viewquote = AA->Viewquote(); int x; Line* line; throw_xrelease(msg->line); line = msg->lin; msg->lines = 0; while(line) { msg->lines++; if(line->next) { if(line->type & GLINE_QUOT) { if(not (line->next->type & GLINE_QUOT) and not strblank(line->next->txt.c_str())) { if(CFG->switches.get(quotespacing)) { line = AddLine(line, ""); msg->lines++; } } } else { const char *posn, *posn2 = line->txt.c_str(); if(msg->attr.pos() and ((posn = striinc("@position", posn2)) != NULL)) { line->txt.erase(posn - posn2, 9); line->type |= GLINE_POSI; } if((line->next->type & GLINE_QUOT) and not strblank(line->txt.c_str())) { if(CFG->switches.get(quotespacing)) { line = AddLine(line, ""); msg->lines++; } } } } line = line->next; } msg->line = (Line**)throw_xcalloc(msg->lines+2, sizeof(Line*)); x = 0; msg->lines = 0; char qbuf[MAXQUOTELEN]; char qbuf0[MAXQUOTELEN]; uint qlen = 0; int qmatches = 0; *qbuf0 = NUL; for(line = msg->lin; line != NULL; line = line->next) { if(line->type & GLINE_KLUD) { *qbuf0 = NUL; qmatches = 0; if(not viewkludge) { continue; } } else if(line->type & GLINE_HIDD) { *qbuf0 = NUL; qmatches = 0; if(not viewhidden) { continue; } } else if (line->type & GLINE_TXTH) { *qbuf0 = NUL; qmatches = 0; continue; } else if(line->type & GLINE_QUOT) { if(not viewquote) { GetQuotestr(line->txt.c_str(), qbuf, &qlen); if(not cmp_quotes(qbuf0, qbuf)) { strcpy(qbuf0, qbuf); qmatches = 0; } const char *p = line->txt.c_str()+qlen; while(*p != NUL) { if(isxalnum(*p)) { qmatches++; break; } ++p; } if(qmatches != 1) { continue; } } } else { *qbuf0 = NUL; qmatches = 0; } msg->line[x++] = line; msg->lines++; } msg->line[x] = NULL; // Mark end of index // Calculate quote percent int quotes = 0, nonquotes = 0; line = msg->lin; while(line) { if(not (line->type & (GLINE_KLUDGE|GLINE_TEAR|GLINE_ORIG))) { if(line->txt.c_str()) { int n = line->txt.length(); nonquotes += n; if(line->type & GLINE_QUOT) quotes += n; } } line = line->next; } msg->quotepct = 100-Pct(nonquotes, quotes); } // ------------------------------------------------------------------ bool IsQuotedPrintable(const char *encoding) { if(striinc("LATIN1QP", encoding)) return true; else { const char *lencoding = strlword(encoding); int len = strlen(lencoding); if((len > 2) and strnieql("QP", lencoding+len-2, 2)) return true; } return false; } // ------------------------------------------------------------------ static char qpencodingbuf[100]; char *MakeQuotedPrintable(const char *encoding) { strxmerge(qpencodingbuf, sizeof(qpencodingbuf), strlword(encoding), "QP", NULL); return qpencodingbuf; } // ------------------------------------------------------------------ char *ExtractPlainCharset(const char *encoding) { strxcpy(qpencodingbuf, strlword(encoding), sizeof(qpencodingbuf)); int len = strlen(qpencodingbuf); if(len > 2) qpencodingbuf[len-2] = NUL; return qpencodingbuf; } // ------------------------------------------------------------------ char *Latin2ISO(char *iso_encoding, const char *latin_encoding) { static const char *isono[] = { "15", "1", "2", "3", "4", "9", "10", "13", "14", "15" }; int chsno = atoi(latin_encoding+5); if(chsno < 0) chsno = -chsno; // support for both latin-1 and latin1 chsno = chsno > sizeof(isono)/sizeof(const char *) ? 0 : chsno; return strxmerge(iso_encoding, 12, "iso-8859-", isono[chsno], NULL); } // ------------------------------------------------------------------ char *ISO2Latin(char *latin_encoding, const char *iso_encoding) { static const char *latinno[] = { NULL, "1", "2", "3", "4", NULL, NULL, NULL, NULL, "5", "6", NULL, NULL, "7", "8", "9" }; int chsno = atoi(strstr(iso_encoding, "8859")+5); chsno = chsno > sizeof(latinno)/sizeof(const char *) ? 0 : chsno; if(latinno[chsno] == NULL) return strxmerge(latin_encoding, 12, iso_encoding, NULL); else return strxmerge(latin_encoding, 8, "latin-", latinno[chsno], NULL); } // ------------------------------------------------------------------ static bool CheckLevel(const char* imp, const char* imp2, int n, int ¤t_table) { const char *ptr = striinc(imp2, imp); ptr += strlen(imp2); strskip_wht(ptr); int level = atoi(ptr); if (CharTable && (n == current_table) && (level <= CharTable->level)) return true; FILE* fp = fsopen(AddPath(CFG->goldpath, CFG->xlatged), "rb", CFG->sharemode); if (fp) { if (!CharTable) CharTable = (Chs*)throw_calloc(1, sizeof(Chs)); fseek(fp, ((long)n*(long)sizeof(Chs)), SEEK_SET); fread(CharTable, sizeof(Chs), 1, fp); fclose(fp); ChsTP = CharTable->t; current_table = n; // Disable softcr translation unless DISPSOFTCR is enabled if (not WideDispsoftcr) { char* tptr = (char*)ChsTP[SOFTCR]; *tptr++ = 1; *tptr = SOFTCR; } if (level <= CharTable->level) return true; } return false; } // ------------------------------------------------------------------ int LoadCharset(const char* imp, const char* exp, int query) { static int current_table = -1; int n; switch(query) { case 1: return current_table; default: break; } #ifdef HAS_ICONV if( iconv_cd != (iconv_t)(-1) ) iconv_close(iconv_cd); iconv_cd = iconv_open(imp,exp); if(iconv_cd != (iconv_t)(-1) ) LOG.printf("iconv is initialised to convert from %s to %s", imp, exp); else LOG.printf("Can't initialise iconv to convert from %s to %s", imp, exp); #endif // Find and load charset table std::vector::iterator xlt; for(n = 0, xlt = CFG->xlatcharset.begin(); xlt != CFG->xlatcharset.end(); xlt++, n++) { if (!striinc(xlt->exp, exp)) continue; bool imp_found = make_bool(striinc(xlt->imp, imp)); if (imp_found) imp_found = CheckLevel(imp, xlt->imp, n, current_table); std::vector< std::pair >::iterator als; for (als = CFG->xlatcharsetalias.begin(); !imp_found && (als != CFG->xlatcharsetalias.end()); als++) { if (strieql(xlt->imp, als->first.c_str())) { for (gstrarray::iterator it = als->second.begin(); !imp_found && (it != als->second.end()); it++) if (striinc(it->c_str(), imp)) imp_found = CheckLevel(imp, it->c_str(), n, current_table); } } if (imp_found) return CharTable->level; } // No matching table found throw_release(CharTable); ChsTP = NULL; current_table = -1; return 0; } // ------------------------------------------------------------------ Line* DeleteLine(Line* line) { Line* nextline = NULL; // Link next and previous lines and release this line if(line) { if(line->prev) { line->prev->next = line->next; nextline = line->prev; } if(line->next) { line->next->prev = line->prev; nextline = line->next; } throw_xdelete(line); } return nextline; } // ------------------------------------------------------------------ Line* InsertLine(Line* newline, Line* oldline, int pos) { if(oldline) { if(pos >= DIR_BELOW) { newline->prev = oldline; newline->next = oldline->next; if(oldline->next) oldline->next->prev = newline; oldline->next = newline; } else { newline->prev = oldline->prev; newline->next = oldline; if(oldline->prev) oldline->prev->next = newline; oldline->prev = newline; } } return newline; } // ------------------------------------------------------------------ Line* FirstLine(Line* line) { if(line) while(line->prev) line = line->prev; return line; } // ------------------------------------------------------------------ Line* LastLine(Line* line) { if(line) while(line->next) line = line->next; return line; } // ------------------------------------------------------------------ Line* AddLine(Line* line, const char* buf, int where) { Line* newline = new Line(buf); throw_xnew(newline); newline->type = GLINE_HARD; newline->color = C_READW; return InsertLine(newline, line, where); } // ------------------------------------------------------------------ Line* AddLine(Line* line, const char* buf) { return AddLine(line, buf, DIR_BELOW); } // ------------------------------------------------------------------ Line* AddLineFast(Line* oldline, char* text) { Line* newline = new Line(text); throw_xnew(newline); newline->type = GLINE_HARD; newline->color = C_READW; newline->prev = oldline; newline->next = oldline->next; if(oldline->next) oldline->next->prev = newline; oldline->next = newline; return newline; } // ------------------------------------------------------------------ Line* AddKludge(Line* line, char* buf, int where) { Line* newline = new Line(buf); throw_xnew(newline); newline->type = GLINE_HARD|GLINE_KLUD; newline->color = C_READK; return InsertLine(newline, line, where); } // ------------------------------------------------------------------ Line* AddLineF(Line*& line, const char* format, ...) { char buf[256]; va_list argptr; va_start(argptr, format); vsprintf(buf, format, argptr); va_end(argptr); line = AddLine(line, buf); return line; } // ------------------------------------------------------------------ Line* AddHexdump(Line*& line, void* data, size_t datalen) { char buf[256]; uint pos = 0; char* ptr = (char*)data; while(pos < datalen) { uint dataleft = datalen - pos; sprintf(buf, "%04X ", pos); HexDump16(buf+7, ptr, (dataleft < 16) ? dataleft : 16, HEX_DUMP2); line = AddLine(line, buf); ptr += 16; pos += 16; } return line; } // ------------------------------------------------------------------ char* ParseInternetAddr(char* __string, char* __name, char* __addr, bool detect_charset) { *__name = *__addr = NUL; char* commaptr = NULL; if(strchr(__string, ',')) { bool inquotes = false; commaptr = __string; while(commaptr) { if(*commaptr == '\"') inquotes = not inquotes; else if((*commaptr == ',') and not inquotes) { *commaptr = NUL; break; } if(not *commaptr) commaptr = NULL; else commaptr++; } } char* p; if((p = strrchr(__string, '>')) != NULL) *(++p) = NUL; char* endchar = __string + strlen(__string) - 1; if(*endchar == /*(*/ ')') { char* begchar = endchar; int pcnt = 0; while(begchar > __string) { if(*begchar == /*(*/ ')') pcnt++; else if(*begchar == '(' /*)*/) pcnt--; if(pcnt == 0) break; begchar--; } if(*begchar == '(' /*)*/) begchar++; strbtrim(strxcpy(__name, begchar, MinV((size_t)(endchar-begchar)+1, (size_t)sizeof(INam)))); strbtrim(strxcpy(__addr, __string, MinV((size_t)(begchar-__string), (size_t)sizeof(IAdr)))); } else if(*endchar == '>') { char* endaddr = endchar; while(*endchar != '<' and endchar > __string) endchar--; char* begaddr = endchar; if(*endchar == '<') { begaddr++; if (endchar > __string) endchar--; } __string = strskip_wht(__string); strbtrim(strxcpy(__name, __string, MinV((size_t)(endchar-__string)+1, (size_t)sizeof(INam)))); strbtrim(strxcpy(__addr, begaddr, MinV((size_t)(endaddr-begaddr)+1, (size_t)sizeof(IAdr)))); } else { strxcpy(__addr, __string, sizeof(IAdr)); } if(*__addr == '@') { char* ptr = strchr(__addr, ':'); if(ptr) memmove(__addr, ptr+1, strlen(ptr)); } if(commaptr) *commaptr = ','; StripQuotes(__name); if(not strchr(__addr, '@')) *__addr = NUL; strxmimecpy(__name, __name, 0, strlen(__name)+1, detect_charset); return __name; } // ------------------------------------------------------------------ void InvalidateControlInfo(GMsg* msg) { Line* line = msg->lin; char buf[256]; while(line) { if(not (line->type & (GLINE_TEAR | GLINE_ORIG))) { strcpy(buf, line->txt.c_str()); // Invalidate tearline if(not CFG->invalidate.tearline.first.empty()) doinvalidate(buf, CFG->invalidate.tearline.first.c_str(), CFG->invalidate.tearline.second.c_str(), true); else doinvalidate(buf, "---", "-+-", true); // Invalidate originline if(not CFG->invalidate.origin.first.empty()) doinvalidate(buf, CFG->invalidate.origin.first.c_str(), CFG->invalidate.origin.second.c_str()); else doinvalidate(buf, " * Origin: ", " + Origin: "); // Invalidate SEEN-BY's if(not CFG->invalidate.seenby.first.empty()) doinvalidate(buf, CFG->invalidate.seenby.first.c_str(), CFG->invalidate.seenby.second.c_str()); else doinvalidate(buf, "SEEN-BY: ", "SEEN+BY: "); if(stricmp(buf, line->txt.c_str())) { line->type &= ~GLINE_KLUDGE; line->kludge = 0; line->color = C_READW; line->txt = buf; } } line = line->next; } } // ------------------------------------------------------------------