X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fmodules%2Fimap%2Fimap_fetch.c;h=396e6070c6808516cdee483925cec7f8bbad8589;hb=573281fcad13fe840b7f0795ff36be5cfc5b420a;hp=d0afd3207b64d936c831e229b7cf1a5e50056274;hpb=984583756d062536382d78da5ffc70eba9378bfb;p=citadel.git diff --git a/citadel/modules/imap/imap_fetch.c b/citadel/modules/imap/imap_fetch.c index d0afd3207..396e6070c 100644 --- a/citadel/modules/imap/imap_fetch.c +++ b/citadel/modules/imap/imap_fetch.c @@ -1,12 +1,10 @@ /* - * $Id$ - * * Implements the FETCH command in IMAP. * This is a good example of the protocol's gratuitous complexity. * - * Copyright (c) 2001-2009 by the citadel.org team + * Copyright (c) 2001-2011 by the citadel.org team * - * This program is free software; you can redistribute it and/or modify + * This program is open source 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 3 of the License, or * (at your option) any later version. @@ -55,12 +53,11 @@ #include "support.h" #include "config.h" #include "user_ops.h" -#include "policy.h" #include "database.h" #include "msgbase.h" #include "internet_addressing.h" -#include "imap_tools.h" #include "serv_imap.h" +#include "imap_tools.h" #include "imap_fetch.h" #include "genstamp.h" #include "ctdl_module.h" @@ -72,38 +69,44 @@ */ void imap_fetch_uid(int seq) { - cprintf("UID %ld", IMAP->msgids[seq-1]); + IAPrintf("UID %ld", IMAP->msgids[seq-1]); } -void imap_fetch_flags(int seq) { +void imap_fetch_flags(int seq) +{ + citimap *Imap = IMAP; int num_flags_printed = 0; - cprintf("FLAGS ("); - if (IMAP->flags[seq] & IMAP_DELETED) { - if (num_flags_printed > 0) cprintf(" "); - cprintf("\\Deleted"); + IAPuts("FLAGS ("); + if (Imap->flags[seq] & IMAP_DELETED) { + if (num_flags_printed > 0) + IAPuts(" "); + IAPuts("\\Deleted"); ++num_flags_printed; } - if (IMAP->flags[seq] & IMAP_SEEN) { - if (num_flags_printed > 0) cprintf(" "); - cprintf("\\Seen"); + if (Imap->flags[seq] & IMAP_SEEN) { + if (num_flags_printed > 0) + IAPuts(" "); + IAPuts("\\Seen"); ++num_flags_printed; } - if (IMAP->flags[seq] & IMAP_ANSWERED) { - if (num_flags_printed > 0) cprintf(" "); - cprintf("\\Answered"); + if (Imap->flags[seq] & IMAP_ANSWERED) { + if (num_flags_printed > 0) + IAPuts(" "); + IAPuts("\\Answered"); ++num_flags_printed; } - if (IMAP->flags[seq] & IMAP_RECENT) { - if (num_flags_printed > 0) cprintf(" "); - cprintf("\\Recent"); + if (Imap->flags[seq] & IMAP_RECENT) { + if (num_flags_printed > 0) + IAPuts(" "); + IAPuts("\\Recent"); ++num_flags_printed; } - cprintf(")"); + IAPuts(")"); } void imap_fetch_internaldate(struct CtdlMessage *msg) { - char buf[SIZ]; + char datebuf[64]; time_t msgdate; if (!msg) return; @@ -114,8 +117,8 @@ void imap_fetch_internaldate(struct CtdlMessage *msg) { msgdate = time(NULL); } - datestring(buf, sizeof buf, msgdate, DATESTRING_IMAP); - cprintf("INTERNALDATE \"%s\"", buf); + datestring(datebuf, sizeof datebuf, msgdate, DATESTRING_IMAP); + IAPrintf( "INTERNALDATE \"%s\"", datebuf); } @@ -129,7 +132,8 @@ void imap_fetch_internaldate(struct CtdlMessage *msg) { * "RFC822.TEXT" body only (without leading blank line) */ void imap_fetch_rfc822(long msgnum, const char *whichfmt) { - char buf[SIZ]; + CitContext *CCC = CC; + citimap *Imap = CCCIMAP; const char *ptr = NULL; size_t headers_size, text_size, total_size; size_t bytes_to_send = 0; @@ -152,7 +156,7 @@ void imap_fetch_rfc822(long msgnum, const char *whichfmt) { if (!strcasecmp(whichfmt, "RFC822.SIZE")) { GetMetaData(&smi, msgnum); if (smi.meta_rfc822_length > 0L) { - cprintf("RFC822.SIZE %ld", smi.meta_rfc822_length); + IAPrintf("RFC822.SIZE %ld", smi.meta_rfc822_length); return; } need_to_rewrite_metadata = 1; @@ -165,38 +169,37 @@ void imap_fetch_rfc822(long msgnum, const char *whichfmt) { * client requests something that involves reading the message * body, but we haven't fetched the body yet. */ - if ((IMAP->cached_rfc822_data != NULL) - && (IMAP->cached_rfc822_msgnum == msgnum) - && (IMAP->cached_rfc822_withbody || (!need_body)) ) { + if ((Imap->cached_rfc822 != NULL) + && (Imap->cached_rfc822_msgnum == msgnum) + && (Imap->cached_rfc822_withbody || (!need_body)) ) { /* Good to go! */ } - else if (IMAP->cached_rfc822_data != NULL) { + else if (Imap->cached_rfc822 != NULL) { /* Some other message is cached -- free it */ - free(IMAP->cached_rfc822_data); - IMAP->cached_rfc822_data = NULL; - IMAP->cached_rfc822_msgnum = (-1); - IMAP->cached_rfc822_len = 0; + FreeStrBuf(&Imap->cached_rfc822); + Imap->cached_rfc822_msgnum = (-1); } /* At this point, we now can fetch and convert the message iff it's not * the one we had cached. */ - if (IMAP->cached_rfc822_data == NULL) { + if (Imap->cached_rfc822 == NULL) { /* * Load the message into memory for translation & measurement */ - CC->redirect_buffer = NewStrBufPlain(NULL, SIZ); + CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ); CtdlOutputMsg(msgnum, MT_RFC822, (need_body ? HEADERS_ALL : HEADERS_FAST), - 0, 1, NULL, SUPPRESS_ENV_TO + 0, 1, NULL, SUPPRESS_ENV_TO, NULL, NULL ); - if (!need_body) cprintf("\r\n"); /* extra trailing newline */ - IMAP->cached_rfc822_len = StrLength(CC->redirect_buffer); - IMAP->cached_rfc822_data = SmashStrBuf(&CC->redirect_buffer); - IMAP->cached_rfc822_msgnum = msgnum; - IMAP->cached_rfc822_withbody = need_body; - if ( (need_to_rewrite_metadata) && (IMAP->cached_rfc822_len > 0) ) { - smi.meta_rfc822_length = (long)IMAP->cached_rfc822_len; + if (!need_body) IAPuts("\r\n"); /* extra trailing newline */ + Imap->cached_rfc822 = CCC->redirect_buffer; + CCC->redirect_buffer = NULL; + Imap->cached_rfc822_msgnum = msgnum; + Imap->cached_rfc822_withbody = need_body; + if ( (need_to_rewrite_metadata) && + (StrLength(Imap->cached_rfc822) > 0) ) { + smi.meta_rfc822_length = StrLength(Imap->cached_rfc822); PutMetaData(&smi); } } @@ -206,58 +209,63 @@ void imap_fetch_rfc822(long msgnum, const char *whichfmt) { * intervening blank line to be part of the headers, not the text. */ headers_size = 0; - text_size = 0; - total_size = 0; if (need_body) { - ptr = IMAP->cached_rfc822_data; + StrBuf *Line = NewStrBuf(); + ptr = NULL; do { - ptr = memreadline(ptr, buf, sizeof buf); - if (*ptr != 0) { - striplt(buf); - if (IsEmptyStr(buf)) { - headers_size = ptr - IMAP->cached_rfc822_data; + StrBufSipLine(Line, Imap->cached_rfc822, &ptr); + + if ((StrLength(Line) != 0) && (ptr != StrBufNOTNULL)) + { + StrBufTrim(Line); + if ((StrLength(Line) != 0) && + (ptr != StrBufNOTNULL) ) + { + headers_size = ptr - ChrPtr(Imap->cached_rfc822); } } - } while ( (headers_size == 0) && (*ptr != 0) ); + } while ( (headers_size == 0) && + (ptr != StrBufNOTNULL) ); - total_size = IMAP->cached_rfc822_len; + total_size = StrLength(Imap->cached_rfc822); text_size = total_size - headers_size; + FreeStrBuf(&Line); } else { - headers_size = IMAP->cached_rfc822_len; - total_size = IMAP->cached_rfc822_len; + headers_size = + total_size = StrLength(Imap->cached_rfc822); text_size = 0; } - CtdlLogPrintf(CTDL_DEBUG, - "RFC822: headers=" SIZE_T_FMT - ", text=" SIZE_T_FMT - ", total=" SIZE_T_FMT "\n", - headers_size, text_size, total_size); + IMAP_syslog(LOG_DEBUG, + "RFC822: headers=" SIZE_T_FMT + ", text=" SIZE_T_FMT + ", total=" SIZE_T_FMT, + headers_size, text_size, total_size); if (!strcasecmp(whichfmt, "RFC822.SIZE")) { - cprintf("RFC822.SIZE " SIZE_T_FMT, total_size); + IAPrintf("RFC822.SIZE " SIZE_T_FMT, total_size); return; } else if (!strcasecmp(whichfmt, "RFC822")) { - ptr = IMAP->cached_rfc822_data; + ptr = ChrPtr(Imap->cached_rfc822); bytes_to_send = total_size; } else if (!strcasecmp(whichfmt, "RFC822.HEADER")) { - ptr = IMAP->cached_rfc822_data; + ptr = ChrPtr(Imap->cached_rfc822); bytes_to_send = headers_size; } else if (!strcasecmp(whichfmt, "RFC822.TEXT")) { - ptr = &IMAP->cached_rfc822_data[headers_size]; + ptr = &ChrPtr(Imap->cached_rfc822)[headers_size]; bytes_to_send = text_size; } - cprintf("%s {" SIZE_T_FMT "}\r\n", whichfmt, bytes_to_send); - client_write(ptr, bytes_to_send); + IAPrintf("%s {" SIZE_T_FMT "}\r\n", whichfmt, bytes_to_send); + iaputs(ptr, bytes_to_send); } @@ -274,38 +282,54 @@ void imap_load_part(char *name, char *filename, char *partnum, char *disp, void *content, char *cbtype, char *cbcharset, size_t length, char *encoding, char *cbid, void *cbuserdata) { - char mbuf2[SIZ]; - char *desired_section; - - desired_section = (char *)cbuserdata; + struct CitContext *CCC = CC; + char mimebuf2[SIZ]; + StrBuf *desired_section; + + desired_section = (StrBuf *)cbuserdata; + IMAP_syslog(LOG_DEBUG, "imap_load_part() looking for %s, found %s", + ChrPtr(desired_section), + partnum + ); - if (!strcasecmp(partnum, desired_section)) { + if (!strcasecmp(partnum, ChrPtr(desired_section))) { client_write(content, length); } - snprintf(mbuf2, sizeof mbuf2, "%s.MIME", partnum); + snprintf(mimebuf2, sizeof mimebuf2, "%s.MIME", partnum); - if (!strcasecmp(desired_section, mbuf2)) { - cprintf("Content-type: %s", cbtype); - if (!IsEmptyStr(cbcharset)) - cprintf("; charset=\"%s\"", cbcharset); - if (!IsEmptyStr(name)) - cprintf("; name=\"%s\"", name); - cprintf("\r\n"); - if (!IsEmptyStr(encoding)) - cprintf("Content-Transfer-Encoding: %s\r\n", encoding); + if (!strcasecmp(ChrPtr(desired_section), mimebuf2)) { + client_write(HKEY("Content-type: ")); + client_write(cbtype, strlen(cbtype)); + if (!IsEmptyStr(cbcharset)) { + client_write(HKEY("; charset=\"")); + client_write(cbcharset, strlen(cbcharset)); + client_write(HKEY("\"")); + } + if (!IsEmptyStr(name)) { + client_write(HKEY("; name=\"")); + client_write(name, strlen(name)); + client_write(HKEY("\"")); + } + client_write(HKEY("\r\n")); + if (!IsEmptyStr(encoding)) { + client_write(HKEY("Content-Transfer-Encoding: ")); + client_write(encoding, strlen(encoding)); + client_write(HKEY("\r\n")); + } if (!IsEmptyStr(encoding)) { - cprintf("Content-Disposition: %s", disp); + client_write(HKEY("Content-Disposition: ")); + client_write(disp, strlen(disp)); + if (!IsEmptyStr(filename)) { - cprintf("; filename=\"%s\"", filename); + client_write(HKEY("; filename=\"")); + client_write(filename, strlen(filename)); + client_write(HKEY("\"")); } - cprintf("\r\n"); + client_write(HKEY("\r\n")); } - cprintf("Content-Length: %ld\r\n", (long)length); - cprintf("\r\n"); + cprintf("Content-Length: %ld\r\n\r\n", (long)length); } - - } @@ -321,24 +345,24 @@ void imap_output_envelope_from(struct CtdlMessage *msg) { /* For anonymous messages, it's so easy! */ if (!is_room_aide() && (msg->cm_anon_type == MES_ANONONLY)) { - cprintf("((\"----\" NIL \"x\" \"x.org\")) "); + IAPuts("((\"----\" NIL \"x\" \"x.org\")) "); return; } if (!is_room_aide() && (msg->cm_anon_type == MES_ANONOPT)) { - cprintf("((\"anonymous\" NIL \"x\" \"x.org\")) "); + IAPuts("((\"anonymous\" NIL \"x\" \"x.org\")) "); return; } /* For everything else, we do stuff. */ - cprintf("(("); /* open double-parens */ + IAPuts("(("); /* open double-parens */ plain_imap_strout(msg->cm_fields['A']); /* personal name */ - cprintf(" NIL "); /* source route (not used) */ + IAPuts(" NIL "); /* source route (not used) */ if (msg->cm_fields['F'] != NULL) { process_rfc822_addr(msg->cm_fields['F'], user, node, name); plain_imap_strout(user); /* mailbox name (user id) */ - cprintf(" "); + IAPuts(" "); if (!strcasecmp(node, config.c_nodename)) { plain_imap_strout(config.c_fqdn); } @@ -348,11 +372,11 @@ void imap_output_envelope_from(struct CtdlMessage *msg) { } else { plain_imap_strout(msg->cm_fields['A']); /* mailbox name (user id) */ - cprintf(" "); + IAPuts(" "); plain_imap_strout(msg->cm_fields['N']); /* host name */ } - cprintf(")) "); /* close double-parens */ + IAPuts(")) "); /* close double-parens */ } @@ -372,16 +396,16 @@ void imap_output_envelope_addr(char *addr) { char name[256]; if (addr == NULL) { - cprintf("NIL "); + IAPuts("NIL "); return; } if (IsEmptyStr(addr)) { - cprintf("NIL "); + IAPuts("NIL "); return; } - cprintf("("); + IAPuts("("); /* How many addresses are listed here? */ num_addrs = num_tokens(addr, ','); @@ -391,17 +415,18 @@ void imap_output_envelope_addr(char *addr) { extract_token(individual_addr, addr, i, ',', sizeof individual_addr); striplt(individual_addr); process_rfc822_addr(individual_addr, user, node, name); - cprintf("("); + IAPuts("("); plain_imap_strout(name); - cprintf(" NIL "); + IAPuts(" NIL "); plain_imap_strout(user); - cprintf(" "); + IAPuts(" "); plain_imap_strout(node); - cprintf(")"); - if (i < (num_addrs-1)) cprintf(" "); + IAPuts(")"); + if (i < (num_addrs-1)) + IAPuts(" "); } - cprintf(") "); + IAPuts(") "); } @@ -415,6 +440,7 @@ void imap_fetch_envelope(struct CtdlMessage *msg) { char datestringbuf[SIZ]; time_t msgdate; char *fieldptr = NULL; + long len; if (!msg) return; @@ -433,15 +459,15 @@ void imap_fetch_envelope(struct CtdlMessage *msg) { * be output as NIL, existent fields must be quoted or literalled. * The imap_strout() function conveniently does all this for us. */ - cprintf("ENVELOPE ("); + IAPuts("ENVELOPE ("); /* Date */ plain_imap_strout(datestringbuf); - cprintf(" "); + IAPuts(" "); /* Subject */ plain_imap_strout(msg->cm_fields['U']); - cprintf(" "); + IAPuts(" "); /* From */ imap_output_envelope_from(msg); @@ -488,13 +514,41 @@ void imap_fetch_envelope(struct CtdlMessage *msg) { /* In-reply-to */ fieldptr = rfc822_fetch_field(msg->cm_fields['M'], "In-reply-to"); plain_imap_strout(fieldptr); - cprintf(" "); + IAPuts(" "); if (fieldptr != NULL) free(fieldptr); /* message ID */ - plain_imap_strout(msg->cm_fields['I']); - - cprintf(")"); + len = strlen(msg->cm_fields['I']); + + if ((len == 0) || ( + (msg->cm_fields['I'][0] == '<') && + (msg->cm_fields['I'][len - 1] == '>')) + ) + { + plain_imap_strout(msg->cm_fields['I']); + } + else + { + char *Buf = malloc(len + 3); + long pos = 0; + + if (msg->cm_fields['I'][0] != '<') + { + Buf[pos] = '<'; + pos ++; + } + memcpy(&Buf[pos], msg->cm_fields['I'], len); + pos += len; + if (msg->cm_fields['I'][len] != '>') + { + Buf[pos] = '>'; + pos++; + } + Buf[pos] = '\0'; + IPutStr(Buf, pos); + free(Buf); + } + IAPuts(")"); } /* @@ -504,7 +558,6 @@ void imap_fetch_envelope(struct CtdlMessage *msg) { */ void imap_strip_headers(StrBuf *section) { citimap_command Cmd; - char buf[SIZ]; StrBuf *which_fields = NULL; int doing_headers = 0; int headers_not = 0; @@ -515,14 +568,16 @@ void imap_strip_headers(StrBuf *section) { int ok = 0; int done_headers = 0; const char *Ptr = NULL; + CitContext *CCC = CC; - if (CC->redirect_buffer == NULL) return; + if (CCC->redirect_buffer == NULL) return; which_fields = NewStrBufDup(section); if (!strncasecmp(ChrPtr(which_fields), "HEADER.FIELDS", 13)) doing_headers = 1; - if (!strncasecmp(ChrPtr(which_fields), "HEADER.FIELDS.NOT", 17)) + if (doing_headers && + !strncasecmp(ChrPtr(which_fields), "HEADER.FIELDS.NOT", 17)) headers_not = 1; for (i=0; i < StrLength(which_fields); ++i) { @@ -539,25 +594,33 @@ void imap_strip_headers(StrBuf *section) { Cmd.CmdBuf = which_fields; num_parms = imap_parameterize(&Cmd); - boiled_headers = NewStrBufPlain(NULL, StrLength(CC->redirect_buffer)); + boiled_headers = NewStrBufPlain(NULL, StrLength(CCC->redirect_buffer)); + Line = NewStrBufPlain(NULL, SIZ); Ptr = NULL; ok = 0; do { - StrBufSipLine(CC->redirect_buffer, Line, &Ptr); + StrBufSipLine(Line, CCC->redirect_buffer, &Ptr); if (!isspace(ChrPtr(Line)[0])) { - ok = 0; + if (doing_headers == 0) ok = 1; else { - if (headers_not) ok = 1; - else ok = 0; - for (i=0; iredirect_buffer); - CC->redirect_buffer = boiled_headers; + FreeStrBuf(&CCC->redirect_buffer); + CCC->redirect_buffer = boiled_headers; + free(Cmd.Params); FreeStrBuf(&which_fields); FreeStrBuf(&Line); } @@ -591,12 +655,14 @@ void imap_strip_headers(StrBuf *section) { void imap_fetch_body(long msgnum, ConstStr item, int is_peek) { struct CtdlMessage *msg = NULL; StrBuf *section; - char partial[SIZ]; + StrBuf *partial; int is_partial = 0; size_t pstart, pbytes; int loading_body_now = 0; int need_body = 1; int burn_the_cache = 0; + CitContext *CCC = CC; + citimap *Imap = CCCIMAP; /* extract section */ section = NewStrBufPlain(CKEY(item)); @@ -604,45 +670,45 @@ void imap_fetch_body(long msgnum, ConstStr item, int is_peek) { if (strchr(ChrPtr(section), '[') != NULL) { StrBufStripAllBut(section, '[', ']'); } - CtdlLogPrintf(CTDL_DEBUG, "Section is: %s%s\n", - ChrPtr(section), - (StrLength(section) == 0) ? "(empty)" : "" + IMAP_syslog(LOG_DEBUG, "Section is: [%s]", + (StrLength(section) == 0) ? "(empty)" : ChrPtr(section) ); /* Burn the cache if we don't have the same section of the * same message again. */ - if (IMAP->cached_body != NULL) { - if (IMAP->cached_bodymsgnum != msgnum) { + if (Imap->cached_body != NULL) { + if (Imap->cached_bodymsgnum != msgnum) { burn_the_cache = 1; } - else if ( (!IMAP->cached_body_withbody) && (need_body) ) { + else if ( (!Imap->cached_body_withbody) && (need_body) ) { burn_the_cache = 1; } - else if (strcasecmp(IMAP->cached_bodypart, ChrPtr(section))) { + else if (strcasecmp(Imap->cached_bodypart, ChrPtr(section))) { burn_the_cache = 1; } if (burn_the_cache) { /* Yup, go ahead and burn the cache. */ - free(IMAP->cached_body); - IMAP->cached_body_len = 0; - IMAP->cached_body = NULL; - IMAP->cached_bodymsgnum = (-1); - strcpy(IMAP->cached_bodypart, ""); + free(Imap->cached_body); + Imap->cached_body_len = 0; + Imap->cached_body = NULL; + Imap->cached_bodymsgnum = (-1); + strcpy(Imap->cached_bodypart, ""); } } /* extract partial */ - safestrncpy(partial, item.Key, sizeof partial); - if (strchr(partial, '<') != NULL) { - stripallbut(partial, '<', '>'); + partial = NewStrBufPlain(CKEY(item)); + if (strchr(ChrPtr(partial), '<') != NULL) { + StrBufStripAllBut(partial, '<', '>'); is_partial = 1; } - if (is_partial == 0) strcpy(partial, ""); - /* if (!IsEmptyStr(partial)) CtdlLogPrintf(CTDL_DEBUG, "Partial is %s\n", partial); */ + if ( (is_partial == 1) && (StrLength(partial) > 0) ) { + IMAP_syslog(LOG_DEBUG, "Partial is <%s>", ChrPtr(partial)); + } - if (IMAP->cached_body == NULL) { - CC->redirect_buffer = NewStrBufPlain(NULL, SIZ); + if (Imap->cached_body == NULL) { + CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ); loading_body_now = 1; msg = CtdlFetchMessage(msgnum, (need_body ? 1 : 0)); } @@ -687,34 +753,41 @@ void imap_fetch_body(long msgnum, ConstStr item, int is_peek) { */ else { mime_parser(msg->cm_fields['M'], NULL, - *imap_load_part, NULL, NULL, - section, - 1); + *imap_load_part, NULL, NULL, + section, + 1 + ); } if (loading_body_now) { - IMAP->cached_body_len = StrLength(CC->redirect_buffer); - IMAP->cached_body = SmashStrBuf(&CC->redirect_buffer); - IMAP->cached_bodymsgnum = msgnum; - IMAP->cached_body_withbody = need_body; - strcpy(IMAP->cached_bodypart, ChrPtr(section)); + Imap->cached_body_len = StrLength(CCC->redirect_buffer); + Imap->cached_body = SmashStrBuf(&CCC->redirect_buffer); + Imap->cached_bodymsgnum = msgnum; + Imap->cached_body_withbody = need_body; + strcpy(Imap->cached_bodypart, ChrPtr(section)); } if (is_partial == 0) { - cprintf("BODY[%s] {" SIZE_T_FMT "}\r\n", ChrPtr(section), IMAP->cached_body_len); + IAPuts("BODY["); + iaputs(SKEY(section)); + IAPrintf("] {" SIZE_T_FMT "}\r\n", Imap->cached_body_len); pstart = 0; - pbytes = IMAP->cached_body_len; + pbytes = Imap->cached_body_len; } else { - sscanf(partial, SIZE_T_FMT "." SIZE_T_FMT, &pstart, &pbytes); - if (pbytes > (IMAP->cached_body_len - pstart)) { - pbytes = IMAP->cached_body_len - pstart; + sscanf(ChrPtr(partial), SIZE_T_FMT "." SIZE_T_FMT, &pstart, &pbytes); + if (pbytes > (Imap->cached_body_len - pstart)) { + pbytes = Imap->cached_body_len - pstart; } - cprintf("BODY[%s]<" SIZE_T_FMT "> {" SIZE_T_FMT "}\r\n", ChrPtr(section), pstart, pbytes); + IAPuts("BODY["); + iaputs(SKEY(section)); + IAPrintf("]<" SIZE_T_FMT "> {" SIZE_T_FMT "}\r\n", pstart, pbytes); } + FreeStrBuf(&partial); + /* Here we go -- output it */ - client_write(&IMAP->cached_body[pstart], pbytes); + iaputs(&Imap->cached_body[pstart], pbytes); if (msg != NULL) { CtdlFreeMessage(msg); @@ -724,6 +797,7 @@ void imap_fetch_body(long msgnum, ConstStr item, int is_peek) { if (is_peek == 0) { CtdlSetSeen(&msgnum, 1, 1, ctdlsetseen_seen, NULL, NULL); } + FreeStrBuf(§ion); } /* @@ -735,7 +809,7 @@ void imap_fetch_bodystructure_pre( char *cbid, void *cbuserdata ) { - cprintf("("); + IAPuts("("); } @@ -751,16 +825,16 @@ void imap_fetch_bodystructure_post( char subtype[128]; - cprintf(" "); + IAPuts(" "); /* disposition */ extract_token(subtype, cbtype, 1, '/', sizeof subtype); plain_imap_strout(subtype); /* body language */ - /* cprintf(" NIL"); We thought we needed this at one point, but maybe we don't... */ + /* IAPuts(" NIL"); We thought we needed this at one point, but maybe we don't... */ - cprintf(")"); + IAPuts(")"); } @@ -792,25 +866,25 @@ void imap_fetch_bodystructure_part( strcpy(cbsubtype, "PLAIN"); } - cprintf("("); + IAPuts("("); plain_imap_strout(cbmaintype); /* body type */ - cprintf(" "); + IAPuts(" "); plain_imap_strout(cbsubtype); /* body subtype */ - cprintf(" "); + IAPuts(" "); - cprintf("("); /* begin body parameter list */ + IAPuts("("); /* begin body parameter list */ /* "NAME" must appear as the first parameter. This is not required by IMAP, * but the Asterisk voicemail application blindly assumes that NAME will be in * the first position. If it isn't, it rejects the message. */ if (name != NULL) if (!IsEmptyStr(name)) { - cprintf("\"NAME\" "); + IAPuts("\"NAME\" "); plain_imap_strout(name); - cprintf(" "); + IAPuts(" "); } - cprintf("\"CHARSET\" "); + IAPuts("\"CHARSET\" "); if (cbcharset == NULL) { plain_imap_strout("US-ASCII"); } @@ -820,10 +894,10 @@ void imap_fetch_bodystructure_part( else { plain_imap_strout(cbcharset); } - cprintf(") "); /* end body parameter list */ + IAPuts(") "); /* end body parameter list */ - cprintf("NIL "); /* Body ID */ - cprintf("NIL "); /* Body description */ + IAPuts("NIL "); /* Body ID */ + IAPuts("NIL "); /* Body description */ if (encoding != NULL) if (encoding[0] != 0) have_encoding = 1; if (have_encoding) { @@ -832,10 +906,10 @@ void imap_fetch_bodystructure_part( else { plain_imap_strout("7BIT"); } - cprintf(" "); + IAPuts(" "); /* The next field is the size of the part in bytes. */ - cprintf("%ld ", (long)length); /* bytes */ + IAPrintf("%ld ", (long)length); /* bytes */ /* The next field is the number of lines in the part, if and only * if the part is TEXT. More gratuitous complexity. @@ -844,7 +918,7 @@ void imap_fetch_bodystructure_part( if (length) for (i=0; icm_fields['M'], NULL, *imap_fetch_bodystructure_part, /* part */ @@ -969,7 +1044,7 @@ void imap_do_fetch_msg(int seq, citimap_command *Cmd) { if (Imap->msgids[seq-1] < 1L) return; buffer_output(); - cprintf("* %d FETCH (", seq); + IAPrintf("* %d FETCH (", seq); for (i=0; inum_parms; ++i) { @@ -1034,10 +1109,10 @@ void imap_do_fetch_msg(int seq, citimap_command *Cmd) { imap_fetch_internaldate(msg); } - if (i != Cmd->num_parms-1) cprintf(" "); + if (i != Cmd->num_parms-1) IAPuts(" "); } - cprintf(")\r\n"); + IAPuts(")\r\n"); unbuffer_output(); if (msg != NULL) { CtdlFreeMessage(msg); @@ -1051,30 +1126,30 @@ void imap_do_fetch_msg(int seq, citimap_command *Cmd) { * validated and boiled down the request a bit. */ void imap_do_fetch(citimap_command *Cmd) { + citimap *Imap = IMAP; int i; #if 0 /* debug output the parsed vector */ { int i; - CtdlLogPrintf(CTDL_DEBUG, "----- %ld params \n", - Cmd->num_parms); + IMAP_syslog(LOG_DEBUG, "----- %ld params", Cmd->num_parms); for (i=0; i < Cmd->num_parms; i++) { if (Cmd->Params[i].len != strlen(Cmd->Params[i].Key)) - CtdlLogPrintf(CTDL_DEBUG, "*********** %ld != %ld : %s\n", - Cmd->Params[i].len, - strlen(Cmd->Params[i].Key), - Cmd->Params[i].Key); + IMAP_syslog(LOG_DEBUG, "*********** %ld != %ld : %s", + Cmd->Params[i].len, + strlen(Cmd->Params[i].Key), + Cmd->Params[i].Key); else - CtdlLogPrintf(CTDL_DEBUG, "%ld : %s\n", - Cmd->Params[i].len, - Cmd->Params[i].Key); + IMAP_syslog(LOG_DEBUG, "%ld : %s", + Cmd->Params[i].len, + Cmd->Params[i].Key); }} #endif - if (IMAP->num_msgs > 0) { - for (i = 0; i < IMAP->num_msgs; ++i) { + if (Imap->num_msgs > 0) { + for (i = 0; i < Imap->num_msgs; ++i) { /* Abort the fetch loop if the session breaks. * This is important for users who keep mailboxes @@ -1084,7 +1159,7 @@ void imap_do_fetch(citimap_command *Cmd) { if (CC->kill_me) return; /* Get any message marked for fetch. */ - if (IMAP->flags[i] & IMAP_SELECTED) { + if (Imap->flags[i] & IMAP_SELECTED) { imap_do_fetch_msg(i+1, Cmd); } } @@ -1182,7 +1257,6 @@ int imap_extract_data_items(citimap_command *Cmd) int nArgs; int nest = 0; const char *pch, *end; - long initial_len; /* Convert all whitespace to ordinary space characters. */ pch = ChrPtr(Cmd->CmdBuf); @@ -1217,7 +1291,6 @@ int imap_extract_data_items(citimap_command *Cmd) */ nArgs = StrLength(Cmd->CmdBuf) / 10 + 10; nArgs = CmdAdjust(Cmd, nArgs, 0); - initial_len = StrLength(Cmd->CmdBuf); Cmd->num_parms = 0; Cmd->Params[Cmd->num_parms].Key = pch = ChrPtr(Cmd->CmdBuf); end = Cmd->Params[Cmd->num_parms].Key + StrLength(Cmd->CmdBuf); @@ -1276,13 +1349,13 @@ int imap_extract_data_items(citimap_command *Cmd) * Set is_uid to 1 to fetch by UID instead of sequence number. */ void imap_pick_range(const char *supplied_range, int is_uid) { + citimap *Imap = IMAP; int i; int num_sets; int s; char setstr[SIZ], lostr[SIZ], histr[SIZ]; long lo, hi; char actual_range[SIZ]; - citimap *Imap; /* * Handle the "ALL" macro @@ -1294,7 +1367,6 @@ void imap_pick_range(const char *supplied_range, int is_uid) { safestrncpy(actual_range, supplied_range, sizeof actual_range); } - Imap = IMAP; /* * Clear out the IMAP_SELECTED flags for all messages. */ @@ -1347,7 +1419,7 @@ void imap_fetch(int num_parms, ConstStr *Params) { int num_items; if (num_parms < 4) { - cprintf("%s BAD invalid parameters\r\n", Params[0].Key); + IReply("BAD invalid parameters"); return; } @@ -1359,14 +1431,14 @@ void imap_fetch(int num_parms, ConstStr *Params) { num_items = imap_extract_data_items(&Cmd); if (num_items < 1) { - cprintf("%s BAD invalid data item list\r\n", Params[0].Key); + IReply("BAD invalid data item list"); FreeStrBuf(&Cmd.CmdBuf); free(Cmd.Params); return; } imap_do_fetch(&Cmd); - cprintf("%s OK FETCH completed\r\n", Params[0].Key); + IReply("OK FETCH completed"); FreeStrBuf(&Cmd.CmdBuf); free(Cmd.Params); } @@ -1381,7 +1453,7 @@ void imap_uidfetch(int num_parms, ConstStr *Params) { int have_uid_item = 0; if (num_parms < 5) { - cprintf("%s BAD invalid parameters\r\n", Params[0].Key); + IReply("BAD invalid parameters"); return; } @@ -1392,11 +1464,11 @@ void imap_uidfetch(int num_parms, ConstStr *Params) { MakeStringOf(Cmd.CmdBuf, 4); #if 0 - CtdlLogPrintf(CTDL_DEBUG, "-------%s--------\n", ChrPtr(Cmd.CmdBuf)); + IMAP_syslog(LOG_DEBUG, "-------%s--------", ChrPtr(Cmd.CmdBuf)); #endif num_items = imap_extract_data_items(&Cmd); if (num_items < 1) { - cprintf("%s BAD invalid data item list\r\n", Params[0].Key); + IReply("BAD invalid data item list"); FreeStrBuf(&Cmd.CmdBuf); free(Cmd.Params); return; @@ -1420,7 +1492,7 @@ void imap_uidfetch(int num_parms, ConstStr *Params) { } imap_do_fetch(&Cmd); - cprintf("%s OK UID FETCH completed\r\n", Params[0].Key); + IReply("OK UID FETCH completed"); FreeStrBuf(&Cmd.CmdBuf); free(Cmd.Params); }