/*
- * $Id$
- *
* Implements the message store.
*
- * Copyright (c) 1987-2010 by the citadel.org team
+ * Copyright (c) 1987-2011 by the citadel.org team
*
- * This program is free software; you can redistribute it and/or modify
+ * This program is open source software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "sysdep.h"
}
if (strcasecmp(original_name, name)) {
- CtdlLogPrintf(CTDL_INFO, "%s is being forwarded to %s\n", original_name, name);
+ syslog(LOG_INFO, "%s is being forwarded to %s\n", original_name, name);
}
/* Change "user @ xxx" to "user" if xxx is an alias for this host */
if (name[a] == '@') {
if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
name[a] = 0;
- CtdlLogPrintf(CTDL_INFO, "Changed to <%s>\n", name);
+ syslog(LOG_INFO, "Changed to <%s>\n", name);
}
}
}
which_user = &CC->user;
}
- CtdlLogPrintf(CTDL_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %s, %d) in <%s>\n",
+ syslog(LOG_DEBUG, "CtdlSetSeen(%d msgs starting with %ld, %s, %d) in <%s>\n",
num_target_msgnums, target_msgnums[0],
(target_setting ? "SET" : "CLEAR"),
which_set,
#if 0 /* This is a special diagnostic section. Do not allow it to run during normal operation. */
- CtdlLogPrintf(CTDL_DEBUG, "There are %d messages in the room.\n", num_msgs);
+ syslog(LOG_DEBUG, "There are %d messages in the room.\n", num_msgs);
for (i=0; i<num_msgs; ++i) {
if ((i > 0) && (msglist[i] <= msglist[i-1])) abort();
}
- CtdlLogPrintf(CTDL_DEBUG, "We are twiddling %d of them.\n", num_target_msgnums);
+ syslog(LOG_DEBUG, "We are twiddling %d of them.\n", num_target_msgnums);
for (k=0; k<num_target_msgnums; ++k) {
if ((k > 0) && (target_msgnums[k] <= target_msgnums[k-1])) abort();
}
#endif
- CtdlLogPrintf(CTDL_DEBUG, "before update: %s\n", ChrPtr(vset));
+ syslog(LOG_DEBUG, "before update: %s\n", ChrPtr(vset));
/* Translate the existing sequence set into an array of booleans */
setstr = NewStrBuf();
vset = new_set;
}
- CtdlLogPrintf(CTDL_DEBUG, " after update: %s\n", ChrPtr(vset));
+ syslog(LOG_DEBUG, " after update: %s\n", ChrPtr(vset));
/* Decide which message set we're manipulating */
switch (which_set) {
/* Load the message list */
cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
- if (cdbfr != NULL) {
- msglist = (long *) cdbfr->ptr;
- num_msgs = cdbfr->len / sizeof(long);
- } else {
+ if (cdbfr == NULL) {
if (need_to_free_re) regfree(&re);
return 0; /* No messages at all? No further action. */
}
+ msglist = (long *) cdbfr->ptr;
+ num_msgs = cdbfr->len / sizeof(long);
+
+ cdbfr->ptr = NULL; /* clear this so that cdb_free() doesn't free it */
+ cdb_free(cdbfr); /* we own this memory now */
+
+ /*
+ * We cache the most recent msglist in order to do security checks later
+ */
+ if (CC->client_socket > 0) {
+ if (CC->cached_msglist != NULL) {
+ free(CC->cached_msglist);
+ }
+
+ CC->cached_msglist = msglist;
+ CC->cached_num_msgs = num_msgs;
+ syslog(LOG_DEBUG, "\033[34m RELOAD \033[0m\n");
+ }
/*
* Now begin the traversal.
++num_processed;
}
}
- cdb_free(cdbfr); /* Clean up */
if (need_to_free_re) regfree(&re);
+ if (CC->client_socket <= 0) free(msglist);
return num_processed;
}
char search_string[1024];
ForEachMsgCallback CallBack;
+ if (CtdlAccessCheck(ac_logged_in_or_guest)) return;
+
extract_token(which, cmdbuf, 0, '|', sizeof which);
cm_ref = extract_int(cmdbuf, 1);
extract_token(search_string, cmdbuf, 1, '|', sizeof search_string);
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);
while (ch=*(mptr++), ch != 0) {
if (ch == '\n') {
- client_write(outbuf, len);
+ if (client_write(outbuf, len) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
len = 0;
- client_write(nl, nllen);
+ if (client_write(nl, nllen) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
column = 0;
}
else if (ch == '\r') {
}
else if (isspace(ch)) {
if (column > 72) { /* Beyond 72 columns, break on the next space */
- client_write(outbuf, len);
+ if (client_write(outbuf, len) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
len = 0;
- client_write(nl, nllen);
+ if (client_write(nl, nllen) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
column = 0;
}
else {
outbuf[len++] = ch;
++column;
if (column > 1000) { /* Beyond 1000 columns, break anywhere */
- client_write(outbuf, len);
+ if (client_write(outbuf, len) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
len = 0;
- client_write(nl, nllen);
+ if (client_write(nl, nllen) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
column = 0;
}
}
}
if (len) {
- client_write(outbuf, len);
+ if (client_write(outbuf, len) == -1)
+ {
+ syslog(LOG_ERR, "memfmout(): aborting due to write failure.\n");
+ return;
+ }
len = 0;
client_write(nl, nllen);
column = 0;
}
-
/*
* Load a message from disk into memory.
* This is used by CtdlOutputMsg() and other fetch functions.
cit_uint8_t ch;
cit_uint8_t field_header;
- CtdlLogPrintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
-
+ syslog(LOG_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
if (dmsgtext == NULL) {
return NULL;
*/
ch = *mptr++;
if (ch != 255) {
- CtdlLogPrintf(CTDL_ERR, "Message %ld appears to be corrupted.\n", msgnum);
+ syslog(LOG_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) {
- CtdlLogPrintf(CTDL_WARNING, "is_valid_message() -- self-check failed\n");
+ syslog(LOG_WARNING, "is_valid_message() -- self-check failed\n");
return 0;
}
return 1;
struct ma_info *ma;
ma = (struct ma_info *)cbuserdata;
- CtdlLogPrintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
+ syslog(LOG_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;
- CtdlLogPrintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
+ syslog(LOG_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;
- CtdlLogPrintf(CTDL_DEBUG,
+ syslog(LOG_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) ) {
- CtdlLogPrintf(CTDL_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
+ syslog(LOG_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
return;
}
ma->did_print = 1;
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);
+ syslog(LOG_DEBUG, "Setting chosen part: <%s>\n", partnum);
safestrncpy(ma->chosen_part, partnum, sizeof ma->chosen_part);
ma->chosen_pref = i;
}
/*
* Now that we've chosen our preferred part, output it.
*/
-void output_preferred(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, char *cbcharset, size_t length,
- char *encoding, char *cbid, void *cbuserdata)
+void output_preferred(char *name,
+ char *filename,
+ char *partnum,
+ char *disp,
+ void *content,
+ char *cbtype,
+ char *cbcharset,
+ size_t length,
+ char *encoding,
+ char *cbid,
+ void *cbuserdata)
{
int i;
char buf[128];
int add_newline = 0;
char *text_content;
struct ma_info *ma;
-
+ char *decoded = NULL;
+ size_t bytes_decoded;
+ int rc = 0;
+
ma = (struct ma_info *)cbuserdata;
/* This is not the MIME part you're looking for... */
extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
if (!strcasecmp(buf, cbtype)) {
/* Yeah! Go! W00t!! */
+ if (ma->dont_decode == 0)
+ rc = mime_decode_now (content,
+ length,
+ encoding,
+ &decoded,
+ &bytes_decoded);
+ if (rc < 0)
+ break; /* Give us the chance, maybe theres another one. */
+
+ if (rc == 0) text_content = (char *)content;
+ else {
+ text_content = decoded;
+ length = bytes_decoded;
+ }
- text_content = (char *)content;
if (text_content[length-1] != '\n') {
++add_newline;
}
}
cprintf("X-Citadel-MSG4-Partnum: %s\n", partnum);
cprintf("\n");
- client_write(content, length);
+ if (client_write(text_content, length) == -1)
+ {
+ syslog(LOG_ERR, "output_preferred(): aborting due to write failure.\n");
+ return;
+ }
if (add_newline) cprintf("\n");
+ if (decoded != NULL) free(decoded);
return;
}
}
/* No translations required or possible: output as text/plain */
cprintf("Content-type: text/plain\n\n");
- fixed_output(name, filename, partnum, disp, content, cbtype, cbcharset,
+ rc = 0;
+ if (ma->dont_decode == 0)
+ rc = mime_decode_now (content,
+ length,
+ encoding,
+ &decoded,
+ &bytes_decoded);
+ if (rc < 0)
+ return; /* Give us the chance, maybe theres another one. */
+
+ if (rc == 0) text_content = (char *)content;
+ else {
+ text_content = decoded;
+ length = bytes_decoded;
+ }
+
+ fixed_output(name, filename, partnum, disp, text_content, cbtype, cbcharset,
length, encoding, cbid, cbuserdata);
+ if (decoded != NULL) free(decoded);
}
memcpy(encap->msg, content, length);
return;
}
-
}
+/*
+ * Determine whether the specified message exists in the cached_msglist
+ * (This is a security check)
+ */
+int check_cached_msglist(long msgnum) {
+ /* cases in which we skip the check */
+ if (!CC) return om_ok; /* not a session */
+ if (CC->client_socket <= 0) return om_ok; /* not a client session */
+ if (CC->cached_msglist == NULL) return om_access_denied; /* no msglist fetched */
+ if (CC->cached_num_msgs == 0) return om_access_denied; /* nothing to check */
+ /* Do a binary search within the cached_msglist for the requested msgnum */
+ int min = 0;
+ int max = (CC->cached_num_msgs - 1);
+
+ while (max >= min) {
+ syslog(LOG_DEBUG, "\033[35m Checking from %d to %d \033[0m\n", min, max);
+ int middle = min + (max-min) / 2 ;
+ if (msgnum == CC->cached_msglist[middle]) {
+ return om_ok;
+ }
+ if (msgnum > CC->cached_msglist[middle]) {
+ min = middle + 1;
+ }
+ else {
+ max = middle - 1;
+ }
+ }
+ return om_access_denied;
+}
+
+
+/*
+ * Determine whether the currently logged in session has permission to read
+ * messages in the current room.
+ */
int CtdlDoIHavePermissionToReadMessagesInThisRoom(void) {
- if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
+ if ( (!(CC->logged_in))
+ && (!(CC->internal_pgm))
+ && (!config.c_guest_logins)
+ ) {
return(om_not_logged_in);
}
return(om_ok);
struct encapmsg encap;
int r;
- CtdlLogPrintf(CTDL_DEBUG, "CtdlOutputMsg(msgnum=%ld, mode=%d, section=%s)\n",
+ syslog(LOG_DEBUG, "CtdlOutputMsg(msgnum=%ld, mode=%d, section=%s)\n",
msg_num, mode,
(section ? section : "<>")
);
return(r);
}
- /* FIXME: check message id against msglist for this room */
+ r = check_cached_msglist(msg_num);
+ if (r == om_ok) {
+ syslog(LOG_DEBUG, "\033[32m PASS \033[0m\n");
+ }
+ else {
+ syslog(LOG_DEBUG, "\033[31m FAIL \033[0m\n");
+ }
+ /* FIXME after testing, this is where we deny access */
/*
* Fetch the message from disk. If we're in HEADERS_FAST mode,
if (source == NULL) return source;
if (IsEmptyStr(source)) return source;
cit_backtrace();
- CtdlLogPrintf(CTDL_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
+ syslog(LOG_DEBUG, "qp_encode_email_addrs: [%s]\n", source);
AddrPtr = malloc (sizeof (long) * nAddrPtrMax);
AddrUtf8 = malloc (sizeof (long) * nAddrPtrMax);
int outlen = 0;
int nllen = strlen(nl);
char *mptr;
+ int rc;
mptr = TheMessage->cm_fields['M'];
}
++mptr;
if (outlen > 1000) {
- client_write(outbuf, outlen);
+ if (client_write(outbuf, outlen) == -1)
+ {
+ syslog(LOG_ERR, "Dump_RFC822HeadersBody(): aborting due to write failure.\n");
+ return;
+ }
outlen = 0;
}
}
if (outlen > 0) {
- client_write(outbuf, outlen);
+ rc = client_write(outbuf, outlen);
outlen = 0;
}
}
buflen += nllen;
buf[buflen] = '\0';
- client_write(buf, buflen);
+ if (client_write(buf, buflen) == -1)
+ {
+ syslog(LOG_ERR, "DumpFormatFixed(): aborting due to write failure.\n");
+ return;
+ }
*buf = '\0';
buflen = 0;
xlline = 0;
char snode[100];
char mid[100];
- CtdlLogPrintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d\n",
+ syslog(LOG_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)) {
- CtdlLogPrintf(CTDL_ERR,
+ syslog(LOG_ERR,
"ERROR: invalid preloaded message for output\n");
cit_backtrace ();
return(om_no_such_msg);
(do_proto ? *list_this_part : NULL),
(do_proto ? *list_this_pref : NULL),
(do_proto ? *list_this_suff : NULL),
- (void *)&ma, 0);
+ (void *)&ma, 1);
}
else if (mode == MT_RFC822) { /* unparsed RFC822 dump */
Dump_RFC822HeadersBody(
ma.use_fo_hooks = 0;
strcpy(ma.chosen_part, "1");
ma.chosen_pref = 9999;
+ ma.dont_decode = CC->msg4_dont_decode;
mime_parser(mptr, NULL,
*choose_preferred, *fixed_output_pre,
- *fixed_output_post, (void *)&ma, 0);
+ *fixed_output_post, (void *)&ma, 1);
mime_parser(mptr, NULL,
- *output_preferred, NULL, NULL, (void *)&ma, CC->msg4_dont_decode);
+ *output_preferred, NULL, NULL, (void *)&ma, 1);
}
else {
ma.use_fo_hooks = 1;
long *msgs_to_be_merged = NULL;
int num_msgs_to_be_merged = 0;
- CtdlLogPrintf(CTDL_DEBUG,
+ syslog(LOG_DEBUG,
"CtdlSaveMsgPointersInRoom(room=%s, num_msgs=%d, repl=%d, suppress_rca=%d)\n",
roomname, num_newmsgs, do_repl_check, suppress_refcount_adj
);
if (CtdlGetRoomLock(&CC->room,
((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
- CtdlLogPrintf(CTDL_ERR, "No such room <%s>\n", roomname);
+ syslog(LOG_ERR, "No such room <%s>\n", roomname);
return(ERROR + ROOM_NOT_FOUND);
}
}
}
- CtdlLogPrintf(9, "%d unique messages to be merged\n", num_msgs_to_be_merged);
+ syslog(LOG_DEBUG, "%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) {
- CtdlLogPrintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
+ syslog(LOG_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) ) {
- CtdlLogPrintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
+ syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() doing repl checks\n");
for (i=0; i<num_msgs_to_be_merged; ++i) {
msgid = msgs_to_be_merged[i];
}
else {
- CtdlLogPrintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
+ syslog(LOG_DEBUG, "CtdlSaveMsgPointerInRoom() skips repl checks\n");
}
/* Submit this room for processing by hooks */
/* Write our little bundle of joy into the message base */
if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
smr.ser, smr.len) < 0) {
- CtdlLogPrintf(CTDL_ERR, "Can't store message\n");
+ syslog(LOG_ERR, "Can't store message\n");
retval = 0L;
} else {
if (is_bigmsg) {
* Check for valid message format
*/
if (is_valid_message(msg) == 0) {
- CtdlLogPrintf(CTDL_ERR, "serialize_message() aborting due to invalid message\n");
+ syslog(LOG_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) {
- CtdlLogPrintf(CTDL_ERR, "serialize_message() malloc(%ld) failed: %s\n",
+ syslog(LOG_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) CtdlLogPrintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
+ if (ret->len != wlen) syslog(LOG_ERR, "ERROR: len=%ld wlen=%ld\n",
(long)ret->len, (long)wlen);
return;
* Check for valid message format
*/
if (is_valid_message(msg) == 0) {
- CtdlLogPrintf(CTDL_ERR, "dump_message() aborting due to invalid message\n");
+ syslog(LOG_ERR, "dump_message() aborting due to invalid message\n");
return;
}
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));
+ if (client_write (buf, strlen(buf)) == -1)
+ {
+ syslog(LOG_ERR, "dump_message(): aborting due to write failure.\n");
+ return;
+ }
}
return;
if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
- CtdlLogPrintf(CTDL_DEBUG, "Performing replication checks in <%s>\n",
+ syslog(LOG_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 (IsEmptyStr(msg->cm_fields['E'])) return;
- /*CtdlLogPrintf(CTDL_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
+ /*syslog(LOG_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
msg->cm_fields['E'], CC->room.QRname);*/
old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CC->room);
if (old_msgnum > 0L) {
- CtdlLogPrintf(CTDL_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
+ syslog(LOG_DEBUG, "ReplicationChecks() replacing message %ld\n", old_msgnum);
CtdlDeleteMessages(CC->room.QRname, &old_msgnum, 1, "");
}
}
*/
long CtdlSubmitMsg(struct CtdlMessage *msg, /* message to save */
struct recptypes *recps, /* recipients (if mail) */
- char *force, /* force a particular room? */
+ const char *force, /* force a particular room? */
int flags /* should the message be exported clean? */
) {
char submit_filename[128];
size_t tmp = 0;
int rv = 0;
- CtdlLogPrintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
+ syslog(LOG_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
/* Learn about what's inside, because it's what's inside that counts */
if (msg->cm_fields['M'] == NULL) {
- CtdlLogPrintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
+ syslog(LOG_ERR, "ERROR: attempt to save message with NULL body\n");
return(-2);
}
}
/* Goto the correct room */
- CtdlLogPrintf(CTDL_DEBUG, "Selected room %s\n", (recps) ? CCC->room.QRname : SENTITEMS);
+ syslog(LOG_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) {
if (CCC->user.axlevel == AxProbU) {
strcpy(hold_rm, actual_rm);
strcpy(actual_rm, config.c_twitroom);
- CtdlLogPrintf(CTDL_DEBUG, "Diverting to twit room\n");
+ syslog(LOG_DEBUG, "Diverting to twit room\n");
}
}
strcpy(actual_rm, force_room);
}
- CtdlLogPrintf(CTDL_DEBUG, "Final selection: %s\n", actual_rm);
+ syslog(LOG_DEBUG, "Final selection: %s\n", actual_rm);
if (strcasecmp(actual_rm, CCC->room.QRname)) {
/* CtdlGetRoom(&CCC->room, actual_rm); */
CtdlUserGoto(actual_rm, 0, 1, NULL, NULL);
}
/* Perform "before save" hooks (aborting if any return nonzero) */
- CtdlLogPrintf(CTDL_DEBUG, "Performing before-save hooks\n");
+ syslog(LOG_DEBUG, "Performing before-save hooks\n");
if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
/*
}
/* Save it to disk */
- CtdlLogPrintf(CTDL_DEBUG, "Saving to disk\n");
+ syslog(LOG_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.
*/
- CtdlLogPrintf(CTDL_DEBUG, "Creating MetaData record\n");
+ syslog(LOG_DEBUG, "Creating MetaData record\n");
memset(&smi, 0, sizeof(struct MetaData));
smi.meta_msgnum = newmsgid;
smi.meta_refcount = 0;
* message to attach to the journalized copy.
*/
if (CCC->redirect_buffer != NULL) {
- CtdlLogPrintf(CTDL_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
+ syslog(LOG_ALERT, "CCC->redirect_buffer is not NULL during message submission!\n");
abort();
}
CCC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
PutMetaData(&smi);
/* Now figure out where to store the pointers */
- CtdlLogPrintf(CTDL_DEBUG, "Storing pointers\n");
+ syslog(LOG_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
*/
if ((!CCC->internal_pgm) || (recps == NULL)) {
if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 1, msg) != 0) {
- CtdlLogPrintf(CTDL_ERR, "ERROR saving message pointer!\n");
+ syslog(LOG_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);
- CtdlLogPrintf(CTDL_DEBUG, "Delivering to room <%s>\n", recipient);
+ syslog(LOG_DEBUG, "Delivering to room <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
}
/* Bump this user's messages posted counter. */
- CtdlLogPrintf(CTDL_DEBUG, "Updating user\n");
+ syslog(LOG_DEBUG, "Updating user\n");
CtdlGetUserLock(&CCC->user, CCC->curr_user);
CCC->user.posted = CCC->user.posted + 1;
CtdlPutUserLock(&CCC->user);
for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
extract_token(recipient, recps->recp_local, i,
'|', sizeof recipient);
- CtdlLogPrintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
+ syslog(LOG_DEBUG, "Delivering private local mail to <%s>\n",
recipient);
if (CtdlGetUser(&userbuf, recipient) == 0) {
// Add a flag so the Funambol module knows its mail
}
}
else {
- CtdlLogPrintf(CTDL_DEBUG, "No user <%s>\n", recipient);
+ syslog(LOG_DEBUG, "No user <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(config.c_aideroom,
newmsgid, 0, msg);
}
}
/* Perform "after save" hooks */
- CtdlLogPrintf(CTDL_DEBUG, "Performing after-save hooks\n");
+ syslog(LOG_DEBUG, "Performing after-save hooks\n");
PerformMessageHooks(msg, EVT_AFTERSAVE);
/* For IGnet mail, we have to save a new copy into the spooler for
}
/* Go back to the room we started from */
- CtdlLogPrintf(CTDL_DEBUG, "Returning to original room %s\n", hold_rm);
+ syslog(LOG_DEBUG, "Returning to original room %s\n", hold_rm);
if (strcasecmp(hold_rm, CCC->room.QRname))
CtdlUserGoto(hold_rm, 0, 1, NULL, NULL);
* contain a recipient.
*/
if ((recps != NULL) && (recps->num_internet > 0)) {
- CtdlLogPrintf(CTDL_DEBUG, "Generating delivery instructions\n");
+ syslog(LOG_DEBUG, "Generating delivery instructions\n");
instr_alloc = 1024;
instr = malloc(instr_alloc);
snprintf(instr, instr_alloc,
/* read in the lines of message text one by one */
do {
if (sock != NULL) {
- if ((CtdlSockGetLine(sock, LineBuf) < 0) ||
+ if ((CtdlSockGetLine(sock, LineBuf, 5) < 0) ||
(*sock == -1))
finished = 1;
}
return Message;
}
+void DeleteAsyncMsg(ReadAsyncMsg **Msg)
+{
+ if (*Msg == NULL)
+ return;
+ FreeStrBuf(&(*Msg)->MsgBuf);
+
+ free(*Msg);
+ *Msg = NULL;
+}
+
+ReadAsyncMsg *NewAsyncMsg(const char *terminator, /* token signalling EOT */
+ long tlen,
+ size_t maxlen, /* maximum message length */
+ size_t expectlen, /* if we expect a message, how long should it be? */
+ char *exist, /* if non-null, append to it;
+ exist is ALWAYS freed */
+ long eLen, /* length of exist */
+ int crlf /* CRLF newlines instead of LF */
+ )
+{
+ ReadAsyncMsg *NewMsg;
+
+ NewMsg = (ReadAsyncMsg *)malloc(sizeof(ReadAsyncMsg));
+ memset(NewMsg, 0, sizeof(ReadAsyncMsg));
+
+ if (exist == NULL) {
+ long len;
+
+ if (expectlen == 0) {
+ len = 4 * SIZ;
+ }
+ else {
+ len = expectlen + 10;
+ }
+ NewMsg->MsgBuf = NewStrBufPlain(NULL, len);
+ }
+ else {
+ NewMsg->MsgBuf = NewStrBufPlain(exist, eLen);
+ free(exist);
+ }
+ /* Do we need to change leading ".." to "." for SMTP escaping? */
+ if ((tlen == 1) && (*terminator == '.')) {
+ NewMsg->dodot = 1;
+ }
+
+ NewMsg->terminator = terminator;
+ NewMsg->tlen = tlen;
+
+ NewMsg->maxlen = maxlen;
+
+ NewMsg->crlf = crlf;
+
+ return NewMsg;
+}
+
+/*
+ * Back end function used by CtdlMakeMessage() and similar functions
+ */
+eReadState CtdlReadMessageBodyAsync(AsyncIO *IO)
+{
+ ReadAsyncMsg *ReadMsg;
+ int MsgFinished = 0;
+ eReadState Finished = eMustReadMore;
+
+#ifdef BIGBAD_IODBG
+ char fn [SIZ];
+ FILE *fd;
+ const char *pch = ChrPtr(IO->SendBuf.Buf);
+ const char *pchh = IO->SendBuf.ReadWritePointer;
+ long nbytes;
+
+ if (pchh == NULL)
+ pchh = pch;
+
+ nbytes = StrLength(IO->SendBuf.Buf) - (pchh - pch);
+ snprintf(fn, SIZ, "/tmp/foolog_ev_%s.%d",
+ ((CitContext*)(IO->CitContext))->ServiceName,
+ IO->SendBuf.fd);
+
+ fd = fopen(fn, "a+");
+#endif
+
+ ReadMsg = IO->ReadMsg;
+
+ /* read in the lines of message text one by one */
+ do {
+ Finished = StrBufChunkSipLine(IO->IOBuf, &IO->RecvBuf);
+
+ switch (Finished) {
+ case eMustReadMore: /// read new from socket...
+#ifdef BIGBAD_IODBG
+ if (IO->RecvBuf.ReadWritePointer != NULL) {
+ nbytes = StrLength(IO->RecvBuf.Buf) - (IO->RecvBuf.ReadWritePointer - ChrPtr(IO->RecvBuf.Buf));
+ fprintf(fd, "Read; Line unfinished: %ld Bytes still in buffer [", nbytes);
+
+ fwrite(IO->RecvBuf.ReadWritePointer, nbytes, 1, fd);
+
+ fprintf(fd, "]\n");
+ } else {
+ fprintf(fd, "BufferEmpty! \n");
+ }
+ fclose(fd);
+#endif
+ return Finished;
+ break;
+ case eBufferNotEmpty: /* shouldn't happen... */
+ case eReadSuccess: /// done for now...
+ break;
+ case eReadFail: /// WHUT?
+ ///todo: shut down!
+ break;
+ }
+
+
+ if ((StrLength(IO->IOBuf) == ReadMsg->tlen) &&
+ (!strcmp(ChrPtr(IO->IOBuf), ReadMsg->terminator))) {
+ MsgFinished = 1;
+#ifdef BIGBAD_IODBG
+ fprintf(fd, "found Terminator; Message Size: %d\n", StrLength(ReadMsg->MsgBuf));
+#endif
+ }
+ else if (!ReadMsg->flushing) {
+
+#ifdef BIGBAD_IODBG
+ fprintf(fd, "Read Line: [%d][%s]\n", StrLength(IO->IOBuf), ChrPtr(IO->IOBuf));
+#endif
+
+ /* Unescape SMTP-style input of two dots at the beginning of the line */
+ if ((ReadMsg->dodot) &&
+ (StrLength(IO->IOBuf) == 2) && /* TODO: do we just unescape lines with two dots or any line? */
+ (!strcmp(ChrPtr(IO->IOBuf), "..")))
+ {
+#ifdef BIGBAD_IODBG
+ fprintf(fd, "UnEscaped!\n");
+#endif
+ StrBufCutLeft(IO->IOBuf, 1);
+ }
+
+ if (ReadMsg->crlf) {
+ StrBufAppendBufPlain(IO->IOBuf, HKEY("\r\n"), 0);
+ }
+ else {
+ StrBufAppendBufPlain(IO->IOBuf, HKEY("\n"), 0);
+ }
+
+ StrBufAppendBuf(ReadMsg->MsgBuf, IO->IOBuf, 0);
+ }
+
+ /* if we've hit the max msg length, flush the rest */
+ if (StrLength(ReadMsg->MsgBuf) >= ReadMsg->maxlen) ReadMsg->flushing = 1;
+
+ } while (!MsgFinished);
+
+#ifdef BIGBAD_IODBG
+ fprintf(fd, "Done with reading; %s.\n, ",
+ (MsgFinished)?"Message Finished": "FAILED");
+ fclose(fd);
+#endif
+ if (MsgFinished)
+ return eReadSuccess;
+ else
+ return eAbort;
+}
+
/*
* Back end function used by CtdlMakeMessage() and similar functions
char dest_node[256];
char buf[1024];
struct CtdlMessage *msg;
+ StrBuf *FakeAuthor;
+ StrBuf *FakeEncAuthor = NULL;
msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_fields['T'] = strdup(buf);
if ((fake_name != NULL) && (fake_name[0])) { /* author */
- msg->cm_fields['A'] = strdup(fake_name);
+ FakeAuthor = NewStrBufPlain (fake_name, -1);
}
else {
- msg->cm_fields['A'] = strdup(author->fullname);
+ FakeAuthor = NewStrBufPlain (author->fullname, -1);
}
+ StrBufRFC2047encode(&FakeEncAuthor, FakeAuthor);
+ msg->cm_fields['A'] = SmashStrBuf(&FakeEncAuthor);
+ FreeStrBuf(&FakeAuthor);
if (CC->room.QRflags & QR_MAILBOX) { /* room */
msg->cm_fields['O'] = strdup(&CC->room.QRname[11]);
* room. Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
* returns 0 on success.
*/
-int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf,
- size_t n,
- const char* RemoteIdentifier,
- int PostPublic) {
+int CtdlDoIHavePermissionToPostInThisRoom(
+ char *errmsgbuf,
+ size_t n,
+ const char* RemoteIdentifier,
+ int PostPublic,
+ int is_reply
+) {
int ra;
if (!(CC->logged_in) &&
}
CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
- if (!(ra & UA_POSTALLOWED)) {
+
+ if ( (!(ra & UA_POSTALLOWED)) && (ra & UA_REPLYALLOWED) && (!is_reply) ) {
+ /*
+ * To be thorough, we ought to check to see if the message they are
+ * replying to is actually a valid one in this room, but unless this
+ * actually becomes a problem we'll go with high performance instead.
+ */
+ snprintf(errmsgbuf, n, "You may only reply to existing messages here.");
+ return (ERROR + HIGHER_ACCESS_REQUIRED);
+ }
+
+ else if (!(ra & UA_POSTALLOWED)) {
snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
striplt(this_recp);
if (IsEmptyStr(this_recp))
break;
- CtdlLogPrintf(CTDL_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
+ syslog(LOG_DEBUG, "Evaluating recipient #%d: %s\n", num_recps, this_recp);
++num_recps;
mailtype = alias(this_recp);
mailtype = alias(this_recp);
CC->room = tempQR;
/* Check permissions to send mail to this room */
- err = CtdlDoIHavePermissionToPostInThisRoom(errmsg,
- sizeof errmsg,
- RemoteIdentifier,
- Flags
+ err = CtdlDoIHavePermissionToPostInThisRoom(
+ errmsg,
+ sizeof errmsg,
+ RemoteIdentifier,
+ Flags,
+ 0 /* 0 = not a reply */
);
if (err)
{
strcpy(ret->errormsg, "No recipients specified.");
}
- 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);
+ syslog(LOG_DEBUG, "validate_recipients()\n");
+ syslog(LOG_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
+ syslog(LOG_DEBUG, " room: %d <%s>\n", ret->num_room, ret->recp_room);
+ syslog(LOG_DEBUG, " inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
+ syslog(LOG_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
+ syslog(LOG_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
free(recipients);
return(ret);
}
if (valid->recptypes_magic != RECPTYPES_MAGIC) {
- CtdlLogPrintf(CTDL_EMERG, "Attempt to call free_recipients() on some other data type!\n");
+ syslog(LOG_EMERG, "Attempt to call free_recipients() on some other data type!\n");
abort();
}
/* first check to make sure the request is valid. */
- err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg, NULL, POST_LOGGED_IN);
+ err = CtdlDoIHavePermissionToPostInThisRoom(
+ errmsg,
+ sizeof errmsg,
+ NULL,
+ POST_LOGGED_IN,
+ (!IsEmptyStr(references)) /* is this a reply? or a top-level post? */
+ );
if (err)
{
cprintf("%d %s\n", err, errmsg);
/* 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). We do this for the Mail> room, as
- * well as any room which has the "Mailbox" view set.
+ * well as any room which has the "Mailbox" view set - unless it
+ * is the DRAFTS room which does not require recipients
*/
- if ( ( (CC->room.QRflags & QR_MAILBOX) && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) )
- || ( (CC->room.QRflags & QR_MAILBOX) && (CC->curr_view == VIEW_MAILBOX) )
- ) {
+ if ( ( ( (CC->room.QRflags & QR_MAILBOX) && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) )
+ || ( (CC->room.QRflags & QR_MAILBOX) && (CC->curr_view == VIEW_MAILBOX) )
+ ) && (strcasecmp(&CC->room.QRname[11], USERDRAFTROOM)) !=0 ) {
if (CC->user.axlevel < AxProbU) {
strcpy(recp, "sysop");
strcpy(cc, "");
regcomp(&re, content_type, 0);
need_to_free_re = 1;
}
- CtdlLogPrintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
+ syslog(LOG_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
room_name, num_dmsgnums, content_type);
/* get room record, obtaining a lock... */
if (CtdlGetRoomLock(&qrbuf, room_name) != 0) {
- CtdlLogPrintf(CTDL_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
+ syslog(LOG_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
room_name);
if (need_to_free_re) regfree(&re);
return (0); /* room not found */
/* Now free the memory we used, and go away. */
if (msglist != NULL) free(msglist);
if (dellist != NULL) free(dellist);
- CtdlLogPrintf(CTDL_DEBUG, "%d message(s) deleted.\n", num_deleted);
+ syslog(LOG_DEBUG, "%d message(s) deleted.\n", num_deleted);
if (need_to_free_re) regfree(&re);
return (num_deleted);
}
struct arcq new_arcq;
int rv = 0;
- CtdlLogPrintf(CTDL_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
+ syslog(LOG_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
msgnum, incr
);
/* msgnum < 0 means that we're trying to close the file */
if (msgnum < 0) {
- CtdlLogPrintf(CTDL_DEBUG, "Closing the AdjRefCount queue file\n");
+ syslog(LOG_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) {
- CtdlLogPrintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ syslog(LOG_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) {
- CtdlLogPrintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
return(num_records_processed);
}
fclose(fp);
r = unlink(file_arcq_temp);
if (r != 0) {
- CtdlLogPrintf(CTDL_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
+ syslog(LOG_CRIT, "%s: %s\n", file_arcq_temp, strerror(errno));
}
return(num_records_processed);
smi.meta_refcount += incr;
PutMetaData(&smi);
end_critical_section(S_SUPPMSGMAIN);
- CtdlLogPrintf(CTDL_DEBUG, "TDAP_AdjRefCount() msg %ld ref count delta %+d, is now %d\n",
+ syslog(LOG_DEBUG, "TDAP_AdjRefCount() msg %ld ref count delta %+d, is now %d\n",
msgnum, incr, smi.meta_refcount
);
* (and its supplementary record as well).
*/
if (smi.meta_refcount == 0) {
- CtdlLogPrintf(CTDL_DEBUG, "Deleting message <%ld>\n", msgnum);
+ syslog(LOG_DEBUG, "Deleting message <%ld>\n", msgnum);
/* Call delete hooks with NULL room to show it has gone altogether */
PerformDeleteHooks(NULL, msgnum);
safestrncpy(roomname, req_room, sizeof(roomname));
}
- CtdlLogPrintf(CTDL_DEBUG, "Raw length is %ld\n", (long)raw_length);
+ syslog(LOG_DEBUG, "Raw length is %ld\n", (long)raw_length);
if (is_binary) {
encoded_message = malloc((size_t) (((raw_length * 134) / 100) + 4096 ) );
);
}
- CtdlLogPrintf(CTDL_DEBUG, "Allocating\n");
+ syslog(LOG_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) {
- CtdlLogPrintf(CTDL_DEBUG, "Deleted %d other msgs of this type\n",
+ syslog(LOG_DEBUG, "Deleted %d other msgs of this type\n",
CtdlDeleteMessages(roomname, NULL, 0, content_type)
);
}
}
/* return our Subversion id for the Log */
- return "$Id$";
+ return "msgbase";
}