Allows for request custom headers when fetching messages

* Defines new request kind ExtraHeaders
* Exposes extraHeaders property on fetch messages operations
* Modifies MessageHeader::importIMFFields for handling any headers

4 files changed, 228 insertions, 134 deletions

diff --git a/src/core/abstract/MCMessageConstants.h b/src/core/abstract/MCMessageConstants.h
index 4949bb95..2ecde808 100644
--- a/src/core/abstract/MCMessageConstants.h
+++ b/src/core/abstract/MCMessageConstants.h
@@ -68,6 +68,7 @@ namespace mailcore {
         IMAPMessagesRequestKindGmailLabels   = 1 << 6,
         IMAPMessagesRequestKindGmailMessageID = 1 << 7,
         IMAPMessagesRequestKindGmailThreadID  = 1 << 8,
+        IMAPMessagesRequestKindExtraHeaders  = 1 << 9,
     };
 
     enum IMAPFetchRequestType {
@@ -225,4 +226,4 @@ namespace mailcore {
 
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/core/abstract/MCMessageHeader.cc b/src/core/abstract/MCMessageHeader.cc
index bdeb6907..b1fe740e 100644
--- a/src/core/abstract/MCMessageHeader.cc
+++ b/src/core/abstract/MCMessageHeader.cc
@@ -22,6 +22,9 @@ static Array * lep_address_list_from_lep_mailbox(struct mailimf_mailbox_list * m
 static Array * msg_id_to_string_array(clist * msgids);
 static clist * msg_id_from_string_array(Array * msgids);
 
+static Array * keyword_to_string_array(clist * keywords);
+static Array * clist_to_string_array(clist * cstrs);
+
 #define MAX_HOSTNAME 512
 
 MessageHeader::MessageHeader()
@@ -155,6 +158,11 @@ String * MessageHeader::description()
 	if (mUserAgent != NULL) {
         result->appendUTF8Format("X-Mailer: %s\n", mUserAgent->UTF8Characters());
     }
+    if (mExtraHeaders != NULL) {
+        mc_foreachdictionaryKeyAndValue(String, header, String, value, mExtraHeaders) {
+            result->appendUTF8Format("%s: %s\n", header->UTF8Characters(), value->UTF8Characters());
+        }
+    }
     result->appendUTF8Format(">");
     
     return result;
@@ -355,127 +363,170 @@ void MessageHeader::importHeadersData(Data * data)
 	}
     
     importIMFFields(fields);
-    
+
     mailimf_fields_free(fields);
 }
 
 void MessageHeader::importIMFFields(struct mailimf_fields * fields)
 {
-	struct mailimf_single_fields single_fields;
-	
-	mailimf_single_fields_init(&single_fields, fields);
-	
-	/* date */
-	
-	if (single_fields.fld_orig_date != NULL) {
-		time_t timestamp;
-		timestamp = timestamp_from_date(single_fields.fld_orig_date->dt_date_time);
-        setDate(timestamp);
-        setReceivedDate(timestamp);
-		//MCLog("%lu %lu", (unsigned long) timestamp, date());
-	}
-	
-	/* subject */
-	if (single_fields.fld_subject != NULL) {
-		char * subject;
-		
-		subject = single_fields.fld_subject->sbj_value;
-		setSubject(String::stringByDecodingMIMEHeaderValue(subject));
-	}
-	
-	/* sender */
-	if (single_fields.fld_sender != NULL) {
-		struct mailimf_mailbox * mb;
-		Address * address;
+    clistiter * cur;
+    cur = clist_begin(fields->fld_list);
+    while (cur != NULL) {
+        struct mailimf_field * field;
+
+        field = (mailimf_field *)clist_content(cur);
         
-		mb = single_fields.fld_sender->snd_mb;
-       if (mb != NULL) {
-           address = Address::addressWithIMFMailbox(mb);
-           setSender(address);
-       }
-	}
+        switch (field->fld_type) {
+            case MAILIMF_FIELD_ORIG_DATE:
+                if (date() == 0) {
+                    time_t timestamp;
+                    timestamp = timestamp_from_date(field->fld_data.fld_orig_date->dt_date_time);
+                    setDate(timestamp);
+                    setReceivedDate(timestamp);
+                }
+                break;
+            case MAILIMF_FIELD_SUBJECT:
+                if (subject() == NULL) {
+                    char * subject;
+                    subject = field->fld_data.fld_subject->sbj_value;
+                    setSubject(String::stringByDecodingMIMEHeaderValue(subject));
+                }
+                break;
+            case MAILIMF_FIELD_SENDER:
+                if (sender() == NULL) {
+                    struct mailimf_mailbox * mb;
+                    Address * address;
+                    
+                    mb = field->fld_data.fld_sender->snd_mb;
+                    if (mb != NULL) {
+                        address = Address::addressWithIMFMailbox(mb);
+                        setSender(address);
+                    }
+                }
+                break;
+            case MAILIMF_FIELD_FROM:
+                if (from() == NULL) {
+                    struct mailimf_mailbox_list * mb_list;
+                    Array * addresses;
+                    
+                    mb_list = field->fld_data.fld_from->frm_mb_list;
+                    addresses = lep_address_list_from_lep_mailbox(mb_list);
+                    if (addresses->count() > 0) {
+                        setFrom((Address *) (addresses->objectAtIndex(0)));
+                    }
+                }
+                break;
+            case MAILIMF_FIELD_REPLY_TO:
+                if (replyTo() == NULL) {
+                    struct mailimf_address_list * addr_list;
+                    Array * addresses;
+
+                    addr_list = field->fld_data.fld_reply_to->rt_addr_list;
+                    addresses = lep_address_list_from_lep_addr(addr_list);
+                    setReplyTo(addresses);
+                }
+                break;
+            case MAILIMF_FIELD_TO:
+                if (to() == NULL) {
+                    struct mailimf_address_list * addr_list;
+                    Array * addresses;
+
+                    addr_list = field->fld_data.fld_to->to_addr_list;
+                    addresses = lep_address_list_from_lep_addr(addr_list);
+                    setTo(addresses);
+                }
+                break;
+            case MAILIMF_FIELD_CC:
+                if (cc() == NULL) {
+                    struct mailimf_address_list * addr_list;
+                    Array * addresses;
+
+                    addr_list = field->fld_data.fld_cc->cc_addr_list;
+                    addresses = lep_address_list_from_lep_addr(addr_list);
+                    setCc(addresses);
+                }
+                break;
+            case MAILIMF_FIELD_BCC:
+                if (bcc() == NULL) {
+                    struct mailimf_address_list * addr_list;
+                    Array * addresses;
+
+                    addr_list = field->fld_data.fld_bcc->bcc_addr_list;
+                    addresses = lep_address_list_from_lep_addr(addr_list);
+                    setBcc(addresses);
+                }
+                break;
+            case MAILIMF_FIELD_MESSAGE_ID:
+                char * msgid;
+                String * str;
+                    
+                msgid = field->fld_data.fld_message_id->mid_value;
+                str = String::stringWithUTF8Characters(msgid);
+                setMessageID(str);
+                break;
+            case MAILIMF_FIELD_REFERENCES:
+                if (references() == NULL) {
+                    clist * msg_id_list;
+                    Array * msgids;
+                    
+                    msg_id_list = field->fld_data.fld_references->mid_list;
+                    msgids = msg_id_to_string_array(msg_id_list);
+                    setReferences(msgids);
+                }
+                break;
+            case MAILIMF_FIELD_IN_REPLY_TO:
+                if (inReplyTo() == NULL) {
+                    clist * msg_id_list;
+                    Array * msgids;
+                    
+                    msg_id_list = field->fld_data.fld_references->mid_list;
+                    msgids = msg_id_to_string_array(msg_id_list);
+                    setReferences(msgids);
+                }
+                break;
+            case MAILIMF_FIELD_COMMENTS:
+                if (headerValueForName(MCSTR("Comments")) == NULL) {
+                    char * comments;
+                    String * str;
+                
+                    comments = field->fld_data.fld_comments->cm_value;
+                    str = String::stringWithUTF8Characters(comments);
+                    addHeader(MCSTR("Comments"), str);
+                }
+                break;
+            case MAILIMF_FIELD_OPTIONAL_FIELD:
+                char * fieldName;
+                String * fieldNameStr;
+                
+                fieldName = field->fld_data.fld_optional_field->fld_name;
+                fieldNameStr = String::stringWithUTF8Characters(fieldName);
+                if (headerValueForName(fieldNameStr) == NULL) {
+                    char * fieldValue;
+                    String * fieldValueStr;
+                    
+                    fieldValue = field->fld_data.fld_optional_field->fld_value;
+                    fieldValueStr = String::stringWithUTF8Characters(fieldValue);
+                    addHeader(fieldNameStr, fieldValueStr);
+                }
+                break;
+            case MAILIMF_FIELD_KEYWORDS:
+//                TODO: deal with non-string headers in mExtraHeaders
+//                if (headerForName(MCSTR("Keywords")) == NULL) {
+//                    clist * keywords_list;
+//                    Array * keywords;
+//                
+//                    keywords_list = field->fld_data.fld_keywords->kw_list;
+//                    keywords = keyword_to_string_array(keywords_list);
+//                    addHeader(MCSTR("Keywords"), keywords);
+//                }
+//                break;
+            default:
+                break;
+        }
+        cur = clist_next(cur);
+
     
-	/* from */
-	if (single_fields.fld_from != NULL) {
-		struct mailimf_mailbox_list * mb_list;
-		Array * addresses;
-		
-		mb_list = single_fields.fld_from->frm_mb_list;
-		addresses = lep_address_list_from_lep_mailbox(mb_list);
-		if (addresses->count() > 0) {
-			setFrom((Address *) (addresses->objectAtIndex(0)));
-		}
-	}
-	
-	/* replyto */
-	if (single_fields.fld_reply_to != NULL) {
-		struct mailimf_address_list * addr_list;
-		Array * addresses;
-		
-		addr_list = single_fields.fld_reply_to->rt_addr_list;
-		addresses = lep_address_list_from_lep_addr(addr_list);
-        setReplyTo(addresses);
-	}
-	
-	/* to */
-	if (single_fields.fld_to != NULL) {
-		struct mailimf_address_list * addr_list;
-		Array * addresses;
-		
-		addr_list = single_fields.fld_to->to_addr_list;
-		addresses = lep_address_list_from_lep_addr(addr_list);
-        setTo(addresses);
-	}
-	
-	/* cc */
-	if (single_fields.fld_cc != NULL) {
-		struct mailimf_address_list * addr_list;
-		Array * addresses;
-		
-		addr_list = single_fields.fld_cc->cc_addr_list;
-		addresses = lep_address_list_from_lep_addr(addr_list);
-        setCc(addresses);
-	}
-	
-	/* bcc */
-	if (single_fields.fld_bcc != NULL) {
-		struct mailimf_address_list * addr_list;
-		Array * addresses;
-		
-		addr_list = single_fields.fld_bcc->bcc_addr_list;
-		addresses = lep_address_list_from_lep_addr(addr_list);
-        setBcc(addresses);
-	}
-	
-	/* msgid */
-	if (single_fields.fld_message_id != NULL) {
-		char * msgid;
-		String * str;
-        
-		msgid = single_fields.fld_message_id->mid_value;
-        str = String::stringWithUTF8Characters(msgid);
-        setMessageID(str);
-	}
-	
-	/* references */
-	if (single_fields.fld_references != NULL) {
-		clist * msg_id_list;
-		Array * msgids;
-		
-		msg_id_list = single_fields.fld_references->mid_list;
-		msgids = msg_id_to_string_array(msg_id_list);
-        setReferences(msgids);
-	}
-	
-	/* inreplyto */
-	if (single_fields.fld_in_reply_to != NULL) {
-		clist * msg_id_list;
-		Array * msgids;
-		
-		msg_id_list = single_fields.fld_in_reply_to->mid_list;
-		msgids = msg_id_to_string_array(msg_id_list);
-        setInReplyTo(msgids);
-	}
+    }
 }
 
 static time_t timestamp_from_date(struct mailimf_date_time * date_time)
@@ -753,17 +804,27 @@ static struct mailimf_address_list * lep_address_list_from_array(Array * address
 
 static Array * msg_id_to_string_array(clist * msgids)
 {
+    return clist_to_string_array(msgids);
+}
+
+static Array * keyword_to_string_array(clist * keywords)
+{
+    return clist_to_string_array(keywords);
+}
+
+static Array * clist_to_string_array(clist * cstrs)
+{
 	clistiter * cur;
 	Array * result;
 	
 	result = Array::array();
 	
-	for(cur = clist_begin(msgids) ; cur != NULL ; cur = clist_next(cur)) {
-		char * msgid;
+	for(cur = clist_begin(cstrs) ; cur != NULL ; cur = clist_next(cur)) {
+		char * cstr;
 		String * str;
 		
-		msgid = (char *) clist_content(cur);
-		str = String::stringWithUTF8Characters(msgid);
+		cstr = (char *) clist_content(cur);
+		str = String::stringWithUTF8Characters(cstr);
         result->addObject(str);
 	}
 	
diff --git a/src/core/imap/MCIMAPSession.cc b/src/core/imap/MCIMAPSession.cc
index b44efdfd..f2b9ccdc 100644
--- a/src/core/imap/MCIMAPSession.cc
+++ b/src/core/imap/MCIMAPSession.cc
@@ -1722,7 +1722,8 @@ static void msg_att_handler(struct mailimap_msg_att * msg_att, void * context)
                 hasHeader = true;
             }
             else if (att_static->att_type == MAILIMAP_MSG_ATT_BODY_SECTION) {
-                if ((requestKind & IMAPMessagesRequestKindFullHeaders) != 0) {
+                if ((requestKind & IMAPMessagesRequestKindFullHeaders) != 0 ||
+                    (requestKind & IMAPMessagesRequestKindExtraHeaders) != 0) {
                     char * bytes;
                     size_t length;
                     
@@ -1849,7 +1850,7 @@ static void msg_att_handler(struct mailimap_msg_att * msg_att, void * context)
 
 IMAPSyncResult * IMAPSession::fetchMessages(String * folder, IMAPMessagesRequestKind requestKind, bool fetchByUID,
                                             struct mailimap_set * imapset, uint64_t modseq, HashMap * mapping, uint32_t startUid,
-                                            IMAPProgressCallback * progressCallback, ErrorCode * pError)
+                                            IMAPProgressCallback * progressCallback, ErrorCode * pError, Array *extraHeaders)
 {
     struct mailimap_fetch_type * fetch_type;
     clist * fetch_result;
@@ -1986,6 +1987,30 @@ IMAPSyncResult * IMAPSession::fetchMessages(String * folder, IMAPMessagesRequest
 		fetch_att = mailimap_fetch_att_new_internaldate();
         mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
 	}
+    if ((requestKind & IMAPMessagesRequestKindExtraHeaders) != 0) {
+        // custom header request
+        clist * hdrlist;
+        char * header;
+        struct mailimap_header_list * imap_hdrlist;
+        struct mailimap_section * section;
+        
+		MCLog("request extra headers");
+        
+        if (extraHeaders && extraHeaders->count() > 0) {
+            hdrlist = clist_new();
+            for (unsigned int i = 0; i < extraHeaders->count(); i++) {
+                String *headerString = (String *)extraHeaders->objectAtIndex(i);
+                header = strdup(headerString->UTF8Characters());
+                clist_append(hdrlist, header);
+            }
+            
+            imap_hdrlist = mailimap_header_list_new(hdrlist);
+            section = mailimap_section_new_header_fields(imap_hdrlist);
+            fetch_att = mailimap_fetch_att_new_body_peek_section(section);
+            mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att);
+            needsHeader = true;
+        }
+    }
     
     struct msg_att_handler_data msg_att_data;
     
@@ -2086,7 +2111,7 @@ IMAPSyncResult * IMAPSession::fetchMessages(String * folder, IMAPMessagesRequest
                 requestKind = (IMAPMessagesRequestKind) (requestKind | IMAPMessagesRequestKindFullHeaders);
 
                 result = fetchMessages(folder, requestKind, fetchByUID,
-                    imapset, modseq, NULL, startUid, progressCallback, pError);
+                    imapset, modseq, NULL, startUid, progressCallback, pError, extraHeaders);
                 if (result != NULL) {
                     if (result->modifiedOrAddedMessages() != NULL) {
                         if (result->modifiedOrAddedMessages()->count() > 0) {
@@ -2105,11 +2130,12 @@ IMAPSyncResult * IMAPSession::fetchMessages(String * folder, IMAPMessagesRequest
 }
 
 Array * IMAPSession::fetchMessagesByUID(String * folder, IMAPMessagesRequestKind requestKind,
-                                        IndexSet * uids, IMAPProgressCallback * progressCallback, ErrorCode * pError)
+                                        IndexSet * uids, IMAPProgressCallback * progressCallback, ErrorCode * pError,
+                                        Array * extraHeaders)
 {
     struct mailimap_set * imapset = setFromIndexSet(uids);
     IMAPSyncResult * syncResult = fetchMessages(folder, requestKind, true, imapset, 0, NULL, 0,
-                                                progressCallback, pError);
+                                                progressCallback, pError, extraHeaders);
     if (syncResult == NULL)
         return NULL;
     Array * result = syncResult->modifiedOrAddedMessages();
@@ -2119,11 +2145,12 @@ Array * IMAPSession::fetchMessagesByUID(String * folder, IMAPMessagesRequestKind
 }
 
 Array * IMAPSession::fetchMessagesByNumber(String * folder, IMAPMessagesRequestKind requestKind,
-                                           IndexSet * numbers, IMAPProgressCallback * progressCallback, ErrorCode * pError)
+                                           IndexSet * numbers, IMAPProgressCallback * progressCallback, ErrorCode * pError,
+                                           Array * extraHeaders)
 {
     struct mailimap_set * imapset = setFromIndexSet(numbers);
     IMAPSyncResult * syncResult = fetchMessages(folder, requestKind, false, imapset, 0, NULL, 0,
-                                                progressCallback, pError);
+                                                progressCallback, pError, extraHeaders);
     if (syncResult == NULL)
         return NULL;
     Array * result = syncResult->modifiedOrAddedMessages();
@@ -2914,13 +2941,14 @@ uint32_t IMAPSession::firstUnseenUid()
 
 IMAPSyncResult * IMAPSession::syncMessagesByUID(String * folder, IMAPMessagesRequestKind requestKind,
                                                 IndexSet * uids, uint64_t modseq,
-                                                IMAPProgressCallback * progressCallback, ErrorCode * pError)
+                                                IMAPProgressCallback * progressCallback, ErrorCode * pError,
+                                                Array * extraHeaders)
 {
     MCAssert(uids->rangesCount() > 0);
     struct mailimap_set * imapset = setFromIndexSet(uids);
     IMAPSyncResult * result = fetchMessages(folder, requestKind, true, imapset, modseq, NULL,
                                             (uint32_t) uids->allRanges()[0].location,
-                                            progressCallback, pError);
+                                            progressCallback, pError, extraHeaders);
     mailimap_set_free(imapset);
     return result;
 }
diff --git a/src/core/imap/MCIMAPSession.h b/src/core/imap/MCIMAPSession.h
index 09732edd..82abd311 100644
--- a/src/core/imap/MCIMAPSession.h
+++ b/src/core/imap/MCIMAPSession.h
@@ -88,9 +88,11 @@ namespace mailcore {
         virtual void expunge(String * folder, ErrorCode * pError);
         
         virtual Array * /* IMAPMessage */ fetchMessagesByUID(String * folder, IMAPMessagesRequestKind requestKind,
-                                                             IndexSet * uids, IMAPProgressCallback * progressCallback, ErrorCode * pError);
+                                                             IndexSet * uids, IMAPProgressCallback * progressCallback,
+                                                             ErrorCode * pError, Array * extraHeaders = NULL);
         virtual Array * /* IMAPMessage */ fetchMessagesByNumber(String * folder, IMAPMessagesRequestKind requestKind,
-                                                                IndexSet * numbers, IMAPProgressCallback * progressCallback, ErrorCode * pError);
+                                                                IndexSet * numbers, IMAPProgressCallback * progressCallback,
+                                                                ErrorCode * pError,  Array * extraHeaders = NULL);
         
         virtual Data * fetchMessageByUID(String * folder, uint32_t uid,
                                          IMAPProgressCallback * progressCallback, ErrorCode * pError);
@@ -102,7 +104,8 @@ namespace mailcore {
         /* When CONDSTORE or QRESYNC is available */
         virtual IMAPSyncResult * syncMessagesByUID(String * folder, IMAPMessagesRequestKind requestKind,
                                                    IndexSet * uids, uint64_t modseq,
-                                                   IMAPProgressCallback * progressCallback, ErrorCode * pError);
+                                                   IMAPProgressCallback * progressCallback, ErrorCode * pError,
+                                                   Array * extraHeaders = NULL);
         
         virtual void storeFlags(String * folder, IndexSet * uids, IMAPStoreFlagsRequestKind kind, MessageFlag flags, ErrorCode * pError);
         virtual void storeLabels(String * folder, IndexSet * uids, IMAPStoreFlagsRequestKind kind, Array * labels, ErrorCode * pError);
@@ -207,9 +210,10 @@ namespace mailcore {
         void unsetup();
         void selectIfNeeded(String * folder, ErrorCode * pError);
         char fetchDelimiterIfNeeded(char defaultDelimiter, ErrorCode * pError);
-        IMAPSyncResult * fetchMessages(String * folder, IMAPMessagesRequestKind requestKind, bool fetchByUID,
-                                       struct mailimap_set * imapset, uint64_t modseq, HashMap * mapping, uint32_t startUid,
-                                       IMAPProgressCallback * progressCallback, ErrorCode * pError);
+        IMAPSyncResult * fetchMessages(String * folder, IMAPMessagesRequestKind requestKind,
+                                       bool fetchByUID, struct mailimap_set * imapset, uint64_t modseq,
+                                       HashMap * mapping, uint32_t startUid, IMAPProgressCallback * progressCallback,
+                                       ErrorCode * pError,  Array * extraHeaders);
     };
 }