if (field_length == 0)
break;
field_header = *mptr++;
- ret->cm_fields[field_header] = malloc(field_length);
+ ret->cm_fields[field_header] = malloc(field_length + 1);
strcpy(ret->cm_fields[field_header], mptr);
while (*mptr++ != 0); /* advance to next field */
int do_proto, /* do Citadel protocol responses? */
int crlf /* Use CRLF newlines instead of LF? */
) {
- struct CtdlMessage *TheMessage;
- int retcode;
+ struct CtdlMessage *TheMessage = NULL;
+ int retcode = om_no_such_msg;
lprintf(CTDL_DEBUG, "CtdlOutputMsg() msgnum=%ld, mode=%d\n",
msg_num, mode);
- TheMessage = NULL;
-
if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
if (do_proto) cprintf("%d Not logged in.\n",
ERROR + NOT_LOGGED_IN);
return(om_no_such_msg);
}
+ TRACE;
retcode = CtdlOutputPreLoadedMsg(
TheMessage, msg_num, mode,
headers_only, do_proto, crlf);
+ TRACE;
CtdlFreeMessage(TheMessage);
return(retcode);
* Get a message off disk. (returns om_* values found in msgbase.h)
*
*/
-int CtdlOutputPreLoadedMsg(struct CtdlMessage *TheMessage,
+int CtdlOutputPreLoadedMsg(
+ struct CtdlMessage *TheMessage,
long msg_num,
int mode, /* how would you like that message? */
int headers_only, /* eschew the message body? */
int crlf /* Use CRLF newlines instead of LF? */
) {
int i, k;
- char buf[1024];
+ char buf[SIZ];
cit_uint8_t ch;
char allkeys[SIZ];
char display_name[SIZ];
char datestamp[SIZ];
/* */
+ lprintf(CTDL_DEBUG, "CtdlOutputPreLoadedMsg(TheMessage=%s, %ld, %d, %d, %d, %d\n",
+ ((TheMessage == NULL) ? "NULL" : "not null"),
+ msg_num,
+ mode, headers_only, do_proto, crlf);
+
+ TRACE;
snprintf(mid, sizeof mid, "%ld", msg_num);
nl = (crlf ? "\r\n" : "\n");
+ TRACE;
if (!is_valid_message(TheMessage)) {
lprintf(CTDL_ERR,
"ERROR: invalid preloaded message for output\n");
}
/* Are we downloading a MIME component? */
+ TRACE;
if (mode == MT_DOWNLOAD) {
if (TheMessage->cm_format_type != FMT_RFC822) {
if (do_proto)
desired_section);
}
}
+ TRACE;
return((CC->download_fp != NULL) ? om_ok : om_mime_error);
}
+ TRACE;
/* now for the user-mode message reading loops */
if (do_proto) cprintf("%d Message %ld:\n", LISTING_FOLLOWS, msg_num);
/* begin header processing loop for Citadel message format */
+ TRACE;
if ((mode == MT_CITADEL) || (mode == MT_MIME)) {
strcpy(display_name, "<unknown>");
}
/* begin header processing loop for RFC822 transfer format */
+ TRACE;
strcpy(suser, "");
strcpy(luser, "");
strcpy(fuser, "");
strcpy(snode, NODENAME);
strcpy(lnode, HUMANNODE);
+ TRACE;
if (mode == MT_RFC822) {
- cprintf("X-UIDL: %ld%s", msg_num, nl);
for (i = 0; i < 256; ++i) {
+ TRACE;
if (TheMessage->cm_fields[i]) {
mptr = TheMessage->cm_fields[i];
+ TRACE;
if (i == 'A') {
- strcpy(luser, mptr);
- strcpy(suser, mptr);
- }
-/****
- "Path:" removed for now because it confuses brain-dead Microsoft shitware
- into thinking that mail messages are newsgroup messages instead. When we
- add NNTP support back into Citadel we'll have to add code to only output
- this field when appropriate.
- else if (i == 'P') {
- cprintf("Path: %s%s", mptr, nl);
+ safestrncpy(luser, mptr, sizeof luser);
+ safestrncpy(suser, mptr, sizeof suser);
}
- ****/
else if (i == 'U') {
cprintf("Subject: %s%s", mptr, nl);
subject_found = 1;
}
}
if (subject_found == 0) {
+ TRACE;
cprintf("Subject: (no subject)%s", nl);
}
}
+ TRACE;
for (i=0; i<strlen(suser); ++i) {
suser[i] = tolower(suser[i]);
if (!isalnum(suser[i])) suser[i]='_';
}
+ TRACE;
if (mode == MT_RFC822) {
if (!strcasecmp(snode, NODENAME)) {
- strcpy(snode, FQDN);
+ safestrncpy(snode, FQDN, sizeof snode);
}
+ TRACE;
/* Construct a fun message id */
cprintf("Message-ID: <%s", mid);
cprintf("@%s", snode);
}
cprintf(">%s", nl);
+ TRACE;
if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
cprintf("From: x@x.org (----)%s", nl);
}
cprintf("Organization: %s%s", lnode, nl);
+ TRACE;
/* Blank line signifying RFC822 end-of-headers */
if (TheMessage->cm_format_type != FMT_RFC822) {
/* end header processing loop ... at this point, we're in the text */
START_TEXT:
+ TRACE;
if (headers_only == HEADERS_FAST) goto DONE;
mptr = TheMessage->cm_fields['M'];
if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
if (do_proto) cprintf("text\n");
}
+ TRACE;
/* If the format type on disk is 1 (fixed-format), then we want
* everything to be output completely literally ... regardless of
* what message transfer format is in use.
*/
+ TRACE;
if (TheMessage->cm_format_type == FMT_FIXED) {
if (mode == MT_MIME) {
cprintf("Content-type: text/plain\n\n");
* for new paragraphs is correct and the client will reformat the
* message to the reader's screen width.
*/
+ TRACE;
if (TheMessage->cm_format_type == FMT_CITADEL) {
if (mode == MT_MIME) {
cprintf("Content-type: text/x-citadel-variformat\n\n");
* this message is format 1 (fixed format), so the callback function
* we use will display those parts as-is.
*/
+ TRACE;
if (TheMessage->cm_format_type == FMT_RFC822) {
CtdlAllocUserData(SYM_MA_INFO, sizeof(struct ma_info));
memset(ma, 0, sizeof(struct ma_info));
DONE: /* now we're done */
if (do_proto) cprintf("000\n");
+ TRACE;
return(om_ok);
}
}
cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
- client_write(smr.ser, smr.len);
+ client_write((char *)smr.ser, (int)smr.len);
free(smr.ser);
}
highest_msg = msglist[num_msgs - 1];
/* Write it back to disk. */
- cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long),
- msglist, num_msgs * sizeof(long));
+ cdb_store(CDB_MSGLISTS, &CC->room.QRnumber, (int)sizeof(long),
+ msglist, (int)(num_msgs * sizeof(long)));
/* Free up the memory we used. */
free(msglist);
}
/* Write our little bundle of joy into the message base */
- if (cdb_store(CDB_MSGMAIN, &newmsgid, sizeof(long),
+ if (cdb_store(CDB_MSGMAIN, &newmsgid, (int)sizeof(long),
smr.ser, smr.len) < 0) {
lprintf(CTDL_ERR, "Can't store message\n");
retval = 0L;
if (is_bigmsg) {
cdb_store(CDB_BIGMSGS,
&newmsgid,
- sizeof(long),
+ (int)sizeof(long),
holdM,
(strlen(holdM) + 1)
);
for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
ret->ser[wlen++] = (char)forder[i];
- strcpy(&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
+ strcpy((char *)&ret->ser[wlen], msg->cm_fields[(int)forder[i]]);
wlen = wlen + strlen(msg->cm_fields[(int)forder[i]]) + 1;
}
if (ret->len != wlen) lprintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
}
num_msgs = sort_msglist(msglist, num_msgs);
- cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long),
- msglist, (num_msgs * sizeof(long)));
+ cdb_store(CDB_MSGLISTS, &qrbuf.QRnumber, (int)sizeof(long),
+ msglist, (int)(num_msgs * sizeof(long)));
qrbuf.QRhighest = msglist[num_msgs - 1];
}
smibuf->meta_msgnum, smibuf->meta_refcount);
cdb_store(CDB_MSGMAIN,
- &TheIndex, sizeof(long),
- smibuf, sizeof(struct MetaData));
+ &TheIndex, (int)sizeof(long),
+ smibuf, (int)sizeof(struct MetaData));
}
if (smi.meta_refcount == 0) {
lprintf(CTDL_DEBUG, "Deleting message <%ld>\n", msgnum);
delnum = msgnum;
- cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
- cdb_delete(CDB_BIGMSGS, &delnum, sizeof(long));
+ cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
+ cdb_delete(CDB_BIGMSGS, &delnum, (int)sizeof(long));
/* We have to delete the metadata record too! */
delnum = (0L - msgnum);
- cdb_delete(CDB_MSGMAIN, &delnum, sizeof(long));
+ cdb_delete(CDB_MSGMAIN, &delnum, (int)sizeof(long));
}
}
projects / citadel.git / blobdiff