/*
* 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"
#include "journaling.h"
#include "citadel_dirs.h"
#include "clientsocket.h"
-#include "serv_network.h"
#include "threads.h"
#include "ctdl_module.h"
/* 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.
- */
-struct FilterList *filterlist = NULL;
-
-
/*
* These are the four-character field headers we use when outputting
* messages in Citadel format (as opposed to RFC822 format).
}
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 */
/*
* Now begin the traversal.
++num_processed;
}
}
- cdb_free(cdbfr); /* Clean up */
if (need_to_free_re) regfree(&re);
+
+ /*
+ * 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;
+ }
+ else {
+ free(msglist);
+ }
+
return num_processed;
}
return;
rv = fwrite(content, length, 1, CC->download_fp);
+ if (rv == -1) {
+ syslog(LOG_EMERG, "mime_download(): Couldn't write: %s\n",
+ strerror(errno));
+ }
fflush(CC->download_fp);
rewind(CC->download_fp);
}
}
-#ifdef MESSAGE_IN_ROOM
-/*
- * Check if a message is in the current room.
- * This is used by CtdlFetchMessage to prevent random picking
- * of messages from users private rooms
- *
- * The message list should probably be cached against the CC->room
- */
-int CtdlMessageInRoom(long msgnum)
-{
- visit vbuf;
- struct cdbdata *cdbfr;
-
- /* Learn about the user and room in question */
- CtdlGetUser(&CC->user, CC->curr_user);
- CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
-
- /* Load the message list */
- cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
- if (cdbfr != NULL) {
- long *msglist = NULL;
- int num_msgs = 0;
- int i;
- int r = 0;
-
- msglist = (long *) cdbfr->ptr;
- num_msgs = cdbfr->len / sizeof(long);
-
- /* search for message msgnum */
- for (i=0; i<num_msgs; i++) {
- if (msglist[i] == msgnum) {
- r = 1;
- break;
- }
- }
-
- cdb_free(cdbfr);
- return r;
- } else {
- return 0;
- }
-}
-#endif
/*
* Load a message from disk into memory.
cit_uint8_t ch;
cit_uint8_t field_header;
- CtdlLogPrintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
-
-#ifdef MESSAGE_IN_ROOM
- if (!CtdlMessageInRoom(msgnum)) {
- CtdlLogPrintf(CTDL_DEBUG, "Message %ld not in current room\n", msgnum);
- return NULL;
- }
-#endif
-
+ 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;
}
}
+/*
+ * 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) {
+ 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.
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);
}
-#ifdef MESSAGE_IN_ROOM
- if (!CtdlMessageInRoom(msg_num)) {
- CtdlLogPrintf(CTDL_DEBUG, "Message %ld not in current room\n", msg_num);
- if (do_proto) cprintf("%d Can't locate msg %ld in room\n",
- ERROR + MESSAGE_NOT_FOUND, msg_num);
- return(om_no_such_msg);
+ /*
+ * Check to make sure the message is actually IN this room
+ */
+ r = check_cached_msglist(msg_num);
+ if (r == om_access_denied) {
+ /* Not in the cache? We get ONE shot to check it again. */
+ CtdlForEachMessage(MSGS_ALL, 0L, NULL, NULL, NULL, NULL, NULL);
+ r = check_cached_msglist(msg_num);
+ }
+ if (r != om_ok) {
+ syslog(LOG_DEBUG, "Security check fail: message %ld is not in %s\n",
+ msg_num, CC->room.QRname
+ );
+ if (do_proto) {
+ if (r == om_access_denied) {
+ cprintf("%d message %ld was not found in this room\n",
+ ERROR + HIGHER_ACCESS_REQUIRED,
+ msg_num
+ );
+ }
+ }
+ return(r);
}
-#endif
/*
* 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 i, j, k;
char *mptr = NULL;
char *mpptr = NULL;
+ char *hptr;
for (i = 0; i < 256; ++i) {
if (TheMessage->cm_fields[i]) {
else if (i == 'V') {
if ((flags & QP_EADDR) != 0)
mptr = qp_encode_email_addrs(mptr);
- cprintf("Envelope-To: %s%s", mptr, nl);
+ hptr = mptr;
+ while ((*hptr != '\0') && isspace(*hptr))
+ hptr ++;
+ if (!IsEmptyStr(hptr))
+ cprintf("Envelope-To: %s%s", hptr, nl);
}
else if (i == 'U') {
cprintf("Subject: %s%s", mptr, nl);
}
}
else if (i == 'K') {
- cprintf("Reply-To: <%s>%s", mptr, nl);
+ hptr = mptr;
+ while ((*hptr != '\0') && isspace(*hptr))
+ hptr ++;
+ if (!IsEmptyStr(hptr))
+ cprintf("Reply-To: %s%s", mptr, nl);
}
if (mptr != mpptr)
free (mptr);
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);
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 */
* a single message.
*/
int CtdlSaveMsgPointerInRoom(char *roomname, long msgid,
- int do_repl_check, struct CtdlMessage *supplied_msg)
+ int do_repl_check, struct CtdlMessage *supplied_msg)
{
return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg, 0);
}
/* Get a new message number */
newmsgid = get_new_message_number();
- snprintf(msgidbuf, sizeof msgidbuf, "%010ld@%s", newmsgid, config.c_fqdn);
+ snprintf(msgidbuf, sizeof msgidbuf, "%08lX-%08lX@%s",
+ (long unsigned int) time(NULL),
+ (long unsigned int) newmsgid,
+ config.c_fqdn
+ );
/* Generate an ID if we don't have one already */
if (msg->cm_fields['I']==NULL) {
/* 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) {
cdb_store(CDB_BIGMSGS,
- &newmsgid,
- (int)sizeof(long),
- holdM,
- (strlen(holdM) + 1)
- );
+ &newmsgid,
+ (int)sizeof(long),
+ holdM,
+ (strlen(holdM) + 1)
+ );
}
retval = newmsgid;
}
* serialized message in memory. THE LATTER MUST BE FREED BY THE CALLER.
*/
void serialize_message(struct ser_ret *ret, /* return values */
- struct CtdlMessage *msg) /* unserialized msg */
+ struct CtdlMessage *msg) /* unserialized msg */
{
size_t wlen, fieldlen;
int i;
* 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->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;
+ ret->len = ret->len +
+ strlen(msg->cm_fields[(int)forder[i]]) + 2;
ret->ser = malloc(ret->len);
if (ret->ser == NULL) {
- CtdlLogPrintf(CTDL_ERR, "serialize_message() malloc(%ld) failed: %s\n",
- (long)ret->len, strerror(errno));
+ syslog(LOG_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];
- 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",
- (long)ret->len, (long)wlen);
+ fieldlen = strlen(msg->cm_fields[(int)forder[i]]);
+ ret->ser[wlen++] = (char)forder[i];
+ safestrncpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]], fieldlen+1);
+ wlen = wlen + fieldlen + 1;
+ }
+ if (ret->len != wlen) syslog(LOG_ERR, "ERROR: len=%ld wlen=%ld\n",
+ (long)ret->len, (long)wlen);
return;
}
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");
+ syslog(LOG_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]]);
+ msg->cm_fields[(int)forder[i]]);
client_write (buf, strlen(buf));
}
if (DoesThisRoomNeedEuidIndexing(&CC->room) == 0) return;
- CtdlLogPrintf(CTDL_DEBUG, "Performing replication checks in <%s>\n",
- CC->room.QRname);
+ 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",
- msg->cm_fields['E'], CC->room.QRname);*/
+ /*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, "");
}
}
struct recptypes *recps, /* recipients (if mail) */
char *force, /* force a particular room? */
int flags /* should the message be exported clean? */
-) {
+ )
+{
char submit_filename[128];
char generated_timestamp[32];
char hold_rm[ROOMNAMELEN];
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;
safestrncpy(smi.meta_content_type, content_type,
- sizeof smi.meta_content_type);
+ sizeof smi.meta_content_type);
/*
* Measure how big this message will be when rendered as RFC822.
* 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);
}
}
/* If other rooms are specified, drop them there too. */
if ((recps != NULL) && (recps->num_room > 0))
- 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);
- CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
- }
+ for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
+ extract_token(recipient, recps->recp_room, i,
+ '|', sizeof 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);
* recipient's mailbox and bump the reference count.
*/
if ((recps != NULL) && (recps->num_local > 0))
- 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",
- recipient);
- if (CtdlGetUser(&userbuf, recipient) == 0) {
- // Add a flag so the Funambol module knows its mail
- msg->cm_fields['W'] = strdup(recipient);
- CtdlMailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
- CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
- CtdlBumpNewMailCounter(userbuf.usernum);
- 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_alloc = 1024;
- instr = malloc(instr_alloc);
- snprintf(instr, instr_alloc,
- "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
- "bounceto|%s\n",
- SPOOLMIME, newmsgid, (long)time(NULL),
- bounce_to
- );
-
- 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, 0);
- CtdlFreeMessage(imsg);
+ for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
+ extract_token(recipient, recps->recp_local, i,
+ '|', sizeof recipient);
+ 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
+ msg->cm_fields['W'] = strdup(recipient);
+ CtdlMailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
+ CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
+ CtdlBumpNewMailCounter(userbuf.usernum);
+ 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_alloc = 1024;
+ instr = malloc(instr_alloc);
+ snprintf(instr, instr_alloc,
+ "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
+ "bounceto|%s\n",
+ SPOOLMIME, newmsgid, (long)time(NULL),
+ bounce_to
+ );
+
+ 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, 0);
+ CtdlFreeMessage(imsg);
+ }
+ }
+ else {
+ syslog(LOG_DEBUG, "No user <%s>\n", recipient);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom,
+ newmsgid, 0, msg);
}
}
- else {
- CtdlLogPrintf(CTDL_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
* a network spool receiver that can handle the new style messages.
*/
if ((recps != NULL) && (recps->num_ignet > 0))
- for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
- extract_token(recipient, recps->recp_ignet, i,
- '|', sizeof recipient);
-
- hold_R = msg->cm_fields['R'];
- hold_D = msg->cm_fields['D'];
- msg->cm_fields['R'] = malloc(SIZ);
- msg->cm_fields['D'] = malloc(128);
- extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
- extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
+ for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
+ extract_token(recipient, recps->recp_ignet, i,
+ '|', sizeof recipient);
+
+ hold_R = msg->cm_fields['R'];
+ hold_D = msg->cm_fields['D'];
+ msg->cm_fields['R'] = malloc(SIZ);
+ msg->cm_fields['D'] = malloc(128);
+ extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
+ extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
- serialize_message(&smr, msg);
- if (smr.len > 0) {
- snprintf(submit_filename, sizeof submit_filename,
+ serialize_message(&smr, msg);
+ if (smr.len > 0) {
+ snprintf(submit_filename, sizeof submit_filename,
"%s/netmail.%04lx.%04x.%04x",
ctdl_netin_dir,
(long) getpid(), CCC->cs_pid, ++seqnum);
- network_fp = fopen(submit_filename, "wb+");
- if (network_fp != NULL) {
- rv = fwrite(smr.ser, smr.len, 1, network_fp);
- fclose(network_fp);
+ network_fp = fopen(submit_filename, "wb+");
+ if (network_fp != NULL) {
+ rv = fwrite(smr.ser, smr.len, 1, network_fp);
+ if (rv == -1) {
+ syslog(LOG_EMERG, "CtdlSubmitMsg(): Couldn't write network spool file: %s\n",
+ strerror(errno));
+ }
+ fclose(network_fp);
+ }
+ free(smr.ser);
}
- free(smr.ser);
- }
- free(msg->cm_fields['R']);
- free(msg->cm_fields['D']);
- msg->cm_fields['R'] = hold_R;
- msg->cm_fields['D'] = hold_D;
- }
+ free(msg->cm_fields['R']);
+ free(msg->cm_fields['D']);
+ msg->cm_fields['R'] = hold_R;
+ msg->cm_fields['D'] = hold_D;
+ }
/* 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,
- "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
- "bounceto|%s\n",
- SPOOLMIME, newmsgid, (long)time(NULL),
- bounce_to
- );
+ "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
+ "bounceto|%s\n",
+ SPOOLMIME, newmsgid, (long)time(NULL),
+ bounce_to
+ );
if (recps->envelope_from != NULL) {
tmp = strlen(instr);
aptr = (struct addresses_to_be_filed *)
malloc(sizeof(struct addresses_to_be_filed));
CtdlMailboxName(actual_rm, sizeof actual_rm,
- &CCC->user, USERCONTACTSROOM);
+ &CCC->user, USERCONTACTSROOM);
aptr->roomname = strdup(actual_rm);
aptr->collected_addresses = collected_addresses;
begin_critical_section(S_ATBF);
* Convenience function for generating small administrative messages.
*/
void quickie_message(const char *from, const char *fromaddr, char *to, char *room, const char *text,
- int format_type, const char *subject)
+ int format_type, const char *subject)
{
struct CtdlMessage *msg;
struct recptypes *recp = NULL;
exist is ALWAYS freed */
int crlf, /* CRLF newlines instead of LF */
int *sock /* socket handle or 0 for this session's client socket */
- )
+ )
{
StrBuf *Message;
StrBuf *LineBuf;
char *supplied_euid, /* ...or NULL if this is irrelevant */
char *preformatted_text, /* ...or NULL to read text from client */
char *references /* Thread references */
-) {
+ ) {
char dest_node[256];
char buf[1024];
struct CtdlMessage *msg;
return(msg);
}
+extern int netconfig_check_roomaccess(
+ char *errmsgbuf,
+ size_t n,
+ const char* RemoteIdentifier); /* TODO: find a smarter way */
/*
* Check to see whether we have permission to post a message in the current
const char* RemoteIdentifier,
int PostPublic,
int is_reply
-) {
+ ) {
int ra;
if (!(CC->logged_in) &&
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 netconfig_check_roomaccess(errmsgbuf, n, RemoteIdentifier);
}
return (0);
if ((CC->user.axlevel < AxProbU)
&& ((CC->room.QRflags & QR_MAILBOX) == 0)) {
- snprintf(errmsgbuf, n, "Need to be validated to enter "
- "(except in %s> to sysop)", MAILROOM);
+ snprintf(errmsgbuf, n, "Need to be validated to enter (except in %s> to sysop)", MAILROOM);
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
CtdlRoomAccess(&CC->room, &CC->user, &ra, NULL);
- if ( (!(ra & UA_POSTALLOWED)) && (ra & UA_REPLYALLOWED) && (!is_reply) ) {
+ if (ra & UA_POSTALLOWED) {
+ strcpy(errmsgbuf, "OK to post or reply here");
+ return(0);
+ }
+
+ if ( (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);
+ strcpy(errmsgbuf, "OK to reply here");
+ return(0);
}
- else if (!(ra & UA_POSTALLOWED)) {
- snprintf(errmsgbuf, n, "Higher access is required to post in this room.");
+ if ( (ra & UA_REPLYALLOWED) && (!is_reply) ) {
+ /* Clarify what happened with a better error message */
+ snprintf(errmsgbuf, n, "You may only reply to existing messages here.");
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
- strcpy(errmsgbuf, "Ok");
- return(0);
+ 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);
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 (!IsEmptyStr(ret->recp_room)) {
- strcat(ret->recp_room, "|");
- }
- strcat(ret->recp_room, this_recp);
+ case MES_LOCAL:
+ if (!strcasecmp(this_recp, "sysop")) {
+ ++ret->num_room;
+ strcpy(this_recp, config.c_aideroom);
+ if (!IsEmptyStr(ret->recp_room)) {
+ strcat(ret->recp_room, "|");
}
- else if ( (!strncasecmp(this_recp, "room_", 5))
- && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
+ strcat(ret->recp_room, this_recp);
+ }
+ else if ( (!strncasecmp(this_recp, "room_", 5))
+ && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
- /* Save room so we can restore it later */
- tempQR2 = CC->room;
- CC->room = tempQR;
+ /* 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,
- 0 /* 0 = not a reply */
+ /* Check permissions to send mail to this room */
+ err = CtdlDoIHavePermissionToPostInThisRoom(
+ errmsg,
+ sizeof errmsg,
+ RemoteIdentifier,
+ Flags,
+ 0 /* 0 = not a reply */
);
- 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 (CtdlGetUser(&tempUS, this_recp) == 0) {
- ++ret->num_local;
- strcpy(this_recp, tempUS.fullname);
- if (!IsEmptyStr(ret->recp_local)) {
- strcat(ret->recp_local, "|");
- }
- strcat(ret->recp_local, this_recp);
- }
- else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
- ++ret->num_local;
- strcpy(this_recp, tempUS.fullname);
- if (!IsEmptyStr(ret->recp_local)) {
- strcat(ret->recp_local, "|");
- }
- strcat(ret->recp_local, this_recp);
- }
- else {
- ++ret->num_error;
- invalid = 1;
- }
- break;
- case MES_INTERNET:
- /* Yes, you're reading this correctly: if the target
- * domain points back to the local system or an attached
- * Citadel directory, the address is invalid. That's
- * because if the address were valid, we would have
- * already translated it to a local address by now.
- */
- if (IsDirectory(this_recp, 0)) {
+ if (err)
+ {
++ret->num_error;
invalid = 1;
- }
+ }
else {
- ++ret->num_internet;
- if (!IsEmptyStr(ret->recp_internet)) {
- strcat(ret->recp_internet, "|");
+ ++ret->num_room;
+ if (!IsEmptyStr(ret->recp_room)) {
+ strcat(ret->recp_room, "|");
}
- strcat(ret->recp_internet, this_recp);
+ strcat(ret->recp_room, &this_recp_cooked[5]);
}
- break;
- case MES_IGNET:
- ++ret->num_ignet;
- if (!IsEmptyStr(ret->recp_ignet)) {
- strcat(ret->recp_ignet, "|");
+
+ /* Restore room in case something needs it */
+ CC->room = tempQR2;
+
+ }
+ else if (CtdlGetUser(&tempUS, this_recp) == 0) {
+ ++ret->num_local;
+ strcpy(this_recp, tempUS.fullname);
+ if (!IsEmptyStr(ret->recp_local)) {
+ strcat(ret->recp_local, "|");
}
- strcat(ret->recp_ignet, this_recp);
- break;
- case MES_ERROR:
+ strcat(ret->recp_local, this_recp);
+ }
+ else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
+ ++ret->num_local;
+ strcpy(this_recp, tempUS.fullname);
+ if (!IsEmptyStr(ret->recp_local)) {
+ strcat(ret->recp_local, "|");
+ }
+ strcat(ret->recp_local, this_recp);
+ }
+ else {
++ret->num_error;
invalid = 1;
- break;
+ }
+ break;
+ case MES_INTERNET:
+ /* Yes, you're reading this correctly: if the target
+ * domain points back to the local system or an attached
+ * Citadel directory, the address is invalid. That's
+ * because if the address were valid, we would have
+ * already translated it to a local address by now.
+ */
+ if (IsDirectory(this_recp, 0)) {
+ ++ret->num_error;
+ invalid = 1;
+ }
+ else {
+ ++ret->num_internet;
+ if (!IsEmptyStr(ret->recp_internet)) {
+ strcat(ret->recp_internet, "|");
+ }
+ strcat(ret->recp_internet, this_recp);
+ }
+ break;
+ case MES_IGNET:
+ ++ret->num_ignet;
+ if (!IsEmptyStr(ret->recp_ignet)) {
+ strcat(ret->recp_ignet, "|");
+ }
+ strcat(ret->recp_ignet, this_recp);
+ break;
+ case MES_ERROR:
+ ++ret->num_error;
+ invalid = 1;
+ break;
}
if (invalid) {
if (IsEmptyStr(errmsg)) {
}
if ((ret->num_local + ret->num_internet + ret->num_ignet +
- ret->num_room + ret->num_error) == 0) {
+ ret->num_room + ret->num_error) == 0) {
ret->num_error = (-1);
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();
}
extract_token(cc, entargs, 7, '|', sizeof cc);
extract_token(bcc, entargs, 8, '|', sizeof bcc);
switch(CC->room.QRdefaultview) {
- case VIEW_NOTES:
- case VIEW_WIKI:
- extract_token(supplied_euid, entargs, 9, '|', sizeof supplied_euid);
- break;
- default:
- supplied_euid[0] = 0;
- break;
+ case VIEW_NOTES:
+ case VIEW_WIKI:
+ extract_token(supplied_euid, entargs, 9, '|', sizeof supplied_euid);
+ break;
+ default:
+ supplied_euid[0] = 0;
+ break;
}
extract_token(newuseremail, entargs, 10, '|', sizeof newuseremail);
extract_token(references, entargs, 11, '|', sizeof references);
NULL,
POST_LOGGED_IN,
(!IsEmptyStr(references)) /* is this a reply? or a top-level post? */
- );
+ );
if (err)
{
cprintf("%d %s\n", err, errmsg);
strcpy(newusername, CC->user.fullname);
}
if ( (CC->user.axlevel < AxAideU)
- && (strcasecmp(newusername, CC->user.fullname))
- && (strcasecmp(newusername, CC->cs_inet_fn))
- ) {
+ && (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;
}
cprintf("%d You don't have permission to author messages as '%s'.\n",
ERROR + HIGHER_ACCESS_REQUIRED,
newuseremail
- );
+ );
return;
}
*/
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 ) {
+ || ( (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, "");
}
if ( ( (valid_to->num_internet + valid_to->num_ignet + valid_cc->num_internet + valid_cc->num_ignet + valid_bcc->num_internet + valid_bcc->num_ignet) > 0)
- && (CC->user.axlevel < AxNetU) ) {
+ && (CC->user.axlevel < AxNetU) ) {
cprintf("%d Higher access required for network mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
free_recipients(valid_to);
}
msg = CtdlMakeMessage(&CC->user, recp, cc,
- CC->room.QRname, anonymous, format_type,
- newusername, newuseremail, subject,
- ((!IsEmptyStr(supplied_euid)) ? supplied_euid : NULL),
- NULL, references);
+ CC->room.QRname, anonymous, format_type,
+ newusername, newuseremail, subject,
+ ((!IsEmptyStr(supplied_euid)) ? supplied_euid : NULL),
+ NULL, references);
/* Put together one big recipients struct containing to/cc/bcc all in
* one. This is for the envelope.
* (returns the actual number of messages deleted)
*/
int CtdlDeleteMessages(char *room_name, /* which room */
- 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. */
-)
+ 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;
int need_to_free_re = 0;
if (content_type) if (!IsEmptyStr(content_type)) {
- regcomp(&re, content_type, 0);
- need_to_free_re = 1;
- }
- CtdlLogPrintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %d msgs, %s)\n",
- room_name, num_dmsgnums, content_type);
+ regcomp(&re, content_type, 0);
+ need_to_free_re = 1;
+ }
+ 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",
- room_name);
+ syslog(LOG_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
+ room_name);
if (need_to_free_re) regfree(&re);
return (0); /* room not found */
}
* section.
*/
if (num_deleted) for (i=0; i<num_deleted; ++i) {
- PerformDeleteHooks(qrbuf.QRname, dellist[i]);
- AdjRefCount(dellist[i], -1);
- }
+ PerformDeleteHooks(qrbuf.QRname, dellist[i]);
+ AdjRefCount(dellist[i], -1);
+ }
/* 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);
}
/* Permit move/copy from personal rooms */
if ((CC->room.QRflags & QR_MAILBOX)
- && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+ && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
/* Permit only copy from public to personal room */
if ( (is_copy)
- && (!(CC->room.QRflags & QR_MAILBOX))
- && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+ && (!(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;
struct arcq new_arcq;
int rv = 0;
- CtdlLogPrintf(CTDL_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
- msgnum, incr
- );
+ syslog(LOG_DEBUG, "AdjRefCount() msg %ld ref count delta %+d\n",
+ msgnum, incr
+ );
begin_critical_section(S_SUPPMSGMAIN);
if (arcfp == NULL) {
/* 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);
new_arcq.arcq_msgnum = msgnum;
new_arcq.arcq_delta = incr;
rv = fwrite(&new_arcq, sizeof(struct arcq), 1, arcfp);
+ if (rv == -1) {
+ syslog(LOG_EMERG, "Couldn't write Refcount Queue File %s: %s\n",
+ file_arcq,
+ strerror(errno));
+ }
fflush(arcfp);
return;
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",
- msgnum, incr, smi.meta_refcount
- );
+ syslog(LOG_DEBUG, "TDAP_AdjRefCount() 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) {
- 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);
* files, and still pull the message into memory as with all others.
*/
void CtdlWriteObject(char *req_room, /* Room to stuff it in */
- char *content_type, /* MIME type of this object */
- char *raw_message, /* Data to be written */
- off_t raw_length, /* Size of raw_message */
- struct ctdluser *is_mailbox, /* Mailbox room? */
- int is_binary, /* Is encoding necessary? */
- int is_unique, /* Del others of this type? */
- unsigned int flags /* Internal save flags */
- )
+ char *content_type, /* MIME type of this object */
+ char *raw_message, /* Data to be written */
+ off_t raw_length, /* Size of raw_message */
+ struct ctdluser *is_mailbox, /* Mailbox room? */
+ int is_binary, /* Is encoding necessary? */
+ int is_unique, /* Del others of this type? */
+ unsigned int flags /* Internal save flags */
+ )
{
struct ctdlroom qrbuf;
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 ) );
if (is_binary) {
sprintf(&encoded_message[strlen(encoded_message)],
"Content-transfer-encoding: base64\n\n"
- );
+ );
}
else {
sprintf(&encoded_message[strlen(encoded_message)],
"Content-transfer-encoding: 7bit\n\n"
- );
+ );
}
if (is_binary) {
raw_message,
(int)raw_length,
0
- );
+ );
}
else {
memcpy(
&encoded_message[strlen(encoded_message)],
raw_message,
(int)(raw_length+1)
- );
+ );
}
- 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;
/* Create the requested room if we have to. */
if (CtdlGetRoom(&qrbuf, roomname) != 0) {
CtdlCreateRoom(roomname,
- ( (is_mailbox != NULL) ? 5 : 3 ),
- "", 0, 1, 0, VIEW_BBS);
+ ( (is_mailbox != NULL) ? 5 : 3 ),
+ "", 0, 1, 0, VIEW_BBS);
}
/* If the caller specified this object as unique, delete all
* 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",
- CtdlDeleteMessages(roomname, NULL, 0, content_type)
- );
+ syslog(LOG_DEBUG, "Deleted %d other msgs of this type\n",
+ CtdlDeleteMessages(roomname, NULL, 0, content_type)
+ );
}
/* Now write the data */
CtdlSubmitMsg(msg, NULL, roomname, 0);
begin_critical_section(S_CONFIG);
config_msgnum = (-1L);
CtdlForEachMessage(MSGS_LAST, 1, NULL, sysconfname, NULL,
- CtdlGetSysConfigBackend, NULL);
+ CtdlGetSysConfigBackend, NULL);
msgnum = config_msgnum;
end_critical_section(S_CONFIG);
CtdlGetRoom(&CC->room, hold_rm);
if (conf != NULL) do {
- extract_token(buf, conf, 0, '\n', sizeof buf);
- strcpy(conf, &conf[strlen(buf)+1]);
- } while ( (!IsEmptyStr(conf)) && (!IsEmptyStr(buf)) );
+ extract_token(buf, conf, 0, '\n', sizeof buf);
+ strcpy(conf, &conf[strlen(buf)+1]);
+ } while ( (!IsEmptyStr(conf)) && (!IsEmptyStr(buf)) );
return(conf);
}
projects / citadel.git / blobdiff