/*
* Hand off a copy of a message to be journalized.
*/
void JournalBackgroundSubmit(struct CtdlMessage *msg,
StrBuf *saved_rfc822_version,
recptypes *recps) {
struct jnlq *jptr = NULL;
/* Avoid double journaling! */
if (!CM_IsEmpty(msg, eJournal)) {
FreeStrBuf(&saved_rfc822_version);
return;
}
jptr = (struct jnlq *)malloc(sizeof(struct jnlq));
if (jptr == NULL) {
FreeStrBuf(&saved_rfc822_version);
return;
}
memset(jptr, 0, sizeof(struct jnlq));
if (recps != NULL) memcpy(&jptr->recps, recps, sizeof(recptypes));
if (!CM_IsEmpty(msg, eAuthor)) jptr->from = strdup(msg->cm_fields[eAuthor]);
if (!CM_IsEmpty(msg, eNodeName)) jptr->node = strdup(msg->cm_fields[eNodeName]);
if (!CM_IsEmpty(msg, erFc822Addr)) jptr->rfca = strdup(msg->cm_fields[erFc822Addr]);
if (!CM_IsEmpty(msg, eMsgSubject)) jptr->subj = strdup(msg->cm_fields[eMsgSubject]);
if (!CM_IsEmpty(msg, emessageId)) jptr->msgn = strdup(msg->cm_fields[emessageId]);
jptr->rfc822 = SmashStrBuf(&saved_rfc822_version);
/* Add to the queue */
begin_critical_section(S_JOURNAL_QUEUE);
jptr->next = jnlq;
jnlq = jptr;
end_critical_section(S_JOURNAL_QUEUE);
}
void render_MIME_VNote(StrBuf *Target, WCTemplputParams *TP, StrBuf *FoundCharset)
{
wc_mime_attachment *Mime = CTX(CTX_MIME_ATACH);
if (StrLength(Mime->Data) == 0)
MimeLoadData(Mime);
if (StrLength(Mime->Data) > 0) {
struct vnote *v;
StrBuf *Buf;
char *vcard;
Buf = NewStrBuf();
vcard = SmashStrBuf(&Mime->Data);
v = vnote_new_from_str(vcard);
free (vcard);
if (v) {
WCTemplputParams TP;
memset(&TP, 0, sizeof(WCTemplputParams));
TP.Filter.ContextType = CTX_VNOTE;
TP.Context = v;
DoTemplate(HKEY("mail_vnoteitem"),
Buf, &TP);
vnote_free(v);
Mime->Data = Buf;
}
else {
if (Mime->Data == NULL)
Mime->Data = NewStrBuf();
else
FlushStrBuf(Mime->Data);
}
}
}
int ReadPostData(void)
{
int rc;
int urlencoded_post = 0;
wcsession *WCC = WC;
StrBuf *content = NULL;
urlencoded_post = (strncasecmp(ChrPtr(WCC->Hdr->HR.ContentType), "application/x-www-form-urlencoded", 33) == 0) ;
content = NewStrBufPlain(NULL, WCC->Hdr->HR.ContentLength + 256);
if (!urlencoded_post)
{
StrBufPrintf(content,
"Content-type: %s\n"
"Content-length: %ld\n\n",
ChrPtr(WCC->Hdr->HR.ContentType),
WCC->Hdr->HR.ContentLength);
}
/** Read the entire input data at once. */
rc = client_read_to(WCC->Hdr, content,
WCC->Hdr->HR.ContentLength,
SLEEPING);
if (rc < 0)
return rc;
if (urlencoded_post) {
ParseURLParams(content);
} else if (!strncasecmp(ChrPtr(WCC->Hdr->HR.ContentType), "multipart", 9)) {
char *Buf;
char *BufEnd;
long len;
len = StrLength(content);
Buf = SmashStrBuf(&content);
BufEnd = Buf + len;
mime_parser(Buf, BufEnd, *upload_handler, NULL, NULL, NULL, 0);
free(Buf);
} else if (WCC->Hdr->HR.ContentLength > 0) {
WCC->upload = content;
WCC->upload_length = StrLength(WCC->upload);
content = NULL;
}
FreeStrBuf(&content);
return 1;
}
/*
* Fetch a message from the server and extract a vNote from it
*/
struct vnote *vnote_new_from_msg(long msgnum,int unread)
{
StrBuf *Buf;
StrBuf *Data = NULL;
const char *bptr;
int Done = 0;
char uid_from_headers[256];
char mime_partnum[256];
char mime_filename[256];
char mime_content_type[256];
char mime_disposition[256];
char relevant_partnum[256];
int phase = 0; /* 0 = citadel headers, 1 = mime headers, 2 = body */
char msg4_content_type[256] = "";
char msg4_content_encoding[256] = "";
int msg4_content_length = 0;
struct vnote *vnote_from_body = NULL;
int vnote_inline = 0; /* 1 = MSG4 gave us a text/x-vnote top level */
relevant_partnum[0] = '\0';
serv_printf("MSG4 %ld", msgnum); /* we need the mime headers */
Buf = NewStrBuf();
StrBuf_ServGetln(Buf);
if (GetServerStatus(Buf, NULL) != 1) {
FreeStrBuf (&Buf);
return NULL;
}
while ((StrBuf_ServGetln(Buf)>=0) && !Done) {
if ( (StrLength(Buf)==3) &&
!strcmp(ChrPtr(Buf), "000")) {
Done = 1;
break;
}
bptr = ChrPtr(Buf);
switch (phase) {
case 0:
if (!strncasecmp(bptr, "exti=", 5)) {
safestrncpy(uid_from_headers, &(ChrPtr(Buf)[5]), sizeof uid_from_headers);
}
else if (!strncasecmp(bptr, "part=", 5)) {
extract_token(mime_filename, &bptr[5], 1, '|', sizeof mime_filename);
extract_token(mime_partnum, &bptr[5], 2, '|', sizeof mime_partnum);
extract_token(mime_disposition, &bptr[5], 3, '|', sizeof mime_disposition);
extract_token(mime_content_type, &bptr[5], 4, '|', sizeof mime_content_type);
if (!strcasecmp(mime_content_type, "text/vnote")) {
strcpy(relevant_partnum, mime_partnum);
}
}
else if ((phase == 0) && (!strncasecmp(bptr, "text", 4))) {
phase = 1;
}
break;
case 1:
if (!IsEmptyStr(bptr)) {
if (!strncasecmp(bptr, "Content-type: ", 14)) {
safestrncpy(msg4_content_type, &bptr[14], sizeof msg4_content_type);
striplt(msg4_content_type);
}
else if (!strncasecmp(bptr, "Content-transfer-encoding: ", 27)) {
safestrncpy(msg4_content_encoding, &bptr[27], sizeof msg4_content_encoding);
striplt(msg4_content_type);
}
else if ((!strncasecmp(bptr, "Content-length: ", 16))) {
msg4_content_length = atoi(&bptr[16]);
}
break;
}
else {
phase++;
if ((msg4_content_length > 0)
&& ( !strcasecmp(msg4_content_encoding, "7bit"))
&& (!strcasecmp(msg4_content_type, "text/vnote"))
) {
vnote_inline = 1;
}
}
case 2:
if (vnote_inline) {
Data = NewStrBufPlain(NULL, msg4_content_length * 2);
if (msg4_content_length > 0) {
StrBuf_ServGetBLOBBuffered(Data, msg4_content_length);
phase ++;
}
else {
StrBufAppendBuf(Data, Buf, 0);
StrBufAppendBufPlain(Data, "\r\n", 1, 0);
}
}
case 3:
if (vnote_inline) {
StrBufAppendBuf(Data, Buf, 0);
}
}
}
FreeStrBuf(&Buf);
/* If MSG4 didn't give us the part we wanted, but we know that we can find it
* as one of the other MIME parts, attempt to load it now.
*/
if ((!vnote_inline) && (!IsEmptyStr(relevant_partnum))) {
Data = load_mimepart(msgnum, relevant_partnum);
}
if (StrLength(Data) > 0) {
if (IsEmptyStr(uid_from_headers)) {
/* Convert an old-style note to a vNote */
vnote_from_body = vnote_new();
vnote_from_body->uid = strdup(uid_from_headers);
vnote_from_body->color_red = pastel_palette[3][0];
vnote_from_body->color_green = pastel_palette[3][1];
vnote_from_body->color_blue = pastel_palette[3][2];
vnote_from_body->body = malloc(StrLength(Data) + 1);
vnote_from_body->body[0] = 0;
memcpy(vnote_from_body->body, ChrPtr(Data), StrLength(Data) + 1);
FreeStrBuf(&Data);
return vnote_from_body;
}
else {
char *Buf = SmashStrBuf(&Data);
struct vnote *v = vnote_new_from_str(Buf);
free(Buf);
return(v);
}
}
return NULL;
}
/*
* Index or de-index a message. (op == 1 to index, 0 to de-index)
*/
void ft_index_message(long msgnum, int op) {
int num_tokens = 0;
int *tokens = NULL;
int i, j;
struct cdbdata *cdb_bucket;
StrBuf *msgtext;
char *txt;
int tok;
struct CtdlMessage *msg = NULL;
msg = CtdlFetchMessage(msgnum, 1, 1);
if (msg == NULL) {
syslog(LOG_ERR, "ft_index_message() could not load msg %ld", msgnum);
return;
}
if (!CM_IsEmpty(msg, eSuppressIdx)) {
syslog(LOG_DEBUG, "ft_index_message() excluded msg %ld", msgnum);
CM_Free(msg);
return;
}
syslog(LOG_DEBUG, "ft_index_message() %s msg %ld", (op ? "adding" : "removing") , msgnum);
/* Output the message as text before indexing it, so we don't end up
* indexing a bunch of encoded base64, etc.
*/
CC->redirect_buffer = NewStrBufPlain(NULL, SIZ);
CtdlOutputPreLoadedMsg(msg, MT_CITADEL, HEADERS_ALL, 0, 1, 0);
CM_Free(msg);
msgtext = CC->redirect_buffer;
CC->redirect_buffer = NULL;
if (msgtext != NULL) {
syslog(LOG_DEBUG, "Wordbreaking message %ld (%d bytes)", msgnum, StrLength(msgtext));
}
txt = SmashStrBuf(&msgtext);
wordbreaker(txt, &num_tokens, &tokens);
free(txt);
syslog(LOG_DEBUG, "Indexing message %ld [%d tokens]", msgnum, num_tokens);
if (num_tokens > 0) {
for (i=0; i<num_tokens; ++i) {
/* Add the message to the relevant token bucket */
/* search for tokens[i] */
tok = tokens[i];
if ( (tok >= 0) && (tok <= 65535) ) {
/* fetch the bucket, Liza */
if (ftc_msgs[tok] == NULL) {
cdb_bucket = cdb_fetch(CDB_FULLTEXT, &tok, sizeof(int));
if (cdb_bucket != NULL) {
ftc_num_msgs[tok] = cdb_bucket->len / sizeof(long);
ftc_msgs[tok] = (long *)cdb_bucket->ptr;
cdb_bucket->ptr = NULL;
cdb_free(cdb_bucket);
}
else {
ftc_num_msgs[tok] = 0;
ftc_msgs[tok] = malloc(sizeof(long));
}
}
if (op == 1) { /* add to index */
++ftc_num_msgs[tok];
ftc_msgs[tok] = realloc(ftc_msgs[tok],
ftc_num_msgs[tok]*sizeof(long));
ftc_msgs[tok][ftc_num_msgs[tok] - 1] = msgnum;
}
if (op == 0) { /* remove from index */
if (ftc_num_msgs[tok] >= 1) {
for (j=0; j<ftc_num_msgs[tok]; ++j) {
if (ftc_msgs[tok][j] == msgnum) {
memmove(&ftc_msgs[tok][j], &ftc_msgs[tok][j+1], ((ftc_num_msgs[tok] - j - 1)*sizeof(long)));
--ftc_num_msgs[tok];
--j;
}
}
}
}
}
else {
syslog(LOG_ALERT, "Invalid token %d !!", tok);
}
}
free(tokens);
}
}
int main(int argc, char* argv[])
{
char a;
int fd;
char *filename = NULL;
char *IconDir = NULL;
struct stat statbuf;
const char *Err;
StrBuf *MimeBuf;
long MimeLen;
char *MimeStr;
int by_extension = 0;
const char *GuessedMimeType;
const char *GuessedMimeIcon;
char MimeTypeStr[SIZ];
setvbuf(stdout, NULL, _IONBF, 0);
while ((a = getopt(argc, argv, "xf:i:")) != EOF)
{
switch (a) {
case 'x':
by_extension = 1;
break;
case 'f':
filename = optarg;
break;
case 'i':
IconDir = optarg;
break;
}
}
StartLibCitadel(8);
if (IconDir != NULL)
LoadIconDir(IconDir);
if (filename == NULL) {
ShutDownLibCitadel();
printf("Filename requried! -f\n");
return 1;
}
if (by_extension) {
GuessedMimeType = GuessMimeByFilename(filename, strlen(filename));
printf("Mimetype: %s\n", GuessedMimeType);
if (IconDir != NULL) {
strcpy(MimeTypeStr, GuessedMimeType);
GuessedMimeIcon = GetIconFilename(MimeTypeStr, strlen(MimeTypeStr));
if (GuessedMimeIcon != NULL)
printf("Associated Icon [%s]\n", GuessedMimeIcon);
else
printf("no icon associated.\n");
}
ShutDownLibCitadel();
return 0;
}
fd = open(filename, 0);
if (fd < 0) {
printf("Error opening file [%s] %d [%s]\n", filename, errno, strerror(errno));
ShutDownLibCitadel();
return 1;
}
if (fstat(fd, &statbuf) == -1) {
printf("Error stating file [%s] %d [%s]\n", filename, errno, strerror(errno));
ShutDownLibCitadel();
return 1;
}
MimeBuf = NewStrBufPlain(NULL, statbuf.st_size + 1);
if (StrBufReadBLOB(MimeBuf, &fd, 1, statbuf.st_size, &Err) < 0) {
printf("Error reading file [%s] %d [%s] [%s]\n", filename, errno, strerror(errno), Err);
FreeStrBuf(&MimeBuf);
ShutDownLibCitadel();
return 1;
}
MimeLen = StrLength(MimeBuf);
MimeStr = SmashStrBuf(&MimeBuf);
GuessedMimeType = GuessMimeType(MimeStr, MimeLen);
printf("Mimetype: %s\n", GuessedMimeType);
if (IconDir != NULL) {
strcpy(MimeTypeStr, GuessedMimeType);
GuessedMimeIcon = GetIconFilename(MimeTypeStr, strlen(MimeTypeStr));
if (GuessedMimeIcon != NULL)
printf("Associated Icon [%s]\n", GuessedMimeIcon);
else
printf("no icon associated.\n");
}
free(MimeStr);
ShutDownLibCitadel();
return 0;
}
