#include <ctype.h>
#include <string.h>
-#include <syslog.h>
#include <limits.h>
#include <errno.h>
#include <stdarg.h>
#include <sys/stat.h>
#include "citadel.h"
#include "server.h"
-#include "dynloader.h"
+#include "serv_extensions.h"
#include "database.h"
#include "msgbase.h"
#include "support.h"
#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;
+
+/*
+ * This really belongs in serv_network.c, but I don't know how to export
+ * symbols between modules.
+ */
+struct FilterList *filterlist = NULL;
+
+
+/*
+ * These are the four-character field headers we use when outputting
+ * messages in Citadel format (as opposed to RFC822 format).
+ */
char *msgkeys[] = {
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "",
- "",
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL,
"from",
- "", "", "",
+ NULL, NULL, NULL,
"exti",
"rfca",
- "",
+ NULL,
"hnod",
"msgn",
- "", "", "",
+ NULL, NULL, NULL,
"text",
"node",
"room",
"path",
- "",
+ NULL,
"rcpt",
"spec",
"time",
"subj",
- "",
- "",
- "",
- "",
- ""
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL
};
/*
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);
strcpy(name, aaa);
}
- lprintf(7, "Mail is being forwarded to %s\n", name);
+ lprintf(CTDL_INFO, "Mail is being forwarded to %s\n", name);
/* Change "user @ xxx" to "user" if xxx is an alias for this host */
for (a=0; a<strlen(name); ++a) {
if (name[a] == '@') {
if (CtdlHostAlias(&name[a+1]) == hostalias_localhost) {
name[a] = 0;
- lprintf(7, "Changed to <%s>\n", name);
+ lprintf(CTDL_INFO, "Changed to <%s>\n", 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)) {
- phree(ignetcfg);
+ free(ignetcfg);
return(MES_IGNET);
}
}
- phree(ignetcfg);
+ free(ignetcfg);
/*
* Then try nodes that are two or more hops away.
*/
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)) {
- phree(ignetmap);
+ free(ignetmap);
return(MES_IGNET);
}
}
- phree(ignetmap);
+ free(ignetmap);
/* If we get to this point it's an invalid node name */
return (MES_ERROR);
FILE *fp;
fp = fopen("citadel.control", "r");
+ if (fp == NULL) {
+ lprintf(CTDL_CRIT, "Cannot open citadel.control: %s\n",
+ strerror(errno));
+ exit(errno);
+ }
fread((char *) &CitControl, sizeof(struct CitControl), 1, fp);
fclose(fp);
}
}
+
+/*
+ * Retrieve the "seen" message list for the current room.
+ */
+void CtdlGetSeen(char *buf, int which_set) {
+ struct visit vbuf;
+
+ /* Learn about the user and room in question */
+ CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
+
+ if (which_set == ctdlsetseen_seen)
+ safestrncpy(buf, vbuf.v_seen, SIZ);
+ if (which_set == ctdlsetseen_answered)
+ safestrncpy(buf, vbuf.v_answered, SIZ);
+}
+
+
+
/*
- * Manipulate the "seen msgs" string.
+ * Manipulate the "seen msgs" string (or other message set strings)
*/
-void CtdlSetSeen(long target_msgnum, int target_setting) {
+void CtdlSetSeen(long target_msgnum, int target_setting, int which_set) {
char newseen[SIZ];
struct cdbdata *cdbfr;
int i;
struct visit vbuf;
long *msglist;
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 */
- get_mm();
- getuser(&CC->usersupp, CC->curr_user);
- CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
+ CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
/* Load the message list */
- cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long));
+ cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
return; /* No messages at all? No further action. */
}
- lprintf(9, "before optimize: %s\n", vbuf.v_seen);
+ /* Decide which message set we're manipulating */
+ if (which_set == ctdlsetseen_seen) strcpy(vset, vbuf.v_seen);
+ if (which_set == ctdlsetseen_answered) strcpy(vset, vbuf.v_answered);
+
+ lprintf(CTDL_DEBUG, "before optimize: %s\n", vset);
strcpy(newseen, "");
for (i=0; i<num_msgs; ++i) {
is_seen = target_setting;
}
else {
- if (is_msg_in_mset(vbuf.v_seen, msglist[i])) {
+ if (is_msg_in_mset(vset, msglist[i])) {
is_seen = 1;
}
}
}
if ( ((is_seen == 0) && (was_seen == 1))
|| ((is_seen == 1) && (i == num_msgs-1)) ) {
+ size_t tmp;
+
if ( (strlen(newseen) + 20) > SIZ) {
strcpy(newseen, &newseen[20]);
newseen[0] = '*';
}
- if (strlen(newseen) > 0) strcat(newseen, ",");
+ tmp = strlen(newseen);
+ if (tmp > 0) {
+ strcat(newseen, ",");
+ tmp++;
+ }
if (lo == hi) {
- sprintf(&newseen[strlen(newseen)], "%ld", lo);
+ snprintf(&newseen[tmp], sizeof newseen - tmp,
+ "%ld", lo);
}
else {
- sprintf(&newseen[strlen(newseen)], "%ld:%ld",
- lo, hi);
+ snprintf(&newseen[tmp], sizeof newseen - tmp,
+ "%ld:%ld", lo, hi);
}
lo = (-1L);
hi = (-1L);
was_seen = is_seen;
}
- safestrncpy(vbuf.v_seen, newseen, SIZ);
- lprintf(9, " after optimize: %s\n", vbuf.v_seen);
- phree(msglist);
- CtdlSetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
+ /* Decide which message set we're manipulating */
+ if (which_set == ctdlsetseen_seen) strcpy(vbuf.v_seen, newseen);
+ if (which_set == ctdlsetseen_answered) strcpy(vbuf.v_answered, newseen);
+
+ lprintf(CTDL_DEBUG, " after optimize: %s\n", newseen);
+ free(msglist);
+ CtdlSetRelationship(&vbuf, &CC->user, &CC->room);
}
* current room. (Returns the number of messages processed.)
*/
int CtdlForEachMessage(int mode, long ref,
- int moderation_level,
char *content_type,
struct CtdlMessage *compare,
void (*CallBack) (long, void *),
/* Learn about the user and room in question */
get_mm();
- getuser(&CC->usersupp, CC->curr_user);
- CtdlGetRelationship(&vbuf, &CC->usersupp, &CC->quickroom);
+ getuser(&CC->user, CC->curr_user);
+ CtdlGetRelationship(&vbuf, &CC->user, &CC->room);
/* Load the message list */
- cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long));
+ cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
* Now begin the traversal.
*/
if (num_msgs > 0) for (a = 0; a < num_msgs; ++a) {
- GetMetaData(&smi, msglist[a]);
-
- /* Filter out messages that are moderated below the level
- * currently being viewed at.
- */
- if (smi.meta_mod < moderation_level) {
- msglist[a] = 0L;
- }
/* If the caller is looking for a specific MIME type, filter
* out all messages which are not of the type requested.
*/
if (content_type != NULL) if (strlen(content_type) > 0) {
+
+ /* This call to GetMetaData() sits inside this loop
+ * so that we only do the extra database read per msg
+ * if we need to. Doing the extra read all the time
+ * really kills the server. If we ever need to use
+ * metadata for another search criterion, we need to
+ * move the read somewhere else -- but still be smart
+ * enough to only do the read if the caller has
+ * specified something that will need it.
+ */
+ GetMetaData(&smi, msglist[a]);
+
if (strcasecmp(smi.meta_content_type, content_type)) {
msglist[a] = 0L;
}
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;
|| ((mode == MSGS_EQ) && (thismsg == ref))
)
) {
- if ((mode == MSGS_NEW) && (CC->usersupp.flags & US_LASTOLD) && (lastold > 0L) && (printed_lastold == 0) && (!is_seen)) {
+ if ((mode == MSGS_NEW) && (CC->user.flags & US_LASTOLD) && (lastold > 0L) && (printed_lastold == 0) && (!is_seen)) {
if (CallBack)
CallBack(lastold, userdata);
printed_lastold = 1;
++num_processed;
}
}
- phree(msglist); /* Clean up */
+ free(msglist); /* Clean up */
return num_processed;
}
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 *)
- mallok(sizeof(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] =
- strdoop(tvalue);
+ strdup(tvalue);
}
}
}
+ buffer_output();
}
else {
cprintf("%d Message list...\n", LISTING_FOLLOWS);
}
CtdlForEachMessage(mode, cm_ref,
- CC->usersupp.moderation_filter,
NULL, template, simple_listing, NULL);
if (template != NULL) CtdlFreeMessage(template);
cprintf("000\n");
help_subst(buffer, "^nodename", config.c_nodename);
help_subst(buffer, "^humannode", config.c_humannode);
help_subst(buffer, "^fqdn", config.c_fqdn);
- help_subst(buffer, "^username", CC->usersupp.fullname);
- sprintf(buf2, "%ld", CC->usersupp.usernum);
+ help_subst(buffer, "^username", CC->user.fullname);
+ snprintf(buf2, sizeof buf2, "%ld", CC->user.usernum);
help_subst(buffer, "^usernum", buf2);
help_subst(buffer, "^sysadm", config.c_sysadm);
help_subst(buffer, "^variantname", CITADEL);
- sprintf(buf2, "%d", config.c_maxsessions);
+ snprintf(buf2, sizeof buf2, "%d", config.c_maxsessions);
help_subst(buffer, "^maxsessions", buf2);
+ help_subst(buffer, "^bbsdir", CTDLDIR);
}
int a, b, c;
int real = 0;
int old = 0;
- CIT_UBYTE ch;
+ cit_uint8_t ch;
char aaa[140];
char buffer[SIZ];
name, filename, partnum, disp, cbtype, (long)length);
}
+/*
+ * Callback function for multipart prefix
+ */
+void list_this_pref(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, size_t length, char *encoding,
+ void *cbuserdata)
+{
+ cprintf("pref=%s|%s\n", partnum, cbtype);
+}
+
+/*
+ * Callback function for multipart sufffix
+ */
+void list_this_suff(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, size_t length, char *encoding,
+ void *cbuserdata)
+{
+ cprintf("suff=%s|%s\n", partnum, cbtype);
+}
+
/*
* Callback function for mime parser that opens a section for downloading
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();
* 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;
char *mptr;
- CIT_UBYTE ch;
- CIT_UBYTE field_header;
- size_t field_length;
+ char *upper_bound;
+ cit_uint8_t ch;
+ cit_uint8_t field_header;
+
+ 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(5, "Message %ld appears to be corrupted.\n", msgnum);
+ lprintf(CTDL_ERR,
+ "Message %ld appears to be corrupted.\n",
+ msgnum);
cdb_free(dmsgtext);
return NULL;
}
- ret = (struct CtdlMessage *) mallok(sizeof(struct CtdlMessage));
+ ret = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
memset(ret, 0, sizeof(struct CtdlMessage));
ret->cm_magic = CTDLMESSAGE_MAGIC;
* 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] = mallok(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);
- /* Always make sure there's something in the msg text field */
- if (ret->cm_fields['M'] == NULL)
- ret->cm_fields['M'] = strdoop("<no text>\n");
+ /* 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) {
if (msg == NULL)
return 0;
if ((msg->cm_magic) != CTDLMESSAGE_MAGIC) {
- lprintf(3, "is_valid_message() -- self-check failed\n");
+ lprintf(CTDL_WARNING, "is_valid_message() -- self-check failed\n");
return 0;
}
return 1;
for (i = 0; i < 256; ++i)
if (msg->cm_fields[i] != NULL) {
- phree(msg->cm_fields[i]);
+ free(msg->cm_fields[i]);
}
msg->cm_magic = 0; /* just in case */
- phree(msg);
+ free(msg);
}
void *content, char *cbtype, size_t length, char *encoding,
void *cbuserdata)
{
- lprintf(9, "fixed_output_pre() type=<%s>\n", cbtype);
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- ma->is_ma = 1;
- 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(9, "fixed_output_post() type=<%s>\n", cbtype);
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- ma->is_ma = 0;
- 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;
- CIT_UBYTE ch = 0;
+ struct ma_info *ma;
+
+ ma = (struct ma_info *)cbuserdata;
- lprintf(9, "fixed_output() type=<%s>\n", cbtype);
+ lprintf(CTDL_DEBUG, "fixed_output() type=<%s>\n", cbtype);
/*
* If we're in the middle of a multipart/alternative scope and
* we've already printed another section, skip this one.
*/
if ( (ma->is_ma == 1) && (ma->did_print == 1) ) {
- lprintf(9, "Skipping part %s (%s)\n", partnum, cbtype);
+ lprintf(CTDL_DEBUG, "Skipping part %s (%s)\n", partnum, cbtype);
return;
}
ma->did_print = 1;
if ( (!strcasecmp(cbtype, "text/plain"))
|| (strlen(cbtype)==0) ) {
- wlen = length;
wptr = content;
- while (wlen--) {
- ch = *wptr++;
- /**********
- if (ch==10) cprintf("\r\n");
- else cprintf("%c", ch);
- **********/
- cprintf("%c", ch);
+ if (length > 0) {
+ client_write(wptr, length);
+ if (wptr[length-1] != '\n') {
+ cprintf("\n");
+ }
}
- if (ch != '\n') cprintf("\n");
}
else if (!strcasecmp(cbtype, "text/html")) {
ptr = html_to_ascii(content, 80, 0);
wlen = strlen(ptr);
- wptr = ptr;
- while (wlen--) {
- ch = *wptr++;
- if (ch==10) cprintf("\r\n");
- else cprintf("%c", ch);
+ client_write(ptr, wlen);
+ if (ptr[wlen-1] != '\n') {
+ cprintf("\n");
}
- phree(ptr);
+ free(ptr);
}
else if (strncasecmp(cbtype, "multipart/", 10)) {
cprintf("Part %s: %s (%s) (%ld bytes)\r\n",
}
}
+/*
+ * The client is elegant and sophisticated and wants to be choosy about
+ * MIME content types, so figure out which multipart/alternative part
+ * we're going to send.
+ */
+void choose_preferred(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, size_t length, char *encoding,
+ void *cbuserdata)
+{
+ 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_token(buf, CC->preferred_formats, i, '|', sizeof buf);
+ if (!strcasecmp(buf, cbtype)) {
+ strcpy(ma->chosen_part, partnum);
+ }
+ }
+ }
+}
+
+/*
+ * Now that we've chosen our preferred part, output it.
+ */
+void output_preferred(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, size_t length, char *encoding,
+ void *cbuserdata)
+{
+ int i;
+ 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;
+
+ /* If the content-type of this part is in our preferred formats
+ * list, we can simply output it verbatim.
+ */
+ for (i=0; i<num_tokens(CC->preferred_formats, '|'); ++i) {
+ extract_token(buf, CC->preferred_formats, i, '|', sizeof buf);
+ if (!strcasecmp(buf, cbtype)) {
+ /* Yeah! Go! W00t!! */
+
+ text_content = (char *)content;
+ if (text_content[length-1] != '\n') {
+ ++add_newline;
+ }
+
+ cprintf("Content-type: %s\n", cbtype);
+ cprintf("Content-length: %d\n",
+ (int)(length + add_newline) );
+ if (strlen(encoding) > 0) {
+ cprintf("Content-transfer-encoding: %s\n", encoding);
+ }
+ else {
+ cprintf("Content-transfer-encoding: 7bit\n");
+ }
+ cprintf("\n");
+ client_write(content, length);
+ if (add_newline) cprintf("\n");
+ return;
+ }
+ }
+
+ /* No translations required or possible: output as text/plain */
+ cprintf("Content-type: text/plain\n\n");
+ fixed_output(name, filename, partnum, disp, content, cbtype,
+ length, encoding, cbuserdata);
+}
+
/*
* Get a message off disk. (returns om_* values found in msgbase.h)
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(7, "CtdlOutputMsg() msgnum=%ld, mode=%d\n",
+ 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, 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",
- ERROR, msg_num);
+ ERROR + MESSAGE_NOT_FOUND, msg_num);
return(om_no_such_msg);
}
headers_only, do_proto, crlf);
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];
- CIT_UBYTE ch;
- char allkeys[SIZ];
- char display_name[SIZ];
+ char buf[SIZ];
+ cit_uint8_t ch;
+ 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];
- /* */
-
- sprintf(mid, "%ld", msg_num);
+ /* 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(1, "ERROR: invalid preloaded message for output\n");
+ lprintf(CTDL_ERR,
+ "ERROR: invalid preloaded message for output\n");
return(om_no_such_msg);
}
if (TheMessage->cm_format_type != FMT_RFC822) {
if (do_proto)
cprintf("%d This is not a MIME message.\n",
- ERROR);
+ ERROR + ILLEGAL_VALUE);
} else if (CC->download_fp != NULL) {
if (do_proto) cprintf(
"%d You already have a download open.\n",
- ERROR);
+ ERROR + RESOURCE_BUSY);
} 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);
/* now for the user-mode message reading loops */
if (do_proto) cprintf("%d Message %ld:\n", LISTING_FOLLOWS, msg_num);
- /* Tell the client which format type we're using. If this is a
- * MIME message, *lie* about it and tell the user it's fixed-format.
- */
- if (mode == MT_CITADEL) {
- if (TheMessage->cm_format_type == FMT_RFC822) {
- if (do_proto) cprintf("type=1\n");
- }
- else {
- if (do_proto) cprintf("type=%d\n",
- TheMessage->cm_format_type);
- }
+ /* Does the caller want to skip the headers? */
+ if (headers_only == HEADERS_NONE) goto START_TEXT;
+
+ /* Tell the client which format type we're using. */
+ if ( (mode == MT_CITADEL) && (do_proto) ) {
+ cprintf("type=%d\n", TheMessage->cm_format_type);
}
/* nhdr=yes means that we're only displaying headers, no body */
- if ((TheMessage->cm_anon_type == MES_ANONONLY) && (mode == MT_CITADEL)) {
- if (do_proto) cprintf("nhdr=yes\n");
+ if ( (TheMessage->cm_anon_type == MES_ANONONLY)
+ && (mode == MT_CITADEL)
+ && (do_proto)
+ ) {
+ cprintf("nhdr=yes\n");
}
/* begin header processing loop for Citadel message format */
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']);
- PerformUserHooks(buf, (-1L), EVT_OUTPUTMSG);
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)
|| (TheMessage->cm_anon_type == MES_ANONOPT))) {
- sprintf(&display_name[strlen(display_name)],
- " [%s]", buf);
+ size_t tmp = strlen(display_name);
+ snprintf(&display_name[tmp],
+ sizeof display_name - tmp,
+ " [%s]", buf);
}
}
- strcpy(allkeys, FORDER);
+ /* Don't show Internet address for users on the
+ * local Citadel network.
+ */
+ suppress_f = 0;
+ if (TheMessage->cm_fields['N'] != NULL)
+ if (strlen(TheMessage->cm_fields['N']) > 0)
+ if (haschar(TheMessage->cm_fields['N'], '.') == 0) {
+ suppress_f = 1;
+ }
+
+ /* Now spew the header fields in the order we like them. */
+ safestrncpy(allkeys, FORDER, sizeof allkeys);
for (i=0; i<strlen(allkeys); ++i) {
k = (int) allkeys[i];
if (k != 'M') {
- if (TheMessage->cm_fields[k] != NULL) {
+ if ( (TheMessage->cm_fields[k] != NULL)
+ && (msgkeys[k] != NULL) ) {
if (k == 'A') {
if (do_proto) cprintf("%s=%s\n",
msgkeys[k],
display_name);
}
+ else if ((k == 'F') && (suppress_f)) {
+ /* do nothing */
+ }
+ /* Masquerade display name if needed */
else {
if (do_proto) cprintf("%s=%s\n",
msgkeys[k],
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')
+ else if (i == 'U') {
cprintf("Subject: %s%s", mptr, nl);
+ subject_found = 1;
+ }
else if (i == 'I')
- strcpy(mid, mptr);
+ safestrncpy(mid, mptr, sizeof mid);
else if (i == 'H')
- strcpy(lnode, mptr);
+ safestrncpy(lnode, mptr, sizeof lnode);
+ else if (i == 'F')
+ safestrncpy(fuser, mptr, sizeof fuser);
else if (i == 'O')
cprintf("X-Citadel-Room: %s%s",
mptr, nl);
else if (i == 'N')
- strcpy(snode, mptr);
+ safestrncpy(snode, mptr, sizeof snode);
else if (i == 'R')
cprintf("To: %s%s", mptr, nl);
else if (i == 'T') {
- datestring(datestamp, atol(mptr),
- DATESTRING_RFC822 );
+ datestring(datestamp, sizeof datestamp,
+ atol(mptr), DATESTRING_RFC822);
cprintf("Date: %s%s", datestamp, nl);
}
}
}
+ if (subject_found == 0) {
+ cprintf("Subject: (no subject)%s", nl);
+ }
}
for (i=0; i<strlen(suser); ++i) {
if (mode == MT_RFC822) {
if (!strcasecmp(snode, NODENAME)) {
- strcpy(snode, FQDN);
+ safestrncpy(snode, FQDN, sizeof snode);
}
/* Construct a fun message id */
}
cprintf(">%s", nl);
- PerformUserHooks(luser, (-1L), EVT_OUTPUTMSG);
-
- if (strlen(fuser) > 0) {
+ if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONONLY)) {
+ cprintf("From: x@x.org (----)%s", nl);
+ }
+ else if (!is_room_aide() && (TheMessage->cm_anon_type == MES_ANONOPT)) {
+ cprintf("From: x@x.org (anonymous)%s", nl);
+ }
+ else if (strlen(fuser) > 0) {
cprintf("From: %s (%s)%s", fuser, luser, nl);
}
else {
}
cprintf("Organization: %s%s", lnode, nl);
+
+ /* Blank line signifying RFC822 end-of-headers */
+ if (TheMessage->cm_format_type != FMT_RFC822) {
+ cprintf("%s", nl);
+ }
}
/* end header processing loop ... at this point, we're in the text */
-
+START_TEXT:
+ if (headers_only == HEADERS_FAST) goto DONE;
mptr = TheMessage->cm_fields['M'];
/* Tell the client about the MIME parts in this message */
if (TheMessage->cm_format_type == FMT_RFC822) {
- if (mode == MT_CITADEL) {
+ if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
mime_parser(mptr, NULL,
- *list_this_part, NULL, NULL,
+ *list_this_part,
+ *list_this_pref,
+ *list_this_suff,
NULL, 0);
}
- else if (mode == MT_MIME) { /* list parts only */
- mime_parser(mptr, NULL,
- *list_this_part, NULL, NULL,
- NULL, 0);
- if (do_proto) cprintf("000\n");
- return(om_ok);
- }
else if (mode == MT_RFC822) { /* unparsed RFC822 dump */
/* FIXME ... we have to put some code in here to avoid
* printing duplicate header information when both
* Citadel and RFC822 headers exist. Preference should
* probably be given to the RFC822 headers.
*/
+ int done_rfc822_hdrs = 0;
while (ch=*(mptr++), ch!=0) {
- if (ch==13) ;
- else if (ch==10) cprintf("%s", nl);
- else cprintf("%c", ch);
+ if (ch==13) {
+ /* do nothing */
+ }
+ else if (ch==10) {
+ if (!done_rfc822_hdrs) {
+ if (headers_only != HEADERS_NONE) {
+ cprintf("%s", nl);
+ }
+ }
+ else {
+ if (headers_only != HEADERS_ONLY) {
+ cprintf("%s", nl);
+ }
+ }
+ if ((*(mptr) == 13) || (*(mptr) == 10)) {
+ done_rfc822_hdrs = 1;
+ }
+ }
+ else {
+ if (done_rfc822_hdrs) {
+ if (headers_only != HEADERS_NONE) {
+ cprintf("%c", ch);
+ }
+ }
+ else {
+ if (headers_only != HEADERS_ONLY) {
+ cprintf("%c", ch);
+ }
+ }
+ if ((*mptr == 13) || (*mptr == 10)) {
+ done_rfc822_hdrs = 1;
+ }
+ }
}
- if (do_proto) cprintf("000\n");
- return(om_ok);
+ goto DONE;
}
}
- if (headers_only) {
- if (do_proto) cprintf("000\n");
- return(om_ok);
+ if (headers_only == HEADERS_ONLY) {
+ goto DONE;
}
/* signify start of msg text */
- if (mode == MT_CITADEL)
+ if ( (mode == MT_CITADEL) || (mode == MT_MIME) ) {
if (do_proto) cprintf("text\n");
- if (mode == MT_RFC822) {
- if (TheMessage->cm_fields['U'] == NULL) {
- cprintf("Subject: (no subject)%s", nl);
- }
- cprintf("%s", nl);
}
/* If the format type on disk is 1 (fixed-format), then we want
* what message transfer format is in use.
*/
if (TheMessage->cm_format_type == FMT_FIXED) {
+ if (mode == MT_MIME) {
+ cprintf("Content-type: text/plain\n\n");
+ }
strcpy(buf, "");
while (ch = *mptr++, ch > 0) {
if (ch == 13)
* message to the reader's screen width.
*/
if (TheMessage->cm_format_type == FMT_CITADEL) {
+ if (mode == MT_MIME) {
+ cprintf("Content-type: text/x-citadel-variformat\n\n");
+ }
memfmout(80, mptr, 0, nl);
}
* 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));
- mime_parser(mptr, NULL,
- *fixed_output, *fixed_output_pre, *fixed_output_post,
- NULL, 0);
+
+ if (mode == MT_MIME) {
+ strcpy(ma->chosen_part, "1");
+ mime_parser(mptr, NULL,
+ *choose_preferred, *fixed_output_pre,
+ *fixed_output_post, (void *)ma, 0);
+ mime_parser(mptr, NULL,
+ *output_preferred, NULL, NULL, (void *)ma, 0);
+ }
+ else {
+ mime_parser(mptr, NULL,
+ *fixed_output, *fixed_output_pre,
+ *fixed_output_post, (void *)ma, 0);
+ }
+
+ free(ma);
}
- /* now we're done */
+DONE: /* now we're done */
if (do_proto) cprintf("000\n");
return(om_ok);
}
void cmd_msg0(char *cmdbuf)
{
long msgid;
- int headers_only = 0;
+ int headers_only = HEADERS_ALL;
msgid = extract_long(cmdbuf, 0);
headers_only = extract_int(cmdbuf, 1);
void cmd_msg2(char *cmdbuf)
{
long msgid;
- int headers_only = 0;
+ int headers_only = HEADERS_ALL;
msgid = extract_long(cmdbuf, 0);
headers_only = extract_int(cmdbuf, 1);
if (CC->internal_pgm == 0) {
cprintf("%d This command is for internal programs only.\n",
- ERROR);
+ ERROR + HIGHER_ACCESS_REQUIRED);
return;
}
msgnum = extract_long(cmdbuf, 0);
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg == NULL) {
cprintf("%d Message %ld not found.\n",
- ERROR, msgnum);
+ ERROR + MESSAGE_NOT_FOUND, msgnum);
return;
}
if (smr.len == 0) {
cprintf("%d Unable to serialize message\n",
- ERROR+INTERNAL_ERROR);
+ ERROR + INTERNAL_ERROR);
return;
}
cprintf("%d %ld\n", BINARY_FOLLOWS, (long)smr.len);
- client_write(smr.ser, smr.len);
- phree(smr.ser);
+ client_write((char *)smr.ser, (int)smr.len);
+ free(smr.ser);
}
/*
- * display a message (mode 4 - MIME) (FIXME ... still evolving, not complete)
+ * Display a message using MIME content types
*/
void cmd_msg4(char *cmdbuf)
{
CtdlOutputMsg(msgid, MT_MIME, 0, 1, 0);
}
+
+
+/*
+ * Client tells us its preferred message format(s)
+ */
+void cmd_msgp(char *cmdbuf)
+{
+ safestrncpy(CC->preferred_formats, cmdbuf,
+ sizeof(CC->preferred_formats));
+ cprintf("%d ok\n", CIT_OK);
+}
+
+
/*
* Open a component of a MIME message as a download file
*/
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);
}
long highest_msg = 0L;
struct CtdlMessage *msg = NULL;
- lprintf(9, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
+ lprintf(CTDL_DEBUG, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
roomname, msgid, flags);
- strcpy(hold_rm, CC->quickroom.QRname);
+ strcpy(hold_rm, CC->room.QRname);
/* We may need to check to see if this message is real */
if ( (flags & SM_VERIFY_GOODNESS)
|| (flags & SM_DO_REPL_CHECK)
) {
- msg = CtdlFetchMessage(msgid);
+ msg = CtdlFetchMessage(msgid, 1);
if (msg == NULL) return(ERROR + ILLEGAL_VALUE);
}
/* Perform replication checks if necessary */
if ( (flags & SM_DO_REPL_CHECK) && (msg != NULL) ) {
- if (getroom(&CC->quickroom,
- ((roomname != NULL) ? roomname : CC->quickroom.QRname) )
+ if (getroom(&CC->room,
+ ((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
- lprintf(9, "No such room <%s>\n", roomname);
+ lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
if (msg != NULL) CtdlFreeMessage(msg);
return(ERROR + ROOM_NOT_FOUND);
}
if (ReplicationChecks(msg) != 0) {
- getroom(&CC->quickroom, hold_rm);
+ getroom(&CC->room, hold_rm);
if (msg != NULL) CtdlFreeMessage(msg);
- lprintf(9, "Did replication, and newer exists\n");
+ lprintf(CTDL_DEBUG,
+ "Did replication, and newer exists\n");
return(0);
}
}
/* Now the regular stuff */
- if (lgetroom(&CC->quickroom,
- ((roomname != NULL) ? roomname : CC->quickroom.QRname) )
+ if (lgetroom(&CC->room,
+ ((roomname != NULL) ? roomname : CC->room.QRname) )
!= 0) {
- lprintf(9, "No such room <%s>\n", roomname);
+ lprintf(CTDL_ERR, "No such room <%s>\n", roomname);
if (msg != NULL) CtdlFreeMessage(msg);
return(ERROR + ROOM_NOT_FOUND);
}
- cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->quickroom.QRnumber, sizeof(long));
+ cdbfr = cdb_fetch(CDB_MSGLISTS, &CC->room.QRnumber, sizeof(long));
if (cdbfr == NULL) {
msglist = NULL;
num_msgs = 0;
} else {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
if (msglist == NULL)
- lprintf(3, "ERROR malloc msglist!\n");
+ lprintf(CTDL_ALERT, "ERROR malloc msglist!\n");
num_msgs = cdbfr->len / sizeof(long);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
cdb_free(cdbfr);
*/
if (num_msgs > 0) for (i=0; i<num_msgs; ++i) {
if (msglist[i] == msgid) {
- lputroom(&CC->quickroom); /* unlock the room */
- getroom(&CC->quickroom, hold_rm);
+ 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 = reallok(msglist,
- (num_msgs * sizeof(long)));
+ msglist = realloc(msglist, (num_msgs * sizeof(long)));
if (msglist == NULL) {
- lprintf(3, "ERROR: can't realloc message list!\n");
+ lprintf(CTDL_ALERT, "ERROR: can't realloc message list!\n");
}
msglist[num_msgs - 1] = msgid;
highest_msg = msglist[num_msgs - 1];
/* Write it back to disk. */
- cdb_store(CDB_MSGLISTS, &CC->quickroom.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. */
- phree(msglist);
+ free(msglist);
/* Update the highest-message pointer and unlock the room. */
- CC->quickroom.QRhighest = highest_msg;
- lputroom(&CC->quickroom);
- getroom(&CC->quickroom, hold_rm);
+ CC->room.QRhighest = highest_msg;
+ lputroom(&CC->room);
+ getroom(&CC->room, hold_rm);
/* Bump the reference count for this message. */
if ((flags & SM_DONT_BUMP_REF)==0) {
/*
- * 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];
+ char msgidbuf[256];
struct ser_ret smr;
+ int is_bigmsg = 0;
+ char *holdM = NULL;
/* Get a new message number */
newmsgid = get_new_message_number();
- sprintf(msgidbuf, "%ld@%s", newmsgid, config.c_fqdn);
+ snprintf(msgidbuf, sizeof msgidbuf, "%ld@%s", newmsgid, config.c_fqdn);
/* Generate an ID if we don't have one already */
if (msg->cm_fields['I']==NULL) {
- msg->cm_fields['I'] = strdoop(msgidbuf);
+ 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);
+ ERROR + INTERNAL_ERROR);
return (-1L);
}
/* 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(2, "Can't store message\n");
+ 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 */
- phree(smr.ser);
+ free(smr.ser);
/* Return the *local* message ID to the caller
* (even if we're storing an incoming network message)
ret->len = ret->len +
strlen(msg->cm_fields[(int)forder[i]]) + 2;
- lprintf(9, "serialize_message() calling malloc(%ld)\n", (long)ret->len);
- ret->ser = mallok(ret->len);
+ lprintf(CTDL_DEBUG, "serialize_message() calling malloc(%ld)\n", (long)ret->len);
+ ret->ser = malloc(ret->len);
if (ret->ser == NULL) {
ret->len = 0;
return;
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(3, "ERROR: len=%ld wlen=%ld\n",
+ if (ret->len != wlen) lprintf(CTDL_ERR, "ERROR: len=%ld wlen=%ld\n",
(long)ret->len, (long)wlen);
return;
* Back end for the ReplicationChecks() function
*/
void check_repl(long msgnum, void *userdata) {
- struct CtdlMessage *msg;
- time_t timestamp = (-1L);
-
- lprintf(9, "check_repl() found message %ld\n", msgnum);
- msg = CtdlFetchMessage(msgnum);
- 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(9, "newer!\n");
- return;
- }
- lprintf(9, "older!\n");
-
- /* Existing isn't newer? Then delete the old one(s). */
- CtdlDeleteMessages(CC->quickroom.QRname, msgnum, "");
+ 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(9, "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(9, "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));
- template->cm_fields['E'] = strdoop(msg->cm_fields['E']);
+ template->cm_fields['E'] = strdup(msg->cm_fields['E']);
- CtdlForEachMessage(MSGS_ALL, 0L, (-127), 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;
- }
+ CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl, NULL);
CtdlFreeMessage(template);
- lprintf(9, "ReplicationChecks() returning %d\n", abort_this);
+ 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];
char recipient[SIZ];
long newmsgid;
char *mptr = NULL;
- struct usersupp userbuf;
+ struct ctdluser userbuf;
int a, i;
struct MetaData smi;
FILE *network_fp = NULL;
struct ser_ret smr;
char *hold_R, *hold_D;
- lprintf(9, "CtdlSubmitMsg() called\n");
+ lprintf(CTDL_DEBUG, "CtdlSubmitMsg() called\n");
if (is_valid_message(msg) == 0) return(-1); /* self check */
/* If this message has no timestamp, we take the liberty of
* giving it one, right now.
*/
if (msg->cm_fields['T'] == NULL) {
- lprintf(9, "Generating timestamp\n");
- sprintf(aaa, "%ld", (long)time(NULL));
- msg->cm_fields['T'] = strdoop(aaa);
+ lprintf(CTDL_DEBUG, "Generating timestamp\n");
+ 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.
*/
if (msg->cm_fields['P'] == NULL) {
- lprintf(9, "Generating path\n");
+ lprintf(CTDL_DEBUG, "Generating path\n");
if (msg->cm_fields['A'] != NULL) {
- msg->cm_fields['P'] = strdoop(msg->cm_fields['A']);
+ msg->cm_fields['P'] = strdup(msg->cm_fields['A']);
for (a=0; a<strlen(msg->cm_fields['P']); ++a) {
if (isspace(msg->cm_fields['P'][a])) {
msg->cm_fields['P'][a] = ' ';
}
}
else {
- msg->cm_fields['P'] = strdoop("unknown");
+ msg->cm_fields['P'] = strdup("unknown");
}
}
- strcpy(force_room, force);
+ if (force == NULL) {
+ strcpy(force_room, "");
+ }
+ else {
+ strcpy(force_room, force);
+ }
/* Learn about what's inside, because it's what's inside that counts */
- lprintf(9, "Learning what's inside\n");
+ lprintf(CTDL_DEBUG, "Learning what's inside\n");
if (msg->cm_fields['M'] == NULL) {
- lprintf(1, "ERROR: attempt to save message with NULL body\n");
+ lprintf(CTDL_ERR, "ERROR: attempt to save message with NULL body\n");
+ 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(9, "Switching rooms\n");
- strcpy(hold_rm, CC->quickroom.QRname);
- strcpy(actual_rm, CC->quickroom.QRname);
+ 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) {
strcpy(actual_rm, SENTITEMS);
}
/* If the user is a twit, move to the twit room for posting */
- lprintf(9, "Handling twit stuff\n");
+ lprintf(CTDL_DEBUG, "Handling twit stuff: %s\n",
+ (CC->user.axlevel == 2) ? config.c_twitroom : "OK");
if (TWITDETECT) {
- if (CC->usersupp.axlevel == 2) {
+ if (CC->user.axlevel == 2) {
strcpy(hold_rm, actual_rm);
strcpy(actual_rm, config.c_twitroom);
}
strcpy(actual_rm, force_room);
}
- lprintf(9, "Possibly relocating\n");
- if (strcasecmp(actual_rm, CC->quickroom.QRname)) {
- getroom(&CC->quickroom, actual_rm);
+ lprintf(CTDL_DEBUG, "Final selection: %s\n", actual_rm);
+ if (strcasecmp(actual_rm, CC->room.QRname)) {
+ getroom(&CC->room, actual_rm);
}
/*
* If this message has no O (room) field, generate one.
*/
if (msg->cm_fields['O'] == NULL) {
- msg->cm_fields['O'] = strdoop(CC->quickroom.QRname);
+ msg->cm_fields['O'] = strdup(CC->room.QRname);
}
/* Perform "before save" hooks (aborting if any return nonzero) */
- lprintf(9, "Performing before-save hooks\n");
- if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
+ lprintf(CTDL_DEBUG, "Performing before-save hooks\n");
+ if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-3);
- /* If this message has an Extended ID, perform replication checks */
- lprintf(9, "Performing replication checks\n");
- if (ReplicationChecks(msg) > 0) return(-1);
+ /* If this message has an Exclusive ID, perform replication checks */
+ lprintf(CTDL_DEBUG, "Performing replication checks\n");
+ if (ReplicationChecks(msg) > 0) return(-4);
/* Save it to disk */
- lprintf(9, "Saving to disk\n");
- newmsgid = send_message(msg, NULL);
- if (newmsgid <= 0L) return(-1);
+ lprintf(CTDL_DEBUG, "Saving to disk\n");
+ newmsgid = send_message(msg);
+ 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
* yet.
*/
- lprintf(9, "Creating MetaData record\n");
+ lprintf(CTDL_DEBUG, "Creating MetaData record\n");
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 */
- lprintf(9, "Storing pointers\n");
+ lprintf(CTDL_DEBUG, "Storing pointers\n");
/* If this is being done by the networker delivering a private
* message, we want to BYPASS saving the sender's copy (because there
*/
if ((!CC->internal_pgm) || (recps == NULL)) {
if (CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0) != 0) {
- lprintf(3, "ERROR saving message pointer!\n");
- CtdlSaveMsgPointerInRoom(AIDEROOM, newmsgid, 0);
+ lprintf(CTDL_ERR, "ERROR saving message pointer!\n");
+ CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
}
}
if (recps != NULL)
if (recps->num_room > 0)
for (i=0; i<num_tokens(recps->recp_room, '|'); ++i) {
- extract(recipient, recps->recp_room, i);
- lprintf(9, "Delivering to local room <%s>\n", recipient);
+ extract_token(recipient, recps->recp_room, i, '|', sizeof recipient);
+ lprintf(CTDL_DEBUG, "Delivering to local room <%s>\n", recipient);
CtdlSaveMsgPointerInRoom(recipient, newmsgid, 0);
}
/* Bump this user's messages posted counter. */
- lprintf(9, "Updating user\n");
- lgetuser(&CC->usersupp, CC->curr_user);
- CC->usersupp.posted = CC->usersupp.posted + 1;
- lputuser(&CC->usersupp);
+ lprintf(CTDL_DEBUG, "Updating user\n");
+ lgetuser(&CC->user, CC->curr_user);
+ CC->user.posted = CC->user.posted + 1;
+ lputuser(&CC->user);
/* If this is private, local mail, make a copy in the
* recipient's mailbox and bump the reference count.
if (recps != NULL)
if (recps->num_local > 0)
for (i=0; i<num_tokens(recps->recp_local, '|'); ++i) {
- extract(recipient, recps->recp_local, i);
- lprintf(9, "Delivering private local mail to <%s>\n",
+ 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) {
- MailboxName(actual_rm, &userbuf, MAILROOM);
+ MailboxName(actual_rm, sizeof actual_rm, &userbuf, MAILROOM);
CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
+ BumpNewMailCounter(userbuf.usernum);
}
else {
- lprintf(9, "No user <%s>\n", recipient);
- CtdlSaveMsgPointerInRoom(AIDEROOM, newmsgid, 0);
+ lprintf(CTDL_DEBUG, "No user <%s>\n", recipient);
+ CtdlSaveMsgPointerInRoom(config.c_aideroom, newmsgid, 0);
}
}
/* Perform "after save" hooks */
- lprintf(9, "Performing after-save hooks\n");
+ lprintf(CTDL_DEBUG, "Performing after-save hooks\n");
PerformMessageHooks(msg, EVT_AFTERSAVE);
/* For IGnet mail, we have to save a new copy into the spooler for
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'] = mallok(SIZ);
- msg->cm_fields['D'] = mallok(SIZ);
- extract_token(msg->cm_fields['R'], recipient, 0, '@');
- extract_token(msg->cm_fields['D'], recipient, 1, '@');
+ msg->cm_fields['R'] = malloc(SIZ);
+ 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) {
- sprintf(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);
}
- phree(smr.ser);
+ free(smr.ser);
}
- phree(msg->cm_fields['R']);
- phree(msg->cm_fields['D']);
+ free(msg->cm_fields['R']);
+ free(msg->cm_fields['D']);
msg->cm_fields['R'] = hold_R;
msg->cm_fields['D'] = hold_D;
}
/* Go back to the room we started from */
- lprintf(9, "Returning to original room\n");
- if (strcasecmp(hold_rm, CC->quickroom.QRname))
- getroom(&CC->quickroom, hold_rm);
+ lprintf(CTDL_DEBUG, "Returning to original room %s\n", hold_rm);
+ if (strcasecmp(hold_rm, CC->room.QRname))
+ getroom(&CC->room, hold_rm);
/* For internet mail, generate delivery instructions.
* Yes, this is recursive. Deal with it. Infinite recursion does
*/
if (recps != NULL)
if (recps->num_internet > 0) {
- lprintf(9, "Generating delivery instructions\n");
- instr = mallok(SIZ * 2);
- sprintf(instr,
+ lprintf(CTDL_DEBUG, "Generating delivery instructions\n");
+ instr = malloc(SIZ * 2);
+ snprintf(instr, SIZ * 2,
"Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
"bounceto|%s@%s\n",
SPOOLMIME, newmsgid, (long)time(NULL),
);
for (i=0; i<num_tokens(recps->recp_internet, '|'); ++i) {
- extract(recipient, recps->recp_internet, i);
- sprintf(&instr[strlen(instr)],
- "remote|%s|0||\n", recipient);
+ size_t tmp = strlen(instr);
+ extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
+ snprintf(&instr[tmp], SIZ * 2 - tmp,
+ "remote|%s|0||\n", recipient);
}
- imsg = mallok(sizeof(struct CtdlMessage));
+ imsg = malloc(sizeof(struct CtdlMessage));
memset(imsg, 0, sizeof(struct CtdlMessage));
imsg->cm_magic = CTDLMESSAGE_MAGIC;
imsg->cm_anon_type = MES_NORMAL;
imsg->cm_format_type = FMT_RFC822;
- imsg->cm_fields['A'] = strdoop("Citadel");
+ imsg->cm_fields['A'] = strdup("Citadel");
imsg->cm_fields['M'] = instr;
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM);
CtdlFreeMessage(imsg);
/*
* Convenience function for generating small administrative messages.
*/
-void quickie_message(char *from, char *to, char *room, char *text)
+void quickie_message(char *from, char *to, char *room, char *text,
+ int format_type, char *subject)
{
struct CtdlMessage *msg;
+ struct recptypes *recp = NULL;
- msg = mallok(sizeof(struct CtdlMessage));
+ msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = MES_NORMAL;
- msg->cm_format_type = 0;
- msg->cm_fields['A'] = strdoop(from);
- msg->cm_fields['O'] = strdoop(room);
- msg->cm_fields['N'] = strdoop(NODENAME);
- if (to != NULL)
- msg->cm_fields['R'] = strdoop(to);
- msg->cm_fields['M'] = strdoop(text);
-
- CtdlSubmitMsg(msg, NULL, room);
+ msg->cm_format_type = format_type;
+ msg->cm_fields['A'] = strdup(from);
+ if (room != NULL) msg->cm_fields['O'] = strdup(room);
+ msg->cm_fields['N'] = strdup(NODENAME);
+ if (to != NULL) {
+ msg->cm_fields['R'] = strdup(to);
+ recp = validate_recipients(to);
+ }
+ if (subject != NULL) {
+ msg->cm_fields['U'] = strdup(subject);
+ }
+ msg->cm_fields['M'] = strdup(text);
+
+ CtdlSubmitMsg(msg, recp, room);
CtdlFreeMessage(msg);
- syslog(LOG_NOTICE, text);
+ if (recp != NULL) free(recp);
}
/*
- * Back end function used by make_message() and similar functions
+ * Back end function used by CtdlMakeMessage() and similar functions
*/
char *CtdlReadMessageBody(char *terminator, /* token signalling EOT */
size_t maxlen, /* maximum message length */
- char *exist /* if non-null, append to it;
+ char *exist, /* if non-null, append to it;
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;
char *ptr;
char *m;
+ int flushing = 0;
+ int finished = 0;
if (exist == NULL) {
- m = mallok(4096);
+ m = malloc(4096);
+ m[0] = 0;
+ buffer_len = 4096;
+ message_len = 0;
}
else {
- m = reallok(exist, strlen(exist) + 4096);
- if (m == NULL) phree(exist);
+ message_len = strlen(exist);
+ buffer_len = message_len + 4096;
+ m = realloc(exist, buffer_len);
+ if (m == NULL) {
+ free(exist);
+ return m;
+ }
}
/* flush the input if we have nowhere to store it */
if (m == NULL) {
- while ( (client_gets(buf)>0) && strcmp(buf, terminator) ) ;;
- return(NULL);
+ flushing = 1;
}
- /* otherwise read it into memory */
- else {
- buffer_len = 4096;
- m[0] = 0;
- message_len = 0;
- }
/* read in the lines of message text one by one */
- while ( (client_gets(buf)>0) && strcmp(buf, terminator) ) {
-
- /* strip trailing newline type stuff */
- if (buf[strlen(buf)-1]==10) buf[strlen(buf)-1]=0;
- if (buf[strlen(buf)-1]==13) buf[strlen(buf)-1]=0;
-
- linelen = strlen(buf);
-
- /* augment the buffer if we have to */
- if ((message_len + linelen + 2) > buffer_len) {
- lprintf(9, "realloking\n");
- ptr = reallok(m, (buffer_len * 2) );
- if (ptr == NULL) { /* flush if can't allocate */
- while ( (client_gets(buf)>0) &&
- strcmp(buf, terminator)) ;;
- return(m);
- } else {
- buffer_len = (buffer_len * 2);
- m = ptr;
- lprintf(9, "buffer_len is %ld\n", (long)buffer_len);
- }
+ do {
+ if (client_getln(buf, (sizeof buf - 3)) < 1) finished = 1;
+ if (!strcmp(buf, terminator)) finished = 1;
+ if (crlf) {
+ strcat(buf, "\r\n");
+ }
+ else {
+ strcat(buf, "\n");
}
- /* Add the new line to the buffer. NOTE: this loop must avoid
- * using functions like strcat() and strlen() because they
- * traverse the entire buffer upon every call, and doing that
- * for a multi-megabyte message slows it down beyond usability.
- */
- strcpy(&m[message_len], buf);
- m[message_len + linelen] = '\n';
- m[message_len + linelen + 1] = 0;
- message_len = message_len + linelen + 1;
+ if ( (!flushing) && (!finished) ) {
+ /* Measure the line */
+ linelen = strlen(buf);
+
+ /* augment the buffer if we have to */
+ if ((message_len + linelen) >= buffer_len) {
+ ptr = realloc(m, (buffer_len * 2) );
+ if (ptr == NULL) { /* flush if can't allocate */
+ flushing = 1;
+ } else {
+ buffer_len = (buffer_len * 2);
+ m = ptr;
+ lprintf(CTDL_DEBUG, "buffer_len is now %ld\n", (long)buffer_len);
+ }
+ }
+
+ /* Add the new line to the buffer. NOTE: this loop must avoid
+ * using functions like strcat() and strlen() because they
+ * traverse the entire buffer upon every call, and doing that
+ * for a multi-megabyte message slows it down beyond usability.
+ */
+ strcpy(&m[message_len], buf);
+ message_len += linelen;
+ }
/* if we've hit the max msg length, flush the rest */
- if (message_len >= maxlen) {
- while ( (client_gets(buf)>0)
- && strcmp(buf, terminator)) ;;
- return(m);
- }
- }
+ if (message_len >= maxlen) flushing = 1;
+
+ } while (!finished);
return(m);
}
/*
* Build a binary message to be saved on disk.
+ * (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.)
*/
-static struct CtdlMessage *make_message(
- struct usersupp *author, /* author's usersupp structure */
+struct CtdlMessage *CtdlMakeMessage(
+ struct ctdluser *author, /* author's user structure */
char *recipient, /* NULL if it's not mail */
char *room, /* room where it's going */
int type, /* see MES_ types in header file */
int format_type, /* variformat, plain text, MIME... */
- char *fake_name /* who we're masquerading as */
+ char *fake_name, /* who we're masquerading as */
+ char *subject, /* Subject (optional) */
+ char *preformatted_text /* ...or NULL to read text from client */
) {
char dest_node[SIZ];
char buf[SIZ];
struct CtdlMessage *msg;
- msg = mallok(sizeof(struct CtdlMessage));
+ msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = type;
striplt(recipient);
- sprintf(buf, "cit%ld", author->usernum); /* Path */
- msg->cm_fields['P'] = strdoop(buf);
+ snprintf(buf, sizeof buf, "cit%ld", author->usernum); /* Path */
+ msg->cm_fields['P'] = strdup(buf);
- sprintf(buf, "%ld", (long)time(NULL)); /* timestamp */
- msg->cm_fields['T'] = strdoop(buf);
+ snprintf(buf, sizeof buf, "%ld", (long)time(NULL)); /* timestamp */
+ msg->cm_fields['T'] = strdup(buf);
if (fake_name[0]) /* author */
- msg->cm_fields['A'] = strdoop(fake_name);
+ msg->cm_fields['A'] = strdup(fake_name);
else
- msg->cm_fields['A'] = strdoop(author->fullname);
+ msg->cm_fields['A'] = strdup(author->fullname);
- if (CC->quickroom.QRflags & QR_MAILBOX) { /* room */
- msg->cm_fields['O'] = strdoop(&CC->quickroom.QRname[11]);
+ if (CC->room.QRflags & QR_MAILBOX) { /* room */
+ msg->cm_fields['O'] = strdup(&CC->room.QRname[11]);
}
else {
- msg->cm_fields['O'] = strdoop(CC->quickroom.QRname);
+ msg->cm_fields['O'] = strdup(CC->room.QRname);
}
- msg->cm_fields['N'] = strdoop(NODENAME); /* nodename */
- msg->cm_fields['H'] = strdoop(HUMANNODE); /* hnodename */
+ msg->cm_fields['N'] = strdup(NODENAME); /* nodename */
+ msg->cm_fields['H'] = strdup(HUMANNODE); /* hnodename */
if (recipient[0] != 0) {
- msg->cm_fields['R'] = strdoop(recipient);
+ msg->cm_fields['R'] = strdup(recipient);
}
if (dest_node[0] != 0) {
- msg->cm_fields['D'] = strdoop(dest_node);
+ msg->cm_fields['D'] = strdup(dest_node);
+ }
+
+ if ( (author == &CC->user) && (strlen(CC->cs_inet_email) > 0) ) {
+ msg->cm_fields['F'] = strdup(CC->cs_inet_email);
}
- msg->cm_fields['M'] = CtdlReadMessageBody("000",
- config.c_maxmsglen, NULL);
+ if (subject != NULL) {
+ striplt(subject);
+ if (strlen(subject) > 0) {
+ msg->cm_fields['U'] = strdup(subject);
+ }
+ }
+
+ if (preformatted_text != NULL) {
+ msg->cm_fields['M'] = preformatted_text;
+ }
+ else {
+ msg->cm_fields['M'] = CtdlReadMessageBody("000",
+ config.c_maxmsglen, NULL, 0);
+ }
return(msg);
}
* room. Returns a *CITADEL ERROR CODE* and puts a message in errmsgbuf, or
* returns 0 on success.
*/
-int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf) {
+int CtdlDoIHavePermissionToPostInThisRoom(char *errmsgbuf, size_t n) {
if (!(CC->logged_in)) {
- sprintf(errmsgbuf, "Not logged in.");
+ snprintf(errmsgbuf, n, "Not logged in.");
return (ERROR + NOT_LOGGED_IN);
}
- if ((CC->usersupp.axlevel < 2)
- && ((CC->quickroom.QRflags & QR_MAILBOX) == 0)) {
- sprintf(errmsgbuf, "Need to be validated to enter "
+ if ((CC->user.axlevel < 2)
+ && ((CC->room.QRflags & QR_MAILBOX) == 0)) {
+ snprintf(errmsgbuf, n, "Need to be validated to enter "
"(except in %s> to sysop)", MAILROOM);
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
- if ((CC->usersupp.axlevel < 4)
- && (CC->quickroom.QRflags & QR_NETWORK)) {
- sprintf(errmsgbuf, "Need net privileges to enter here.");
+ if ((CC->user.axlevel < 4)
+ && (CC->room.QRflags & QR_NETWORK)) {
+ snprintf(errmsgbuf, n, "Need net privileges to enter here.");
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
- if ((CC->usersupp.axlevel < 6)
- && (CC->quickroom.QRflags & QR_READONLY)) {
- sprintf(errmsgbuf, "Sorry, this is a read-only room.");
+ if ((CC->user.axlevel < 6)
+ && (CC->room.QRflags & QR_READONLY)) {
+ snprintf(errmsgbuf, n, "Sorry, this is a read-only room.");
return (ERROR + HIGHER_ACCESS_REQUIRED);
}
}
+/*
+ * Check to see if the specified user has Internet mail permission
+ * (returns nonzero if permission is granted)
+ */
+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);
+
+ /* User flagged ok? */
+ if (who->flags & US_INTERNET) return(2);
+
+ /* Aide level access? */
+ if (who->axlevel >= 6) return(3);
+
+ /* No mail for you! */
+ return(0);
+}
+
+
+
/*
* Validate recipients, count delivery types and errors, and handle aliasing
* FIXME check for dupes!!!!!
int i, j;
int mailtype;
int invalid;
- struct usersupp tempUS;
- struct quickroom tempQR;
+ struct ctdluser tempUS;
+ struct ctdlroom tempQR;
/* Initialize */
ret = (struct recptypes *) malloc(sizeof(struct recptypes));
}
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(9, "Evaluating recipient #%d <%s>\n", i, this_recp);
+ lprintf(CTDL_DEBUG, "Evaluating recipient #%d <%s>\n", i, this_recp);
mailtype = alias(this_recp);
mailtype = alias(this_recp);
mailtype = alias(this_recp);
case MES_LOCAL:
if (!strcasecmp(this_recp, "sysop")) {
++ret->num_room;
- strcpy(this_recp, AIDEROOM);
+ strcpy(this_recp, config.c_aideroom);
if (strlen(ret->recp_room) > 0) {
strcat(ret->recp_room, "|");
}
}
break;
case MES_INTERNET:
- ++ret->num_internet;
- if (strlen(ret->recp_internet) > 0) {
- strcat(ret->recp_internet, "|");
+ /* Yes, you're reading this correctly: if the target
+ * domain points back to the local system or an attached
+ * Citadel directory, the address is invalid. That's
+ * because if the address were valid, we would have
+ * already translated it to a local address by now.
+ */
+ if (IsDirectory(this_recp)) {
+ ++ret->num_error;
+ invalid = 1;
+ }
+ else {
+ ++ret->num_internet;
+ if (strlen(ret->recp_internet) > 0) {
+ strcat(ret->recp_internet, "|");
+ }
+ strcat(ret->recp_internet, this_recp);
}
- strcat(ret->recp_internet, this_recp);
break;
case MES_IGNET:
++ret->num_ignet;
}
if (invalid) {
if (strlen(ret->errormsg) == 0) {
- sprintf(append,
- "Invalid recipient: %s",
- this_recp);
+ snprintf(append, sizeof append,
+ "Invalid recipient: %s",
+ this_recp);
}
else {
- sprintf(append,
- ", %s", this_recp);
+ snprintf(append, sizeof append,
+ ", %s", this_recp);
}
if ( (strlen(ret->errormsg) + strlen(append)) < SIZ) {
strcat(ret->errormsg, append);
strcpy(append, this_recp);
}
else {
- sprintf(append, ", %s", this_recp);
+ snprintf(append, sizeof append, ", %s",
+ this_recp);
}
if ( (strlen(ret->display_recp)+strlen(append)) < SIZ) {
strcat(ret->display_recp, append);
strcpy(ret->errormsg, "No recipients specified.");
}
- lprintf(9, "validate_recipients()\n");
- lprintf(9, " local: %d <%s>\n", ret->num_local, ret->recp_local);
- lprintf(9, " room: %d <%s>\n", ret->num_room, ret->recp_room);
- lprintf(9, " inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
- lprintf(9, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
- lprintf(9, " error: %d <%s>\n", ret->num_error, ret->errormsg);
+ lprintf(CTDL_DEBUG, "validate_recipients()\n");
+ lprintf(CTDL_DEBUG, " local: %d <%s>\n", ret->num_local, ret->recp_local);
+ lprintf(CTDL_DEBUG, " room: %d <%s>\n", ret->num_room, ret->recp_room);
+ lprintf(CTDL_DEBUG, " inet: %d <%s>\n", ret->num_internet, ret->recp_internet);
+ lprintf(CTDL_DEBUG, " ignet: %d <%s>\n", ret->num_ignet, ret->recp_ignet);
+ lprintf(CTDL_DEBUG, " error: %d <%s>\n", ret->num_error, ret->errormsg);
return(ret);
}
char errmsg[SIZ];
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_token(subject, entargs, 4, '|', sizeof subject);
+ do_confirm = extract_int(entargs, 6);
/* first check to make sure the request is valid. */
- err = CtdlDoIHavePermissionToPostInThisRoom(errmsg);
+ err = CtdlDoIHavePermissionToPostInThisRoom(errmsg, sizeof errmsg);
if (err) {
cprintf("%d %s\n", err, errmsg);
return;
/* Check some other permission type things. */
if (post == 2) {
- if (CC->usersupp.axlevel < 6) {
+ if (CC->user.axlevel < 6) {
cprintf("%d You don't have permission to masquerade.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
return;
}
- extract(newusername, entargs, 4);
+ 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) );
- cprintf("%d ok\n", OK);
+ cprintf("%d ok\n", CIT_OK);
return;
}
CC->cs_flags |= CS_POSTING;
- if (CC->quickroom.QRflags & QR_MAILBOX) {
- if (CC->usersupp.axlevel < 2) {
+ /* In the Mail> room we have to behave a little differently --
+ * make sure the user has specified at least one recipient. Then
+ * validate the recipient(s).
+ */
+ if ( (CC->room.QRflags & QR_MAILBOX)
+ && (!strcasecmp(&CC->room.QRname[11], MAILROOM)) ) {
+
+ if (CC->user.axlevel < 2) {
strcpy(recp, "sysop");
}
if (valid->num_error > 0) {
cprintf("%d %s\n",
ERROR + NO_SUCH_USER, valid->errormsg);
- phree(valid);
+ free(valid);
return;
}
+ if (valid->num_internet > 0) {
+ if (CtdlCheckInternetMailPermission(&CC->user)==0) {
+ cprintf("%d You do not have permission "
+ "to send Internet mail.\n",
+ ERROR + HIGHER_ACCESS_REQUIRED);
+ free(valid);
+ return;
+ }
+ }
if ( ( (valid->num_internet + valid->num_ignet) > 0)
- && (CC->usersupp.axlevel < 4) ) {
+ && (CC->user.axlevel < 4) ) {
cprintf("%d Higher access required for network mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- phree(valid);
+ free(valid);
return;
}
if ((RESTRICT_INTERNET == 1) && (valid->num_internet > 0)
- && ((CC->usersupp.flags & US_INTERNET) == 0)
+ && ((CC->user.flags & US_INTERNET) == 0)
&& (!CC->internal_pgm)) {
cprintf("%d You don't have access to Internet mail.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
- phree(valid);
+ free(valid);
return;
}
/* Is this a room which has anonymous-only or anonymous-option? */
anonymous = MES_NORMAL;
- if (CC->quickroom.QRflags & QR_ANONONLY) {
+ if (CC->room.QRflags & QR_ANONONLY) {
anonymous = MES_ANONONLY;
}
- if (CC->quickroom.QRflags & QR_ANONOPT) {
+ if (CC->room.QRflags & QR_ANONOPT) {
if (anon_flag == 1) { /* only if the user requested it */
anonymous = MES_ANONOPT;
}
}
- if ((CC->quickroom.QRflags & QR_MAILBOX) == 0) {
+ if ((CC->room.QRflags & QR_MAILBOX) == 0) {
recp[0] = 0;
}
* success without creating the message.
*/
if (post == 0) {
- cprintf("%d %s\n", OK,
+ cprintf("%d %s\n", CIT_OK,
((valid != NULL) ? valid->display_recp : "") );
- phree(valid);
+ free(valid);
return;
}
}
/* Read in the message from the client. */
- cprintf("%d send message\n", SEND_LISTING);
- msg = make_message(&CC->usersupp, recp,
- CC->quickroom.QRname, anonymous, format_type, masquerade_as);
+ 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';
- phree(valid);
+ free(valid);
return;
}
)
{
- struct quickroom qrbuf;
+ struct ctdlroom qrbuf;
struct cdbdata *cdbfr;
long *msglist = NULL;
+ long *dellist = NULL;
int num_msgs = 0;
int i;
int num_deleted = 0;
int delete_this;
struct MetaData smi;
- lprintf(9, "CtdlDeleteMessages(%s, %ld, %s)\n",
+ lprintf(CTDL_DEBUG, "CtdlDeleteMessages(%s, %ld, %s)\n",
room_name, dmsgnum, content_type);
/* get room record, obtaining a lock... */
if (lgetroom(&qrbuf, room_name) != 0) {
- lprintf(7, "CtdlDeleteMessages(): Room <%s> not found\n",
+ lprintf(CTDL_ERR, "CtdlDeleteMessages(): Room <%s> not found\n",
room_name);
return (0); /* room not found */
}
cdbfr = cdb_fetch(CDB_MSGLISTS, &qrbuf.QRnumber, sizeof(long));
if (cdbfr != NULL) {
- msglist = mallok(cdbfr->len);
+ msglist = malloc(cdbfr->len);
+ dellist = malloc(cdbfr->len);
memcpy(msglist, cdbfr->ptr, cdbfr->len);
num_msgs = cdbfr->len / sizeof(long);
cdb_free(cdbfr);
/* Delete message only if all bits are set */
if (delete_this == 0x03) {
- AdjRefCount(msglist[i], -1);
+ dellist[num_deleted++] = msglist[i];
msglist[i] = 0L;
- ++num_deleted;
}
}
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];
- phree(msglist);
}
lputroom(&qrbuf);
- lprintf(9, "%d message(s) deleted.\n", num_deleted);
+
+ /* Go through the messages we pulled out of the index, and decrement
+ * their reference counts by 1. If this is the only room the message
+ * was in, the reference count will reach zero and the message will
+ * automatically be deleted from the database. We do this in a
+ * separate pass because there might be plug-in hooks getting called,
+ * and we don't want that happening during an S_ROOMS critical
+ * section.
+ */
+ if (num_deleted) for (i=0; i<num_deleted; ++i) {
+ PerformDeleteHooks(qrbuf.QRname, dellist[i]);
+ AdjRefCount(dellist[i], -1);
+ }
+
+ /* Now free the memory we used, and go away. */
+ if (msglist != NULL) free(msglist);
+ if (dellist != NULL) free(dellist);
+ lprintf(CTDL_DEBUG, "%d message(s) deleted.\n", num_deleted);
return (num_deleted);
}
* the current room (returns 1 for yes, 0 for no)
*/
int CtdlDoIHavePermissionToDeleteMessagesFromThisRoom(void) {
- getuser(&CC->usersupp, CC->curr_user);
- if ((CC->usersupp.axlevel < 6)
- && (CC->usersupp.usernum != CC->quickroom.QRroomaide)
- && ((CC->quickroom.QRflags & QR_MAILBOX) == 0)
+ getuser(&CC->user, CC->curr_user);
+ if ((CC->user.axlevel < 6)
+ && (CC->user.usernum != CC->room.QRroomaide)
+ && ((CC->room.QRflags & QR_MAILBOX) == 0)
&& (!(CC->internal_pgm))) {
return(0);
}
}
delnum = extract_long(delstr, 0);
- num_deleted = CtdlDeleteMessages(CC->quickroom.QRname, delnum, "");
+ num_deleted = CtdlDeleteMessages(CC->room.QRname, delnum, "");
if (num_deleted) {
- cprintf("%d %d message%s deleted.\n", OK,
+ cprintf("%d %d message%s deleted.\n", CIT_OK,
num_deleted, ((num_deleted != 1) ? "s" : ""));
} else {
- cprintf("%d Message %ld not found.\n", ERROR, delnum);
+ cprintf("%d Message %ld not found.\n", ERROR + MESSAGE_NOT_FOUND, delnum);
}
}
void cmd_move(char *args)
{
long num;
- char targ[SIZ];
- struct quickroom qtemp;
+ char targ[ROOMNAMELEN];
+ struct ctdlroom qtemp;
int err;
int is_copy = 0;
+ int ra;
+ 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);
if (getroom(&qtemp, targ) != 0) {
- cprintf("%d '%s' does not exist.\n", ERROR, targ);
+ cprintf("%d '%s' does not exist.\n",
+ ERROR + ROOM_NOT_FOUND, targ);
return;
}
- getuser(&CC->usersupp, CC->curr_user);
+ getuser(&CC->user, CC->curr_user);
+ CtdlRoomAccess(&qtemp, &CC->user, &ra, NULL);
+
+ /* Check for permission to perform this operation.
+ * Remember: "CC->room" is source, "qtemp" is target.
+ */
+ permit = 0;
+
/* Aides can move/copy */
- if ((CC->usersupp.axlevel < 6)
- /* Roomaides can move/copy */
- && (CC->usersupp.usernum != CC->quickroom.QRroomaide)
- /* Permit move/copy to/from personal rooms */
- && (!((CC->quickroom.QRflags & QR_MAILBOX)
- && (qtemp.QRflags & QR_MAILBOX)))
- /* Permit only copy from public to personal room */
- && (!(is_copy && !(CC->quickroom.QRflags & QR_MAILBOX)
- && (qtemp.QRflags & QR_MAILBOX)))) {
+ 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;
* if this is a 'move' rather than a 'copy' operation.
*/
if (is_copy == 0) {
- CtdlDeleteMessages(CC->quickroom.QRname, num, "");
+ CtdlDeleteMessages(CC->room.QRname, num, "");
}
- cprintf("%d Message %s.\n", OK, (is_copy ? "copied" : "moved") );
+ cprintf("%d Message %s.\n", CIT_OK, (is_copy ? "copied" : "moved") );
}
/* Use the negative of the message number for the metadata db index */
TheIndex = (0L - smibuf->meta_msgnum);
- lprintf(9, "PutMetaData(%ld) - ref count is %d\n",
+ lprintf(CTDL_DEBUG, "PutMetaData(%ld) - ref count is %d\n",
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));
}
*/
begin_critical_section(S_SUPPMSGMAIN);
GetMetaData(&smi, msgnum);
- lprintf(9, "Ref count for message <%ld> before write is <%d>\n",
+ lprintf(CTDL_DEBUG, "Ref count for message <%ld> before write is <%d>\n",
msgnum, smi.meta_refcount);
smi.meta_refcount += incr;
PutMetaData(&smi);
end_critical_section(S_SUPPMSGMAIN);
- lprintf(9, "Ref count for message <%ld> after write is <%d>\n",
+ lprintf(CTDL_DEBUG, "Ref count for message <%ld> after write is <%d>\n",
msgnum, smi.meta_refcount);
/* If the reference count is now zero, delete the message
* (and its supplementary record as well).
*/
if (smi.meta_refcount == 0) {
- lprintf(9, "Deleting message <%ld>\n", msgnum);
+ 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));
}
}
void CtdlWriteObject(char *req_room, /* Room to stuff it in */
char *content_type, /* MIME type of this object */
char *tempfilename, /* Where to fetch it from */
- struct usersupp *is_mailbox, /* Mailbox room? */
+ struct ctdluser *is_mailbox, /* Mailbox room? */
int is_binary, /* Is encoding necessary? */
int is_unique, /* Del others of this type? */
unsigned int flags /* Internal save flags */
)
{
- FILE *fp, *tempfp;
- char filename[PATH_MAX];
- char cmdbuf[SIZ];
- char ch;
- struct quickroom qrbuf;
+ FILE *fp;
+ struct ctdlroom qrbuf;
char roomname[ROOMNAMELEN];
struct CtdlMessage *msg;
- size_t len;
+
+ char *raw_message = NULL;
+ char *encoded_message = NULL;
+ off_t raw_length = 0;
if (is_mailbox != NULL)
- MailboxName(roomname, is_mailbox, req_room);
+ MailboxName(roomname, sizeof roomname, is_mailbox, req_room);
else
safestrncpy(roomname, req_room, sizeof(roomname));
- lprintf(9, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
+ lprintf(CTDL_DEBUG, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
- strcpy(filename, tmpnam(NULL));
- fp = fopen(filename, "w");
- if (fp == NULL)
- return;
- tempfp = fopen(tempfilename, "r");
- if (tempfp == NULL) {
- fclose(fp);
- unlink(filename);
+ fp = fopen(tempfilename, "rb");
+ if (fp == NULL) {
+ lprintf(CTDL_CRIT, "Cannot open %s: %s\n",
+ tempfilename, strerror(errno));
return;
}
+ fseek(fp, 0L, SEEK_END);
+ raw_length = ftell(fp);
+ rewind(fp);
+ lprintf(CTDL_DEBUG, "Raw length is %ld\n", (long)raw_length);
+
+ raw_message = malloc((size_t)raw_length + 2);
+ fread(raw_message, (size_t)raw_length, 1, fp);
+ fclose(fp);
- fprintf(fp, "Content-type: %s\n", content_type);
- lprintf(9, "Content-type: %s\n", content_type);
+ if (is_binary) {
+ encoded_message = malloc((size_t)
+ (((raw_length * 134) / 100) + 4096 ) );
+ }
+ else {
+ encoded_message = malloc((size_t)(raw_length + 4096));
+ }
- if (is_binary == 0) {
- fprintf(fp, "Content-transfer-encoding: 7bit\n\n");
- while (ch = getc(tempfp), ch > 0)
- putc(ch, fp);
- fclose(tempfp);
- putc(0, fp);
- fclose(fp);
- } else {
- fprintf(fp, "Content-transfer-encoding: base64\n\n");
- fclose(tempfp);
- fclose(fp);
- sprintf(cmdbuf, "./base64 -e <%s >>%s",
- tempfilename, filename);
- system(cmdbuf);
+ sprintf(encoded_message, "Content-type: %s\n", content_type);
+
+ if (is_binary) {
+ sprintf(&encoded_message[strlen(encoded_message)],
+ "Content-transfer-encoding: base64\n\n"
+ );
+ }
+ else {
+ sprintf(&encoded_message[strlen(encoded_message)],
+ "Content-transfer-encoding: 7bit\n\n"
+ );
+ }
+
+ if (is_binary) {
+ CtdlEncodeBase64(
+ &encoded_message[strlen(encoded_message)],
+ raw_message,
+ (int)raw_length
+ );
+ }
+ else {
+ raw_message[raw_length] = 0;
+ memcpy(
+ &encoded_message[strlen(encoded_message)],
+ raw_message,
+ (int)(raw_length+1)
+ );
}
- lprintf(9, "Allocating\n");
- msg = mallok(sizeof(struct CtdlMessage));
+ free(raw_message);
+
+ lprintf(CTDL_DEBUG, "Allocating\n");
+ msg = malloc(sizeof(struct CtdlMessage));
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC;
msg->cm_anon_type = MES_NORMAL;
msg->cm_format_type = 4;
- msg->cm_fields['A'] = strdoop(CC->usersupp.fullname);
- msg->cm_fields['O'] = strdoop(req_room);
- msg->cm_fields['N'] = strdoop(config.c_nodename);
- msg->cm_fields['H'] = strdoop(config.c_humannode);
+ msg->cm_fields['A'] = strdup(CC->user.fullname);
+ msg->cm_fields['O'] = strdup(req_room);
+ msg->cm_fields['N'] = strdup(config.c_nodename);
+ msg->cm_fields['H'] = strdup(config.c_humannode);
msg->cm_flags = flags;
- lprintf(9, "Loading\n");
- fp = fopen(filename, "rb");
- fseek(fp, 0L, SEEK_END);
- len = ftell(fp);
- rewind(fp);
- msg->cm_fields['M'] = mallok(len);
- fread(msg->cm_fields['M'], len, 1, fp);
- fclose(fp);
- unlink(filename);
+ msg->cm_fields['M'] = encoded_message;
/* Create the requested room if we have to. */
if (getroom(&qrbuf, roomname) != 0) {
create_room(roomname,
( (is_mailbox != NULL) ? 5 : 3 ),
- "", 0, 1);
+ "", 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.
*/
if (is_unique) {
- lprintf(9, "Deleted %d other msgs of this type\n",
+ lprintf(CTDL_DEBUG, "Deleted %d other msgs of this type\n",
CtdlDeleteMessages(roomname, 0L, content_type));
}
/* Now write the data */
struct CtdlMessage *msg;
char buf[SIZ];
- strcpy(hold_rm, CC->quickroom.QRname);
- if (getroom(&CC->quickroom, SYSCONFIGROOM) != 0) {
- getroom(&CC->quickroom, hold_rm);
+ strcpy(hold_rm, CC->room.QRname);
+ if (getroom(&CC->room, SYSCONFIGROOM) != 0) {
+ getroom(&CC->room, hold_rm);
return NULL;
}
/* We want the last (and probably only) config in this room */
begin_critical_section(S_CONFIG);
config_msgnum = (-1L);
- CtdlForEachMessage(MSGS_LAST, 1, (-127), sysconfname, NULL,
+ CtdlForEachMessage(MSGS_LAST, 1, sysconfname, NULL,
CtdlGetSysConfigBackend, NULL);
msgnum = config_msgnum;
end_critical_section(S_CONFIG);
conf = NULL;
}
else {
- msg = CtdlFetchMessage(msgnum);
+ msg = CtdlFetchMessage(msgnum, 1);
if (msg != NULL) {
- conf = strdoop(msg->cm_fields['M']);
+ conf = strdup(msg->cm_fields['M']);
CtdlFreeMessage(msg);
}
else {
}
}
- getroom(&CC->quickroom, hold_rm);
+ 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) );
CtdlWriteObject(SYSCONFIGROOM, sysconfname, temp, NULL, 0, 1, 0);
unlink(temp);
}
+
+
+/*
+ * Determine whether a given Internet address belongs to the current user
+ */
+int CtdlIsMe(char *addr, int addr_buf_len)
+{
+ struct recptypes *recp;
+ int i;
+
+ recp = validate_recipients(addr);
+ if (recp == NULL) return(0);
+
+ if (recp->num_local == 0) {
+ free(recp);
+ return(0);
+ }
+
+ for (i=0; i<recp->num_local; ++i) {
+ extract_token(addr, recp->recp_local, i, '|', addr_buf_len);
+ if (!strcasecmp(addr, CC->user.fullname)) {
+ free(recp);
+ return(1);
+ }
+ }
+
+ free(recp);
+ return(0);
+}
+
+
+/*
+ * Citadel protocol command to do the same
+ */
+void cmd_isme(char *argbuf) {
+ char addr[256];
+
+ if (CtdlAccessCheck(ac_logged_in)) return;
+ extract_token(addr, argbuf, 0, '|', sizeof addr);
+
+ if (CtdlIsMe(addr, sizeof addr)) {
+ cprintf("%d %s\n", CIT_OK, addr);
+ }
+ else {
+ cprintf("%d Not you.\n", ERROR + ILLEGAL_VALUE);
+ }
+
+}