};
static const long NDiskFields = sizeof(FieldOrder) / sizeof(eMsgField);
+
+int CM_IsEmpty(struct CtdlMessage *Msg, eMsgField which)
+{
+ return !((Msg->cm_fields[which] != NULL) &&
+ (Msg->cm_fields[which][0] != '\0'));
+}
+
void CM_SetField(struct CtdlMessage *Msg, eMsgField which, const char *buf, long length)
{
if (Msg->cm_fields[which] != NULL)
}
}
+/*
+ * Returns 1 if the supplied pointer points to a valid Citadel message.
+ * If the pointer is NULL or the magic number check fails, returns 0.
+ */
+int CM_IsValidMsg(struct CtdlMessage *msg) {
+ if (msg == NULL)
+ return 0;
+ if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
+ struct CitContext *CCC = CC;
+ MSGM_syslog(LOG_WARNING, "CM_IsValidMsg() -- self-check failed\n");
+ return 0;
+ }
+ return 1;
+}
+
+void CM_FreeContents(struct CtdlMessage *msg)
+{
+ int i;
+
+ for (i = 0; i < 256; ++i)
+ if (msg->cm_fields[i] != NULL) {
+ free(msg->cm_fields[i]);
+ }
+
+ msg->cm_magic = 0; /* just in case */
+}
+/*
+ * 'Destructor' for struct CtdlMessage
+ */
+void CM_Free(struct CtdlMessage *msg)
+{
+ if (CM_IsValidMsg(msg) == 0)
+ {
+ if (msg != NULL) free (msg);
+ return;
+ }
+ CM_FreeContents(msg);
+ free(msg);
+}
+
+int CM_DupField(eMsgField i, struct CtdlMessage *OrgMsg, struct CtdlMessage *NewMsg)
+{
+ long len;
+ len = strlen(OrgMsg->cm_fields[i]);
+ NewMsg->cm_fields[i] = malloc(len + 1);
+ if (NewMsg->cm_fields[i] == NULL)
+ return 0;
+ memcpy(NewMsg->cm_fields[i], OrgMsg->cm_fields[i], len);
+ NewMsg->cm_fields[i][len] = '\0';
+ return 1;
+}
+
+struct CtdlMessage * CM_Duplicate(struct CtdlMessage *OrgMsg)
+{
+ int i;
+ struct CtdlMessage *NewMsg;
+
+ if (CM_IsValidMsg(OrgMsg) == 0)
+ return NULL;
+ NewMsg = (struct CtdlMessage *)malloc(sizeof(struct CtdlMessage));
+ if (NewMsg == NULL)
+ return NULL;
+
+ memcpy(NewMsg, OrgMsg, sizeof(struct CtdlMessage));
+
+ memset(&NewMsg->cm_fields, 0, sizeof(char*) * 256);
+
+ for (i = 0; i < 256; ++i)
+ {
+ if (OrgMsg->cm_fields[i] != NULL)
+ {
+ if (!CM_DupField(i, OrgMsg, NewMsg))
+ {
+ CM_Free(NewMsg);
+ return NULL;
+ }
+ }
+ }
+
+ return NewMsg;
+}
+
+
+
/*
* This function is self explanatory.
* (What can I say, I'm in a weird mood today...)
cprintf("%ld|%s|%s|%s|%s|%s|\n",
msgnum,
- (msg->cm_fields[eTimestamp] ? msg->cm_fields[eTimestamp] : "0"),
- (msg->cm_fields[eAuthor] ? msg->cm_fields[eAuthor] : ""),
- (msg->cm_fields[eNodeName] ? msg->cm_fields[eNodeName] : ""),
- (msg->cm_fields[erFc822Addr] ? msg->cm_fields[erFc822Addr] : ""),
- (msg->cm_fields[eMsgSubject] ? msg->cm_fields[eMsgSubject] : "")
+ (!CM_IsEmpty(msg, eTimestamp) ? msg->cm_fields[eTimestamp] : "0"),
+ (!CM_IsEmpty(msg, eAuthor) ? msg->cm_fields[eAuthor] : ""),
+ (!CM_IsEmpty(msg, eNodeName) ? msg->cm_fields[eNodeName] : ""),
+ (!CM_IsEmpty(msg, erFc822Addr) ? msg->cm_fields[erFc822Addr] : ""),
+ (!CM_IsEmpty(msg, eMsgSubject) ? msg->cm_fields[eMsgSubject] : "")
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
/*
cprintf("%ld|%s|%s\n",
msgnum,
- (msg->cm_fields[eExclusiveID] ? msg->cm_fields[eExclusiveID] : ""),
- (msg->cm_fields[eTimestamp] ? msg->cm_fields[eTimestamp] : "0"));
- CtdlFreeMessage(msg);
+ (!CM_IsEmpty(msg, eExclusiveID) ? msg->cm_fields[eExclusiveID] : ""),
+ (!CM_IsEmpty(msg, eTimestamp) ? msg->cm_fields[eTimestamp] : "0"));
+ CM_Free(msg);
}
if (CtdlMsgCmp(msg, compare)) {
msglist[a] = 0L;
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
}
}
template,
CallBack,
NULL);
- if (template != NULL) CtdlFreeMessage(template);
+ if (template != NULL) CM_Free(template);
cprintf("000\n");
}
-
-
-/*
- * help_subst() - support routine for help file viewer
- */
-void help_subst(char *strbuf, char *source, char *dest)
-{
- char workbuf[SIZ];
- int p;
-
- while (p = pattern2(strbuf, source), (p >= 0)) {
- strcpy(workbuf, &strbuf[p + strlen(source)]);
- strcpy(&strbuf[p], dest);
- strcat(strbuf, workbuf);
- }
-}
-
-
-void do_help_subst(char *buffer)
-{
- char buf2[16];
-
- help_subst(buffer, "^nodename", config.c_nodename);
- help_subst(buffer, "^humannode", config.c_humannode);
- help_subst(buffer, "^fqdn", config.c_fqdn);
- help_subst(buffer, "^username", CC->user.fullname);
- snprintf(buf2, sizeof buf2, "%ld", CC->user.usernum);
- help_subst(buffer, "^usernum", buf2);
- help_subst(buffer, "^sysadm", config.c_sysadm);
- help_subst(buffer, "^variantname", CITADEL);
- snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
- help_subst(buffer, "^maxsessions", buf2);
- help_subst(buffer, "^bbsdir", ctdl_message_dir);
-}
-
-
-
/*
* memfmout() - Citadel text formatter and paginator.
* Although the original purpose of this routine was to format
* so go ahead and fetch that. Failing that, just set a dummy
* body so other code doesn't barf.
*/
- if ( (ret->cm_fields[eMesageText] == NULL) && (with_body) ) {
+ if ( (CM_IsEmpty(ret, eMesageText)) && (with_body) ) {
dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
if (dmsgtext != NULL) {
CM_SetAsField(ret, eMesageText, &dmsgtext->ptr, dmsgtext->len);
cdb_free(dmsgtext);
}
}
- if (ret->cm_fields[eMesageText] == NULL) {
+ if (CM_IsEmpty(ret, eMesageText)) {
CM_SetField(ret, eMesageText, HKEY("\r\n\r\n (no text)\r\n"));
}
/* Perform "before read" hooks (aborting if any return nonzero) */
if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
- CtdlFreeMessage(ret);
+ CM_Free(ret);
return NULL;
}
}
-/*
- * Returns 1 if the supplied pointer points to a valid Citadel message.
- * If the pointer is NULL or the magic number check fails, returns 0.
- */
-int is_valid_message(struct CtdlMessage *msg) {
- if (msg == NULL)
- return 0;
- if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
- struct CitContext *CCC = CC;
- MSGM_syslog(LOG_WARNING, "is_valid_message() -- self-check failed\n");
- return 0;
- }
- return 1;
-}
-
-void CtdlFreeMessageContents(struct CtdlMessage *msg)
-{
- int i;
-
- for (i = 0; i < 256; ++i)
- if (msg->cm_fields[i] != NULL) {
- free(msg->cm_fields[i]);
- }
-
- msg->cm_magic = 0; /* just in case */
-}
-/*
- * 'Destructor' for struct CtdlMessage
- */
-void CtdlFreeMessage(struct CtdlMessage *msg)
-{
- if (is_valid_message(msg) == 0)
- {
- if (msg != NULL) free (msg);
- return;
- }
- CtdlFreeMessageContents(msg);
- free(msg);
-}
-
-int DupCMField(eMsgField i, struct CtdlMessage *OrgMsg, struct CtdlMessage *NewMsg)
-{
- long len;
- len = strlen(OrgMsg->cm_fields[i]);
- NewMsg->cm_fields[i] = malloc(len + 1);
- if (NewMsg->cm_fields[i] == NULL)
- return 0;
- memcpy(NewMsg->cm_fields[i], OrgMsg->cm_fields[i], len);
- NewMsg->cm_fields[i][len] = '\0';
- return 1;
-}
-
-struct CtdlMessage * CtdlDuplicateMessage(struct CtdlMessage *OrgMsg)
-{
- int i;
- struct CtdlMessage *NewMsg;
-
- if (is_valid_message(OrgMsg) == 0)
- return NULL;
- NewMsg = (struct CtdlMessage *)malloc(sizeof(struct CtdlMessage));
- if (NewMsg == NULL)
- return NULL;
-
- memcpy(NewMsg, OrgMsg, sizeof(struct CtdlMessage));
-
- memset(&NewMsg->cm_fields, 0, sizeof(char*) * 256);
-
- for (i = 0; i < 256; ++i)
- {
- if (OrgMsg->cm_fields[i] != NULL)
- {
- if (!DupCMField(i, OrgMsg, NewMsg))
- {
- CtdlFreeMessage(NewMsg);
- return NULL;
- }
- }
- }
-
- return NewMsg;
-}
-
-
/*
* Pre callback function for multipart/alternative
*Address = TheMessage->cm_fields[erFc822Addr];
TheMessage->cm_fields[erFc822Addr] = NULL;
}
- CtdlFreeMessage(TheMessage);
+ CM_Free(TheMessage);
TheMessage = NULL;
if (encap.msg) {
TheMessage->cm_fields[erFc822Addr] = NULL;
}
- CtdlFreeMessage(TheMessage);
+ CM_Free(TheMessage);
return(retcode);
}
/* begin header processing loop for Citadel message format */
safestrncpy(display_name, "<unknown>", sizeof display_name);
- if (TheMessage->cm_fields[eAuthor]) {
+ if (!CM_IsEmpty(TheMessage, eAuthor)) {
strcpy(buf, TheMessage->cm_fields[eAuthor]);
if (TheMessage->cm_anon_type == MES_ANONONLY) {
safestrncpy(display_name, "****", sizeof display_name);
* local Citadel network.
*/
suppress_f = 0;
- if (TheMessage->cm_fields[eNodeName] != NULL)
- if (!IsEmptyStr(TheMessage->cm_fields[eNodeName]))
- if (haschar(TheMessage->cm_fields[eNodeName], '.') == 0) {
- suppress_f = 1;
- }
+ 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;
Field = FieldOrder[i];
if (Field != eMesageText) {
- if ( (TheMessage->cm_fields[Field] != NULL)
+ if ( (!CM_IsEmpty(TheMessage, Field))
&& (msgkeys[Field] != NULL) ) {
if ((Field == eenVelopeTo) ||
(Field == eRecipient) ||
strcpy(mid, "unknown");
nl = (crlf ? "\r\n" : "\n");
- if (!is_valid_message(TheMessage)) {
+ if (!CM_IsValidMsg(TheMessage)) {
MSGM_syslog(LOG_ERR,
"ERROR: invalid preloaded message for output\n");
cit_backtrace ();
/* 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[eenVelopeTo] != NULL) ) {
+ if ( (flags & SUPPRESS_ENV_TO) && (!CM_IsEmpty(TheMessage, eenVelopeTo)) ) {
memset(TheMessage->cm_fields[eenVelopeTo], ' ', strlen(TheMessage->cm_fields[eenVelopeTo]));
}
}
serialize_message(&smr, msg);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (smr.len == 0) {
cprintf("%d Unable to serialize message\n",
ReplicationChecks(msg);
/* If the message has an Exclusive ID, index that... */
- if (msg->cm_fields[eExclusiveID] != NULL) {
+ if (!CM_IsEmpty(msg, eExclusiveID)) {
index_message_by_euid(msg->cm_fields[eExclusiveID], &CCC->room, msgid);
}
/* Free up the memory we may have allocated */
if (msg != supplied_msg) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
}
);
/* Generate an ID if we don't have one already */
- if (msg->cm_fields[emessageId]==NULL) {
+ if (CM_IsEmpty(msg, emessageId)) {
CM_SetField(msg, emessageId, msgidbuf, msgidbuflen);
}
/* If the message is big, set its body aside for storage elsewhere */
- if (msg->cm_fields[eMesageText] != NULL) {
+ if (!CM_IsEmpty(msg, eMesageText)) {
if (strlen(msg->cm_fields[eMesageText]) > BIGMSG) {
is_bigmsg = 1;
holdM = msg->cm_fields[eMesageText];
/*
* Check for valid message format
*/
- if (is_valid_message(msg) == 0) {
+ if (CM_IsValidMsg(msg) == 0) {
MSGM_syslog(LOG_ERR, "serialize_message() aborting due to invalid message\n");
ret->len = 0;
ret->ser = NULL;
/* No exclusive id? Don't do anything. */
if (msg == NULL) return;
- if (msg->cm_fields[eExclusiveID] == NULL) return;
- if (IsEmptyStr(msg->cm_fields[eExclusiveID])) return;
+ if (CM_IsEmpty(msg, eExclusiveID)) return;
+
/*MSG_syslog(LOG_DEBUG, "Exclusive ID: <%s> for room <%s>\n",
msg->cm_fields[eExclusiveID], CCC->room.QRname);*/
int rv = 0;
MSGM_syslog(LOG_DEBUG, "CtdlSubmitMsg() called\n");
- if (is_valid_message(msg) == 0) return(-1); /* self check */
+ if (CM_IsValidMsg(msg) == 0) return(-1); /* self check */
/* If this message has no timestamp, we take the liberty of
* giving it one, right now.
*/
- if (msg->cm_fields[eTimestamp] == NULL) {
+ if (CM_IsEmpty(msg, eTimestamp)) {
CM_SetFieldLONG(msg, eTimestamp, time(NULL));
}
/* If this message has no path, we generate one.
*/
- if (msg->cm_fields[eMessagePath] == NULL) {
- if (msg->cm_fields[eAuthor] != NULL) {
+ if (CM_IsEmpty(msg, eMessagePath)) {
+ if (!CM_IsEmpty(msg, eAuthor)) {
CM_CopyField(msg, eMessagePath, eAuthor);
for (a=0; !IsEmptyStr(&msg->cm_fields[eMessagePath][a]); ++a) {
if (isspace(msg->cm_fields[eMessagePath][a])) {
}
}
else {
- CM_SetField(msg,eMessagePath, HKEY("unknown"));
+ CM_SetField(msg, eMessagePath, HKEY("unknown"));
}
}
}
/* Learn about what's inside, because it's what's inside that counts */
- if (msg->cm_fields[eMesageText] == NULL) {
+ if (CM_IsEmpty(msg, eMesageText)) {
MSGM_syslog(LOG_ERR, "ERROR: attempt to save message with NULL body\n");
return(-2);
}
/*
* If this message has no O (room) field, generate one.
*/
- if (msg->cm_fields[eOriginalRoom] == NULL) {
+ if (CM_IsEmpty(msg, eOriginalRoom)) {
CM_SetField(msg, eOriginalRoom, CCC->room.QRname, strlen(CCC->room.QRname));
}
CM_SetAsField(imsg, eMesageText, &instr, instrlen);
CM_SetField(imsg, eExtnotify, recipient, recipientlen);
CtdlSubmitMsg(imsg, NULL, FNBL_QUEUE_ROOM, 0);
- CtdlFreeMessage(imsg);
+ CM_Free(imsg);
}
}
else {
/* Perform "after save" hooks */
MSGM_syslog(LOG_DEBUG, "Performing after-save hooks\n");
- if (msg->cm_fields[eVltMsgNum] != NULL) free(msg->cm_fields[eVltMsgNum]);
- msg->cm_fields[eVltMsgNum] = malloc(20);
- snprintf(msg->cm_fields[eVltMsgNum], 20, "%ld", newmsgid);
+
+ CM_SetFieldLONG(msg, eVltMsgNum, newmsgid);
PerformMessageHooks(msg, EVT_AFTERSAVE);
- free(msg->cm_fields[eVltMsgNum]);
- msg->cm_fields[eVltMsgNum] = NULL;
+ CM_FlushField(msg, eVltMsgNum);
/* For IGnet mail, we have to save a new copy into the spooler for
* each recipient, with the R and D fields set to the recipient and
imsg->cm_fields[eJournal] = strdup("do not journal");
imsg->cm_fields[eMesageText] = SmashStrBuf(&SpoolMsg); /* imsg owns this memory now */
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
- CtdlFreeMessage(imsg);
+ CM_Free(imsg);
}
/*
/*
* Determine whether this message qualifies for journaling.
*/
- if (msg->cm_fields[eJournal] != NULL) {
+ if (!CM_IsEmpty(msg, eJournal)) {
qualified_for_journaling = 0;
}
else {
msg->cm_fields[eMesageText] = strdup(text);
CtdlSubmitMsg(msg, recp, room, 0);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (recp != NULL) free_recipients(recp);
}
* (NOTE: if you supply 'preformatted_text', the buffer you give it
* will become part of the message. This means you are no longer
* responsible for managing that memory -- it will be freed along with
- * the rest of the fields when CtdlFreeMessage() is called.)
+ * the rest of the fields when CM_Free() is called.)
*/
struct CtdlMessage *CtdlMakeMessage(
client_write(HKEY("Internal error.\n"));
}
- if (msg->cm_fields[eExclusiveID] != NULL) {
+ if (!CM_IsEmpty(msg, eExclusiveID)) {
cprintf("%s\n", msg->cm_fields[eExclusiveID]);
} else {
cprintf("\n");
cprintf("000\n");
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
if (valid != NULL) {
free_recipients(valid);
}
/* Now write the data */
CtdlSubmitMsg(msg, NULL, roomname, 0);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
msg = CtdlFetchMessage(msgnum, 1);
if (msg != NULL) {
conf = strdup(msg->cm_fields[eMesageText]);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
else {
conf = NULL;
projects / citadel.git / blobdiff