"jrnl", // J -> eJournal
"rep2", // K -> eReplyTo
"list", // L -> eListID
- "text", // M -> eMesageText
+ "text", // M -> eMessageText
NULL, // N (formerly used as eNodename)
"room", // O -> eOriginalRoom
"path", // P -> eMessagePath
eSuppressIdx ,
eExtnotify ,
// Message text (MUST be last)
- eMesageText
+ eMessageText
// Not saved to disk:
// eVltMsgNum
//
// so go ahead and fetch that. Failing that, just set a dummy
// body so other code doesn't barf.
//
- if ( (CM_IsEmpty(ret, eMesageText)) && (with_body) ) {
+ if ( (CM_IsEmpty(ret, eMessageText)) && (with_body) ) {
dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
if (dmsgtext.ptr != NULL) {
- CM_SetField(ret, eMesageText, dmsgtext.ptr);
+ CM_SetField(ret, eMessageText, dmsgtext.ptr);
}
}
- if (CM_IsEmpty(ret, eMesageText)) {
- CM_SetField(ret, eMesageText, "\r\n\r\n (no text)\r\n");
+ if (CM_IsEmpty(ret, eMessageText)) {
+ CM_SetField(ret, eMessageText, "\r\n\r\n (no text)\r\n");
}
return (ret);
// Get a message off disk. (returns om_* values found in msgbase.h)
int CtdlOutputMsg(long msg_num, // message number (local) to fetch
int mode, // how would you like that message?
- int headers_only, // eschew the message body?
+ int headers_only, // If nonzero, skip the message body. Also avoids loading it, if it's stored separately.
int do_proto, // do Citadel protocol responses?
- int crlf, // Use CRLF newlines instead of LF?
+ int crlf, // If nonzero, terminate lines with CRLF instead of just LF
char *section, // NULL or a message/rfc822 section
int flags, // various flags; see msgbase.h
- char **Author,
- char **Address,
- char **MessageID
+ char **Author, // If non-NULL, allocate a string buffer and populate the display name (caller must free)
+ char **Address, // If non-NULL, allocate a string buffer and populate the email address (caller must free)
+ char **MessageID // If non-NULL, allocate a string buffer and populate the message ID (caller must free)
) {
struct CtdlMessage *TheMessage = NULL;
int retcode = CIT_OK;
r = check_cached_msglist(msg_num);
}
if (r != om_ok) {
- syslog(LOG_DEBUG, "msgbase: security check fail; message %ld is not in %s",
- msg_num, CC->room.QRname
- );
+ syslog(LOG_DEBUG, "msgbase: security check fail; message %ld is not in %s", 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
- );
+ cprintf("%d message %ld was not found in this room\n", ERROR + HIGHER_ACCESS_REQUIRED, msg_num);
}
}
return(r);
}
if (TheMessage == NULL) {
- if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
- ERROR + MESSAGE_NOT_FOUND, msg_num);
+ if (do_proto) cprintf("%d Can't locate msg %ld on disk\n", ERROR + MESSAGE_NOT_FOUND, msg_num);
return(om_no_such_msg);
}
if (section) if (!IsEmptyStr(section)) if (strcmp(section, "0")) {
memset(&encap, 0, sizeof encap);
safestrncpy(encap.desired_section, section, sizeof encap.desired_section);
- mime_parser(CM_RANGE(TheMessage, eMesageText),
+ mime_parser(CM_RANGE(TheMessage, eMessageText),
*extract_encapsulated_message,
NULL, NULL, (void *)&encap, 0
);
if ((Author != NULL) && (*Author == NULL)) {
- long len;
- CM_GetAsField(TheMessage, eAuthor, Author, &len);
+ *Author = strdup(TheMessage->cm_fields[eAuthor]);
}
if ((Address != NULL) && (*Address == NULL)) {
- long len;
- CM_GetAsField(TheMessage, erFc822Addr, Address, &len);
+ *Address = strdup(TheMessage->cm_fields[erFc822Addr]);
}
if ((MessageID != NULL) && (*MessageID == NULL)) {
- long len;
- CM_GetAsField(TheMessage, emessageId, MessageID, &len);
+ *MessageID = strdup(TheMessage->cm_fields[emessageId]);
}
CM_Free(TheMessage);
TheMessage = NULL;
else {
safestrncpy(display_name, buf, sizeof display_name);
}
- if ((is_room_aide())
- && ((TheMessage->cm_anon_type == MES_ANONONLY)
- || (TheMessage->cm_anon_type == MES_ANONOPT))) {
+ if ( (is_room_aide())
+ && ( (TheMessage->cm_anon_type == MES_ANONONLY)
+ || (TheMessage->cm_anon_type == MES_ANONOPT)
+ )
+ ) {
size_t tmp = strlen(display_name);
- snprintf(&display_name[tmp],
- sizeof display_name - tmp,
- " [%s]", buf);
+ snprintf(&display_name[tmp], sizeof display_name - tmp, " [%s]", buf);
}
}
for (i=0; i< NDiskFields; ++i) {
eMsgField Field;
Field = FieldOrder[i];
- if (Field != eMesageText) {
+ if (Field != eMessageText) {
if ( (!CM_IsEmpty(TheMessage, Field)) && (msgkeys[Field] != NULL) ) {
if ((Field == eenVelopeTo) || (Field == eRecipient) || (Field == eCarbonCopY)) {
sanitize_truncated_recipient(TheMessage->cm_fields[Field]);
case eExclusiveID:
case eJournal:
- case eMesageText:
+ case eMessageText:
case eBig_message:
case eOriginalRoom:
case eErrorMsg:
char *mptr;
int lfSent = 0;
- mptr = TheMessage->cm_fields[eMesageText];
+ mptr = TheMessage->cm_fields[eMessageText];
prev_ch = '\0';
while (*mptr != '\0') {
// do nothing
}
else {
- if ((!eoh) &&
- (*mptr == '\n'))
- {
+ if ((!eoh) && (*mptr == '\n')) {
eoh = (*(mptr+1) == '\r') && (*(mptr+2) == '\n');
- if (!eoh)
+ if (!eoh) {
eoh = *(mptr+1) == '\n';
- if (eoh)
- {
+ }
+ if (eoh) {
StartOfText = mptr;
StartOfText = strchr(StartOfText, '\n');
StartOfText = strchr(StartOfText, '\n');
int xlline = 0;
char *mptr;
- mptr = TheMessage->cm_fields[eMesageText];
+ mptr = TheMessage->cm_fields[eMessageText];
if (mode == MT_MIME) {
cprintf("Content-type: text/plain\n\n");
}
else {
// Parse the message text component
- mime_parser(CM_RANGE(TheMessage, eMesageText), *mime_download, NULL, NULL, NULL, 0);
+ mime_parser(CM_RANGE(TheMessage, eMessageText), *mime_download, NULL, NULL, NULL, 0);
// If there's no file open by this time, the requested * section wasn't found, so print an error
if (CC->download_fp == NULL) {
else {
// Locate and parse the component specified by the caller
int found_it = 0;
- mime_parser(CM_RANGE(TheMessage, eMesageText), *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
+ mime_parser(CM_RANGE(TheMessage, eMessageText), *mime_spew_section, NULL, NULL, (void *)&found_it, 0);
// If section wasn't found, print an error
if (!found_it) {
}
// nhdr=yes means that we're only displaying headers, no body
- if ( (TheMessage->cm_anon_type == MES_ANONONLY)
- && ((mode == MT_CITADEL) || (mode == MT_MIME))
- && (do_proto)
- ) {
+ if ( (TheMessage->cm_anon_type == MES_ANONONLY)
+ && ((mode == MT_CITADEL) || (mode == MT_MIME))
+ && (do_proto)
+ ) {
cprintf("nhdr=yes\n");
}
}
if (mode == MT_RFC822) {
- // Construct a fun message id
- cprintf("Message-ID: <%s", mid);
- if (strchr(mid, '@')==NULL) {
- cprintf("@%s", snode);
- }
- cprintf(">%s", nl);
+ // Make the message ID RFC2822 compliant
+ cprintf("Message-ID: <%s%s%s>%s", // put it in angle brackets
+ mid,
+ (strchr(mid, '@') ? "" : "@"), // if there is no domain part,
+ (strchr(mid, '@') ? "" : snode), // tack on ours.
+ nl
+ );
if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
cprintf("From: \"----\" <x@x.org>%s", nl);
if (TheMessage->cm_format_type == FMT_RFC822) {
if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
memset(&ma, 0, sizeof(struct ma_info));
- mime_parser(CM_RANGE(TheMessage, eMesageText),
+ mime_parser(CM_RANGE(TheMessage, eMessageText),
(do_proto ? *list_this_part : NULL),
(do_proto ? *list_this_pref : NULL),
(do_proto ? *list_this_suff : NULL),
(void *)&ma, 1);
}
else if (mode == MT_RFC822) { // unparsed RFC822 dump
- Dump_RFC822HeadersBody(
- TheMessage,
- headers_only,
- flags,
- nl, nlen);
+ Dump_RFC822HeadersBody(TheMessage, headers_only, flags, nl, nlen);
goto DONE;
}
}
if (do_proto) cprintf("text\n");
}
- if (TheMessage->cm_format_type == FMT_FIXED)
- DumpFormatFixed(
- TheMessage,
- mode, // how would you like that message?
- nl, nlen);
+ if (TheMessage->cm_format_type == FMT_FIXED) {
+ DumpFormatFixed( TheMessage, mode, nl, nlen);
+ }
// If the message on disk is format 0 (Citadel vari-format), we
// output using the formatter at 80 columns. This is the final output
if (mode == MT_MIME) {
cprintf("Content-type: text/x-citadel-variformat\n\n");
}
- memfmout(TheMessage->cm_fields[eMesageText], nl);
+ memfmout(TheMessage->cm_fields[eMessageText], nl);
}
// If the message on disk is format 4 (MIME), we've gotta hand it
strcpy(ma.chosen_part, "1");
ma.chosen_pref = 9999;
ma.dont_decode = CC->msg4_dont_decode;
- mime_parser(CM_RANGE(TheMessage, eMesageText),
+ mime_parser(CM_RANGE(TheMessage, eMessageText),
*choose_preferred, *fixed_output_pre,
*fixed_output_post, (void *)&ma, 1);
- mime_parser(CM_RANGE(TheMessage, eMesageText),
+ mime_parser(CM_RANGE(TheMessage, eMessageText),
*output_preferred, NULL, NULL, (void *)&ma, 1);
}
else {
ma.use_fo_hooks = 1;
- mime_parser(CM_RANGE(TheMessage, eMesageText),
+ mime_parser(CM_RANGE(TheMessage, eMessageText),
*fixed_output, *fixed_output_pre,
*fixed_output_post, (void *)&ma, 0);
}
return(om_ok);
}
+
// Save one or more message pointers into a specified room
// (Returns 0 for success, nonzero for failure)
// roomname may be NULL to use the current room
//
-// Note that the 'supplied_msg' field may be set to NULL, in which case
+// Note that the 'msg_in' field may be set to NULL, in which case
// the message will be fetched from disk, by number, if we need to perform
// replication checks. This adds an additional database read, so if the
// caller already has the message in memory then it should be supplied. (Obviously
// this mode of operation only works if we're saving a single message.)
//
int CtdlSaveMsgPointersInRoom(char *roomname, long newmsgidlist[], int num_newmsgs,
- int do_repl_check, struct CtdlMessage *supplied_msg, int suppress_refcount_adj
+ int do_repl_check, struct CtdlMessage *msg_in, int suppress_refcount_adj
) {
int i, j, unique;
char hold_rm[ROOMNAMELEN];
// Sanity checks
if (newmsgidlist == NULL) return(ERROR + INTERNAL_ERROR);
if (num_newmsgs < 1) return(ERROR + INTERNAL_ERROR);
- if (num_newmsgs > 1) supplied_msg = NULL;
+ if (num_newmsgs > 1) msg_in = NULL;
// Now the regular stuff
if (CtdlGetRoomLock(&CC->room, ((roomname != NULL) ? roomname : CC->room.QRname) ) != 0) {
for (i=0; i<num_msgs_to_be_merged; ++i) {
msgid = msgs_to_be_merged[i];
- if (supplied_msg != NULL) {
- msg = supplied_msg;
+ if (msg_in != NULL) {
+ msg = msg_in;
}
else {
msg = CtdlFetchMessage(msgid, 0);
}
// Free up the memory we may have allocated
- if (msg != supplied_msg) {
+ if (msg != msg_in) {
CM_Free(msg);
}
}
// This is the same as CtdlSaveMsgPointersInRoom() but it only accepts a single message.
-int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int do_repl_check, struct CtdlMessage *supplied_msg) {
- return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, supplied_msg, 0);
+int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int do_repl_check, struct CtdlMessage *msg_in) {
+ return CtdlSaveMsgPointersInRoom(roomname, &msgid, 1, do_repl_check, msg_in, 0);
}
//
// This is the back end for CtdlSubmitMsg() and should not be directly
// called by server-side modules.
-long CtdlSaveThisMessage(struct CtdlMessage *msg, long msgid, int Reply) {
- long retval;
- struct ser_ret smr;
- int is_bigmsg = 0;
- char *holdM = NULL;
- long holdMLen = 0;
+long CtdlSaveThisMessage(struct CtdlMessage *msg, long msgid) {
+ long error_count = 0;
+
+ // Serialize our data structure for storage in the database
+ struct ser_ret smr = CtdlSerializeMessage(msg);
- // 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) {
- is_bigmsg = 1;
- holdM = msg->cm_fields[eMesageText];
- msg->cm_fields[eMesageText] = NULL;
- holdMLen = msg->cm_lengths[eMesageText];
- msg->cm_lengths[eMesageText] = 0;
+ if (smr.len == 0) {
+ syslog(LOG_ERR, "msgbase: CtdlSaveMessage() unable to serialize message");
+ return (-1);
}
- // Serialize our data structure for storage in the database
- CtdlSerializeMessage(&smr, msg);
+ // STORAGE STRATEGY:
+ // * If headers+content fit are <= 4K, store them together. It's likely to be one
+ // memory page, one disk sector, etc. so we benefit from a single disk operation.
+ // * If headers+content exceed 4K, store them separately so we don't end up fetching
+ // many gigamegs of data when we're just scanning the headers.
+ // * We are using a threshold of 4000 bytes so that there's some room for overhead
+ // if the database or OS adds any metadata to that one disk page.
+
+ if (smr.len <= 4000) { // all together less than one page, store them together
+
+ if (cdb_store(CDB_MSGMAIN, &msgid, (int)sizeof(long), smr.ser, smr.len)) {
+ ++error_count;
+ }
- if (is_bigmsg) {
- // put the message body back into the message
- msg->cm_fields[eMesageText] = holdM;
- msg->cm_lengths[eMesageText] = holdMLen;
}
- if (smr.len == 0) {
- if (Reply) {
- cprintf("%d Unable to serialize message\n", ERROR + INTERNAL_ERROR);
+ else { // exceed one page, store headers in MSGMAIN, body in BIGMSGS
+
+ if (cdb_store(CDB_MSGMAIN, &msgid, (int)sizeof(long), smr.ser, (smr.msgstart - smr.ser))) {
+ ++error_count;
}
- else {
- syslog(LOG_ERR, "msgbase: CtdlSaveMessage() unable to serialize message");
+
+ if (cdb_store(CDB_BIGMSGS, &msgid, (int)sizeof(long), smr.msgstart+1, (smr.len - (smr.msgstart - smr.ser) - 1) )) {
+ ++error_count;
}
- return (-1L);
- }
- // Write our little bundle of joy into the message base
- 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);
}
- else {
- if (is_bigmsg) {
- retval = cdb_store(CDB_BIGMSGS, &msgid, (int)sizeof(long), holdM, (holdMLen + 1));
- if (retval < 0) {
- syslog(LOG_ERR, "msgbase: failed to store message body for msgid %ld: %ld", msgid, retval);
- }
- }
+
+ if (error_count > 0) {
+ syslog(LOG_ERR, "msgbase: encountered %ld errors storing message %ld", error_count, msgid);
}
// Free the memory we used for the serialized message
free(smr.ser);
- return(retval);
+ return(error_count);
}
// Generate an ID if we don't have one already
if (CM_IsEmpty(msg, emessageId)) {
- msgidbuflen = snprintf(msgidbuf, sizeof msgidbuf, "%08lX-%08lX@%s",
+ msgidbuflen = snprintf(msgidbuf, sizeof msgidbuf, "%lX-%lX@%s",
(long unsigned int) time(NULL),
(long unsigned int) newmsgid,
CtdlGetConfigStr("c_fqdn")
CM_SetField(msg, emessageId, msgidbuf);
}
- retval = CtdlSaveThisMessage(msg, newmsgid, 1);
+ retval = CtdlSaveThisMessage(msg, newmsgid);
if (retval == 0) {
retval = newmsgid;
// Serialize a struct CtdlMessage into the format used on disk.
//
-// This function loads up a "struct ser_ret" (defined in server.h) which
+// This function returns a "struct ser_ret" (defined in server.h) which
// contains the length of the serialized message and a pointer to the
// serialized message in memory. THE LATTER MUST BE FREED BY THE CALLER.
-void CtdlSerializeMessage(struct ser_ret *ret, // return values
- struct CtdlMessage *msg) // unserialized msg
-{
+struct ser_ret CtdlSerializeMessage(struct CtdlMessage *msg) {
+ struct ser_ret ret;
size_t wlen;
int i;
+ ret.len = 0;
+ ret.ser = NULL;
+ ret.msgstart = NULL;
+
// Check for valid message format
if (CM_IsValidMsg(msg) == 0) {
syslog(LOG_ERR, "msgbase: CtdlSerializeMessage() aborting due to invalid message");
- ret->len = 0;
- ret->ser = NULL;
- return;
+ return(ret);
}
- ret->len = 3;
- for (i=0; i < NDiskFields; ++i)
- if (msg->cm_fields[FieldOrder[i]] != NULL)
- ret->len += msg->cm_lengths[FieldOrder[i]] + 2;
+ ret.len = 3;
+ assert(FieldOrder[NDiskFields-1] == eMessageText); // Message text MUST be last!
+ for (i=0; i < NDiskFields; ++i) {
+ if (msg->cm_fields[FieldOrder[i]] != NULL) {
+ ret.len += msg->cm_lengths[FieldOrder[i]] + 2;
+ }
+ }
- ret->ser = malloc(ret->len);
- if (ret->ser == NULL) {
- syslog(LOG_ERR, "msgbase: CtdlSerializeMessage() malloc(%ld) failed: %m", (long)ret->len);
- ret->len = 0;
- ret->ser = NULL;
- return;
+ ret.ser = malloc(ret.len);
+ if (ret.ser == NULL) {
+ syslog(LOG_ERR, "msgbase: CtdlSerializeMessage() malloc(%ld) failed: %m", (long)ret.len);
+ ret.len = 0;
+ ret.ser = NULL;
+ ret.msgstart = NULL;
+ return(ret);
}
- ret->ser[0] = 0xFF;
- ret->ser[1] = msg->cm_anon_type;
- ret->ser[2] = msg->cm_format_type;
+ ret.ser[0] = 0xFF;
+ ret.ser[1] = msg->cm_anon_type;
+ ret.ser[2] = msg->cm_format_type;
wlen = 3;
for (i=0; i < NDiskFields; ++i) {
if (msg->cm_fields[FieldOrder[i]] != NULL) {
- ret->ser[wlen++] = (char)FieldOrder[i];
-
- memcpy(&ret->ser[wlen],
- msg->cm_fields[FieldOrder[i]],
- msg->cm_lengths[FieldOrder[i]] + 1);
-
+ if (FieldOrder[i] == eMessageText) {
+ ret.msgstart = &ret.ser[wlen]; // Make a note where the message text begins
+ }
+ ret.ser[wlen++] = (char)FieldOrder[i];
+ memcpy(&ret.ser[wlen], msg->cm_fields[FieldOrder[i]], msg->cm_lengths[FieldOrder[i]] + 1);
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);
- }
-
- return;
+ assert(ret.len == wlen); // Make sure we measured it correctly
+ return(ret);
}
}
// Learn about what's inside, because it's what's inside that counts
- if (CM_IsEmpty(msg, eMesageText)) {
+ if (CM_IsEmpty(msg, eMessageText)) {
syslog(LOG_ERR, "msgbase: ERROR; attempt to save message with NULL body");
return(-2);
}
break;
case 4:
strcpy(content_type, "text/plain");
- mptr = bmstrcasestr(msg->cm_fields[eMesageText], "Content-type:");
+ mptr = bmstrcasestr(msg->cm_fields[eMessageText], "Content-type:");
if (mptr != NULL) {
char *aptr;
safestrncpy(content_type, &mptr[13], sizeof content_type);
string_trim(content_type);
aptr = content_type;
while (!IsEmptyStr(aptr)) {
- if ((*aptr == ';')
- || (*aptr == ' ')
- || (*aptr == 13)
- || (*aptr == 10)) {
+ if ( (*aptr == ';')
+ || (*aptr == ' ')
+ || (*aptr == 13)
+ || (*aptr == 10)
+ ) {
*aptr = 0;
}
- else aptr++;
+ else {
+ aptr++;
+ }
}
}
}
if (!IsEmptyStr(room)) CM_SetField(msg, eOriginalRoom, room);
if (!IsEmptyStr(to)) {
CM_SetField(msg, eRecipient, to);
- recp = validate_recipients(to, NULL, 0);
+ recp = validate_recipients(to, 0);
}
if (!IsEmptyStr(subject)) {
CM_SetField(msg, eMsgSubject, subject);
}
if (!IsEmptyStr(text)) {
- CM_SetField(msg, eMesageText, text);
+ CM_SetField(msg, eMessageText, text);
}
long msgnum = CtdlSubmitMsg(msg, recp, room);
char *fake_name, // who we're masquerading as
char *my_email, // which of my email addresses to use (empty is ok)
char *subject, // Subject (optional)
- char *supplied_euid, // ...or NULL if this is irrelevant
+ char *euid_in, // ...or NULL if this is irrelevant
char *preformatted_text, // ...or NULL to read text from client
char *references // Thread references
) {
(my_email)?strlen(my_email): 0,
subject, // Subject (optional)
(subject)?strlen(subject): 0,
- supplied_euid, // ...or NULL if this is irrelevant
- (supplied_euid)?strlen(supplied_euid):0,
+ euid_in, // ...or NULL if this is irrelevant
+ (euid_in)?strlen(euid_in):0,
preformatted_text, // ...or NULL to read text from client
(preformatted_text)?strlen(preformatted_text) : 0,
references, // Thread references
long myelen,
char *subject, // Subject (optional)
long subjlen,
- char *supplied_euid, // ...or NULL if this is irrelevant
+ char *euid_in, // ...or NULL if this is irrelevant
long euidlen,
char *preformatted_text, // ...or NULL to read text from client
long textlen,
long IsAscii;
IsAscii = -1;
i = 0;
- while ((subject[i] != '\0') && (IsAscii = isascii(subject[i]) != 0 ))
+ while ((subject[i] != '\0') && (IsAscii = isascii(subject[i]) != 0 )) {
i++;
- if (IsAscii != 0)
+ }
+ if (IsAscii != 0) {
CM_SetField(msg, eMsgSubject, subject);
+ }
else { // ok, we've got utf8 in the string.
char *rfc2047Subj;
rfc2047Subj = rfc2047encode(subject, length);
}
if (euidlen > 0) {
- CM_SetField(msg, eExclusiveID, supplied_euid);
+ CM_SetField(msg, eExclusiveID, euid_in);
}
if (reflen > 0) {
}
if (preformatted_text != NULL) {
- CM_SetField(msg, eMesageText, preformatted_text);
+ CM_SetField(msg, eMessageText, preformatted_text);
}
else {
StrBuf *MsgBody;
MsgBody = CtdlReadMessageBodyBuf(HKEY("000"), CtdlGetConfigLong("c_maxmsglen"), NULL, 0);
if (MsgBody != NULL) {
- CM_SetAsFieldSB(msg, eMesageText, &MsgBody);
+ CM_SetAsFieldSB(msg, eMessageText, &MsgBody);
}
}
int need_to_free_re = 0;
if (content_type) if (!IsEmptyStr(content_type)) {
- regcomp(&re, content_type, 0);
- need_to_free_re = 1;
- }
+ regcomp(&re, content_type, 0);
+ need_to_free_re = 1;
+ }
syslog(LOG_DEBUG, "msgbase: CtdlDeleteMessages(%s, %d msgs, %s)", room_name, num_dmsgnums, content_type);
// get room record, obtaining a lock...
// Use the negative of the message number for the metadata db index
TheIndex = (0L - smibuf->meta_msgnum);
-
- cdb_store(CDB_MSGMAIN,
- &TheIndex, (int)sizeof(long),
- smibuf, (int)sizeof(struct MetaData)
- );
+ cdb_store(CDB_MSGMAIN, &TheIndex, (int)sizeof(long), smibuf, (int)sizeof(struct MetaData));
}
CM_SetField(msg, eOriginalRoom, req_room);
msg->cm_flags = flags;
- CM_SetAsFieldSB(msg, eMesageText, &encoded_message);
+ CM_SetAsFieldSB(msg, eMessageText, &encoded_message);
// Create the requested room if we have to.
if (CtdlGetRoom(&qrbuf, roomname) != 0) {
projects / citadel.git / blobdiff