* $Id$
*
* Implements the message store.
+ *
+ * Copyright (c) 1987-2010 by the citadel.org team
+ *
+ * This program is free 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
*
+ * 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
*/
#include "sysdep.h"
CtdlFreeMessage(msg);
}
+/*
+ * Back end for the MSGS command: output EUID header.
+ */
+void headers_euid(long msgnum, void *userdata)
+{
+ struct CtdlMessage *msg;
+
+ msg = CtdlFetchMessage(msgnum, 0);
+ if (msg == NULL) {
+ cprintf("%ld||\n", msgnum);
+ return;
+ }
+
+ cprintf("%ld|%s|\n", msgnum, (msg->cm_fields['E'] ? msg->cm_fields['E'] : ""));
+ CtdlFreeMessage(msg);
+}
+
+
+
/* Determine if a given message matches the fields in a message template.
StrBuf *histr;
const char *pvset;
char *is_set; /* actually an array of booleans */
- int w = 0;
/* Don't bother doing *anything* if we were passed a list of zero messages */
if (num_target_msgnums < 1) {
lostr = NewStrBuf();
histr = NewStrBuf();
pvset = NULL;
- while (StrBufExtract_NextToken(setstr, vset, &pvset, ',')) {
- /* CtdlLogPrintf(CTDL_DEBUG, "Token: '%s'\n", ChrPtr(setstr)); NOTE ZERO-LENGTH TOKENS */
+ while (StrBufExtract_NextToken(setstr, vset, &pvset, ',') >= 0) {
StrBufExtract_token(lostr, setstr, 0, ':');
if (StrBufNum_tokens(setstr, ':') >= 2) {
}
}
- w = 0; /* set to 1 if we write something to the string */
-
if ((was_seen == 0) && (is_seen == 1)) {
lo = msglist[i];
}
else if ((was_seen == 1) && (is_seen == 0)) {
hi = msglist[i-1];
- w = 1;
if (StrLength(vset) > 0) {
StrBufAppendBufPlain(vset, HKEY(","), 0);
StrBufAppendPrintf(vset, "%ld:%ld", lo, hi);
}
}
- else if ((is_seen) && (i == num_msgs - 1)) {
- w = 1;
+
+ if ((is_seen) && (i == num_msgs - 1)) {
if (StrLength(vset) > 0) {
StrBufAppendBufPlain(vset, HKEY(","), 0);
}
}
}
- /* If the string is getting too long, truncate it at the beginning; repeat up to 9 times * /
- if (w) for (j=0; j<9; ++j) {
- if ((StrLength(vset) + 20) > sizeof vset) {
- remove_token(vset, 0, ',');
- if (which_set == ctdlsetseen_seen) {
- char temp[SIZ];
- sprintf(temp, "1:%ld,", atol(vset)-1L);
- strcat(temp, vset);
- strcpy(vset, temp);
- }
- }
- }
- we don't get to long anymore.
- */
-
was_seen = is_seen;
}
- while (StrLength(vset) > SIZ)
+ /*
+ * We will have to stuff this string back into a 4096 byte buffer, so if it's
+ * larger than that now, truncate it by removing tokens from the beginning.
+ * The limit of 100 iterations is there to prevent an infinite loop in case
+ * something unexpected happens.
+ */
+ int number_of_truncations = 0;
+ while ( (StrLength(vset) > SIZ) && (number_of_truncations < 100) ) {
+ StrBufRemove_token(vset, 0, ',');
+ ++number_of_truncations;
+ }
+
+ /*
+ * If we're truncating the sequence set of messages marked with the 'seen' flag,
+ * we want the earliest messages (the truncated ones) to be marked, not unmarked.
+ * Otherwise messages at the beginning will suddenly appear to be 'unseen'.
+ */
+ if ( (which_set == ctdlsetseen_seen) && (number_of_truncations > 0) ) {
+ StrBuf *first_tok;
+ first_tok = NewStrBuf();
+ StrBufExtract_token(first_tok, vset, 0, ',');
StrBufRemove_token(vset, 0, ',');
+ if (StrBufNum_tokens(first_tok, ':') > 1) {
+ StrBufRemove_token(first_tok, 0, ':');
+ }
+
+ StrBuf *new_set;
+ new_set = NewStrBuf();
+ StrBufAppendBufPlain(new_set, HKEY("1:"), 0);
+ StrBufAppendBuf(new_set, first_tok, 0);
+ StrBufAppendBufPlain(new_set, HKEY(":"), 0);
+ StrBufAppendBuf(new_set, vset, 0);
+
+ FreeStrBuf(&vset);
+ FreeStrBuf(&first_tok);
+ vset = new_set;
+ }
+
CtdlLogPrintf(CTDL_DEBUG, " after update: %s\n", ChrPtr(vset));
/* Decide which message set we're manipulating */
int CtdlForEachMessage(int mode, long ref, char *search_string,
char *content_type,
struct CtdlMessage *compare,
- void (*CallBack) (long, void *),
+ ForEachMsgCallback CallBack,
void *userdata)
{
}
/* Learn about the user and room in question */
- getuser(&CC->user, CC->curr_user);
+ CtdlGetUser(&CC->user, CC->curr_user);
CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
/* Load the message list */
|| ((mode == MSGS_LAST) && (a >= (num_msgs - ref)))
|| ((mode == MSGS_FIRST) && (a < ref))
|| ((mode == MSGS_GT) && (thismsg > ref))
+ || ((mode == MSGS_LT) && (thismsg < ref))
|| ((mode == MSGS_EQ) && (thismsg == ref))
)
) {
int i;
int with_template = 0;
struct CtdlMessage *template = NULL;
- int with_headers = 0;
char search_string[1024];
+ ForEachMsgCallback CallBack;
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);
+ switch (extract_int(cmdbuf, 3))
+ {
+ default:
+ case MSG_HDRS_BRIEF:
+ CallBack = simple_listing;
+ break;
+ case MSG_HDRS_ALL:
+ CallBack = headers_listing;
+ break;
+ case MSG_HDRS_EUID:
+ CallBack = headers_euid;
+ break;
+ }
strcat(which, " ");
if (!strncasecmp(which, "OLD", 3))
mode = MSGS_LAST;
else if (!strncasecmp(which, "GT", 2))
mode = MSGS_GT;
+ else if (!strncasecmp(which, "LT", 2))
+ mode = MSGS_LT;
else if (!strncasecmp(which, "SEARCH", 6))
mode = MSGS_SEARCH;
else
}
CtdlForEachMessage(mode,
- ( (mode == MSGS_SEARCH) ? 0 : cm_ref ),
- ( (mode == MSGS_SEARCH) ? search_string : NULL ),
- NULL,
- template,
- (with_headers ? headers_listing : simple_listing),
- NULL
- );
+ ( (mode == MSGS_SEARCH) ? 0 : cm_ref ),
+ ( (mode == MSGS_SEARCH) ? search_string : NULL ),
+ NULL,
+ template,
+ CallBack,
+ NULL);
if (template != NULL) CtdlFreeMessage(template);
cprintf("000\n");
}
*/
void memfmout(
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 */
+ const char *nl) /* string to terminate lines with */
{
- int a, b, c;
+ int b, c;
int real = 0;
int old = 0;
cit_uint8_t ch;
c = 1; /* c is the current pos */
do {
- if (subst) {
- while (ch = *mptr, ((ch != 0) && (strlen(buffer) < 126))) {
- ch = *mptr++;
- buffer[strlen(buffer) + 1] = 0;
- buffer[strlen(buffer)] = ch;
- }
-
- if (buffer[0] == '^')
- do_help_subst(buffer);
-
- buffer[strlen(buffer) + 1] = 0;
- a = buffer[0];
- strcpy(buffer, &buffer[1]);
- } else {
- ch = *mptr++;
- }
+ ch = *mptr++;
old = real;
real = ch;
+
+
+int CtdlDoIHavePermissionToReadMessagesInThisRoom(void) {
+ if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
+ return(om_not_logged_in);
+ }
+ return(om_ok);
+}
+
+
/*
* Get a message off disk. (returns om_* values found in msgbase.h)
*
int do_proto, /* do Citadel protocol responses? */
int crlf, /* Use CRLF newlines instead of LF? */
char *section, /* NULL or a message/rfc822 section */
- int flags /* should the bessage be exported clean? */
+ int flags /* various flags; see msgbase.h */
) {
struct CtdlMessage *TheMessage = NULL;
int retcode = om_no_such_msg;
struct encapmsg encap;
+ int r;
- CtdlLogPrintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d, section=%s\n",
+ CtdlLogPrintf(CTDL_DEBUG, "CtdlOutputMsg(msgnum=%ld, mode=%d, section=%s)\n",
msg_num, mode,
(section ? section : "<>")
);
- if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
- if (do_proto) cprintf("%d Not logged in.\n",
- ERROR + NOT_LOGGED_IN);
- return(om_not_logged_in);
+ r = CtdlDoIHavePermissionToReadMessagesInThisRoom();
+ if (r != om_ok) {
+ if (do_proto) {
+ if (r == om_not_logged_in) {
+ cprintf("%d Not logged in.\n", ERROR + NOT_LOGGED_IN);
+ }
+ else {
+ cprintf("%d An unknown error has occurred.\n", ERROR);
+ }
+ }
+ return(r);
}
/* FIXME: check message id against msglist for this room */
char allkeys[30];
char display_name[256];
char *mptr, *mpptr;
- char *nl; /* newline string */
+ const char *nl; /* newline string */
int suppress_f = 0;
int subject_found = 0;
struct ma_info ma;
return(om_no_such_msg);
}
+ /* Suppress envelope recipients if required to avoid disclosing BCC addresses.
+ * Pad it with spaces in order to avoid changing the RFC822 length of the message.
+ */
+ if ( (flags & SUPPRESS_ENV_TO) && (TheMessage->cm_fields['V'] != NULL) ) {
+ memset(TheMessage->cm_fields['V'], ' ', strlen(TheMessage->cm_fields['V']));
+ }
+
/* Are we downloading a MIME component? */
if (mode == MT_DOWNLOAD) {
if (TheMessage->cm_format_type != FMT_RFC822) {
if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
suppress_f = 1;
}
-
+
/* Now spew the header fields in the order we like them. */
safestrncpy(allkeys, FORDER, sizeof allkeys);
for (i=0; i<strlen(allkeys); ++i) {
if (mode == MT_MIME) {
cprintf("Content-type: text/x-citadel-variformat\n\n");
}
- memfmout(mptr, 0, nl);
+ memfmout(mptr, nl);
}
/* If the message on disk is format 4 (MIME), we've gotta hand it
if (num_newmsgs > 1) supplied_msg = NULL;
/* Now the regular stuff */
- if (lgetroom(&CC->room,
+ if (CtdlGetRoomLock(&CC->room,
((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
CtdlLogPrintf(CTDL_ERR, "No such room <%s>\n", roomname);
/* Update the highest-message pointer and unlock the room. */
CC->room.QRhighest = highest_msg;
- lputroom(&CC->room);
+ CtdlPutRoomLock(&CC->room);
/* Perform replication checks if necessary */
if ( (DoesThisRoomNeedEuidIndexing(&CC->room)) && (do_repl_check) ) {
PerformRoomHooks(&CC->room);
/* Go back to the room we were in before we wandered here... */
- getroom(&CC->room, hold_rm);
+ CtdlGetRoom(&CC->room, hold_rm);
/* Bump the reference count for all messages which were merged */
for (i=0; i<num_msgs_to_be_merged; ++i) {
/*CtdlLogPrintf(CTDL_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
msg->cm_fields['E'], CC->room.QRname);*/
- old_msgnum = locate_message_by_euid(msg->cm_fields['E'], &CC->room);
+ old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields['E'], &CC->room);
if (old_msgnum > 0L) {
CtdlLogPrintf(CTDL_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? */
- int flags /* should the bessage be exported clean? */
+ int flags /* should the message be exported clean? */
) {
char submit_filename[128];
char generated_timestamp[32];
struct addresses_to_be_filed *aptr = NULL;
char *saved_rfc822_version = NULL;
int qualified_for_journaling = 0;
- struct CitContext *CCC = CC; /* CachedCitContext - performance boost */
+ CitContext *CCC = CC; /* CachedCitContext - performance boost */
char bounce_to[1024] = "";
size_t tmp = 0;
int rv = 0;
CtdlLogPrintf(CTDL_DEBUG, "Final selection: %s\n", actual_rm);
if (strcasecmp(actual_rm, CCC->room.QRname)) {
- /* getroom(&CCC->room, actual_rm); */
- usergoto(actual_rm, 0, 1, NULL, NULL);
+ /* CtdlGetRoom(&CCC->room, actual_rm); */
+ CtdlUserGoto(actual_rm, 0, 1, NULL, NULL);
}
/*
/* Bump this user's messages posted counter. */
CtdlLogPrintf(CTDL_DEBUG, "Updating user\n");
- lgetuser(&CCC->user, CCC->curr_user);
+ CtdlGetUserLock(&CCC->user, CCC->curr_user);
CCC->user.posted = CCC->user.posted + 1;
- lputuser(&CCC->user);
+ CtdlPutUserLock(&CCC->user);
/* Decide where bounces need to be delivered */
if ((recps != NULL) && (recps->bounce_to != NULL)) {
'|', sizeof recipient);
CtdlLogPrintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
recipient);
- if (getuser(&userbuf, recipient) == 0) {
+ if (CtdlGetUser(&userbuf, recipient) == 0) {
// Add a flag so the Funambol module knows its mail
msg->cm_fields['W'] = strdup(recipient);
- MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
+ CtdlMailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0, msg);
- BumpNewMailCounter(userbuf.usernum);
+ 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
/* Go back to the room we started from */
CtdlLogPrintf(CTDL_DEBUG, "Returning to original room %s\n", hold_rm);
if (strcasecmp(hold_rm, CCC->room.QRname))
- usergoto(hold_rm, 0, 1, NULL, NULL);
+ CtdlUserGoto(hold_rm, 0, 1, NULL, NULL);
/* For internet mail, generate delivery instructions.
* Yes, this is recursive. Deal with it. Infinite recursion does
if (collected_addresses != NULL) {
aptr = (struct addresses_to_be_filed *)
malloc(sizeof(struct addresses_to_be_filed));
- MailboxName(actual_rm, sizeof actual_rm,
+ CtdlMailboxName(actual_rm, sizeof actual_rm,
&CCC->user, USERCONTACTSROOM);
aptr->roomname = strdup(actual_rm);
aptr->collected_addresses = collected_addresses;
+void aide_message (char *text, char *subject)
+{
+ quickie_message("Citadel",NULL,NULL,AIDEROOM,text,FMT_CITADEL,subject);
+}
/*
strcat(ret->recp_room, this_recp);
}
else if ( (!strncasecmp(this_recp, "room_", 5))
- && (!getroom(&tempQR, &this_recp_cooked[5])) ) {
+ && (!CtdlGetRoom(&tempQR, &this_recp_cooked[5])) ) {
/* Save room so we can restore it later */
tempQR2 = CC->room;
CC->room = tempQR2;
}
- else if (getuser(&tempUS, this_recp) == 0) {
+ else if (CtdlGetUser(&tempUS, this_recp) == 0) {
++ret->num_local;
strcpy(this_recp, tempUS.fullname);
if (!IsEmptyStr(ret->recp_local)) {
}
strcat(ret->recp_local, this_recp);
}
- else if (getuser(&tempUS, this_recp_cooked) == 0) {
+ else if (CtdlGetUser(&tempUS, this_recp_cooked) == 0) {
++ret->num_local;
strcpy(this_recp, tempUS.fullname);
if (!IsEmptyStr(ret->recp_local)) {
room_name, num_dmsgnums, content_type);
/* get room record, obtaining a lock... */
- if (lgetroom(&qrbuf, room_name) != 0) {
+ if (CtdlGetRoomLock(&qrbuf, room_name) != 0) {
CtdlLogPrintf(CTDL_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
room_name);
if (need_to_free_re) regfree(&re);
qrbuf.QRhighest = msglist[num_msgs - 1];
}
- lputroom(&qrbuf);
+ CtdlPutRoomLock(&qrbuf);
/* 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
targ[ROOMNAMELEN - 1] = 0;
is_copy = extract_int(args, 2);
- if (getroom(&qtemp, targ) != 0) {
+ if (CtdlGetRoom(&qtemp, targ) != 0) {
cprintf("%d '%s' does not exist.\n", ERROR + ROOM_NOT_FOUND, targ);
return;
}
return;
}
- getuser(&CC->user, CC->curr_user);
+ CtdlGetUser(&CC->user, CC->curr_user);
CtdlRoomAccess(&qtemp, &CC->user, &ra, NULL);
/* Check for permission to perform this operation.
char *encoded_message = NULL;
if (is_mailbox != NULL) {
- MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
+ CtdlMailboxName(roomname, sizeof roomname, is_mailbox, req_room);
}
else {
safestrncpy(roomname, req_room, sizeof(roomname));
msg->cm_fields['M'] = encoded_message;
/* Create the requested room if we have to. */
- if (getroom(&qrbuf, roomname) != 0) {
- create_room(roomname,
+ if (CtdlGetRoom(&qrbuf, roomname) != 0) {
+ CtdlCreateRoom(roomname,
( (is_mailbox != NULL) ? 5 : 3 ),
"", 0, 1, 0, VIEW_BBS);
}
char buf[SIZ];
strcpy(hold_rm, CC->room.QRname);
- if (getroom(&CC->room, SYSCONFIGROOM) != 0) {
- getroom(&CC->room, hold_rm);
+ if (CtdlGetRoom(&CC->room, SYSCONFIGROOM) != 0) {
+ CtdlGetRoom(&CC->room, hold_rm);
return NULL;
}
}
}
- getroom(&CC->room, hold_rm);
+ CtdlGetRoom(&CC->room, hold_rm);
if (conf != NULL) do {
extract_token(buf, conf, 0, '\n', sizeof buf);
CTDL_MODULE_INIT(msgbase)
{
- CtdlRegisterProtoHook(cmd_msgs, "MSGS", "Output a list of messages in the current room");
- CtdlRegisterProtoHook(cmd_msg0, "MSG0", "Output a message in plain text format");
- CtdlRegisterProtoHook(cmd_msg2, "MSG2", "Output a message in RFC822 format");
- CtdlRegisterProtoHook(cmd_msg3, "MSG3", "Output a message in raw format (deprecated)");
- CtdlRegisterProtoHook(cmd_msg4, "MSG4", "Output a message in the client's preferred format");
- CtdlRegisterProtoHook(cmd_msgp, "MSGP", "Select preferred format for MSG4 output");
- CtdlRegisterProtoHook(cmd_opna, "OPNA", "Open an attachment for download");
- CtdlRegisterProtoHook(cmd_dlat, "DLAT", "Download an attachment");
- CtdlRegisterProtoHook(cmd_ent0, "ENT0", "Enter a message");
- CtdlRegisterProtoHook(cmd_dele, "DELE", "Delete a message");
- CtdlRegisterProtoHook(cmd_move, "MOVE", "Move or copy a message to another room");
- CtdlRegisterProtoHook(cmd_isme, "ISME", "Determine whether an email address belongs to a user");
+ if (!threading) {
+ CtdlRegisterProtoHook(cmd_msgs, "MSGS", "Output a list of messages in the current room");
+ CtdlRegisterProtoHook(cmd_msg0, "MSG0", "Output a message in plain text format");
+ CtdlRegisterProtoHook(cmd_msg2, "MSG2", "Output a message in RFC822 format");
+ CtdlRegisterProtoHook(cmd_msg3, "MSG3", "Output a message in raw format (deprecated)");
+ CtdlRegisterProtoHook(cmd_msg4, "MSG4", "Output a message in the client's preferred format");
+ CtdlRegisterProtoHook(cmd_msgp, "MSGP", "Select preferred format for MSG4 output");
+ CtdlRegisterProtoHook(cmd_opna, "OPNA", "Open an attachment for download");
+ CtdlRegisterProtoHook(cmd_dlat, "DLAT", "Download an attachment");
+ CtdlRegisterProtoHook(cmd_ent0, "ENT0", "Enter a message");
+ CtdlRegisterProtoHook(cmd_dele, "DELE", "Delete a message");
+ CtdlRegisterProtoHook(cmd_move, "MOVE", "Move or copy a message to another room");
+ CtdlRegisterProtoHook(cmd_isme, "ISME", "Determine whether an email address belongs to a user");
+ }
/* return our Subversion id for the Log */
return "$Id$";
projects / citadel.git / blobdiff