#include <sys/stat.h>
#include <sys/types.h>
#include <regex.h>
+#include <libcitadel.h>
#include "citadel.h"
#include "server.h"
#include "serv_extensions.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"
#include "journaling.h"
#include "citadel_dirs.h"
+#include "clientsocket.h"
#include "serv_network.h"
-
-#ifdef HAVE_LIBSIEVE
-# include "serv_sieve.h"
-#endif /* HAVE_LIBSIEVE */
+#include "threads.h"
long config_msgnum;
struct addresses_to_be_filed *atbf = NULL;
"time",
"subj",
NULL,
- NULL,
+ "wefw",
NULL,
"cccc",
NULL
char testnode[64];
char buf[SIZ];
+ char original_name[256];
+ safestrncpy(original_name, name, sizeof original_name);
+
striplt(name);
remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
stripallbut(name, '<', '>');
strcpy(name, aaa);
}
- lprintf(CTDL_INFO, "Mail is being forwarded to %s\n", name);
+ if (strcasecmp(original_name, name)) {
+ CtdlLogPrintf(CTDL_INFO, "%s is being forwarded to %s\n", original_name, name);
+ }
/* Change "user @ xxx" to "user" if xxx is an alias for this host */
for (a=0; a<strlen(name); ++a) {
if (name[a] == '@') {
if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
name[a] = 0;
- lprintf(CTDL_INFO, "Changed to <%s>\n", name);
+ CtdlLogPrintf(CTDL_INFO, "Changed to <%s>\n", name);
}
}
}
return;
}
- lprintf(CTDL_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %d, %d)\n",
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %d, %d)\n",
num_target_msgnums, target_msgnums[0],
target_setting, which_set);
break;
}
- /* lprintf(CTDL_DEBUG, "before optimize: %s\n", vset); */
+ /* CtdlLogPrintf(CTDL_DEBUG, "before optimize: %s\n", vset); */
/* Translate the existing sequence set into an array of booleans */
num_sets = num_tokens(vset, ',');
}
free(is_set);
- /* lprintf(CTDL_DEBUG, " after optimize: %s\n", vset); */
+ /* CtdlLogPrintf(CTDL_DEBUG, " after optimize: %s\n", vset); */
free(msglist);
CtdlSetRelationship(&vbuf,
((which_user != NULL) ? which_user : &CC->user),
int num_search_msgs = 0;
long *search_msgs = NULL;
regex_t re;
+ int need_to_free_re = 0;
regmatch_t pm;
- if (content_type) if (strlen(content_type) > 0) {
+ if (content_type) if (!IsEmptyStr(content_type)) {
regcomp(&re, content_type, 0);
+ need_to_free_re = 1;
}
/* Learn about the user and room in question */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
msglist = (long *) cdbfr->ptr;
- cdbfr->ptr = NULL; /* CtdlForEachMessage() now owns this memory */
num_msgs = cdbfr->len / sizeof(long);
- cdb_free(cdbfr);
} else {
+ if (need_to_free_re) regfree(&re);
return 0; /* No messages at all? No further action. */
}
/* If the caller is looking for a specific MIME type, filter
* out all messages which are not of the type requested.
*/
- if (content_type != NULL) if (strlen(content_type) > 0) {
+ if (content_type != NULL) if (!IsEmptyStr(content_type)) {
/* This call to GetMetaData() sits inside this loop
* so that we only do the extra database read per msg
* over again.
*/
if ( (num_msgs > 0) && (mode == MSGS_SEARCH) && (search_string) ) {
- ft_search(&num_search_msgs, &search_msgs, search_string);
+
+ /* Call search module via hook mechanism.
+ * NULL means use any search function available.
+ * otherwise replace with a char * to name of search routine
+ */
+ CtdlModuleDoSearch(&num_search_msgs, &search_msgs, search_string, "fulltext");
+
if (num_search_msgs > 0) {
int orig_num_msgs;
++num_processed;
}
}
- free(msglist); /* Clean up */
+ cdb_free(cdbfr); /* Clean up */
+ if (need_to_free_re) regfree(&re);
return num_processed;
}
help_subst(buffer, "^variantname", CITADEL);
snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
help_subst(buffer, "^maxsessions", buf2);
- help_subst(buffer, "^bbsdir", ctdl_bbsbase_dir);
+ help_subst(buffer, "^bbsdir", ctdl_message_dir);
}
*found_it = 1;
- cprintf("%d %d\n", BINARY_FOLLOWS, length);
+ cprintf("%d %d\n", BINARY_FOLLOWS, (int)length);
client_write(content, length);
}
cit_uint8_t ch;
cit_uint8_t field_header;
- lprintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
if (dmsgtext == NULL) {
*/
ch = *mptr++;
if (ch != 255) {
- lprintf(CTDL_ERR,
- "Message %ld appears to be corrupted.\n",
- msgnum);
+ CtdlLogPrintf(CTDL_ERR, "Message %ld appears to be corrupted.\n", msgnum);
cdb_free(dmsgtext);
return NULL;
}
if (msg == NULL)
return 0;
if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
- lprintf(CTDL_WARNING, "is_valid_message() -- self-check failed\n");
+ CtdlLogPrintf(CTDL_WARNING, "is_valid_message() -- self-check failed\n");
return 0;
}
return 1;
struct ma_info *ma;
ma = (struct ma_info *)cbuserdata;
- lprintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
+ CtdlLogPrintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
if (!strcasecmp(cbtype, "multipart/alternative")) {
++ma->is_ma;
ma->did_print = 0;
struct ma_info *ma;
ma = (struct ma_info *)cbuserdata;
- lprintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
+ CtdlLogPrintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
if (!strcasecmp(cbtype, "multipart/alternative")) {
--ma->is_ma;
ma->did_print = 0;
ma = (struct ma_info *)cbuserdata;
- lprintf(CTDL_DEBUG,
+ CtdlLogPrintf(CTDL_DEBUG,
"fixed_output() part %s: %s (%s) (%ld bytes)\n",
partnum, filename, cbtype, (long)length);
* 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);
+ CtdlLogPrintf(CTDL_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
return;
}
ma->did_print = 1;
if ( (!strcasecmp(cbtype, "text/plain"))
- || (strlen(cbtype)==0) ) {
+ || (IsEmptyStr(cbtype)) ) {
wptr = content;
if (length > 0) {
client_write(wptr, length);
ma = (struct ma_info *)cbuserdata;
- 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)) && (!ma->freeze) ) {
- if (i < ma->chosen_pref) {
- safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
- ma->chosen_pref = i;
- }
+ // NOTE: REMOVING THIS CONDITIONAL FIXES BUG 220
+ // http://bugzilla.citadel.org/show_bug.cgi?id=220
+ // I don't know if there are any side effects! Please TEST TEST TEST
+ //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)) && (!ma->freeze) ) {
+ if (i < ma->chosen_pref) {
+ CtdlLogPrintf(CTDL_DEBUG, "Setting chosen part: <%s>\n", partnum);
+ safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
+ ma->chosen_pref = i;
}
}
}
if (text_content[length-1] != '\n') {
++add_newline;
}
-
cprintf("Content-type: %s", cbtype);
- if (strlen(cbcharset) > 0) {
+ if (!IsEmptyStr(cbcharset)) {
cprintf("; charset=%s", cbcharset);
}
cprintf("\nContent-length: %d\n",
(int)(length + add_newline) );
- if (strlen(encoding) > 0) {
+ if (!IsEmptyStr(encoding)) {
cprintf("Content-transfer-encoding: %s\n", encoding);
}
else {
cprintf("Content-transfer-encoding: 7bit\n");
}
+ cprintf("X-Citadel-MSG4-Partnum: %s\n", partnum);
cprintf("\n");
client_write(content, length);
if (add_newline) cprintf("\n");
int retcode = om_no_such_msg;
struct encapmsg encap;
- lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d, section=%s\n",
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d, section=%s\n",
msg_num, mode,
(section ? section : "<>")
);
/* 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")) {
+ if (section) if (!IsEmptyStr(section)) if (strcmp(section, "0")) {
memset(&encap, 0, sizeof encap);
safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
mime_parser(TheMessage->cm_fields['M'],
}
/* Ok, output the message now */
- retcode = CtdlOutputPreLoadedMsg(
- TheMessage, mode,
- headers_only, do_proto, crlf);
+ retcode = CtdlOutputPreLoadedMsg(TheMessage, mode, headers_only, do_proto, crlf);
CtdlFreeMessage(TheMessage);
return(retcode);
/*
* Get a message off disk. (returns om_* values found in msgbase.h)
- *
*/
int CtdlOutputPreLoadedMsg(
struct CtdlMessage *TheMessage,
char mid[100];
char datestamp[100];
- lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
((TheMessage == NULL) ? "NULL" : "not null"),
mode, headers_only, do_proto, crlf);
nl = (crlf ? "\r\n" : "\n");
if (!is_valid_message(TheMessage)) {
- lprintf(CTDL_ERR,
+ CtdlLogPrintf(CTDL_ERR,
"ERROR: invalid preloaded message for output\n");
return(om_no_such_msg);
}
*/
suppress_f = 0;
if (TheMessage->cm_fields['N'] != NULL)
- if (strlen(TheMessage->cm_fields['N']) > 0)
+ if (!IsEmptyStr(TheMessage->cm_fields['N']))
if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
suppress_f = 1;
}
else if (i == 'N')
safestrncpy(snode, mptr, sizeof snode);
else if (i == 'R')
- cprintf("To: %s%s", mptr, nl);
+ {
+ if (haschar(mptr, '@') == 0)
+ {
+ cprintf("To: %s@%s%s", mptr, config.c_fqdn, nl);
+ }
+ else
+ {
+ cprintf("To: %s%s", mptr, nl);
+ }
+ }
else if (i == 'T') {
datestring(datestamp, sizeof datestamp,
atol(mptr), DATESTRING_RFC822);
cprintf("Date: %s%s", datestamp, nl);
}
+ else if (i == 'W') {
+ cprintf("References: ");
+ k = num_tokens(mptr, '|');
+ for (i=0; i<k; ++i) {
+ extract_token(buf, mptr, i, '|', sizeof buf);
+ cprintf("<%s>", buf);
+ if (i == (k-1)) {
+ cprintf("%s", nl);
+ }
+ else {
+ cprintf(" ");
+ }
+ }
+ }
}
}
if (subject_found == 0) {
}
}
- for (i=0; i<strlen(suser); ++i) {
+ for (i=0; !IsEmptyStr(&suser[i]); ++i) {
suser[i] = tolower(suser[i]);
if (!isalnum(suser[i])) suser[i]='_';
}
}
/* Construct a fun message id */
- cprintf("Message-ID: <%s", mid);
+ cprintf("Message-ID: <%s", mid);/// todo: this possibly breaks threadding mails.
if (strchr(mid, '@')==NULL) {
cprintf("@%s", snode);
}
else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
cprintf("From: \"anonymous\" <x@x.org>%s", nl);
}
- else if (strlen(fuser) > 0) {
+ else if (!IsEmptyStr(fuser)) {
cprintf("From: \"%s\" <%s>%s", luser, fuser, nl);
}
else {
* what message transfer format is in use.
*/
if (TheMessage->cm_format_type == FMT_FIXED) {
+ int buflen;
if (mode == MT_MIME) {
cprintf("Content-type: text/plain\n\n");
}
- strcpy(buf, "");
+ *buf = '\0';
+ buflen = 0;
while (ch = *mptr++, ch > 0) {
if (ch == 13)
ch = 10;
- if ((ch == 10) || (strlen(buf) > 250)) {
+ if ((ch == 10) || (buflen > 250)) {
+ buf[buflen] = '\0';
cprintf("%s%s", buf, nl);
- strcpy(buf, "");
+ *buf = '\0';
+ buflen = 0;
} else {
- buf[strlen(buf) + 1] = 0;
- buf[strlen(buf)] = ch;
+ buf[buflen] = ch;
+ buflen++;
}
}
- if (strlen(buf) > 0)
+ buf[buflen] = '\0';
+ if (!IsEmptyStr(buf))
cprintf("%s%s", buf, nl);
}
*choose_preferred, *fixed_output_pre,
*fixed_output_post, (void *)&ma, 0);
mime_parser(mptr, NULL,
- *output_preferred, NULL, NULL, (void *)&ma, 0);
+ *output_preferred, NULL, NULL, (void *)&ma, CC->msg4_dont_decode);
}
else {
ma.use_fo_hooks = 1;
*/
void cmd_msgp(char *cmdbuf)
{
- safestrncpy(CC->preferred_formats, cmdbuf,
- sizeof(CC->preferred_formats));
- cprintf("%d ok\n", CIT_OK);
+ if (!strcasecmp(cmdbuf, "dont_decode")) {
+ CC->msg4_dont_decode = 1;
+ cprintf("%d MSG4 will not pre-decode messages.\n", CIT_OK);
+ }
+ else {
+ safestrncpy(CC->preferred_formats, cmdbuf, sizeof(CC->preferred_formats));
+ cprintf("%d Preferred MIME formats have been set.\n", CIT_OK);
+ }
}
long *msgs_to_be_merged = NULL;
int num_msgs_to_be_merged = 0;
- lprintf(CTDL_DEBUG,
+ CtdlLogPrintf(CTDL_DEBUG,
"CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d)\n",
roomname, num_newmsgs, do_repl_check);
if (lgetroom(&CC->room,
((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
- lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
+ CtdlLogPrintf(CTDL_ERR, "No such room <%s>\n", roomname);
return(ERROR + ROOM_NOT_FOUND);
}
}
}
- lprintf(9, "%d unique messages to be merged\n", num_msgs_to_be_merged);
+ CtdlLogPrintf(9, "%d unique messages to be merged\n", num_msgs_to_be_merged);
/*
* Now merge the new messages
*/
msglist = realloc(msglist, (sizeof(long) * (num_msgs + num_msgs_to_be_merged)) );
if (msglist == NULL) {
- lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
+ CtdlLogPrintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
}
memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
num_msgs += num_msgs_to_be_merged;
/* Perform replication checks if necessary */
if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
- lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
for (i=0; i<num_msgs_to_be_merged; ++i) {
msgid = msgs_to_be_merged[i];
}
else {
- lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
}
- /* Submit this room for net processing */
- network_queue_room(&CC->room, NULL);
-
-#ifdef HAVE_LIBSIEVE
- /* If this is someone's inbox, submit the room for sieve processing */
- if (!strcasecmp(&CC->room.QRname[11], MAILROOM)) {
- sieve_queue_room(&CC->room);
- }
-#endif /* HAVE_LIBSIEVE */
+ /* Submit this room for processing by hooks */
+ PerformRoomHooks(&CC->room);
/* Go back to the room we were in before we wandered here... */
getroom(&CC->room, hold_rm);
/* Write our little bundle of joy into the message base */
if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
smr.ser, smr.len) < 0) {
- lprintf(CTDL_ERR, "Can't store message\n");
+ CtdlLogPrintf(CTDL_ERR, "Can't store message\n");
retval = 0L;
} else {
if (is_bigmsg) {
* Check for valid message format
*/
if (is_valid_message(msg) == 0) {
- lprintf(CTDL_ERR, "serialize_message() aborting due to invalid message\n");
+ CtdlLogPrintf(CTDL_ERR, "serialize_message() aborting due to invalid message\n");
ret->len = 0;
ret->ser = NULL;
return;
ret->ser = malloc(ret->len);
if (ret->ser == NULL) {
- lprintf(CTDL_ERR, "serialize_message() malloc(%ld) failed: %s\n",
+ CtdlLogPrintf(CTDL_ERR, "serialize_message() malloc(%ld) failed: %s\n",
(long)ret->len, strerror(errno));
ret->len = 0;
ret->ser = NULL;
safestrncpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]], fieldlen+1);
wlen = wlen + fieldlen + 1;
}
- if (ret->len != wlen) lprintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
+ if (ret->len != wlen) CtdlLogPrintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
(long)ret->len, (long)wlen);
return;
}
+/*
+ * Serialize a struct CtdlMessage into the format used on disk and network.
+ *
+ * This function loads up a "struct ser_ret" (defined in server.h) which
+ * contains the length of the serialized message and a pointer to the
+ * serialized message in memory. THE LATTER MUST BE FREED BY THE CALLER.
+ */
+void dump_message(struct CtdlMessage *msg, /* unserialized msg */
+ long Siz) /* how many chars ? */
+{
+ size_t wlen;
+ int i;
+ static char *forder = FORDER;
+ char *buf;
+
+ /*
+ * Check for valid message format
+ */
+ if (is_valid_message(msg) == 0) {
+ CtdlLogPrintf(CTDL_ERR, "dump_message() aborting due to invalid message\n");
+ return;
+ }
+
+ buf = (char*) malloc (Siz + 1);
+
+ wlen = 3;
+
+ for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
+ snprintf (buf, Siz, " msg[%c] = %s ...\n", (char) forder[i],
+ msg->cm_fields[(int)forder[i]]);
+ client_write (buf, strlen(buf));
+ }
+
+ return;
+}
+
+
/*
* Check to see if any messages already exist in the current room which
if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
- lprintf(CTDL_DEBUG, "Performing replication checks in <%s>\n",
+ CtdlLogPrintf(CTDL_DEBUG, "Performing replication checks in <%s>\n",
CC->room.QRname);
/* No exclusive id? Don't do anything. */
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",
+ if (IsEmptyStr(msg->cm_fields['E'])) return;
+ /*CtdlLogPrintf(CTDL_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
msg->cm_fields['E'], CC->room.QRname);*/
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);
+ CtdlLogPrintf(CTDL_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
CtdlDeleteMessages(CC->room.QRname, &old_msgnum, 1, "");
}
}
FILE *network_fp = NULL;
static int seqnum = 1;
struct CtdlMessage *imsg = NULL;
- char *instr;
+ char *instr = NULL;
+ size_t instr_alloc = 0;
struct ser_ret smr;
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;
+ struct CitContext *CCC = CC; /* CachedCitContext - performance boost */
- lprintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
if (is_valid_message(msg) == 0) return(-1); /* self check */
/* If this message has no timestamp, we take the liberty of
if (msg->cm_fields['P'] == NULL) {
if (msg->cm_fields['A'] != NULL) {
msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
- for (a=0; a<strlen(msg->cm_fields['P']); ++a) {
+ for (a=0; !IsEmptyStr(&msg->cm_fields['P'][a]); ++a) {
if (isspace(msg->cm_fields['P'][a])) {
msg->cm_fields['P'][a] = ' ';
}
/* Learn about what's inside, because it's what's inside that counts */
if (msg->cm_fields['M'] == NULL) {
- lprintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
+ CtdlLogPrintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
return(-2);
}
break;
case 4:
strcpy(content_type, "text/plain");
- mptr = bmstrcasestr(msg->cm_fields['M'], "Content-type: ");
+ 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;
+ char *aptr;
+ safestrncpy(content_type, &mptr[13], sizeof content_type);
+ striplt(content_type);
+ aptr = content_type;
+ while (!IsEmptyStr(aptr)) {
+ if ((*aptr == ';')
+ || (*aptr == ' ')
+ || (*aptr == 13)
+ || (*aptr == 10)) {
+ *aptr = 0;
}
+ else aptr++;
}
}
}
/* Goto the correct room */
- lprintf(CTDL_DEBUG, "Selected room %s\n", (recps) ? CC->room.QRname : SENTITEMS);
- strcpy(hold_rm, CC->room.QRname);
- strcpy(actual_rm, CC->room.QRname);
+ CtdlLogPrintf(CTDL_DEBUG, "Selected room %s\n", (recps) ? CCC->room.QRname : SENTITEMS);
+ strcpy(hold_rm, CCC->room.QRname);
+ strcpy(actual_rm, CCC->room.QRname);
if (recps != NULL) {
strcpy(actual_rm, SENTITEMS);
}
/* If the user is a twit, move to the twit room for posting */
if (TWITDETECT) {
- if (CC->user.axlevel == 2) {
+ if (CCC->user.axlevel == 2) {
strcpy(hold_rm, actual_rm);
strcpy(actual_rm, config.c_twitroom);
- lprintf(CTDL_DEBUG, "Diverting to twit room\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Diverting to twit room\n");
}
}
/* ...or if this message is destined for Aide> then go there. */
- if (strlen(force_room) > 0) {
+ if (!IsEmptyStr(force_room)) {
strcpy(actual_rm, force_room);
}
- lprintf(CTDL_DEBUG, "Final selection: %s\n", actual_rm);
- if (strcasecmp(actual_rm, CC->room.QRname)) {
- /* getroom(&CC->room, actual_rm); */
+ CtdlLogPrintf(CTDL_DEBUG, "Final selection: %s\n", actual_rm);
+ if (strcasecmp(actual_rm, CCC->room.QRname)) {
+ /* getroom(&CCC->room, actual_rm); */
usergoto(actual_rm, 0, 1, NULL, NULL);
}
* If this message has no O (room) field, generate one.
*/
if (msg->cm_fields['O'] == NULL) {
- msg->cm_fields['O'] = strdup(CC->room.QRname);
+ msg->cm_fields['O'] = strdup(CCC->room.QRname);
}
/* Perform "before save" hooks (aborting if any return nonzero) */
- lprintf(CTDL_DEBUG, "Performing before-save hooks\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Performing before-save hooks\n");
if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
/*
* If this message has an Exclusive ID, and the room is replication
* checking enabled, then do replication checks.
*/
- if (DoesThisRoomNeedEuidIndexing(&CC->room)) {
+ if (DoesThisRoomNeedEuidIndexing(&CCC->room)) {
ReplicationChecks(msg);
}
/* Save it to disk */
- lprintf(CTDL_DEBUG, "Saving to disk\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Saving to disk\n");
newmsgid = send_message(msg);
if (newmsgid <= 0L) return(-5);
* be a critical section because nobody else knows about this message
* yet.
*/
- lprintf(CTDL_DEBUG, "Creating MetaData record\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Creating MetaData record\n");
memset(&smi, 0, sizeof(struct MetaData));
smi.meta_msgnum = newmsgid;
smi.meta_refcount = 0;
* 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");
+ if (CCC->redirect_buffer != NULL) {
+ CtdlLogPrintf(CTDL_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
abort();
}
- CC->redirect_buffer = malloc(SIZ);
- CC->redirect_len = 0;
- CC->redirect_alloc = SIZ;
+ CCC->redirect_buffer = malloc(SIZ);
+ CCC->redirect_len = 0;
+ CCC->redirect_alloc = SIZ;
CtdlOutputPreLoadedMsg(msg, MT_RFC822, HEADERS_ALL, 0, 1);
- smi.meta_rfc822_length = CC->redirect_len;
- saved_rfc822_version = CC->redirect_buffer;
- CC->redirect_buffer = NULL;
- CC->redirect_len = 0;
- CC->redirect_alloc = 0;
+ smi.meta_rfc822_length = CCC->redirect_len;
+ saved_rfc822_version = CCC->redirect_buffer;
+ CCC->redirect_buffer = NULL;
+ CCC->redirect_len = 0;
+ CCC->redirect_alloc = 0;
PutMetaData(&smi);
/* Now figure out where to store the pointers */
- lprintf(CTDL_DEBUG, "Storing pointers\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Storing pointers\n");
/* If this is being done by the networker delivering a private
* 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 ((!CCC->internal_pgm) || (recps == NULL)) {
if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
- lprintf(CTDL_ERR, "ERROR saving message pointer!\n");
+ CtdlLogPrintf(CTDL_ERR, "ERROR saving message pointer!\n");
CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0, msg);
}
}
for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
extract_token(recipient, recps->recp_room, i,
'|', sizeof recipient);
- lprintf(CTDL_DEBUG, "Delivering to room <%s>\n", recipient);
+ CtdlLogPrintf(CTDL_DEBUG, "Delivering to room <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
}
/* Bump this user's messages posted counter. */
- lprintf(CTDL_DEBUG, "Updating user\n");
- lgetuser(&CC->user, CC->curr_user);
- CC->user.posted = CC->user.posted + 1;
- lputuser(&CC->user);
+ CtdlLogPrintf(CTDL_DEBUG, "Updating user\n");
+ lgetuser(&CCC->user, CCC->curr_user);
+ CCC->user.posted = CCC->user.posted + 1;
+ lputuser(&CCC->user);
/* If this is private, local mail, make a copy in the
* recipient's mailbox and bump the reference count.
for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
extract_token(recipient, recps->recp_local, i,
'|', sizeof recipient);
- lprintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
+ CtdlLogPrintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
recipient);
if (getuser(&userbuf, recipient) == 0) {
// Add a flag so the Funambol module knows its mail
msg->cm_fields['W'] = strdup(recipient);
- MailboxName(actual_rm, sizeof actual_rm,
- &userbuf, MAILROOM);
+ MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
BumpNewMailCounter(userbuf.usernum);
- if (strlen(config.c_funambol_host) > 0) {
+ if (!IsEmptyStr(config.c_funambol_host) || !IsEmptyStr(config.c_pager_program)) {
/* Generate a instruction message for the Funambol notification
- server, in the same style as the SMTP queue */
- instr = malloc(SIZ * 2);
- snprintf(instr, SIZ * 2,
+ * server, in the same style as the SMTP queue
+ */
+ instr_alloc = 1024;
+ instr = malloc(instr_alloc);
+ snprintf(instr, instr_alloc,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|%s@%s\n",
SPOOLMIME, newmsgid, (long)time(NULL),
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;
+ imsg->cm_fields['M'] = instr; /* imsg owns this memory now */
imsg->cm_fields['W'] = strdup(recipient);
CtdlSubmitMsg(imsg, NULL, FNBL_QUEUE_ROOM);
CtdlFreeMessage(imsg);
}
}
else {
- lprintf(CTDL_DEBUG, "No user <%s>\n", recipient);
+ CtdlLogPrintf(CTDL_DEBUG, "No user <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(config.c_aideroom,
newmsgid, 0, msg);
}
}
/* Perform "after save" hooks */
- lprintf(CTDL_DEBUG, "Performing after-save hooks\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Performing after-save hooks\n");
PerformMessageHooks(msg, EVT_AFTERSAVE);
/* For IGnet mail, we have to save a new copy into the spooler for
snprintf(submit_filename, sizeof submit_filename,
"%s/netmail.%04lx.%04x.%04x",
ctdl_netin_dir,
- (long) getpid(), CC->cs_pid, ++seqnum);
+ (long) getpid(), CCC->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); */
+ CtdlLogPrintf(CTDL_DEBUG, "Returning to original room %s\n", hold_rm);
+ if (strcasecmp(hold_rm, CCC->room.QRname))
usergoto(hold_rm, 0, 1, NULL, NULL);
/* For internet mail, generate delivery instructions.
*/
if (recps != NULL)
if (recps->num_internet > 0) {
- lprintf(CTDL_DEBUG, "Generating delivery instructions\n");
- instr = malloc(SIZ * 2);
- snprintf(instr, SIZ * 2,
+ CtdlLogPrintf(CTDL_DEBUG, "Generating delivery instructions\n");
+ instr_alloc = 1024;
+ instr = malloc(instr_alloc);
+ snprintf(instr, instr_alloc,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|%s@%s\n",
SPOOLMIME, newmsgid, (long)time(NULL),
for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
size_t tmp = strlen(instr);
- extract_token(recipient, recps->recp_internet,
- i, '|', sizeof recipient);
- snprintf(&instr[tmp], SIZ * 2 - tmp,
- "remote|%s|0||\n", recipient);
+ extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
+ if ((tmp + strlen(recipient) + 32) > instr_alloc) {
+ instr_alloc = instr_alloc * 2;
+ instr = realloc(instr, instr_alloc);
+ }
+ snprintf(&instr[tmp], instr_alloc - tmp, "remote|%s|0||\n", recipient);
}
imsg = malloc(sizeof(struct CtdlMessage));
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;
+ imsg->cm_fields['M'] = instr; /* imsg owns this memory now */
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
}
/*
* Any addresses to harvest for someone's address book?
*/
- if ( (CC->logged_in) && (recps != NULL) ) {
+ if ( (CCC->logged_in) && (recps != NULL) ) {
collected_addresses = harvest_collected_addresses(msg);
}
malloc(sizeof(struct addresses_to_be_filed));
aptr->next = atbf;
MailboxName(actual_rm, sizeof actual_rm,
- &CC->user, USERCONTACTSROOM);
+ &CCC->user, USERCONTACTSROOM);
aptr->roomname = strdup(actual_rm);
aptr->collected_addresses = collected_addresses;
atbf = aptr;
msg->cm_fields['N'] = strdup(NODENAME);
if (to != NULL) {
msg->cm_fields['R'] = strdup(to);
- recp = validate_recipients(to);
+ recp = validate_recipients(to, NULL, 0);
}
if (subject != NULL) {
msg->cm_fields['U'] = strdup(subject);
CtdlSubmitMsg(msg, recp, room);
CtdlFreeMessage(msg);
- if (recp != NULL) free(recp);
+ if (recp != NULL) free_recipients(recp);
}
size_t maxlen, /* maximum message length */
char *exist, /* if non-null, append to it;
exist is ALWAYS freed */
- int crlf /* CRLF newlines instead of LF */
+ int crlf, /* CRLF newlines instead of LF */
+ int sock /* socket handle or 0 for this session's client socket */
) {
char buf[1024];
int linelen;
/* read in the lines of message text one by one */
do {
- if (client_getln(buf, (sizeof buf - 3)) < 1) finished = 1;
+ if (sock > 0) {
+ if (sock_getln(sock, buf, (sizeof buf - 3)) < 0) finished = 1;
+ }
+ else {
+ if (client_getln(buf, (sizeof buf - 3)) < 1) finished = 1;
+ }
if (!strcmp(buf, terminator)) finished = 1;
if (crlf) {
strcat(buf, "\r\n");
} else {
buffer_len = (buffer_len * 2);
m = ptr;
- lprintf(CTDL_DEBUG, "buffer_len is now %ld\n", (long)buffer_len);
+ CtdlLogPrintf(CTDL_DEBUG, "buffer_len is now %ld\n", (long)buffer_len);
}
}
int type, /* see MES_ types in header file */
int format_type, /* variformat, plain text, MIME... */
char *fake_name, /* who we're masquerading as */
+ char *my_email, /* which of my email addresses to use (empty is ok) */
char *subject, /* Subject (optional) */
char *supplied_euid, /* ...or NULL if this is irrelevant */
char *preformatted_text /* ...or NULL to read text from client */
striplt(recipient);
striplt(recp_cc);
- snprintf(buf, sizeof buf, "cit%ld", author->usernum); /* Path */
- msg->cm_fields['P'] = strdup(buf);
+ /* Path or Return-Path */
+ if (my_email == NULL) my_email = "";
+
+ if (!IsEmptyStr(my_email)) {
+ msg->cm_fields['P'] = strdup(my_email);
+ }
+ else {
+ snprintf(buf, sizeof buf, "%s", author->fullname);
+ msg->cm_fields['P'] = strdup(buf);
+ }
+ convert_spaces_to_underscores(msg->cm_fields['P']);
snprintf(buf, sizeof buf, "%ld", (long)time(NULL)); /* timestamp */
msg->cm_fields['T'] = strdup(buf);
msg->cm_fields['D'] = strdup(dest_node);
}
- if ( (author == &CC->user) && (strlen(CC->cs_inet_email) > 0) ) {
+ if (!IsEmptyStr(my_email)) {
+ msg->cm_fields['F'] = strdup(my_email);
+ }
+ else if ( (author == &CC->user) && (!IsEmptyStr(CC->cs_inet_email)) ) {
msg->cm_fields['F'] = strdup(CC->cs_inet_email);
}
msg->cm_fields['M'] = preformatted_text;
}
else {
- msg->cm_fields['M'] = CtdlReadMessageBody("000", config.c_maxmsglen, NULL, 0);
+ msg->cm_fields['M'] = CtdlReadMessageBody("000", config.c_maxmsglen, NULL, 0, 0);
}
return(msg);
* room. Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
* returns 0 on success.
*/
-int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf, size_t n) {
+int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf,
+ size_t n,
+ const char* RemoteIdentifier,
+ int PostPublic) {
int ra;
- if (!(CC->logged_in)) {
+ if (!(CC->logged_in) &&
+ (PostPublic == POST_LOGGED_IN)) {
snprintf(errmsgbuf, n, "Not logged in.");
return (ERROR + NOT_LOGGED_IN);
}
+ else if (PostPublic == CHECK_EXISTANCE) {
+ return (0); // We're Evaling whether a recipient exists
+ }
+ else if (!(CC->logged_in)) {
+
+ if ((CC->room.QRflags & QR_READONLY)) {
+ snprintf(errmsgbuf, n, "Not logged in.");
+ return (ERROR + NOT_LOGGED_IN);
+ }
+ if (CC->room.QRflags2 & QR2_MODERATED) {
+ snprintf(errmsgbuf, n, "Not logged in Moderation feature not yet implemented!");
+ return (ERROR + NOT_LOGGED_IN);
+ }
+ if ((PostPublic!=POST_LMTP) &&(CC->room.QRflags2 & QR2_SMTP_PUBLIC) == 0) {
+ SpoolControl *sc;
+ char filename[SIZ];
+ int found;
+
+ if (RemoteIdentifier == NULL)
+ {
+ snprintf(errmsgbuf, n, "Need sender to permit access.");
+ return (ERROR + USERNAME_REQUIRED);
+ }
+
+ assoc_file_name(filename, sizeof filename, &CC->room, ctdl_netcfg_dir);
+ begin_critical_section(S_NETCONFIGS);
+ if (!read_spoolcontrol_file(&sc, filename))
+ {
+ end_critical_section(S_NETCONFIGS);
+ snprintf(errmsgbuf, n,
+ "This mailing list only accepts posts from subscribers.");
+ return (ERROR + NO_SUCH_USER);
+ }
+ end_critical_section(S_NETCONFIGS);
+ found = is_recipient (sc, RemoteIdentifier);
+ free_spoolcontrol_struct(&sc);
+ if (found) {
+ return (0);
+ }
+ else {
+ snprintf(errmsgbuf, n,
+ "This mailing list only accepts posts from subscribers.");
+ return (ERROR + NO_SUCH_USER);
+ }
+ }
+ return (0);
+
+ }
if ((CC->user.axlevel < 2)
&& ((CC->room.QRflags & QR_MAILBOX) == 0)) {
/*
* Validate recipients, count delivery types and errors, and handle aliasing
* FIXME check for dupes!!!!!
+ *
* Returns 0 if all addresses are ok, ret->num_error = -1 if no addresses
* were specified, or the number of addresses found invalid.
- * caller needs to free the result.
+ *
+ * Caller needs to free the result using free_recipients()
*/
-struct recptypes *validate_recipients(char *supplied_recipients) {
+struct recptypes *validate_recipients(char *supplied_recipients,
+ const char *RemoteIdentifier,
+ int Flags) {
struct recptypes *ret;
- char recipients[SIZ];
+ char *recipients = NULL;
char this_recp[256];
char this_recp_cooked[256];
char append[SIZ];
int invalid;
struct ctdluser tempUS;
struct ctdlroom tempQR;
+ struct ctdlroom tempQR2;
+ int err = 0;
+ char errmsg[SIZ];
int in_quotes = 0;
/* Initialize */
ret = (struct recptypes *) malloc(sizeof(struct recptypes));
if (ret == NULL) return(NULL);
- memset(ret, 0, sizeof(struct recptypes));
- ret->num_local = 0;
- ret->num_internet = 0;
- ret->num_ignet = 0;
- ret->num_error = 0;
- ret->num_room = 0;
+ /* Set all strings to null and numeric values to zero */
+ memset(ret, 0, sizeof(struct recptypes));
if (supplied_recipients == NULL) {
- strcpy(recipients, "");
+ recipients = strdup("");
}
else {
- safestrncpy(recipients, supplied_recipients, sizeof recipients);
+ recipients = strdup(supplied_recipients);
}
+ /* Allocate some memory. Yes, this allocates 500% more memory than we will
+ * actually need, but it's healthier for the heap than doing lots of tiny
+ * realloc() calls instead.
+ */
+
+ ret->errormsg = malloc(strlen(recipients) + 1024);
+ ret->recp_local = malloc(strlen(recipients) + 1024);
+ ret->recp_internet = malloc(strlen(recipients) + 1024);
+ ret->recp_ignet = malloc(strlen(recipients) + 1024);
+ ret->recp_room = malloc(strlen(recipients) + 1024);
+ ret->display_recp = malloc(strlen(recipients) + 1024);
+
+ ret->errormsg[0] = 0;
+ ret->recp_local[0] = 0;
+ ret->recp_internet[0] = 0;
+ ret->recp_ignet[0] = 0;
+ ret->recp_room[0] = 0;
+ ret->display_recp[0] = 0;
+
+ ret->recptypes_magic = RECPTYPES_MAGIC;
+
/* Change all valid separator characters to commas */
- for (i=0; i<strlen(recipients); ++i) {
+ for (i=0; !IsEmptyStr(&recipients[i]); ++i) {
if ((recipients[i] == ';') || (recipients[i] == '|')) {
recipients[i] = ',';
}
/* Now start extracting recipients... */
- while (strlen(recipients) > 0) {
+ while (!IsEmptyStr(recipients)) {
for (i=0; i<=strlen(recipients); ++i) {
if (recipients[i] == '\"') in_quotes = 1 - in_quotes;
}
striplt(this_recp);
- lprintf(CTDL_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
+ if (IsEmptyStr(this_recp))
+ break;
+ CtdlLogPrintf(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);
- for (j=0; j<=strlen(this_recp); ++j) {
+ j = 0;
+ for (j=0; !IsEmptyStr(&this_recp[j]); ++j) {
if (this_recp[j]=='_') {
this_recp_cooked[j] = ' ';
}
this_recp_cooked[j] = this_recp[j];
}
}
+ this_recp_cooked[j] = '\0';
invalid = 0;
+ errmsg[0] = 0;
switch(mailtype) {
case MES_LOCAL:
if (!strcasecmp(this_recp, "sysop")) {
++ret->num_room;
strcpy(this_recp, config.c_aideroom);
- if (strlen(ret->recp_room) > 0) {
+ if (!IsEmptyStr(ret->recp_room)) {
strcat(ret->recp_room, "|");
}
strcat(ret->recp_room, this_recp);
}
+ else if ( (!strncasecmp(this_recp, "room_", 5))
+ && (!getroom(&tempQR, &this_recp_cooked[5])) ) {
+
+ /* Save room so we can restore it later */
+ tempQR2 = CC->room;
+ CC->room = tempQR;
+
+ /* Check permissions to send mail to this room */
+ err = CtdlDoIHavePermissionToPostInThisRoom(errmsg,
+ sizeof errmsg,
+ RemoteIdentifier,
+ Flags
+ );
+ if (err)
+ {
+ ++ret->num_error;
+ invalid = 1;
+ }
+ else {
+ ++ret->num_room;
+ if (!IsEmptyStr(ret->recp_room)) {
+ strcat(ret->recp_room, "|");
+ }
+ strcat(ret->recp_room, &this_recp_cooked[5]);
+ }
+
+ /* Restore room in case something needs it */
+ CC->room = tempQR2;
+
+ }
else if (getuser(&tempUS, this_recp) == 0) {
++ret->num_local;
strcpy(this_recp, tempUS.fullname);
- if (strlen(ret->recp_local) > 0) {
+ if (!IsEmptyStr(ret->recp_local)) {
strcat(ret->recp_local, "|");
}
strcat(ret->recp_local, this_recp);
else if (getuser(&tempUS, this_recp_cooked) == 0) {
++ret->num_local;
strcpy(this_recp, tempUS.fullname);
- if (strlen(ret->recp_local) > 0) {
+ if (!IsEmptyStr(ret->recp_local)) {
strcat(ret->recp_local, "|");
}
strcat(ret->recp_local, this_recp);
}
- else if ( (!strncasecmp(this_recp, "room_", 5))
- && (!getroom(&tempQR, &this_recp_cooked[5])) ) {
- ++ret->num_room;
- if (strlen(ret->recp_room) > 0) {
- strcat(ret->recp_room, "|");
- }
- strcat(ret->recp_room, &this_recp_cooked[5]);
- }
else {
++ret->num_error;
invalid = 1;
* because if the address were valid, we would have
* already translated it to a local address by now.
*/
- if (IsDirectory(this_recp)) {
+ if (IsDirectory(this_recp, 0)) {
++ret->num_error;
invalid = 1;
}
else {
++ret->num_internet;
- if (strlen(ret->recp_internet) > 0) {
+ if (!IsEmptyStr(ret->recp_internet)) {
strcat(ret->recp_internet, "|");
}
strcat(ret->recp_internet, this_recp);
break;
case MES_IGNET:
++ret->num_ignet;
- if (strlen(ret->recp_ignet) > 0) {
+ if (!IsEmptyStr(ret->recp_ignet)) {
strcat(ret->recp_ignet, "|");
}
strcat(ret->recp_ignet, this_recp);
break;
}
if (invalid) {
- if (strlen(ret->errormsg) == 0) {
- snprintf(append, sizeof append,
- "Invalid recipient: %s",
- this_recp);
+ if (IsEmptyStr(errmsg)) {
+ snprintf(append, sizeof append, "Invalid recipient: %s", this_recp);
}
else {
- snprintf(append, sizeof append,
- ", %s", this_recp);
+ snprintf(append, sizeof append, "%s", errmsg);
}
- if ( (strlen(ret->errormsg) + strlen(append)) < SIZ) {
+ if ( (strlen(ret->errormsg) + strlen(append) + 3) < SIZ) {
+ if (!IsEmptyStr(ret->errormsg)) {
+ strcat(ret->errormsg, "; ");
+ }
strcat(ret->errormsg, append);
}
}
else {
- if (strlen(ret->display_recp) == 0) {
+ if (IsEmptyStr(ret->display_recp)) {
strcpy(append, this_recp);
}
else {
- snprintf(append, sizeof append, ", %s",
- this_recp);
+ snprintf(append, sizeof append, ", %s", this_recp);
}
if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
strcat(ret->display_recp, append);
strcpy(ret->errormsg, "No recipients specified.");
}
- lprintf(CTDL_DEBUG, "validate_recipients()\n");
- lprintf(CTDL_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
- lprintf(CTDL_DEBUG, " room: %d <%s>\n", ret->num_room, ret->recp_room);
- lprintf(CTDL_DEBUG, " inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
- lprintf(CTDL_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
- lprintf(CTDL_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
+ CtdlLogPrintf(CTDL_DEBUG, "validate_recipients()\n");
+ CtdlLogPrintf(CTDL_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
+ CtdlLogPrintf(CTDL_DEBUG, " room: %d <%s>\n", ret->num_room, ret->recp_room);
+ CtdlLogPrintf(CTDL_DEBUG, " inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
+ CtdlLogPrintf(CTDL_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
+ CtdlLogPrintf(CTDL_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
+ free(recipients);
return(ret);
}
+/*
+ * Destructor for struct recptypes
+ */
+void free_recipients(struct recptypes *valid) {
+
+ if (valid == NULL) {
+ return;
+ }
+
+ if (valid->recptypes_magic != RECPTYPES_MAGIC) {
+ CtdlLogPrintf(CTDL_EMERG, "Attempt to call free_recipients() on some other data type!\n");
+ abort();
+ }
+
+ if (valid->errormsg != NULL) free(valid->errormsg);
+ if (valid->recp_local != NULL) free(valid->recp_local);
+ if (valid->recp_internet != NULL) free(valid->recp_internet);
+ if (valid->recp_ignet != NULL) free(valid->recp_ignet);
+ if (valid->recp_room != NULL) free(valid->recp_room);
+ if (valid->display_recp != NULL) free(valid->display_recp);
+ free(valid);
+}
+
+
/*
* message entry - mode 0 (normal)
int anon_flag = 0;
int format_type = 0;
char newusername[256];
+ char newuseremail[256];
struct CtdlMessage *msg;
int anonymous = 0;
char errmsg[SIZ];
struct recptypes *valid_cc = NULL;
struct recptypes *valid_bcc = NULL;
char subject[SIZ];
+ int subject_required = 0;
int do_confirm = 0;
long msgnum;
+ int i, j;
+ char buf[256];
+ int newuseremail_ok = 0;
unbuffer_output();
supplied_euid[0] = 0;
break;
}
+ extract_token(newuseremail, entargs, 10, '|', sizeof newuseremail);
/* first check to make sure the request is valid. */
- err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg);
+ err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg, NULL, POST_LOGGED_IN);
if (err)
{
cprintf("%d %s\n", err, errmsg);
/* Check some other permission type things. */
- if (strlen(newusername) == 0)
- {
+ if (IsEmptyStr(newusername)) {
strcpy(newusername, CC->user.fullname);
}
if ( (CC->user.axlevel < 6)
return;
}
+
+ if (IsEmptyStr(newuseremail)) {
+ newuseremail_ok = 1;
+ }
+
+ if (!IsEmptyStr(newuseremail)) {
+ if (!strcasecmp(newuseremail, CC->cs_inet_email)) {
+ newuseremail_ok = 1;
+ }
+ else if (!IsEmptyStr(CC->cs_inet_other_emails)) {
+ j = num_tokens(CC->cs_inet_other_emails, '|');
+ for (i=0; i<j; ++i) {
+ extract_token(buf, CC->cs_inet_other_emails, i, '|', sizeof buf);
+ if (!strcasecmp(newuseremail, buf)) {
+ newuseremail_ok = 1;
+ }
+ }
+ }
+ }
+
+ if (!newuseremail_ok) {
+ cprintf("%d You don't have permission to author messages as '%s'.\n",
+ ERROR + HIGHER_ACCESS_REQUIRED,
+ newuseremail
+ );
+ return;
+ }
+
CC->cs_flags |= CS_POSTING;
- /* In the Mail> room we have to behave a little differently --
+ /* In mailbox rooms we have to behave a little differently --
* make sure the user has specified at least one recipient. Then
- * validate the recipient(s).
+ * validate the recipient(s). We do this for the Mail> room, as
+ * well as any room which has the "Mailbox" view set.
*/
- if ( (CC->room.QRflags & QR_MAILBOX)
- && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) ) {
+ if ( ( (CC->room.QRflags & QR_MAILBOX) && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) )
+ || ( (CC->room.QRflags & QR_MAILBOX) && (CC->curr_view == VIEW_MAILBOX) )
+ ) {
if (CC->user.axlevel < 2) {
strcpy(recp, "sysop");
strcpy(cc, "");
strcpy(bcc, "");
}
- valid_to = validate_recipients(recp);
+ valid_to = validate_recipients(recp, NULL, 0);
if (valid_to->num_error > 0) {
- cprintf("%d Invalid recipient (To)\n", ERROR + NO_SUCH_USER);
- free(valid_to);
+ cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_to->errormsg);
+ free_recipients(valid_to);
return;
}
- valid_cc = validate_recipients(cc);
+ valid_cc = validate_recipients(cc, NULL, 0);
if (valid_cc->num_error > 0) {
- cprintf("%d Invalid recipient (CC)\n", ERROR + NO_SUCH_USER);
- free(valid_to);
- free(valid_cc);
+ cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_cc->errormsg);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
return;
}
- valid_bcc = validate_recipients(bcc);
+ valid_bcc = validate_recipients(bcc, NULL, 0);
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);
+ cprintf("%d %s\n", ERROR + NO_SUCH_USER, valid_bcc->errormsg);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(valid_bcc);
return;
}
/* 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);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(valid_bcc);
cprintf("%d At least one recipient is required.\n", ERROR + NO_SUCH_USER);
return;
}
cprintf("%d You do not have permission "
"to send Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- free(valid_to);
- free(valid_cc);
- free(valid_bcc);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(valid_bcc);
return;
}
}
&& (CC->user.axlevel < 4) ) {
cprintf("%d Higher access required for network mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- free(valid_to);
- free(valid_cc);
- free(valid_bcc);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(valid_bcc);
return;
}
&& (!CC->internal_pgm)) {
cprintf("%d You don't have access to Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- free(valid_to);
- free(valid_cc);
- free(valid_bcc);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(valid_bcc);
return;
}
recp[0] = 0;
}
+ /* Recommend to the client that the use of a message subject is
+ * strongly recommended in this room, if either the SUBJECTREQ flag
+ * is set, or if there is one or more Internet email recipients.
+ */
+ if (CC->room.QRflags2 & QR2_SUBJECTREQ) subject_required = 1;
+ if (valid_to) if (valid_to->num_internet > 0) subject_required = 1;
+ if (valid_cc) if (valid_cc->num_internet > 0) subject_required = 1;
+ if (valid_bcc) if (valid_bcc->num_internet > 0) subject_required = 1;
+
/* If we're only checking the validity of the request, return
* success without creating the message.
*/
if (post == 0) {
- cprintf("%d %s\n", CIT_OK,
- ((valid_to != NULL) ? valid_to->display_recp : "") );
- free(valid_to);
- free(valid_cc);
- free(valid_bcc);
+ cprintf("%d %s|%d\n", CIT_OK,
+ ((valid_to != NULL) ? valid_to->display_recp : ""),
+ subject_required);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(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);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
+ free_recipients(valid_bcc);
/* Read in the message from the client. */
if (do_confirm) {
msg = CtdlMakeMessage(&CC->user, recp, cc,
CC->room.QRname, anonymous, format_type,
- newusername, subject,
- ((strlen(supplied_euid) > 0) ? supplied_euid : NULL),
+ newusername, newuseremail, subject,
+ ((!IsEmptyStr(supplied_euid)) ? supplied_euid : NULL),
NULL);
/* Put together one big recipients struct containing to/cc/bcc all in
*/
char *all_recps = malloc(SIZ * 3);
strcpy(all_recps, recp);
- if (strlen(cc) > 0) {
- if (strlen(all_recps) > 0) {
+ if (!IsEmptyStr(cc)) {
+ if (!IsEmptyStr(all_recps)) {
strcat(all_recps, ",");
}
strcat(all_recps, cc);
}
- if (strlen(bcc) > 0) {
- if (strlen(all_recps) > 0) {
+ if (!IsEmptyStr(bcc)) {
+ if (!IsEmptyStr(all_recps)) {
strcat(all_recps, ",");
}
strcat(all_recps, bcc);
}
- if (strlen(all_recps) > 0) {
- valid = validate_recipients(all_recps);
+ if (!IsEmptyStr(all_recps)) {
+ valid = validate_recipients(all_recps, NULL, 0);
}
else {
valid = NULL;
CtdlFreeMessage(msg);
}
if (valid != NULL) {
- free(valid);
+ free_recipients(valid);
}
return;
}
struct MetaData smi;
regex_t re;
regmatch_t pm;
+ int need_to_free_re = 0;
- if (content_type) if (strlen(content_type) > 0) {
+ if (content_type) if (!IsEmptyStr(content_type)) {
regcomp(&re, content_type, 0);
+ need_to_free_re = 1;
}
- lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
room_name, num_dmsgnums, content_type);
/* get room record, obtaining a lock... */
if (lgetroom(&qrbuf, room_name) != 0) {
- lprintf(CTDL_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
+ CtdlLogPrintf(CTDL_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
room_name);
+ if (need_to_free_re) regfree(&re);
return (0); /* room not found */
}
cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
}
}
- if (strlen(content_type) == 0) {
+ if (IsEmptyStr(content_type)) {
delete_this |= 0x02;
} else {
GetMetaData(&smi, msglist[i]);
/* Now free the memory we used, and go away. */
if (msglist != NULL) free(msglist);
if (dellist != NULL) free(dellist);
- lprintf(CTDL_DEBUG, "%d message(s) deleted.\n", num_deleted);
+ CtdlLogPrintf(CTDL_DEBUG, "%d message(s) deleted.\n", num_deleted);
+ if (need_to_free_re) regfree(&re);
return (num_deleted);
}
&& (!(CC->room.QRflags & QR_MAILBOX))
&& (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+ /* Permit message removal from collaborative delete rooms */
+ if (CC->room.QRflags2 & QR2_COLLABDEL) permit = 1;
+
+ /* Users allowed to post into the target room may move into it too. */
+ if ((CC->room.QRflags & QR_MAILBOX) &&
+ (qtemp.QRflags & UA_POSTALLOWED)) permit = 1;
+
/* User must have access to target room */
if (!(ra & UA_KNOWN)) permit = 0;
/* msgnum < 0 means that we're trying to close the file */
if (msgnum < 0) {
- lprintf(CTDL_DEBUG, "Closing the AdjRefCount queue file\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Closing the AdjRefCount queue file\n");
begin_critical_section(S_SUPPMSGMAIN);
if (arcfp != NULL) {
fclose(arcfp);
r = link(file_arcq, file_arcq_temp);
if (r != 0) {
- lprintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ CtdlLogPrintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
end_critical_section(S_SUPPMSGMAIN);
return(num_records_processed);
}
fp = fopen(file_arcq_temp, "rb");
if (fp == NULL) {
- lprintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ CtdlLogPrintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
return(num_records_processed);
}
fclose(fp);
r = unlink(file_arcq_temp);
if (r != 0) {
- lprintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ CtdlLogPrintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
}
return(num_records_processed);
smi.meta_refcount += incr;
PutMetaData(&smi);
end_critical_section(S_SUPPMSGMAIN);
- lprintf(CTDL_DEBUG, "msg %ld ref count delta %d, is now %d\n",
+ CtdlLogPrintf(CTDL_DEBUG, "msg %ld ref count delta %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);
- }
+ CtdlLogPrintf(CTDL_DEBUG, "Deleting message <%ld>\n", msgnum);
+
+ /* Call delete hooks with NULL room to show it has gone altogether */
+ PerformDeleteHooks(NULL, msgnum);
/* Remove from message base */
delnum = msgnum;
fp = fopen(tempfilename, "rb");
if (fp == NULL) {
- lprintf(CTDL_CRIT, "Cannot open %s: %s\n",
+ CtdlLogPrintf(CTDL_CRIT, "Cannot open %s: %s\n",
tempfilename, strerror(errno));
return;
}
fseek(fp, 0L, SEEK_END);
raw_length = ftell(fp);
rewind(fp);
- lprintf(CTDL_DEBUG, "Raw length is %ld\n", (long)raw_length);
+ CtdlLogPrintf(CTDL_DEBUG, "Raw length is %ld\n", (long)raw_length);
raw_message = malloc((size_t)raw_length + 2);
fread(raw_message, (size_t)raw_length, 1, fp);
CtdlEncodeBase64(
&encoded_message[strlen(encoded_message)],
raw_message,
- (int)raw_length
+ (int)raw_length,
+ 0
);
}
else {
free(raw_message);
- lprintf(CTDL_DEBUG, "Allocating\n");
+ CtdlLogPrintf(CTDL_DEBUG, "Allocating\n");
msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
* other objects of this type that are currently in the room.
*/
if (is_unique) {
- lprintf(CTDL_DEBUG, "Deleted %d other msgs of this type\n",
+ CtdlLogPrintf(CTDL_DEBUG, "Deleted %d other msgs of this type\n",
CtdlDeleteMessages(roomname, NULL, 0, content_type)
);
}
if (conf != NULL) do {
extract_token(buf, conf, 0, '\n', sizeof buf);
strcpy(conf, &conf[strlen(buf)+1]);
- } while ( (strlen(conf)>0) && (strlen(buf)>0) );
+ } while ( (!IsEmptyStr(conf)) && (!IsEmptyStr(buf)) );
return(conf);
}
struct recptypes *recp;
int i;
- recp = validate_recipients(addr);
+ recp = validate_recipients(addr, NULL, 0);
if (recp == NULL) return(0);
if (recp->num_local == 0) {
- free(recp);
+ free_recipients(recp);
return(0);
}
for (i=0; i<recp->num_local; ++i) {
extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
if (!strcasecmp(addr, CC->user.fullname)) {
- free(recp);
+ free_recipients(recp);
return(1);
}
}
- free(recp);
+ free_recipients(recp);
return(0);
}