#include <errno.h>
#include <stdarg.h>
#include <sys/stat.h>
+#include <sys/types.h>
+#include <regex.h>
#include "citadel.h"
#include "server.h"
#include "serv_extensions.h"
#include "euidindex.h"
#include "journaling.h"
#include "citadel_dirs.h"
+#include "serv_network.h"
+
long config_msgnum;
struct addresses_to_be_filed *atbf = NULL;
+/* This temp file holds the queue of operations for AdjRefCount() */
+static FILE *arcfp = NULL;
+
/*
* This really belongs in serv_network.c, but I don't know how to export
* symbols between modules.
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)) {
+ lprintf(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) {
}
-void get_mm(void)
-{
- FILE *fp;
-
- fp = fopen(file_citadel_control, "r");
- if (fp == NULL) {
- lprintf(CTDL_CRIT, "Cannot open %s: %s\n",
- file_citadel_control,
- strerror(errno));
- exit(errno);
- }
- fread((char *) &CitControl, sizeof(struct CitControl), 1, fp);
- fclose(fp);
-}
-
-
/*
* Back end for the MSGS command: output message number only.
*/
char setstr[SIZ], lostr[SIZ], histr[SIZ];
size_t tmp;
+ /* Don't bother doing *anything* if we were passed a list of zero messages */
+ if (num_target_msgnums < 1) {
+ return;
+ }
+
lprintf(CTDL_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %d, %d)\n",
num_target_msgnums, target_msgnums[0],
target_setting, which_set);
* API function to perform an operation for each qualifying message in the
* current room. (Returns the number of messages processed.)
*/
-int CtdlForEachMessage(int mode, long ref,
+int CtdlForEachMessage(int mode, long ref, char *search_string,
char *content_type,
struct CtdlMessage *compare,
void (*CallBack) (long, void *),
void *userdata)
{
- int a;
+ int a, i, j;
struct visit vbuf;
struct cdbdata *cdbfr;
long *msglist = NULL;
int num_processed = 0;
long thismsg;
struct MetaData smi;
- struct CtdlMessage *msg;
+ struct CtdlMessage *msg = NULL;
int is_seen = 0;
long lastold = 0L;
int printed_lastold = 0;
+ 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) {
+ regcomp(&re, content_type, 0);
+ need_to_free_re = 1;
+ }
/* Learn about the user and room in question */
- get_mm();
getuser(&CC->user, CC->curr_user);
CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
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. */
}
*/
GetMetaData(&smi, msglist[a]);
- if (strcasecmp(smi.meta_content_type, content_type)) {
+ /* if (strcasecmp(smi.meta_content_type, content_type)) { old non-regex way */
+ if (regexec(&re, smi.meta_content_type, 1, &pm, 0) != 0) {
msglist[a] = 0L;
}
}
}
}
+ /* If a search string was specified, get a message list from
+ * the full text index and remove messages which aren't on both
+ * lists.
+ *
+ * How this works:
+ * Since the lists are sorted and strictly ascending, and the
+ * output list is guaranteed to be shorter than or equal to the
+ * input list, we overwrite the bottom of the input list. This
+ * eliminates the need to memmove big chunks of the list over and
+ * over again.
+ */
+ if ( (num_msgs > 0) && (mode == MSGS_SEARCH) && (search_string) ) {
+ ft_search(&num_search_msgs, &search_msgs, search_string);
+ if (num_search_msgs > 0) {
+ int orig_num_msgs;
+
+ orig_num_msgs = num_msgs;
+ num_msgs = 0;
+ for (i=0; i<orig_num_msgs; ++i) {
+ for (j=0; j<num_search_msgs; ++j) {
+ if (msglist[i] == search_msgs[j]) {
+ msglist[num_msgs++] = msglist[i];
+ }
+ }
+ }
+ }
+ else {
+ num_msgs = 0; /* No messages qualify */
+ }
+ if (search_msgs != NULL) free(search_msgs);
+
+ /* Now that we've purged messages which don't contain the search
+ * string, treat a MSGS_SEARCH just like a MSGS_ALL from this
+ * point on.
+ */
+ mode = MSGS_ALL;
+ }
+
/*
* Now iterate through the message list, according to the
* criteria supplied by the caller.
}
}
free(msglist); /* Clean up */
+ if (need_to_free_re) regfree(&re);
return num_processed;
}
int with_template = 0;
struct CtdlMessage *template = NULL;
int with_headers = 0;
+ char search_string[1024];
extract_token(which, cmdbuf, 0, '|', sizeof which);
cm_ref = extract_int(cmdbuf, 1);
+ extract_token(search_string, cmdbuf, 1, '|', sizeof search_string);
with_template = extract_int(cmdbuf, 2);
with_headers = extract_int(cmdbuf, 3);
- mode = MSGS_ALL;
strcat(which, " ");
if (!strncasecmp(which, "OLD", 3))
mode = MSGS_OLD;
mode = MSGS_LAST;
else if (!strncasecmp(which, "GT", 2))
mode = MSGS_GT;
+ else if (!strncasecmp(which, "SEARCH", 6))
+ mode = MSGS_SEARCH;
+ else
+ mode = MSGS_ALL;
if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
cprintf("%d not logged in\n", ERROR + NOT_LOGGED_IN);
return;
}
+ if ( (mode == MSGS_SEARCH) && (!config.c_enable_fulltext) ) {
+ cprintf("%d Full text index is not enabled on this server.\n",
+ ERROR + CMD_NOT_SUPPORTED);
+ return;
+ }
+
if (with_template) {
unbuffer_output();
cprintf("%d Send template then receive message list\n",
template = (struct CtdlMessage *)
malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
+ template->cm_magic = CTDLMESSAGE_MAGIC;
+ template->cm_anon_type = MES_NORMAL;
+
while(client_getln(buf, sizeof buf), strcmp(buf,"000")) {
extract_token(tfield, buf, 0, '|', sizeof tfield);
extract_token(tvalue, buf, 1, '|', sizeof tvalue);
}
CtdlForEachMessage(mode,
- cm_ref,
+ ( (mode == MSGS_SEARCH) ? 0 : cm_ref ),
+ ( (mode == MSGS_SEARCH) ? search_string : NULL ),
NULL,
template,
(with_headers ? headers_listing : simple_listing),
* to the client. The client software may reformat it again.
*/
void memfmout(
- int width, /* screen width to use */
char *mptr, /* where are we going to get our text from? */
char subst, /* nonzero if we should do substitutions */
char *nl) /* string to terminate lines with */
cit_uint8_t ch;
char aaa[140];
char buffer[SIZ];
+ static int width = 80;
strcpy(aaa, "");
old = 255;
old = real;
real = ch;
- if (((ch == 13) || (ch == 10)) && (old != 13) && (old != 10))
+ if (((ch == 13) || (ch == 10)) && (old != 13) && (old != 10)) {
ch = 32;
+ }
if (((old == 13) || (old == 10)) && (isspace(real))) {
cprintf("%s", nl);
c = 1;
}
- if (ch > 126)
- continue;
-
if (ch > 32) {
if (((strlen(aaa) + c) > (width - 5)) && (strlen(aaa) > (width - 5))) {
cprintf("%s%s", nl, aaa);
+/*
+ * Callback function for mime parser that outputs a section all at once
+ */
+void mime_spew_section(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, char *cbcharset, size_t length,
+ char *encoding, void *cbuserdata)
+{
+ int *found_it = (int *)cbuserdata;
+
+ /* ...or if this is not the desired section */
+ if (strcasecmp(CC->download_desired_section, partnum))
+ return;
+
+ *found_it = 1;
+
+ cprintf("%d %d\n", BINARY_FOLLOWS, (int)length);
+ client_write(content, length);
+}
+
+
+
/*
* Load a message from disk into memory.
* This is used by CtdlOutputMsg() and other fetch functions.
{
int i;
- if (is_valid_message(msg) == 0) return;
+ if (is_valid_message(msg) == 0)
+ {
+ if (msg != NULL) free (msg);
+ return;
+ }
for (i = 0; i < 256; ++i)
if (msg->cm_fields[i] != NULL) {
cprintf("\n");
}
}
+ return;
}
- else if (!strcasecmp(cbtype, "text/html")) {
+
+ if (!strcasecmp(cbtype, "text/html")) {
ptr = html_to_ascii(content, length, 80, 0);
wlen = strlen(ptr);
client_write(ptr, wlen);
cprintf("\n");
}
free(ptr);
+ return;
}
- else if (PerformFixedOutputHooks(cbtype, content, length)) {
+
+ if (ma->use_fo_hooks) {
+ if (PerformFixedOutputHooks(cbtype, content, length)) {
/* above function returns nonzero if it handled the part */
+ return;
+ }
}
- else if (strncasecmp(cbtype, "multipart/", 10)) {
+
+ if (strncasecmp(cbtype, "multipart/", 10)) {
cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
partnum, filename, cbtype, (long)length);
+ return;
}
}
* The client is elegant and sophisticated and wants to be choosy about
* MIME content types, so figure out which multipart/alternative part
* we're going to send.
+ *
+ * We use a system of weights. When we find a part that matches one of the
+ * MIME types we've declared as preferential, we can store it in ma->chosen_part
+ * and then set ma->chosen_pref to that MIME type's position in our preference
+ * list. If we then hit another match, we only replace the first match if
+ * the preference value is lower.
*/
void choose_preferred(char *name, char *filename, char *partnum, char *disp,
void *content, char *cbtype, char *cbcharset, size_t length,
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) ) {
- safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
+ if (i < ma->chosen_pref) {
+ 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) {
cprintf("; charset=%s", cbcharset);
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");
return((CC->download_fp != NULL) ? om_ok : om_mime_error);
}
+ /* MT_SPEW_SECTION is like MT_DOWNLOAD except it outputs the whole MIME part
+ * in a single server operation instead of opening a download file.
+ */
+ if (mode == MT_SPEW_SECTION) {
+ if (TheMessage->cm_format_type != FMT_RFC822) {
+ if (do_proto)
+ cprintf("%d This is not a MIME message.\n",
+ ERROR + ILLEGAL_VALUE);
+ } else {
+ /* Parse the message text component */
+ int found_it = 0;
+
+ mptr = TheMessage->cm_fields['M'];
+ mime_parser(mptr, NULL, *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
+ /* If section wasn't found, print an error
+ */
+ if (!found_it) {
+ if (do_proto) cprintf(
+ "%d Section %s not found.\n",
+ ERROR + FILE_NOT_FOUND,
+ CC->download_desired_section);
+ }
+ }
+ return((CC->download_fp != NULL) ? om_ok : om_mime_error);
+ }
+
/* now for the user-mode message reading loops */
if (do_proto) cprintf("%d msg:\n", LISTING_FOLLOWS);
else if (i == 'Y') {
cprintf("CC: %s%s", mptr, nl);
}
+ else if (i == 'P') {
+ cprintf("Return-Path: %s%s", mptr, nl);
+ }
+ else if (i == 'V') {
+ cprintf("Envelope-To: %s%s", mptr, nl);
+ }
else if (i == 'U') {
cprintf("Subject: %s%s", mptr, nl);
subject_found = 1;
++start_of_text;
start_of_text = strstr(start_of_text, "\n");
++start_of_text;
+
+ char outbuf[1024];
+ int outlen = 0;
+ int nllen = strlen(nl);
while (ch=*mptr, ch!=0) {
if (ch==13) {
/* do nothing */
}
- else switch(headers_only) {
- case HEADERS_NONE:
- if (mptr >= start_of_text) {
- if (ch == 10) cprintf("%s", nl);
- else cprintf("%c", ch);
+ else {
+ if (
+ ((headers_only == HEADERS_NONE) && (mptr >= start_of_text))
+ || ((headers_only == HEADERS_ONLY) && (mptr < start_of_text))
+ || ((headers_only != HEADERS_NONE) && (headers_only != HEADERS_ONLY))
+ ) {
+ if (ch == 10) {
+ sprintf(&outbuf[outlen], "%s", nl);
+ outlen += nllen;
}
- break;
- case HEADERS_ONLY:
- if (mptr < start_of_text) {
- if (ch == 10) cprintf("%s", nl);
- else cprintf("%c", ch);
+ else {
+ outbuf[outlen++] = ch;
}
- break;
- default:
- if (ch == 10) cprintf("%s", nl);
- else cprintf("%c", ch);
- break;
+ }
}
++mptr;
+ if (outlen > 1000) {
+ client_write(outbuf, outlen);
+ outlen = 0;
+ }
+ }
+ if (outlen > 0) {
+ client_write(outbuf, outlen);
+ outlen = 0;
}
+
goto DONE;
}
}
if (mode == MT_MIME) {
cprintf("Content-type: text/x-citadel-variformat\n\n");
}
- memfmout(80, mptr, 0, nl);
+ memfmout(mptr, 0, nl);
}
/* If the message on disk is format 4 (MIME), we've gotta hand it
memset(&ma, 0, sizeof(struct ma_info));
if (mode == MT_MIME) {
+ ma.use_fo_hooks = 0;
strcpy(ma.chosen_part, "1");
+ ma.chosen_pref = 9999;
mime_parser(mptr, NULL,
*choose_preferred, *fixed_output_pre,
*fixed_output_post, (void *)&ma, 0);
*output_preferred, NULL, NULL, (void *)&ma, 0);
}
else {
+ ma.use_fo_hooks = 1;
mime_parser(mptr, NULL,
*fixed_output, *fixed_output_pre,
*fixed_output_post, (void *)&ma, 0);
void cmd_msg3(char *cmdbuf)
{
long msgnum;
- struct CtdlMessage *msg;
+ struct CtdlMessage *msg = NULL;
struct ser_ret smr;
if (CC->internal_pgm == 0) {
/*
- * Save a message pointer into a specified room
+ * Open a component of a MIME message and transmit it all at once
+ */
+void cmd_dlat(char *cmdbuf)
+{
+ long msgid;
+ char desired_section[128];
+
+ msgid = extract_long(cmdbuf, 0);
+ extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
+ safestrncpy(CC->download_desired_section, desired_section,
+ sizeof CC->download_desired_section);
+ CtdlOutputMsg(msgid, MT_SPEW_SECTION, 0, 1, 1, NULL);
+}
+
+
+/*
+ * Save one or more message pointers into a specified room
* (Returns 0 for success, nonzero for failure)
* roomname may be NULL to use the current room
*
* Note that the 'supplied_msg' field may be set to NULL, in which case
* the message will be fetched from disk, by number, if we need to perform
* replication checks. This adds an additional database read, so if the
- * caller already has the message in memory then it should be supplied.
+ * caller already has the message in memory then it should be supplied. (Obviously
+ * this mode of operation only works if we're saving a single message.)
*/
-int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int do_repl_check,
- struct CtdlMessage *supplied_msg) {
- int i;
+int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
+ int do_repl_check, struct CtdlMessage *supplied_msg)
+{
+ int i, j, unique;
char hold_rm[ROOMNAMELEN];
struct cdbdata *cdbfr;
int num_msgs;
long *msglist;
long highest_msg = 0L;
+
+ long msgid = 0;
struct CtdlMessage *msg = NULL;
- /*lprintf(CTDL_DEBUG,
- "CtdlSaveMsgPointerInRoom(room=%s, msgid=%ld, repl=%d)\n",
- roomname, msgid, do_repl_check);*/
+ long *msgs_to_be_merged = NULL;
+ int num_msgs_to_be_merged = 0;
+
+ lprintf(CTDL_DEBUG,
+ "CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d)\n",
+ roomname, num_newmsgs, do_repl_check);
strcpy(hold_rm, CC->room.QRname);
+ /* Sanity checks */
+ if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
+ if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
+ if (num_newmsgs > 1) supplied_msg = NULL;
+
/* Now the regular stuff */
if (lgetroom(&CC->room,
((roomname != NULL) ? roomname : CC->room.QRname) )
return(ERROR + ROOM_NOT_FOUND);
}
+
+ msgs_to_be_merged = malloc(sizeof(long) * num_newmsgs);
+ num_msgs_to_be_merged = 0;
+
+
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr == NULL) {
msglist = NULL;
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.
+
+ /* Create a list of msgid's which were supplied by the caller, but do
+ * not already exist in the target 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 (msglist[i] == msgid) {
- lputroom(&CC->room); /* unlock the room */
- getroom(&CC->room, hold_rm);
- free(msglist);
- return(ERROR + ALREADY_EXISTS);
+ for (i=0; i<num_newmsgs; ++i) {
+ unique = 1;
+ if (num_msgs > 0) for (j=0; j<num_msgs; ++j) {
+ if (msglist[j] == newmsgidlist[i]) {
+ unique = 0;
+ }
+ }
+ if (unique) {
+ msgs_to_be_merged[num_msgs_to_be_merged++] = newmsgidlist[i];
}
}
- /* Now add the new message */
- ++num_msgs;
- msglist = realloc(msglist, (num_msgs * sizeof(long)));
+ lprintf(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");
}
- msglist[num_msgs - 1] = msgid;
+ memcpy(&msglist[num_msgs], msgs_to_be_merged, (sizeof(long) * num_msgs_to_be_merged) );
+ num_msgs += num_msgs_to_be_merged;
/* Sort the message list, so all the msgid's are in order */
num_msgs = sort_msglist(msglist, num_msgs);
/* Perform replication checks if necessary */
if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
- if (supplied_msg != NULL) {
- msg = supplied_msg;
- }
- else {
- msg = CtdlFetchMessage(msgid, 0);
- }
+ lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
- if (msg != NULL) {
- ReplicationChecks(msg);
- }
-
- }
+ for (i=0; i<num_msgs_to_be_merged; ++i) {
+ msgid = msgs_to_be_merged[i];
+
+ if (supplied_msg != NULL) {
+ msg = supplied_msg;
+ }
+ else {
+ msg = CtdlFetchMessage(msgid, 0);
+ }
+
+ if (msg != NULL) {
+ ReplicationChecks(msg);
+
+ /* If the message has an Exclusive ID, index that... */
+ if (msg->cm_fields['E'] != NULL) {
+ index_message_by_euid(msg->cm_fields['E'], &CC->room, msgid);
+ }
- /* If the message has an Exclusive ID, index that... */
- if (msg != NULL) {
- if (msg->cm_fields['E'] != NULL) {
- index_message_by_euid(msg->cm_fields['E'],
- &CC->room, msgid);
+ /* Free up the memory we may have allocated */
+ if (msg != supplied_msg) {
+ CtdlFreeMessage(msg);
+ }
+ }
+
}
}
- /* Free up the memory we may have allocated */
- if ( (msg != NULL) && (msg != supplied_msg) ) {
- CtdlFreeMessage(msg);
+ else {
+ lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
}
+ /* 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);
- /* Bump the reference count for this message. */
- AdjRefCount(msgid, +1);
+ /* Bump the reference count for all messages which were merged */
+ for (i=0; i<num_msgs_to_be_merged; ++i) {
+ AdjRefCount(msgs_to_be_merged[i], +1);
+ }
+
+ /* Free up memory... */
+ if (msgs_to_be_merged != NULL) {
+ free(msgs_to_be_merged);
+ }
/* Return success. */
return (0);
}
+/*
+ * This is the same as CtdlSaveMsgPointersInRoom() but it only accepts
+ * a single message.
+ */
+int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
+ int do_repl_check, struct CtdlMessage *supplied_msg)
+{
+ return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg);
+}
+
+
+
/*
* Message base operation to save a new message to the message store
/* Get a new message number */
newmsgid = get_new_message_number();
- snprintf(msgidbuf, sizeof msgidbuf, "%ld@%s", newmsgid, config.c_fqdn);
+ snprintf(msgidbuf, sizeof msgidbuf, "%010ld@%s", newmsgid, config.c_fqdn);
/* Generate an ID if we don't have one already */
if (msg->cm_fields['I']==NULL) {
void serialize_message(struct ser_ret *ret, /* return values */
struct CtdlMessage *msg) /* unserialized msg */
{
- size_t wlen;
+ size_t wlen, fieldlen;
int i;
static char *forder = FORDER;
- if (is_valid_message(msg) == 0) return; /* self check */
+ /*
+ * Check for valid message format
+ */
+ if (is_valid_message(msg) == 0) {
+ lprintf(CTDL_ERR, "serialize_message() aborting due to invalid message\n");
+ ret->len = 0;
+ ret->ser = NULL;
+ return;
+ }
ret->len = 3;
for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
ret->len = ret->len +
strlen(msg->cm_fields[(int)forder[i]]) + 2;
- lprintf(CTDL_DEBUG, "serialize_message() calling malloc(%ld)\n", (long)ret->len);
ret->ser = malloc(ret->len);
if (ret->ser == NULL) {
+ lprintf(CTDL_ERR, "serialize_message() malloc(%ld) failed: %s\n",
+ (long)ret->len, strerror(errno));
ret->len = 0;
+ ret->ser = NULL;
return;
}
wlen = 3;
for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
+ fieldlen = strlen(msg->cm_fields[(int)forder[i]]);
ret->ser[wlen++] = (char)forder[i];
- strcpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
- wlen = wlen + strlen(msg->cm_fields[(int)forder[i]]) + 1;
+ 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",
(long)ret->len, (long)wlen);
old_msgnum = locate_message_by_euid(msg->cm_fields['E'], &CC->room);
if (old_msgnum > 0L) {
lprintf(CTDL_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
- CtdlDeleteMessages(CC->room.QRname, old_msgnum, "", 0);
+ 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;
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);
+ safestrncpy(content_type, &mptr[13], sizeof content_type);
+ striplt(content_type);
for (a = 0; a < strlen(content_type); ++a) {
if ((content_type[a] == ';')
|| (content_type[a] == ' ')
lprintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
recipient);
if (getuser(&userbuf, recipient) == 0) {
- MailboxName(actual_rm, sizeof actual_rm,
- &userbuf, MAILROOM);
+ // Add a flag so the Funambol module knows its mail
+ msg->cm_fields['W'] = strdup(recipient);
+ MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
BumpNewMailCounter(userbuf.usernum);
+ if (strlen(config.c_funambol_host) > 0) {
+ /* Generate a instruction message for the Funambol notification
+ * 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),
+ msg->cm_fields['A'], msg->cm_fields['N']
+ );
+
+ 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['J'] = strdup("do not journal");
+ 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);
/* 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); */
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,
+ 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);
}
/*
* Convenience function for generating small administrative messages.
*/
-void quickie_message(char *from, char *to, char *room, char *text,
+void quickie_message(char *from, char *fromaddr, char *to, char *room, char *text,
int format_type, char *subject)
{
struct CtdlMessage *msg;
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = MES_NORMAL;
msg->cm_format_type = format_type;
- msg->cm_fields['A'] = strdup(from);
+
+ if (from != NULL) {
+ msg->cm_fields['A'] = strdup(from);
+ }
+ else if (fromaddr != NULL) {
+ msg->cm_fields['A'] = strdup(fromaddr);
+ if (strchr(msg->cm_fields['A'], '@')) {
+ *strchr(msg->cm_fields['A'], '@') = 0;
+ }
+ }
+ else {
+ msg->cm_fields['A'] = strdup("Citadel");
+ }
+
+ if (fromaddr != NULL) msg->cm_fields['F'] = strdup(fromaddr);
if (room != NULL) msg->cm_fields['O'] = strdup(room);
msg->cm_fields['N'] = strdup(NODENAME);
if (to != NULL) {
CtdlSubmitMsg(msg, recp, room);
CtdlFreeMessage(msg);
- if (recp != NULL) free(recp);
+ if (recp != NULL) free_recipients(recp);
}
char *m;
int flushing = 0;
int finished = 0;
+ int dotdot = 0;
if (exist == NULL) {
m = malloc(4096);
}
}
+ /* Do we need to change leading ".." to "." for SMTP escaping? */
+ if (!strcmp(terminator, ".")) {
+ dotdot = 1;
+ }
+
/* flush the input if we have nowhere to store it */
if (m == NULL) {
flushing = 1;
strcat(buf, "\n");
}
+ /* Unescape SMTP-style input of two dots at the beginning of the line */
+ if (dotdot) {
+ if (!strncmp(buf, "..", 2)) {
+ strcpy(buf, &buf[1]);
+ }
+ }
+
if ( (!flushing) && (!finished) ) {
/* Measure the line */
linelen = strlen(buf);
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 */
) {
- char dest_node[SIZ];
- char buf[SIZ];
+ char dest_node[256];
+ char buf[1024];
struct CtdlMessage *msg;
+ int i;
msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
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 (strlen(my_email) > 0) {
+ msg->cm_fields['P'] = strdup(my_email);
+ }
+ else {
+ snprintf(buf, sizeof buf, "%s", author->fullname);
+ msg->cm_fields['P'] = strdup(buf);
+ }
+ for (i=0; (msg->cm_fields['P'][i]!=0); ++i) {
+ if (isspace(msg->cm_fields['P'][i])) {
+ msg->cm_fields['P'][i] = '_';
+ }
+ }
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 (strlen(my_email) > 0) {
+ msg->cm_fields['F'] = strdup(my_email);
+ }
+ else if ( (author == &CC->user) && (strlen(CC->cs_inet_email) > 0) ) {
msg->cm_fields['F'] = strdup(CC->cs_inet_email);
}
if (subject != NULL) {
+ long length;
striplt(subject);
- if (strlen(subject) > 0) {
- msg->cm_fields['U'] = strdup(subject);
+ length = strlen(subject);
+ if (length > 0) {
+ long i;
+ long IsAscii;
+ IsAscii = -1;
+ i = 0;
+ while ((subject[i] != '\0') &&
+ (IsAscii = isascii(subject[i]) != 0 ))
+ i++;
+ if (IsAscii != 0)
+ msg->cm_fields['U'] = strdup(subject);
+ else /* ok, we've got utf8 in the string. */
+ {
+ msg->cm_fields['U'] = rfc2047encode(subject, length);
+ }
+
}
}
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);
}
return(msg);
* returns 0 on success.
*/
int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf, size_t n) {
+ int ra;
if (!(CC->logged_in)) {
snprintf(errmsgbuf, n, "Not logged in.");
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
- if ((CC->user.axlevel < 4)
- && (CC->room.QRflags & QR_NETWORK)) {
- snprintf(errmsgbuf, n, "Need net privileges to enter here.");
- return (ERROR + HIGHER_ACCESS_REQUIRED);
- }
-
- if ((CC->user.axlevel < 6)
- && (CC->room.QRflags & QR_READONLY)) {
- snprintf(errmsgbuf, n, "Sorry, this is a read-only room.");
+ CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
+ if (!(ra & UA_POSTALLOWED)) {
+ snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
/*
* Validate recipients, count delivery types and errors, and handle aliasing
* FIXME check for dupes!!!!!
- * Returns 0 if all addresses are ok, -1 if no addresses were specified,
- * or the number of addresses found invalid.
+ *
+ * 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 using free_recipients()
*/
struct recptypes *validate_recipients(char *supplied_recipients) {
struct recptypes *ret;
- char recipients[SIZ];
+ char *recipients = NULL;
char this_recp[256];
char this_recp_cooked[256];
char append[SIZ];
/* 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) {
if ((recipients[i] == ';') || (recipients[i] == '|')) {
* 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;
}
this_recp);
}
else {
- snprintf(append, sizeof append,
- ", %s", this_recp);
+ snprintf(append, sizeof append, ", %s", this_recp);
}
if ( (strlen(ret->errormsg) + strlen(append)) < SIZ) {
strcat(ret->errormsg, append);
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);
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);
+ free(recipients);
return(ret);
}
+/*
+ * Destructor for struct recptypes
+ */
+void free_recipients(struct recptypes *valid) {
+
+ if (valid == NULL) {
+ return;
+ }
+
+ if (valid->recptypes_magic != RECPTYPES_MAGIC) {
+ lprintf(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)
char cc[SIZ];
char bcc[SIZ];
char supplied_euid[128];
- char masquerade_as[SIZ];
int anon_flag = 0;
int format_type = 0;
- char newusername[SIZ];
+ 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();
anon_flag = extract_int(entargs, 2);
format_type = extract_int(entargs, 3);
extract_token(subject, entargs, 4, '|', sizeof subject);
+ extract_token(newusername, entargs, 5, '|', sizeof newusername);
do_confirm = extract_int(entargs, 6);
extract_token(cc, entargs, 7, '|', sizeof cc);
extract_token(bcc, entargs, 8, '|', sizeof bcc);
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);
- if (err) {
+ if (err)
+ {
cprintf("%d %s\n", err, errmsg);
return;
}
/* Check some other permission type things. */
- if (post == 2) {
- if (CC->user.axlevel < 6) {
- cprintf("%d You don't have permission to masquerade.\n",
- ERROR + HIGHER_ACCESS_REQUIRED);
- return;
+ if (strlen(newusername) == 0) {
+ strcpy(newusername, CC->user.fullname);
+ }
+ if ( (CC->user.axlevel < 6)
+ && (strcasecmp(newusername, CC->user.fullname))
+ && (strcasecmp(newusername, CC->cs_inet_fn))
+ ) {
+ cprintf("%d You don't have permission to author messages as '%s'.\n",
+ ERROR + HIGHER_ACCESS_REQUIRED,
+ newusername
+ );
+ return;
+ }
+
+
+ if (strlen(newuseremail) == 0) {
+ newuseremail_ok = 1;
+ }
+
+ if (strlen(newuseremail) > 0) {
+ if (!strcasecmp(newuseremail, CC->cs_inet_email)) {
+ newuseremail_ok = 1;
}
- 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) );
- cprintf("%d ok\n", CIT_OK);
+ else if (strlen(CC->cs_inet_other_emails) > 0) {
+ 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, "");
valid_to = validate_recipients(recp);
if (valid_to->num_error > 0) {
cprintf("%d Invalid recipient (To)\n", ERROR + NO_SUCH_USER);
- free(valid_to);
+ free_recipients(valid_to);
return;
}
valid_cc = validate_recipients(cc);
if (valid_cc->num_error > 0) {
cprintf("%d Invalid recipient (CC)\n", ERROR + NO_SUCH_USER);
- free(valid_to);
- free(valid_cc);
+ free_recipients(valid_to);
+ free_recipients(valid_cc);
return;
}
valid_bcc = validate_recipients(bcc);
if (valid_bcc->num_error > 0) {
cprintf("%d Invalid recipient (BCC)\n", ERROR + NO_SUCH_USER);
- free(valid_to);
- free(valid_cc);
- free(valid_bcc);
+ 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);
-
- /* Handle author masquerading */
- if (CC->fake_postname[0]) {
- strcpy(masquerade_as, CC->fake_postname);
- }
- else if (CC->fake_username[0]) {
- strcpy(masquerade_as, CC->fake_username);
- }
- else {
- strcpy(masquerade_as, "");
- }
+ 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,
- masquerade_as, subject,
+ newusername, newuseremail, subject,
((strlen(supplied_euid) > 0) ? supplied_euid : NULL),
NULL);
CtdlFreeMessage(msg);
}
- CC->fake_postname[0] = '\0';
if (valid != NULL) {
- free(valid);
+ free_recipients(valid);
}
return;
}
* (returns the actual number of messages deleted)
*/
int CtdlDeleteMessages(char *room_name, /* which room */
- long dmsgnum, /* or "0" for any */
- char *content_type, /* or "" for any */
- int deferred /* let TDAP sweep it later */
+ long *dmsgnums, /* array of msg numbers to be deleted */
+ int num_dmsgnums, /* number of msgs to be deleted, or 0 for "any" */
+ char *content_type /* or "" for any. regular expressions expected. */
)
{
-
struct ctdlroom qrbuf;
struct cdbdata *cdbfr;
long *msglist = NULL;
long *dellist = NULL;
int num_msgs = 0;
- int i;
+ int i, j;
int num_deleted = 0;
int delete_this;
struct MetaData smi;
+ regex_t re;
+ regmatch_t pm;
+ int need_to_free_re = 0;
- lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %ld, %s, %d)\n",
- room_name, dmsgnum, content_type, deferred);
+ if (content_type) if (strlen(content_type) > 0) {
+ regcomp(&re, content_type, 0);
+ need_to_free_re = 1;
+ }
+ lprintf(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",
room_name);
+ if (need_to_free_re) regfree(&re);
return (0); /* room not found */
}
cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
/* Set/clear a bit for each criterion */
- if ((dmsgnum == 0L) || (msglist[i] == dmsgnum)) {
+ /* 0 messages in the list or a null list means that we are
+ * interested in deleting any messages which meet the other criteria.
+ */
+ if ((num_dmsgnums == 0) || (dmsgnums == NULL)) {
delete_this |= 0x01;
}
+ else {
+ for (j=0; j<num_dmsgnums; ++j) {
+ if (msglist[i] == dmsgnums[j]) {
+ delete_this |= 0x01;
+ }
+ }
+ }
+
if (strlen(content_type) == 0) {
delete_this |= 0x02;
} else {
GetMetaData(&smi, msglist[i]);
- if (!strcasecmp(smi.meta_content_type,
- content_type)) {
+ if (regexec(&re, smi.meta_content_type, 1, &pm, 0) == 0) {
delete_this |= 0x02;
}
}
}
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
if (msglist != NULL) free(msglist);
if (dellist != NULL) free(dellist);
lprintf(CTDL_DEBUG, "%d message(s) deleted.\n", num_deleted);
+ if (need_to_free_re) regfree(&re);
return (num_deleted);
}
* the current room (returns 1 for yes, 0 for no)
*/
int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
- getuser(&CC->user, CC->curr_user);
- if ((CC->user.axlevel < 6)
- && (CC->user.usernum != CC->room.QRroomaide)
- && ((CC->room.QRflags & QR_MAILBOX) == 0)
- && (!(CC->internal_pgm))) {
- return(0);
- }
- return(1);
+ int ra;
+ CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
+ if (ra & UA_DELETEALLOWED) return(1);
+ return(0);
}
+
/*
* Delete message from current room
*/
-void cmd_dele(char *delstr)
+void cmd_dele(char *args)
{
- long delnum;
int num_deleted;
+ int i;
+ char msgset[SIZ];
+ char msgtok[32];
+ long *msgs;
+ int num_msgs = 0;
+
+ extract_token(msgset, args, 0, '|', sizeof msgset);
+ num_msgs = num_tokens(msgset, ',');
+ if (num_msgs < 1) {
+ cprintf("%d Nothing to do.\n", CIT_OK);
+ return;
+ }
if (CtdlDoIHavePermissionToDeleteMessagesFromThisRoom() == 0) {
cprintf("%d Higher access required.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
return;
}
- delnum = extract_long(delstr, 0);
- num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "", 1);
+ /*
+ * Build our message set to be moved/copied
+ */
+ msgs = malloc(num_msgs * sizeof(long));
+ for (i=0; i<num_msgs; ++i) {
+ extract_token(msgtok, msgset, i, ',', sizeof msgtok);
+ msgs[i] = atol(msgtok);
+ }
+
+ num_deleted = CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
+ free(msgs);
if (num_deleted) {
cprintf("%d %d message%s deleted.\n", CIT_OK,
num_deleted, ((num_deleted != 1) ? "s" : ""));
} else {
- cprintf("%d Message %ld not found.\n", ERROR + MESSAGE_NOT_FOUND, delnum);
+ cprintf("%d Message not found.\n", ERROR + MESSAGE_NOT_FOUND);
}
}
/*
- * Back end API function for moves and deletes
+ * Back end API function for moves and deletes (multiple messages)
*/
-int CtdlCopyMsgToRoom(long msgnum, char *dest) {
+int CtdlCopyMsgsToRoom(long *msgnums, int num_msgs, char *dest) {
int err;
- err = CtdlSaveMsgPointerInRoom(dest, msgnum, 1, NULL);
+ err = CtdlSaveMsgPointersInRoom(dest, msgnums, num_msgs, 1, NULL);
if (err != 0) return(err);
return(0);
+
/*
* move or copy a message to another room
*/
void cmd_move(char *args)
{
- long num;
+ char msgset[SIZ];
+ char msgtok[32];
+ long *msgs;
+ int num_msgs = 0;
+
char targ[ROOMNAMELEN];
struct ctdlroom qtemp;
int err;
int is_copy = 0;
int ra;
int permit = 0;
+ int i;
+
+ extract_token(msgset, args, 0, '|', sizeof msgset);
+ num_msgs = num_tokens(msgset, ',');
+ if (num_msgs < 1) {
+ cprintf("%d Nothing to do.\n", CIT_OK);
+ return;
+ }
- num = extract_long(args, 0);
extract_token(targ, args, 1, '|', sizeof targ);
convert_room_name_macros(targ, sizeof targ);
targ[ROOMNAMELEN - 1] = 0;
&& (!(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;
+
/* User must have access to target room */
if (!(ra & UA_KNOWN)) permit = 0;
return;
}
- err = CtdlCopyMsgToRoom(num, targ);
+ /*
+ * Build our message set to be moved/copied
+ */
+ msgs = malloc(num_msgs * sizeof(long));
+ for (i=0; i<num_msgs; ++i) {
+ extract_token(msgtok, msgset, i, ',', sizeof msgtok);
+ msgs[i] = atol(msgtok);
+ }
+
+ /*
+ * Do the copy
+ */
+ err = CtdlCopyMsgsToRoom(msgs, num_msgs, targ);
if (err != 0) {
- cprintf("%d Cannot store message in %s: error %d\n",
+ cprintf("%d Cannot store message(s) in %s: error %d\n",
err, targ, err);
+ free(msgs);
return;
}
* if this is a 'move' rather than a 'copy' operation.
*/
if (is_copy == 0) {
- CtdlDeleteMessages(CC->room.QRname, num, "", 0);
+ CtdlDeleteMessages(CC->room.QRname, msgs, num_msgs, "");
}
+ free(msgs);
- cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
+ cprintf("%d Message(s) %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
}
/* Use the negative of the message number for the metadata db index */
TheIndex = (0L - smibuf->meta_msgnum);
- lprintf(CTDL_DEBUG, "PutMetaData(%ld) - ref count is %d\n",
- smibuf->meta_msgnum, smibuf->meta_refcount);
-
cdb_store(CDB_MSGMAIN,
&TheIndex, (int)sizeof(long),
smibuf, (int)sizeof(struct MetaData));
}
/*
- * AdjRefCount - change the reference count for a message;
- * delete the message if it reaches zero
+ * AdjRefCount - submit an adjustment to the reference count for a message.
+ * (These are just queued -- we actually process them later.)
*/
void AdjRefCount(long msgnum, int incr)
+{
+ struct arcq new_arcq;
+
+ begin_critical_section(S_SUPPMSGMAIN);
+ if (arcfp == NULL) {
+ arcfp = fopen(file_arcq, "ab+");
+ }
+ end_critical_section(S_SUPPMSGMAIN);
+
+ /* msgnum < 0 means that we're trying to close the file */
+ if (msgnum < 0) {
+ lprintf(CTDL_DEBUG, "Closing the AdjRefCount queue file\n");
+ begin_critical_section(S_SUPPMSGMAIN);
+ if (arcfp != NULL) {
+ fclose(arcfp);
+ arcfp = NULL;
+ }
+ end_critical_section(S_SUPPMSGMAIN);
+ return;
+ }
+
+ /*
+ * If we can't open the queue, perform the operation synchronously.
+ */
+ if (arcfp == NULL) {
+ TDAP_AdjRefCount(msgnum, incr);
+ return;
+ }
+
+ new_arcq.arcq_msgnum = msgnum;
+ new_arcq.arcq_delta = incr;
+ fwrite(&new_arcq, sizeof(struct arcq), 1, arcfp);
+ fflush(arcfp);
+
+ return;
+}
+
+
+/*
+ * TDAP_ProcessAdjRefCountQueue()
+ *
+ * Process the queue of message count adjustments that was created by calls
+ * to AdjRefCount() ... by reading the queue and calling TDAP_AdjRefCount()
+ * for each one. This should be an "off hours" operation.
+ */
+int TDAP_ProcessAdjRefCountQueue(void)
+{
+ char file_arcq_temp[PATH_MAX];
+ int r;
+ FILE *fp;
+ struct arcq arcq_rec;
+ int num_records_processed = 0;
+
+ snprintf(file_arcq_temp, sizeof file_arcq_temp, "%s2", file_arcq);
+
+ begin_critical_section(S_SUPPMSGMAIN);
+ if (arcfp != NULL) {
+ fclose(arcfp);
+ arcfp = NULL;
+ }
+
+ r = link(file_arcq, file_arcq_temp);
+ if (r != 0) {
+ lprintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ end_critical_section(S_SUPPMSGMAIN);
+ return(num_records_processed);
+ }
+
+ unlink(file_arcq);
+ end_critical_section(S_SUPPMSGMAIN);
+
+ fp = fopen(file_arcq_temp, "rb");
+ if (fp == NULL) {
+ lprintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ return(num_records_processed);
+ }
+
+ while (fread(&arcq_rec, sizeof(struct arcq), 1, fp) == 1) {
+ TDAP_AdjRefCount(arcq_rec.arcq_msgnum, arcq_rec.arcq_delta);
+ ++num_records_processed;
+ }
+
+ fclose(fp);
+ r = unlink(file_arcq_temp);
+ if (r != 0) {
+ lprintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ }
+
+ return(num_records_processed);
+}
+
+
+
+/*
+ * TDAP_AdjRefCount - adjust the reference count for a message.
+ * This one does it "for real" because it's called by
+ * the autopurger function that processes the queue
+ * created by AdjRefCount(). If a message's reference
+ * count becomes zero, we also delete the message from
+ * disk and de-index it.
+ */
+void TDAP_AdjRefCount(long msgnum, int incr)
{
struct MetaData smi;
smi.meta_refcount += incr;
PutMetaData(&smi);
end_critical_section(S_SUPPMSGMAIN);
- lprintf(CTDL_DEBUG, "msg %ld ref count incr %d, is now %d\n",
+ lprintf(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
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, 0)
+ CtdlDeleteMessages(roomname, NULL, 0, content_type)
);
}
/* Now write the data */
/* We want the last (and probably only) config in this room */
begin_critical_section(S_CONFIG);
config_msgnum = (-1L);
- CtdlForEachMessage(MSGS_LAST, 1, sysconfname, NULL,
+ CtdlForEachMessage(MSGS_LAST, 1, NULL, sysconfname, NULL,
CtdlGetSysConfigBackend, NULL);
msgnum = config_msgnum;
end_critical_section(S_CONFIG);
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);
}
projects / citadel.git / blobdiff