#include <ctype.h>
#include <string.h>
#include <syslog.h>
-#ifdef HAVE_PTHREAD_H
-#include <pthread.h>
-#endif
#include <limits.h>
-#include "citadel.h"
-#include "server.h"
#include <errno.h>
+#include <stdarg.h>
#include <sys/stat.h>
+#include "citadel.h"
+#include "server.h"
#include "database.h"
#include "msgbase.h"
#include "support.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;
-
-/* FIX dumb stub function */
-void save_message(char *junk, char *more_junk, char *foo, int wahw, int ee) {
-}
+long config_msgnum;
+
+char *msgkeys[] = {
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "",
+ "",
+ "from",
+ "", "", "",
+ "exti",
+ "", "",
+ "hnod",
+ "msgn",
+ "", "", "",
+ "text",
+ "node",
+ "room",
+ "path",
+ "",
+ "rcpt",
+ "spec",
+ "time",
+ "subj",
+ "",
+ "",
+ "",
+ "",
+ ""
+};
/*
* This function is self explanatory.
int a, b;
char aaa[300], bbb[300];
- lprintf(9, "alias() called for <%s>\n", name);
-
remove_any_whitespace_to_the_left_or_right_of_at_symbol(name);
fp = fopen("network/mail.aliases", "r");
}
+
+/* Determine if a given message matches the fields in a message template.
+ * Return 0 for a successful match.
+ */
+int CtdlMsgCmp(struct CtdlMessage *msg, struct CtdlMessage *template) {
+ int i;
+
+ /* If there aren't any fields in the template, all messages will
+ * match.
+ */
+ if (template == NULL) return(0);
+
+ /* Null messages are bogus. */
+ if (msg == NULL) return(1);
+
+ for (i='A'; i<='Z'; ++i) {
+ if (template->cm_fields[i] != NULL) {
+ if (msg->cm_fields[i] == NULL) {
+ return 1;
+ }
+ if (strcasecmp(msg->cm_fields[i],
+ template->cm_fields[i])) return 1;
+ }
+ }
+
+ /* All compares succeeded: we have a match! */
+ return 0;
+}
+
+
+
+
/*
* API function to perform an operation for each qualifying message in the
* current room.
*/
void CtdlForEachMessage(int mode, long ref,
char *content_type,
+ struct CtdlMessage *compare,
void (*CallBack) (long msgnum))
{
int num_msgs = 0;
long thismsg;
struct SuppMsgInfo smi;
+ struct CtdlMessage *msg;
/* Learn about the user and room in question */
get_mm();
}
num_msgs = sort_msglist(msglist, num_msgs);
+
+ /* If a template was supplied, filter out the messages which
+ * don't match. (This could induce some delays!)
+ */
+ if (num_msgs > 0) {
+ if (compare != NULL) {
+ for (a = 0; a < num_msgs; ++a) {
+ msg = CtdlFetchMessage(msglist[a]);
+ if (msg != NULL) {
+ if (CtdlMsgCmp(msg, compare)) {
+ msglist[a] = 0L;
+ }
+ CtdlFreeMessage(msg);
+ }
+ }
+ }
+ }
+
/*
* Now iterate through the message list, according to the
{
int mode = 0;
char which[256];
+ 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);
cm_ref = extract_int(cmdbuf, 1);
+ with_template = extract_int(cmdbuf, 2);
mode = MSGS_ALL;
strcat(which, " ");
cprintf("%d not logged in\n", ERROR + NOT_LOGGED_IN);
return;
}
- cprintf("%d Message list...\n", LISTING_FOLLOWS);
- CtdlForEachMessage(mode, cm_ref, NULL, simple_listing);
+
+ if (with_template) {
+ cprintf("%d Send template then receive message list\n",
+ START_CHAT_MODE);
+ template = (struct CtdlMessage *)
+ mallok(sizeof(struct CtdlMessage));
+ memset(template, 0, sizeof(struct CtdlMessage));
+ while(client_gets(buf), strcmp(buf,"000")) {
+ extract(tfield, buf, 0);
+ extract(tvalue, buf, 1);
+ for (i='A'; i<='Z'; ++i) if (msgkeys[i]!=NULL) {
+ if (!strcasecmp(tfield, msgkeys[i])) {
+ template->cm_fields[i] =
+ strdoop(tvalue);
+ }
+ }
+ }
+ }
+ else {
+ cprintf("%d Message list...\n", LISTING_FOLLOWS);
+ }
+
+ CtdlForEachMessage(mode, cm_ref, NULL, template, simple_listing);
+ if (template != NULL) CtdlFreeMessage(template);
cprintf("000\n");
}
* for here is to format text out to 80 columns before sending it
* to the client. The client software may reformat it again.
*/
-void memfmout(int width, char *mptr, char subst)
- /* screen width to use */
- /* where are we going to get our text from? */
- /* nonzero if we should use hypertext mode */
+void memfmout(
+ int width, /* screen width to use */
+ char *mptr, /* where are we going to get our text from? */
+ char subst) /* nonzero if we should do substitutions */
{
int a, b, c;
int real = 0;
}
-/*
- * Callback function for mime parser that wants to display text
- */
-void fixed_output(char *name, char *filename, char *partnum, char *disp,
- void *content, char *cbtype, size_t length)
-{
- char *ptr;
-
- if (!strcasecmp(cbtype, "multipart/alternative")) {
- strcpy(ma->prefix, partnum);
- strcat(ma->prefix, ".");
- ma->is_ma = 1;
- ma->did_print = 0;
- return;
- }
-
- if ( (!strncasecmp(partnum, ma->prefix, strlen(ma->prefix)))
- && (ma->is_ma == 1)
- && (ma->did_print == 1) ) {
- lprintf(9, "Skipping part %s (%s)\n", partnum, cbtype);
- return;
- }
-
- ma->did_print = 1;
-
- if (!strcasecmp(cbtype, "text/plain")) {
- client_write(content, length);
- }
- else if (!strcasecmp(cbtype, "text/html")) {
- ptr = html_to_ascii(content, 80, 0);
- client_write(ptr, strlen(ptr));
- phree(ptr);
- }
- else if (strncasecmp(cbtype, "multipart/", 10)) {
- cprintf("Part %s: %s (%s) (%d bytes)\n",
- partnum, filename, cbtype, length);
- }
-}
-
-
/*
* Callback function for mime parser that opens a section for downloading
*/
/*
* Load a message from disk into memory.
- * This is used by output_message() and other fetch functions.
+ * This is used by CtdlOutputMsg() and other fetch functions.
*
* NOTE: Caller is responsible for freeing the returned CtdlMessage struct
* using the CtdlMessageFree() function.
CIT_UBYTE field_header;
size_t field_length;
-
dmsgtext = cdb_fetch(CDB_MSGMAIN, &msgnum, sizeof(long));
if (dmsgtext == NULL) {
- lprintf(9, "CtdlFetchMessage(%ld) failed.\n");
return NULL;
}
mptr = dmsgtext->ptr;
} while ((field_length > 0) && (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");
+
+ /* Perform "before read" hooks (aborting if any return nonzero) */
+ if (PerformMessageHooks(ret, EVT_BEFOREREAD) > 0) {
+ CtdlFreeMessage(ret);
+ return NULL;
+ }
+
return (ret);
}
}
-
/*
* Get a message off disk. (return value is the message's timestamp)
*
*/
-void output_message(char *msgid, int mode, int headers_only)
-{
- long msg_num;
- int a, i;
+int CtdlOutputMsg(long msg_num, /* message number (local) to fetch */
+ int mode, /* how would you like that message? */
+ int headers_only, /* eschew the message body? */
+ int do_proto, /* do Citadel protocol responses? */
+ FILE *outfp,
+ int outsock,
+ int crlf /* Use CRLF newlines instead of LF? */
+) {
+ int a, i, k;
char buf[1024];
time_t xtime;
CIT_UBYTE ch;
-
- struct CtdlMessage *TheMessage = NULL;
-
+ char allkeys[256];
+ char display_name[256];
+ struct CtdlMessage *TheMessage;
char *mptr;
+ char *nl; /* newline string */
/* buffers needed for RFC822 translation */
char suser[256];
char mid[256];
/* */
- msg_num = atol(msgid);
+
+ /* BEGIN NESTED FUNCTION omprintf() */
+ void omprintf(const char *format, ...) {
+ va_list arg_ptr;
+ char buf[256];
+
+ va_start(arg_ptr, format);
+ if (vsnprintf(buf, sizeof buf, format, arg_ptr) == -1)
+ buf[sizeof buf - 2] = '\n';
+ if (outfp != NULL) {
+ fwrite(buf, strlen(buf), 1, outfp);
+ }
+ else if (outsock >= 0) {
+ write(outsock, buf, strlen(buf));
+ }
+ else {
+ client_write(buf, strlen(buf));
+ }
+ va_end(arg_ptr);
+ }
+ /* END NESTED FUNCTION omprintf() */
+
+ /* BEGIN NESTED FUNCTION omfmout() */
+ void omfmout(char *mptr) {
+ int b, c;
+ int real = 0;
+ int old = 0;
+ CIT_UBYTE ch;
+ char aaa[140];
+ char buffer[256];
+
+ strcpy(aaa, "");
+ old = 255;
+ strcpy(buffer, "");
+ c = 1; /* c is the current pos */
+
+FMTA: ch = *mptr++;
+ old = real;
+ real = ch;
+ if (ch <= 0)
+ goto FMTEND;
+
+ if (((ch == 13) || (ch == 10)) && (old != 13) && (old != 10))
+ ch = 32;
+ if (((old == 13) || (old == 10)) && (isspace(real))) {
+ omprintf("%s", nl);
+ c = 1;
+ }
+ if (ch > 126)
+ goto FMTA;
+
+ if (ch > 32) {
+ if (((strlen(aaa) + c) > (75)) && (strlen(aaa) > (75))) {
+ omprintf("%s%s", nl, aaa);
+ c = strlen(aaa);
+ aaa[0] = 0;
+ }
+ b = strlen(aaa);
+ aaa[b] = ch;
+ aaa[b + 1] = 0;
+ }
+ if (ch == 32) {
+ if ((strlen(aaa) + c) > (75)) {
+ omprintf("%s", nl);
+ c = 1;
+ }
+ omprintf("%s ", aaa);
+ ++c;
+ c = c + strlen(aaa);
+ strcpy(aaa, "");
+ goto FMTA;
+ }
+ if ((ch == 13) || (ch == 10)) {
+ omprintf("%s%s", aaa, nl);
+ c = 1;
+ strcpy(aaa, "");
+ goto FMTA;
+ }
+ goto FMTA;
+
+FMTEND: omprintf("%s%s", aaa, nl);
+ }
+ /* END NESTED FUNCTION omfmout() */
+
+ /* BEGIN NESTED FUNCTION fixed_output() */
+ /*
+ * Callback function for mime parser that wants to display text
+ */
+ void fixed_output(char *name, char *filename, char *partnum, char *disp,
+ void *content, char *cbtype, size_t length)
+ {
+ char *ptr;
+ char *wptr;
+ size_t wlen;
+
+ if (!strcasecmp(cbtype, "multipart/alternative")) {
+ strcpy(ma->prefix, partnum);
+ strcat(ma->prefix, ".");
+ ma->is_ma = 1;
+ ma->did_print = 0;
+ return;
+ }
+
+ if ( (!strncasecmp(partnum, ma->prefix, strlen(ma->prefix)))
+ && (ma->is_ma == 1)
+ && (ma->did_print == 1) ) {
+ lprintf(9, "Skipping part %s (%s)\n", partnum, cbtype);
+ return;
+ }
+
+ ma->did_print = 1;
+
+ if (!strcasecmp(cbtype, "text/plain")) {
+ wlen = length;
+ wptr = content;
+ while (wlen--) {
+ ch = *wptr++;
+ if (ch==10) omprintf("%s", nl);
+ else omprintf("%c", ch);
+ }
+ }
+ 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) omprintf("%s", nl);
+ else omprintf("%c", ch);
+ }
+ phree(ptr);
+ }
+ else if (strncasecmp(cbtype, "multipart/", 10)) {
+ omprintf("Part %s: %s (%s) (%d bytes)%s",
+ partnum, filename, cbtype, length, nl);
+ }
+ }
+
+ /* END NESTED FUNCTION fixed_output() */
+
+
+ TheMessage = NULL;
+ sprintf(mid, "%ld", msg_num);
+ nl = (crlf ? "\r\n" : "\n");
if ((!(CC->logged_in)) && (!(CC->internal_pgm))) {
- cprintf("%d Not logged in.\n", ERROR + NOT_LOGGED_IN);
- return;
+ if (do_proto) cprintf("%d Not logged in.\n",
+ ERROR + NOT_LOGGED_IN);
+ return(om_not_logged_in);
}
/* FIX ... small security issue
* broken production code with nonbroken pre-beta code. :( -- ajc
*
if (!msg_ok) {
- cprintf("%d Message %ld is not in this room.\n",
+ if (do_proto) cprintf("%d Message %ld is not in this room.\n",
ERROR, msg_num);
- return;
+ return(om_no_such_msg);
}
*/
*/
TheMessage = CtdlFetchMessage(msg_num);
if (TheMessage == NULL) {
- cprintf("%d Can't locate msg %ld on disk\n", ERROR, msg_num);
- return;
+ if (do_proto) cprintf("%d Can't locate msg %ld on disk\n",
+ ERROR, msg_num);
+ return(om_no_such_msg);
}
/* Are we downloading a MIME component? */
if (mode == MT_DOWNLOAD) {
- if (TheMessage->cm_format_type != 4) {
- cprintf("%d This is not a MIME message.\n",
+ if (TheMessage->cm_format_type != FMT_RFC822) {
+ if (do_proto)
+ cprintf("%d This is not a MIME message.\n",
ERROR);
} else if (CC->download_fp != NULL) {
- cprintf("%d You already have a download open.\n",
+ if (do_proto) cprintf(
+ "%d You already have a download open.\n",
ERROR);
} else {
/* Parse the message text component */
* section wasn't found, so print an error
*/
if (CC->download_fp == NULL) {
- cprintf("%d Section %s not found.\n",
+ if (do_proto) cprintf(
+ "%d Section %s not found.\n",
ERROR + FILE_NOT_FOUND,
desired_section);
}
}
CtdlFreeMessage(TheMessage);
- return;
+ return((CC->download_fp != NULL) ? om_ok : om_mime_error);
}
/* now for the user-mode message reading loops */
- cprintf("%d Message %ld:\n", LISTING_FOLLOWS, msg_num);
+ 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 == 4)
- cprintf("type=1\n");
- else
- cprintf("type=%d\n", TheMessage->cm_format_type);
+ 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);
+ }
}
/* nhdr=yes means that we're only displaying headers, no body */
if ((TheMessage->cm_anon_type == MES_ANON) && (mode == MT_CITADEL)) {
- cprintf("nhdr=yes\n");
+ if (do_proto) cprintf("nhdr=yes\n");
}
/* begin header processing loop for Citadel message format */
if ((mode == MT_CITADEL) || (mode == MT_MIME)) {
- if (TheMessage->cm_fields['P']) {
- cprintf("path=%s\n", TheMessage->cm_fields['P']);
- }
- if (TheMessage->cm_fields['I']) {
- cprintf("msgn=%s\n", TheMessage->cm_fields['I']);
- }
- if (TheMessage->cm_fields['T']) {
- cprintf("time=%s\n", TheMessage->cm_fields['T']);
- }
+ strcpy(display_name, "<unknown>");
if (TheMessage->cm_fields['A']) {
strcpy(buf, TheMessage->cm_fields['A']);
PerformUserHooks(buf, (-1L), EVT_OUTPUTMSG);
if (TheMessage->cm_anon_type == MES_ANON)
- cprintf("from=****");
+ strcpy(display_name, "****");
else if (TheMessage->cm_anon_type == MES_AN2)
- cprintf("from=anonymous");
+ strcpy(display_name, "anonymous");
else
- cprintf("from=%s", buf);
+ strcpy(display_name, buf);
if ((is_room_aide())
&& ((TheMessage->cm_anon_type == MES_ANON)
|| (TheMessage->cm_anon_type == MES_AN2))) {
- cprintf(" [%s]", buf);
+ sprintf(&display_name[strlen(display_name)],
+ " [%s]", buf);
}
- cprintf("\n");
}
- if (TheMessage->cm_fields['O']) {
- cprintf("room=%s\n", TheMessage->cm_fields['O']);
- }
- if (TheMessage->cm_fields['N']) {
- cprintf("node=%s\n", TheMessage->cm_fields['N']);
- }
- if (TheMessage->cm_fields['H']) {
- cprintf("hnod=%s\n", TheMessage->cm_fields['H']);
- }
- if (TheMessage->cm_fields['R']) {
- cprintf("rcpt=%s\n", TheMessage->cm_fields['R']);
- }
- if (TheMessage->cm_fields['U']) {
- cprintf("subj=%s\n", TheMessage->cm_fields['U']);
+
+ strcpy(allkeys, FORDER);
+ for (i=0; i<strlen(allkeys); ++i) {
+ k = (int) allkeys[i];
+ if (k != 'M') {
+ if (TheMessage->cm_fields[k] != NULL) {
+ if (k == 'A') {
+ if (do_proto) cprintf("%s=%s\n",
+ msgkeys[k],
+ display_name);
+ }
+ else {
+ if (do_proto) cprintf("%s=%s\n",
+ msgkeys[k],
+ TheMessage->cm_fields[k]
+ );
+ }
+ }
+ }
}
+
}
/* begin header processing loop for RFC822 transfer format */
if (i == 'A') {
strcpy(luser, mptr);
} else if (i == 'P') {
- cprintf("Path: %s\n", mptr);
+ omprintf("Path: %s%s", mptr, nl);
for (a = 0; a < strlen(mptr); ++a) {
if (mptr[a] == '!') {
strcpy(mptr, &mptr[a + 1]);
}
strcpy(suser, mptr);
} else if (i == 'U')
- cprintf("Subject: %s\n", mptr);
+ omprintf("Subject: %s%s", mptr, nl);
else if (i == 'I')
strcpy(mid, mptr);
else if (i == 'H')
strcpy(lnode, mptr);
else if (i == 'O')
- cprintf("X-Citadel-Room: %s\n", mptr);
+ omprintf("X-Citadel-Room: %s%s",
+ mptr, nl);
else if (i == 'N')
strcpy(snode, mptr);
else if (i == 'R')
- cprintf("To: %s\n", mptr);
+ omprintf("To: %s%s", mptr, nl);
else if (i == 'T') {
xtime = atol(mptr);
- cprintf("Date: %s", asctime(localtime(&xtime)));
+ omprintf("Date: %s", asctime(localtime(&xtime)));
}
}
}
if (!strcasecmp(snode, NODENAME)) {
strcpy(snode, FQDN);
}
- cprintf("Message-ID: <%s@%s>\n", mid, snode);
+ omprintf("Message-ID: <%s@%s>%s", mid, snode, nl);
PerformUserHooks(luser, (-1L), EVT_OUTPUTMSG);
- cprintf("From: %s@%s (%s)\n", suser, snode, luser);
- cprintf("Organization: %s\n", lnode);
+ omprintf("From: %s@%s (%s)%s", suser, snode, luser, nl);
+ omprintf("Organization: %s%s", lnode, nl);
}
/* end header processing loop ... at this point, we're in the text */
mptr = TheMessage->cm_fields['M'];
/* Tell the client about the MIME parts in this message */
- if (TheMessage->cm_format_type == 4) { /* legacy textual dump */
+ if (TheMessage->cm_format_type == FMT_RFC822) { /* legacy text dump */
if (mode == MT_CITADEL) {
mime_parser(mptr, NULL, *list_this_part);
}
else if (mode == MT_MIME) { /* list parts only */
mime_parser(mptr, NULL, *list_this_part);
- cprintf("000\n");
+ if (do_proto) cprintf("000\n");
CtdlFreeMessage(TheMessage);
- return;
+ return(om_ok);
}
}
if (headers_only) {
- cprintf("000\n");
+ if (do_proto) cprintf("000\n");
CtdlFreeMessage(TheMessage);
- return;
+ return(om_ok);
}
/* signify start of msg text */
if (mode == MT_CITADEL)
- cprintf("text\n");
- if ((mode == MT_RFC822) && (TheMessage->cm_format_type != 4))
- cprintf("\n");
+ if (do_proto) cprintf("text\n");
+ /* if ((mode == MT_RFC822) && (TheMessage->cm_format_type != FMT_RFC822)) { */
+ if (mode == MT_RFC822) {
+ omprintf("%s", nl);
+ }
/* If the format type on disk is 1 (fixed-format), then we want
* everything to be output completely literally ... regardless of
* what message transfer format is in use.
*/
- if (TheMessage->cm_format_type == 1) {
+ if (TheMessage->cm_format_type == FMT_FIXED) {
strcpy(buf, "");
while (ch = *mptr++, ch > 0) {
if (ch == 13)
ch = 10;
if ((ch == 10) || (strlen(buf) > 250)) {
- cprintf("%s\n", buf);
+ omprintf("%s%s", buf, nl);
strcpy(buf, "");
} else {
buf[strlen(buf) + 1] = 0;
}
}
if (strlen(buf) > 0)
- cprintf("%s\n", buf);
+ omprintf("%s%s", buf, nl);
}
/* If the message on disk is format 0 (Citadel vari-format), we
* for new paragraphs is correct and the client will reformat the
* message to the reader's screen width.
*/
- if (TheMessage->cm_format_type == 0) {
- memfmout(80, mptr, 0);
+ if (TheMessage->cm_format_type == FMT_CITADEL) {
+ omfmout(mptr);
}
/* If the message on disk is format 4 (MIME), we've gotta hand it
* this message is format 1 (fixed format), so the callback function
* we use will display those parts as-is.
*/
- if (TheMessage->cm_format_type == 4) {
+ if (TheMessage->cm_format_type == FMT_RFC822) {
CtdlAllocUserData(SYM_MA_INFO, sizeof(struct ma_info));
memset(ma, 0, sizeof(struct ma_info));
mime_parser(mptr, NULL, *fixed_output);
}
/* now we're done */
- cprintf("000\n");
+ if (do_proto) cprintf("000\n");
CtdlFreeMessage(TheMessage);
- return;
+ return(om_ok);
}
*/
void cmd_msg0(char *cmdbuf)
{
- char msgid[256];
+ long msgid;
int headers_only = 0;
- extract(msgid, cmdbuf, 0);
+ msgid = extract_long(cmdbuf, 0);
headers_only = extract_int(cmdbuf, 1);
- output_message(msgid, MT_CITADEL, headers_only);
+ CtdlOutputMsg(msgid, MT_CITADEL, headers_only, 1, NULL, -1, 0);
return;
}
*/
void cmd_msg2(char *cmdbuf)
{
- char msgid[256];
+ long msgid;
int headers_only = 0;
- extract(msgid, cmdbuf, 0);
+ msgid = extract_long(cmdbuf, 0);
headers_only = extract_int(cmdbuf, 1);
- output_message(msgid, MT_RFC822, headers_only);
+ CtdlOutputMsg(msgid, MT_RFC822, headers_only, 1, NULL, -1, 1);
}
{
long msgnum;
struct CtdlMessage *msg;
- struct sermsgret smr;
+ struct ser_ret smr;
if (CC->internal_pgm == 0) {
cprintf("%d This command is for internal programs only.\n",
*/
void cmd_msg4(char *cmdbuf)
{
- char msgid[256];
-
- extract(msgid, cmdbuf, 0);
+ long msgid;
- output_message(msgid, MT_MIME, 0);
+ msgid = extract_long(cmdbuf, 0);
+ CtdlOutputMsg(msgid, MT_MIME, 0, 1, NULL, -1, 0);
}
/*
*/
void cmd_opna(char *cmdbuf)
{
- char msgid[256];
+ long msgid;
CtdlAllocUserData(SYM_DESIRED_SECTION, 64);
- extract(msgid, cmdbuf, 0);
+ msgid = extract_long(cmdbuf, 0);
extract(desired_section, cmdbuf, 1);
- output_message(msgid, MT_DOWNLOAD, 0);
+ CtdlOutputMsg(msgid, MT_DOWNLOAD, 0, 1, NULL, -1, 1);
}
+
+/*
+ * Save a message pointer into a specified room
+ * (Returns 0 for success, nonzero for failure)
+ * roomname may be NULL to use the current room
+ */
+int CtdlSaveMsgPointerInRoom(char *roomname, long msgid, int flags) {
+ int i;
+ char hold_rm[ROOMNAMELEN];
+ struct cdbdata *cdbfr;
+ int num_msgs;
+ long *msglist;
+ long highest_msg = 0L;
+ struct CtdlMessage *msg = NULL;
+
+ lprintf(9, "CtdlSaveMsgPointerInRoom(%s, %ld, %d)\n",
+ roomname, msgid, flags);
+
+ strcpy(hold_rm, CC->quickroom.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);
+ 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) )
+ != 0) {
+ lprintf(9, "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);
+ if (msg != NULL) CtdlFreeMessage(msg);
+ lprintf(9, "Did replication, and newer exists\n");
+ return(0);
+ }
+ }
+
+ /* Now the regular stuff */
+ if (lgetroom(&CC->quickroom,
+ ((roomname != NULL) ? roomname : CC->quickroom.QRname) )
+ != 0) {
+ lprintf(9, "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));
+ if (cdbfr == NULL) {
+ msglist = NULL;
+ num_msgs = 0;
+ } else {
+ msglist = mallok(cdbfr->len);
+ if (msglist == NULL)
+ lprintf(3, "ERROR malloc msglist!\n");
+ num_msgs = cdbfr->len / sizeof(long);
+ memcpy(msglist, cdbfr->ptr, cdbfr->len);
+ cdb_free(cdbfr);
+ }
+
+
+ /* Make sure the message doesn't already exist in this room. It
+ * is absolutely taboo to have more than one reference to the same
+ * message in a room.
+ */
+ 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);
+ if (msg != NULL) CtdlFreeMessage(msg);
+ return(ERROR + ALREADY_EXISTS);
+ }
+ }
+
+ /* Now add the new message */
+ ++num_msgs;
+ msglist = reallok(msglist,
+ (num_msgs * sizeof(long)));
+
+ if (msglist == NULL) {
+ lprintf(3, "ERROR: can't realloc message list!\n");
+ }
+ msglist[num_msgs - 1] = msgid;
+
+ /* Sort the message list, so all the msgid's are in order */
+ num_msgs = sort_msglist(msglist, num_msgs);
+
+ /* Determine the highest message number */
+ 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));
+
+ /* Free up the memory we used. */
+ phree(msglist);
+
+ /* Update the highest-message pointer and unlock the room. */
+ CC->quickroom.QRhighest = highest_msg;
+ lputroom(&CC->quickroom);
+ getroom(&CC->quickroom, hold_rm);
+
+ /* Bump the reference count for this message. */
+ if ((flags & SM_DONT_BUMP_REF)==0) {
+ AdjRefCount(msgid, +1);
+ }
+
+ /* Return success. */
+ if (msg != NULL) CtdlFreeMessage(msg);
+ return (0);
+}
+
+
+
/*
* Message base operation to send a message to the master file
* (returns new message number)
long newmsgid;
long retval;
char msgidbuf[32];
- struct sermsgret smr;
+ struct ser_ret smr;
/* Get a new message number */
newmsgid = get_new_message_number();
/*
* Serialize a struct CtdlMessage into the format used on disk and network.
*
- * This function returns a "struct sermsgret" (defined in msgbase.h) which
+ * This function loads up a "struct ser_ret" (defined in server.h) which
* contains the length of the serialized message and a pointer to the
* serialized message in memory. THE LATTER MUST BE FREED BY THE CALLER.
*/
-void serialize_message(struct sermsgret *ret, /* return values */
+void serialize_message(struct ser_ret *ret, /* return values */
struct CtdlMessage *msg) /* unserialized msg */
{
size_t wlen;
int i;
static char *forder = FORDER;
- lprintf(9, "serialize_message() called\n");
-
if (is_valid_message(msg) == 0) return; /* self check */
- lprintf(9, "magic number check OK.\n");
-
ret->len = 3;
for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL)
ret->len = ret->len +
strlen(msg->cm_fields[(int)forder[i]]) + 2;
- lprintf(9, "message is %d bytes\n", ret->len);
-
lprintf(9, "calling malloc\n");
ret->ser = mallok(ret->len);
if (ret->ser == NULL) {
ret->ser[1] = msg->cm_anon_type;
ret->ser[2] = msg->cm_format_type;
wlen = 3;
- lprintf(9, "stuff\n");
for (i=0; i<26; ++i) if (msg->cm_fields[(int)forder[i]] != NULL) {
ret->ser[wlen++] = (char)forder[i];
+/*
+ * Back end for the ReplicationChecks() function
+ */
+void check_repl(long msgnum) {
+ 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, NULL);
+}
+
+
+/*
+ * Check to see if any messages already exist which carry the same Extended ID
+ * as this one.
+ *
+ * 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. */
+ 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']);
+
+ template = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
+ memset(template, 0, sizeof(struct CtdlMessage));
+ template->cm_fields['E'] = strdoop(msg->cm_fields['E']);
+
+ CtdlForEachMessage(MSGS_ALL, 0L, NULL, template, check_repl);
+
+ /* 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(9, "ReplicationChecks() returning %d\n", abort_this);
+ return(abort_this);
+}
+
+
+
+
/*
* Save a message to disk
*/
-void CtdlSaveMsg(struct CtdlMessage *msg, /* message to save */
+long CtdlSaveMsg(struct CtdlMessage *msg, /* message to save */
char *rec, /* Recipient (mail) */
char *force, /* force a particular room? */
int mailtype, /* local or remote type */
char hold_rm[ROOMNAMELEN];
char actual_rm[ROOMNAMELEN];
char force_room[ROOMNAMELEN];
- char content_type[256]; /* We have to learn this */
+ char content_type[256]; /* We have to learn this */
char recipient[256];
long newmsgid;
- char *mptr;
+ char *mptr = NULL;
struct usersupp userbuf;
int a;
- int successful_local_recipients = 0;
- struct quickroom qtemp;
struct SuppMsgInfo smi;
FILE *network_fp = NULL;
static int seqnum = 1;
+ struct CtdlMessage *imsg;
+ char *instr;
lprintf(9, "CtdlSaveMsg() called\n");
- if (is_valid_message(msg) == 0) return; /* self check */
+ 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", time(NULL));
msg->cm_fields['T'] = strdoop(aaa);
}
/* If this message has no path, we generate one.
*/
if (msg->cm_fields['P'] == NULL) {
- msg->cm_fields['P'] = strdoop(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] = ' ';
+ lprintf(9, "Generating path\n");
+ if (msg->cm_fields['A'] != NULL) {
+ msg->cm_fields['P'] = strdoop(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");
+ }
}
strcpy(force_room, force);
strcpy(&recipient[a], &recipient[a + 1]);
/* Learn about what's inside, because it's what's inside that counts */
+ lprintf(9, "Learning what's inside\n");
+ if (msg->cm_fields['M'] == NULL) {
+ lprintf(1, "ERROR: attempt to save message with NULL body\n");
+ }
switch (msg->cm_format_type) {
case 0:
}
}
+ /* Goto the correct room */
+ lprintf(9, "Switching rooms\n");
+ strcpy(hold_rm, CC->quickroom.QRname);
+ strcpy(actual_rm, CC->quickroom.QRname);
+
+ /* If the user is a twit, move to the twit room for posting */
+ lprintf(9, "Handling twit stuff\n");
+ if (TWITDETECT) {
+ if (CC->usersupp.axlevel == 2) {
+ strcpy(hold_rm, actual_rm);
+ strcpy(actual_rm, config.c_twitroom);
+ }
+ }
+
+ /* ...or if this message is destined for Aide> then go there. */
+ if (strlen(force_room) > 0) {
+ strcpy(actual_rm, force_room);
+ }
+
+ lprintf(9, "Possibly relocating\n");
+ if (strcasecmp(actual_rm, CC->quickroom.QRname)) {
+ getroom(&CC->quickroom, 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);
+ }
+
+ /* Perform "before save" hooks (aborting if any return nonzero) */
+ lprintf(9, "Performing before-save hooks\n");
+ if (PerformMessageHooks(msg, EVT_BEFORESAVE) > 0) return(-1);
+
+ /* If this message has an Extended ID, perform replication checks */
+ lprintf(9, "Performing replication checks\n");
+ if (ReplicationChecks(msg) > 0) return(-1);
+
/* Network mail - send a copy to the network program. */
- if ((strlen(recipient) > 0) && (mailtype != MES_LOCAL)) {
+ if ((strlen(recipient) > 0) && (mailtype == MES_BINARY)) {
+ lprintf(9, "Sending network spool\n");
sprintf(aaa, "./network/spoolin/netmail.%04lx.%04x.%04x",
(long) getpid(), CC->cs_pid, ++seqnum);
lprintf(9, "Saving a copy to %s\n", aaa);
}
/* Save it to disk */
+ lprintf(9, "Saving to disk\n");
newmsgid = send_message(msg, generate_id, network_fp);
if (network_fp != NULL) {
fclose(network_fp);
system("exec nohup ./netproc -i >/dev/null 2>&1 &");
}
- if (newmsgid <= 0L)
- return;
- strcpy(actual_rm, CC->quickroom.QRname);
- strcpy(hold_rm, "");
+ if (newmsgid <= 0L) return(-1);
+
+ /* 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 SuppMsgInfo record\n");
+ memset(&smi, 0, sizeof(struct SuppMsgInfo));
+ smi.smi_msgnum = newmsgid;
+ smi.smi_refcount = 0;
+ safestrncpy(smi.smi_content_type, content_type, 64);
+ PutSuppMsgInfo(&smi);
+
+ /* Now figure out where to store the pointers */
+ lprintf(9, "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
* is no local sender; it would otherwise go to the Trashcan).
*/
if ((!CC->internal_pgm) || (strlen(recipient) == 0)) {
- /* If the user is a twit, move to the twit room for posting */
- if (TWITDETECT)
- if (CC->usersupp.axlevel == 2) {
- strcpy(hold_rm, actual_rm);
- strcpy(actual_rm, config.c_twitroom);
- }
- /* ...or if this message is destined for Aide> then go there. */
- if (strlen(force_room) > 0) {
- strcpy(hold_rm, actual_rm);
- strcpy(actual_rm, force_room);
- }
- /* This call to usergoto() changes rooms if necessary. It also
- * causes the latest message list to be read into memory.
- */
- usergoto(actual_rm, 0);
-
- /* read in the quickroom record, obtaining a lock... */
- lgetroom(&CC->quickroom, actual_rm);
-
- /* Fix an obscure bug */
- if (!strcasecmp(CC->quickroom.QRname, AIDEROOM)) {
- CC->quickroom.QRflags =
- CC->quickroom.QRflags & ~QR_MAILBOX;
- }
- /* Add the message pointer to the room */
- CC->quickroom.QRhighest =
- AddMessageToRoom(&CC->quickroom, newmsgid);
+ CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
+ }
- /* update quickroom */
- lputroom(&CC->quickroom);
- ++successful_local_recipients;
+ /* For internet mail, drop a copy in the outbound queue room */
+ if (mailtype == MES_INTERNET) {
+ CtdlSaveMsgPointerInRoom(SMTP_SPOOLOUT_ROOM, 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);
*/
if ((strlen(recipient) > 0) && (mailtype == MES_LOCAL)) {
if (getuser(&userbuf, recipient) == 0) {
+ lprintf(9, "Delivering private mail\n");
MailboxName(actual_rm, &userbuf, MAILROOM);
- if (lgetroom(&qtemp, actual_rm) == 0) {
- qtemp.QRhighest =
- AddMessageToRoom(&qtemp, newmsgid);
- lputroom(&qtemp);
- ++successful_local_recipients;
- }
+ CtdlSaveMsgPointerInRoom(actual_rm, newmsgid, 0);
}
}
- /* If we've posted in a room other than the current room, then we
- * have to now go back to the current room...
- */
- if (strlen(hold_rm) > 0) {
- usergoto(hold_rm, 0);
- }
- /* Write a supplemental message info record. This doesn't have to
- * be a critical section because nobody else knows about this message
- * yet.
+ /* Perform "after save" hooks */
+ lprintf(9, "Performing after-save hooks\n");
+ PerformMessageHooks(msg, EVT_AFTERSAVE);
+
+ /* */
+ lprintf(9, "Returning to original room\n");
+ if (strcasecmp(hold_rm, CC->quickroom.QRname))
+ getroom(&CC->quickroom, hold_rm);
+
+ /* For internet mail, generate delivery instructions
+ * (Yes, this is recursive! Deal with it!)
*/
- memset(&smi, 0, sizeof(struct SuppMsgInfo));
- smi.smi_msgnum = newmsgid;
- smi.smi_refcount = successful_local_recipients;
- safestrncpy(smi.smi_content_type, content_type, 64);
- PutSuppMsgInfo(&smi);
+ if (mailtype == MES_INTERNET) {
+ lprintf(9, "Generating delivery instructions\n");
+ instr = mallok(2048);
+ sprintf(instr,
+ "Content-type: %s\n\nmsgid|%ld\nsubmitted|%ld\n"
+ "remote|%s|0||\n",
+ SPOOLMIME, newmsgid, time(NULL), recipient );
+
+ imsg = mallok(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['M'] = instr;
+ CtdlSaveMsg(imsg, "", SMTP_SPOOLOUT_ROOM, MES_LOCAL, 1);
+ CtdlFreeMessage(imsg);
+ }
+
+ return(newmsgid);
}
/*
* Convenience function for generating small administrative messages.
*/
-void quickie_message(char *from, char *room, char *text)
+void quickie_message(char *from, char *to, char *room, char *text)
{
struct CtdlMessage *msg;
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);
CtdlSaveMsg(msg, "", room, MES_LOCAL, 1);
}
+
+/*
+ * Back end function used by make_message() and similar functions
+ */
+char *CtdlReadMessageBody(char *terminator, /* token signalling EOT */
+ size_t maxlen, /* maximum message length */
+ char *exist /* if non-null, append to it;
+ exist is ALWAYS freed */
+ ) {
+ char buf[256];
+ size_t message_len = 0;
+ size_t buffer_len = 0;
+ char *ptr, *append;
+ char *m;
+
+ if (exist == NULL) {
+ m = mallok(4096);
+ }
+ else {
+ m = reallok(exist, strlen(exist) + 4096);
+ if (m == NULL) phree(exist);
+ }
+ if (m == NULL) {
+ while ( (client_gets(buf)>0) && strcmp(buf, terminator) ) ;;
+ return(NULL);
+ } else {
+ buffer_len = 4096;
+ m[0] = 0;
+ message_len = 0;
+ }
+ /* read in the lines of message text one by one */
+ append = NULL;
+ while ( (client_gets(buf)>0) && strcmp(buf, terminator) ) {
+
+ /* augment the buffer if we have to */
+ if ((message_len + strlen(buf) + 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;
+ append = NULL;
+ lprintf(9, "buffer_len is %d\n", buffer_len);
+ }
+ }
+
+ if (append == NULL) append = m;
+ while (strlen(append) > 0) ++append;
+ strcpy(append, buf);
+ strcat(append, "\n");
+ message_len = message_len + strlen(buf) + 1;
+
+ /* 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);
+ }
+ }
+ return(m);
+}
+
+
+
+
/*
* Build a binary message to be saved on disk.
*/
int a;
char dest_node[32];
char buf[256];
- size_t message_len = 0;
- size_t buffer_len = 0;
- char *ptr;
struct CtdlMessage *msg;
msg = mallok(sizeof(struct CtdlMessage));
if (dest_node[0] != 0)
msg->cm_fields['D'] = strdoop(dest_node);
- msg->cm_fields['M'] = mallok(4096);
- if (msg->cm_fields['M'] == NULL) {
- while (client_gets(buf), strcmp(buf, "000")) ;; /* flush */
- return(msg);
- } else {
- buffer_len = 4096;
- msg->cm_fields['M'][0] = 0;
- message_len = 0;
- }
-
- /* read in the lines of message text one by one */
- while (client_gets(buf), strcmp(buf, "000")) {
- /* augment the buffer if we have to */
- if ((message_len + strlen(buf) + 2) > buffer_len) {
- ptr = reallok(msg->cm_fields['M'], (buffer_len * 2) );
- if (ptr == NULL) { /* flush if can't allocate */
- while (client_gets(buf), strcmp(buf, "000")) ;;
- return(msg);
- } else {
- buffer_len = (buffer_len * 2);
- msg->cm_fields['M'] = ptr;
- }
- }
+ msg->cm_fields['M'] = CtdlReadMessageBody("000",
+ config.c_maxmsglen, NULL);
- strcat(msg->cm_fields['M'], buf);
- strcat(msg->cm_fields['M'], "\n");
-
- /* if we've hit the max msg length, flush the rest */
- if (message_len >= config.c_maxmsglen) {
- while (client_gets(buf), strcmp(buf, "000")) ;;
- return(msg);
- }
- }
return(msg);
}
void cmd_ent3(char *entargs)
{
char recp[256];
- char buf[256];
int a;
int e = 0;
+ int valid_msg = 1;
+ unsigned char ch, which_field;
struct usersupp tempUS;
long msglen;
- long bloklen;
- FILE *fp;
+ struct CtdlMessage *msg;
+ char *tempbuf;
if (CC->internal_pgm == 0) {
cprintf("%d This command is for internal programs only.\n",
}
}
}
+
/* At this point, message has been approved. */
if (extract_int(entargs, 0) == 0) {
cprintf("%d OK to send\n", OK);
return;
}
- /* open a temp file to hold the message */
- fp = fopen(CC->temp, "wb");
- if (fp == NULL) {
- cprintf("%d Cannot open %s: %s\n",
- ERROR + INTERNAL_ERROR,
- CC->temp, strerror(errno));
+
+ msglen = extract_long(entargs, 2);
+ msg = mallok(sizeof(struct CtdlMessage));
+ if (msg == NULL) {
+ cprintf("%d Out of memory\n", ERROR+INTERNAL_ERROR);
return;
}
- msglen = extract_long(entargs, 2);
- cprintf("%d %ld\n", SEND_BINARY, msglen);
- while (msglen > 0L) {
- bloklen = ((msglen >= 255L) ? 255 : msglen);
- client_read(buf, (int) bloklen);
- fwrite(buf, (int) bloklen, 1, fp);
- msglen = msglen - bloklen;
+
+ memset(msg, 0, sizeof(struct CtdlMessage));
+ tempbuf = mallok(msglen);
+ if (tempbuf == NULL) {
+ cprintf("%d Out of memory\n", ERROR+INTERNAL_ERROR);
+ phree(msg);
+ return;
}
- fclose(fp);
- save_message(CC->temp, recp, "", e, 0);
+ cprintf("%d %ld\n", SEND_BINARY, msglen);
+
+ client_read(&ch, 1); /* 0xFF magic number */
+ msg->cm_magic = CTDLMESSAGE_MAGIC;
+ client_read(&ch, 1); /* anon type */
+ msg->cm_anon_type = ch;
+ client_read(&ch, 1); /* format type */
+ msg->cm_format_type = ch;
+ msglen = msglen - 3;
+
+ while (msglen > 0) {
+ client_read(&which_field, 1);
+ if (!isalpha(which_field)) valid_msg = 0;
+ --msglen;
+ tempbuf[0] = 0;
+ do {
+ client_read(&ch, 1);
+ --msglen;
+ a = strlen(tempbuf);
+ tempbuf[a+1] = 0;
+ tempbuf[a] = ch;
+ } while ( (ch != 0) && (msglen > 0) );
+ if (valid_msg)
+ msg->cm_fields[which_field] = strdoop(tempbuf);
+ }
+
+ msg->cm_flags = CM_SKIP_HOOKS;
+ if (valid_msg) CtdlSaveMsg(msg, recp, "", e, 0);
+ CtdlFreeMessage(msg);
+ phree(tempbuf);
}
/*
* API function to delete messages which match a set of criteria
* (returns the actual number of messages deleted)
- * FIX ... still need to implement delete by content type
*/
int CtdlDeleteMessages(char *room_name, /* which room */
long dmsgnum, /* or "0" for any */
getuser(&CC->usersupp, CC->curr_user);
if ((CC->usersupp.axlevel < 6)
&& (CC->usersupp.usernum != CC->quickroom.QRroomaide)
- && ((CC->quickroom.QRflags & QR_MAILBOX) == 0)) {
+ && ((CC->quickroom.QRflags & QR_MAILBOX) == 0)
+ && (!(CC->internal_pgm))) {
cprintf("%d Higher access required.\n",
ERROR + HIGHER_ACCESS_REQUIRED);
return;
/*
- * move a message to another room
+ * move or copy a message to another room
*/
void cmd_move(char *args)
{
long num;
- char targ[32];
+ char targ[256];
struct quickroom qtemp;
- int foundit;
+ int err;
+ int is_copy = 0;
num = extract_long(args, 0);
extract(targ, args, 1);
+ targ[ROOMNAMELEN - 1] = 0;
+ is_copy = extract_int(args, 2);
getuser(&CC->usersupp, CC->curr_user);
if ((CC->usersupp.axlevel < 6)
ERROR + HIGHER_ACCESS_REQUIRED);
return;
}
+
if (getroom(&qtemp, targ) != 0) {
cprintf("%d '%s' does not exist.\n", ERROR, targ);
return;
}
- /* Bump the reference count, otherwise the message will be deleted
- * from disk when we remove it from the source room.
- */
- AdjRefCount(num, 1);
- /* yank the message out of the current room... */
- foundit = CtdlDeleteMessages(CC->quickroom.QRname, num, NULL);
-
- if (foundit) {
- /* put the message into the target room */
- lgetroom(&qtemp, targ);
- qtemp.QRhighest = AddMessageToRoom(&qtemp, num);
- lputroom(&qtemp);
- cprintf("%d Message moved.\n", OK);
- } else {
- AdjRefCount(num, (-1)); /* oops */
- cprintf("%d msg %ld does not exist.\n", ERROR, num);
+ err = CtdlSaveMsgPointerInRoom(targ, num,
+ (SM_VERIFY_GOODNESS | SM_DO_REPL_CHECK) );
+ if (err != 0) {
+ cprintf("%d Cannot store message in %s: error %d\n",
+ err, targ, err);
+ return;
}
+
+ /* Now delete the message from the source room,
+ * if this is a 'move' rather than a 'copy' operation.
+ */
+ if (is_copy == 0) CtdlDeleteMessages(CC->quickroom.QRname, num, NULL);
+
+ cprintf("%d Message %s.\n", OK, (is_copy ? "copied" : "moved") );
}
*/
begin_critical_section(S_SUPPMSGMAIN);
GetSuppMsgInfo(&smi, msgnum);
+ lprintf(9, "Ref count for message <%ld> before write is <%d>\n",
+ msgnum, smi.smi_refcount);
smi.smi_refcount += incr;
PutSuppMsgInfo(&smi);
end_critical_section(S_SUPPMSGMAIN);
-
lprintf(9, "Ref count for message <%ld> after write is <%d>\n",
msgnum, smi.smi_refcount);
/*
* Write a generic object to this room
+ *
+ * Note: this could be much more efficient. Right now we use two temporary
+ * files, and still pull the message into memory as with all others.
*/
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 */
- int is_mailbox, /* Private mailbox room? */
+ struct usersupp *is_mailbox, /* Mailbox room? */
int is_binary, /* Is encoding necessary? */
- int is_unique /* Del others of this type? */
+ int is_unique, /* Del others of this type? */
+ unsigned int flags /* Internal save flags */
)
{
struct CtdlMessage *msg;
size_t len;
- lprintf(9, "CtdlWriteObject() called\n");
-
- if (is_mailbox)
- MailboxName(roomname, &CC->usersupp, req_room);
+ if (is_mailbox != NULL)
+ MailboxName(roomname, is_mailbox, req_room);
else
safestrncpy(roomname, req_room, sizeof(roomname));
+ lprintf(9, "CtdlWriteObject() to <%s> (flags=%d)\n", roomname, flags);
strcpy(filename, tmpnam(NULL));
fp = fopen(filename, "w");
msg->cm_anon_type = MES_NORMAL;
msg->cm_format_type = 4;
msg->cm_fields['A'] = strdoop(CC->usersupp.fullname);
- msg->cm_fields['O'] = strdoop(roomname);
+ 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_flags = flags;
lprintf(9, "Loading\n");
fp = fopen(filename, "rb");
unlink(filename);
/* Create the requested room if we have to. */
- lprintf(9, "Checking room\n");
if (getroom(&qrbuf, roomname) != 0) {
- create_room(roomname, 4, "", 0);
+ create_room(roomname,
+ ( (is_mailbox != NULL) ? 4 : 3 ),
+ "", 0);
}
/* If the caller specified this object as unique, delete all
* other objects of this type that are currently in the room.
CtdlDeleteMessages(roomname, 0L, content_type));
}
/* Now write the data */
- lprintf(9, "Calling CtdlSaveMsg()\n");
CtdlSaveMsg(msg, "", roomname, MES_LOCAL, 1);
- lprintf(9, "is valid? %d\n",
- is_valid_message(msg) );
- lprintf(9, "Calling CtdlFreeMsg()\n");
CtdlFreeMessage(msg);
- lprintf(9, "Done.\n");
}
+
+
+
+
+
+
+void CtdlGetSysConfigBackend(long msgnum) {
+ config_msgnum = msgnum;
+}
+
+
+char *CtdlGetSysConfig(char *sysconfname) {
+ char hold_rm[ROOMNAMELEN];
+ long msgnum;
+ char *conf;
+ struct CtdlMessage *msg;
+ char buf[256];
+
+ strcpy(hold_rm, CC->quickroom.QRname);
+ if (getroom(&CC->quickroom, SYSCONFIGROOM) != 0) {
+ getroom(&CC->quickroom, 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, sysconfname, NULL,
+ CtdlGetSysConfigBackend);
+ msgnum = config_msgnum;
+ end_critical_section(S_CONFIG);
+
+ if (msgnum < 0L) {
+ conf = NULL;
+ }
+ else {
+ msg = CtdlFetchMessage(msgnum);
+ if (msg != NULL) {
+ conf = strdoop(msg->cm_fields['M']);
+ CtdlFreeMessage(msg);
+ }
+ else {
+ conf = NULL;
+ }
+ }
+
+ getroom(&CC->quickroom, hold_rm);
+
+ lprintf(9, "eggstracting...\n");
+ if (conf != NULL) do {
+ extract_token(buf, conf, 0, '\n');
+ lprintf(9, "eggstracted <%s>\n", buf);
+ strcpy(conf, &conf[strlen(buf)+1]);
+ } while ( (strlen(conf)>0) && (strlen(buf)>0) );
+
+ return(conf);
+}
+
+void CtdlPutSysConfig(char *sysconfname, char *sysconfdata) {
+ char temp[PATH_MAX];
+ FILE *fp;
+
+ strcpy(temp, tmpnam(NULL));
+
+ fp = fopen(temp, "w");
+ if (fp == NULL) return;
+ fprintf(fp, "%s", sysconfdata);
+ fclose(fp);
+
+ /* this handy API function does all the work for us */
+ CtdlWriteObject(SYSCONFIGROOM, sysconfname, temp, NULL, 0, 1, 0);
+ unlink(temp);
+}
+
+
projects / citadel.git / blobdiff