if (!CM_IsEmpty(msg, eExclusiveID)) {
index_message_by_euid(msg->cm_fields[eExclusiveID], &CC->room, msgnum);
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
/*
* Convert an RFC822 message (headers + body) to a CtdlMessage structure.
* NOTE: the supplied buffer becomes part of the CtdlMessage structure, and
- * will be deallocated when CtdlFreeMessage() is called. Therefore, the
+ * will be deallocated when CM_Free() is called. Therefore, the
* supplied buffer should be DEREFERENCED. It should not be freed or used
* again.
*/
/* Submit journal message */
CtdlSubmitMsg(journal_msg, journal_recps, "", 0);
- CtdlFreeMessage(journal_msg);
+ CM_Free(journal_msg);
}
free_recipients(journal_recps);
if (msg == NULL) return;
v = vcard_load(msg->cm_fields[eMesageText]);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/*
* Try to match from a friendly name (the "fn" field). If there is
/* Now write the data */
CtdlSubmitMsg(msg, NULL, "", QP_EADDR);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
/* In either case, now we can free the serialized calendar object */
if (msg != NULL) {
valid = validate_recipients(organizer_string, NULL, 0);
CtdlSubmitMsg(msg, valid, "", QP_EADDR);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
free_recipients(valid);
}
}
/* We're done with the incoming message, because we now have a
* calendar object in memory.
*/
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/*
* Here is the real meat of this function. Handle the event.
&oec, /* user data */
0
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
original_event = oec.c;
if (original_event == NULL) {
if (msg != NULL) {
CIT_ICAL->avoid_sending_invitations = 1;
CtdlSubmitMsg(msg, NULL, roomname, QP_EADDR);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
CIT_ICAL->avoid_sending_invitations = 0;
}
}
/* We're done with the incoming message, because we now have a
* calendar object in memory.
*/
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/*
* Here is the real meat of this function. Handle the event.
(void *) &ird, /* user data */
0
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (ird.cal == NULL) return;
0
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (ird.cal != NULL) {
ical_hunt_for_conflicts(ird.cal);
(void *) &ird, /* user data */
0
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (ird.cal) {
ical_add_to_freebusy(fb, ird.cal); /* Add VEVENT times to VFREEBUSY */
(void *) &ird, /* user data */
0
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (ird.cal == NULL) return;
if (msg != NULL) {
valid = validate_recipients(attendees_string, NULL, 0);
CtdlSubmitMsg(msg, valid, "", QP_EADDR);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
free_recipients(valid);
}
}
msg = CtdlFetchMessage(delnum, 0); /* dont need body */
if (msg != NULL) {
xtime = atol(msg->cm_fields[eTimestamp]);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
} else {
xtime = 0L;
}
msg = CtdlFetchMessage(msgnum, 0);
if (msg != NULL) {
- CtdlFreeMessage(msg); /* it still exists, so do nothing */
+ CM_Free(msg); /* it still exists, so do nothing */
}
else {
eptr = (struct EPurgeList *) malloc(sizeof(struct EPurgeList));
{
break;
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
msg = NULL;
}
}
// type. This string would be at the very top of the message contents.
CM_GetAsField(msg, eMesageText, &configMsg, &clen);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/* here we would find the pager number... */
pch = strchr(configMsg, '\n');
}
if (FreeMe != NULL)
free(FreeMe);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
todelete[0] = NotifyMsgnum;
CtdlDeleteMessages(FNBL_QUEUE_ROOM, todelete, 1, "");
}
if (!CM_IsEmpty(msg, eSuppressIdx)) {
syslog(LOG_DEBUG, "ft_index_message() excluded msg %ld", msgnum);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
return;
}
*/
CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
CtdlOutputPreLoadedMsg(msg, MT_CITADEL, HEADERS_ALL, 0, 1, 0);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
msgtext = CC->redirect_buffer;
CC->redirect_buffer = NULL;
if (msgtext != NULL) {
iaputs(&Imap->cached_body[pstart], pbytes);
if (msg != NULL) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
/* Mark this message as "seen" *unless* this is a "peek" operation */
*/
else if (!strcasecmp(Cmd->Params[i].Key, "BODYSTRUCTURE")) {
if ((msg != NULL) && (!body_loaded)) {
- CtdlFreeMessage(msg); /* need the whole thing */
+ CM_Free(msg); /* need the whole thing */
msg = NULL;
}
if (msg == NULL) {
IAPuts(")\r\n");
unbuffer_output();
if (msg != NULL) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
}
}
/* We don't need this buffer anymore */
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (new_message_flags != NULL) {
imap_do_append_flags(new_msgnum, new_message_flags);
}
if (need_to_free_msg) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
return(match);
}
msg = CtdlFetchMessage(msgnum, 1);
if (msg != NULL) {
inetcfg_setTo(msg);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
}
snprintf(roomname, sizeof roomname, "%010ld.%s", im->usernums[1], PAGELOGROOM);
CtdlCreateRoom(roomname, 5, "", 0, 1, 1, VIEW_BBS);
msgnum = CtdlSubmitMsg(msg, NULL, roomname, 0);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/* If there is a valid user number in usernums[0], save a copy for them too. */
if (im->usernums[0] > 0) {
client_write("<msg_text>", 10);
serialize_message(&smr, msg);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/* Predict the buffer size we need. Expand the buffer if necessary. */
int encoded_len = smr.len * 15 / 10 ;
valid->envelope_from = strdup(bounce_to);
CtdlSubmitMsg(msg, valid, NULL, 0);
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
free_recipients(valid);
}
(sc->digestfp == NULL))
return;
- msg = CtdlDuplicateMessage(omsg);
+ msg = CM_Duplicate(omsg);
if (msg != NULL) {
fprintf(sc->digestfp,
" -----------------------------------"
FreeStrBuf(&CC->redirect_buffer);
sc->num_msgs_spooled += 1;
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
}
* in order to insert the [list name] in it, etc.
*/
- msg = CtdlDuplicateMessage(omsg);
+ msg = CM_Duplicate(omsg);
CM_SetField(msg, eListID, SKEY(sc->Users[roommailalias]));
/* Handle delivery */
network_deliver_list(msg, sc, CC->room.QRname);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
/*
CtdlSubmitMsg(msg, valid, NULL, 0);
free_recipients(valid);
}
- /* Do not call CtdlFreeMessage(msg) here; the caller will free it. */
+ /* Do not call CM_Free(msg) here; the caller will free it. */
}
if (sc->Users[participate] == NULL)
return;
- msg = CtdlDuplicateMessage(omsg);
+ msg = CM_Duplicate(omsg);
/* Only send messages which originated on our own
* Citadel network, otherwise we'll end up sending the
free_recipients(valid);
}
FreeStrBuf(&Buf);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
void network_process_ignetpush(SpoolControl *sc, struct CtdlMessage *omsg, long *delete_after_send)
/*
* Process IGnet push shares
*/
- msg = CtdlDuplicateMessage(omsg);
+ msg = CM_Duplicate(omsg);
/* Prepend our node name to the Path field whenever
* sending a message to another IGnet node
FreeStrBuf(&Buf);
FreeStrBuf(&Recipient);
FreeStrBuf(&RemoteRoom);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
network_process_participate(sc, msg, &delete_after_send);
network_process_ignetpush(sc, msg, &delete_after_send);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/* update lastsent */
sc->lastsent = msgnum;
QN_syslog(LOG_ERR, "%s: %s\n", filename, strerror(errno));
}
free(sermsg.ser);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
FreeStrBuf(&Buf);
return;
}
* connected that it's inevitable.)
*/
if (network_usetable(msg) != 0) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
return;
}
msg->cm_flags = CM_SKIP_HOOKS;
CtdlSubmitMsg(msg, recp, target_room, 0);
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
free_recipients(recp);
}
/* Clean up */
if (valid != NULL) free_recipients(valid);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
QNM_syslog(LOG_DEBUG, "leaving network_bounce()\n");
}
* so we don't fetch this message again
*/
}
- CtdlFreeMessage(RecvMsg->CurrMsg->Msg);
+ CM_Free(RecvMsg->CurrMsg->Msg);
RecvMsg->count ++;
return NextDBOperation(&RecvMsg->IO, POP3C_StoreMsgRead);
{
networker_save_message *Msg = (networker_save_message *) vMsg;
- CtdlFreeMessageContents(&Msg->Msg);
+ CM_FreeContents(&Msg->Msg);
FreeStrBuf(&Msg->Message);
FreeStrBuf(&Msg->MsgGUID);
CtdlSubmitMsg(msg, valid, NULL, 0);
cs->cancel_implicit_keep = 1;
free_recipients(valid);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
return SIEVE2_OK;
}
strcat(my.envelope_to, config.c_fqdn);
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
SVM_syslog(LOG_DEBUG, "Calling sieve2_execute()");
res = sieve2_execute(sieve2_context, &my);
CM_GetAsField(msg, eMesageText, &conf, &conflen);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (conf != NULL) {
parse_sieve_config(conf, u);
*webcit_conf = (char *)msg->cm_fields[eMesageText];
msg->cm_fields[eMesageText] = NULL;
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
);
/* Clean up */
- CtdlFreeMessage(msg);
+ CM_Free(msg);
free_recipients(valid);
smtp_data_clear(0, 0); /* clear out the buffers now */
}
Msg->MyQItem->QueMsgID =
CtdlSubmitMsg(msg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
EVS_syslog(LOG_DEBUG, "%ld", Msg->MyQItem->QueMsgID);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
else {
CtdlDeleteMessages(SMTP_SPOOLOUT_ROOM,
/* Free up the memory we used */
free_recipients(valid);
FreeStrBuf(&boundary);
- CtdlFreeMessage(bmsg);
+ CM_Free(bmsg);
SMTPCM_syslog(LOG_DEBUG, "Done processing bounces\n");
}
}
}
PlainQItem = NewStrBufPlain(instr, -1);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
MyQItem = DeserializeQueueItem(PlainQItem, msgnum);
FreeStrBuf(&PlainQItem);
}
}
FreeStrBuf(&boundary);
- CtdlFreeMessage(bmsg);
+ CM_Free(bmsg);
syslog(LOG_DEBUG, "Done processing bounces\n");
}
vcard_extract_internet_addresses(msg, vcard_directory_add_user);
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
if (msg == NULL) return vcard_new();
v = vcard_load(msg->cm_fields[eMesageText]);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
return v;
}
CM_SetField(msg, eSpecialField, HKEY("CANCEL"));
CtdlSubmitMsg(msg, NULL, ADDRESS_BOOK_ROOM, QP_EADDR);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
if (ptr != NULL) ++ptr;
}
-EOH: CtdlFreeMessage(msg);
+EOH: CM_Free(msg);
}
NULL, /* user data */
0
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) return;
v = vcard_load(msg->cm_fields[eMesageText]);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
i = 0;
while (value = vcard_get_prop(v, "email", 1, i++, 0), value != NULL) {
syslog(LOG_DEBUG, "Adding contact: %s", recipient);
CtdlSubmitMsg(vmsg, NULL, aptr->roomname, QP_EADDR);
- CtdlFreeMessage(vmsg);
+ CM_Free(vmsg);
}
}
}
if ((old_msg != NULL) && (CM_IsEmpty(old_msg, eMesageText))) { /* old version is corrupt? */
- CtdlFreeMessage(old_msg);
+ CM_Free(old_msg);
old_msg = NULL;
}
/* If no changes were made, don't bother saving it again */
if ((old_msg != NULL) && (!strcmp(msg->cm_fields[eMesageText], old_msg->cm_fields[eMesageText]))) {
- CtdlFreeMessage(old_msg);
+ CM_Free(old_msg);
return(1);
}
fp = fopen(diff_old_filename, "w");
rv = fwrite(old_msg->cm_fields[eMesageText], strlen(old_msg->cm_fields[eMesageText]), 1, fp);
fclose(fp);
- CtdlFreeMessage(old_msg);
+ CM_Free(old_msg);
}
fp = fopen(diff_new_filename, "w");
}
free(diffbuf);
- CtdlFreeMessage(history_msg);
+ CM_Free(history_msg);
return(0);
}
}
if ((msg != NULL) && CM_IsEmpty(msg, eMesageText)) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
msg = NULL;
}
mime_parser(msg->cm_fields[eMesageText], NULL, *wiki_history_callback, NULL, NULL, NULL, 0);
cprintf("000\n");
- CtdlFreeMessage(msg);
+ CM_Free(msg);
return;
}
}
if ((msg != NULL) && CM_IsEmpty(msg, eMesageText)) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
msg = NULL;
}
else {
syslog(LOG_ALERT, "Cannot open %s: %s\n", temp, strerror(errno));
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/* Get the revision history */
}
if ((msg != NULL) && CM_IsEmpty(msg, eMesageText)) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
msg = NULL;
}
striplt(hecbd.stop_when);
mime_parser(msg->cm_fields[eMesageText], NULL, *wiki_rev_callback, NULL, NULL, (void *)&hecbd, 0);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
/* Were we successful? */
if (hecbd.done == 0) {
/* Theoretically it is impossible to get here, but throw an error anyway */
msgnum = (-1L);
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (msgnum >= 0L) {
cprintf("%d %ld\n", CIT_OK, msgnum); /* Give the client a msgnum */
}
}
}
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
* 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) {
+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, "is_valid_message() -- self-check failed\n");
+ MSGM_syslog(LOG_WARNING, "CM_IsValidMsg() -- self-check failed\n");
return 0;
}
return 1;
}
-void CtdlFreeMessageContents(struct CtdlMessage *msg)
+void CM_FreeContents(struct CtdlMessage *msg)
{
int i;
/*
* 'Destructor' for struct CtdlMessage
*/
-void CtdlFreeMessage(struct CtdlMessage *msg)
+void CM_Free(struct CtdlMessage *msg)
{
- if (is_valid_message(msg) == 0)
+ if (CM_IsValidMsg(msg) == 0)
{
if (msg != NULL) free (msg);
return;
}
- CtdlFreeMessageContents(msg);
+ CM_FreeContents(msg);
free(msg);
}
-int DupCMField(eMsgField i, struct CtdlMessage *OrgMsg, struct CtdlMessage *NewMsg)
+int CM_DupField(eMsgField i, struct CtdlMessage *OrgMsg, struct CtdlMessage *NewMsg)
{
long len;
len = strlen(OrgMsg->cm_fields[i]);
return 1;
}
-struct CtdlMessage * CtdlDuplicateMessage(struct CtdlMessage *OrgMsg)
+struct CtdlMessage * CM_Duplicate(struct CtdlMessage *OrgMsg)
{
int i;
struct CtdlMessage *NewMsg;
- if (is_valid_message(OrgMsg) == 0)
+ if (CM_IsValidMsg(OrgMsg) == 0)
return NULL;
NewMsg = (struct CtdlMessage *)malloc(sizeof(struct CtdlMessage));
if (NewMsg == NULL)
{
if (OrgMsg->cm_fields[i] != NULL)
{
- if (!DupCMField(i, OrgMsg, NewMsg))
+ if (!CM_DupField(i, OrgMsg, NewMsg))
{
- CtdlFreeMessage(NewMsg);
+ CM_Free(NewMsg);
return NULL;
}
}
(!CM_IsEmpty(msg, erFc822Addr) ? msg->cm_fields[erFc822Addr] : ""),
(!CM_IsEmpty(msg, eMsgSubject) ? msg->cm_fields[eMsgSubject] : "")
);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
/*
msgnum,
(!CM_IsEmpty(msg, eExclusiveID) ? msg->cm_fields[eExclusiveID] : ""),
(!CM_IsEmpty(msg, eTimestamp) ? msg->cm_fields[eTimestamp] : "0"));
- CtdlFreeMessage(msg);
+ 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");
}
/* Perform "before read" hooks (aborting if any return nonzero) */
if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
- CtdlFreeMessage(ret);
+ CM_Free(ret);
return NULL;
}
*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);
}
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 ();
}
serialize_message(&smr, msg);
- CtdlFreeMessage(msg);
+ CM_Free(msg);
if (smr.len == 0) {
cprintf("%d Unable to serialize message\n",
/* Free up the memory we may have allocated */
if (msg != supplied_msg) {
- CtdlFreeMessage(msg);
+ CM_Free(msg);
}
}
/*
* 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;
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.
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 {
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);
}
/*
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(
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;
unsigned int flags /* Internal save flags */
);
struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body);
-struct CtdlMessage * CtdlDuplicateMessage(struct CtdlMessage *OrgMsg);
+struct CtdlMessage * CM_Duplicate
+ (struct CtdlMessage *OrgMsg);
int CM_IsEmpty (struct CtdlMessage *Msg, eMsgField which);
void CM_SetField (struct CtdlMessage *Msg, eMsgField which, const char *buf, long length);
void CM_SetFieldLONG (struct CtdlMessage *Msg, eMsgField which, long lvalue);
void CM_GetAsField (struct CtdlMessage *Msg, eMsgField which, char **ret, long *retlen);
void CM_PrependToField (struct CtdlMessage *Msg, eMsgField which, const char *buf, long length);
-void CtdlFreeMessage(struct CtdlMessage *msg);
-void CtdlFreeMessageContents(struct CtdlMessage *msg);
+void CM_Free (struct CtdlMessage *msg);
+void CM_FreeContents (struct CtdlMessage *msg);
+int CM_IsValidMsg (struct CtdlMessage *msg);
+
void serialize_message(struct ser_ret *, struct CtdlMessage *);
-int is_valid_message(struct CtdlMessage *);
void ReplicationChecks(struct CtdlMessage *);
int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
int do_repl_check, struct CtdlMessage *supplied_msg, int suppress_refcount_adj);
projects / citadel.git / commitdiff