int num_msgs = 0;
char vset[SIZ];
+ lprintf(CTDL_DEBUG, "CtdlSetSeen(%ld, %d, %d)\n",
+ target_msgnum, target_setting, which_set);
+
/* Learn about the user and room in question */
CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
if (num_msgs > 0) {
if (compare != NULL) {
for (a = 0; a < num_msgs; ++a) {
- msg = CtdlFetchMessage(msglist[a]);
+ msg = CtdlFetchMessage(msglist[a], 1);
if (msg != NULL) {
if (CtdlMsgCmp(msg, compare)) {
msglist[a] = 0L;
}
if (with_template) {
+ unbuffer_output();
cprintf("%d Send template then receive message list\n",
START_CHAT_MODE);
template = (struct CtdlMessage *)
}
}
}
+ buffer_output();
}
else {
cprintf("%d Message list...\n", LISTING_FOLLOWS);
* NOTE: Caller is responsible for freeing the returned CtdlMessage struct
* using the CtdlMessageFree() function.
*/
-struct CtdlMessage *CtdlFetchMessage(long msgnum)
+struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
{
struct cdbdata *dmsgtext;
struct CtdlMessage *ret = NULL;
cit_uint8_t field_header;
size_t field_length;
+ lprintf(CTDL_DEBUG, "CtdlFetchMessage(%ld, %d)\n", msgnum, with_body);
+
dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
if (dmsgtext == NULL) {
return NULL;
*/
ch = *mptr++;
if (ch != 255) {
- lprintf(CTDL_ERR, "Message %ld appears to be corrupted.\n", msgnum);
+ lprintf(CTDL_ERR,
+ "Message %ld appears to be corrupted.\n",
+ msgnum);
cdb_free(dmsgtext);
return NULL;
}
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 */
cdb_free(dmsgtext);
- /* Always make sure there's something in the msg text field */
- if (ret->cm_fields['M'] == NULL)
+ /* Always make sure there's something in the msg text field. If
+ * it's NULL, the message text is most likely stored separately,
+ * so go ahead and fetch that. Failing that, just set a dummy
+ * body so other code doesn't barf.
+ */
+ if ( (ret->cm_fields['M'] == NULL) && (with_body) ) {
+ dmsgtext = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
+ if (dmsgtext != NULL) {
+ ret->cm_fields['M'] = strdup(dmsgtext->ptr);
+ cdb_free(dmsgtext);
+ }
+ }
+ if (ret->cm_fields['M'] == NULL) {
ret->cm_fields['M'] = strdup("<no text>\n");
+ }
/* Perform "before read" hooks (aborting if any return nonzero) */
if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
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_not_logged_in);
}
- /* FIXME ... small security issue
- * We need to check to make sure the requested message is actually
- * in the current room, and set msg_ok to 1 only if it is. This
- * functionality is currently missing because I'm in a hurry to replace
- * broken production code with nonbroken pre-beta code. :( -- ajc
- *
- if (!msg_ok) {
- if (do_proto) cprintf("%d Message %ld is not in this room.\n",
- ERROR + MESSAGE_NOT_FOUND, msg_num);
- return(om_no_such_msg);
- }
- */
+ /* FIXME: check message id against msglist for this room */
/*
- * Fetch the message from disk.
+ * Fetch the message from disk. If we're in sooper-fast headers
+ * only mode, request that we don't even bother loading the body
+ * into memory.
*/
- TheMessage = CtdlFetchMessage(msg_num);
+ if (headers_only == HEADERS_FAST) {
+ TheMessage = CtdlFetchMessage(msg_num, 0);
+ }
+ else {
+ TheMessage = CtdlFetchMessage(msg_num, 1);
+ }
if (TheMessage == NULL) {
if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
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");
+ lprintf(CTDL_ERR,
+ "ERROR: invalid preloaded message for output\n");
return(om_no_such_msg);
}
/* 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);
+ safestrncpy(luser, mptr, sizeof luser);
+ safestrncpy(suser, mptr, sizeof suser);
}
-/****
- "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);
- }
- ****/
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'];
/* Tell the client about the MIME parts in this message */
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);
}
}
msgnum = extract_long(cmdbuf, 0);
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) {
cprintf("%d Message %ld not found.\n",
ERROR + MESSAGE_NOT_FOUND, msgnum);
}
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);
}
if ( (flags & SM_VERIFY_GOODNESS)
|| (flags & SM_DO_REPL_CHECK)
) {
- msg = CtdlFetchMessage(msgid);
+ msg = CtdlFetchMessage(msgid, 1);
if (msg == NULL) return(ERROR + ILLEGAL_VALUE);
}
if (ReplicationChecks(msg) != 0) {
getroom(&CC->room, hold_rm);
if (msg != NULL) CtdlFreeMessage(msg);
- lprintf(CTDL_DEBUG, "Did replication, and newer exists\n");
+ lprintf(CTDL_DEBUG,
+ "Did replication, and newer exists\n");
return(0);
}
}
lputroom(&CC->room); /* unlock the room */
getroom(&CC->room, hold_rm);
if (msg != NULL) CtdlFreeMessage(msg);
+ free(msglist);
return(ERROR + ALREADY_EXISTS);
}
}
/* Now add the new message */
++num_msgs;
- msglist = realloc(msglist,
- (num_msgs * sizeof(long)));
+ msglist = realloc(msglist, (num_msgs * sizeof(long)));
if (msglist == NULL) {
lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
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);
/*
- * Message base operation to send a message to the master file
+ * Message base operation to save a new message to the message store
* (returns new message number)
*
* This is the back end for CtdlSubmitMsg() and should not be directly
* called by server-side modules.
*
*/
-long send_message(struct CtdlMessage *msg, /* pointer to buffer */
- FILE *save_a_copy) /* save a copy to disk? */
-{
+long send_message(struct CtdlMessage *msg) {
long newmsgid;
long retval;
char msgidbuf[SIZ];
struct ser_ret smr;
+ int is_bigmsg = 0;
+ char *holdM = NULL;
/* Get a new message number */
newmsgid = get_new_message_number();
if (msg->cm_fields['I']==NULL) {
msg->cm_fields['I'] = strdup(msgidbuf);
}
-
+
+ /* If the message is big, set its body aside for storage elsewhere */
+ if (msg->cm_fields['M'] != NULL) {
+ if (strlen(msg->cm_fields['M']) > BIGMSG) {
+ is_bigmsg = 1;
+ holdM = msg->cm_fields['M'];
+ msg->cm_fields['M'] = NULL;
+ }
+ }
+
+ /* Serialize our data structure for storage in the database */
serialize_message(&smr, msg);
+ if (is_bigmsg) {
+ msg->cm_fields['M'] = holdM;
+ }
+
if (smr.len == 0) {
cprintf("%d Unable to serialize message\n",
ERROR + INTERNAL_ERROR);
}
/* 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;
} else {
+ if (is_bigmsg) {
+ cdb_store(CDB_BIGMSGS,
+ &newmsgid,
+ (int)sizeof(long),
+ holdM,
+ (strlen(holdM) + 1)
+ );
+ }
retval = newmsgid;
}
- /* If the caller specified that a copy should be saved to a particular
- * file handle, do that now too.
- */
- if (save_a_copy != NULL) {
- fwrite(smr.ser, smr.len, 1, save_a_copy);
- }
-
/* Free the memory we used for the serialized message */
free(smr.ser);
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",
time_t timestamp = (-1L);
lprintf(CTDL_DEBUG, "check_repl() found message %ld\n", msgnum);
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) return;
if (msg->cm_fields['T'] != NULL) {
timestamp = atol(msg->cm_fields['T']);
/* Save it to disk */
lprintf(CTDL_DEBUG, "Saving to disk\n");
- newmsgid = send_message(msg, NULL);
+ newmsgid = send_message(msg);
if (newmsgid <= 0L) return(-1);
/* Write a supplemental message info record. This doesn't have to
*/
int CtdlCheckInternetMailPermission(struct ctdluser *who) {
+ /* Do not allow twits to send Internet mail */
+ if (who->axlevel <= 2) return(0);
+
/* Globally enabled? */
if (config.c_restrict == 0) return(1);
struct recptypes *valid = NULL;
char subject[SIZ];
+ unbuffer_output();
+
post = extract_int(entargs, 0);
extract(recp, entargs, 1);
anon_flag = extract_int(entargs, 2);
}
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];
}
int err;
int is_copy = 0;
int ra;
+ int permit = 0;
num = extract_long(args, 0);
extract(targ, args, 1);
is_copy = extract_int(args, 2);
if (getroom(&qtemp, targ) != 0) {
- cprintf("%d '%s' does not exist.\n", ERROR + ROOM_NOT_FOUND, targ);
+ cprintf("%d '%s' does not exist.\n",
+ ERROR + ROOM_NOT_FOUND, targ);
return;
}
getuser(&CC->user, CC->curr_user);
ra = CtdlRoomAccess(&qtemp, &CC->user);
+
+ /* Check for permission to perform this operation.
+ * Remember: "CC->room" is source, "qtemp" is target.
+ */
+ permit = 0;
+
/* Aides can move/copy */
- if ((CC->user.axlevel < 6)
- /* Roomaides can move/copy */
- && (CC->user.usernum != CC->room.QRroomaide)
- /* Permit move/copy from personal rooms */
- && (!((CC->room.QRflags & QR_MAILBOX)
- && (qtemp.QRflags & QR_MAILBOX)))
- /* Permit only copy from public to personal room */
- && (!(is_copy && (CC->room.QRflags & QR_MAILBOX)
- || (qtemp.QRflags & QR_MAILBOX)))
- /* User must have access to target room */
- && !((ra & UA_KNOWN))) {
+ if (CC->user.axlevel >= 6) permit = 1;
+
+ /* Room aides can move/copy */
+ if (CC->user.usernum == CC->room.QRroomaide) permit = 1;
+
+ /* Permit move/copy from personal rooms */
+ if ((CC->room.QRflags & QR_MAILBOX)
+ && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+
+ /* Permit only copy from public to personal room */
+ if ( (is_copy)
+ && (!(CC->room.QRflags & QR_MAILBOX))
+ && (qtemp.QRflags & QR_MAILBOX)) permit = 1;
+
+ /* User must have access to target room */
+ if (!(ra & UA_KNOWN)) permit = 0;
+
+ if (!permit) {
cprintf("%d Higher access required.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
return;
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_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));
}
}
if (getroom(&qrbuf, roomname) != 0) {
create_room(roomname,
( (is_mailbox != NULL) ? 5 : 3 ),
- "", 0, 1, 0);
+ "", 0, 1, 0, VIEW_BBS);
}
/* If the caller specified this object as unique, delete all
* other objects of this type that are currently in the room.
conf = NULL;
}
else {
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg != NULL) {
conf = strdup(msg->cm_fields['M']);
CtdlFreeMessage(msg);