*
*/
-#ifdef DLL_EXPORT
-#define IN_LIBCIT
-#endif
-
#include "sysdep.h"
#include <stdlib.h>
#include <unistd.h>
#include "serv_fulltext.h"
#include "vcard.h"
#include "euidindex.h"
+#include "journaling.h"
long config_msgnum;
struct addresses_to_be_filed *atbf = NULL;
NULL,
"hnod",
"msgn",
- NULL, NULL, NULL,
+ "jrnl",
+ NULL, NULL,
"text",
"node",
"room",
striplt(name);
remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
+ stripallbut(name, '<', '>');
fp = fopen(
#ifndef HAVE_ETG_DIR
FILE *fp;
fp = fopen(
-#ifndef HAVE_RUN_DIR
+#ifndef HAVE_DATA_DIR
"."
#else
- RUN_DIR
+ DATA_DIR
#endif
"/citadel.control", "r");
if (fp == NULL) {
struct CtdlMessage *msg;
msg = CtdlFetchMessage(msgnum, 0);
- if (msg < 0L) {
+ if (msg == NULL) {
cprintf("%ld|0|||||\n", msgnum);
return;
}
/* Load the message list */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = malloc(cdbfr->len);
- memcpy(msglist, cdbfr->ptr, cdbfr->len);
+ msglist = (long *) cdbfr->ptr;
+ cdbfr->ptr = NULL; /* CtdlSetSeen() now owns this memory */
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
} else {
/* Load the message list */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = malloc(cdbfr->len);
- memcpy(msglist, cdbfr->ptr, cdbfr->len);
+ msglist = (long *) cdbfr->ptr;
+ cdbfr->ptr = NULL; /* CtdlForEachMessage() now owns this memory */
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
} else {
if (!strcasecmp(cbtype, "multipart/alternative")) {
++ma->is_ma;
ma->did_print = 0;
- return;
+ }
+ if (!strcasecmp(cbtype, "message/rfc822")) {
+ ++ma->freeze;
}
}
* Post callback function for multipart/alternative
*/
void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
- void *cbuserdata)
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
{
struct ma_info *ma;
if (!strcasecmp(cbtype, "multipart/alternative")) {
--ma->is_ma;
ma->did_print = 0;
- return;
+ }
+ if (!strcasecmp(cbtype, "message/rfc822")) {
+ --ma->freeze;
}
}
* Inline callback function for mime parser that wants to display text
*/
void fixed_output(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
- void *cbuserdata)
- {
- char *ptr;
- char *wptr;
- size_t wlen;
- struct ma_info *ma;
-
- ma = (struct ma_info *)cbuserdata;
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
+{
+ char *ptr;
+ char *wptr;
+ size_t wlen;
+ struct ma_info *ma;
- lprintf(CTDL_DEBUG, "fixed_output() type=<%s>\n", cbtype);
+ ma = (struct ma_info *)cbuserdata;
- /*
- * If we're in the middle of a multipart/alternative scope and
- * we've already printed another section, skip this one.
- */
- if ( (ma->is_ma == 1) && (ma->did_print == 1) ) {
- lprintf(CTDL_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
- return;
- }
- ma->did_print = 1;
-
- if ( (!strcasecmp(cbtype, "text/plain"))
- || (strlen(cbtype)==0) ) {
- wptr = content;
- if (length > 0) {
- client_write(wptr, length);
- if (wptr[length-1] != '\n') {
- cprintf("\n");
- }
- }
- }
- else if (!strcasecmp(cbtype, "text/html")) {
- ptr = html_to_ascii(content, 80, 0);
- wlen = strlen(ptr);
- client_write(ptr, wlen);
- if (ptr[wlen-1] != '\n') {
+ lprintf(CTDL_DEBUG,
+ "fixed_output() part %s: %s (%s) (%ld bytes)\n",
+ partnum, filename, cbtype, (long)length);
+
+ /*
+ * If we're in the middle of a multipart/alternative scope and
+ * we've already printed another section, skip this one.
+ */
+ if ( (ma->is_ma) && (ma->did_print) ) {
+ lprintf(CTDL_DEBUG, "Skipping part %s (%s)\n",
+ partnum, cbtype);
+ return;
+ }
+ ma->did_print = 1;
+
+ if ( (!strcasecmp(cbtype, "text/plain"))
+ || (strlen(cbtype)==0) ) {
+ wptr = content;
+ if (length > 0) {
+ client_write(wptr, length);
+ if (wptr[length-1] != '\n') {
cprintf("\n");
}
- free(ptr);
}
- else if (strncasecmp(cbtype, "multipart/", 10)) {
- cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
- partnum, filename, cbtype, (long)length);
+ }
+ else if (!strcasecmp(cbtype, "text/html")) {
+ ptr = html_to_ascii(content, length, 80, 0);
+ wlen = strlen(ptr);
+ client_write(ptr, wlen);
+ if (ptr[wlen-1] != '\n') {
+ cprintf("\n");
}
+ free(ptr);
+ }
+ else if (PerformFixedOutputHooks(cbtype, content, length)) {
+ /* above function returns nonzero if it handled the part */
+ }
+ else if (strncasecmp(cbtype, "multipart/", 10)) {
+ cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
+ partnum, filename, cbtype, (long)length);
}
+}
/*
* The client is elegant and sophisticated and wants to be choosy about
* we're going to send.
*/
void choose_preferred(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
- void *cbuserdata)
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
{
char buf[1024];
int i;
if (ma->is_ma > 0) {
for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
- if (!strcasecmp(buf, cbtype)) {
- strcpy(ma->chosen_part, partnum);
+ if ( (!strcasecmp(buf, cbtype)) && (!ma->freeze) ) {
+ safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
}
}
}
* Now that we've chosen our preferred part, output it.
*/
void output_preferred(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
- void *cbuserdata)
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
{
int i;
char buf[128];
}
+struct encapmsg {
+ char desired_section[64];
+ char *msg;
+ size_t msglen;
+};
+
+
+/*
+ * Callback function for
+ */
+void extract_encapsulated_message(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
+{
+ struct encapmsg *encap;
+
+ encap = (struct encapmsg *)cbuserdata;
+
+ /* Only proceed if this is the desired section... */
+ if (!strcasecmp(encap->desired_section, partnum)) {
+ encap->msglen = length;
+ encap->msg = malloc(length + 2);
+ memcpy(encap->msg, content, length);
+ return;
+ }
+
+}
+
+
+
+
/*
* Get a message off disk. (returns om_* values found in msgbase.h)
*
int mode, /* how would you like that message? */
int headers_only, /* eschew the message body? */
int do_proto, /* do Citadel protocol responses? */
- int crlf /* Use CRLF newlines instead of LF? */
+ int crlf, /* Use CRLF newlines instead of LF? */
+ char *section /* NULL or a message/rfc822 section */
) {
struct CtdlMessage *TheMessage = NULL;
int retcode = om_no_such_msg;
+ struct encapmsg encap;
- lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d\n",
- msg_num, mode);
+ lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d, section=%s\n",
+ msg_num, mode,
+ (section ? section : "<>")
+ );
if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
if (do_proto) cprintf("%d Not logged in.\n",
ERROR + MESSAGE_NOT_FOUND, msg_num);
return(om_no_such_msg);
}
-
- retcode = CtdlOutputPreLoadedMsg(
- TheMessage, mode,
- headers_only, do_proto, crlf);
+ /* Here is the weird form of this command, to process only an
+ * encapsulated message/rfc822 section.
+ */
+ if (section) if (strlen(section)>0) if (strcmp(section, "0")) {
+ memset(&encap, 0, sizeof encap);
+ safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
+ mime_parser(TheMessage->cm_fields['M'],
+ NULL,
+ *extract_encapsulated_message,
+ NULL, NULL, (void *)&encap, 0
+ );
+ CtdlFreeMessage(TheMessage);
+ TheMessage = NULL;
+
+ if (encap.msg) {
+ encap.msg[encap.msglen] = 0;
+ TheMessage = convert_internet_message(encap.msg);
+ encap.msg = NULL; /* no free() here, TheMessage owns it now */
+
+ /* Now we let it fall through to the bottom of this
+ * function, because TheMessage now contains the
+ * encapsulated message instead of the top-level
+ * message. Isn't that neat?
+ */
+
+ }
+ else {
+ if (do_proto) cprintf("%d msg %ld has no part %s\n",
+ ERROR + MESSAGE_NOT_FOUND, msg_num, section);
+ retcode = om_no_such_msg;
+ }
+
+ }
+
+ /* Ok, output the message now */
+ retcode = CtdlOutputPreLoadedMsg(
+ TheMessage, mode,
+ headers_only, do_proto, crlf);
CtdlFreeMessage(TheMessage);
return(retcode);
msgid = extract_long(cmdbuf, 0);
headers_only = extract_int(cmdbuf, 1);
- CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0);
+ CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, 0, NULL);
return;
}
msgid = extract_long(cmdbuf, 0);
headers_only = extract_int(cmdbuf, 1);
- CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1);
+ CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, 1, NULL);
}
void cmd_msg4(char *cmdbuf)
{
long msgid;
+ char section[64];
msgid = extract_long(cmdbuf, 0);
- CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0);
+ extract_token(section, cmdbuf, 1, '|', sizeof section);
+ CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0, (section[0] ? section : NULL) );
}
extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
safestrncpy(CC->download_desired_section, desired_section,
sizeof CC->download_desired_section);
- CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1);
+ CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1, NULL);
}
msglist = NULL;
num_msgs = 0;
} else {
- msglist = malloc(cdbfr->len);
- if (msglist == NULL) {
- lprintf(CTDL_ALERT, "ERROR malloc msglist!\n");
- }
+ msglist = (long *) cdbfr->ptr;
+ cdbfr->ptr = NULL; /* CtdlSaveMsgPointerInRoom() now owns this memory */
num_msgs = cdbfr->len / sizeof(long);
- memcpy(msglist, cdbfr->ptr, cdbfr->len);
cdb_free(cdbfr);
}
char *hold_R, *hold_D;
char *collected_addresses = NULL;
struct addresses_to_be_filed *aptr = NULL;
+ char *saved_rfc822_version = NULL;
+ int qualified_for_journaling = 0;
lprintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
if (is_valid_message(msg) == 0) return(-1); /* self check */
safestrncpy(smi.meta_content_type, content_type,
sizeof smi.meta_content_type);
- /* As part of the new metadata record, measure how
- * big this message will be when displayed as RFC822.
- * Both POP and IMAP use this, and it's best to just take the hit now
- * instead of having to potentially measure thousands of messages when
- * a mailbox is opened later.
+ /*
+ * Measure how big this message will be when rendered as RFC822.
+ * We do this for two reasons:
+ * 1. We need the RFC822 length for the new metadata record, so the
+ * POP and IMAP services don't have to calculate message lengths
+ * while the user is waiting (multiplied by potentially hundreds
+ * or thousands of messages).
+ * 2. If journaling is enabled, we will need an RFC822 version of the
+ * message to attach to the journalized copy.
*/
-
if (CC->redirect_buffer != NULL) {
lprintf(CTDL_ALERT, "CC->redirect_buffer is not NULL during message submission!\n");
abort();
CC->redirect_alloc = SIZ;
CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1);
smi.meta_rfc822_length = CC->redirect_len;
- free(CC->redirect_buffer);
+ saved_rfc822_version = CC->redirect_buffer;
CC->redirect_buffer = NULL;
CC->redirect_len = 0;
CC->redirect_alloc = 0;
}
else {
lprintf(CTDL_DEBUG, "No user <%s>\n", recipient);
- CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom,
+ newmsgid, 0, msg);
}
}
for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
size_t tmp = strlen(instr);
- extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
+ extract_token(recipient, recps->recp_internet,
+ i, '|', sizeof recipient);
snprintf(&instr[tmp], SIZ * 2 - tmp,
"remote|%s|0||\n", recipient);
}
imsg->cm_anon_type = MES_NORMAL;
imsg->cm_format_type = FMT_RFC822;
imsg->cm_fields['A'] = strdup("Citadel");
+ imsg->cm_fields['J'] = strdup("do not journal");
imsg->cm_fields['M'] = instr;
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
if (collected_addresses != NULL) {
begin_critical_section(S_ATBF);
- aptr = (struct addresses_to_be_filed *) malloc(sizeof(struct addresses_to_be_filed));
+ aptr = (struct addresses_to_be_filed *)
+ malloc(sizeof(struct addresses_to_be_filed));
aptr->next = atbf;
- MailboxName(actual_rm, sizeof actual_rm, &CC->user, USERCONTACTSROOM);
+ MailboxName(actual_rm, sizeof actual_rm,
+ &CC->user, USERCONTACTSROOM);
aptr->roomname = strdup(actual_rm);
aptr->collected_addresses = collected_addresses;
atbf = aptr;
end_critical_section(S_ATBF);
}
- return(newmsgid);
-}
+ /*
+ * Determine whether this message qualifies for journaling.
+ */
+ if (msg->cm_fields['J'] != NULL) {
+ qualified_for_journaling = 0;
+ }
+ else {
+ if (recps == NULL) {
+ qualified_for_journaling = config.c_journal_pubmsgs;
+ }
+ else if (recps->num_local + recps->num_ignet + recps->num_internet > 0) {
+ qualified_for_journaling = config.c_journal_email;
+ }
+ else {
+ qualified_for_journaling = config.c_journal_pubmsgs;
+ }
+ }
+ /*
+ * Do we have to perform journaling? If so, hand off the saved
+ * RFC822 version will be handed off to the journaler for background
+ * submit. Otherwise, we have to free the memory ourselves.
+ */
+ if (saved_rfc822_version != NULL) {
+ if (qualified_for_journaling) {
+ JournalBackgroundSubmit(msg, saved_rfc822_version, recps);
+ }
+ else {
+ free(saved_rfc822_version);
+ }
+ }
+ /* Done. */
+ return(newmsgid);
+}
* Returns 0 if all addresses are ok, -1 if no addresses were specified,
* or the number of addresses found invalid.
*/
-struct recptypes *validate_recipients(char *recipients) {
+struct recptypes *validate_recipients(char *supplied_recipients) {
struct recptypes *ret;
- char this_recp[SIZ];
- char this_recp_cooked[SIZ];
+ char recipients[SIZ];
+ char this_recp[256];
+ char this_recp_cooked[256];
char append[SIZ];
- int num_recps;
+ int num_recps = 0;
int i, j;
int mailtype;
int invalid;
struct ctdluser tempUS;
struct ctdlroom tempQR;
+ int in_quotes = 0;
/* Initialize */
ret = (struct recptypes *) malloc(sizeof(struct recptypes));
ret->num_error = 0;
ret->num_room = 0;
- if (recipients == NULL) {
- num_recps = 0;
- }
- else if (strlen(recipients) == 0) {
- num_recps = 0;
+ if (supplied_recipients == NULL) {
+ strcpy(recipients, "");
}
else {
- /* Change all valid separator characters to commas */
- for (i=0; i<strlen(recipients); ++i) {
- if ((recipients[i] == ';') || (recipients[i] == '|')) {
- recipients[i] = ',';
- }
- }
+ safestrncpy(recipients, supplied_recipients, sizeof recipients);
+ }
- /* Count 'em up */
- num_recps = num_tokens(recipients, ',');
+ /* Change all valid separator characters to commas */
+ for (i=0; i<strlen(recipients); ++i) {
+ if ((recipients[i] == ';') || (recipients[i] == '|')) {
+ recipients[i] = ',';
+ }
}
- if (num_recps > 0) for (i=0; i<num_recps; ++i) {
- extract_token(this_recp, recipients, i, ',', sizeof this_recp);
+ /* Now start extracting recipients... */
+
+ while (strlen(recipients) > 0) {
+
+ for (i=0; i<=strlen(recipients); ++i) {
+ if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
+ if ( ( (recipients[i] == ',') && (!in_quotes) ) || (recipients[i] == 0) ) {
+ safestrncpy(this_recp, recipients, i+1);
+ this_recp[i] = 0;
+ if (recipients[i] == ',') {
+ strcpy(recipients, &recipients[i+1]);
+ }
+ else {
+ strcpy(recipients, "");
+ }
+ break;
+ }
+ }
+
striplt(this_recp);
- lprintf(CTDL_DEBUG, "Evaluating recipient #%d <%s>\n", i, this_recp);
+ lprintf(CTDL_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
+ ++num_recps;
mailtype = alias(this_recp);
mailtype = alias(this_recp);
mailtype = alias(this_recp);
cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = malloc(cdbfr->len);
dellist = malloc(cdbfr->len);
- memcpy(msglist, cdbfr->ptr, cdbfr->len);
+ msglist = (long *) cdbfr->ptr;
+ cdbfr->ptr = NULL; /* CtdlDeleteMessages() now owns this memory */
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
}
num = extract_long(args, 0);
extract_token(targ, args, 1, '|', sizeof targ);
+ convert_room_name_macros(targ, sizeof targ);
targ[ROOMNAMELEN - 1] = 0;
is_copy = extract_int(args, 2);
char *encoded_message = NULL;
off_t raw_length = 0;
- if (is_mailbox != NULL)
+ if (is_mailbox != NULL) {
MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
- else
+ }
+ else {
safestrncpy(roomname, req_room, sizeof(roomname));
- lprintf(CTDL_DEBUG, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
-
+ }
fp = fopen(tempfilename, "rb");
if (fp == NULL) {
char temp[PATH_MAX];
FILE *fp;
- strcpy(temp, tmpnam(NULL));
+ CtdlMakeTempFileName(temp, sizeof temp);
fp = fopen(temp, "w");
if (fp == NULL) return;
projects / citadel.git / blobdiff