/*
* Before allowing a wiki page save to execute, we have to perform version control.
* This involves fetching the old version of the page if it exists.
*/
int wiki_upload_beforesave(struct CtdlMessage *msg, recptypes *recp) {
struct CitContext *CCC = CC;
long old_msgnum = (-1L);
struct CtdlMessage *old_msg = NULL;
long history_msgnum = (-1L);
struct CtdlMessage *history_msg = NULL;
char diff_old_filename[PATH_MAX];
char diff_new_filename[PATH_MAX];
char diff_out_filename[PATH_MAX];
char diff_cmd[PATH_MAX];
FILE *fp;
int rv;
char history_page[1024];
long history_page_len;
char boundary[256];
char prefixed_boundary[258];
char buf[1024];
char *diffbuf = NULL;
size_t diffbuf_len = 0;
char *ptr = NULL;
long newmsgid;
StrBuf *msgidbuf;
if (!CCC->logged_in) return(0); /* Only do this if logged in. */
/* Is this a room with a Wiki in it, don't run this hook. */
if ((CCC->room.QRdefaultview != VIEW_WIKI) &&
(CCC->room.QRdefaultview != VIEW_WIKIMD)) {
return(0);
}
/* If this isn't a MIME message, don't bother. */
if (msg->cm_format_type != 4) return(0);
/* If there's no EUID we can't do this. Reject the post. */
if (CM_IsEmpty(msg, eExclusiveID)) return(1);
newmsgid = get_new_message_number();
msgidbuf = NewStrBuf();
StrBufPrintf(msgidbuf, "%08lX-%08lX@%s/%s",
(long unsigned int) time(NULL),
(long unsigned int) newmsgid,
CtdlGetConfigStr("c_fqdn"),
msg->cm_fields[eExclusiveID]
);
CM_SetAsFieldSB(msg, emessageId, &msgidbuf);
history_page_len = snprintf(history_page, sizeof history_page,
"%s_HISTORY_", msg->cm_fields[eExclusiveID]);
/* Make sure we're saving a real wiki page rather than a wiki history page.
* This is important in order to avoid recursing infinitely into this hook.
*/
if ( (msg->cm_lengths[eExclusiveID] >= 9)
&& (!strcasecmp(&msg->cm_fields[eExclusiveID][msg->cm_lengths[eExclusiveID]-9], "_HISTORY_"))
) {
syslog(LOG_DEBUG, "History page not being historied\n");
return(0);
}
/* If there's no message text, obviously this is all b0rken and shouldn't happen at all */
if (CM_IsEmpty(msg, eMesageText)) return(0);
/* Set the message subject identical to the page name */
CM_CopyField(msg, eMsgSubject, eExclusiveID);
/* See if we can retrieve the previous version. */
old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields[eExclusiveID], &CCC->room);
if (old_msgnum > 0L) {
old_msg = CtdlFetchMessage(old_msgnum, 1, 1);
}
else {
old_msg = NULL;
}
if ((old_msg != NULL) && (CM_IsEmpty(old_msg, eMesageText))) { /* old version is corrupt? */
CM_Free(old_msg);
old_msg = NULL;
}
/* If no changes were made, don't bother saving it again */
if ((old_msg != NULL) && (!strcmp(msg->cm_fields[eMesageText], old_msg->cm_fields[eMesageText]))) {
CM_Free(old_msg);
return(1);
}
/*
* Generate diffs
*/
CtdlMakeTempFileName(diff_old_filename, sizeof diff_old_filename);
CtdlMakeTempFileName(diff_new_filename, sizeof diff_new_filename);
CtdlMakeTempFileName(diff_out_filename, sizeof diff_out_filename);
if (old_msg != NULL) {
fp = fopen(diff_old_filename, "w");
rv = fwrite(old_msg->cm_fields[eMesageText], old_msg->cm_lengths[eMesageText], 1, fp);
fclose(fp);
CM_Free(old_msg);
}
fp = fopen(diff_new_filename, "w");
rv = fwrite(msg->cm_fields[eMesageText], msg->cm_lengths[eMesageText], 1, fp);
fclose(fp);
snprintf(diff_cmd, sizeof diff_cmd,
DIFF " -u %s %s >%s",
diff_new_filename,
((old_msg != NULL) ? diff_old_filename : "/dev/null"),
diff_out_filename
);
syslog(LOG_DEBUG, "diff cmd: %s", diff_cmd);
rv = system(diff_cmd);
syslog(LOG_DEBUG, "diff cmd returned %d", rv);
diffbuf_len = 0;
diffbuf = NULL;
fp = fopen(diff_out_filename, "r");
if (fp == NULL) {
fp = fopen("/dev/null", "r");
}
if (fp != NULL) {
fseek(fp, 0L, SEEK_END);
diffbuf_len = ftell(fp);
fseek(fp, 0L, SEEK_SET);
diffbuf = malloc(diffbuf_len + 1);
fread(diffbuf, diffbuf_len, 1, fp);
diffbuf[diffbuf_len] = '\0';
fclose(fp);
}
syslog(LOG_DEBUG, "diff length is "SIZE_T_FMT" bytes", diffbuf_len);
unlink(diff_old_filename);
unlink(diff_new_filename);
unlink(diff_out_filename);
/* Determine whether this was a bogus (empty) edit */
if ((diffbuf_len = 0) && (diffbuf != NULL)) {
free(diffbuf);
diffbuf = NULL;
}
if (diffbuf == NULL) {
return(1); /* No changes at all? Abandon the post entirely! */
}
/* Now look for the existing edit history */
history_msgnum = CtdlLocateMessageByEuid(history_page, &CCC->room);
history_msg = NULL;
if (history_msgnum > 0L) {
history_msg = CtdlFetchMessage(history_msgnum, 1, 1);
}
/* Create a new history message if necessary */
if (history_msg == NULL) {
char *buf;
long len;
history_msg = malloc(sizeof(struct CtdlMessage));
memset(history_msg, 0, sizeof(struct CtdlMessage));
history_msg->cm_magic = CTDLMESSAGE_MAGIC;
history_msg->cm_anon_type = MES_NORMAL;
history_msg->cm_format_type = FMT_RFC822;
CM_SetField(history_msg, eAuthor, HKEY("Citadel"));
if (!IsEmptyStr(CCC->room.QRname)){
CM_SetField(history_msg, eRecipient, CCC->room.QRname, strlen(CCC->room.QRname));
}
CM_SetField(history_msg, eExclusiveID, history_page, history_page_len);
CM_SetField(history_msg, eMsgSubject, history_page, history_page_len);
CM_SetField(history_msg, eSuppressIdx, HKEY("1")); /* suppress full text indexing */
snprintf(boundary, sizeof boundary, "Citadel--Multipart--%04x--%08lx", getpid(), time(NULL));
buf = (char*) malloc(1024);
len = snprintf(buf, 1024,
"Content-type: multipart/mixed; boundary=\"%s\"\n\n"
"This is a Citadel wiki history encoded as multipart MIME.\n"
"Each part is comprised of a diff script representing one change set.\n"
"\n"
"--%s--\n",
boundary, boundary
);
CM_SetAsField(history_msg, eMesageText, &buf, len);
}
/* Update the history message (regardless of whether it's new or existing) */
/* Remove the Message-ID from the old version of the history message. This will cause a brand
* new one to be generated, avoiding an uninitentional hit of the loop zapper when we replicate.
*/
CM_FlushField(history_msg, emessageId);
/* Figure out the boundary string. We do this even when we generated the
* boundary string in the above code, just to be safe and consistent.
*/
*boundary = '\0';
ptr = history_msg->cm_fields[eMesageText];
do {
ptr = memreadline(ptr, buf, sizeof buf);
if (*ptr != 0) {
striplt(buf);
if (!IsEmptyStr(buf) && (!strncasecmp(buf, "Content-type:", 13))) {
if (
(bmstrcasestr(buf, "multipart") != NULL)
&& (bmstrcasestr(buf, "boundary=") != NULL)
) {
safestrncpy(boundary, bmstrcasestr(buf, "\""), sizeof boundary);
char *qu;
qu = strchr(boundary, '\"');
if (qu) {
strcpy(boundary, ++qu);
}
qu = strchr(boundary, '\"');
if (qu) {
*qu = 0;
}
}
}
}
} while ( (IsEmptyStr(boundary)) && (*ptr != 0) );
/*
* Now look for the first boundary. That is where we need to insert our fun.
*/
if (!IsEmptyStr(boundary)) {
char *MsgText;
long MsgTextLen;
time_t Now = time(NULL);
snprintf(prefixed_boundary, sizeof(prefixed_boundary), "--%s", boundary);
CM_GetAsField(history_msg, eMesageText, &MsgText, &MsgTextLen);
ptr = bmstrcasestr(MsgText, prefixed_boundary);
if (ptr != NULL) {
StrBuf *NewMsgText;
char uuid[64];
char memo[512];
long memolen;
char encoded_memo[1024];
NewMsgText = NewStrBufPlain(NULL, MsgTextLen + diffbuf_len + 1024);
generate_uuid(uuid);
memolen = snprintf(memo, sizeof(memo), "%s|%ld|%s|%s",
uuid,
Now,
CCC->user.fullname,
CtdlGetConfigStr("c_nodename"));
memolen = CtdlEncodeBase64(encoded_memo, memo, memolen, 0);
StrBufAppendBufPlain(NewMsgText, HKEY("--"), 0);
StrBufAppendBufPlain(NewMsgText, boundary, -1, 0);
StrBufAppendBufPlain(
NewMsgText,
HKEY("\n"
"Content-type: text/plain\n"
"Content-Disposition: inline; filename=\""), 0);
StrBufAppendBufPlain(NewMsgText, encoded_memo, memolen, 0);
StrBufAppendBufPlain(
NewMsgText,
HKEY("\"\n"
"Content-Transfer-Encoding: 8bit\n"
"\n"), 0);
StrBufAppendBufPlain(NewMsgText, diffbuf, diffbuf_len, 0);
StrBufAppendBufPlain(NewMsgText, HKEY("\n"), 0);
StrBufAppendBufPlain(NewMsgText, ptr, MsgTextLen - (ptr - MsgText), 0);
free(MsgText);
CM_SetAsFieldSB(history_msg, eMesageText, &NewMsgText);
}
else
{
CM_SetAsField(history_msg, eMesageText, &MsgText, MsgTextLen);
}
CM_SetFieldLONG(history_msg, eTimestamp, Now);
CtdlSubmitMsg(history_msg, NULL, "", 0);
}
else {
syslog(LOG_ALERT, "Empty boundary string in history message. No history!\n");
}
free(diffbuf);
CM_Free(history_msg);
return(0);
}
/*
* Sanitize and enhance an HTML message for display.
* Also convert weird character sets to UTF-8 if necessary.
* Also fixup img src="cid:..." type inline images to fetch the image
*
*/
void output_html(const char *supplied_charset, int treat_as_wiki, int msgnum, StrBuf *Source, StrBuf *Target) {
char buf[SIZ];
char *msg;
char *ptr;
char *msgstart;
char *msgend;
StrBuf *converted_msg;
int buffer_length = 1;
int line_length = 0;
int content_length = 0;
char new_window[SIZ];
int brak = 0;
int alevel = 0;
int scriptlevel = 0;
int script_start_pos = (-1);
int i;
int linklen;
char charset[128];
StrBuf *BodyArea = NULL;
#ifdef HAVE_ICONV
iconv_t ic = (iconv_t)(-1) ;
char *ibuf; /* Buffer of characters to be converted */
char *obuf; /* Buffer for converted characters */
size_t ibuflen; /* Length of input buffer */
size_t obuflen; /* Length of output buffer */
char *osav; /* Saved pointer to output buffer */
#endif
if (Target == NULL)
Target = WC->WBuf;
safestrncpy(charset, supplied_charset, sizeof charset);
msg = strdup("");
sprintf(new_window, "<a target=\"%s\" href=", TARGET);
if (Source == NULL) while (serv_getln(buf, sizeof buf), strcmp(buf, "000")) {
line_length = strlen(buf);
buffer_length = content_length + line_length + 2;
ptr = realloc(msg, buffer_length);
if (ptr == NULL) {
StrBufAppendPrintf(Target, "<b>");
StrBufAppendPrintf(Target, _("realloc() error! couldn't get %d bytes: %s"),
buffer_length + 1,
strerror(errno));
StrBufAppendPrintf(Target, "</b><br><br>\n");
while (serv_getln(buf, sizeof buf), strcmp(buf, "000")) {
/** flush */
}
free(msg);
return;
}
msg = ptr;
strcpy(&msg[content_length], buf);
content_length += line_length;
strcpy(&msg[content_length], "\n");
content_length += 1;
}
else {
content_length = StrLength(Source);
free(msg);
msg = (char*) ChrPtr(Source);/* TODO: remove cast */
buffer_length = content_length;
}
/** Do a first pass to isolate the message body */
ptr = msg + 1;
msgstart = msg;
msgend = &msg[content_length];
while (ptr < msgend) {
/** Advance to next tag */
ptr = strchr(ptr, '<');
if ((ptr == NULL) || (ptr >= msgend)) break;
++ptr;
if ((ptr == NULL) || (ptr >= msgend)) break;
/*
* Look for META tags. Some messages (particularly in
* Asian locales) illegally declare a message's character
* set in the HTML instead of in the MIME headers. This
* is wrong but we have to work around it anyway.
*/
if (!strncasecmp(ptr, "META", 4)) {
char *meta_start;
char *meta_end;
int meta_length;
char *meta;
char *meta_http_equiv;
char *meta_content;
char *spaceptr;
meta_start = &ptr[4];
meta_end = strchr(ptr, '>');
if ((meta_end != NULL) && (meta_end <= msgend)) {
meta_length = meta_end - meta_start + 1;
meta = malloc(meta_length + 1);
safestrncpy(meta, meta_start, meta_length);
meta[meta_length] = 0;
striplt(meta);
if (!strncasecmp(meta, "HTTP-EQUIV=", 11)) {
meta_http_equiv = strdup(&meta[11]);
spaceptr = strchr(meta_http_equiv, ' ');
if (spaceptr != NULL) {
*spaceptr = 0;
meta_content = strdup(++spaceptr);
if (!strncasecmp(meta_content, "content=", 8)) {
strcpy(meta_content, &meta_content[8]);
stripquotes(meta_http_equiv);
stripquotes(meta_content);
extract_charset_from_meta(charset,
meta_http_equiv, meta_content);
}
free(meta_content);
}
free(meta_http_equiv);
}
free(meta);
}
}
/*
* Any of these tags cause everything up to and including
* the tag to be removed.
*/
if ( (!strncasecmp(ptr, "HTML", 4))
||(!strncasecmp(ptr, "HEAD", 4))
||(!strncasecmp(ptr, "/HEAD", 5))
||(!strncasecmp(ptr, "BODY", 4)) ) {
char *pBody = NULL;
if (!strncasecmp(ptr, "BODY", 4)) {
pBody = ptr;
}
ptr = strchr(ptr, '>');
if ((ptr == NULL) || (ptr >= msgend)) break;
if ((pBody != NULL) && (ptr - pBody > 4)) {
char* src;
char *cid_start, *cid_end;
*ptr = '\0';
pBody += 4;
while ((isspace(*pBody)) && (pBody < ptr))
pBody ++;
BodyArea = NewStrBufPlain(NULL, ptr - pBody);
if (pBody < ptr) {
src = strstr(pBody, "cid:");
if (src) {
cid_start = src + 4;
cid_end = cid_start;
while ((*cid_end != '"') &&
!isspace(*cid_end) &&
(cid_end < ptr))
cid_end ++;
/* copy tag and attributes up to src="cid: */
StrBufAppendBufPlain(BodyArea, pBody, src - pBody, 0);
/* add in /webcit/mimepart/<msgno>/CID/
trailing / stops dumb URL filters getting excited */
StrBufAppendPrintf(BodyArea,
"/webcit/mimepart/%d/",msgnum);
StrBufAppendBufPlain(BodyArea, cid_start, cid_end - cid_start, 0);
if (ptr - cid_end > 0)
StrBufAppendBufPlain(BodyArea,
cid_end + 1,
ptr - cid_end, 0);
}
else
StrBufAppendBufPlain(BodyArea, pBody, ptr - pBody, 0);
}
*ptr = '>';
}
++ptr;
if ((ptr == NULL) || (ptr >= msgend)) break;
msgstart = ptr;
}
/*
* Any of these tags cause everything including and following
* the tag to be removed.
*/
if ( (!strncasecmp(ptr, "/HTML", 5))
||(!strncasecmp(ptr, "/BODY", 5)) ) {
--ptr;
msgend = ptr;
strcpy(ptr, "");
}
++ptr;
}
if (msgstart > msg) {
strcpy(msg, msgstart);
}
/* Now go through the message, parsing tags as necessary. */
converted_msg = NewStrBufPlain(NULL, content_length + 8192);
/** Convert foreign character sets to UTF-8 if necessary. */
#ifdef HAVE_ICONV
if ( (strcasecmp(charset, "us-ascii"))
&& (strcasecmp(charset, "UTF-8"))
&& (strcasecmp(charset, ""))
) {
syslog(LOG_DEBUG, "Converting %s to UTF-8\n", charset);
ctdl_iconv_open("UTF-8", charset, &ic);
if (ic == (iconv_t)(-1) ) {
syslog(LOG_WARNING, "%s:%d iconv_open() failed: %s\n",
__FILE__, __LINE__, strerror(errno));
}
}
if (Source == NULL) {
if (ic != (iconv_t)(-1) ) {
ibuf = msg;
ibuflen = content_length;
obuflen = content_length + (content_length / 2) ;
obuf = (char *) malloc(obuflen);
osav = obuf;
iconv(ic, &ibuf, &ibuflen, &obuf, &obuflen);
content_length = content_length + (content_length / 2) - obuflen;
osav[content_length] = 0;
free(msg);
msg = osav;
iconv_close(ic);
}
}
else {
if (ic != (iconv_t)(-1) ) {
StrBuf *Buf = NewStrBufPlain(NULL, StrLength(Source) + 8096);;
StrBufConvert(Source, Buf, &ic);
FreeStrBuf(&Buf);
iconv_close(ic);
msg = (char*)ChrPtr(Source); /* TODO: get rid of this. */
}
}
#endif
/*
* At this point, the message has been stripped down to
* only the content inside the <BODY></BODY> tags, and has
* been converted to UTF-8 if it was originally in a foreign
* character set. The text is also guaranteed to be null
* terminated now.
*/
if (converted_msg == NULL) {
StrBufAppendPrintf(Target, "Error %d: %s<br>%s:%d", errno, strerror(errno), __FILE__, __LINE__);
goto BAIL;
}
if (BodyArea != NULL) {
StrBufAppendBufPlain(converted_msg, HKEY("<table "), 0);
StrBufAppendBuf(converted_msg, BodyArea, 0);
StrBufAppendBufPlain(converted_msg, HKEY(" width=\"100%\"><tr><td>"), 0);
}
ptr = msg;
msgend = strchr(msg, 0);
while (ptr < msgend) {
/** Try to sanitize the html of any rogue scripts */
if (!strncasecmp(ptr, "<script", 7)) {
if (scriptlevel == 0) {
script_start_pos = StrLength(converted_msg);
}
++scriptlevel;
}
if (!strncasecmp(ptr, "</script", 8)) {
--scriptlevel;
}
/**
* Change mailto: links to WebCit mail, by replacing the
* link with one that points back to our mail room. Due to
* the way we parse URL's, it'll even handle mailto: links
* that have "?subject=" in them.
*/
if (!strncasecmp(ptr, "<a href=\"mailto:", 16)) {
content_length += 64;
StrBufAppendPrintf(converted_msg,
"<a href=\"display_enter?force_room=_MAIL_?recp=");
ptr = &ptr[16];
++alevel;
++brak;
}
/** Make external links open in a separate window */
else if (!strncasecmp(ptr, "<a href=\"", 9)) {
++alevel;
++brak;
if ( ((strchr(ptr, ':') < strchr(ptr, '/')))
&& ((strchr(ptr, '/') < strchr(ptr, '>')))
) {
/* open external links to new window */
StrBufAppendPrintf(converted_msg, new_window);
ptr = &ptr[8];
}
else if (
(treat_as_wiki)
&& (strncasecmp(ptr, "<a href=\"wiki?", 14))
&& (strncasecmp(ptr, "<a href=\"dotgoto?", 17))
&& (strncasecmp(ptr, "<a href=\"knrooms?", 17))
) {
content_length += 64;
StrBufAppendPrintf(converted_msg, "<a href=\"wiki?go=");
StrBufUrlescAppend(converted_msg, WC->CurRoom.name, NULL);
StrBufAppendPrintf(converted_msg, "?page=");
ptr = &ptr[9];
}
else {
StrBufAppendPrintf(converted_msg, "<a href=\"");
ptr = &ptr[9];
}
}
/** Fixup <img src="cid:... ...> to fetch the mime part */
else if (!strncasecmp(ptr, "<img ", 5)) {
char *cid_start, *cid_end;
char* tag_end=strchr(ptr,'>');
char* src;
/* FIXME - handle this situation (maybe someone opened an <img cid...
* and then ended the message)
*/
if (!tag_end) {
syslog(LOG_DEBUG, "tag_end is null and ptr is:\n");
syslog(LOG_DEBUG, "%s\n", ptr);
syslog(LOG_DEBUG, "Theoretical bytes remaining: %d\n", (int)(msgend - ptr));
}
src=strstr(ptr, "src=\"cid:");
++brak;
if (src
&& isspace(*(src-1))
&& tag_end
&& (cid_start=strchr(src,':'))
&& (cid_end=strchr(cid_start,'"'))
&& (cid_end < tag_end)
) {
/* copy tag and attributes up to src="cid: */
StrBufAppendBufPlain(converted_msg, ptr, src - ptr, 0);
cid_start++;
/* add in /webcit/mimepart/<msgno>/CID/
trailing / stops dumb URL filters getting excited */
StrBufAppendPrintf(converted_msg,
" src=\"/webcit/mimepart/%d/",msgnum);
StrBufAppendBufPlain(converted_msg, cid_start, cid_end - cid_start, 0);
StrBufAppendBufPlain(converted_msg, "/\"", -1, 0);
ptr = cid_end+1;
}
StrBufAppendBufPlain(converted_msg, ptr, tag_end - ptr, 0);
ptr = tag_end;
}
/**
* Turn anything that looks like a URL into a real link, as long
* as it's not inside a tag already
*/
else if ( (brak == 0) && (alevel == 0) &&
( (!strncasecmp(ptr, "http://", 7)) ||
(!strncasecmp(ptr, "https://", 8)))) {
/** Find the end of the link */
int strlenptr;
linklen = 0;
strlenptr = strlen(ptr);
for (i=0; i<=strlenptr; ++i) {
if ((ptr[i]==0)
||(isspace(ptr[i]))
||(ptr[i]==10)
||(ptr[i]==13)
||(ptr[i]=='(')
||(ptr[i]==')')
||(ptr[i]=='<')
||(ptr[i]=='>')
||(ptr[i]=='[')
||(ptr[i]==']')
||(ptr[i]=='"')
||(ptr[i]=='\'')
) linklen = i;
/* did s.b. send us an entity? */
if (ptr[i] == '&') {
if ((ptr[i+2] ==';') ||
(ptr[i+3] ==';') ||
(ptr[i+5] ==';') ||
(ptr[i+6] ==';') ||
(ptr[i+7] ==';'))
linklen = i;
}
if (linklen > 0) break;
}
if (linklen > 0) {
char *ltreviewptr;
char *nbspreviewptr;
char linkedchar;
int len;
len = linklen;
linkedchar = ptr[len];
ptr[len] = '\0';
/* spot for some subject strings tinymce tends to give us. */
ltreviewptr = strchr(ptr, '<');
if (ltreviewptr != NULL) {
*ltreviewptr = '\0';
linklen = ltreviewptr - ptr;
}
nbspreviewptr = strstr(ptr, " ");
if (nbspreviewptr != NULL) {
/* nbspreviewptr = '\0'; */
linklen = nbspreviewptr - ptr;
}
if (ltreviewptr != 0)
*ltreviewptr = '<';
ptr[len] = linkedchar;
content_length += (32 + linklen);
StrBufAppendPrintf(converted_msg, "%s\"", new_window);
StrBufAppendBufPlain(converted_msg, ptr, linklen, 0);
StrBufAppendPrintf(converted_msg, "\">");
StrBufAppendBufPlain(converted_msg, ptr, linklen, 0);
ptr += linklen;
StrBufAppendPrintf(converted_msg, "</A>");
}
}
else {
StrBufAppendBufPlain(converted_msg, ptr, 1, 0);
ptr++;
}
if ((ptr >= msg) && (ptr <= msgend)) {
/*
* We need to know when we're inside a tag,
* so we don't turn things that look like URL's into
* links, when they're already links - or image sources.
*/
if ((ptr > msg) && (*(ptr-1) == '<')) {
++brak;
}
if ((ptr > msg) && (*(ptr-1) == '>')) {
--brak;
if ((scriptlevel == 0) && (script_start_pos >= 0)) {
StrBufCutRight(converted_msg, StrLength(converted_msg) - script_start_pos);
script_start_pos = (-1);
}
}
if (!strncasecmp(ptr, "</A>", 3)) --alevel;
}
}
if (BodyArea != NULL) {
StrBufAppendBufPlain(converted_msg, HKEY("</td></tr></table>"), 0);
FreeStrBuf(&BodyArea);
}
/** uncomment these two lines to override conversion */
/** memcpy(converted_msg, msg, content_length); */
/** output_length = content_length; */
/** Output our big pile of markup */
StrBufAppendBuf(Target, converted_msg, 0);
BAIL: /** A little trailing vertical whitespace... */
StrBufAppendPrintf(Target, "<br><br>\n");
/** Now give back the memory */
FreeStrBuf(&converted_msg);
if ((msg != NULL) && (Source == NULL)) free(msg);
}
/*
* The pathname is always going to take one of two formats:
* [/groupdav/]room_name/euid (GroupDAV)
* [/groupdav/]room_name (webcal)
*/
void dav_put(void)
{
wcsession *WCC = WC;
StrBuf *dav_roomname;
StrBuf *dav_uid;
long new_msgnum = (-2L);
long old_msgnum = (-1L);
char buf[SIZ];
int n = 0;
if (StrBufNum_tokens(WCC->Hdr->HR.ReqLine, '/') < 2) {
hprintf("HTTP/1.1 404 not found\r\n");
dav_common_headers();
hprintf("Content-Type: text/plain\r\n");
begin_burst();
wc_printf("The object you requested was not found.\r\n");
end_burst();
return;
}
dav_roomname = NewStrBuf();;
dav_uid = NewStrBuf();;
StrBufExtract_token(dav_roomname, WCC->Hdr->HR.ReqLine, 0, '/');
StrBufExtract_token(dav_uid, WCC->Hdr->HR.ReqLine, 1, '/');
if ((!strcasecmp(ChrPtr(dav_uid), "ics")) ||
(!strcasecmp(ChrPtr(dav_uid), "calendar.ics"))) {
FlushStrBuf(dav_uid);
}
/* Go to the correct room. */
if (strcasecmp(ChrPtr(WC->CurRoom.name), ChrPtr(dav_roomname))) {
gotoroom(dav_roomname);
}
if (strcasecmp(ChrPtr(WC->CurRoom.name), ChrPtr(dav_roomname))) {
hprintf("HTTP/1.1 404 not found\r\n");
dav_common_headers();
hprintf("Content-Type: text/plain\r\n");
begin_burst();
wc_printf("There is no folder called \"%s\" on this server.\r\n",
ChrPtr(dav_roomname));
end_burst();
FreeStrBuf(&dav_roomname);
FreeStrBuf(&dav_uid);
return;
}
/*
* If an HTTP If-Match: header is present, the client is attempting
* to replace an existing item. We have to check to see if the
* message number associated with the supplied uid matches what the
* client is expecting. If not, the server probably contains a newer
* version, so we fail...
*/
if (StrLength(WCC->Hdr->HR.dav_ifmatch) > 0) {
syslog(LOG_DEBUG, "dav_ifmatch: %s\n", ChrPtr(WCC->Hdr->HR.dav_ifmatch));
old_msgnum = locate_message_by_uid(ChrPtr(dav_uid));
syslog(LOG_DEBUG, "old_msgnum: %ld\n", old_msgnum);
if (StrTol(WCC->Hdr->HR.dav_ifmatch) != old_msgnum) {
hprintf("HTTP/1.1 412 Precondition Failed\r\n");
syslog(LOG_INFO, "HTTP/1.1 412 Precondition Failed (ifmatch=%ld, old_msgnum=%ld)\r\n",
StrTol(WCC->Hdr->HR.dav_ifmatch), old_msgnum);
dav_common_headers();
end_burst();
FreeStrBuf(&dav_roomname);
FreeStrBuf(&dav_uid);
return;
}
}
/** PUT on the collection itself uploads an ICS of the entire collection.
*/
if (StrLength(dav_uid) == 0) {
dav_put_bigics();
FreeStrBuf(&dav_roomname);
FreeStrBuf(&dav_uid);
return;
}
/*
* We are cleared for upload! We use the new calling syntax for ENT0
* which allows a confirmation to be sent back to us. That's how we
* extract the message ID.
*/
serv_puts("ENT0 1|||4|||1|");
serv_getln(buf, sizeof buf);
if (buf[0] != '8') {
hprintf("HTTP/1.1 502 Bad Gateway\r\n");
dav_common_headers();
hprintf("Content-type: text/plain\r\n");
begin_burst();
wc_printf("%s\r\n", &buf[4]);
end_burst();
return;
}
/* Send the content to the Citadel server */
//serv_printf("Content-type: %s\n\n", WCC->upload_content_type);
serv_putbuf(WCC->upload);
serv_puts("\n000");
/* Fetch the reply from the Citadel server */
n = 0;
FlushStrBuf(dav_uid);
while (serv_getln(buf, sizeof buf), strcmp(buf, "000")) {
switch(n++) {
case 0:
new_msgnum = atol(buf);
break;
case 1:
syslog(LOG_DEBUG, "new_msgnum=%ld (%s)\n", new_msgnum, buf);
break;
case 2:
StrBufAppendBufPlain(dav_uid, buf, -1, 0);
break;
default:
break;
}
}
/* Tell the client what happened. */
/* Citadel failed in some way? */
if (new_msgnum < 0L) {
hprintf("HTTP/1.1 502 Bad Gateway\r\n");
dav_common_headers();
hprintf("Content-type: text/plain\r\n");
begin_burst();
wc_printf("new_msgnum is %ld\r\n"
"\r\n", new_msgnum);
end_burst();
FreeStrBuf(&dav_roomname);
FreeStrBuf(&dav_uid);
return;
}
/* We created this item for the first time. */
if (old_msgnum < 0L) {
char escaped_uid[1024];
hprintf("HTTP/1.1 201 Created\r\n");
syslog(LOG_DEBUG, "HTTP/1.1 201 Created\r\n");
dav_common_headers();
hprintf("etag: \"%ld\"\r\n", new_msgnum);
hprintf("Location: ");
dav_identify_hosthdr();
hprintf("/groupdav/");/* TODO */
hurlescputs(ChrPtr(dav_roomname));
euid_escapize(escaped_uid, ChrPtr(dav_uid));
hprintf("/%s\r\n", escaped_uid);
end_burst();
FreeStrBuf(&dav_roomname);
FreeStrBuf(&dav_uid);
return;
}
/* We modified an existing item. */
hprintf("HTTP/1.1 204 No Content\r\n");
syslog(LOG_DEBUG, "HTTP/1.1 204 No Content\r\n");
dav_common_headers();
hprintf("Etag: \"%ld\"\r\n", new_msgnum);
/* The item we replaced has probably already been deleted by
* the Citadel server, but we'll do this anyway, just in case.
*/
serv_printf("DELE %ld", old_msgnum);
serv_getln(buf, sizeof buf);
begin_burst();
end_burst();
FreeStrBuf(&dav_roomname);
FreeStrBuf(&dav_uid);
return;
}
/*
* This function handles the logging of instant messages to disk.
*/
void log_instant_message(struct CitContext *me, struct CitContext *them, char *msgtext, int serial_number)
{
long usernums[2];
long t;
struct imlog *iptr = NULL;
struct imlog *this_im = NULL;
memset(usernums, 0, sizeof usernums);
usernums[0] = me->user.usernum;
usernums[1] = them->user.usernum;
/* Always put the lower user number first, so we can use the array as a hash value which
* represents a pair of users. For a broadcast message one of the users will be 0.
*/
if (usernums[0] > usernums[1]) {
t = usernums[0];
usernums[0] = usernums[1];
usernums[1] = t;
}
begin_critical_section(S_IM_LOGS);
/* Look for an existing conversation in the hash table.
* If not found, create a new one.
*/
this_im = NULL;
for (iptr = imlist; iptr != NULL; iptr = iptr->next) {
if ((iptr->usernums[0] == usernums[0]) && (iptr->usernums[1] == usernums[1])) {
/* Existing conversation */
this_im = iptr;
}
}
if (this_im == NULL) {
/* New conversation */
this_im = malloc(sizeof(struct imlog));
memset(this_im, 0, sizeof (struct imlog));
this_im->usernums[0] = usernums[0];
this_im->usernums[1] = usernums[1];
/* usernames[] and usernums[] might not be in the same order. This is not an error. */
if (me) {
safestrncpy(this_im->usernames[0], me->user.fullname, sizeof this_im->usernames[0]);
}
if (them) {
safestrncpy(this_im->usernames[1], them->user.fullname, sizeof this_im->usernames[1]);
}
this_im->conversation = NewStrBuf();
this_im->next = imlist;
imlist = this_im;
StrBufAppendBufPlain(this_im->conversation, HKEY(
"<html><body>\r\n"
), 0);
}
/* Since it's possible for this function to get called more than once if a user is logged
* in on multiple sessions, we use the message's serial number to keep track of whether
* we've already logged it.
*/
if (this_im->last_serial != serial_number)
{
this_im->lastmsg = time(NULL); /* Touch the timestamp so we know when to flush */
this_im->last_serial = serial_number;
StrBufAppendBufPlain(this_im->conversation, HKEY("<p><b>"), 0);
StrBufAppendBufPlain(this_im->conversation, me->user.fullname, -1, 0);
StrBufAppendBufPlain(this_im->conversation, HKEY(":</b> "), 0);
StrEscAppend(this_im->conversation, NULL, msgtext, 0, 0);
StrBufAppendBufPlain(this_im->conversation, HKEY("</p>\r\n"), 0);
}
end_critical_section(S_IM_LOGS);
}
int CtdlNetworkTalkingTo(const char *nodename, long len, int operation)
{
int retval = 0;
HashPos *Pos = NULL;
void *vdata;
begin_critical_section(S_NTTLIST);
switch(operation) {
case NTT_ADD:
if (nttlist == NULL)
nttlist = NewHash(1, NULL);
Put(nttlist, nodename, len, NewStrBufPlain(nodename, len), HFreeStrBuf);
if (NTTDebugEnabled) syslog(LOG_DEBUG, "nttlist: added <%s>\n", nodename);
break;
case NTT_REMOVE:
if ((nttlist == NULL) ||
(GetCount(nttlist) == 0))
break;
Pos = GetNewHashPos(nttlist, 1);
if (GetHashPosFromKey (nttlist, nodename, len, Pos))
DeleteEntryFromHash(nttlist, Pos);
DeleteHashPos(&Pos);
if (NTTDebugEnabled) syslog(LOG_DEBUG, "nttlist: removed <%s>\n", nodename);
break;
case NTT_CHECK:
if ((nttlist == NULL) ||
(GetCount(nttlist) == 0))
break;
if (GetHash(nttlist, nodename, len, &vdata))
retval ++;
if (NTTDebugEnabled) syslog(LOG_DEBUG, "nttlist: have [%d] <%s>\n", retval, nodename);
break;
}
if (NTTDumpEnabled)
{
HashPos *It;
StrBuf *NTTDump;
long len;
const char *Key;
void *v;
NTTDump = NewStrBuf ();
It = GetNewHashPos(nttlist, 0);
while (GetNextHashPos(nttlist, It, &len, &Key, &v))
{
if (StrLength(NTTDump) > 0)
StrBufAppendBufPlain(NTTDump, HKEY("|"), 0);
StrBufAppendBuf(NTTDump, (StrBuf*) v, 0);
}
DeleteHashPos(&It);
syslog(LOG_DEBUG, "nttlist: Dump: [%d] <%s>\n",
GetCount(nttlist),
ChrPtr(NTTDump));
FreeStrBuf(&NTTDump);
}
end_critical_section(S_NTTLIST);
return(retval);
}
/*
* Setup an OpenID authentication
*/
void cmd_oids(char *argbuf) {
struct CitContext *CCC = CC; /* CachedCitContext - performance boost */
const char *Pos = NULL;
StrBuf *ArgBuf = NULL;
StrBuf *ReplyBuf = NULL;
StrBuf *return_to = NULL;
StrBuf *RedirectUrl = NULL;
ctdl_openid *oiddata;
int discovery_succeeded = 0;
if (config.c_disable_newu)
{
cprintf("%d this system does not support openid.\n",
ERROR + CMD_NOT_SUPPORTED);
return;
}
Free_ctdl_openid ((ctdl_openid**)&CCC->openid_data);
CCC->openid_data = oiddata = malloc(sizeof(ctdl_openid));
if (oiddata == NULL) {
syslog(LOG_ALERT, "malloc() failed: %s", strerror(errno));
cprintf("%d malloc failed\n", ERROR + INTERNAL_ERROR);
return;
}
memset(oiddata, 0, sizeof(ctdl_openid));
ArgBuf = NewStrBufPlain(argbuf, -1);
oiddata->verified = 0;
oiddata->claimed_id = NewStrBufPlain(NULL, StrLength(ArgBuf));
return_to = NewStrBufPlain(NULL, StrLength(ArgBuf));
StrBufExtract_NextToken(oiddata->claimed_id, ArgBuf, &Pos, '|');
StrBufExtract_NextToken(return_to, ArgBuf, &Pos, '|');
syslog(LOG_DEBUG, "User-Supplied Identifier is: %s", ChrPtr(oiddata->claimed_id));
/********** OpenID 2.0 section 7.3 - Discovery **********/
/* Section 7.3.1 says we have to attempt XRI based discovery.
* No one is using this, no one is asking for it, no one wants it.
* So we're not even going to bother attempting this mode.
*/
/* Attempt section 7.3.2 (Yadis discovery) and section 7.3.3 (HTML discovery);
*/
discovery_succeeded = perform_openid2_discovery(oiddata->claimed_id);
if (discovery_succeeded == 0) {
cprintf("%d There is no OpenID identity provider at this location.\n", ERROR);
}
else {
/*
* If we get to this point we are in possession of a valid OpenID Provider URL.
*/
syslog(LOG_DEBUG, "OP URI '%s' discovered using method %d",
ChrPtr(oiddata->op_url),
discovery_succeeded
);
/* We have to "normalize" our Claimed ID otherwise it will cause some OP's to barf */
if (cbmstrcasestr(ChrPtr(oiddata->claimed_id), "://") == NULL) {
StrBuf *cid = oiddata->claimed_id;
oiddata->claimed_id = NewStrBufPlain(HKEY("http://"));
StrBufAppendBuf(oiddata->claimed_id, cid, 0);
FreeStrBuf(&cid);
}
/*
* OpenID 2.0 section 9: request authentication
* Assemble a URL to which the user-agent will be redirected.
*/
RedirectUrl = NewStrBufDup(oiddata->op_url);
StrBufAppendBufPlain(RedirectUrl, HKEY("?openid.ns="), 0);
StrBufUrlescAppend(RedirectUrl, NULL, "http://specs.openid.net/auth/2.0");
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.mode=checkid_setup"), 0);
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.claimed_id="), 0);
StrBufUrlescAppend(RedirectUrl, oiddata->claimed_id, NULL);
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.identity="), 0);
StrBufUrlescAppend(RedirectUrl, oiddata->claimed_id, NULL);
/* return_to tells the provider how to complete the round trip back to our site */
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.return_to="), 0);
StrBufUrlescAppend(RedirectUrl, return_to, NULL);
/* Attribute Exchange
* See:
* http://openid.net/specs/openid-attribute-exchange-1_0.html
* http://code.google.com/apis/accounts/docs/OpenID.html#endpoint
* http://test-id.net/OP/AXFetch.aspx
*/
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ns.ax="), 0);
StrBufUrlescAppend(RedirectUrl, NULL, "http://openid.net/srv/ax/1.0");
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ax.mode=fetch_request"), 0);
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ax.required=firstname,lastname,friendly,nickname"), 0);
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ax.type.firstname="), 0);
StrBufUrlescAppend(RedirectUrl, NULL, "http://axschema.org/namePerson/first");
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ax.type.lastname="), 0);
StrBufUrlescAppend(RedirectUrl, NULL, "http://axschema.org/namePerson/last");
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ax.type.friendly="), 0);
StrBufUrlescAppend(RedirectUrl, NULL, "http://axschema.org/namePerson/friendly");
StrBufAppendBufPlain(RedirectUrl, HKEY("&openid.ax.type.nickname="), 0);
StrBufUrlescAppend(RedirectUrl, NULL, "http://axschema.org/namePerson/nickname");
syslog(LOG_DEBUG, "OpenID: redirecting client to %s", ChrPtr(RedirectUrl));
cprintf("%d %s\n", CIT_OK, ChrPtr(RedirectUrl));
}
FreeStrBuf(&ArgBuf);
FreeStrBuf(&ReplyBuf);
FreeStrBuf(&return_to);
FreeStrBuf(&RedirectUrl);
}
/*
* This is the back end for flush_conversations_to_disk()
* At this point we've isolated a single conversation (struct imlog)
* and are ready to write it to disk.
*/
void flush_individual_conversation(struct imlog *im) {
struct CtdlMessage *msg;
long msgnum = 0;
char roomname[ROOMNAMELEN];
StrBuf *MsgBuf, *FullMsgBuf;
StrBufAppendBufPlain(im->conversation, HKEY(
"</body>\r\n"
"</html>\r\n"
), 0
);
MsgBuf = StrBufRFC2047encodeMessage(im->conversation);
FlushStrBuf(im->conversation);
FullMsgBuf = NewStrBufPlain(NULL, StrLength(im->conversation) + 100);
StrBufAppendBufPlain(FullMsgBuf, HKEY(
"Content-type: text/html; charset=UTF-8\r\n"
"Content-Transfer-Encoding: quoted-printable\r\n"
"\r\n"
), 0);
StrBufAppendBuf (FullMsgBuf, MsgBuf, 0);
FreeStrBuf(&MsgBuf);
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 = FMT_RFC822;
if (!IsEmptyStr(im->usernames[0])) {
CM_SetField(msg, eAuthor, im->usernames[0], strlen(im->usernames[0]));
} else {
CM_SetField(msg, eAuthor, HKEY("Citadel"));
}
if (!IsEmptyStr(im->usernames[1])) {
CM_SetField(msg, eRecipient, im->usernames[1], strlen(im->usernames[1]));
}
CM_SetField(msg, eOriginalRoom, HKEY(PAGELOGROOM));
CM_SetField(msg, eNodeName, CFG_KEY(c_nodename));
CM_SetAsFieldSB(msg, eMesageText, &FullMsgBuf); /* we own this memory now */
/* Start with usernums[1] because it's guaranteed to be higher than usernums[0],
* so if there's only one party, usernums[0] will be zero but usernums[1] won't.
* Create the room if necessary. Note that we create as a type 5 room rather
* than 4, which indicates that it's a personal room but we've already supplied
* the namespace prefix.
*
* In the unlikely event that usernums[1] is zero, a room with an invalid namespace
* prefix will be created. That's ok because the auto-purger will clean it up later.
*/
snprintf(roomname, sizeof roomname, "%010ld.%s", im->usernums[1], PAGELOGROOM);
CtdlCreateRoom(roomname, 5, "", 0, 1, 1, VIEW_BBS);
msgnum = CtdlSubmitMsg(msg, NULL, roomname, 0);
CM_Free(msg);
/* If there is a valid user number in usernums[0], save a copy for them too. */
if (im->usernums[0] > 0) {
snprintf(roomname, sizeof roomname, "%010ld.%s", im->usernums[0], PAGELOGROOM);
CtdlCreateRoom(roomname, 5, "", 0, 1, 1, VIEW_BBS);
CtdlSaveMsgPointerInRoom(roomname, msgnum, 0, NULL);
}
/* Finally, if we're logging instant messages globally, do that now. */
if (!IsEmptyStr(config.c_logpages)) {
CtdlCreateRoom(config.c_logpages, 3, "", 0, 1, 1, VIEW_BBS);
CtdlSaveMsgPointerInRoom(config.c_logpages, msgnum, 0, NULL);
}
}
void xrds_xml_chardata(void *data, const XML_Char *s, int len) {
struct xrds *xrds = (struct xrds *) data;
StrBufAppendBufPlain (xrds->CharData, s, len, 0);
}
/*
* smtp_do_bounce() is caled by smtp_do_procmsg() to scan a set of delivery
* instructions for "5" codes (permanent fatal errors) and produce/deliver
* a "bounce" message (delivery status notification).
*/
void smtpq_do_bounce(OneQueItem *MyQItem, StrBuf *OMsgTxt, ParsedURL *Relay)
{
static int seq = 0;
struct CtdlMessage *bmsg = NULL;
StrBuf *boundary;
StrBuf *Msg = NULL;
StrBuf *BounceMB;
recptypes *valid;
time_t now;
HashPos *It;
void *vQE;
long len;
const char *Key;
int first_attempt = 0;
int successful_bounce = 0;
int num_bounces = 0;
int give_up = 0;
SMTPCM_syslog(LOG_DEBUG, "smtp_do_bounce() called\n");
if (MyQItem->SendBounceMail == 0)
return;
now = time (NULL); //ev_time();
if ( (now - MyQItem->Submitted) > SMTP_GIVE_UP ) {
give_up = 1;
}
if (MyQItem->Retry == SMTP_RETRY_INTERVAL) {
first_attempt = 1;
}
/*
* Now go through the instructions checking for stuff.
*/
Msg = NewStrBufPlain(NULL, 1024);
It = GetNewHashPos(MyQItem->MailQEntries, 0);
while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE))
{
MailQEntry *ThisItem = vQE;
if ((ThisItem->Active && (ThisItem->Status == 5)) || /* failed now? */
((give_up == 1) && (ThisItem->Status != 2)) ||
((first_attempt == 1) && (ThisItem->Status != 2)))
/* giving up after failed attempts... */
{
++num_bounces;
StrBufAppendBufPlain(Msg, HKEY(" "), 0);
StrBufAppendBuf(Msg, ThisItem->Recipient, 0);
StrBufAppendBufPlain(Msg, HKEY(": "), 0);
if (ThisItem->AllStatusMessages != NULL)
StrBufAppendBuf(Msg, ThisItem->AllStatusMessages, 0);
else
StrBufAppendBuf(Msg, ThisItem->StatusMessage, 0);
StrBufAppendBufPlain(Msg, HKEY("\r\n"), 0);
}
}
DeleteHashPos(&It);
/* Deliver the bounce if there's anything worth mentioning */
SMTPC_syslog(LOG_DEBUG, "num_bounces = %d\n", num_bounces);
if (num_bounces == 0) {
FreeStrBuf(&Msg);
return;
}
if ((StrLength(MyQItem->SenderRoom) == 0) && MyQItem->HaveRelay) {
const char *RelayUrlStr = "[not found]";
/* one message that relaying is broken is enough; no extra room error message. */
StrBuf *RelayDetails = NewStrBuf();
if (Relay != NULL)
RelayUrlStr = ChrPtr(Relay->URL);
StrBufPrintf(RelayDetails,
"Relaying via %s failed permanently. \n Reason:\n%s\n Revalidate your relay configuration.",
RelayUrlStr,
ChrPtr(Msg));
CtdlAideMessage(ChrPtr(RelayDetails), "Relaying Failed");
FreeStrBuf(&RelayDetails);
}
boundary = NewStrBufPlain(HKEY("=_Citadel_Multipart_"));
StrBufAppendPrintf(boundary,
"%s_%04x%04x",
CtdlGetConfigStr("c_fqdn"),
getpid(),
++seq);
/* Start building our bounce message; go shopping for memory first. */
BounceMB = NewStrBufPlain(
NULL,
1024 + /* mime stuff.... */
StrLength(Msg) + /* the bounce information... */
StrLength(OMsgTxt)); /* the original message */
if (BounceMB == NULL) {
FreeStrBuf(&boundary);
SMTPCM_syslog(LOG_ERR, "Failed to alloc() bounce message.\n");
return;
}
bmsg = (struct CtdlMessage *) malloc(sizeof(struct CtdlMessage));
if (bmsg == NULL) {
FreeStrBuf(&boundary);
FreeStrBuf(&BounceMB);
SMTPCM_syslog(LOG_ERR, "Failed to alloc() bounce message.\n");
return;
}
memset(bmsg, 0, sizeof(struct CtdlMessage));
StrBufAppendBufPlain(BounceMB, HKEY("Content-type: multipart/mixed; boundary=\""), 0);
StrBufAppendBuf(BounceMB, boundary, 0);
StrBufAppendBufPlain(BounceMB, HKEY("\"\r\n"), 0);
StrBufAppendBufPlain(BounceMB, HKEY("MIME-Version: 1.0\r\n"), 0);
StrBufAppendBufPlain(BounceMB, HKEY("X-Mailer: " CITADEL "\r\n"), 0);
StrBufAppendBufPlain(BounceMB, HKEY("\r\nThis is a multipart message in MIME format.\r\n\r\n"), 0);
StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
StrBufAppendBuf(BounceMB, boundary, 0);
StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
StrBufAppendBufPlain(BounceMB, HKEY("Content-type: text/plain\r\n\r\n"), 0);
if (give_up)
StrBufAppendBufPlain(
BounceMB,
HKEY(
"A message you sent could not be delivered "
"to some or all of its recipients\n"
"due to prolonged unavailability "
"of its destination(s).\n"
"Giving up on the following addresses:\n\n"
), 0);
else
StrBufAppendBufPlain(
BounceMB,
HKEY(
"A message you sent could not be delivered "
"to some or all of its recipients.\n"
"The following addresses "
"were undeliverable:\n\n"
), 0);
StrBufAppendBuf(BounceMB, Msg, 0);
FreeStrBuf(&Msg);
if (StrLength(MyQItem->SenderRoom) > 0)
{
StrBufAppendBufPlain(
BounceMB,
HKEY("The message was originaly posted in: "), 0);
StrBufAppendBuf(BounceMB, MyQItem->SenderRoom, 0);
StrBufAppendBufPlain(
BounceMB,
HKEY("\n"), 0);
}
/* Attach the original message */
StrBufAppendBufPlain(BounceMB, HKEY("\r\n--"), 0);
StrBufAppendBuf(BounceMB, boundary, 0);
StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
StrBufAppendBufPlain(BounceMB,
HKEY("Content-type: message/rfc822\r\n"), 0);
StrBufAppendBufPlain(BounceMB,
HKEY("Content-Transfer-Encoding: 7bit\r\n"), 0);
StrBufAppendBufPlain(BounceMB,
HKEY("Content-Disposition: inline\r\n"), 0);
StrBufAppendBufPlain(BounceMB, HKEY("\r\n"), 0);
StrBufAppendBuf(BounceMB, OMsgTxt, 0);
/* Close the multipart MIME scope */
StrBufAppendBufPlain(BounceMB, HKEY("--"), 0);
StrBufAppendBuf(BounceMB, boundary, 0);
StrBufAppendBufPlain(BounceMB, HKEY("--\r\n"), 0);
bmsg->cm_magic = CTDLMESSAGE_MAGIC;
bmsg->cm_anon_type = MES_NORMAL;
bmsg->cm_format_type = FMT_RFC822;
CM_SetField(bmsg, eOriginalRoom, HKEY(MAILROOM));
CM_SetField(bmsg, eAuthor, HKEY("Citadel"));
CM_SetField(bmsg, eNodeName, CtdlGetConfigStr("c_nodename"), strlen(CtdlGetConfigStr("c_nodename")));
CM_SetField(bmsg, eMsgSubject, HKEY("Delivery Status Notification (Failure)"));
CM_SetAsFieldSB(bmsg, eMesageText, &BounceMB);
/* First try the user who sent the message */
if (StrLength(MyQItem->BounceTo) == 0) {
SMTPCM_syslog(LOG_ERR, "No bounce address specified\n");
}
else {
SMTPC_syslog(LOG_DEBUG, "bounce to user? <%s>\n",
ChrPtr(MyQItem->BounceTo));
}
/* Can we deliver the bounce to the original sender? */
valid = validate_recipients(ChrPtr(MyQItem->BounceTo), NULL, 0);
if ((valid != NULL) && (valid->num_error == 0)) {
CtdlSubmitMsg(bmsg, valid, "", QP_EADDR);
successful_bounce = 1;
}
/* If not, post it in the Aide> room */
if (successful_bounce == 0) {
CtdlSubmitMsg(bmsg, NULL, CtdlGetConfigStr("c_aideroom"), QP_EADDR);
}
/* Free up the memory we used */
free_recipients(valid);
FreeStrBuf(&boundary);
CM_Free(bmsg);
SMTPCM_syslog(LOG_DEBUG, "Done processing bounces\n");
}
StrBuf *SerializeQueueItem(OneQueItem *MyQItem)
{
StrBuf *QMessage;
HashPos *It;
const char *Key;
long len;
void *vQE;
QMessage = NewStrBufPlain(NULL, SIZ);
StrBufPrintf(QMessage, "Content-type: %s\n", SPOOLMIME);
// "attempted|%ld\n" "retry|%ld\n",, (long)time(NULL), (long)retry );
StrBufAppendBufPlain(QMessage, HKEY("\nmsgid|"), 0);
StrBufAppendPrintf(QMessage, "%ld", MyQItem->MessageID);
StrBufAppendBufPlain(QMessage, HKEY("\nsubmitted|"), 0);
StrBufAppendPrintf(QMessage, "%ld", MyQItem->Submitted);
if (StrLength(MyQItem->BounceTo) > 0) {
StrBufAppendBufPlain(QMessage, HKEY("\nbounceto|"), 0);
StrBufAppendBuf(QMessage, MyQItem->BounceTo, 0);
}
if (StrLength(MyQItem->EnvelopeFrom) > 0) {
StrBufAppendBufPlain(QMessage, HKEY("\nenvelope_from|"), 0);
StrBufAppendBuf(QMessage, MyQItem->EnvelopeFrom, 0);
}
if (StrLength(MyQItem->SenderRoom) > 0) {
StrBufAppendBufPlain(QMessage, HKEY("\nsource_room|"), 0);
StrBufAppendBuf(QMessage, MyQItem->SenderRoom, 0);
}
StrBufAppendBufPlain(QMessage, HKEY("\nretry|"), 0);
StrBufAppendPrintf(QMessage, "%ld",
MyQItem->Retry);
StrBufAppendBufPlain(QMessage, HKEY("\nattempted|"), 0);
StrBufAppendPrintf(QMessage, "%ld",
time(NULL) /*ctdl_ev_now()*/ + MyQItem->Retry);
It = GetNewHashPos(MyQItem->MailQEntries, 0);
while (GetNextHashPos(MyQItem->MailQEntries, It, &len, &Key, &vQE))
{
MailQEntry *ThisItem = vQE;
StrBufAppendBufPlain(QMessage, HKEY("\nremote|"), 0);
StrBufAppendBuf(QMessage, ThisItem->Recipient, 0);
StrBufAppendBufPlain(QMessage, HKEY("|"), 0);
StrBufAppendPrintf(QMessage, "%d", ThisItem->Status);
StrBufAppendBufPlain(QMessage, HKEY("|"), 0);
if (ThisItem->AllStatusMessages != NULL)
StrBufAppendBuf(QMessage, ThisItem->AllStatusMessages, 0);
else
StrBufAppendBuf(QMessage, ThisItem->StatusMessage, 0);
}
DeleteHashPos(&It);
StrBufAppendBufPlain(QMessage, HKEY("\n"), 0);
return QMessage;
}
int smtp_aftersave(struct CtdlMessage *msg,
recptypes *recps)
{
/* For internet mail, generate delivery instructions.
* Yes, this is recursive. Deal with it. Infinite recursion does
* not happen because the delivery instructions message does not
* contain a recipient.
*/
if ((recps != NULL) && (recps->num_internet > 0)) {
struct CtdlMessage *imsg = NULL;
char recipient[SIZ];
CitContext *CCC = MyContext();
StrBuf *SpoolMsg = NewStrBuf();
long nTokens;
int i;
MSGM_syslog(LOG_DEBUG, "Generating delivery instructions\n");
StrBufPrintf(SpoolMsg,
"Content-type: "SPOOLMIME"\n"
"\n"
"msgid|%s\n"
"submitted|%ld\n"
"bounceto|%s\n",
msg->cm_fields[eVltMsgNum],
(long)time(NULL),
recps->bounce_to);
if (recps->envelope_from != NULL) {
StrBufAppendBufPlain(SpoolMsg, HKEY("envelope_from|"), 0);
StrBufAppendBufPlain(SpoolMsg, recps->envelope_from, -1, 0);
StrBufAppendBufPlain(SpoolMsg, HKEY("\n"), 0);
}
if (recps->sending_room != NULL) {
StrBufAppendBufPlain(SpoolMsg, HKEY("source_room|"), 0);
StrBufAppendBufPlain(SpoolMsg, recps->sending_room, -1, 0);
StrBufAppendBufPlain(SpoolMsg, HKEY("\n"), 0);
}
nTokens = num_tokens(recps->recp_internet, '|');
for (i = 0; i < nTokens; i++) {
long len;
len = extract_token(recipient, recps->recp_internet, i, '|', sizeof recipient);
if (len > 0) {
StrBufAppendBufPlain(SpoolMsg, HKEY("remote|"), 0);
StrBufAppendBufPlain(SpoolMsg, recipient, len, 0);
StrBufAppendBufPlain(SpoolMsg, HKEY("|0||\n"), 0);
}
}
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;
CM_SetField(imsg, eMsgSubject, HKEY("QMSG"));
CM_SetField(imsg, eAuthor, HKEY("Citadel"));
CM_SetField(imsg, eJournal, HKEY("do not journal"));
CM_SetAsFieldSB(imsg, eMesageText, &SpoolMsg);
CtdlSubmitMsg(imsg, NULL, SMTP_SPOOLOUT_ROOM, QP_EADDR);
CM_Free(imsg);
}
return 0;
}
struct CtdlMessage *convert_internet_message_buf(StrBuf **rfc822)
{
struct CtdlMessage *msg;
const char *pos, *beg, *end, *totalend;
int done, alldone = 0;
int converted;
StrBuf *OtherHeaders;
msg = malloc(sizeof(struct CtdlMessage));
if (msg == NULL) return msg;
memset(msg, 0, sizeof(struct CtdlMessage));
msg->cm_magic = CTDLMESSAGE_MAGIC; /* self check */
msg->cm_anon_type = 0; /* never anonymous */
msg->cm_format_type = FMT_RFC822; /* internet message */
pos = ChrPtr(*rfc822);
totalend = pos + StrLength(*rfc822);
done = 0;
OtherHeaders = NewStrBufPlain(NULL, StrLength(*rfc822));
while (!alldone) {
/* Locate beginning and end of field, keeping in mind that
* some fields might be multiline
*/
end = beg = pos;
while ((end < totalend) &&
(end == beg) &&
(done == 0) )
{
if ( (*pos=='\n') && ((*(pos+1))!=0x20) && ((*(pos+1))!=0x09) )
{
end = pos;
}
/* done with headers? */
if ((*pos=='\n') &&
( (*(pos+1)=='\n') ||
(*(pos+1)=='\r')) )
{
alldone = 1;
}
if (pos >= (totalend - 1) )
{
end = pos;
done = 1;
}
++pos;
}
/* At this point we have a field. Are we interested in it? */
converted = convert_field(msg, beg, end);
/* Strip the field out of the RFC822 header if we used it */
if (!converted) {
StrBufAppendBufPlain(OtherHeaders, beg, end - beg, 0);
StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0);
}
/* If we've hit the end of the message, bail out */
if (pos >= totalend)
alldone = 1;
}
StrBufAppendBufPlain(OtherHeaders, HKEY("\n"), 0);
if (pos < totalend)
StrBufAppendBufPlain(OtherHeaders, pos, totalend - pos, 0);
FreeStrBuf(rfc822);
CM_SetAsFieldSB(msg, eMesageText, &OtherHeaders);
/* Follow-up sanity checks... */
/* If there's no timestamp on this message, set it to now. */
if (CM_IsEmpty(msg, eTimestamp)) {
CM_SetFieldLONG(msg, eTimestamp, time(NULL));
}
/* If a W (references, or rather, Wefewences) field is present, we
* have to convert it from RFC822 format to Citadel format.
*/
if (!CM_IsEmpty(msg, eWeferences)) {
/// todo: API!
convert_references_to_wefewences(msg->cm_fields[eWeferences]);
}
return msg;
}
