#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"
-#define desired_section ((char *)CtdlGetUserData(SYM_DESIRED_SECTION))
-#define ma ((struct ma_info *)CtdlGetUserData(SYM_MA_INFO))
-#define msg_repl ((struct repl *)CtdlGetUserData(SYM_REPL))
-
-extern struct config config;
long config_msgnum;
NULL,
NULL,
NULL,
- NULL,
+ "cccc",
NULL
};
char *ignetcfg = NULL;
char *ignetmap = NULL;
int at = 0;
- char node[SIZ];
- char testnode[SIZ];
+ char node[64];
+ char testnode[64];
char buf[SIZ];
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);
}
remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
/* figure out the delivery mode */
- extract_token(node, name, 1, '@');
+ extract_token(node, name, 1, '@', sizeof node);
/* If there are one or more dots in the nodename, we assume that it
* is an FQDN and will attempt SMTP delivery to the Internet.
*/
ignetcfg = CtdlGetSysConfig(IGNETCFG);
for (i=0; i<num_tokens(ignetcfg, '\n'); ++i) {
- extract_token(buf, ignetcfg, i, '\n');
- extract_token(testnode, buf, 0, '|');
+ extract_token(buf, ignetcfg, i, '\n', sizeof buf);
+ extract_token(testnode, buf, 0, '|', sizeof testnode);
if (!strcasecmp(node, testnode)) {
free(ignetcfg);
return(MES_IGNET);
*/
ignetmap = CtdlGetSysConfig(IGNETMAP);
for (i=0; i<num_tokens(ignetmap, '\n'); ++i) {
- extract_token(buf, ignetmap, i, '\n');
- extract_token(testnode, buf, 0, '|');
+ extract_token(buf, ignetmap, i, '\n', sizeof buf);
+ extract_token(testnode, buf, 0, '|', sizeof testnode);
if (!strcasecmp(node, testnode)) {
free(ignetmap);
return(MES_IGNET);
{
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) {
- char newseen[SIZ];
+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;
char vset[SIZ];
+ char *is_set; /* actually an array of booleans */
+ 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));
return; /* No messages at all? No further action. */
}
+ is_set = malloc(num_msgs * sizeof(char));
+ memset(is_set, 0, (num_msgs * sizeof(char)) );
+
/* Decide which message set we're manipulating */
- if (which_set == ctdlsetseen_seen) strcpy(vset, vbuf.v_seen);
- if (which_set == ctdlsetseen_answered) strcpy(vset, vbuf.v_answered);
+ 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); */
+
+ /* Translate the existing sequence set into an array of booleans */
+ num_sets = num_tokens(vset, ',');
+ for (s=0; s<num_sets; ++s) {
+ extract_token(setstr, vset, s, ',', sizeof setstr);
+
+ extract_token(lostr, setstr, 0, ':', sizeof lostr);
+ if (num_tokens(setstr, ':') >= 2) {
+ extract_token(histr, setstr, 1, ':', sizeof histr);
+ if (!strcmp(histr, "*")) {
+ snprintf(histr, sizeof histr, "%ld", LONG_MAX);
+ }
+ }
+ else {
+ strcpy(histr, lostr);
+ }
+ lo = atol(lostr);
+ hi = atol(histr);
+
+ for (i = 0; i < num_msgs; ++i) {
+ if ((msglist[i] >= lo) && (msglist[i] <= hi)) {
+ is_set[i] = 1;
+ }
+ }
+ }
- lprintf(CTDL_DEBUG, "before optimize: %s\n", vset);
- strcpy(newseen, "");
+ /* 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_msg_in_mset(vset, msglist[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(newseen) + 20) > SIZ) {
- strcpy(newseen, &newseen[20]);
- newseen[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);
}
- tmp = strlen(newseen);
+ /* end trim-o-matic code */
+
+ tmp = strlen(vset);
if (tmp > 0) {
- strcat(newseen, ",");
- tmp++;
+ strcat(vset, ",");
+ ++tmp;
}
if (lo == hi) {
- snprintf(&newseen[tmp], sizeof newseen - tmp,
+ snprintf(&vset[tmp], (sizeof vset) - tmp,
"%ld", lo);
}
else {
- snprintf(&newseen[tmp], sizeof newseen - 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) strcpy(vbuf.v_seen, newseen);
- if (which_set == ctdlsetseen_answered) strcpy(vbuf.v_answered, newseen);
+ 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", newseen);
+ /* 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_mset(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)
&& (
/*
* cmd_msgs() - get list of message #'s in this room
- * implements the MSGS server command using CtdlForEachMessage()
+ * implements the MSGS server command using CtdlForEachMessage()
*/
void cmd_msgs(char *cmdbuf)
{
int mode = 0;
- char which[SIZ];
- char buf[SIZ];
- char tfield[SIZ];
- char tvalue[SIZ];
+ char which[16];
+ char buf[256];
+ char tfield[256];
+ char tvalue[256];
int cm_ref = 0;
int i;
int with_template = 0;
struct CtdlMessage *template = NULL;
+ int with_headers = 0;
- extract(which, cmdbuf, 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, " ");
template = (struct CtdlMessage *)
malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
- while(client_gets(buf), strcmp(buf,"000")) {
- extract(tfield, buf, 0);
- extract(tvalue, buf, 1);
+ while(client_getln(buf, sizeof buf), strcmp(buf,"000")) {
+ extract_token(tfield, buf, 0, '|', sizeof tfield);
+ extract_token(tvalue, buf, 1, '|', sizeof tvalue);
for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
if (!strcasecmp(tfield, msgkeys[i])) {
template->cm_fields[i] =
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");
}
help_subst(buffer, "^variantname", CITADEL);
snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
help_subst(buffer, "^maxsessions", buf2);
- help_subst(buffer, "^bbsdir", BBSDIR);
+ help_subst(buffer, "^bbsdir", CTDLDIR);
}
/*
* memfmout() - Citadel text formatter and paginator.
- * Although the original purpose of this routine was to format
- * text to the reader's screen width, all we're really using it
- * for here is to format text out to 80 columns before sending it
- * to the client. The client software may reformat it again.
+ * Although the original purpose of this routine was to format
+ * text to the reader's screen width, all we're really using it
+ * for here is to format text out to 80 columns before sending it
+ * to the client. The client software may reformat it again.
*/
void memfmout(
int width, /* screen width to use */
* 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)
{
* 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);
* 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);
* 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... */
return;
/* ...or if this is not the desired section */
- if (strcasecmp(desired_section, partnum))
+ if (strcasecmp(CC->download_desired_section, partnum))
return;
CC->download_fp = tmpfile();
struct cdbdata *dmsgtext;
struct CtdlMessage *ret = NULL;
char *mptr;
+ char *upper_bound;
cit_uint8_t ch;
cit_uint8_t field_header;
- size_t field_length;
lprintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
return NULL;
}
mptr = dmsgtext->ptr;
+ upper_bound = mptr + dmsgtext->len;
/* Parse the three bytes that begin EVERY message on disk.
* The first is always 0xFF, the on-disk magic number.
* have just processed the 'M' (message text) field.
*/
do {
- field_length = strlen(mptr);
- if (field_length == 0)
+ if (mptr >= upper_bound) {
break;
+ }
field_header = *mptr++;
- ret->cm_fields[field_header] = malloc(field_length + 1);
- strcpy(ret->cm_fields[field_header], mptr);
+ ret->cm_fields[field_header] = strdup(mptr);
while (*mptr++ != 0); /* advance to next field */
- } while ((field_length > 0) && (field_header != 'M'));
+ } while ((mptr < upper_bound) && (field_header != 'M'));
cdb_free(dmsgtext);
*
*/
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)
{
- lprintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- ++ma->is_ma;
- ma->did_print = 0;
- return;
- }
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ lprintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ ++ma->is_ma;
+ ma->did_print = 0;
+ return;
+ }
}
/*
* 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)
{
- lprintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- --ma->is_ma;
- ma->did_print = 0;
- return;
- }
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ lprintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ --ma->is_ma;
+ ma->did_print = 0;
+ return;
+ }
}
/*
* 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;
char *wptr;
size_t wlen;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
lprintf(CTDL_DEBUG, "fixed_output() type=<%s>\n", cbtype);
* 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[SIZ];
+ char buf[1024];
int i;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
if (ma->is_ma > 0) {
for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
- extract(buf, CC->preferred_formats, i);
+ extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
if (!strcasecmp(buf, cbtype)) {
strcpy(ma->chosen_part, partnum);
}
* 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;
- char buf[SIZ];
+ char buf[128];
int add_newline = 0;
char *text_content;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
/* This is not the MIME part you're looking for... */
if (strcasecmp(partnum, ma->chosen_part)) return;
* list, we can simply output it verbatim.
*/
for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
- extract(buf, CC->preferred_formats, i);
+ extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
if (!strcasecmp(buf, cbtype)) {
/* Yeah! Go! W00t!! */
++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);
}
/* FIXME: check message id against msglist for this room */
/*
- * Fetch the message from disk. If we're in sooper-fast headers
+ * Fetch the message from disk. If we're in any sort of headers
* only mode, request that we don't even bother loading the body
* into memory.
*/
- if (headers_only == HEADERS_FAST) {
+ if ( (headers_only == HEADERS_FAST) || (headers_only == HEADERS_ONLY) ) {
TheMessage = CtdlFetchMessage(msg_num, 0);
}
else {
int i, k;
char buf[SIZ];
cit_uint8_t ch;
- char allkeys[SIZ];
- char display_name[SIZ];
+ char allkeys[30];
+ char display_name[256];
char *mptr;
char *nl; /* newline string */
int suppress_f = 0;
int subject_found = 0;
+ struct ma_info *ma;
- /* buffers needed for RFC822 translation */
- char suser[SIZ];
- char luser[SIZ];
- char fuser[SIZ];
- char snode[SIZ];
- char lnode[SIZ];
- char mid[SIZ];
- char datestamp[SIZ];
- /* */
+ /* Buffers needed for RFC822 translation. These are all filled
+ * using functions that are bounds-checked, and therefore we can
+ * make them substantially smaller than SIZ.
+ */
+ char suser[100];
+ char luser[100];
+ char fuser[100];
+ char snode[100];
+ char lnode[100];
+ char mid[100];
+ char datestamp[100];
lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %ld, %d, %d, %d, %d\n",
((TheMessage == NULL) ? "NULL" : "not null"),
} else {
/* Parse the message text component */
mptr = TheMessage->cm_fields['M'];
- mime_parser(mptr, NULL,
- *mime_download, NULL, NULL,
- NULL, 0);
+ 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);
/* If there's no file open by this time, the requested
* section wasn't found, so print an error
*/
if (do_proto) cprintf(
"%d Section %s not found.\n",
ERROR + FILE_NOT_FOUND,
- desired_section);
+ CC->download_desired_section);
}
}
return((CC->download_fp != NULL) ? om_ok : om_mime_error);
/* nhdr=yes means that we're only displaying headers, no body */
if ( (TheMessage->cm_anon_type == MES_ANONONLY)
- && (mode == MT_CITADEL)
+ && (mode == MT_CITADEL)
&& (do_proto)
) {
cprintf("nhdr=yes\n");
if ((mode == MT_CITADEL) || (mode == MT_MIME)) {
- strcpy(display_name, "<unknown>");
+ safestrncpy(display_name, "<unknown>", sizeof display_name);
if (TheMessage->cm_fields['A']) {
strcpy(buf, TheMessage->cm_fields['A']);
if (TheMessage->cm_anon_type == MES_ANONONLY) {
- strcpy(display_name, "****");
+ safestrncpy(display_name, "****", sizeof display_name);
}
else if (TheMessage->cm_anon_type == MES_ANONOPT) {
- strcpy(display_name, "anonymous");
+ safestrncpy(display_name, "anonymous", sizeof display_name);
}
else {
- strcpy(display_name, buf);
+ safestrncpy(display_name, buf, sizeof display_name);
}
if ((is_room_aide())
&& ((TheMessage->cm_anon_type == MES_ANONONLY)
}
/* Now spew the header fields in the order we like them. */
- strcpy(allkeys, FORDER);
+ safestrncpy(allkeys, FORDER, sizeof allkeys);
for (i=0; i<strlen(allkeys); ++i) {
k = (int) allkeys[i];
if (k != 'M') {
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;
safestrncpy(lnode, mptr, sizeof lnode);
else if (i == 'F')
safestrncpy(fuser, mptr, sizeof fuser);
- else if (i == 'O')
+ /* else if (i == 'O')
cprintf("X-Citadel-Room: %s%s",
- mptr, nl);
+ mptr, nl); */
else if (i == 'N')
safestrncpy(snode, mptr, sizeof snode);
else if (i == 'R')
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);
+ 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: 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", 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", suser, snode, luser, nl);
+ cprintf("From: \"%s\" <%s@%s>%s", luser, suser, snode, nl);
}
cprintf("Organization: %s%s", lnode, nl);
if (TheMessage->cm_format_type == FMT_RFC822) {
if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
mime_parser(mptr, NULL,
- *list_this_part,
- *list_this_pref,
- *list_this_suff,
+ (do_proto ? *list_this_part : NULL),
+ (do_proto ? *list_this_pref : NULL),
+ (do_proto ? *list_this_suff : NULL),
NULL, 0);
}
else if (mode == MT_RFC822) { /* unparsed RFC822 dump */
* we use will display those parts as-is.
*/
if (TheMessage->cm_format_type == FMT_RFC822) {
- CtdlAllocUserData(SYM_MA_INFO, sizeof(struct ma_info));
+ ma = malloc(sizeof(struct ma_info));
memset(ma, 0, sizeof(struct ma_info));
if (mode == MT_MIME) {
strcpy(ma->chosen_part, "1");
mime_parser(mptr, NULL,
*choose_preferred, *fixed_output_pre,
- *fixed_output_post, NULL, 0);
+ *fixed_output_post, (void *)ma, 0);
mime_parser(mptr, NULL,
- *output_preferred, NULL, NULL, NULL, 0);
+ *output_preferred, NULL, NULL, (void *)ma, 0);
}
else {
mime_parser(mptr, NULL,
*fixed_output, *fixed_output_pre,
- *fixed_output_post, NULL, 0);
+ *fixed_output_post, (void *)ma, 0);
}
+
+ free(ma);
}
DONE: /* now we're done */
void cmd_opna(char *cmdbuf)
{
long msgid;
-
- CtdlAllocUserData(SYM_DESIRED_SECTION, SIZ);
+ char desired_section[128];
msgid = extract_long(cmdbuf, 0);
- extract(desired_section, cmdbuf, 1);
-
+ 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);
}
int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int flags) {
int i;
char hold_rm[ROOMNAMELEN];
- struct cdbdata *cdbfr;
- int num_msgs;
- long *msglist;
- long highest_msg = 0L;
+ struct cdbdata *cdbfr;
+ int num_msgs;
+ long *msglist;
+ long highest_msg = 0L;
struct CtdlMessage *msg = NULL;
lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
return(ERROR + ROOM_NOT_FOUND);
}
- cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
- if (cdbfr == NULL) {
- msglist = NULL;
- num_msgs = 0;
- } else {
- msglist = malloc(cdbfr->len);
- if (msglist == NULL)
- lprintf(CTDL_ALERT, "ERROR malloc msglist!\n");
- num_msgs = cdbfr->len / sizeof(long);
- memcpy(msglist, cdbfr->ptr, cdbfr->len);
- cdb_free(cdbfr);
- }
+ cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
+ if (cdbfr == NULL) {
+ msglist = NULL;
+ num_msgs = 0;
+ } else {
+ msglist = malloc(cdbfr->len);
+ if (msglist == NULL)
+ lprintf(CTDL_ALERT, "ERROR malloc msglist!\n");
+ num_msgs = cdbfr->len / sizeof(long);
+ memcpy(msglist, cdbfr->ptr, cdbfr->len);
+ cdb_free(cdbfr);
+ }
/* Make sure the message doesn't already exist in this room. It
* is absolutely taboo to have more than one reference to the same
* message in a room.
*/
- if (num_msgs > 0) for (i=0; i<num_msgs; ++i) {
+ if (num_msgs > 0) for (i=0; i<num_msgs; ++i) {
if (msglist[i] == msgid) {
lputroom(&CC->room); /* unlock the room */
getroom(&CC->room, hold_rm);
}
}
- /* Now add the new message */
- ++num_msgs;
- msglist = realloc(msglist, (num_msgs * sizeof(long)));
+ /* Now add the new message */
+ ++num_msgs;
+ msglist = realloc(msglist, (num_msgs * sizeof(long)));
- if (msglist == NULL) {
- lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
- }
- msglist[num_msgs - 1] = msgid;
+ if (msglist == NULL) {
+ lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
+ }
+ msglist[num_msgs - 1] = msgid;
- /* Sort the message list, so all the msgid's are in order */
- num_msgs = sort_msglist(msglist, num_msgs);
+ /* Sort the message list, so all the msgid's are in order */
+ num_msgs = sort_msglist(msglist, num_msgs);
- /* Determine the highest message number */
- highest_msg = msglist[num_msgs - 1];
+ /* Determine the highest message number */
+ highest_msg = msglist[num_msgs - 1];
- /* Write it back to disk. */
- cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
- msglist, (int)(num_msgs * sizeof(long)));
+ /* Write it back to disk. */
+ cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
+ msglist, (int)(num_msgs * sizeof(long)));
- /* Free up the memory we used. */
- free(msglist);
+ /* Free up the memory we used. */
+ free(msglist);
/* Update the highest-message pointer and unlock the room. */
CC->room.QRhighest = highest_msg;
/* Return success. */
if (msg != NULL) CtdlFreeMessage(msg);
- return (0);
+ return (0);
}
long send_message(struct CtdlMessage *msg) {
long newmsgid;
long retval;
- char msgidbuf[SIZ];
- struct ser_ret smr;
+ char msgidbuf[256];
+ struct ser_ret smr;
int is_bigmsg = 0;
char *holdM = NULL;
}
/* Serialize our data structure for storage in the database */
- serialize_message(&smr, msg);
+ serialize_message(&smr, msg);
if (is_bigmsg) {
msg->cm_fields['M'] = holdM;
}
- if (smr.len == 0) {
- cprintf("%d Unable to serialize message\n",
- ERROR + INTERNAL_ERROR);
- return (-1L);
- }
+ if (smr.len == 0) {
+ cprintf("%d Unable to serialize message\n",
+ ERROR + INTERNAL_ERROR);
+ return (-1L);
+ }
/* Write our little bundle of joy into the message base */
if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
}
/* Free the memory we used for the serialized message */
- free(smr.ser);
+ free(smr.ser);
/* Return the *local* message ID to the caller
* (even if we're storing an incoming network message)
* Back end for the ReplicationChecks() function
*/
void check_repl(long msgnum, void *userdata) {
- struct CtdlMessage *msg;
- time_t timestamp = (-1L);
-
- lprintf(CTDL_DEBUG, "check_repl() found message %ld\n", msgnum);
- msg = CtdlFetchMessage(msgnum, 1);
- if (msg == NULL) return;
- if (msg->cm_fields['T'] != NULL) {
- timestamp = atol(msg->cm_fields['T']);
- }
- CtdlFreeMessage(msg);
-
- if (timestamp > msg_repl->highest) {
- msg_repl->highest = timestamp; /* newer! */
- lprintf(CTDL_DEBUG, "newer!\n");
- return;
- }
- lprintf(CTDL_DEBUG, "older!\n");
-
- /* Existing isn't newer? Then delete the old one(s). */
- CtdlDeleteMessages(CC->room.QRname, msgnum, "");
+ lprintf(CTDL_DEBUG, "check_repl() replacing message %ld\n", msgnum);
+ CtdlDeleteMessages(CC->room.QRname, msgnum, "", 0);
}
/*
* Check to see if any messages already exist which carry the same Exclusive ID
- * as this one.
+ * as this one. If any are found, delete them.
*
- * If any are found:
- * -> With older timestamps: delete them and return 0. Message will be saved.
- * -> With newer timestamps: return 1. Message save will be aborted.
*/
int ReplicationChecks(struct CtdlMessage *msg) {
struct CtdlMessage *template;
int abort_this = 0;
- lprintf(CTDL_DEBUG, "ReplicationChecks() started\n");
/* 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']);
- CtdlAllocUserData(SYM_REPL, sizeof(struct repl));
- strcpy(msg_repl->exclusive_id, msg->cm_fields['E']);
- msg_repl->highest = atol(msg->cm_fields['T']);
-
template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
template->cm_fields['E'] = strdup(msg->cm_fields['E']);
CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
- /* If a newer message exists with the same Exclusive ID, abort
- * this save.
- */
- if (msg_repl->highest > atol(msg->cm_fields['T']) ) {
- abort_this = 1;
- }
-
CtdlFreeMessage(template);
lprintf(CTDL_DEBUG, "ReplicationChecks() returning %d\n", abort_this);
return(abort_this);
* Save a message to disk and submit it into the delivery system.
*/
long CtdlSubmitMsg(struct CtdlMessage *msg, /* message to save */
- struct recptypes *recps, /* recipients (if mail) */
+ struct recptypes *recps_to, /* To: recipients (if mail) */
+ struct recptypes *recps_cc, /* Cc: recipients (if mail) */
+ struct recptypes *recps_bcc, /* Bcc: recipients (if mail) */
char *force /* force a particular room? */
) {
- char aaa[SIZ];
+ char submit_filename[128];
+ char generated_timestamp[32];
char hold_rm[ROOMNAMELEN];
char actual_rm[ROOMNAMELEN];
char force_room[ROOMNAMELEN];
char *instr;
struct ser_ret smr;
char *hold_R, *hold_D;
+ int is_internet_mail = 0;
+ int force_to_sent = 0; /* Force to 'sent items' room */
+ size_t tmp;
lprintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
if (is_valid_message(msg) == 0) return(-1); /* self check */
*/
if (msg->cm_fields['T'] == NULL) {
lprintf(CTDL_DEBUG, "Generating timestamp\n");
- snprintf(aaa, sizeof aaa, "%ld", (long)time(NULL));
- msg->cm_fields['T'] = strdup(aaa);
+ snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
+ msg->cm_fields['T'] = strdup(generated_timestamp);
}
/* If this message has no path, we generate one.
lprintf(CTDL_DEBUG, "Learning what's inside\n");
if (msg->cm_fields['M'] == NULL) {
lprintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
- return(-1);
+ return(-2);
}
switch (msg->cm_format_type) {
break;
case 4:
strcpy(content_type, "text/plain");
- /* advance past header fields */
- mptr = msg->cm_fields['M'];
- a = strlen(mptr);
- while ((--a) > 0) {
- if (!strncasecmp(mptr, "Content-type: ", 14)) {
- safestrncpy(content_type, mptr,
- sizeof(content_type));
- strcpy(content_type, &content_type[14]);
- for (a = 0; a < strlen(content_type); ++a)
- if ((content_type[a] == ';')
- || (content_type[a] == ' ')
- || (content_type[a] == 13)
- || (content_type[a] == 10))
- content_type[a] = 0;
- break;
+ mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type: ");
+ if (mptr != NULL) {
+ safestrncpy(content_type, &mptr[14],
+ sizeof content_type);
+ for (a = 0; a < strlen(content_type); ++a) {
+ if ((content_type[a] == ';')
+ || (content_type[a] == ' ')
+ || (content_type[a] == 13)
+ || (content_type[a] == 10)) {
+ content_type[a] = 0;
+ }
}
- ++mptr;
}
}
/* Goto the correct room */
- lprintf(CTDL_DEBUG, "Selected room %s\n", (recps) ? CC->room.QRname : SENTITEMS);
+ force_to_sent = 0;
+ if (recps_to) force_to_sent = 1;
+ if (recps_cc) force_to_sent = 1;
+ if (recps_bcc) force_to_sent = 1;
strcpy(hold_rm, CC->room.QRname);
strcpy(actual_rm, CC->room.QRname);
- if (recps != NULL) {
+ if (force_to_sent) {
strcpy(actual_rm, SENTITEMS);
}
+ lprintf(CTDL_DEBUG, "Selected room %s\n", actual_rm);
/* If the user is a twit, move to the twit room for posting */
lprintf(CTDL_DEBUG, "Handling twit stuff: %s\n",
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);
}
/*
/* Perform "before save" hooks (aborting if any return nonzero) */
lprintf(CTDL_DEBUG, "Performing before-save hooks\n");
- if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
+ if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
/* If this message has an Exclusive ID, perform replication checks */
lprintf(CTDL_DEBUG, "Performing replication checks\n");
- if (ReplicationChecks(msg) > 0) return(-1);
+ if (ReplicationChecks(msg) > 0) return(-4);
/* Save it to disk */
lprintf(CTDL_DEBUG, "Saving to disk\n");
newmsgid = send_message(msg);
- if (newmsgid <= 0L) return(-1);
+ if (newmsgid <= 0L) return(-5);
/* Write a supplemental message info record. This doesn't have to
* be a critical section because nobody else knows about this message
memset(&smi, 0, sizeof(struct MetaData));
smi.meta_msgnum = newmsgid;
smi.meta_refcount = 0;
- safestrncpy(smi.meta_content_type, content_type, sizeof smi.meta_content_type);
+ 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.
+ */
+
+ if (CC->redirect_buffer != NULL) {
+ lprintf(CTDL_ALERT, "CC->redirect_buffer is not NULL during message submission!\n");
+ abort();
+ }
+ CC->redirect_buffer = malloc(SIZ);
+ CC->redirect_len = 0;
+ CC->redirect_alloc = SIZ;
+ CtdlOutputPreLoadedMsg(msg, 0L, MT_RFC822, HEADERS_ALL, 0, 1);
+ smi.meta_rfc822_length = CC->redirect_len;
+ free(CC->redirect_buffer);
+ CC->redirect_buffer = NULL;
+ CC->redirect_len = 0;
+ CC->redirect_alloc = 0;
+
PutMetaData(&smi);
/* Now figure out where to store the pointers */
* message, we want to BYPASS saving the sender's copy (because there
* is no local sender; it would otherwise go to the Trashcan).
*/
- if ((!CC->internal_pgm) || (recps == NULL)) {
+ if ((!CC->internal_pgm) || ((recps_to == NULL) && (recps_cc == NULL) && (recps_bcc == NULL))) {
if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0) != 0) {
lprintf(CTDL_ERR, "ERROR saving message pointer!\n");
- CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom,
+ newmsgid, 0);
}
}
/* For internet mail, drop a copy in the outbound queue room */
- if (recps != NULL)
- if (recps->num_internet > 0) {
+ is_internet_mail = 0;
+ if (recps_to != NULL) is_internet_mail = recps_to->num_internet;
+ if (recps_cc != NULL) is_internet_mail = recps_cc->num_internet;
+ if (recps_bcc != NULL) is_internet_mail = recps_bcc->num_internet;
+ if (is_internet_mail) {
CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, newmsgid, 0);
}
- /* If other rooms are specified, drop them there too. */
- if (recps != NULL)
- if (recps->num_room > 0)
- for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
- extract(recipient, recps->recp_room, i);
- lprintf(CTDL_DEBUG, "Delivering to local room <%s>\n", recipient);
+ /* If other rooms are specified in the To: field, drop them there too. */
+ /******* FIXME FIXME ADD CC AND BCC HERE *********/
+ if (recps_to != NULL)
+ if (recps_to->num_room > 0)
+ for (i=0; i<num_tokens(recps_to->recp_room, '|'); ++i) {
+ extract_token(recipient, recps_to->recp_room, i,
+ '|', sizeof recipient);
+ lprintf(CTDL_DEBUG, "Delivering to room <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
}
/* If this is private, local mail, make a copy in the
* recipient's mailbox and bump the reference count.
*/
- if (recps != NULL)
- if (recps->num_local > 0)
- for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
- extract(recipient, recps->recp_local, i);
+ /******* FIXME FIXME ADD CC AND BCC HERE *********/
+ if (recps_to != NULL)
+ if (recps_to->num_local > 0)
+ for (i=0; i<num_tokens(recps_to->recp_local, '|'); ++i) {
+ extract_token(recipient, recps_to->recp_local, i,
+ '|', sizeof recipient);
lprintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
recipient);
if (getuser(&userbuf, recipient) == 0) {
- MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
+ MailboxName(actual_rm, sizeof actual_rm,
+ &userbuf, MAILROOM);
CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
BumpNewMailCounter(userbuf.usernum);
}
else {
lprintf(CTDL_DEBUG, "No user <%s>\n", recipient);
- CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom,
+ newmsgid, 0);
}
}
* node. We'll revisit this again in a year or so when everyone has
* a network spool receiver that can handle the new style messages.
*/
- if (recps != NULL)
- if (recps->num_ignet > 0)
- for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
- extract(recipient, recps->recp_ignet, i);
+ /******* FIXME FIXME ADD CC AND BCC HERE *********/
+ if (recps_to != NULL)
+ if (recps_to->num_ignet > 0)
+ for (i=0; i<num_tokens(recps_to->recp_ignet, '|'); ++i) {
+ extract_token(recipient, recps_to->recp_ignet, i,
+ '|', sizeof recipient);
hold_R = msg->cm_fields['R'];
hold_D = msg->cm_fields['D'];
msg->cm_fields['R'] = malloc(SIZ);
- msg->cm_fields['D'] = malloc(SIZ);
- extract_token(msg->cm_fields['R'], recipient, 0, '@');
- extract_token(msg->cm_fields['D'], recipient, 1, '@');
+ msg->cm_fields['D'] = malloc(128);
+ extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
+ extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
serialize_message(&smr, msg);
if (smr.len > 0) {
- snprintf(aaa, sizeof aaa,
- "./network/spoolin/netmail.%04lx.%04x.%04x",
- (long) getpid(), CC->cs_pid, ++seqnum);
- network_fp = fopen(aaa, "wb+");
+ snprintf(submit_filename, sizeof submit_filename,
+#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);
fclose(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
* not happen because the delivery instructions message does not
- * contain a recipient.
+ * have any recipients.
*/
- if (recps != NULL)
- if (recps->num_internet > 0) {
+ if (is_internet_mail) {
lprintf(CTDL_DEBUG, "Generating delivery instructions\n");
- instr = malloc(SIZ * 2);
- snprintf(instr, SIZ * 2,
+ instr = malloc(SIZ * 4);
+ snprintf(instr, SIZ * 4,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|%s@%s\n",
SPOOLMIME, newmsgid, (long)time(NULL),
msg->cm_fields['A'], msg->cm_fields['N']
);
- for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
- size_t tmp = strlen(instr);
- extract(recipient, recps->recp_internet, i);
- snprintf(&instr[tmp], SIZ * 2 - tmp,
- "remote|%s|0||\n", recipient);
+ if (recps_to) if (strlen(recps_to->recp_internet) > 0) {
+ for (i=0; i<num_tokens(recps_to->recp_internet, '|'); ++i) {
+ tmp = strlen(instr);
+ extract_token(recipient, recps_to->recp_internet, i, '|', sizeof recipient);
+ snprintf(&instr[tmp], SIZ * 4 - tmp,
+ "remote|%s|0||\n", recipient);
+ }
}
- imsg = malloc(sizeof(struct CtdlMessage));
+ if (recps_cc) if (strlen(recps_cc->recp_internet) > 0) {
+ for (i=0; i<num_tokens(recps_cc->recp_internet, '|'); ++i) {
+ tmp = strlen(instr);
+ extract_token(recipient, recps_cc->recp_internet, i, '|', sizeof recipient);
+ snprintf(&instr[tmp], SIZ * 4 - tmp,
+ "remote|%s|0||\n", recipient);
+ }
+ }
+
+ if (recps_bcc) if (strlen(recps_bcc->recp_internet) > 0) {
+ for (i=0; i<num_tokens(recps_bcc->recp_internet, '|'); ++i) {
+ tmp = strlen(instr);
+ extract_token(recipient, recps_bcc->recp_internet, i, '|', sizeof recipient);
+ snprintf(&instr[tmp], SIZ * 4 - tmp,
+ "remote|%s|0||\n", recipient);
+ }
+ }
+
+ imsg = malloc(sizeof(struct CtdlMessage));
memset(imsg, 0, sizeof(struct CtdlMessage));
imsg->cm_magic = CTDLMESSAGE_MAGIC;
imsg->cm_anon_type = MES_NORMAL;
imsg->cm_format_type = FMT_RFC822;
imsg->cm_fields['A'] = strdup("Citadel");
imsg->cm_fields['M'] = instr;
- CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
+ CtdlSubmitMsg(imsg, NULL, NULL, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
}
}
msg->cm_fields['M'] = strdup(text);
- CtdlSubmitMsg(msg, recp, room);
+ CtdlSubmitMsg(msg, recp, NULL, NULL, room);
CtdlFreeMessage(msg);
if (recp != NULL) free(recp);
}
exist is ALWAYS freed */
int crlf /* CRLF newlines instead of LF */
) {
- char buf[SIZ];
+ char buf[1024];
int linelen;
size_t message_len = 0;
size_t buffer_len = 0;
/* read in the lines of message text one by one */
do {
- if (client_gets(buf) < 1) finished = 1;
+ if (client_getln(buf, (sizeof buf - 3)) < 1) finished = 1;
if (!strcmp(buf, terminator)) finished = 1;
if (crlf) {
strcat(buf, "\r\n");
}
if (num_recps > 0) for (i=0; i<num_recps; ++i) {
- extract_token(this_recp, recipients, i, ',');
+ extract_token(this_recp, recipients, i, ',', sizeof this_recp);
striplt(this_recp);
lprintf(CTDL_DEBUG, "Evaluating recipient #%d <%s>\n", i, this_recp);
mailtype = alias(this_recp);
{
int post = 0;
char recp[SIZ];
+ char cc[SIZ];
+ char bcc[SIZ];
char masquerade_as[SIZ];
int anon_flag = 0;
int format_type = 0;
int anonymous = 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;
unbuffer_output();
post = extract_int(entargs, 0);
- extract(recp, entargs, 1);
+ extract_token(recp, entargs, 1, '|', sizeof recp);
anon_flag = extract_int(entargs, 2);
format_type = extract_int(entargs, 3);
- extract(subject, entargs, 4);
+ 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. */
ERROR + HIGHER_ACCESS_REQUIRED);
return;
}
- extract(newusername, entargs, 5);
+ extract_token(newusername, entargs, 5, '|', sizeof newusername);
memset(CC->fake_postname, 0, sizeof(CC->fake_postname) );
safestrncpy(CC->fake_postname, newusername,
sizeof(CC->fake_postname) );
strcpy(recp, "sysop");
}
- valid = validate_recipients(recp);
- if (valid->num_error > 0) {
+ valid_to = validate_recipients(recp);
+ if (valid_to->num_error > 0) {
+ cprintf("%d %s\n",
+ ERROR + NO_SUCH_USER, valid_to->errormsg);
+ free(valid_to);
+ return;
+ }
+
+ valid_cc = validate_recipients(cc);
+ if (valid_cc->num_error > 0) {
cprintf("%d %s\n",
- ERROR + NO_SUCH_USER, valid->errormsg);
- free(valid);
+ ERROR + NO_SUCH_USER, valid_cc->errormsg);
+ free(valid_to);
+ free(valid_cc);
return;
}
- if (valid->num_internet > 0) {
+
+ valid_bcc = validate_recipients(bcc);
+ if (valid_bcc->num_error > 0) {
+ cprintf("%d %s\n",
+ ERROR + NO_SUCH_USER, valid_bcc->errormsg);
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
+ 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;
}
masquerade_as, subject, NULL);
if (msg != NULL) {
- msgnum = CtdlSubmitMsg(msg, valid, "");
+ msgnum = CtdlSubmitMsg(msg, valid_to, valid_cc, valid_bcc, "");
if (do_confirm) {
cprintf("%ld\n", msgnum);
else {
cprintf("Internal error.\n");
}
+ if (msg->cm_fields['E'] != NULL) {
+ cprintf("%s\n", msg->cm_fields['E']);
+ } else {
+ cprintf("\n");
+ }
cprintf("000\n");
}
CtdlFreeMessage(msg);
}
CC->fake_postname[0] = '\0';
- free(valid);
+ free(valid_to);
+ free(valid_cc);
+ free(valid_bcc);
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,
void cmd_move(char *args)
{
long num;
- char targ[SIZ];
+ char targ[ROOMNAMELEN];
struct ctdlroom qtemp;
int err;
int is_copy = 0;
int permit = 0;
num = extract_long(args, 0);
- extract(targ, args, 1);
+ extract_token(targ, args, 1, '|', sizeof targ);
targ[ROOMNAMELEN - 1] = 0;
is_copy = extract_int(args, 2);
* 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") );
/*
* AdjRefCount - change the reference count for a message;
- * delete the message if it reaches zero
+ * delete the message if it reaches zero
*/
void AdjRefCount(long msgnum, int incr)
{
*/
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).
+ * FIXME ... defer this so it doesn't keep the user waiting.
*/
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);
+ CtdlSubmitMsg(msg, NULL, NULL, NULL, roomname);
CtdlFreeMessage(msg);
}
conf = NULL;
}
else {
- msg = CtdlFetchMessage(msgnum, 1);
- if (msg != NULL) {
- conf = strdup(msg->cm_fields['M']);
- CtdlFreeMessage(msg);
+ msg = CtdlFetchMessage(msgnum, 1);
+ if (msg != NULL) {
+ conf = strdup(msg->cm_fields['M']);
+ CtdlFreeMessage(msg);
}
else {
conf = NULL;
getroom(&CC->room, hold_rm);
if (conf != NULL) do {
- extract_token(buf, conf, 0, '\n');
+ extract_token(buf, conf, 0, '\n', sizeof buf);
strcpy(conf, &conf[strlen(buf)+1]);
} while ( (strlen(conf)>0) && (strlen(buf)>0) );
/*
* Determine whether a given Internet address belongs to the current user
*/
-int CtdlIsMe(char *addr) {
+int CtdlIsMe(char *addr, int addr_buf_len)
+{
struct recptypes *recp;
int i;
}
for (i=0; i<recp->num_local; ++i) {
- extract(addr, recp->recp_local, i);
+ extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
if (!strcasecmp(addr, CC->user.fullname)) {
free(recp);
return(1);
* Citadel protocol command to do the same
*/
void cmd_isme(char *argbuf) {
- char addr[SIZ];
+ char addr[256];
if (CtdlAccessCheck(ac_logged_in)) return;
- extract(addr, argbuf, 0);
+ extract_token(addr, argbuf, 0, '|', sizeof addr);
- if (CtdlIsMe(addr)) {
+ if (CtdlIsMe(addr, sizeof addr)) {
cprintf("%d %s\n", CIT_OK, addr);
}
else {