/*
* Implements the message store.
*
- * Copyright (c) 1987-2018 by the citadel.org team
+ * Copyright (c) 1987-2020 by the citadel.org team
*
* This program is open source software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3.
* These are the four-character field headers we use when outputting
* messages in Citadel format (as opposed to RFC822 format).
*/
-char *msgkeys[91] = {
+char *msgkeys[] = {
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL,
- "from", /* A -> eAuthor */
- NULL, /* B -> eBig_message */
- NULL, /* C -> eRemoteRoom FIXME no more ignet */
- NULL, /* D -> eDestination FIXME no more ignet */
- "exti", /* E -> eXclusivID */
- "rfca", /* F -> erFc822Addr */
- NULL, /* G */
- "hnod", /* H -> eHumanNode FIXME no more ignet */
- "msgn", /* I -> emessageId */
- "jrnl", /* J -> eJournal */
- "rep2", /* K -> eReplyTo */
- "list", /* L -> eListID */
- "text", /* M -> eMesageText */
- "node", /* N -> eNodeName FIXME no more ignet */
- "room", /* O -> eOriginalRoom */
- "path", /* P -> eMessagePath */
- NULL, /* Q */
- "rcpt", /* R -> eRecipient */
- "spec", /* S -> eSpecialField FIXME we might not be using this anymore */
- "time", /* T -> eTimestamp */
- "subj", /* U -> eMsgSubject */
- "nvto", /* V -> eenVelopeTo */
- "wefw", /* W -> eWeferences */
- NULL, /* X */
- "cccc", /* Y -> eCarbonCopY */
- NULL /* Z */
-
+ "from", // A -> eAuthor
+ NULL, // B -> eBig_message
+ NULL, // C (formerly used as eRemoteRoom)
+ NULL, // D (formerly used as eDestination)
+ "exti", // E -> eXclusivID
+ "rfca", // F -> erFc822Addr
+ NULL, // G
+ "hnod", // H (formerly used as eHumanNode)
+ "msgn", // I -> emessageId
+ "jrnl", // J -> eJournal
+ "rep2", // K -> eReplyTo
+ "list", // L -> eListID
+ "text", // M -> eMesageText
+ "locl", // N -> eOrigLocal
+ "room", // O -> eOriginalRoom
+ "path", // P -> eMessagePath
+ NULL, // Q
+ "rcpt", // R -> eRecipient
+ NULL, // S (formerly used as eSpecialField)
+ "time", // T -> eTimestamp
+ "subj", // U -> eMsgSubject
+ "nvto", // V -> eenVelopeTo
+ "wefw", // W -> eWeferences
+ NULL, // X
+ "cccc", // Y -> eCarbonCopY
+ NULL // Z
};
+
+
HashList *msgKeyLookup = NULL;
int GetFieldFromMnemonic(eMsgField *f, const char* c)
}
}
+
eMsgField FieldOrder[] = {
/* Important fields */
emessageId ,
eAuthor ,
erFc822Addr ,
eOriginalRoom,
- eNodeName ,
- eHumanNode ,
eRecipient ,
- eDestination ,
/* Semi-important fields */
+ eOrigLocal ,
eBig_message ,
- eRemoteRoom ,
eExclusiveID ,
eWeferences ,
eJournal ,
-/* G is not used yet, may become virus signature*/
+/* G is not used yet */
eReplyTo ,
eListID ,
/* Q is not used yet */
- eSpecialField,
eenVelopeTo ,
/* X is not used yet */
/* Z is not used yet */
if (Msg->cm_fields[which] != NULL) {
free (Msg->cm_fields[which]);
}
+ if (length < 0) { // You can set the length to -1 to have CM_SetField measure it for you
+ length = strlen(buf);
+ }
Msg->cm_fields[which] = malloc(length + 1);
memcpy(Msg->cm_fields[which], buf, length);
Msg->cm_fields[which][length] = '\0';
Msg->cm_fields[which] = *buf;
*buf = NULL;
- Msg->cm_lengths[which] = length;
+ if (length < 0) { // You can set the length to -1 to have CM_SetField measure it for you
+ Msg->cm_lengths[which] = strlen(Msg->cm_fields[which]);
+ }
+ else {
+ Msg->cm_lengths[which] = length;
+ }
}
free(msglist);
return -1;
}
- msg = CtdlFetchMessage(msglist[a], 1, 1);
+ msg = CtdlFetchMessage(msglist[a], 1);
if (msg != NULL) {
if (CtdlMsgCmp(msg, compare)) {
msglist[a] = 0L;
* NOTE: Caller is responsible for freeing the returned CtdlMessage struct
* using the CM_Free(); function.
*/
-struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body, int run_msg_hooks)
+struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
{
struct cdbdata *dmsgtext;
struct CtdlMessage *ret = NULL;
CM_SetField(ret, eMesageText, HKEY("\r\n\r\n (no text)\r\n"));
}
- /* Perform "before read" hooks (aborting if any return nonzero) */
- if (run_msg_hooks && (PerformMessageHooks(ret, NULL, EVT_BEFOREREAD) > 0)) {
- CM_Free(ret);
- return NULL;
- }
-
return (ret);
}
* request that we don't even bother loading the body into memory.
*/
if (headers_only == HEADERS_FAST) {
- TheMessage = CtdlFetchMessage(msg_num, 0, 1);
+ TheMessage = CtdlFetchMessage(msg_num, 0);
}
else {
- TheMessage = CtdlFetchMessage(msg_num, 1, 1);
+ TheMessage = CtdlFetchMessage(msg_num, 1);
}
if (TheMessage == NULL) {
int do_proto) /* do Citadel protocol responses? */
{
int i;
- int suppress_f = 0;
char buf[SIZ];
char display_name[256];
}
}
- /* Don't show Internet address for users on the
- * local Citadel network.
- */
- suppress_f = 0;
- if (!CM_IsEmpty(TheMessage, eNodeName) && (haschar(TheMessage->cm_fields[eNodeName], '.') == 0)) {
- suppress_f = 1;
- }
-
/* Now spew the header fields in the order we like them. */
for (i=0; i< NDiskFields; ++i) {
eMsgField Field;
msgkeys[Field],
display_name);
}
- else if ((Field == erFc822Addr) && (suppress_f)) {
- /* do nothing */
- }
/* Masquerade display name if needed */
else {
if (do_proto) {
void OutputRFC822MsgHeaders(
struct CtdlMessage *TheMessage,
- int flags, /* should the bessage be exported clean */
+ int flags, /* should the message be exported clean */
const char *nl, int nlen,
char *mid, long sizeof_mid,
char *suser, long sizeof_suser,
break;
case erFc822Addr:
safestrncpy(fuser, mptr, sizeof_fuser);
- case eNodeName:
- safestrncpy(snode, mptr, sizeof_snode);
- break;
case eRecipient:
if (haschar(mptr, '@') == 0) {
sanitize_truncated_recipient(mptr);
cprintf("Reply-To: %s%s", mptr, nl);
break;
- case eRemoteRoom:
- case eDestination:
case eExclusiveID:
- case eHumanNode:
case eJournal:
case eMesageText:
case eBig_message:
case eOriginalRoom:
- case eSpecialField:
case eErrorMsg:
case eSuppressIdx:
case eExtnotify:
case eVltMsgNum:
+ case eOrigLocal:
/* these don't map to mime message headers. */
break;
}
* using functions that are bounds-checked, and therefore we can
* make them substantially smaller than SIZ.
*/
- char suser[100];
- char luser[100];
- char fuser[100];
- char snode[100];
- char mid[100];
+ char suser[1024];
+ char luser[1024];
+ char fuser[1024];
+ char snode[1024];
+ char mid[1024];
syslog(LOG_DEBUG, "msgbase: CtdlOutputPreLoadedMsg(TheMessage=%s, %d, %d, %d, %d",
((TheMessage == NULL) ? "NULL" : "not null"),
strcpy(suser, "");
strcpy(luser, "");
strcpy(fuser, "");
- memcpy(snode, CtdlGetConfigStr("c_nodename"), strlen(CtdlGetConfigStr("c_nodename")) + 1);
+ strcpy(snode, "");
if (mode == MT_RFC822)
OutputRFC822MsgHeaders(
TheMessage,
}
if (mode == MT_RFC822) {
- if (!strcasecmp(snode, NODENAME)) {
- safestrncpy(snode, FQDN, sizeof snode);
- }
-
/* Construct a fun message id */
- cprintf("Message-ID: <%s", mid);/// todo: this possibly breaks threadding mails.
+ cprintf("Message-ID: <%s", mid);
if (strchr(mid, '@')==NULL) {
cprintf("@%s", snode);
}
msg = supplied_msg;
}
else {
- msg = CtdlFetchMessage(msgid, 0, 1);
+ msg = CtdlFetchMessage(msgid, 0);
}
if (msg != NULL) {
}
/* Submit this room for processing by hooks */
- PerformRoomHooks(&CC->room);
+ int total_roomhook_errors = PerformRoomHooks(&CC->room);
+ if (total_roomhook_errors) {
+ syslog(LOG_WARNING, "msgbase: room hooks returned %d errors", total_roomhook_errors);
+ }
/* Go back to the room we were in before we wandered here... */
CtdlGetRoom(&CC->room, hold_rm);
}
-
-
/*
* Message base operation to save a new message to the message store
* (returns new message number)
* If the message is big, set its body aside for storage elsewhere
* and we hide the message body from the serializer
*/
- if (!CM_IsEmpty(msg, eMesageText) && msg->cm_lengths[eMesageText] > BIGMSG)
- {
+ if (!CM_IsEmpty(msg, eMesageText) && msg->cm_lengths[eMesageText] > BIGMSG) {
is_bigmsg = 1;
holdM = msg->cm_fields[eMesageText];
msg->cm_fields[eMesageText] = NULL;
}
/* Write our little bundle of joy into the message base */
- retval = cdb_store(CDB_MSGMAIN, &msgid, (int)sizeof(long),
- smr.ser, smr.len);
+ retval = cdb_store(CDB_MSGMAIN, &msgid, (int)sizeof(long), smr.ser, smr.len);
if (retval < 0) {
syslog(LOG_ERR, "msgbase: can't store message %ld: %ld", msgid, retval);
}
return(retval);
}
+
long send_message(struct CtdlMessage *msg) {
long newmsgid;
long retval;
}
-
/*
* Serialize a struct CtdlMessage into the format used on disk and network.
*
ret->ser[2] = msg->cm_format_type;
wlen = 3;
- for (i=0; i < NDiskFields; ++i)
- if (msg->cm_fields[FieldOrder[i]] != NULL)
- {
+ for (i=0; i < NDiskFields; ++i) {
+ if (msg->cm_fields[FieldOrder[i]] != NULL) {
ret->ser[wlen++] = (char)FieldOrder[i];
memcpy(&ret->ser[wlen],
wlen = wlen + msg->cm_lengths[FieldOrder[i]] + 1;
}
+ }
if (ret->len != wlen) {
syslog(LOG_ERR, "msgbase: ERROR; len=%ld wlen=%ld", (long)ret->len, (long)wlen);
}
-
/*
* Save a message to disk and submit it into the delivery system.
*/
long CtdlSubmitMsg(struct CtdlMessage *msg, /* message to save */
recptypes *recps, /* recipients (if mail) */
- const char *force, /* force a particular room? */
- int flags /* should the message be exported clean? */
- )
-{
+ const char *force /* force a particular room? */
+) {
char hold_rm[ROOMNAMELEN];
char actual_rm[ROOMNAMELEN];
char force_room[ROOMNAMELEN];
* If this message has no O (room) field, generate one.
*/
if (CM_IsEmpty(msg, eOriginalRoom) && !IsEmptyStr(CC->room.QRname)) {
- CM_SetField(msg, eOriginalRoom, CC->room.QRname, strlen(CC->room.QRname));
+ CM_SetField(msg, eOriginalRoom, CC->room.QRname, -1);
}
/* Perform "before save" hooks (aborting if any return nonzero) */
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);
+ safestrncpy(smi.meta_content_type, content_type, sizeof smi.meta_content_type);
/*
* Measure how big this message will be when rendered as RFC822.
}
/* If other rooms are specified, drop them there too. */
- if ((recps != NULL) && (recps->num_room > 0))
+ 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);
+ extract_token(recipient, recps->recp_room, i, '|', sizeof recipient);
syslog(LOG_DEBUG, "msgbase: delivering to room <%s>", recipient);
CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0, msg);
}
+ }
/* Bump this user's messages posted counter. */
syslog(LOG_DEBUG, "msgbase: updating user");
CtdlPutCurrentUserLock();
/* Decide where bounces need to be delivered */
- if ((recps != NULL) && (recps->bounce_to == NULL))
- {
+ if ((recps != NULL) && (recps->bounce_to == NULL)) {
if (CC->logged_in) {
- snprintf(bounce_to, sizeof bounce_to, "%s@%s", CC->user.fullname, CtdlGetConfigStr("c_nodename"));
+ strcpy(bounce_to, CC->user.fullname);
}
- else {
- snprintf(bounce_to, sizeof bounce_to, "%s@%s", msg->cm_fields[eAuthor], msg->cm_fields[eNodeName]);
+ else if (!IsEmptyStr(msg->cm_fields[eAuthor])){
+ strcpy(bounce_to, msg->cm_fields[eAuthor]);
}
recps->bounce_to = bounce_to;
}
CM_SetFieldLONG(msg, eVltMsgNum, newmsgid);
-
/* If this is private, local mail, make a copy in the
* recipient's mailbox and bump the reference count.
*/
- if ((recps != NULL) && (recps->num_local > 0))
- {
+ if ((recps != NULL) && (recps->num_local > 0)) {
char *pch;
int ntokens;
pch = recps->recp_local;
recps->recp_local = recipient;
ntokens = num_tokens(pch, '|');
- for (i=0; i<ntokens; ++i)
- {
+ for (i=0; i<ntokens; ++i) {
extract_token(recipient, pch, i, '|', sizeof recipient);
syslog(LOG_DEBUG, "msgbase: delivering private local mail to <%s>", recipient);
if (CtdlGetUser(&userbuf, recipient) == 0) {
/* Go back to the room we started from */
syslog(LOG_DEBUG, "msgbase: returning to original room %s", hold_rm);
- if (strcasecmp(hold_rm, CC->room.QRname))
+ if (strcasecmp(hold_rm, CC->room.QRname)) {
CtdlUserGoto(hold_rm, 0, 1, NULL, NULL, NULL, NULL);
+ }
/*
* Any addresses to harvest for someone's address book?
}
if (collected_addresses != NULL) {
- aptr = (struct addresses_to_be_filed *)
- malloc(sizeof(struct addresses_to_be_filed));
- CtdlMailboxName(actual_rm, sizeof actual_rm,
- &CC->user, USERCONTACTSROOM);
+ aptr = (struct addresses_to_be_filed *) malloc(sizeof(struct addresses_to_be_filed));
+ CtdlMailboxName(actual_rm, sizeof actual_rm, &CC->user, USERCONTACTSROOM);
aptr->roomname = strdup(actual_rm);
aptr->collected_addresses = collected_addresses;
begin_critical_section(S_ATBF);
msg->cm_format_type = format_type;
if (!IsEmptyStr(from)) {
- CM_SetField(msg, eAuthor, from, strlen(from));
+ CM_SetField(msg, eAuthor, from, -1);
}
else if (!IsEmptyStr(fromaddr)) {
char *pAt;
- CM_SetField(msg, eAuthor, fromaddr, strlen(fromaddr));
+ CM_SetField(msg, eAuthor, fromaddr, -1);
pAt = strchr(msg->cm_fields[eAuthor], '@');
if (pAt != NULL) {
CM_CutFieldAt(msg, eAuthor, pAt - msg->cm_fields[eAuthor]);
msg->cm_fields[eAuthor] = strdup("Citadel");
}
- if (!IsEmptyStr(fromaddr)) CM_SetField(msg, erFc822Addr, fromaddr, strlen(fromaddr));
- if (!IsEmptyStr(room)) CM_SetField(msg, eOriginalRoom, room, strlen(room));
- CM_SetField(msg, eNodeName, CtdlGetConfigStr("c_nodename"), strlen(CtdlGetConfigStr("c_nodename")));
+ if (!IsEmptyStr(fromaddr)) CM_SetField(msg, erFc822Addr, fromaddr, -1);
+ if (!IsEmptyStr(room)) CM_SetField(msg, eOriginalRoom, room, -1);
if (!IsEmptyStr(to)) {
- CM_SetField(msg, eRecipient, to, strlen(to));
+ CM_SetField(msg, eRecipient, to, -1);
recp = validate_recipients(to, NULL, 0);
}
if (!IsEmptyStr(subject)) {
- CM_SetField(msg, eMsgSubject, subject, strlen(subject));
+ CM_SetField(msg, eMsgSubject, subject, -1);
}
if (!IsEmptyStr(text)) {
- CM_SetField(msg, eMesageText, text, strlen(text));
+ CM_SetField(msg, eMesageText, text, -1);
}
- long msgnum = CtdlSubmitMsg(msg, recp, room, 0);
+ long msgnum = CtdlSubmitMsg(msg, recp, room);
CM_Free(msg);
if (recp != NULL) free_recipients(recp);
return msgnum;
StrBuf *exist, /* if non-null, append to it;
exist is ALWAYS freed */
int crlf /* CRLF newlines instead of LF */
- )
-{
+) {
StrBuf *Message;
StrBuf *LineBuf;
int flushing = 0;
}
/* Unescape SMTP-style input of two dots at the beginning of the line */
- if ((dotdot) &&
- (StrLength(LineBuf) == 2) &&
- (!strcmp(ChrPtr(LineBuf), "..")))
- {
+ if ((dotdot) && (StrLength(LineBuf) > 1) && (ChrPtr(LineBuf)[0] == '.')) {
StrBufCutLeft(LineBuf, 1);
}
-
StrBufAppendBuf(Message, LineBuf, 0);
}
return SmashStrBuf(&Message);
}
+
struct CtdlMessage *CtdlMakeMessage(
struct ctdluser *author, /* author's user structure */
char *recipient, /* NULL if it's not mail */
char *supplied_euid, /* ...or NULL if this is irrelevant */
char *preformatted_text, /* ...or NULL to read text from client */
char *references /* Thread references */
-)
-{
+) {
return CtdlMakeMessageLen(
author, /* author's user structure */
recipient, /* NULL if it's not mail */
}
+
/*
* Build a binary message to be saved on disk.
* (NOTE: if you supply 'preformatted_text', the buffer you give it
* responsible for managing that memory -- it will be freed along with
* the rest of the fields when CM_Free() is called.)
*/
-
struct CtdlMessage *CtdlMakeMessageLen(
struct ctdluser *author, /* author's user structure */
char *recipient, /* NULL if it's not mail */
long textlen,
char *references, /* Thread references */
long reflen
- )
-{
- /* Don't confuse the poor folks if it's not routed mail. * /
- char dest_node[256] = "";*/
+) {
long blen;
char buf[1024];
struct CtdlMessage *msg;
CM_SetField(msg, eMessagePath, my_email, myelen);
}
else if (!IsEmptyStr(author->fullname)) {
- CM_SetField(msg, eMessagePath, author->fullname, strlen(author->fullname));
+ CM_SetField(msg, eMessagePath, author->fullname, -1);
}
convert_spaces_to_underscores(msg->cm_fields[eMessagePath]);
if (!!IsEmptyStr(CC->room.QRname)) {
if (CC->room.QRflags & QR_MAILBOX) { /* room */
- CM_SetField(msg, eOriginalRoom, &CC->room.QRname[11], strlen(&CC->room.QRname[11]));
+ CM_SetField(msg, eOriginalRoom, &CC->room.QRname[11], -1);
}
else {
- CM_SetField(msg, eOriginalRoom, CC->room.QRname, strlen(CC->room.QRname));
+ CM_SetField(msg, eOriginalRoom, CC->room.QRname, -1);
}
}
- CM_SetField(msg, eNodeName, CtdlGetConfigStr("c_nodename"), strlen(CtdlGetConfigStr("c_nodename")));
- CM_SetField(msg, eHumanNode, CtdlGetConfigStr("c_humannode"), strlen(CtdlGetConfigStr("c_humannode")));
-
if (rcplen > 0) {
CM_SetField(msg, eRecipient, recipient, rcplen);
}
CM_SetField(msg, erFc822Addr, my_email, myelen);
}
else if ( (author == &CC->user) && (!IsEmptyStr(CC->cs_inet_email)) ) {
- CM_SetField(msg, erFc822Addr, CC->cs_inet_email, strlen(CC->cs_inet_email));
+ CM_SetField(msg, erFc822Addr, CC->cs_inet_email, -1);
}
if (subject != NULL) {
}
-
-
/*
* API function to delete messages which match a set of criteria
* (returns the actual number of messages deleted)
*/
-int CtdlDeleteMessages(const 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. */
- )
-{
+int CtdlDeleteMessages(const 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.
+) {
struct ctdlroom qrbuf;
struct cdbdata *cdbfr;
long *msglist = NULL;
int is_binary, /* Is encoding necessary? */
int is_unique, /* Del others of this type? */
unsigned int flags /* Internal save flags */
- )
-{
+) {
struct ctdlroom qrbuf;
char roomname[ROOMNAMELEN];
struct CtdlMessage *msg;
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = MES_NORMAL;
msg->cm_format_type = 4;
- CM_SetField(msg, eAuthor, CC->user.fullname, strlen(CC->user.fullname));
- CM_SetField(msg, eOriginalRoom, req_room, strlen(req_room));
- CM_SetField(msg, eNodeName, CtdlGetConfigStr("c_nodename"), strlen(CtdlGetConfigStr("c_nodename")));
- CM_SetField(msg, eHumanNode, CtdlGetConfigStr("c_humannode"), strlen(CtdlGetConfigStr("c_humannode")));
+ CM_SetField(msg, eAuthor, CC->user.fullname, -1);
+ CM_SetField(msg, eOriginalRoom, req_room, -1);
msg->cm_flags = flags;
CM_SetAsFieldSB(msg, eMesageText, &encoded_message);
);
}
/* Now write the data */
- CtdlSubmitMsg(msg, NULL, roomname, 0);
+ CtdlSubmitMsg(msg, NULL, roomname);
CM_Free(msg);
}