#include "genstamp.h"
#include "internet_addressing.h"
-#define desired_section ((char *)CtdlGetUserData(SYM_DESIRED_SECTION))
-#define ma ((struct ma_info *)CtdlGetUserData(SYM_MA_INFO))
-#define msg_repl ((struct repl *)CtdlGetUserData(SYM_REPL))
-
extern struct config config;
long config_msgnum;
char *ignetcfg = NULL;
char *ignetmap = NULL;
int at = 0;
- char node[SIZ];
- char testnode[SIZ];
+ char node[64];
+ char testnode[64];
char buf[SIZ];
striplt(name);
remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
/* figure out the delivery mode */
- extract_token(node, name, 1, '@');
+ extract_token(node, name, 1, '@', sizeof node);
/* If there are one or more dots in the nodename, we assume that it
* is an FQDN and will attempt SMTP delivery to the Internet.
*/
ignetcfg = CtdlGetSysConfig(IGNETCFG);
for (i=0; i<num_tokens(ignetcfg, '\n'); ++i) {
- extract_token(buf, ignetcfg, i, '\n');
- extract_token(testnode, buf, 0, '|');
+ extract_token(buf, ignetcfg, i, '\n', sizeof buf);
+ extract_token(testnode, buf, 0, '|', sizeof testnode);
if (!strcasecmp(node, testnode)) {
free(ignetcfg);
return(MES_IGNET);
*/
ignetmap = CtdlGetSysConfig(IGNETMAP);
for (i=0; i<num_tokens(ignetmap, '\n'); ++i) {
- extract_token(buf, ignetmap, i, '\n');
- extract_token(testnode, buf, 0, '|');
+ extract_token(buf, ignetmap, i, '\n', sizeof buf);
+ extract_token(testnode, buf, 0, '|', sizeof testnode);
if (!strcasecmp(node, testnode)) {
free(ignetmap);
return(MES_IGNET);
void cmd_msgs(char *cmdbuf)
{
int mode = 0;
- char which[SIZ];
- char buf[SIZ];
- char tfield[SIZ];
- char tvalue[SIZ];
+ char which[16];
+ char buf[256];
+ char tfield[256];
+ char tvalue[256];
int cm_ref = 0;
int i;
int with_template = 0;
struct CtdlMessage *template = NULL;
- extract(which, cmdbuf, 0);
+ extract_token(which, cmdbuf, 0, '|', sizeof which);
cm_ref = extract_int(cmdbuf, 1);
with_template = extract_int(cmdbuf, 2);
}
if (with_template) {
+ unbuffer_output();
cprintf("%d Send template then receive message list\n",
START_CHAT_MODE);
template = (struct CtdlMessage *)
malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
- while(client_gets(buf), strcmp(buf,"000")) {
- extract(tfield, buf, 0);
- extract(tvalue, buf, 1);
+ while(client_getln(buf, sizeof buf), strcmp(buf,"000")) {
+ extract_token(tfield, buf, 0, '|', sizeof tfield);
+ extract_token(tvalue, buf, 1, '|', sizeof tvalue);
for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
if (!strcasecmp(tfield, msgkeys[i])) {
template->cm_fields[i] =
}
}
}
+ buffer_output();
}
else {
cprintf("%d Message list...\n", LISTING_FOLLOWS);
help_subst(buffer, "^variantname", CITADEL);
snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
help_subst(buffer, "^maxsessions", buf2);
- help_subst(buffer, "^bbsdir", BBSDIR);
+ help_subst(buffer, "^bbsdir", CTDLDIR);
}
return;
/* ...or if this is not the desired section */
- if (strcasecmp(desired_section, partnum))
+ if (strcasecmp(CC->download_desired_section, partnum))
return;
CC->download_fp = tmpfile();
struct CtdlMessage *CtdlFetchMessage(long msgnum, int with_body)
{
struct cdbdata *dmsgtext;
- struct cdbdata *dbigmsg;
struct CtdlMessage *ret = NULL;
char *mptr;
+ char *upper_bound;
cit_uint8_t ch;
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;
}
mptr = dmsgtext->ptr;
+ upper_bound = mptr + dmsgtext->len;
/* Parse the three bytes that begin EVERY message on disk.
* The first is always 0xFF, the on-disk magic number.
*/
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;
}
* have just processed the 'M' (message text) field.
*/
do {
- field_length = strlen(mptr);
- if (field_length == 0)
+ if (mptr >= upper_bound) {
break;
+ }
field_header = *mptr++;
- ret->cm_fields[field_header] = malloc(field_length);
- strcpy(ret->cm_fields[field_header], mptr);
+ ret->cm_fields[field_header] = strdup(mptr);
while (*mptr++ != 0); /* advance to next field */
- } while ((field_length > 0) && (field_header != 'M'));
+ } while ((mptr < upper_bound) && (field_header != 'M'));
cdb_free(dmsgtext);
* 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) {
-
- dbigmsg = cdb_fetch(CDB_BIGMSGS, &msgnum, sizeof(long));
- if (dmsgtext == NULL) {
- ret->cm_fields['M'] = strdup("<no text>\n");
- }
- else {
- ret->cm_fields['M'] = strdup(dbigmsg->ptr);
- cdb_free(dbigmsg);
+ 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) {
void *content, char *cbtype, size_t length, char *encoding,
void *cbuserdata)
{
- lprintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- ++ma->is_ma;
- ma->did_print = 0;
- return;
- }
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ lprintf(CTDL_DEBUG, "fixed_output_pre() type=<%s>\n", cbtype);
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ ++ma->is_ma;
+ ma->did_print = 0;
+ return;
+ }
}
/*
void *content, char *cbtype, size_t length, char *encoding,
void *cbuserdata)
{
- lprintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- --ma->is_ma;
- ma->did_print = 0;
- return;
- }
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
+ lprintf(CTDL_DEBUG, "fixed_output_post() type=<%s>\n", cbtype);
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ --ma->is_ma;
+ ma->did_print = 0;
+ return;
+ }
}
/*
char *ptr;
char *wptr;
size_t wlen;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
lprintf(CTDL_DEBUG, "fixed_output() type=<%s>\n", cbtype);
void *content, char *cbtype, size_t length, char *encoding,
void *cbuserdata)
{
- char buf[SIZ];
+ char buf[1024];
int i;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
if (ma->is_ma > 0) {
for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
- extract(buf, CC->preferred_formats, i);
+ extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
if (!strcasecmp(buf, cbtype)) {
strcpy(ma->chosen_part, partnum);
}
void *cbuserdata)
{
int i;
- char buf[SIZ];
+ char buf[128];
int add_newline = 0;
char *text_content;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
/* This is not the MIME part you're looking for... */
if (strcasecmp(partnum, ma->chosen_part)) return;
* list, we can simply output it verbatim.
*/
for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
- extract(buf, CC->preferred_formats, i);
+ extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
if (!strcasecmp(buf, cbtype)) {
/* Yeah! Go! W00t!! */
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);
* 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 allkeys[30];
+ char display_name[256];
char *mptr;
char *nl; /* newline string */
int suppress_f = 0;
int subject_found = 0;
+ struct ma_info *ma;
- /* buffers needed for RFC822 translation */
- char suser[SIZ];
- char luser[SIZ];
- char fuser[SIZ];
- char snode[SIZ];
- char lnode[SIZ];
- char mid[SIZ];
- char datestamp[SIZ];
- /* */
+ /* Buffers needed for RFC822 translation. These are all filled
+ * using functions that are bounds-checked, and therefore we can
+ * make them substantially smaller than SIZ.
+ */
+ char suser[100];
+ char luser[100];
+ char fuser[100];
+ char snode[100];
+ char lnode[100];
+ char mid[100];
+ char datestamp[100];
+
+ 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);
snprintf(mid, sizeof mid, "%ld", msg_num);
nl = (crlf ? "\r\n" : "\n");
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);
}
} else {
/* Parse the message text component */
mptr = TheMessage->cm_fields['M'];
- mime_parser(mptr, NULL,
- *mime_download, NULL, NULL,
- NULL, 0);
+ ma = malloc(sizeof(struct ma_info));
+ memset(ma, 0, sizeof(struct ma_info));
+ mime_parser(mptr, NULL, *mime_download, NULL, NULL, (void *)ma, 0);
+ free(ma);
/* If there's no file open by this time, the requested
* section wasn't found, so print an error
*/
if (do_proto) cprintf(
"%d Section %s not found.\n",
ERROR + FILE_NOT_FOUND,
- desired_section);
+ CC->download_desired_section);
}
}
return((CC->download_fp != NULL) ? om_ok : om_mime_error);
if ((mode == MT_CITADEL) || (mode == MT_MIME)) {
- strcpy(display_name, "<unknown>");
+ safestrncpy(display_name, "<unknown>", sizeof display_name);
if (TheMessage->cm_fields['A']) {
strcpy(buf, TheMessage->cm_fields['A']);
if (TheMessage->cm_anon_type == MES_ANONONLY) {
- strcpy(display_name, "****");
+ safestrncpy(display_name, "****", sizeof display_name);
}
else if (TheMessage->cm_anon_type == MES_ANONOPT) {
- strcpy(display_name, "anonymous");
+ safestrncpy(display_name, "anonymous", sizeof display_name);
}
else {
- strcpy(display_name, buf);
+ safestrncpy(display_name, buf, sizeof display_name);
}
if ((is_room_aide())
&& ((TheMessage->cm_anon_type == MES_ANONONLY)
}
/* Now spew the header fields in the order we like them. */
- strcpy(allkeys, FORDER);
+ safestrncpy(allkeys, FORDER, sizeof allkeys);
for (i=0; i<strlen(allkeys); ++i) {
k = (int) allkeys[i];
if (k != 'M') {
strcpy(snode, NODENAME);
strcpy(lnode, HUMANNODE);
if (mode == MT_RFC822) {
- cprintf("X-UIDL: %ld%s", msg_num, nl);
for (i = 0; i < 256; ++i) {
if (TheMessage->cm_fields[i]) {
mptr = TheMessage->cm_fields[i];
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 (mode == MT_RFC822) {
if (!strcasecmp(snode, NODENAME)) {
- strcpy(snode, FQDN);
+ safestrncpy(snode, FQDN, sizeof snode);
}
/* Construct a fun message id */
* we use will display those parts as-is.
*/
if (TheMessage->cm_format_type == FMT_RFC822) {
- CtdlAllocUserData(SYM_MA_INFO, sizeof(struct ma_info));
+ ma = malloc(sizeof(struct ma_info));
memset(ma, 0, sizeof(struct ma_info));
if (mode == MT_MIME) {
strcpy(ma->chosen_part, "1");
mime_parser(mptr, NULL,
*choose_preferred, *fixed_output_pre,
- *fixed_output_post, NULL, 0);
+ *fixed_output_post, (void *)ma, 0);
mime_parser(mptr, NULL,
- *output_preferred, NULL, NULL, NULL, 0);
+ *output_preferred, NULL, NULL, (void *)ma, 0);
}
else {
mime_parser(mptr, NULL,
*fixed_output, *fixed_output_pre,
- *fixed_output_post, NULL, 0);
+ *fixed_output_post, (void *)ma, 0);
}
+
+ free(ma);
}
DONE: /* now we're done */
}
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);
}
void cmd_opna(char *cmdbuf)
{
long msgid;
-
- CtdlAllocUserData(SYM_DESIRED_SECTION, SIZ);
+ char desired_section[128];
msgid = extract_long(cmdbuf, 0);
- extract(desired_section, cmdbuf, 1);
-
+ extract_token(desired_section, cmdbuf, 1, '|', sizeof desired_section);
+ safestrncpy(CC->download_desired_section, desired_section, sizeof CC->download_desired_section);
CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, 1);
}
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);
}
}
/* 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
long send_message(struct CtdlMessage *msg) {
long newmsgid;
long retval;
- char msgidbuf[SIZ];
+ char msgidbuf[256];
struct ser_ret smr;
int is_bigmsg = 0;
char *holdM = NULL;
}
/* 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",
* Back end for the ReplicationChecks() function
*/
void check_repl(long msgnum, void *userdata) {
- struct CtdlMessage *msg;
- time_t timestamp = (-1L);
-
- lprintf(CTDL_DEBUG, "check_repl() found message %ld\n", msgnum);
- msg = CtdlFetchMessage(msgnum, 1);
- if (msg == NULL) return;
- if (msg->cm_fields['T'] != NULL) {
- timestamp = atol(msg->cm_fields['T']);
- }
- CtdlFreeMessage(msg);
-
- if (timestamp > msg_repl->highest) {
- msg_repl->highest = timestamp; /* newer! */
- lprintf(CTDL_DEBUG, "newer!\n");
- return;
- }
- lprintf(CTDL_DEBUG, "older!\n");
-
- /* Existing isn't newer? Then delete the old one(s). */
+ lprintf(CTDL_DEBUG, "check_repl() replacing message %ld\n", msgnum);
CtdlDeleteMessages(CC->room.QRname, msgnum, "");
}
/*
- * Check to see if any messages already exist which carry the same Extended ID
- * as this one.
+ * Check to see if any messages already exist which carry the same Exclusive ID
+ * as this one. If any are found, delete them.
*
- * If any are found:
- * -> With older timestamps: delete them and return 0. Message will be saved.
- * -> With newer timestamps: return 1. Message save will be aborted.
*/
int ReplicationChecks(struct CtdlMessage *msg) {
struct CtdlMessage *template;
int abort_this = 0;
- lprintf(CTDL_DEBUG, "ReplicationChecks() started\n");
- /* No extended id? Don't do anything. */
+ /* No exclusive id? Don't do anything. */
if (msg->cm_fields['E'] == NULL) return 0;
if (strlen(msg->cm_fields['E']) == 0) return 0;
- lprintf(CTDL_DEBUG, "Extended ID: <%s>\n", msg->cm_fields['E']);
-
- CtdlAllocUserData(SYM_REPL, sizeof(struct repl));
- strcpy(msg_repl->extended_id, msg->cm_fields['E']);
- msg_repl->highest = atol(msg->cm_fields['T']);
+ lprintf(CTDL_DEBUG, "Exclusive ID: <%s>\n", msg->cm_fields['E']);
template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
memset(template, 0, sizeof(struct CtdlMessage));
CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
- /* If a newer message exists with the same Extended ID, abort
- * this save.
- */
- if (msg_repl->highest > atol(msg->cm_fields['T']) ) {
- abort_this = 1;
- }
-
CtdlFreeMessage(template);
lprintf(CTDL_DEBUG, "ReplicationChecks() returning %d\n", abort_this);
return(abort_this);
struct recptypes *recps, /* recipients (if mail) */
char *force /* force a particular room? */
) {
- char aaa[SIZ];
+ char submit_filename[128];
+ char generated_timestamp[32];
char hold_rm[ROOMNAMELEN];
char actual_rm[ROOMNAMELEN];
char force_room[ROOMNAMELEN];
*/
if (msg->cm_fields['T'] == NULL) {
lprintf(CTDL_DEBUG, "Generating timestamp\n");
- snprintf(aaa, sizeof aaa, "%ld", (long)time(NULL));
- msg->cm_fields['T'] = strdup(aaa);
+ snprintf(generated_timestamp, sizeof generated_timestamp, "%ld", (long)time(NULL));
+ msg->cm_fields['T'] = strdup(generated_timestamp);
}
/* If this message has no path, we generate one.
lprintf(CTDL_DEBUG, "Learning what's inside\n");
if (msg->cm_fields['M'] == NULL) {
lprintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
- return(-1);
+ return(-2);
}
switch (msg->cm_format_type) {
break;
case 4:
strcpy(content_type, "text/plain");
- /* advance past header fields */
- mptr = msg->cm_fields['M'];
- a = strlen(mptr);
- while ((--a) > 0) {
- if (!strncasecmp(mptr, "Content-type: ", 14)) {
- safestrncpy(content_type, mptr,
- sizeof(content_type));
- strcpy(content_type, &content_type[14]);
- for (a = 0; a < strlen(content_type); ++a)
- if ((content_type[a] == ';')
- || (content_type[a] == ' ')
- || (content_type[a] == 13)
- || (content_type[a] == 10))
- content_type[a] = 0;
- break;
+ mptr = bmstrstr(msg->cm_fields['M'],
+ "Content-type: ", strncasecmp);
+ if (mptr != NULL) {
+ safestrncpy(content_type, &mptr[14],
+ sizeof content_type);
+ for (a = 0; a < strlen(content_type); ++a) {
+ if ((content_type[a] == ';')
+ || (content_type[a] == ' ')
+ || (content_type[a] == 13)
+ || (content_type[a] == 10)) {
+ content_type[a] = 0;
+ }
}
- ++mptr;
}
}
/* Goto the correct room */
- lprintf(CTDL_DEBUG, "Selected room %s\n", (recps) ? CC->room.QRname : SENTITEMS);
+ lprintf(CTDL_DEBUG, "Selected room %s\n",
+ (recps) ? CC->room.QRname : SENTITEMS);
strcpy(hold_rm, CC->room.QRname);
strcpy(actual_rm, CC->room.QRname);
if (recps != NULL) {
/* Perform "before save" hooks (aborting if any return nonzero) */
lprintf(CTDL_DEBUG, "Performing before-save hooks\n");
- if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
+ if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
- /* If this message has an Extended ID, perform replication checks */
+ /* If this message has an Exclusive ID, perform replication checks */
lprintf(CTDL_DEBUG, "Performing replication checks\n");
- if (ReplicationChecks(msg) > 0) return(-1);
+ if (ReplicationChecks(msg) > 0) return(-4);
/* Save it to disk */
lprintf(CTDL_DEBUG, "Saving to disk\n");
newmsgid = send_message(msg);
- if (newmsgid <= 0L) return(-1);
+ if (newmsgid <= 0L) return(-5);
/* Write a supplemental message info record. This doesn't have to
* be a critical section because nobody else knows about this message
memset(&smi, 0, sizeof(struct MetaData));
smi.meta_msgnum = newmsgid;
smi.meta_refcount = 0;
- safestrncpy(smi.meta_content_type, content_type, 64);
+ safestrncpy(smi.meta_content_type, content_type, sizeof smi.meta_content_type);
PutMetaData(&smi);
/* Now figure out where to store the pointers */
if (recps != NULL)
if (recps->num_room > 0)
for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
- extract(recipient, recps->recp_room, i);
+ extract_token(recipient, recps->recp_room, i, '|', sizeof recipient);
lprintf(CTDL_DEBUG, "Delivering to local room <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
}
if (recps != NULL)
if (recps->num_local > 0)
for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
- extract(recipient, recps->recp_local, i);
+ extract_token(recipient, recps->recp_local, i, '|', sizeof recipient);
lprintf(CTDL_DEBUG, "Delivering private local mail to <%s>\n",
recipient);
if (getuser(&userbuf, recipient) == 0) {
if (recps != NULL)
if (recps->num_ignet > 0)
for (i=0; i<num_tokens(recps->recp_ignet, '|'); ++i) {
- extract(recipient, recps->recp_ignet, i);
+ extract_token(recipient, recps->recp_ignet, i, '|', sizeof recipient);
hold_R = msg->cm_fields['R'];
hold_D = msg->cm_fields['D'];
msg->cm_fields['R'] = malloc(SIZ);
- msg->cm_fields['D'] = malloc(SIZ);
- extract_token(msg->cm_fields['R'], recipient, 0, '@');
- extract_token(msg->cm_fields['D'], recipient, 1, '@');
+ msg->cm_fields['D'] = malloc(128);
+ extract_token(msg->cm_fields['R'], recipient, 0, '@', SIZ);
+ extract_token(msg->cm_fields['D'], recipient, 1, '@', 128);
serialize_message(&smr, msg);
if (smr.len > 0) {
- snprintf(aaa, sizeof aaa,
+ snprintf(submit_filename, sizeof submit_filename,
"./network/spoolin/netmail.%04lx.%04x.%04x",
(long) getpid(), CC->cs_pid, ++seqnum);
- network_fp = fopen(aaa, "wb+");
+ network_fp = fopen(submit_filename, "wb+");
if (network_fp != NULL) {
fwrite(smr.ser, smr.len, 1, network_fp);
fclose(network_fp);
for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
size_t tmp = strlen(instr);
- extract(recipient, recps->recp_internet, i);
+ extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
snprintf(&instr[tmp], SIZ * 2 - tmp,
"remote|%s|0||\n", recipient);
}
exist is ALWAYS freed */
int crlf /* CRLF newlines instead of LF */
) {
- char buf[SIZ];
+ char buf[1024];
int linelen;
size_t message_len = 0;
size_t buffer_len = 0;
/* read in the lines of message text one by one */
do {
- if (client_gets(buf) < 1) finished = 1;
+ if (client_getln(buf, (sizeof buf - 3)) < 1) finished = 1;
if (!strcmp(buf, terminator)) finished = 1;
if (crlf) {
strcat(buf, "\r\n");
}
if (num_recps > 0) for (i=0; i<num_recps; ++i) {
- extract_token(this_recp, recipients, i, ',');
+ extract_token(this_recp, recipients, i, ',', sizeof this_recp);
striplt(this_recp);
lprintf(CTDL_DEBUG, "Evaluating recipient #%d <%s>\n", i, this_recp);
mailtype = alias(this_recp);
int err = 0;
struct recptypes *valid = NULL;
char subject[SIZ];
+ int do_confirm = 0;
+ long msgnum;
+
+ unbuffer_output();
post = extract_int(entargs, 0);
- extract(recp, entargs, 1);
+ extract_token(recp, entargs, 1, '|', sizeof recp);
anon_flag = extract_int(entargs, 2);
format_type = extract_int(entargs, 3);
- extract(subject, entargs, 4);
+ extract_token(subject, entargs, 4, '|', sizeof subject);
+ do_confirm = extract_int(entargs, 6);
/* first check to make sure the request is valid. */
ERROR + HIGHER_ACCESS_REQUIRED);
return;
}
- extract(newusername, entargs, 5);
+ extract_token(newusername, entargs, 5, '|', sizeof newusername);
memset(CC->fake_postname, 0, sizeof(CC->fake_postname) );
safestrncpy(CC->fake_postname, newusername,
sizeof(CC->fake_postname) );
}
/* Read in the message from the client. */
- cprintf("%d send message\n", SEND_LISTING);
- flush_output();
+ if (do_confirm) {
+ cprintf("%d send message\n", START_CHAT_MODE);
+ } else {
+ cprintf("%d send message\n", SEND_LISTING);
+ }
msg = CtdlMakeMessage(&CC->user, recp,
CC->room.QRname, anonymous, format_type,
masquerade_as, subject, NULL);
if (msg != NULL) {
- CtdlSubmitMsg(msg, valid, "");
+ msgnum = CtdlSubmitMsg(msg, valid, "");
+
+ if (do_confirm) {
+ cprintf("%ld\n", msgnum);
+ if (msgnum >= 0L) {
+ cprintf("Message accepted.\n");
+ }
+ else {
+ cprintf("Internal error.\n");
+ }
+ if (msg->cm_fields['E'] != NULL) {
+ cprintf("%s\n", msg->cm_fields['E']);
+ } else {
+ cprintf("\n");
+ }
+ cprintf("000\n");
+ }
+
CtdlFreeMessage(msg);
}
CC->fake_postname[0] = '\0';
}
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];
}
void cmd_move(char *args)
{
long num;
- char targ[SIZ];
+ char targ[ROOMNAMELEN];
struct ctdlroom qtemp;
int err;
int is_copy = 0;
int permit = 0;
num = extract_long(args, 0);
- extract(targ, args, 1);
+ extract_token(targ, args, 1, '|', sizeof targ);
targ[ROOMNAMELEN - 1] = 0;
is_copy = extract_int(args, 2);
}
getuser(&CC->user, CC->curr_user);
- ra = CtdlRoomAccess(&qtemp, &CC->user);
+ CtdlRoomAccess(&qtemp, &CC->user, &ra, NULL);
/* Check for permission to perform this operation.
* Remember: "CC->room" is source, "qtemp" is target.
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));
}
}
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.
getroom(&CC->room, hold_rm);
if (conf != NULL) do {
- extract_token(buf, conf, 0, '\n');
+ extract_token(buf, conf, 0, '\n', sizeof buf);
strcpy(conf, &conf[strlen(buf)+1]);
} while ( (strlen(conf)>0) && (strlen(buf)>0) );
/*
* Determine whether a given Internet address belongs to the current user
*/
-int CtdlIsMe(char *addr) {
+int CtdlIsMe(char *addr, int addr_buf_len)
+{
struct recptypes *recp;
int i;
}
for (i=0; i<recp->num_local; ++i) {
- extract(addr, recp->recp_local, i);
+ extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
if (!strcasecmp(addr, CC->user.fullname)) {
free(recp);
return(1);
* Citadel protocol command to do the same
*/
void cmd_isme(char *argbuf) {
- char addr[SIZ];
+ char addr[256];
if (CtdlAccessCheck(ac_logged_in)) return;
- extract(addr, argbuf, 0);
+ extract_token(addr, argbuf, 0, '|', sizeof addr);
- if (CtdlIsMe(addr)) {
+ if (CtdlIsMe(addr, sizeof addr)) {
cprintf("%d %s\n", CIT_OK, addr);
}
else {
projects / citadel.git / blobdiff