#include "room_ops.h"
#include "user_ops.h"
#include "file_ops.h"
+#include "config.h"
#include "control.h"
#include "tools.h"
#include "mime_parser.h"
#include "html.h"
#include "genstamp.h"
#include "internet_addressing.h"
+#include "serv_fulltext.h"
+#include "vcard.h"
+#include "euidindex.h"
-extern struct config config;
long config_msgnum;
-
+struct addresses_to_be_filed *atbf = NULL;
/*
* This really belongs in serv_network.c, but I don't know how to export
NULL,
NULL,
NULL,
- NULL,
+ "cccc",
NULL
};
striplt(name);
remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
- fp = fopen("network/mail.aliases", "r");
+ fp = fopen(
+#ifndef HAVE_ETG_DIR
+ "network/"
+#else
+ ETC_DIR
+#endif
+ "mail.aliases", "r");
if (fp == NULL) {
fp = fopen("/dev/null", "r");
}
fclose(fp);
/* Hit the Global Address Book */
- if (CtdlDirectoryLookup(aaa, name) == 0) {
+ if (CtdlDirectoryLookup(aaa, name, sizeof aaa) == 0) {
strcpy(name, aaa);
}
{
FILE *fp;
- fp = fopen("citadel.control", "r");
+ fp = fopen(
+#ifndef HAVE_RUN_DIR
+ "."
+#else
+ RUN_DIR
+#endif
+ "/citadel.control", "r");
if (fp == NULL) {
lprintf(CTDL_CRIT, "Cannot open citadel.control: %s\n",
strerror(errno));
}
-
+/*
+ * Back end for the MSGS command: output message number only.
+ */
void simple_listing(long msgnum, void *userdata)
{
cprintf("%ld\n", msgnum);
+/*
+ * Back end for the MSGS command: output header summary.
+ */
+void headers_listing(long msgnum, void *userdata)
+{
+ struct CtdlMessage *msg;
+
+ msg = CtdlFetchMessage(msgnum, 0);
+ if (msg < 0L) {
+ cprintf("%ld|0|||||\n", msgnum);
+ return;
+ }
+
+ cprintf("%ld|%s|%s|%s|%s|%s|\n",
+ msgnum,
+ (msg->cm_fields['T'] ? msg->cm_fields['T'] : "0"),
+ (msg->cm_fields['A'] ? msg->cm_fields['A'] : ""),
+ (msg->cm_fields['N'] ? msg->cm_fields['N'] : ""),
+ (msg->cm_fields['F'] ? msg->cm_fields['F'] : ""),
+ (msg->cm_fields['U'] ? msg->cm_fields['U'] : "")
+ );
+ CtdlFreeMessage(msg);
+}
+
+
+
/* Determine if a given message matches the fields in a message template.
* Return 0 for a successful match.
*/
/*
* Manipulate the "seen msgs" string (or other message set strings)
*/
-void CtdlSetSeen(long target_msgnum, int target_setting, int which_set) {
+void CtdlSetSeen(long target_msgnum, int target_setting, int which_set,
+ struct ctdluser *which_user, struct ctdlroom *which_room) {
struct cdbdata *cdbfr;
- int i;
+ int i, j;
int is_seen = 0;
- int was_seen = 1;
+ int was_seen = 0;
long lo = (-1L);
long hi = (-1L);
+ long t = (-1L);
+ int trimming = 0;
struct visit vbuf;
long *msglist;
int num_msgs = 0;
int num_sets;
int s;
char setstr[SIZ], lostr[SIZ], histr[SIZ];
+ size_t tmp;
lprintf(CTDL_DEBUG, "CtdlSetSeen(%ld, %d, %d)\n",
target_msgnum, target_setting, which_set);
/* Learn about the user and room in question */
- CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
+ CtdlGetRelationship(&vbuf,
+ ((which_user != NULL) ? which_user : &CC->user),
+ ((which_room != NULL) ? which_room : &CC->room)
+ );
/* Load the message list */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
memset(is_set, 0, (num_msgs * sizeof(char)) );
/* Decide which message set we're manipulating */
- if (which_set == ctdlsetseen_seen) safestrncpy(vset, vbuf.v_seen, sizeof vset);
- if (which_set == ctdlsetseen_answered) safestrncpy(vset, vbuf.v_answered, sizeof vset);
+ switch(which_set) {
+ case ctdlsetseen_seen:
+ safestrncpy(vset, vbuf.v_seen, sizeof vset);
+ break;
+ case ctdlsetseen_answered:
+ safestrncpy(vset, vbuf.v_answered, sizeof vset);
+ break;
+ }
- lprintf(CTDL_DEBUG, "before optimize: %s\n", vset);
+ /* lprintf(CTDL_DEBUG, "before optimize: %s\n", vset); */
/* Translate the existing sequence set into an array of booleans */
num_sets = num_tokens(vset, ',');
/* Now translate the array of booleans back into a sequence set */
strcpy(vset, "");
+ lo = (-1L);
+ hi = (-1L);
for (i=0; i<num_msgs; ++i) {
is_seen = 0;
is_seen = target_setting;
}
else {
- if (is_set[i]) {
- is_seen = 1;
- }
+ is_seen = is_set[i];
}
- if (is_seen == 1) {
+ if (is_seen) {
if (lo < 0L) lo = msglist[i];
hi = msglist[i];
}
+
if ( ((is_seen == 0) && (was_seen == 1))
|| ((is_seen == 1) && (i == num_msgs-1)) ) {
- size_t tmp;
- if ( (strlen(vset) + 20) > sizeof vset) {
- strcpy(vset, &vset[20]);
- vset[0] = '*';
+ /* begin trim-o-matic code */
+ j=9;
+ trimming = 0;
+ while ( (strlen(vset) + 20) > sizeof vset) {
+ remove_token(vset, 0, ',');
+ trimming = 1;
+ if (j--) break; /* loop no more than 9 times */
+ }
+ if ( (trimming) && (which_set == ctdlsetseen_seen) ) {
+ t = atol(vset);
+ if (t<2) t=2;
+ --t;
+ snprintf(lostr, sizeof lostr,
+ "1:%ld,%s", t, vset);
+ safestrncpy(vset, lostr, sizeof vset);
}
+ /* end trim-o-matic code */
+
tmp = strlen(vset);
if (tmp > 0) {
strcat(vset, ",");
- tmp++;
+ ++tmp;
}
if (lo == hi) {
- snprintf(&vset[tmp], sizeof vset - tmp,
+ snprintf(&vset[tmp], (sizeof vset) - tmp,
"%ld", lo);
}
else {
- snprintf(&vset[tmp], sizeof vset - tmp,
+ snprintf(&vset[tmp], (sizeof vset) - tmp,
"%ld:%ld", lo, hi);
}
lo = (-1L);
}
/* Decide which message set we're manipulating */
- if (which_set == ctdlsetseen_seen) safestrncpy(vbuf.v_seen, vset, sizeof vbuf.v_seen);
- if (which_set == ctdlsetseen_answered) safestrncpy(vbuf.v_answered, vset, sizeof vbuf.v_answered);
+ switch (which_set) {
+ case ctdlsetseen_seen:
+ safestrncpy(vbuf.v_seen, vset, sizeof vbuf.v_seen);
+ break;
+ case ctdlsetseen_answered:
+ safestrncpy(vbuf.v_answered, vset,
+ sizeof vbuf.v_answered);
+ break;
+ }
free(is_set);
- lprintf(CTDL_DEBUG, " after optimize: %s\n", vset);
+ /* lprintf(CTDL_DEBUG, " after optimize: %s\n", vset); */
free(msglist);
- CtdlSetRelationship(&vbuf, &CC->user, &CC->room);
+ CtdlSetRelationship(&vbuf,
+ ((which_user != NULL) ? which_user : &CC->user),
+ ((which_room != NULL) ? which_room : &CC->room)
+ );
}
long thismsg;
struct MetaData smi;
struct CtdlMessage *msg;
- int is_seen;
+ int is_seen = 0;
long lastold = 0L;
int printed_lastold = 0;
if (num_msgs > 0)
for (a = 0; a < num_msgs; ++a) {
thismsg = msglist[a];
- is_seen = is_msg_in_sequence_set(vbuf.v_seen, thismsg);
- if (is_seen) lastold = thismsg;
+ if (mode == MSGS_ALL) {
+ is_seen = 0;
+ }
+ else {
+ is_seen = is_msg_in_sequence_set(
+ vbuf.v_seen, thismsg);
+ if (is_seen) lastold = thismsg;
+ }
if ((thismsg > 0L)
&& (
int i;
int with_template = 0;
struct CtdlMessage *template = NULL;
+ int with_headers = 0;
extract_token(which, cmdbuf, 0, '|', sizeof which);
cm_ref = extract_int(cmdbuf, 1);
with_template = extract_int(cmdbuf, 2);
+ with_headers = extract_int(cmdbuf, 3);
mode = MSGS_ALL;
strcat(which, " ");
buffer_output();
}
else {
- cprintf("%d Message list...\n", LISTING_FOLLOWS);
+ cprintf("%d \n", LISTING_FOLLOWS);
}
- CtdlForEachMessage(mode, cm_ref,
- NULL, template, simple_listing, NULL);
+ CtdlForEachMessage(mode,
+ cm_ref,
+ NULL,
+ template,
+ (with_headers ? headers_listing : simple_listing),
+ NULL
+ );
if (template != NULL) CtdlFreeMessage(template);
cprintf("000\n");
}
* Callback function for mime parser that simply lists the part
*/
void list_this_part(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
-
- cprintf("part=%s|%s|%s|%s|%s|%ld\n",
- name, filename, partnum, disp, cbtype, (long)length);
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ if (ma->is_ma == 0) {
+ cprintf("part=%s|%s|%s|%s|%s|%ld\n",
+ name, filename, partnum, disp, cbtype, (long)length);
+ }
}
/*
* Callback function for multipart prefix
*/
void list_this_pref(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
- cprintf("pref=%s|%s\n", partnum, cbtype);
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ ++ma->is_ma;
+ }
+
+ if (ma->is_ma == 0) {
+ cprintf("pref=%s|%s\n", partnum, cbtype);
+ }
}
/*
* Callback function for multipart sufffix
*/
void list_this_suff(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
- cprintf("suff=%s|%s\n", partnum, cbtype);
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ if (ma->is_ma == 0) {
+ cprintf("suff=%s|%s\n", partnum, cbtype);
+ }
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ --ma->is_ma;
+ }
}
* Callback function for mime parser that opens a section for downloading
*/
void mime_download(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
- void *cbuserdata)
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
{
/* Silently go away if there's already a download open... */
* body so other code doesn't barf.
*/
if ( (ret->cm_fields['M'] == NULL) && (with_body) ) {
- lprintf(CTDL_DEBUG, "** FETCHING BIG MESSAGE **\n"); /* FIXME */
dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
if (dmsgtext != NULL) {
ret->cm_fields['M'] = strdup(dmsgtext->ptr);
*
*/
void fixed_output_pre(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
struct ma_info *ma;
* Post callback function for multipart/alternative
*/
void fixed_output_post(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
struct ma_info *ma;
* 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, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
char *ptr;
* we're going to send.
*/
void choose_preferred(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
char buf[1024];
* 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, size_t length, char *encoding,
+ void *content, char *cbtype, char *cbcharset, size_t length, char *encoding,
void *cbuserdata)
{
int i;
++add_newline;
}
- cprintf("Content-type: %s\n", cbtype);
- cprintf("Content-length: %d\n",
+ cprintf("Content-type: %s", cbtype);
+ if (strlen(cbcharset) > 0) {
+ cprintf("; charset=%s", cbcharset);
+ }
+ cprintf("\nContent-length: %d\n",
(int)(length + add_newline) );
if (strlen(encoding) > 0) {
cprintf("Content-transfer-encoding: %s\n", encoding);
/* No translations required or possible: output as text/plain */
cprintf("Content-type: text/plain\n\n");
- fixed_output(name, filename, partnum, disp, content, cbtype,
+ fixed_output(name, filename, partnum, disp, content, cbtype, cbcharset,
length, encoding, cbuserdata);
}
}
retcode = CtdlOutputPreLoadedMsg(
- TheMessage, msg_num, mode,
+ TheMessage, mode,
headers_only, do_proto, crlf);
CtdlFreeMessage(TheMessage);
*/
int CtdlOutputPreLoadedMsg(
struct CtdlMessage *TheMessage,
- long msg_num,
int mode, /* how would you like that message? */
int headers_only, /* eschew the message body? */
int do_proto, /* do Citadel protocol responses? */
char *nl; /* newline string */
int suppress_f = 0;
int subject_found = 0;
- struct ma_info *ma;
+ struct ma_info ma;
/* Buffers needed for RFC822 translation. These are all filled
* using functions that are bounds-checked, and therefore we can
char mid[100];
char datestamp[100];
- lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %ld, %d, %d, %d, %d\n",
+ lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
((TheMessage == NULL) ? "NULL" : "not null"),
- msg_num,
mode, headers_only, do_proto, crlf);
- snprintf(mid, sizeof mid, "%ld", msg_num);
+ strcpy(mid, "unknown");
nl = (crlf ? "\r\n" : "\n");
if (!is_valid_message(TheMessage)) {
} else {
/* Parse the message text component */
mptr = TheMessage->cm_fields['M'];
- ma = malloc(sizeof(struct ma_info));
- memset(ma, 0, sizeof(struct ma_info));
- mime_parser(mptr, NULL, *mime_download, NULL, NULL, (void *)ma, 0);
- free(ma);
+ mime_parser(mptr, NULL, *mime_download, NULL, NULL, NULL, 0);
/* If there's no file open by this time, the requested
* section wasn't found, so print an error
*/
}
/* now for the user-mode message reading loops */
- if (do_proto) cprintf("%d Message %ld:\n", LISTING_FOLLOWS, msg_num);
+ if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
/* Does the caller want to skip the headers? */
if (headers_only == HEADERS_NONE) goto START_TEXT;
safestrncpy(luser, mptr, sizeof luser);
safestrncpy(suser, mptr, sizeof suser);
}
+ else if (i == 'Y') {
+ cprintf("CC: %s%s", mptr, nl);
+ }
else if (i == 'U') {
cprintf("Subject: %s%s", mptr, nl);
subject_found = 1;
cprintf(">%s", nl);
if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
- // cprintf("From: x@x.org (----)%s", nl);
cprintf("From: \"----\" <x@x.org>%s", nl);
}
else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
- // cprintf("From: x@x.org (anonymous)%s", nl);
cprintf("From: \"anonymous\" <x@x.org>%s", nl);
}
else if (strlen(fuser) > 0) {
- // cprintf("From: %s (%s)%s", fuser, luser, nl);
cprintf("From: \"%s\" <%s>%s", luser, fuser, nl);
}
else {
- // cprintf("From: %s@%s (%s)%s", suser, snode, luser, nl);
cprintf("From: \"%s\" <%s@%s>%s", luser, suser, snode, nl);
}
/* Tell the client about the MIME parts in this message */
if (TheMessage->cm_format_type == FMT_RFC822) {
if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
+ memset(&ma, 0, sizeof(struct ma_info));
mime_parser(mptr, NULL,
(do_proto ? *list_this_part : NULL),
(do_proto ? *list_this_pref : NULL),
(do_proto ? *list_this_suff : NULL),
- NULL, 0);
+ (void *)&ma, 0);
}
else if (mode == MT_RFC822) { /* unparsed RFC822 dump */
- /* FIXME ... we have to put some code in here to avoid
- * printing duplicate header information when both
- * Citadel and RFC822 headers exist. Preference should
- * probably be given to the RFC822 headers.
- */
- int done_rfc822_hdrs = 0;
- while (ch=*(mptr++), ch!=0) {
+ char *start_of_text = NULL;
+ start_of_text = strstr(mptr, "\n\r\n");
+ if (start_of_text == NULL) start_of_text = strstr(mptr, "\n\n");
+ if (start_of_text == NULL) start_of_text = mptr;
+ ++start_of_text;
+ start_of_text = strstr(start_of_text, "\n");
+ ++start_of_text;
+ while (ch=*mptr, ch!=0) {
if (ch==13) {
/* do nothing */
}
- else if (ch==10) {
- if (!done_rfc822_hdrs) {
- if (headers_only != HEADERS_NONE) {
- cprintf("%s", nl);
+ else switch(headers_only) {
+ case HEADERS_NONE:
+ if (mptr >= start_of_text) {
+ if (ch == 10) cprintf("%s", nl);
+ else cprintf("%c", ch);
}
- }
- else {
- if (headers_only != HEADERS_ONLY) {
- cprintf("%s", nl);
+ break;
+ case HEADERS_ONLY:
+ if (mptr < start_of_text) {
+ if (ch == 10) cprintf("%s", nl);
+ else cprintf("%c", ch);
}
- }
- if ((*(mptr) == 13) || (*(mptr) == 10)) {
- done_rfc822_hdrs = 1;
- }
- }
- else {
- if (done_rfc822_hdrs) {
- if (headers_only != HEADERS_NONE) {
- cprintf("%c", ch);
- }
- }
- else {
- if (headers_only != HEADERS_ONLY) {
- cprintf("%c", ch);
- }
- }
- if ((*mptr == 13) || (*mptr == 10)) {
- done_rfc822_hdrs = 1;
- }
+ break;
+ default:
+ if (ch == 10) cprintf("%s", nl);
+ else cprintf("%c", ch);
+ break;
}
+ ++mptr;
}
goto DONE;
}
* we use will display those parts as-is.
*/
if (TheMessage->cm_format_type == FMT_RFC822) {
- ma = malloc(sizeof(struct ma_info));
- memset(ma, 0, sizeof(struct ma_info));
+ memset(&ma, 0, sizeof(struct ma_info));
if (mode == MT_MIME) {
- strcpy(ma->chosen_part, "1");
+ strcpy(ma.chosen_part, "1");
mime_parser(mptr, NULL,
*choose_preferred, *fixed_output_pre,
- *fixed_output_post, (void *)ma, 0);
+ *fixed_output_post, (void *)&ma, 0);
mime_parser(mptr, NULL,
- *output_preferred, NULL, NULL, (void *)ma, 0);
+ *output_preferred, NULL, NULL, (void *)&ma, 0);
}
else {
mime_parser(mptr, NULL,
*fixed_output, *fixed_output_pre,
- *fixed_output_post, (void *)ma, 0);
+ *fixed_output_post, (void *)&ma, 0);
}
- free(ma);
}
DONE: /* now we're done */
* Save a message pointer into a specified room
* (Returns 0 for success, nonzero for failure)
* roomname may be NULL to use the current room
+ *
+ * Note that the 'supplied_msg' field may be set to NULL, in which case
+ * the message will be fetched from disk, by number, if we need to perform
+ * replication checks. This adds an additional database read, so if the
+ * caller already has the message in memory then it should be supplied.
*/
-int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int flags) {
+int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int do_repl_check,
+ struct CtdlMessage *supplied_msg) {
int i;
char hold_rm[ROOMNAMELEN];
struct cdbdata *cdbfr;
long highest_msg = 0L;
struct CtdlMessage *msg = NULL;
- lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
- roomname, msgid, flags);
+ lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom(roomname=%s, msgid=%ld, do_repl_check=%d)\n",
+ roomname, msgid, do_repl_check);
strcpy(hold_rm, CC->room.QRname);
/* We may need to check to see if this message is real */
- if ( (flags & SM_VERIFY_GOODNESS)
- || (flags & SM_DO_REPL_CHECK)
- ) {
- msg = CtdlFetchMessage(msgid, 1);
+ if (do_repl_check) {
+ if (supplied_msg != NULL) {
+ msg = supplied_msg;
+ }
+ else {
+ msg = CtdlFetchMessage(msgid, 0);
+ }
if (msg == NULL) return(ERROR + ILLEGAL_VALUE);
}
/* Perform replication checks if necessary */
- if ( (flags & SM_DO_REPL_CHECK) && (msg != NULL) ) {
+ if ( (do_repl_check) && (msg != NULL) ) {
if (getroom(&CC->room,
((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
- if (msg != NULL) CtdlFreeMessage(msg);
+ if ( (msg != NULL) && (msg != supplied_msg) ) CtdlFreeMessage(msg);
return(ERROR + ROOM_NOT_FOUND);
}
- if (ReplicationChecks(msg) != 0) {
- getroom(&CC->room, hold_rm);
- if (msg != NULL) CtdlFreeMessage(msg);
- lprintf(CTDL_DEBUG,
- "Did replication, and newer exists\n");
- return(0);
- }
+ ReplicationChecks(msg);
}
/* Now the regular stuff */
((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
- if (msg != NULL) CtdlFreeMessage(msg);
+ if ( (msg != NULL) && (msg != supplied_msg) ) CtdlFreeMessage(msg);
return(ERROR + ROOM_NOT_FOUND);
}
if (msglist[i] == msgid) {
lputroom(&CC->room); /* unlock the room */
getroom(&CC->room, hold_rm);
- if (msg != NULL) CtdlFreeMessage(msg);
+ if ( (msg != NULL) && (msg != supplied_msg) ) CtdlFreeMessage(msg);
free(msglist);
return(ERROR + ALREADY_EXISTS);
}
/* Free up the memory we used. */
free(msglist);
+ /* If the message has an Exclusive ID, index that... */
+ if (msg != NULL) {
+ if (msg->cm_fields['E'] != NULL) {
+ index_message_by_euid(msg->cm_fields['E'], &CC->room, msgid);
+ }
+ }
+
/* Update the highest-message pointer and unlock the room. */
CC->room.QRhighest = highest_msg;
lputroom(&CC->room);
getroom(&CC->room, hold_rm);
/* Bump the reference count for this message. */
- if ((flags & SM_DONT_BUMP_REF)==0) {
- AdjRefCount(msgid, +1);
- }
+ AdjRefCount(msgid, +1);
/* Return success. */
- if (msg != NULL) CtdlFreeMessage(msg);
+ if ( (msg != NULL) && (msg != supplied_msg) ) CtdlFreeMessage(msg);
return (0);
}
/*
- * Back end for the ReplicationChecks() function
- */
-void check_repl(long msgnum, void *userdata) {
- lprintf(CTDL_DEBUG, "check_repl() replacing message %ld\n", msgnum);
- CtdlDeleteMessages(CC->room.QRname, msgnum, "");
-}
-
-
-/*
- * Check to see if any messages already exist which carry the same Exclusive ID
- * as this one. If any are found, delete them.
- *
+ * Check to see if any messages already exist in the current room which
+ * carry the same Exclusive ID as this one. If any are found, delete them.
*/
-int ReplicationChecks(struct CtdlMessage *msg) {
- struct CtdlMessage *template;
- int abort_this = 0;
+void ReplicationChecks(struct CtdlMessage *msg) {
+ long old_msgnum = (-1L);
/* No exclusive id? Don't do anything. */
- if (msg->cm_fields['E'] == NULL) return 0;
- if (strlen(msg->cm_fields['E']) == 0) return 0;
- lprintf(CTDL_DEBUG, "Exclusive ID: <%s>\n", msg->cm_fields['E']);
-
- template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
- memset(template, 0, sizeof(struct CtdlMessage));
- template->cm_fields['E'] = strdup(msg->cm_fields['E']);
+ if (msg == NULL) return;
+ if (msg->cm_fields['E'] == NULL) return;
+ if (strlen(msg->cm_fields['E']) == 0) return;
+ lprintf(CTDL_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
+ msg->cm_fields['E'], CC->room.QRname);
- CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
-
- CtdlFreeMessage(template);
- lprintf(CTDL_DEBUG, "ReplicationChecks() returning %d\n", abort_this);
- return(abort_this);
+ old_msgnum = locate_message_by_euid(msg->cm_fields['E'], &CC->room);
+ if (old_msgnum > 0L) {
+ lprintf(CTDL_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
+ CtdlDeleteMessages(CC->room.QRname, old_msgnum, "", 0);
+ }
}
-
/*
* Save a message to disk and submit it into the delivery system.
*/
char *instr;
struct ser_ret smr;
char *hold_R, *hold_D;
+ char *collected_addresses = NULL;
+ struct addresses_to_be_filed *aptr = NULL;
lprintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
if (is_valid_message(msg) == 0) return(-1); /* self check */
break;
case 4:
strcpy(content_type, "text/plain");
- mptr = bmstrstr(msg->cm_fields['M'],
- "Content-type: ", strncasecmp);
+ mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type: ");
if (mptr != NULL) {
safestrncpy(content_type, &mptr[14],
sizeof content_type);
lprintf(CTDL_DEBUG, "Final selection: %s\n", actual_rm);
if (strcasecmp(actual_rm, CC->room.QRname)) {
- getroom(&CC->room, actual_rm);
+ /* getroom(&CC->room, actual_rm); */
+ usergoto(actual_rm, 0, 1, NULL, NULL);
}
/*
/* If this message has an Exclusive ID, perform replication checks */
lprintf(CTDL_DEBUG, "Performing replication checks\n");
- if (ReplicationChecks(msg) > 0) return(-4);
+ ReplicationChecks(msg);
/* Save it to disk */
lprintf(CTDL_DEBUG, "Saving to disk\n");
CC->redirect_buffer = malloc(SIZ);
CC->redirect_len = 0;
CC->redirect_alloc = SIZ;
- CtdlOutputPreLoadedMsg(msg, 0L, MT_RFC822, HEADERS_ALL, 0, 1);
+ CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1);
smi.meta_rfc822_length = CC->redirect_len;
free(CC->redirect_buffer);
CC->redirect_buffer = NULL;
* is no local sender; it would otherwise go to the Trashcan).
*/
if ((!CC->internal_pgm) || (recps == NULL)) {
- if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0) != 0) {
+ if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
lprintf(CTDL_ERR, "ERROR saving message pointer!\n");
- CtdlSaveMsgPointerInRoom(config.c_aideroom,
- newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
}
}
/* For internet mail, drop a copy in the outbound queue room */
if (recps != NULL)
if (recps->num_internet > 0) {
- CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0, msg);
}
/* If other rooms are specified, drop them there too. */
extract_token(recipient, recps->recp_room, i,
'|', sizeof recipient);
lprintf(CTDL_DEBUG, "Delivering to room <%s>\n", recipient);
- CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
}
/* Bump this user's messages posted counter. */
if (getuser(&userbuf, recipient) == 0) {
MailboxName(actual_rm, sizeof actual_rm,
&userbuf, MAILROOM);
- CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
BumpNewMailCounter(userbuf.usernum);
}
else {
lprintf(CTDL_DEBUG, "No user <%s>\n", recipient);
- CtdlSaveMsgPointerInRoom(config.c_aideroom,
- newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
}
}
serialize_message(&smr, msg);
if (smr.len > 0) {
snprintf(submit_filename, sizeof submit_filename,
- "./network/spoolin/netmail.%04lx.%04x.%04x",
- (long) getpid(), CC->cs_pid, ++seqnum);
+#ifndef HAVE_SPOOL_DIR
+ "."
+#else
+ SPOOL_DIR
+#endif
+ "/network/spoolin/netmail.%04lx.%04x.%04x",
+ (long) getpid(), CC->cs_pid, ++seqnum);
network_fp = fopen(submit_filename, "wb+");
if (network_fp != NULL) {
fwrite(smr.ser, smr.len, 1, network_fp);
/* Go back to the room we started from */
lprintf(CTDL_DEBUG, "Returning to original room %s\n", hold_rm);
if (strcasecmp(hold_rm, CC->room.QRname))
- getroom(&CC->room, hold_rm);
+ /* getroom(&CC->room, hold_rm); */
+ usergoto(hold_rm, 0, 1, NULL, NULL);
/* For internet mail, generate delivery instructions.
* Yes, this is recursive. Deal with it. Infinite recursion does
CtdlFreeMessage(imsg);
}
+ /*
+ * Any addresses to harvest for someone's address book?
+ */
+ if ( (CC->logged_in) && (recps != NULL) ) {
+ collected_addresses = harvest_collected_addresses(msg);
+ }
+
+ if (collected_addresses != NULL) {
+ begin_critical_section(S_ATBF);
+ 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);
+ aptr->roomname = strdup(actual_rm);
+ aptr->collected_addresses = collected_addresses;
+ atbf = aptr;
+ end_critical_section(S_ATBF);
+ }
return(newmsgid);
}
+
+
+
+
+
/*
* Convenience function for generating small administrative messages.
*/
struct CtdlMessage *CtdlMakeMessage(
struct ctdluser *author, /* author's user structure */
char *recipient, /* NULL if it's not mail */
+ char *recp_cc, /* NULL if it's not mail */
char *room, /* room where it's going */
int type, /* see MES_ types in header file */
int format_type, /* variformat, plain text, MIME... */
strcpy(dest_node, "");
striplt(recipient);
+ striplt(recp_cc);
snprintf(buf, sizeof buf, "cit%ld", author->usernum); /* Path */
msg->cm_fields['P'] = strdup(buf);
if (recipient[0] != 0) {
msg->cm_fields['R'] = strdup(recipient);
}
+ if (recp_cc[0] != 0) {
+ msg->cm_fields['Y'] = strdup(recp_cc);
+ }
if (dest_node[0] != 0) {
msg->cm_fields['D'] = strdup(dest_node);
}
}
-
/*
* Validate recipients, count delivery types and errors, and handle aliasing
* FIXME check for dupes!!!!!
+ * 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 *ret;
if ((ret->num_local + ret->num_internet + ret->num_ignet +
ret->num_room + ret->num_error) == 0) {
- ++ret->num_error;
+ ret->num_error = (-1);
strcpy(ret->errormsg, "No recipients specified.");
}
{
int post = 0;
char recp[SIZ];
+ char cc[SIZ];
+ char bcc[SIZ];
char masquerade_as[SIZ];
int anon_flag = 0;
int format_type = 0;
char errmsg[SIZ];
int err = 0;
struct recptypes *valid = NULL;
+ struct recptypes *valid_to = NULL;
+ struct recptypes *valid_cc = NULL;
+ struct recptypes *valid_bcc = NULL;
char subject[SIZ];
int do_confirm = 0;
long msgnum;
format_type = extract_int(entargs, 3);
extract_token(subject, entargs, 4, '|', sizeof subject);
do_confirm = extract_int(entargs, 6);
+ extract_token(cc, entargs, 7, '|', sizeof cc);
+ extract_token(bcc, entargs, 8, '|', sizeof bcc);
/* first check to make sure the request is valid. */
if (CC->user.axlevel < 2) {
strcpy(recp, "sysop");
+ strcpy(cc, "");
+ strcpy(bcc, "");
+ }
+
+ valid_to = validate_recipients(recp);
+ if (valid_to->num_error > 0) {
+ cprintf("%d Invalid recipient (To)\n", ERROR + NO_SUCH_USER);
+ free(valid_to);
+ return;
+ }
+
+ valid_cc = validate_recipients(cc);
+ if (valid_cc->num_error > 0) {
+ cprintf("%d Invalid recipient (CC)\n", ERROR + NO_SUCH_USER);
+ free(valid_to);
+ free(valid_cc);
+ return;
}
- valid = validate_recipients(recp);
- if (valid->num_error > 0) {
- cprintf("%d %s\n",
- ERROR + NO_SUCH_USER, valid->errormsg);
- free(valid);
+ valid_bcc = validate_recipients(bcc);
+ if (valid_bcc->num_error > 0) {
+ cprintf("%d Invalid recipient (BCC)\n", ERROR + NO_SUCH_USER);
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
return;
}
- if (valid->num_internet > 0) {
+
+ /* Recipient required, but none were specified */
+ if ( (valid_to->num_error < 0) && (valid_cc->num_error < 0) && (valid_bcc->num_error < 0) ) {
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
+ cprintf("%d At least one recipient is required.\n", ERROR + NO_SUCH_USER);
+ return;
+ }
+
+ if (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0) {
if (CtdlCheckInternetMailPermission(&CC->user)==0) {
cprintf("%d You do not have permission "
"to send Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- free(valid);
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
return;
}
}
- if ( ( (valid->num_internet + valid->num_ignet) > 0)
+ if ( ( (valid_to->num_internet + valid_to->num_ignet + valid_cc->num_internet + valid_cc->num_ignet + valid_bcc->num_internet + valid_bcc->num_ignet) > 0)
&& (CC->user.axlevel < 4) ) {
cprintf("%d Higher access required for network mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- free(valid);
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
return;
}
- if ((RESTRICT_INTERNET == 1) && (valid->num_internet > 0)
+ if ((RESTRICT_INTERNET == 1)
+ && (valid_to->num_internet + valid_cc->num_internet + valid_bcc->num_internet > 0)
&& ((CC->user.flags & US_INTERNET) == 0)
&& (!CC->internal_pgm)) {
cprintf("%d You don't have access to Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- free(valid);
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
return;
}
*/
if (post == 0) {
cprintf("%d %s\n", CIT_OK,
- ((valid != NULL) ? valid->display_recp : "") );
- free(valid);
+ ((valid_to != NULL) ? valid_to->display_recp : "") );
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
return;
}
+ /* We don't need these anymore because we'll do it differently below */
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
+
/* Handle author masquerading */
if (CC->fake_postname[0]) {
strcpy(masquerade_as, CC->fake_postname);
} else {
cprintf("%d send message\n", SEND_LISTING);
}
- msg = CtdlMakeMessage(&CC->user, recp,
+
+ msg = CtdlMakeMessage(&CC->user, recp, cc,
CC->room.QRname, anonymous, format_type,
masquerade_as, subject, NULL);
+ /* Put together one big recipients struct containing to/cc/bcc all in
+ * one. This is for the envelope.
+ */
+ char *all_recps = malloc(SIZ * 3);
+ strcpy(all_recps, recp);
+ if (strlen(cc) > 0) {
+ if (strlen(all_recps) > 0) {
+ strcat(all_recps, ",");
+ }
+ strcat(all_recps, cc);
+ }
+ if (strlen(bcc) > 0) {
+ if (strlen(all_recps) > 0) {
+ strcat(all_recps, ",");
+ }
+ strcat(all_recps, bcc);
+ }
+ if (strlen(all_recps) > 0) {
+ valid = validate_recipients(all_recps);
+ }
+ else {
+ valid = NULL;
+ }
+ free(all_recps);
+
if (msg != NULL) {
msgnum = CtdlSubmitMsg(msg, valid, "");
CtdlFreeMessage(msg);
}
CC->fake_postname[0] = '\0';
- free(valid);
+ if (valid != NULL) {
+ free(valid);
+ }
return;
}
* (returns the actual number of messages deleted)
*/
int CtdlDeleteMessages(char *room_name, /* which room */
- long dmsgnum, /* or "0" for any */
- char *content_type /* or "" for any */
+ long dmsgnum, /* or "0" for any */
+ char *content_type, /* or "" for any */
+ int deferred /* let TDAP sweep it later */
)
{
int delete_this;
struct MetaData smi;
- lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %ld, %s)\n",
- room_name, dmsgnum, content_type);
+ lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %ld, %s, %d)\n",
+ room_name, dmsgnum, content_type, deferred);
/* get room record, obtaining a lock... */
if (lgetroom(&qrbuf, room_name) != 0) {
}
lputroom(&qrbuf);
+ /*
+ * If the delete operation is "deferred" (and technically, any delete
+ * operation not performed by THE DREADED AUTO-PURGER ought to be
+ * a deferred delete) then we save a pointer to the message in the
+ * DELETED_MSGS_ROOM. This will cause the reference count to remain
+ * at least 1, which will save the user from having to synchronously
+ * wait for various disk-intensive operations to complete.
+ */
+ if ( (deferred) && (num_deleted) ) {
+ for (i=0; i<num_deleted; ++i) {
+ CtdlCopyMsgToRoom(dellist[i], DELETED_MSGS_ROOM);
+ }
+ }
+
/* Go through the messages we pulled out of the index, and decrement
* their reference counts by 1. If this is the only room the message
* was in, the reference count will reach zero and the message will
}
delnum = extract_long(delstr, 0);
- num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "");
+ num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "", 1);
if (num_deleted) {
cprintf("%d %d message%s deleted.\n", CIT_OK,
int CtdlCopyMsgToRoom(long msgnum, char *dest) {
int err;
- err = CtdlSaveMsgPointerInRoom(dest, msgnum,
- (SM_VERIFY_GOODNESS | SM_DO_REPL_CHECK) );
+ err = CtdlSaveMsgPointerInRoom(dest, msgnum, 1, NULL);
if (err != 0) return(err);
return(0);
* if this is a 'move' rather than a 'copy' operation.
*/
if (is_copy == 0) {
- CtdlDeleteMessages(CC->room.QRname, num, "");
+ CtdlDeleteMessages(CC->room.QRname, num, "", 0);
}
cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
*/
begin_critical_section(S_SUPPMSGMAIN);
GetMetaData(&smi, msgnum);
- lprintf(CTDL_DEBUG, "Ref count for message <%ld> before write is <%d>\n",
- msgnum, smi.meta_refcount);
smi.meta_refcount += incr;
PutMetaData(&smi);
end_critical_section(S_SUPPMSGMAIN);
- lprintf(CTDL_DEBUG, "Ref count for message <%ld> after write is <%d>\n",
- msgnum, smi.meta_refcount);
+ lprintf(CTDL_DEBUG, "msg %ld ref count incr %d, is now %d\n",
+ msgnum, incr, smi.meta_refcount);
/* If the reference count is now zero, delete the message
* (and its supplementary record as well).
*/
if (smi.meta_refcount == 0) {
lprintf(CTDL_DEBUG, "Deleting message <%ld>\n", msgnum);
+
+ /* Remove from fulltext index */
+ if (config.c_enable_fulltext) {
+ ft_index_message(msgnum, 0);
+ }
+
+ /* Remove from message base */
delnum = msgnum;
cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
cdb_delete(CDB_BIGMSGS, &delnum, (int)sizeof(long));
- /* We have to delete the metadata record too! */
+ /* Remove metadata record */
delnum = (0L - msgnum);
cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
}
*/
if (is_unique) {
lprintf(CTDL_DEBUG, "Deleted %d other msgs of this type\n",
- CtdlDeleteMessages(roomname, 0L, content_type));
+ CtdlDeleteMessages(roomname, 0L, content_type, 0)
+ );
}
/* Now write the data */
CtdlSubmitMsg(msg, NULL, roomname);