ref: bee6271ae1c4f50180f52f6dc11ce23337467722
parent: 319e625be0ec5d78b063308332056bed0299c2c9
author: Ori Bernstein <ori@eigenstate.org>
date: Fri Jan 29 12:34:47 EST 2021
Mail: rewrite. Acme mail made it hard to do threading, so I wrote a new one.
--- /dev/null
+++ b/sys/man/1/acmemail
@@ -1,0 +1,231 @@
+.TH NAIL 1
+.SH NAME
+Nail \- view mail in acme
+
+.SH SYNOPSIS
+
+Nail
+[
+.B -OsT
+]
+[
+.B -m
+.I maildir
+]
+[
+.B -f
+.I format
+]
+[
+.B -o
+.I outbox
+]
+
+.SH DESCRIPTION
+.PP
+.B Nail
+edits a mailbox in an
+.IR acme (1)
+environment.
+The default mailbox is /mail/fs/mbox.
+Nail shows 3 views:
+The list view, the message view, and the composition view.
+
+.PP
+At startup,
+.B Nail
+takes the following options:
+.PD 0
+.TP
+.B -T
+Disable threading
+.TP
+.B -O
+Disable writing to outbox
+.PD 0
+.TP
+.BI -s
+Accept sendmail plumb messages. By default, only
+the Nail instance viewing /mail/fs/mbox will
+accept plumb messages.
+.PD 0
+.TP
+.BI -m " maildir
+Open the maildir
+.I maildir
+instead of the default
+.PD 0
+.TP
+.BI -f " format
+Define the format of individual messages in the list view
+(see "Format strings" below).
+.TP
+.BI -o " outbox
+Save a copy of outgoing messages to the mailbox
+.IR outbox ,
+instead of discarding them after they're enqueued.
+
+.PP
+Nail presents and acme interface for a upas/fs mailbox.
+When started, a mailbox, by default
+.IR /mail/fs/mbox ,
+is presented.
+In the message list, the tag bar commands typically affect
+the selected messsage.
+In the message and composition views, they typically apply
+to the current message.
+
+.PP
+The following text commands are recognized by the message
+list:
+
+.TP
+.B Put
+Flush pending changes back to
+.IR upasfs (4).
+.PD 0
+.TP
+.B Delmesg, Undelmesg
+Flags a message for deletion on the next
+.I Put
+invocation.
+.PD 0
+.TP
+.B Next
+Select the next unread message in the mailbox.
+.PD 0
+.TP
+.B Mark [±flags]
+Add or remove message flags. The flags recognized
+are listed in
+.IR upasfs (4)
+.PD 0
+.TP
+.B Redraw
+Redraws the contents of the mailbox.
+
+.PP
+The following text commands are recognized by the message
+view:
+
+.TP
+.B Reply [all]
+Replies to a message, quoting it.
+If all is specified, reply to all addresses on the message.
+.PD 0
+.TP
+.B Delmesg, Undelmesg
+As with the message view, but applied to the open message.
+.PD 0
+.TP
+.B Mark
+As with the message view, but applied to the open message.
+
+.PP
+The following text commands are recognized by the composition
+window:
+
+.TP
+.B Post
+Sends the message currently being composed.
+
+.SS Format strings
+The formatting of messages in the list view is controlled by the
+format string defined through the
+.I -f
+flag.
+The format string is composed of multiple directives: plain
+characters, which are displayed unchanged; indentation directives,
+which allows spacing based on thread depth; and messages directives,
+which display message fields.
+.PP
+Directives have the following format:
+.IP
+.B "% [flags] [width] verb
+.PP
+.IR width
+limits the number of characters displayed.
+If width is negative, text is aligned right instead of left.
+.PP
+The supported flags are:
+.PD 0
+.TP
+.B >
+Insert indentation into the start of the field. This
+does not increase the width of the field.
+
+.PP
+Messages directives are:
+.PD 0
+.TP
+.B s
+Subject
+.PD 0
+.TP
+.B f
+From field
+.PD 0
+.TP
+.B F
+From field including sender's name
+.PD 0
+.TP
+.B t
+To field
+.PD 0
+.TP
+.B c
+Cc field
+.PD 0
+.TP
+.B r
+Reply-to field
+
+.PP
+Indentation directives are:
+.PD 0
+.TP
+.B i
+Adds spacing depending on message depth in thread but limited to a single level.
+If
+.IR width
+is not specified, adds a tabulation otherwise
+.IR width
+specifies the number of spaces to display.
+.PD 0
+.TP
+.B I
+Similar to
+.IR i
+but not limited to a single level.
+
+.PP
+Two special directives are also available:
+.PD 0
+.TP
+.B "[...]
+Text within the brackets is displayed if the message is not the toplevel message of a thread.
+.PD 0
+.TP
+.B "{...}+Text within the braces is used as the format string for tmfmt(2).
+
+.PP
+The default format string is "%>48s\\t<%f>"
+
+.SH FILES
+
+.SH "SEE ALSO"
+.IR mail (1),
+.IR aliasmail (8),
+.IR filter (1),
+.IR marshal (1),
+.IR mlmgr (1),
+.IR nedmail (1),
+.IR upasfs (4),
+.IR smtp (8),
+.IR faces (1),
+.IR rewrite (6)
+
+.SH BUGS
+Probably.
--- /dev/null
+++ b/sys/src/cmd/upas/Mail/comp.c
@@ -1,0 +1,290 @@
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <thread.h>
+#include <regexp.h>
+
+#include "mail.h"
+
+typedef struct Fn Fn;
+
+struct Fn {+ char *name;
+ void (*fn)(Comp *, char **, int);
+};
+
+void
+execmarshal(void *p)
+{+ Comp *c;
+ char *av[8];
+ int na;
+
+ c = p;
+ rfork(RFFDG);
+ dup(c->fd[0], 0);
+ close(c->fd[0]);
+ close(c->fd[1]);
+
+ na = 0;
+ av[na++] = "marshal";
+ av[na++] = "-8";
+ if(savebox != nil){+ av[na++] = "-S";
+ av[na++] = savebox;
+ }
+ if(c->rpath != nil){+ av[na++] = "-R";
+ av[na++] = c->rpath;
+ }
+ av[na] = nil;
+ assert(na < nelem(av));
+ procexec(c->sync, "/bin/upas/marshal", av);
+}
+
+static void
+postmesg(Comp *c, char **, int nf)
+{+ char *buf, wpath[64], *path;
+ int n, fd;
+ Mesg *m;
+
+ snprint(wpath, sizeof(wpath), "/mnt/acme/%d/body", c->id);
+ if(nf != 0){+ fprint(2, "Post: too many args\n");
+ return;
+ }
+ if((fd = open(wpath, OREAD)) == -1){+ fprint(2, "open body: %r\n");
+ return;
+ }
+ if(pipe(c->fd) == -1)
+ sysfatal("pipe: %r\n");+
+ c->sync = chancreate(sizeof(ulong), 0);
+ procrfork(execmarshal, c, Stack, RFNOTEG);
+ recvul(c->sync);
+ chanfree(c->sync);
+ close(c->fd[0]);
+
+ /* needed because mail is by default Latin-1 */
+ fprint(c->fd[1], "Content-Type: text/plain; charset=\"UTF-8\"\n");
+ fprint(c->fd[1], "Content-Transfer-Encoding: 8bit\n");
+ buf = emalloc(Bufsz);
+ while((n = read(fd, buf, Bufsz)) > 0)
+ if(write(c->fd[1], buf, n) != n)
+ break;
+ write(c->fd[1], "\n", 1);
+ close(c->fd[1]);
+ close(fd);
+ if(n == -1)
+ return;
+
+ if(fprint(c->ctl, "name %s:Sent\n", c->path) == -1)
+ sysfatal("write ctl: %r");+ if(c->replyto != nil){+ if((m = mesglookup(c->rname, c->rdigest)) == nil)
+ return;
+ m->flags |= Fresp;
+ path = estrjoin(mbox.path, "/", m->name, "/flags", nil);
+ if((fd = open(path, OWRITE)) != -1){+ fprint(fd, "+a");
+ close(fd);
+ }
+ mbredraw(m, 0, 0);
+ free(path);
+ }
+ fprint(c->ctl, "clean\n");
+}
+
+static void
+compquit(Comp *c, char **, int)
+{+ c->quitting = 1;
+}
+
+static Fn compfn[] = {+ {"Post", postmesg},+ {"Del", compquit},+ {nil},+};
+
+static void
+compmain(void *cp)
+{+ char *f[32];
+ int nf;
+ Event ev;
+ Comp *c, **pc;
+ Fn *p;
+
+ c = cp;
+ c->quitting = 0;
+ c->qnext = mbox.opencomp;
+ mbox.opencomp = c;
+ fprint(c->ctl, "clean\n");
+ mbox.nopen++;
+ while(!c->quitting){+ if(winevent(c, &ev) != 'M')
+ continue;
+ if(strcmp(ev.text, "Del") == 0)
+ break;
+ switch(ev.type){+ case 'l':
+ case 'L':
+ if(matchmesg(&mbox, ev.text))
+ mesgopen(ev.text, nil);
+ else
+ winreturn(c, &ev);
+ break;
+ case 'x':
+ case 'X':
+ if((nf = tokenize(ev.text, f, nelem(f))) == 0)
+ continue;
+ for(p = compfn; p->fn != nil; p++)
+ if(strcmp(p->name, f[0]) == 0){+ p->fn(c, &f[1], nf - 1);
+ break;
+ }
+ if(p->fn == nil)
+ winreturn(c, &ev);
+ break;
+ break;
+ }
+ }
+ for(pc = &mbox.opencomp; *pc != nil; pc = &(*pc)->qnext)
+ if(*pc == c){+ *pc = c->qnext;
+ break;
+ }
+ mbox.nopen--;
+ c->qnext = nil;
+ winclose(c);
+ free(c->replyto);
+ free(c->rname);
+ free(c->rdigest);
+ free(c->rpath);
+ threadexits(nil);
+}
+
+static Biobuf*
+openbody(Mesg *r)
+{+ Biobuf *f;
+ int q0, q1;
+ char *s;
+
+ assert(r->state & Sopen);
+
+ wingetsel(r, &q0, &q1);
+ if(q1 - q0 != 0){+ s = smprint("/mnt/acme/%d/xdata", r->id);+ f = Bopen(s, OREAD);
+ free(s);
+ }else
+ f = mesgopenbody(r);
+ return f;
+}
+
+int
+strpcmp(void *a, void *b)
+{+ return strcmp(*(char**)a, *(char**)b);
+}
+
+void
+show(Biobuf *fd, char *type, char **addrs, int naddrs)
+{+ char *sep;
+ int i, w;
+
+ w = 0;
+ sep = "";
+ if(naddrs == 0)
+ return;
+ qsort(addrs, naddrs, sizeof(char*), strpcmp);
+ Bprint(fd, "%s: ", type);
+ for(i = 0; i < naddrs; i++){+ if(i > 0 && strcmp(addrs[i-1], addrs[i]) == 0)
+ continue;
+ w += Bprint(fd, "%s%s", sep, addrs[i]);
+ sep = ", ";
+ if(w > 50){+ w = 0;
+ sep = "";
+ Bprint(fd, "\n%s: ", type);
+ }
+ }
+ Bprint(fd, "\n");
+}
+
+void
+respondto(Biobuf *fd, char *to, Mesg *r, int all)
+{+ char *rpto, **addrs;
+ int n;
+
+ rpto = to;
+ if(r != nil)
+ rpto = (strlen(r->replyto) > 0) ? r->replyto : r->from;
+ if(r == nil || !all){+ Bprint(fd, "To: %s\n", rpto);
+ return;
+ }
+
+ n = 0;
+ addrs = emalloc(64*sizeof(char*));
+ n += tokenize(to, addrs+n, 64-n);
+ n += tokenize(rpto, addrs+n, 64-n);
+ n += tokenize(r->to, addrs+n, 64-n);
+ show(fd, "To", addrs, n);
+ n = tokenize(r->cc, addrs+n, 64-n);
+ show(fd, "CC", addrs, n);
+ free(addrs);
+}
+
+void
+compose(char *to, Mesg *r, int all)
+{+ static int ncompose;
+ Biobuf *rfd, *wfd;
+ Comp *c;
+ char *ln;
+
+ c = emalloc(sizeof(Comp));
+ if(r != nil)
+ c->path = esmprint("%s%s%s.%d", mbox.path, r->name, "Reply", ncompose++);+ else
+ c->path = esmprint("%sCompose.%d", mbox.path, ncompose++);+ wininit(c, c->path);
+
+ wintagwrite(c, "Post |fmt ");
+ wfd = bwinopen(c, "body", OWRITE);
+ respondto(wfd, to, r, all);
+ if(r == nil)
+ Bprint(wfd, "Subject: ");
+ else{+ if(r->messageid != nil)
+ c->replyto = estrdup(r->messageid);
+ c->rpath = estrjoin(mbox.path, r->name, nil);
+ c->rname = estrdup(r->name);
+ c->rdigest = estrdup(r->digest);
+ Bprint(wfd, "Subject: ");
+ if(r->subject != nil && cistrncmp(r->subject, "Re", 2) != 0)
+ Bprint(wfd, "Re: ");
+ Bprint(wfd, "%s\n\n", r->subject);
+ Bprint(wfd, "Quoth %s:\n", r->fromcolon);
+ rfd = openbody(r);
+ if(rfd != nil){+ while((ln = Brdstr(rfd, '\n', 0)) != nil)
+ if(Bprint(wfd, "> %s", ln) == -1)
+ break;
+ Bterm(rfd);
+ }
+ Bterm(wfd);
+ }
+ Bterm(wfd);
+ fprint(c->addr, "$");
+ fprint(c->ctl, "dot=addr");
+ threadcreate(compmain, c, Stack);
+}
--- a/sys/src/cmd/upas/Mail/dat.h
+++ /dev/null
@@ -1,171 +1,0 @@
-typedef struct Event Event;
-typedef struct Exec Exec;
-typedef struct Message Message;
-typedef struct Window Window;
-
-enum
-{- STACK = 8192,
- EVENTSIZE = 256,
- NEVENT = 5,
-};
-
-struct Event
-{- int c1;
- int c2;
- int q0;
- int q1;
- int flag;
- int nb;
- int nr;
- char b[EVENTSIZE*UTFmax+1];
- Rune r[EVENTSIZE+1];
-};
-
-struct Window
-{- /* file descriptors */
- int ctl;
- int event;
- int addr;
- int data;
- Biobuf *body;
-
- /* event input */
- char buf[512];
- char *bufp;
- int nbuf;
- Event e[NEVENT];
-
- int id;
- int open;
- Channel *cevent;
-};
-
-struct Message
-{- Window *w;
- int ctlfd;
- char *name;
- char *replyname;
- char *replydigest;
- uchar opened;
- uchar dirty;
- uchar isreply;
- uchar deleted;
- uchar writebackdel;
- uchar tagposted;
- uchar recursed;
- uchar level;
-
- /* header info */
- char *fromcolon; /* from header file; all rest are from info file */
- char *from;
- char *to;
- char *cc;
- char *replyto;
- char *date;
- char *subject;
- char *type;
- char *disposition;
- char *filename;
- char *digest;
- char *flags;
-
- Message *next; /* next in this mailbox */
- Message *prev; /* prev in this mailbox */
- Message *head; /* first subpart */
- Message *tail; /* last subpart */
-};
-
-enum
-{- NARGS = 100,
- NARGCHAR = 8*1024,
- EXECSTACK = STACK+(NARGS+1)*sizeof(char*)+NARGCHAR
-};
-
-struct Exec
-{- char *prog;
- char **argv;
- int p[2]; /* p[1] is write to program; p[0] set to prog fd 0*/
- int q[2]; /* q[0] is read from program; q[1] set to prog fd 1 */
- Channel *sync;
-};
-
-extern Window* newwindow(void);
-extern int winopenfile(Window*, char*);
-extern void winopenbody(Window*, int);
-extern void winclosebody(Window*);
-extern void wintagwrite(Window*, char*, int);
-extern void winname(Window*, char*);
-extern void winwriteevent(Window*, Event*);
-extern void winread(Window*, uint, uint, char*);
-extern int windel(Window*, int);
-extern void wingetevent(Window*, Event*);
-extern void wineventproc(void*);
-extern void winwritebody(Window*, char*, int);
-extern void winclean(Window*);
-extern int winselect(Window*, char*, int);
-extern char* winselection(Window*);
-extern int winsetaddr(Window*, char*, int);
-extern char* winreadbody(Window*, int*);
-extern void windormant(Window*);
-extern void winsetdump(Window*, char*, char*);
-
-extern void readmbox(Message*, char*, char*);
-extern void rewritembox(Window*, Message*);
-
-extern void mkreply(Message*, char*, char*, Plumbattr*, char*);
-extern void delreply(Message*);
-extern int write2(int, int, char*, int, int);
-
-extern int mesgadd(Message*, char*, Dir*, char*);
-extern void mesgmenu(Window*, Message*);
-extern void mesgmenuselect(Window*, Message*);
-extern void mesgmenunew(Window*, Message*);
-extern void mesgmenureflag(Window*, Message*);
-extern int mesgopen(Message*, char*, char*, Message*, int, char*);
-extern void mesgctl(void*);
-extern void mesgsend(Message*);
-extern void mesgdel(Message*, Message*);
-extern void mesgmenudel(Window*, Message*, Message*);
-extern void mesgmenumark(Window*, char*, char*);
-extern void mesgmenumarkdel(Window*, Message*, Message*, int);
-extern Message* mesglookup(Message*, char*, char*);
-extern Message* mesglookupfile(Message*, char*, char*);
-extern void mesgfreeparts(Message*);
-
-extern char* readfile(char*, char*, int*);
-extern char* readbody(char*, char*, int*);
-extern void ctlprint(int, char*, ...);
-extern void* emalloc(uint);
-extern void* erealloc(void*, uint);
-extern char* estrdup(char*);
-extern char* estrstrdup(char*, char*);
-extern char* egrow(char*, char*, char*);
-extern char* eappend(char*, char*, char*);
-extern void error(char*, ...);
-extern int tokenizec(char*, char**, int, char*);
-extern void execproc(void*);
-extern void setflags(Message*, char *);
-
-#pragma varargck argpos error 1
-#pragma varargck argpos ctlprint 2
-
-extern Window *wbox;
-extern Message mbox;
-extern Message replies;
-extern char *fsname;
-extern int plumbsendfd;
-extern int plumbseemailfd;
-extern char *home;
-extern char *outgoing;
-extern char *mailboxdir;
-extern char *user;
-extern char deleted[];
-extern int wctlfd;
-extern int shortmenu;
-extern int altmenu;
--- a/sys/src/cmd/upas/Mail/html.c
+++ /dev/null
@@ -1,74 +1,0 @@
-#include <u.h>
-#include <libc.h>
-#include <bio.h>
-#include <thread.h>
-#include <ctype.h>
-#include <plumb.h>
-#include "dat.h"
-
-
-char*
-formathtml(char *body, int *np)
-{- int i, j, p[2], q[2];
- Exec *e;
- char buf[1024];
-
- e = emalloc(sizeof(Exec));
- if(pipe(p) < 0 || pipe(q) < 0)
- error("can't create pipe: %r");-
- e->p[0] = p[0];
- e->p[1] = p[1];
- e->q[0] = q[0];
- e->q[1] = q[1];
- e->argv = emalloc(4*sizeof(char*));
- e->argv[0] = estrdup("htmlfmt");- e->argv[1] = estrdup("-a");- e->argv[2] = estrdup("-cutf-8");- e->argv[3] = nil;
- e->prog = "/bin/htmlfmt";
- e->sync = chancreate(sizeof(int), 0);
- proccreate(execproc, e, EXECSTACK);
- recvul(e->sync);
- close(p[0]);
- close(q[1]);
-
- if((i=write(p[1], body, *np)) != *np){- fprint(2, "Mail: warning: htmlfmt failed: wrote %d of %d: %r\n", i, *np);
- close(p[1]);
- close(q[0]);
- return body;
- }
- close(p[1]);
-
- free(body);
- body = nil;
- i = 0;
- for(;;){- j = read(q[0], buf, sizeof buf);
- if(j <= 0)
- break;
- body = realloc(body, i+j+1);
- if(body == nil)
- error("realloc failed: %r");- memmove(body+i, buf, j);
- i += j;
- body[i] = '\0';
- }
- close(q[0]);
-
- *np = i;
- return body;
-}
-
-char*
-readbody(char *type, char *dir, int *np)
-{- char *body;
-
- body = readfile(dir, "body", np);
- if(body != nil && strcmp(type, "text/html") == 0)
- return formathtml(body, np);
- return body;
-}
--- a/sys/src/cmd/upas/Mail/mail.c
+++ /dev/null
@@ -1,644 +1,0 @@
-#include <u.h>
-#include <libc.h>
-#include <bio.h>
-#include <thread.h>
-#include <plumb.h>
-#include <ctype.h>
-#include "dat.h"
-
-char *maildir = "/mail/fs/"; /* mountpoint of mail file system */
-char *mailtermdir = "/mnt/term/mail/fs/"; /* alternate mountpoint */
-char *mboxname = "mbox"; /* mailboxdir/mboxname is mail spool file */
-char *mailboxdir = nil; /* nil == /mail/box/$user */
-char *fsname; /* filesystem for mailboxdir/mboxname is at maildir/fsname */
-char *user;
-char *outgoing;
-
-Window *wbox;
-Message mbox;
-Message replies;
-char *home;
-int plumbsendfd;
-int plumbseemailfd;
-int plumbshowmailfd;
-int plumbsendmailfd;
-Channel *cplumb;
-Channel *cplumbshow;
-Channel *cplumbsend;
-int wctlfd;
-void mainctl(void*);
-void plumbproc(void*);
-void plumbshowproc(void*);
-void plumbsendproc(void*);
-void plumbthread(void);
-void plumbshowthread(void*);
-void plumbsendthread(void*);
-
-int shortmenu;
-int altmenu;
-
-void
-usage(void)
-{- fprint(2, "usage: Mail [-sS] [-o outgoing] [mailboxname [directoryname]]\n");
- threadexitsall("usage");-}
-
-void
-removeupasfs(void)
-{- char buf[256];
-
- if(strcmp(mboxname, "mbox") == 0)
- return;
- snprint(buf, sizeof buf, "close %s", mboxname);
- write(mbox.ctlfd, buf, strlen(buf));
-}
-
-int
-ismaildir(char *s)
-{- char *path;
- Dir *d;
- int ret;
-
- path = smprint("%s%s", maildir, s);- d = dirstat(path);
- free(path);
- if(d == nil)
- return 0;
- ret = d->qid.type & QTDIR;
- free(d);
- return ret;
-}
-
-void
-threadmain(int argc, char *argv[])
-{- char *s, *name;
- char err[ERRMAX], *cmd;
- int i, newdir;
- Fmt fmt;
-
- doquote = needsrcquote;
- quotefmtinstall();
- tmfmtinstall();
-
- /* open these early so we won't miss notification of new mail messages while we read mbox */
- plumbsendfd = plumbopen("send", OWRITE|OCEXEC);- plumbseemailfd = plumbopen("seemail", OREAD|OCEXEC);- plumbshowmailfd = plumbopen("showmail", OREAD|OCEXEC);-
- shortmenu = 0;
- altmenu = 0;
- ARGBEGIN{- case 's':
- shortmenu = 1;
- break;
- case 'S':
- shortmenu = 2;
- break;
- case 'A':
- altmenu = 1;
- break;
- case 'o':
- outgoing = EARGF(usage());
- break;
- case 'm':
- smprint(maildir, "%s/", EARGF(usage()));
- break;
- default:
- usage();
- }ARGEND
-
- name = "mbox";
-
- /* bind the terminal /mail/fs directory over the local one */
- if(access(maildir, 0)<0 && access(mailtermdir, 0)==0)
- bind(mailtermdir, maildir, MAFTER);
-
- newdir = 1;
- if(argc > 0){- i = strlen(argv[0]);
- if(argc>2 || i==0)
- usage();
- /* see if the name is that of an existing /mail/fs directory */
- if(argc==1 && strchr(argv[0], '/')==0 && ismaildir(argv[0])){- name = argv[0];
- mboxname = eappend(estrdup(maildir), "", name);
- newdir = 0;
- }else{- if(argv[0][i-1] == '/')
- argv[0][i-1] = '\0';
- s = strrchr(argv[0], '/');
- if(s == nil)
- mboxname = estrdup(argv[0]);
- else{- *s++ = '\0';
- if(*s == '\0')
- usage();
- mailboxdir = argv[0];
- mboxname = estrdup(s);
- }
- if(argc > 1)
- name = argv[1];
- else
- name = mboxname;
- }
- }
-
- user = getenv("user");- if(user == nil)
- user = "none";
- if(mailboxdir == nil)
- mailboxdir = estrstrdup("/mail/box/", user);- if(outgoing == nil)
- outgoing = estrstrdup(mailboxdir, "/outgoing");
-
- s = estrstrdup(maildir, "ctl");
- mbox.ctlfd = open(s, ORDWR|OCEXEC);
- if(mbox.ctlfd < 0)
- error("can't open %s: %r", s);-
- fsname = estrdup(name);
- if(newdir && argc > 0){- s = emalloc(5+strlen(mailboxdir)+strlen(mboxname)+strlen(name)+10+1);
- for(i=0; i<10; i++){- sprint(s, "open %s/%s %s", mailboxdir, mboxname, fsname);
- if(write(mbox.ctlfd, s, strlen(s)) >= 0)
- break;
- err[0] = '\0';
- errstr(err, sizeof err);
- if(strstr(err, "mbox name in use") == nil)
- error("can't create directory %s for mail: %s", name, err);- free(fsname);
- fsname = emalloc(strlen(name)+10);
- sprint(fsname, "%s-%d", name, i);
- }
- if(i == 10)
- error("can't open %s/%s: %r", mailboxdir, mboxname);- free(s);
- }
-
- s = estrstrdup(fsname, "/");
- mbox.name = estrstrdup(maildir, s);
- mbox.level= 0;
- readmbox(&mbox, maildir, s);
- home = getenv("home");- if(home == nil)
- home = "/";
-
- wbox = newwindow();
- winname(wbox, mbox.name);
- wintagwrite(wbox, "Put Mail Delmesg Save Next ", 3+1+4+1+7+1+4+1+4+1);
- threadcreate(mainctl, wbox, STACK);
-
- fmtstrinit(&fmt);
- fmtprint(&fmt, "Mail");
- if(shortmenu)
- fmtprint(&fmt, " -%c", "sS"[shortmenu-1]);
- if(altmenu)
- fmtprint(&fmt, " -A");
- if(outgoing)
- fmtprint(&fmt, " -o %s", outgoing);
- fmtprint(&fmt, " %s", name);
- cmd = fmtstrflush(&fmt);
- if(cmd == nil)
- sysfatal("out of memory");- winsetdump(wbox, "/acme/mail", cmd);
- mbox.w = wbox;
-
- mesgmenu(wbox, &mbox);
- winclean(wbox);
-
- wctlfd = open("/dev/wctl", OWRITE|OCEXEC); /* for acme window */- cplumb = chancreate(sizeof(Plumbmsg*), 0);
- cplumbshow = chancreate(sizeof(Plumbmsg*), 0);
- if(strcmp(name, "mbox") == 0){- /*
- * Avoid creating multiple windows to send mail by only accepting
- * sendmail plumb messages if we're reading the main mailbox.
- */
- plumbsendmailfd = plumbopen("sendmail", OREAD|OCEXEC);- cplumbsend = chancreate(sizeof(Plumbmsg*), 0);
- proccreate(plumbsendproc, nil, STACK);
- threadcreate(plumbsendthread, nil, STACK);
- }
- /* start plumb reader as separate proc ... */
- proccreate(plumbproc, nil, STACK);
- proccreate(plumbshowproc, nil, STACK);
- threadcreate(plumbshowthread, nil, STACK);
- /* ... and use this thread to read the messages */
- plumbthread();
-}
-
-void
-plumbproc(void*)
-{- Plumbmsg *m;
-
- threadsetname("plumbproc");- for(;;){- m = plumbrecv(plumbseemailfd);
- sendp(cplumb, m);
- if(m == nil)
- threadexits(nil);
- }
-}
-
-void
-plumbshowproc(void*)
-{- Plumbmsg *m;
-
- threadsetname("plumbshowproc");- for(;;){- m = plumbrecv(plumbshowmailfd);
- sendp(cplumbshow, m);
- if(m == nil)
- threadexits(nil);
- }
-}
-
-void
-plumbsendproc(void*)
-{- Plumbmsg *m;
-
- threadsetname("plumbsendproc");- for(;;){- m = plumbrecv(plumbsendmailfd);
- sendp(cplumbsend, m);
- if(m == nil)
- threadexits(nil);
- }
-}
-
-void
-newmesg(char *name, char *digest)
-{- Dir *d;
-
- if(strncmp(name, mbox.name, strlen(mbox.name)) != 0)
- return; /* message is about another mailbox */
- if(mesglookupfile(&mbox, name, digest) != nil)
- return;
- d = dirstat(name);
- if(d == nil)
- return;
- if(mesgadd(&mbox, mbox.name, d, digest))
- mesgmenunew(wbox, &mbox);
- free(d);
-}
-
-void
-showmesg(char *name, char *digest)
-{- char *n;
-
- if(strncmp(name, mbox.name, strlen(mbox.name)) != 0)
- return; /* message is about another mailbox */
- n = estrdup(name+strlen(mbox.name));
- if(n[strlen(n)-1] != '/')
- n = egrow(n, "/", nil);
- mesgopen(&mbox, mbox.name, name+strlen(mbox.name), nil, 1, digest);
- free(n);
-}
-
-void
-delmesg(char *name, char *digest, int dodel)
-{- Message *m;
-
- m = mesglookupfile(&mbox, name, digest);
- if(m != nil){- mesgmenumarkdel(wbox, &mbox, m, 0);
- if(dodel)
- m->writebackdel = 1;
- }
-}
-
-void
-modmesg(char *name, char *digest)
-{- Message *m;
- char *flags;
-
- if((m = mesglookupfile(&mbox, name, digest)) == nil)
- return;
- if((flags = readfile(name, "/flags", nil)) == nil)
- return;
- free(m->flags);
- m->flags = flags;
- mesgmenureflag(mbox.w, m);
-}
-
-
-extern int mesgsave(Message*, char*);
-void
-savemesg(char *box, char *name, char *digest)
-{- char *s;
- int ok;
- Message *m;
-
- m = mesglookupfile(&mbox, name, digest);
- if(!m || m->isreply)
- return;
- s = estrdup("\t[saved");- if(!box[0])
- ok = mesgsave(m, "stored");
- else{- ok = mesgsave(m, box);
- s = eappend(s, " ", box);
- }
- if(ok){- s = egrow(s, "]", nil);
- mesgmenumark(mbox.w, m->name, s);
- }
- free(s);
-
-}
-
-void
-plumbthread(void)
-{- Plumbmsg *m;
- Plumbattr *a;
- char *type, *digest;
-
- threadsetname("plumbthread");- while((m = recvp(cplumb)) != nil){- a = m->attr;
- digest = plumblookup(a, "digest");
- type = plumblookup(a, "mailtype");
- if(type == nil)
- fprint(2, "Mail: plumb message with no mailtype attribute\n");
- else if(strcmp(type, "new") == 0)
- newmesg(m->data, digest);
- else if(strcmp(type, "delete") == 0)
- delmesg(m->data, digest, 0);
- else if(strcmp(type, "modify") == 0)
- modmesg(m->data, digest);
- else
- fprint(2, "Mail: unknown plumb attribute %s\n", type);
- plumbfree(m);
- }
- threadexits(nil);
-}
-
-void
-plumbshowthread(void*)
-{- Plumbmsg *m;
-
- threadsetname("plumbshowthread");- while((m = recvp(cplumbshow)) != nil){- showmesg(m->data, plumblookup(m->attr, "digest"));
- plumbfree(m);
- }
- threadexits(nil);
-}
-
-void
-plumbsendthread(void*)
-{- Plumbmsg *m;
-
- threadsetname("plumbsendthread");- while((m = recvp(cplumbsend)) != nil){- mkreply(nil, "Mail", m->data, m->attr, nil);
- plumbfree(m);
- }
- threadexits(nil);
-}
-
-int
-mboxcommand(Window *w, char *s)
-{- char *args[10], **targs, *r, *box;
- Message *m, *next;
- int ok, nargs, i, j;
- char buf[128];
-
- nargs = tokenize(s, args, nelem(args));
- if(nargs == 0)
- return 0;
- if(strcmp(args[0], "Mail") == 0){- if(nargs == 1)
- mkreply(nil, "Mail", "", nil, nil);
- else
- mkreply(nil, "Mail", args[1], nil, nil);
- return 1;
- }
- if(strcmp(s, "Del") == 0){- if(mbox.dirty){- mbox.dirty = 0;
- fprint(2, "mail: mailbox not written\n");
- return 1;
- }
- ok = 1;
- for(m=mbox.head; m!=nil; m=next){- next = m->next;
- if(m->w){- if(windel(m->w, 0))
- m->w = nil;
- else
- ok = 0;
- }
- }
- for(m=replies.head; m!=nil; m=next){- next = m->next;
- if(m->w){- if(windel(m->w, 0))
- m->w = nil;
- else
- ok = 0;
- }
- }
- if(ok){- windel(w, 1);
- removeupasfs();
- threadexitsall(nil);
- }
- return 1;
- }
- if(strcmp(s, "Put") == 0){- rewritembox(wbox, &mbox);
- return 1;
- }
- if(strcmp(s, "Delmesg") == 0){- if(nargs > 1){- for(i=1; i<nargs; i++){- snprint(buf, sizeof buf, "%s%s", mbox.name, args[i]);
- delmesg(buf, nil, 1);
- }
- }
- s = winselection(w);
- if(s == nil)
- return 1;
- nargs = 1;
- for(i=0; s[i]; i++)
- if(s[i] == '\n')
- nargs++;
- targs = emalloc(nargs*sizeof(char*)); /* could be too many for a local array */
- nargs = getfields(s, targs, nargs, 1, "\n");
- for(i=0; i<nargs; i++){- if(!isdigit(targs[i][0]))
- continue;
- j = atoi(targs[i]); /* easy way to parse the number! */
- if(j == 0)
- continue;
- snprint(buf, sizeof buf, "%s%d", mbox.name, j);
- delmesg(buf, nil, 1);
- }
- free(s);
- free(targs);
- return 1;
- }
- if(strncmp(args[0], "Save", 4) == 0){- box = "";
- i = 1;
- if(nargs > 1 && !mesglookupfile(&mbox, args[1], nil)){- box = args[1];
- i++;
- nargs--;
- }
- if(nargs > 1){- for(; i<nargs; i++){- snprint(buf, sizeof buf, "%s%s", mbox.name, args[i]);
- savemesg(box, buf, nil);
- }
- }
- s = winselection(w);
- if(s == nil)
- return 1;
- nargs = 1;
- for(i=0; s[i]; i++)
- if(s[i] == '\n')
- nargs++;
- targs = emalloc(nargs*sizeof(char*)); /* could be too many for a local array */
- nargs = getfields(s, targs, nargs, 1, "\n");
- for(i=0; i<nargs; i++){- if(!isdigit(targs[i][0]))
- continue;
- j = strtoul(targs[i], &r, 10);
- if(j == 0 || *r != '/')
- continue;
- snprint(buf, sizeof buf, "%s%d", mbox.name, j);
- savemesg(box, buf, nil);
- }
- free(s);
- free(targs);
- return 1;
- }
- if(strcmp(args[0], "Next") == 0){- ctlprint(w->ctl, "addr=dot\n");
- winselect(w, "/^[0-9]*\\/ \\[\\*.*(\\n(\t.*)*)/", 1);
- ctlprint(w->ctl, "show\n");
- }
- return 0;
-}
-
-void
-mainctl(void *v)
-{- Window *w;
- Event *e, *e2, *eq, *ea;
- int na, nopen;
- char *s, *t, *buf;
-
- w = v;
- proccreate(wineventproc, w, STACK);
-
- for(;;){- e = recvp(w->cevent);
- switch(e->c1){- default:
- Unknown:
- print("unknown message %c%c\n", e->c1, e->c2);- break;
-
- case 'E': /* write to body; can't affect us */
- break;
-
- case 'F': /* generated by our actions; ignore */
- break;
-
- case 'K': /* type away; we don't care */
- break;
-
- case 'M':
- switch(e->c2){- case 'x':
- case 'X':
- ea = nil;
- e2 = nil;
- if(e->flag & 2)
- e2 = recvp(w->cevent);
- if(e->flag & 8){- ea = recvp(w->cevent);
- na = ea->nb;
- recvp(w->cevent);
- }else
- na = 0;
- s = e->b;
- /* if it's a known command, do it */
- if((e->flag&2) && e->nb==0)
- s = e2->b;
- if(na){- t = emalloc(strlen(s)+1+na+1);
- sprint(t, "%s %s", s, ea->b);
- s = t;
- }
- /* if it's a long message, it can't be for us anyway */
- if(!mboxcommand(w, s)) /* send it back */
- winwriteevent(w, e);
- if(na)
- free(s);
- break;
-
- case 'l':
- case 'L':
- buf = nil;
- eq = e;
- if(e->flag & 2){- e2 = recvp(w->cevent);
- eq = e2;
- }
- s = eq->b;
- if(eq->q1>eq->q0 && eq->nb==0){- buf = emalloc((eq->q1-eq->q0)*UTFmax+1);
- winread(w, eq->q0, eq->q1, buf);
- s = buf;
- }
- nopen = 0;
- do{- /* skip 'deleted' string if present' */
- if(strncmp(s, deleted, strlen(deleted)) == 0)
- s += strlen(deleted);
- /* skip mail box name if present */
- if(strncmp(s, mbox.name, strlen(mbox.name)) == 0)
- s += strlen(mbox.name);
- nopen += mesgopen(&mbox, mbox.name, s, nil, 0, nil);
- while(*s!='\0' && *s++!='\n')
- ;
- }while(*s);
- if(nopen == 0) /* send it back */
- winwriteevent(w, e);
- free(buf);
- break;
-
- case 'I': /* modify away; we don't care */
- case 'D':
- case 'd':
- case 'i':
- break;
-
- default:
- goto Unknown;
- }
- }
- }
-}
-
--- /dev/null
+++ b/sys/src/cmd/upas/Mail/mail.h
@@ -1,0 +1,195 @@
+typedef struct Event Event;
+typedef struct Win Win;
+typedef struct Mesg Mesg;
+typedef struct Mbox Mbox;
+typedef struct Comp Comp;
+
+enum {+ Stack = 64*1024,
+ Bufsz = 8192,
+ Eventsz = 256*UTFmax,
+ Subjlen = 56,
+};
+
+enum {+ Sdummy = 1<<0, /* message placeholder */
+ Stoplev = 1<<1, /* not a response to anything */
+ Sopen = 1<<2, /* opened for viewing */
+};
+
+enum {+ Fresp = 1<<0, /* has been responded to */
+ Fseen = 1<<1, /* has been viewed */
+ Fdel = 1<<2, /* was deleted */
+ Ftodel = 1<<3, /* pending deletion */
+};
+
+enum {+ Vflat,
+ Vgroup,
+};
+
+struct Event {+ char action;
+ char type;
+ int p0; /* click point */
+ int q0; /* expand lo */
+ int q1; /* expand hi */
+ int flags;
+ int ntext;
+ char text[Eventsz + 1];
+};
+
+struct Win {+ int id;
+ Ioproc *io;
+ Biobuf *event;
+ int revent;
+ int ctl;
+ int addr;
+ int data;
+ int open;
+};
+
+/*
+ * In progress compositon
+ */
+struct Comp {+ Win;
+
+ /* exec setup */
+ Channel *sync;
+ int fd[2];
+
+ /* to relate back the message */
+ char *replyto;
+ char *rname;
+ char *rpath;
+ char *rdigest;
+ char *path;
+
+ int quitting;
+ Comp *qnext;
+};
+
+/*
+ * Message in mailbox
+ */
+struct Mesg {+ Win;
+
+ /* bookkeeping */
+ char *name;
+ int state;
+ int flags;
+ u32int hash;
+ char quitting;
+ Mesg *qnext;
+
+ /* exec setup */
+ Channel *sync;
+ char *path;
+ int fd[2];
+
+ Mesg *parent;
+ Mesg **child;
+ int nchild;
+ int nsub; /* transitive children */
+
+ Mesg *body; /* best attachment to use, or nil */
+ Mesg **parts;
+ int nparts;
+ int xparts;
+
+ /* info fields */
+ char *from;
+ char *to;
+ char *cc;
+ char *replyto;
+ char *date;
+ char *subject;
+ char *type;
+ char *disposition;
+ char *messageid;
+ char *filename;
+ char *digest;
+ char *mflags;
+ char *fromcolon;
+ char *inreplyto;
+
+ vlong time;
+};
+
+/*
+ *The mailbox we're showing.
+ */
+struct Mbox {+ Win;
+
+ Mesg **mesg;
+ Mesg **hash;
+ int mesgsz;
+ int hashsz;
+ int nmesg;
+ int ndead;
+
+ Mesg *openmesg;
+ Comp *opencomp;
+ int canquit;
+
+ Channel *see;
+ Channel *show;
+ Channel *event;
+ Channel *send;
+
+ int view;
+ int nopen;
+ char *path;
+};
+
+extern Mbox mbox;
+extern Reprog *mesgpat;
+extern char *savebox;
+
+/* window management */
+void wininit(Win*, char*);
+int winopen(Win*, char*, int);
+Biobuf *bwinopen(Win*, char*, int);
+Biobuf *bwindata(Win*, int);
+void winclose(Win*);
+void wintagwrite(Win*, char*);
+int winevent(Win*, Event*);
+void winreturn(Win*, Event*);
+int winread(Win*, int, int, char*, int);
+int matchmesg(Win*, char*);
+char *winreadsel(Win*);
+void wingetsel(Win*, int*, int*);
+void winsetsel(Win*, int, int);
+
+/* messages */
+Mesg *mesglookup(char*, char*);
+Mesg *mesgload(char*);
+Mesg *mesgopen(char*, char*);
+int mesgmatch(Mesg*, char*, char*);
+void mesgclear(Mesg*);
+void mesgfree(Mesg*);
+void mesgpath2name(char*, int, char*);
+int mesgflagparse(char*, int*);
+Biobuf* mesgopenbody(Mesg*);
+
+/* mailbox */
+void mbredraw(Mesg*, int, int);
+
+/* composition */
+void compose(char*, Mesg*, int);
+
+/* utils */
+void *emalloc(ulong);
+void *erealloc(void*, ulong);
+char *estrdup(char*);
+char *estrjoin(char*, ...);
+char *esmprint(char*, ...);
+char *rslurp(Mesg*, char*, int*);
+char *fslurp(int, int*);
+u32int strhash(char*);
+
--- /dev/null
+++ b/sys/src/cmd/upas/Mail/mbox.c
@@ -1,0 +1,1056 @@
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <thread.h>
+#include <plumb.h>
+#include <ctype.h>
+#include <regexp.h>
+
+#include "mail.h"
+
+typedef struct Fn Fn;
+
+struct Fn {+ char *name;
+ void (*fn)(char **, int);
+};
+
+enum {+ Cevent,
+ Cseemail,
+ Cshowmail,
+ Csendmail,
+ Nchan,
+};
+
+
+char *maildir = "/mail/fs";
+char *mailbox = "mbox";
+char *savebox = "outgoing";
+char *listfmt = "%>48s\t<%f>";
+Mesg dead = {.messageid="", .hash=42};+
+Reprog *mesgpat;
+
+int threadsort = 1;
+int sender;
+
+int plumbsendfd;
+int plumbseemailfd;
+int plumbshowmailfd;
+int plumbsendmailfd;
+Channel *cwait;
+
+Mbox mbox;
+
+static void showmesg(Biobuf*, Mesg*, int, int);
+
+static void
+plumbloop(Channel *ch, int fd)
+{+ Plumbmsg *m;
+
+ while(1){+ if((m = plumbrecv(fd)) == nil)
+ threadexitsall("plumber gone");+ sendp(ch, m);
+ }
+}
+
+static void
+plumbshowmail(void*)
+{+ threadsetname("plumbshow %s", mbox.path);+ plumbloop(mbox.show, plumbshowmailfd);
+}
+
+static void
+plumbseemail(void*)
+{+ threadsetname("plumbsee %s", mbox.path);+ plumbloop(mbox.see, plumbseemailfd);
+}
+
+static void
+plumbsendmail(void*)
+{+ threadsetname("plumbsend %s", mbox.path);+ plumbloop(mbox.send, plumbsendmailfd);
+}
+
+static void
+eventread(void*)
+{+ Event *ev;
+
+ threadsetname("mbevent %s", mbox.path);+ while(1){+ ev = emalloc(sizeof(Event));
+ if(winevent(&mbox, ev) == -1)
+ break;
+ sendp(mbox.event, ev);
+ }
+ sendp(mbox.event, nil);
+ threadexits(nil);
+}
+
+static int
+ideq(char *a, char *b)
+{+ if(a == nil || b == nil)
+ return 0;
+ return strcmp(a, b) == 0;
+}
+
+static int
+cmpmesg(void *pa, void *pb)
+{+ Mesg *a, *b;
+
+ a = *(Mesg**)pa;
+ b = *(Mesg**)pb;
+
+ return b->time - a->time;
+}
+
+static int
+rcmpmesg(void *pa, void *pb)
+{+ Mesg *a, *b;
+
+ a = *(Mesg**)pa;
+ b = *(Mesg**)pb;
+
+ return a->time - b->time;
+}
+
+static int
+mesglineno(Mesg *msg, int *depth)
+{+ Mesg *p, *m;
+ int i, o, n, d;
+
+ o = 0;
+ d = 0;
+ n = 1;
+
+ /* Walk up to root, counting depth in the thread */
+ p = msg;
+ while(p->parent != nil){+ m = p;
+ p = p->parent;
+ for(i = 0; i < p->nchild; i++){+ if(p->child[i] == m)
+ break;
+ o += p->child[i]->nsub + 1;
+ }
+ if(!(p->state & Sdummy)){+ o++;
+ d++;
+ }
+ }
+
+ /* Find the thread in the thread list */
+ for(i = 0; i < mbox.nmesg; i++){+ m = mbox.mesg[i];
+ if(m == p)
+ break;
+ if(m->state & Stoplev){+ n += mbox.mesg[i]->nsub;
+ if(!(m->state & Sdummy))
+ n++;
+ }
+
+ }
+ if(depth != nil)
+ *depth = d;
+ assert(n + o <= mbox.nmesg);
+ return n + o;
+}
+
+static int
+addchild(Mesg *p, Mesg *m, int d)
+{+ Mesg *q;
+
+ assert(m->parent == nil);
+ for(q = p; q != nil; q = q->parent){+ if(ideq(m->messageid, q->messageid)){+ fprint(2, "wonky message replies to self\n");
+ return 0;
+ }
+ if(m->time > q->time)
+ q->time = m->time;
+ }
+ for(q = p; q != nil; q = q->parent)
+ q->nsub += d;
+ p->child = erealloc(p->child, ++p->nchild*sizeof(Mesg*));
+ p->child[p->nchild - 1] = m;
+ qsort(p->child, p->nchild, sizeof(Mesg*), rcmpmesg);
+ m->parent = p;
+ return 1;
+}
+
+static int
+slotfor(Mesg *m)
+{+ int i;
+
+ for(i = 0; i < mbox.nmesg; i++)
+ if(cmpmesg(&mbox.mesg[i], &m) >= 0)
+ break;
+ return i;
+}
+
+static void
+removeid(Mesg *m)
+{+ Mesg *e;
+ int i;
+
+ /* Dummies don't go in the table */
+ if(m->state & Sdummy)
+ return;
+ i = m->hash % mbox.hashsz;
+ while(1){+ e = mbox.hash[i];
+ if(e == nil)
+ return;
+ if(e != &dead && e->hash == m->hash && strcmp(e->messageid, m->messageid) == 0){+ mbox.hash[i] = &dead;
+ mbox.ndead++;
+ }
+ i = (i + 1) % mbox.hashsz;
+ }
+}
+
+Mesg*
+lookupid(char *msgid)
+{+ u32int h, i;
+ Mesg *e;
+
+ if(msgid == nil || strlen(msgid) == 0)
+ return nil;
+ h = strhash(msgid);
+ i = h % mbox.hashsz;
+ while(1){+ e = mbox.hash[i];
+ if(e == nil)
+ return nil;
+ if(e != &dead && e->hash == h && strcmp(e->messageid, msgid) == 0)
+ return e;
+ i = (i + 1) % mbox.hashsz;
+ }
+}
+
+static void
+addmesg(Mesg *m, int ins)
+{+ Mesg *o, *e, **oldh;
+ int i, oldsz, idx;
+
+ /*
+ * on initial load, it's faster to append everything then sort,
+ * but on subsequent messages it's better to just put it in the
+ * right place; we don't want to shuffle the already-sorted
+ * messages.
+ */
+ if(mbox.nmesg == mbox.mesgsz){+ mbox.mesgsz *= 2;
+ mbox.mesg = erealloc(mbox.mesg, mbox.mesgsz*sizeof(Mesg*));
+ }
+ if(ins)
+ idx = slotfor(m);
+ else
+ idx = mbox.nmesg;
+ memmove(&mbox.mesg[idx + 1], &mbox.mesg[idx], (mbox.nmesg - idx)*sizeof(Mesg*));
+ mbox.mesg[idx] = m;
+ mbox.nmesg++;
+ if(m->messageid == nil)
+ return;
+
+ /* grow hash table, or squeeze out deadwood */
+ if(mbox.hashsz <= 2*(mbox.nmesg + mbox.ndead)){+ oldsz = mbox.hashsz;
+ oldh = mbox.hash;
+ if(mbox.hashsz <= 2*mbox.nmesg)
+ mbox.hashsz *= 2;
+ mbox.ndead = 0;
+ mbox.hash = emalloc(mbox.hashsz*sizeof(Mesg*));
+ for(i = 0; i < oldsz; i++){+ if((o = oldh[i]) == nil)
+ continue;
+ mbox.hash[o->hash % mbox.hashsz] = o;
+ }
+ free(oldh);
+ }
+ i = m->hash % mbox.hashsz;
+ while(1){+ e = mbox.hash[i % mbox.hashsz];
+ if(e == nil || e == &dead)
+ break;
+ i = (i + 1) % mbox.hashsz;
+ }
+ mbox.hash[i] = m;
+}
+
+static Mesg *
+placeholder(char *msgid, vlong time, int ins)
+{+ Mesg *m;
+
+ m = emalloc(sizeof(Mesg));
+ m->state |= Sdummy|Stoplev;
+ m->messageid = estrdup(msgid);
+ m->hash = strhash(msgid);
+ m->time = time;
+ addmesg(m, ins);
+ return m;
+}
+
+static Mesg*
+change(char *name, char *digest)
+{+ Mesg *m;
+ char *f;
+
+ if((m = mesglookup(name, digest)) == nil)
+ return nil;
+ if((f = rslurp(m, "flags", nil)) == nil)
+ return nil;
+ free(m->mflags);
+ m->mflags = f;
+ m->flags = 0;
+ if(strchr(m->mflags, 'd')) m->flags |= Fdel;
+ if(strchr(m->mflags, 's')) m->flags |= Fseen;
+ if(strchr(m->mflags, 'a')) m->flags |= Fresp;
+ return m;
+}
+
+static Mesg*
+delete(char *name, char *digest)
+{+ Mesg *m;
+
+ if((m = mesglookup(name, digest)) == nil)
+ return nil;
+ m->flags |= Fdel;
+ return m;
+}
+
+static Mesg*
+load(char *name, char *digest, int ins)
+{+ Mesg *m, *p;
+ int d;
+
+ if(strncmp(name, mbox.path, strlen(mbox.path)) == 0)
+ name += strlen(mbox.path);
+ if((m = mesgload(name)) == nil)
+ goto error;
+
+ if(digest != nil && strcmp(digest, m->digest) != 0)
+ goto error;
+ /* if we already have a dummy, populate it */
+ d = 1;
+ p = lookupid(m->messageid);
+ if(p != nil && (p->state & Sdummy)){+ d = p->nsub + 1;
+ m->child = p->child;
+ m->nchild = p->nchild;
+ m->nsub = p->nsub;
+ mesgclear(p);
+ memcpy(p, m, sizeof(*p));
+ free(m);
+ m = p;
+
+ }else{+ /*
+ * if we raced a notify and a mailbox load, we
+ * can get duplicate load requests for the same
+ * name in the mailbox.
+ */
+ if(p != nil && strcmp(p->name, m->name) == 0)
+ goto error;
+ addmesg(m, ins);
+ }
+
+ if(!threadsort || m->inreplyto == nil || ideq(m->messageid, m->inreplyto)){+ m->state |= Stoplev;
+ return m;
+ }
+ p = lookupid(m->inreplyto);
+ if(p == nil)
+ p = placeholder(m->inreplyto, m->time, ins);
+ if(!addchild(p, m, d))
+ m->state |= Stoplev;
+ return m;
+error:
+ mesgfree(m);
+ return nil;
+}
+
+void
+mbredraw(Mesg *m, int add, int rec)
+{+ Biobuf *bfd;
+ int ln, depth;
+
+ ln = mesglineno(m, &depth);
+ fprint(mbox.addr, "%d%s", ln, add?"-#0":"");
+ bfd = bwindata(&mbox, OWRITE);
+ showmesg(bfd, m, depth, rec);
+ Bterm(bfd);
+
+ /* highlight the redrawn message */
+ fprint(mbox.addr, "%d%s", ln, add ? "-#0" : "");
+ fprint(mbox.ctl, "dot=addr\n");
+}
+
+static void
+mbload(void)
+{+ int i, n, fd;
+ Dir *d;
+
+ mbox.mesgsz = 128;
+ mbox.hashsz = 128;
+ mbox.mesg = emalloc(mbox.mesgsz*sizeof(Mesg*));
+ mbox.hash = emalloc(mbox.hashsz*sizeof(Mesg*));
+ mbox.path = esmprint("%s/%s/", maildir, mailbox);+ cleanname(mbox.path);
+ n = strlen(mbox.path);
+ if(mbox.path[n - 1] != '/')
+ mbox.path[n] = '/';
+ if((fd = open(mbox.path, OREAD)) == -1)
+ sysfatal("%s: open: %r", mbox.path);+ while(1){+ n = dirread(fd, &d);
+ if(n == -1)
+ sysfatal("%s read: %r", mbox.path);+ if(n == 0)
+ break;
+ for(i = 0; i < n; i++)
+ if(strcmp(d[i].name, "ctl") != 0)
+ load(d[i].name, nil, 0);
+ free(d);
+ }
+ qsort(mbox.mesg, mbox.nmesg, sizeof(Mesg*), cmpmesg);
+}
+
+static char*
+getflag(Mesg *m)
+{+ char* flag;
+
+ flag = "★";
+ if(m->flags & Fseen) flag = " ";
+ if(m->flags & Fresp) flag = "←";
+ if(m->flags & Fdel) flag = "∉";
+ if(m->flags & Ftodel) flag = "∉";
+ return flag;
+}
+
+static void
+printw(Biobuf *bp, char *s, int width)
+{+ char *dots;
+
+ if(width <= 0)
+ Bprint(bp, "%s", s);
+ else{+ dots = "";
+ if(utflen(s) > width){+ width -= 3;
+ dots = "...";
+ }
+ Bprint(bp, "%*.*s%s", -width, width, s, dots);
+ }
+}
+
+/*
+ * Message format string:
+ * ======================
+ * %s: subject
+ * %f: from address
+ * %F: name + from address
+ * %t: to address
+ * %c: CC address
+ * %r: replyto address
+ * %[...]: string to display for child messages
+ * %{...}: date format string+ */
+static void
+fmtmesg(Biobuf *bp, char *fmt, Mesg *m, int depth)
+{+ char *p, *e, buf[64];
+ int width, i, indent;
+ Tm tm;
+
+ Bprint(bp, "%-6s\t%s ", m->name, getflag(m));
+ for(p = fmt; *p; p++){+ if(*p != '%'){+ Bputc(bp, *p);
+ continue;
+ }
+ p++;
+ width = 0;
+ indent = 0;
+ while(*p == '>'){+ p++;
+ indent++;
+ }
+ while('0'<=*p && *p<='9')+ width = width * 10 + *p++ - '0';
+ for(i = 0; indent && i < depth; i++){+ Bputc(bp, '\t');
+ width -= 4;
+ if(indent == 1)
+ break;
+ }
+ switch(*p){+ case '%':
+ Bprint(bp, "%%");
+ break;
+ case 'i':
+ if(depth > 0)
+ depth = 1;
+ case 'I':
+ for(i = 0; i < depth; i++){+ if(width>0)
+ Bprint(bp, "%*s", width, "");
+ else
+ Bprint(bp, "\t");
+ }
+ break;
+ case 's':
+ printw(bp, m->subject, width);
+ break;
+ case 'f':
+ printw(bp, m->from, width);
+ break;
+ case 'F':
+ printw(bp, m->fromcolon, width);
+ break;
+ case 't':
+ printw(bp, m->to, width);
+ break;
+ case 'c':
+ printw(bp, m->cc, width);
+ break;
+ case 'r':
+ printw(bp, m->replyto, width);
+ break;
+ case '[':
+ p++;
+ if((e = strchr(p, ']')) == nil)
+ sysfatal("missing closing '}' in %%{");+ if(e - p >= sizeof(buf) - 1)
+ sysfatal("%%{} contents too long");+ snprint(buf, sizeof(buf), "%.*s", (int)(e - p), p);
+ if(depth > 0)
+ Bprint(bp, "%s", buf);
+ p = e;
+ break;
+ case '{':+ p++;
+ if((e = strchr(p, '}')) == nil)
+ sysfatal("missing closing '}' in %%{");+ if(e - p >= sizeof(buf) - 1)
+ sysfatal("%%{} contents too long");+ snprint(buf, sizeof(buf), "%.*s", (int)(e - p), p);
+ tmtime(&tm, m->time, nil);
+ Bprint(bp, "%τ", tmfmt(&tm, buf));
+ p = e;
+ break;
+ default:
+ sysfatal("invalid directive '%%%c' in format string", *p);+ break;
+ }
+ }
+ Bputc(bp, '\n');
+}
+
+
+static void
+showmesg(Biobuf *bfd, Mesg *m, int depth, int recurse)
+{+ int i;
+
+ if(!(m->state & Sdummy)){+ fmtmesg(bfd, listfmt, m, depth);
+ depth++;
+ }
+ if(recurse && mbox.view != Vflat)
+ for(i = 0; i < m->nchild; i++)
+ showmesg(bfd, m->child[i], depth, recurse);
+}
+
+static void
+mark(char **f, int nf, char *fstr, int flags, int add)
+{+ char *sel, *p, *q, *e, *path;
+ int i, q0, q1, fd;
+ Mesg *m;
+
+ if(flags == 0)
+ return;
+ wingetsel(&mbox, &q0, &q1);
+ if(nf == 0){+ sel = winreadsel(&mbox);
+ for(p = sel; p != nil; p = e){+ if((e = strchr(p, '\n')) != nil)
+ *e++ = 0;
+ if(!matchmesg(&mbox, p))
+ continue;
+ if((q = strchr(p, '/')) != nil)
+ q[1] = 0;
+ if((m = mesglookup(p, nil)) != nil){+ if(add)
+ m->flags |= flags;
+ else
+ m->flags &= ~flags;
+ if(fstr != nil && strlen(fstr) != 0){+ path = estrjoin(mbox.path, "/", m->name, "/flags", nil);
+ if((fd = open(path, OWRITE)) != -1){+ fprint(fd, fstr);
+ close(fd);
+ }
+ free(path);
+ }
+ mbredraw(m, 0, 0);
+ }
+ }
+ free(sel);
+ }else for(i = 0; i < nf; i++){+ if((m = mesglookup(f[i], nil)) != nil){+ m->flags |= flags;
+ mbredraw(m, 0, 0);
+ }
+ }
+ winsetsel(&mbox, q0, q1);
+}
+
+static void
+mbmark(char **f, int nf)
+{+ int add, flg;
+
+ if(nf == 0){+ fprint(2, "missing fstr");
+ return;
+ }
+ if((flg = mesgflagparse(f[0], &add)) == -1){+ fprint(2, "Mark: invalid flags %s\n", f[0]);
+ return;
+ }
+ mark(f+1, nf-1, f[0], flg, add);
+}
+
+static void
+relinkmsg(Mesg *p, Mesg *m)
+{+ Mesg *c, *pp;
+ int i, j;
+
+ /* remove child, preserving order */
+ j = 0;
+ for(i = 0; p && i < p->nchild; i++){+ if(p->child[i] != m)
+ p->child[j++] = p->child[i];
+ }
+ p->nchild = j;
+ for(pp = p; pp != nil; pp = pp->parent)
+ pp->nsub -= m->nsub + 1;
+
+ /* reparent children */
+ for(i = 0; i < m->nchild; i++){+ c = m->child[i];
+ c->parent = nil;
+ addchild(p, c, c->nsub + 1);
+ }
+}
+
+static void
+mbflush(char **, int)
+{+ int i, j, ln, fd;
+ char *path;
+ Mesg *m, *p;
+
+ i = 0;
+ path = estrjoin(maildir, "/ctl", nil);
+ fd = open(path, OWRITE);
+ free(path);
+ if(fd == -1)
+ sysfatal("open mbox: %r");+ while(i < mbox.nmesg){+ m = mbox.mesg[i];
+ if((m->state & Sopen) || !(m->flags & (Fdel|Ftodel))){+ i++;
+ continue;
+ }
+ ln = mesglineno(m, nil);
+ fprint(mbox.addr, "%d,%d", ln, ln+m->nsub);
+ write(mbox.data, "", 0);
+ if(m->flags & Ftodel)
+ fprint(fd, "delete %s %d", mailbox, atoi(m->name));
+
+ p = m->parent;
+ removeid(m);
+ if(p == nil && m->nsub != 0){+ p = placeholder(m->messageid, m->time, 1);
+ p->nsub = m->nsub + 1;
+ mbox.mesg[i] = p;
+ }
+ if(p != nil)
+ relinkmsg(p, m);
+ for(j = 0; j < m->nchild; j++)
+ mbredraw(m->child[j], 1, 1);
+ memmove(&mbox.mesg[i], &mbox.mesg[i+1], (mbox.nmesg - i)*sizeof(Mesg*));
+ mbox.nmesg--;
+ }
+ close(fd);
+ fprint(mbox.ctl, "clean\n");
+}
+
+static void
+mbcompose(char **, int)
+{+ compose("", nil, 0);+}
+
+static void
+delmesg(char **f, int nf)
+{+ mark(f, nf, nil, Ftodel, 1);
+}
+
+static void
+undelmesg(char **f, int nf)
+{+ mark(f, nf, nil, Ftodel, 0);
+}
+
+static void
+showlist(void)
+{+ Biobuf *bfd;
+ Mesg *m;
+ int i;
+
+ bfd = bwinopen(&mbox, "data", OWRITE);
+ for(i = 0; i < mbox.nmesg; i++){+ m = mbox.mesg[i];
+ if(mbox.view == Vflat || m->state & (Sdummy|Stoplev))
+ showmesg(bfd, m, 0, 1);
+ }
+ Bterm(bfd);
+ fprint(mbox.addr, "0");
+ fprint(mbox.ctl, "dot=addr\n");
+ fprint(mbox.ctl, "show\n");
+}
+
+static void
+quitall(char **, int)
+{+ Mesg *m;
+ Comp *c;
+
+ if(mbox.nopen > 0 && !mbox.canquit){+ fprint(2, "Del: %d open messages\n", mbox.nopen);
+ mbox.canquit = 1;
+ return;
+ }
+ for(m = mbox.openmesg; m != nil; m = m->qnext)
+ fprint(m->ctl, "del\n");
+ for(c = mbox.opencomp; c != nil; c = c->qnext)
+ fprint(c->ctl, "del\n");
+ fprint(mbox.ctl, "del\n");
+ threadexitsall(nil);
+}
+
+/*
+ * shuffle a message to the right location
+ * in the list without doing a full sort.
+ */
+static void
+reinsert(Mesg *m)
+{+ int i, idx;
+
+ idx = slotfor(m);
+ for(i = idx; i < mbox.nmesg; i++)
+ if(mbox.mesg[i] == m)
+ break;
+ memmove(&mbox.mesg[idx + 1], &mbox.mesg[idx], (i - idx)*sizeof(Mesg*));
+ mbox.mesg[idx] = m;
+}
+
+static void
+changemesg(Plumbmsg *pm)
+{+ char *digest, *action;
+ Mesg *m, *r;
+ int ln, nr;
+
+ digest = plumblookup(pm->attr, "digest");
+ action = plumblookup(pm->attr, "mailtype");
+// fprint(2, "changing message %s, %s %s\n", action, pm->data, digest);
+ if(strcmp(action, "new") == 0){+ if((m = load(pm->data, digest, 1)) == nil)
+ return;
+ for(r = m; r->parent != nil; r = r->parent)
+ /* nothing */;
+ /* Bump whole thread up in list */
+ if(r->nsub > 0){+ ln = mesglineno(r, nil);
+ nr = r->nsub-1;
+ if(!(r->state & Sdummy))
+ nr++;
+ /*
+ * We can end up with an empty container
+ * in an edge case.
+ *
+ * Imagine we have a dummy message with
+ * a child, and that child gets deleted,
+ * then a new message comes in replying
+ * to that dummy.
+ *
+ * In this case, r->nsub == 1 due to the
+ * newly added message, so nr=0.
+ * in that case, skip the redraw, and
+ * reinsert the dummy in the right place.
+ */
+ if(nr > 0){+ fprint(mbox.addr, "%d,%d", ln, ln+nr-1);
+ write(mbox.data, "", 0);
+ }
+ reinsert(r);
+ }
+ mbredraw(r, 1, 1);
+ }else if(strcmp(action, "delete") == 0){+ if((m = delete(pm->data, digest)) != nil)
+ mbredraw(m, 0, 0);
+ }else if(strcmp(action, "modify") == 0){+ if((m = change(pm->data, digest)) != nil)
+ mbredraw(m, 0, 0);
+ }
+}
+
+static void
+viewmesg(Plumbmsg *pm)
+{+ Mesg *m;
+ m = mesgopen(pm->data, plumblookup(pm->attr, "digest"));
+ if(m != nil){+ fprint(mbox.addr, "%d", mesglineno(m, nil));
+ fprint(mbox.ctl, "dot=addr\n");
+ fprint(mbox.ctl, "show\n");
+ }
+}
+
+static void
+redraw(char **, int)
+{+ fprint(mbox.addr, ",");
+ showlist();
+}
+
+static void
+nextunread(char **, int)
+{+ fprint(mbox.ctl, "addr=dot\n");
+ fprint(mbox.addr, "/^[0-9]+\\/ *\t★.*");
+ fprint(mbox.ctl, "dot=addr\n");
+ fprint(mbox.ctl, "show\n");
+}
+
+Fn mboxfn[] = {+ {"Put", mbflush},+ {"Mail", mbcompose},+ {"Delmesg", delmesg},+ {"Undelmesg", undelmesg},+ {"Del", quitall},+ {"Redraw", redraw},+ {"Next", nextunread},+ {"Mark", mbmark},+#ifdef NOTYET
+ {"Filter", filter},+ {"Get", mbrefresh},+#endif
+ {nil}+};
+
+static void
+doevent(Event *ev)
+{+ char *f[32];
+ int nf;
+ Fn *p;
+
+ if(ev->action != 'M')
+ return;
+ switch(ev->type){+ case 'l':
+ case 'L':
+ if(matchmesg(&mbox, ev->text))
+ if(mesgopen(ev->text, nil) != nil)
+ break;
+ winreturn(&mbox, ev);
+ break;
+ case 'x':
+ case 'X':
+ if((nf = tokenize(ev->text, f, nelem(f))) == 0)
+ return;
+ for(p = mboxfn; p->fn != nil; p++)
+ if(strcmp(p->name, f[0]) == 0 && p->fn != nil){+ p->fn(&f[1], nf - 1);
+ break;
+ }
+ if(p->fn == nil)
+ winreturn(&mbox, ev);
+ else if(p->fn != quitall)
+ mbox.canquit = 0;
+ break;
+ }
+}
+
+static void
+execlog(void*)
+{+ Waitmsg *w;
+
+ while(1){+ w = recvp(cwait);
+ if(w->msg[0] != 0)
+ fprint(2, "%d: %s\n", w->pid, w->msg);
+ free(w);
+ }
+}
+
+static void
+mbmain(void *cmd)
+{+ Event *ev;
+ Plumbmsg *psee, *pshow, *psend;
+
+ Alt a[] = {+ [Cevent] = {mbox.event, &ev, CHANRCV},+ [Cseemail] = {mbox.see, &psee, CHANRCV},+ [Cshowmail] = {mbox.show, &pshow, CHANRCV},+ [Csendmail] = {mbox.send, &psend, CHANRCV},+ [Nchan] = {nil, nil, CHANEND},+ };
+
+ threadsetname("mbox %s", mbox.path);+ wininit(&mbox, mbox.path);
+ wintagwrite(&mbox, "Put Mail Delmesg Undelmesg Next ");
+ showlist();
+ fprint(mbox.ctl, "dump %s\n", cmd);
+ fprint(mbox.ctl, "clean\n");
+ procrfork(eventread, nil, Stack, RFNOTEG);
+ while(1){+ switch(alt(a)){+ case Cevent:
+ doevent(ev);
+ free(ev);
+ break;
+ case Cseemail:
+ changemesg(psee);
+ plumbfree(psee);
+ break;
+ case Cshowmail:
+ viewmesg(pshow);
+ plumbfree(pshow);
+ break;
+ case Csendmail:
+ compose(psend->data, nil, 0);
+ plumbfree(psend);
+ break;
+ }
+ }
+}
+
+static void
+usage(void)
+{+ fprint(2, "usage: %s [-T] [-m mailfs] [-s] [-f format] [mbox]\n", argv0);
+ exits("usage");+}
+
+void
+threadmain(int argc, char **argv)
+{+ Fmt fmt;
+ char *cmd;
+ int i;
+
+ mbox.view = Vgroup;
+ doquote = needsrcquote;
+ quotefmtinstall();
+ tmfmtinstall();
+
+ fmtstrinit(&fmt);
+ for(i = 0; i < argc; i++)
+ fmtprint(&fmt, "%q ", argv[i]);
+ cmd = fmtstrflush(&fmt);
+ if(cmd == nil)
+ sysfatal("out of memory");+
+ ARGBEGIN{+ case 'm':
+ maildir = EARGF(usage());
+ break;
+ case 'T':
+ mbox.view = Vflat;
+ break;
+ case 's':
+ sender++;
+ break;
+ case 'f':
+ listfmt = EARGF(usage());
+ break;
+ case 'O':
+ savebox = nil;
+ break;
+ case 'o':
+ savebox = EARGF(usage());
+ break;
+ default:
+ usage();
+ break;
+ }ARGEND;
+
+ if(argc > 1)
+ usage();
+ if(argc == 1)
+ mailbox = argv[0];
+
+ mesgpat = regcomp("([0-9]+)(/.*)?");+ cwait = threadwaitchan();
+
+ /* open these early so we won't miss messages while loading */
+ mbox.event = chancreate(sizeof(Event*), 0);
+ mbox.see = chancreate(sizeof(Plumbmsg*), 0);
+ mbox.show = chancreate(sizeof(Plumbmsg*), 0);
+ mbox.send = chancreate(sizeof(Plumbmsg*), 0);
+
+ plumbsendfd = plumbopen("send", OWRITE|OCEXEC);+ plumbseemailfd = plumbopen("seemail", OREAD|OCEXEC);+ plumbshowmailfd = plumbopen("showmail", OREAD|OCEXEC);+
+ mbload();
+ procrfork(plumbseemail, nil, Stack, RFNOTEG);
+ procrfork(plumbshowmail, nil, Stack, RFNOTEG);
+
+ /* avoid duplicate sends when multiple mailboxes are open */
+ if(sender || strcmp(mailbox, "mbox") == 0){+ plumbsendmailfd = plumbopen("sendmail", OREAD|OCEXEC);+ procrfork(plumbsendmail, nil, Stack, RFNOTEG);
+ }
+ threadcreate(execlog, nil, Stack);
+ threadcreate(mbmain, cmd, Stack);
+ threadexits(nil);
+}
--- a/sys/src/cmd/upas/Mail/mesg.c
+++ b/sys/src/cmd/upas/Mail/mesg.c
@@ -2,80 +2,53 @@
#include <libc.h>
#include <bio.h>
#include <thread.h>
-#include <ctype.h>
-#include <plumb.h>
-#include "dat.h"
+#include <regexp.h>
-enum
-{- DIRCHUNK = 32*sizeof(Dir)
-};
+#include "mail.h"
-char regexchars[] = "\\/[].+?()*^$";
-char deleted[] = "(deleted)-";
-char deletedrx[] = "\\(deleted\\)-";
-char deletedrx01[] = "(\\(deleted\\)-)?";
-char deletedaddr[] = "-#0;/^\\(deleted\\)-/";
+#define Datefmt "?WWW, ?MMM ?DD hh:mm:ss ?Z YYYY"
-struct{- char *type;
- char *port;
- char *suffix;
-} ports[] = {- "text/", "edit", ".txt", /* must be first for plumbport() */
- /* text must be first for plumbport() */
- "image/gif", "image", ".gif",
- "image/jpeg", "image", ".jpg",
- "image/jpeg", "image", ".jpeg",
- "image/png", "image", ".png",
- "image/tiff", "image", ".tif",
- "application/postscript", "postscript", ".ps",
- "application/pdf", "postscript", ".pdf",
- "application/msword", "msword", ".doc",
- "application/rtf", "msword", ".rtf",
- "audio/x-wav", "wav", ".wav",
- nil, nil
-};
+typedef struct Fn Fn;
-char *goodtypes[] = {- "text",
- "text/plain",
- "message/rfc822",
- "text/richtext",
- "text/tab-separated-values",
- "application/octet-stream",
- nil,
+struct Fn {+ char *name;
+ void (*fn)(Mesg *, char **, int);
};
-struct{- char *type;
- char *ext;
-} exts[] = {- "image/gif", ".gif",
- "image/jpeg", ".jpg",
- nil, nil
-};
-
-char *okheaders[] =
+void
+mesgclear(Mesg *m)
{- "From:",
- "Date:",
- "To:",
- "CC:",
- "Subject:",
- nil
-};
+ int i;
-char *extraheaders[] =
+ for(i = 0; i < m->nparts; i++)
+ mesgclear(m->parts[i]);
+ free(m->name);
+ free(m->from);
+ free(m->to);
+ free(m->cc);
+ free(m->replyto);
+ free(m->date);
+ free(m->subject);
+ free(m->type);
+ free(m->disposition);
+ free(m->messageid);
+ free(m->filename);
+ free(m->digest);
+ free(m->mflags);
+ free(m->fromcolon);
+}
+
+void
+mesgfree(Mesg *m)
{- "Resent-From:",
- "Resent-To:",
- "Sort:",
- nil,
-};
+ if(m == nil)
+ return;
+ mesgclear(m);
+ free(m);
+}
-char*
-line(char *data, char **pp)
+static char*
+line(char *data, char **pp, int z)
{char *p, *q;
@@ -85,1347 +58,488 @@
*pp = p+1;
else
*pp = p;
+ if(z && p == data)
+ return nil;
q = emalloc(p-data + 1);
memmove(q, data, p-data);
return q;
}
-char*
-fc(Message *m, char *s)
+static char*
+fc(Mesg *m, char *s)
{char *r;
- if(*s && *m->from){+ if(s != nil && strlen(m->from) != 0){ r = smprint("%s <%s>", s, m->from);free(s);
return r;
- }else if(*s)
- return s;
- else if(*m->from)
+ }
+ if(m->from != nil)
return estrdup(m->from);
+ if(s != nil)
+ return s;
return estrdup("??");}
-int
-loadinfo(Message *m, char *dir)
+Mesg*
+mesgload(char *name)
{- int n;
- char *data, *p;
+ char *info, *p;
+ int ninfo;
+ Mesg *m;
+ Tm tm;
- data = readfile(dir, "info", &n);
- if(data == nil)
- return 0;
- m->from = line(data, &p);
- m->to = line(p, &p);
- m->cc = line(p, &p);
- m->replyto = line(p, &p);
- m->date = line(p, &p);
- m->subject = line(p, &p);
- m->type = line(p, &p);
- m->disposition = line(p, &p);
- m->filename = line(p, &p);
- m->digest = line(p, &p);
- /* m->bcc = */ free(line(p, &p));
- /* m->inreplyto = */ free(line(p, &p));
- /* m->date = */ free(line(p, &p));
- /* m->sender = */ free(line(p, &p));
- /* m->messageid = */ free(line(p, &p));
- /* m->lines = */ free(line(p, &p));
- /* m->size = */ free(line(p, &p));
- m->flags = line(p, &p);
- /* m->fileid = */ free(line(p, &p));
- m->fromcolon = fc(m, line(p, &p));
-
- free(data);
- return 1;
-}
-
-int
-isnumeric(char *s)
-{- while(*s){- if(!isdigit(*s))
- return 0;
- s++;
+ m = emalloc(sizeof(Mesg));
+ m->name = estrjoin(name, "/", nil);
+ if((info = rslurp(m, "info", &ninfo)) == nil){+ free(m->name);
+ free(m);
+ return nil;
}
- return 1;
-}
-Dir*
-loaddir(char *name, int *np)
-{- int fd;
- Dir *dp;
+ p = info;
+ m->from = line(p, &p, 0);
+ m->to = line(p, &p, 0);
+ m->cc = line(p, &p, 0);
+ m->replyto = line(p, &p, 1);
+ m->date = line(p, &p, 0);
+ m->subject = line(p, &p, 0);
+ m->type = line(p, &p, 1);
+ m->disposition = line(p, &p, 1);
+ m->filename = line(p, &p, 1);
+ m->digest = line(p, &p, 1);
+ /* m->bcc = */ free(line(p, &p, 1));
+ m->inreplyto = line(p, &p, 1);
+ /* m->date = */ free(line(p, &p, 1));
+ /* m->sender = */ free(line(p, &p, 1));
+ m->messageid = line(p, &p, 0);
+ /* m->lines = */ free(line(p, &p, 1));
+ /* m->size = */ free(line(p, &p, 1));
+ m->mflags = line(p, &p, 0);
+ /* m->fileid = */ free(line(p, &p, 1));
+ m->fromcolon = fc(m, line(p, &p, 1));
+ free(info);
- fd = open(name, OREAD);
- if(fd < 0)
- return nil;
- *np = dirreadall(fd, &dp);
- close(fd);
- return dp;
-}
+ m->flags = 0;
+ if(strchr(m->mflags, 'd')) m->flags |= Fdel;
+ if(strchr(m->mflags, 's')) m->flags |= Fseen;
+ if(strchr(m->mflags, 'a')) m->flags |= Fresp;
-void
-readmbox(Message *mbox, char *dir, char *subdir)
-{- char *name;
- Dir *d, *dirp;
- int i, n;
-
- name = estrstrdup(dir, subdir);
- dirp = loaddir(name, &n);
- mbox->recursed = 1;
- if(dirp)
- for(i=0; i<n; i++){- d = &dirp[i];
- if(isnumeric(d->name))
- mesgadd(mbox, name, d, nil);
- }
- free(dirp);
- free(name);
+ m->time = time(nil);
+ if(tmparse(&tm, Datefmt, m->date, nil, nil) != nil)
+ m->time = tmnorm(&tm);
+ m->hash = 0;
+ if(m->messageid != nil)
+ m->hash = strhash(m->messageid);
+ return m;
}
-/* add message to box, in increasing numerical order */
-int
-mesgadd(Message *mbox, char *dir, Dir *d, char *digest)
+static Mesg*
+readparts(Mesg *m)
{- Message *m;
- char *name;
- int loaded;
+ char *dpath, *apath;
+ int n, i, dfd;
+ Mesg *a, *sub;
+ Dir *d;
- m = emalloc(sizeof(Message));
- m->name = estrstrdup(d->name, "/");
- m->next = nil;
- m->prev = mbox->tail;
- m->level= mbox->level+1;
- m->recursed = 0;
- name = estrstrdup(dir, m->name);
- loaded = loadinfo(m, name);
- free(name);
- /* if two upas/fs are running, we can get misled, so check digest before accepting message */
- if(loaded==0 || (digest!=nil && m->digest!=nil && strcmp(digest, m->digest)!=0)){- mesgfreeparts(m);
- free(m);
- return 0;
- }
- if(mbox->tail != nil)
- mbox->tail->next = m;
- mbox->tail = m;
- if(mbox->head == nil)
- mbox->head = m;
+ if(m->body != nil)
+ return m->body;
- if (m->level != 1){- m->recursed = 1;
- readmbox(m, dir, m->name);
- }
- return 1;
-}
+ dpath = estrjoin(mbox.path, m->name, nil);
+ dfd = open(dpath, OREAD);
+ free(dpath);
+ if(dfd == -1)
+ return m;
-int
-thisyear(char *year)
-{- Tzone *tz;
- Tm tm;
+ n = dirreadall(dfd, &d);
+ close(dfd);
+ if(n == -1)
+ sysfatal("%s read: %r", mbox.path);- /* ignore errors: screwed means utc */
- tz = tzload("local");- tmnow(&tm, tz);
- return atoi(year) == (tm.year + 1900);
-}
+ m->body = nil;
+ for(i = 0; i < n; i++){+ if(d[i].qid.type != QTDIR)
+ continue;
-char*
-stripdate(char *as)
-{- int n;
- char *s, *fld[10];
-
- as = estrdup(as);
- s = estrdup(as);
- n = tokenize(s, fld, 10);
- if(n > 5){- sprint(as, "%.3s ", fld[0]); /* day */
- /* some dates have 19 Apr, some Apr 19 */
- if(strlen(fld[1])<4 && isnumeric(fld[1]))
- sprint(as+strlen(as), "%.3s %.3s ", fld[1], fld[2]); /* date, month */
- else
- sprint(as+strlen(as), "%.3s %.3s ", fld[2], fld[1]); /* date, month */
- /* do we use time or year? depends on whether year matches this one */
- if(thisyear(fld[5])){- if(strchr(fld[3], ':') != nil)
- sprint(as+strlen(as), "%.5s ", fld[3]); /* time */
- else if(strchr(fld[4], ':') != nil)
- sprint(as+strlen(as), "%.5s ", fld[4]); /* time */
- }else
- sprint(as+strlen(as), "%.4s ", fld[5]); /* year */
+ apath = estrjoin(m->name, d[i].name, nil);
+ a = mesgload(apath);
+ free(apath);
+ if(a == nil)
+ continue;
+ if(strncmp(a->type, "multipart/", strlen("multipart/")) == 0){+ sub = readparts(a);
+ if(sub != a)
+ m->body = sub;
+ continue;
+ }
+ if(m->nparts >= m->xparts)
+ m->parts = erealloc(m->parts, (2 + m->nparts*2)*sizeof(Mesg*));
+ m->parts[m->nparts++] = a;
+ if(m->body == nil && strcmp(a->type, "text/plain") == 0)
+ m->body = a;
+ else if(m->body == nil && strcmp(a->type, "text/html") == 0)
+ m->body = a;
}
- free(s);
- return as;
+ free(d);
+ if(m->body == nil)
+ m->body = m;
+ return m->body;
}
-char*
-readfile(char *dir, char *name, int *np)
+static void
+execfmt(void *pm)
{- char *file, *data;
- int fd, len;
- Dir *d;
+ Mesg *m;
- if(np != nil)
- *np = 0;
- file = estrstrdup(dir, name);
- fd = open(file, OREAD);
- if(fd < 0)
- return nil;
- d = dirfstat(fd);
- free(file);
- len = 0;
- if(d != nil)
- len = d->length;
- free(d);
- data = emalloc(len+1);
- read(fd, data, len);
- close(fd);
- if(np != nil)
- *np = len;
- return data;
+ m = pm;
+ rfork(RFFDG);
+ dup(m->fd[1], 1);
+ close(m->fd[0]);
+ close(m->fd[1]);
+ procexecl(m->sync, "/bin/htmlfmt", "htmlfmt", "-a", "-cutf-8", m->path, nil);
}
-int
-writefile(char *dir, char *name, char *s)
+static int
+htmlfmt(Mesg *m, char *path)
{- char *e, *file;
- int fd, n;
-
- file = estrstrdup(dir, name);
-// fprint(2, "writefile %s [%s]\n", file, s);
- fd = open(file, OWRITE);
- if(fd < 0)
- return -1;
- for(e = s + strlen(s); e - s > 0; s += n)
- if((n = write(fd, s, e - s)) <= 0)
- break;
- close(fd);
- return s == e? 0: -1;
+ if(pipe(m->fd) == -1)
+ sysfatal("pipe: %r");+ m->sync = chancreate(sizeof(ulong), 0);
+ m->path = path;
+ procrfork(execfmt, m, Stack, RFNOTEG);
+ recvul(m->sync);
+ chanfree(m->sync);
+ close(m->fd[1]);
+ return m->fd[0];
}
-
-void
-setflags(Message *m, char *f)
+static void
+copy(Biobuf *wfd, Biobuf *rfd)
{- char *flgchar = "aDdfrsS";
- char *t, *p;
- int rm;
+ char *buf;
+ int n;
- t = smprint("%s/%s", mbox.name, m->name);- writefile(t, "flags", f);
- free(t);
- for(; *f; f++){- rm = 0;
- if(*f == '-'){- rm = 1;
- f++;
- }
- if((p = strchr(flgchar, *f)) != nil)
- m->flags[p - flgchar] = rm ? '-' : *f;
- }
+ buf = emalloc(Bufsz);
+ while(1){+ n = Bread(rfd, buf, Bufsz);
+ if(n <= 0)
+ break;
+ if(Bwrite(wfd, buf, n) != n)
+ break;
+ }
+ free(buf);
}
-void
-fmtflags(char *b, char *flg)
+static int
+mesgshow(Mesg *m)
{- *b++ = '[';
- *b++ = (strchr(flg, 's') == nil) ? '*' : ' '; /* unread */
- *b++ = (strchr(flg, 'a') == nil) ? ' ' : 'R'; /* answered */
- *b++ = ']';
- *b = '\0';
-}
+ char *path, *home, *name, *suff;
+ Biobuf *rfd, *wfd;
+ Mesg *a;
+ int i;
-char*
-info(Message *m, int ind, int ogf)
-{- char *i;
- int j, len, lens;
- char *p;
- char fmt[80], s[80], flg[16];
+ if((wfd = bwinopen(m, "body", OWRITE)) == nil)
+ return -1;
+ if(m->parent != nil || m->nchild != 0) {+ Bprint(wfd, "Thread:");
+ if(m->parent && !(m->parent->state & Sdummy))
+ Bprint(wfd, " ↑ %s", m->parent->name);
+ for(i = 0; i < m->nchild; i++)
+ Bprint(wfd, " ↓ %s", m->child[i]->name);
+ Bprint(wfd, "\n");
+ }
+ Bprint(wfd, "From: %s\n", m->fromcolon);
+ Bprint(wfd, "To: %s\n", m->to);
+ Bprint(wfd, "Date: %s\n", m->date);
+ Bprint(wfd, "Subject: %s\n\n", m->subject);
- if (ogf)
- p=m->to;
- else
- p=m->fromcolon;
-
- fmtflags(flg, m->flags);
- if(ind==0 && altmenu){- len = 12;
- lens = 20;
-
- if(ind==0 && m->subject[0]=='\0'){- snprint(fmt, sizeof fmt,
- "\t%%-%d.%ds\t%%-12.12s\t", len, len);
- snprint(s, sizeof s, fmt, p, stripdate(m->date) + 4);
- }else{- snprint(fmt, sizeof fmt,
- "\t%%-%d.%ds\t%%-12.12s\t%%-%d.%ds", len, len, lens, lens);
- snprint(s, sizeof s, fmt, p, stripdate(m->date) + 4, m->subject);
- }
- i = estrdup(s);
-
- return i;
+ rfd = mesgopenbody(m);
+ if(rfd != nil){+ copy(wfd, rfd);
+ Bterm(rfd);
}
- if(ind==0 && shortmenu){- len = 30;
- lens = 30;
- if(shortmenu > 1){- len = 10;
- lens = 25;
+ home = getenv("home");+ if(m->nparts != 0)
+ Bprint(wfd, "\n");
+ for(i = 0; i < m->nparts; i++){+ a = m->parts[i];
+ name = a->name;
+ if(strncmp(a->name, m->name, strlen(m->name)) == 0)
+ name += strlen(m->name);
+ if(a->disposition != nil
+ && strcmp(a->disposition, "inline") == 0
+ && strcmp(a->type, "text/plain") == 0){+ if(a == m || a == m->body)
+ continue;
+ Bprint(wfd, "\n===> %s (%s)\n", name, a->type);
+ path = estrjoin(mbox.path, a->name, "body", nil);
+ if((rfd = Bopen(path, OREAD)) != nil){+ copy(wfd, rfd);
+ Bterm(rfd);
+ }
+ free(path);
+ continue;
}
- if(ind==0 && m->subject[0]=='\0'){- snprint(fmt, sizeof fmt, " %%-%d.%ds", len, len);
- snprint(s, sizeof s, fmt, p);
- }else{- snprint(fmt, sizeof fmt, " %%-%d.%ds %%-%d.%ds", len, len, lens, lens);
- snprint(s, sizeof s, fmt, p, m->subject);
- }
- i = estrdup(s);
-
- return i;
- }
-
- i = estrdup("");- i = eappend(i, " ", flg);
- i = eappend(i, "\t", p);
- i = egrow(i, "\t", stripdate(m->date));
- if(ind == 0){- if(strcmp(m->type, "text")!=0 && strncmp(m->type, "text/", 5)!=0 &&
- strncmp(m->type, "multipart/", 10)!=0)
- i = egrow(i, "\t(", estrstrdup(m->type, ")"));- }else if(strncmp(m->type, "multipart/", 10) != 0)
- i = egrow(i, "\t(", estrstrdup(m->type, ")"));- if(m->subject[0] != '\0'){- i = eappend(i, "\n", nil);
- for(j=0; j<ind; j++)
- i = eappend(i, "\t", nil);
- i = eappend(i, "\t", m->subject);
+ Bprint(wfd, "\n===> %s (%s)\n", name, a->type);
+ name = a->filename;
+ if(name == nil)
+ name = "body";
+ if((suff = strchr(name, '.')) == nil)
+ suff = "";
+ Bprint(wfd, "\tcp %s%sbody%s %s/%s\n", mbox.path, a->name, suff, home, name);
+ continue;
}
- return i;
+ Bterm(wfd);
+ free(home);
+ fprint(m->ctl, "clean\n");
+ return 0;
}
-void
-mesgmenu0(Window *w, Message *mbox, char *realdir, char *dir, int ind, Biobuf *fd, int onlyone, int dotail)
+static void
+reply(Mesg *m, char **f, int nf)
{- int i;
- Message *m;
- char *name, *tmp;
- int ogf=0;
-
- if(strstr(realdir, "outgoing") != nil)
- ogf=1;
-
- /* show mail box in reverse order, pieces in forward order */
- if(ind > 0)
- m = mbox->head;
+ if(nf >= 1 && strcmp(f[0], "all") != 0)
+ compose(m->replyto, m, 1);
else
- m = mbox->tail;
- while(m != nil){- for(i=0; i<ind; i++)
- Bprint(fd, "\t");
- if(ind != 0)
- Bprint(fd, " ");
- name = estrstrdup(dir, m->name);
- tmp = info(m, ind, ogf);
- Bprint(fd, "%s%s\n", name, tmp);
- free(tmp);
- if(dotail && m->tail)
- mesgmenu0(w, m, realdir, name, ind+1, fd, 0, dotail);
- free(name);
- if(ind)
- m = m->next;
- else
- m = m->prev;
- if(onlyone)
- m = nil;
- }
+ compose(m->replyto, m, 0);
}
-void
-mesgmenu(Window *w, Message *mbox)
+static void
+delmesg(Mesg *m, char **, int nf)
{- winopenbody(w, OWRITE);
- mesgmenu0(w, mbox, mbox->name, "", 0, w->body, 0, !shortmenu);
- winclosebody(w);
-}
-
-/* one new message has arrived, as mbox->tail */
-void
-mesgmenunew(Window *w, Message *mbox)
-{- Biobuf *b;
-
- winselect(w, "0", 0);
- w->data = winopenfile(w, "data");
- b = emalloc(sizeof(Biobuf));
- Binit(b, w->data, OWRITE);
- mesgmenu0(w, mbox, mbox->name, "", 0, b, 1, !shortmenu);
- Bterm(b);
- free(b);
- if(!mbox->dirty)
- winclean(w);
- /* select tag line plus following indented lines, but not final newline (it's distinctive) */
- winselect(w, "0/.*\\n((\t.*\\n)*\t.*)?/", 1);
- close(w->addr);
- close(w->data);
- w->addr = -1;
- w->data = -1;
-}
-
-char*
-name2regexp(char *prefix, char *s)
-{- char *buf, *p, *q;
-
- buf = emalloc(strlen(prefix)+2*strlen(s)+50); /* leave room to append more */
- p = buf;
- *p++ = '0';
- *p++ = '/';
- *p++ = '^';
- strcpy(p, prefix);
- p += strlen(prefix);
- for(q=s; *q!='\0'; q++){- if(strchr(regexchars, *q) != nil)
- *p++ = '\\';
- *p++ = *q;
+ if(nf != 0){+ fprint(2, "Delmesg: too many args\n");
+ return;
}
- *p++ = '/';
- *p = '\0';
- return buf;
+ m->flags |= Ftodel;
+ m->quitting = 1;
+ mbredraw(m, 0, 0);
}
-void
-mesgmenumarkdel(Window *w, Message *mbox, Message *m, int writeback)
+static void
+markone(Mesg *m, char **f, int nf)
{- char *buf;
+ int add, flg, fd;
+ char *path;
-
- if(m->deleted)
+ if(nf != 1){+ fprint(2, "Mark: invalid arguments");
return;
- m->writebackdel = writeback;
- if(w->data < 0)
- w->data = winopenfile(w, "data");
- buf = name2regexp("", m->name);- strcat(buf, "-#0");
- if(winselect(w, buf, 1))
- write(w->data, deleted, 10);
- free(buf);
- close(w->data);
- close(w->addr);
- w->addr = w->data = -1;
- mbox->dirty = 1;
- m->deleted = 1;
-}
+ }
-void
-mesgmenumarkundel(Window *w, Message*, Message *m)
-{- char *buf;
-
- if(m->deleted == 0)
+ if((flg = mesgflagparse(f[0], &add)) == -1){+ fprint(2, "Mark: invalid flags %s\n", f[0]);
return;
- if(w->data < 0)
- w->data = winopenfile(w, "data");
- buf = name2regexp(deletedrx, m->name);
- if(winselect(w, buf, 1))
- if(winsetaddr(w, deletedaddr, 1))
- write(w->data, "", 0);
- free(buf);
- close(w->data);
- close(w->addr);
- w->addr = w->data = -1;
- m->deleted = 0;
-}
-
-void
-mesgmenudel(Window *w, Message *mbox, Message *m)
-{- char *buf;
-
- if(w->data < 0)
- w->data = winopenfile(w, "data");
- buf = name2regexp(deletedrx, m->name);
- if(winsetaddr(w, buf, 1) && winsetaddr(w, ".,./.*\\n(\t.*\\n)*/", 1))
- write(w->data, "", 0);
- free(buf);
- close(w->data);
- close(w->addr);
- w->addr = w->data = -1;
- mbox->dirty = 1;
- m->deleted = 1;
-}
-
-void
-mesgmenureflag(Window *w, Message *m)
-{- char *buf, flg[16];
-
- fmtflags(flg, m->flags);
- buf = name2regexp(deletedrx01, m->name);
- strcat(buf, "+/\\[[^\\]]*\\]/");
- if(w->data < 0)
- w->data = winopenfile(w, "data");
- if(winselect(w, buf, 1))
- write(w->data, flg, strlen(flg));
- free(buf);
-
- close(w->data);
- w->data = -1;
-}
-
-void
-mesgmenumark(Window *w, char *which, char *mark)
-{- char *buf;
-
- if(w->data < 0)
- w->data = winopenfile(w, "data");
- buf = name2regexp(deletedrx01, which);
- if(winsetaddr(w, buf, 1) && winsetaddr(w, "+0-#1", 1)) /* go to end of line */
- write(w->data, mark, strlen(mark));
- free(buf);
- close(w->data);
- close(w->addr);
- w->addr = w->data = -1;
- if(!mbox.dirty)
- winclean(w);
-}
-
-void
-mesgfreeparts(Message *m)
-{- free(m->name);
- free(m->replyname);
- free(m->fromcolon);
- free(m->from);
- free(m->to);
- free(m->cc);
- free(m->replyto);
- free(m->date);
- free(m->subject);
- free(m->type);
- free(m->disposition);
- free(m->filename);
- free(m->flags);
- free(m->digest);
-}
-
-void
-mesgdel(Message *mbox, Message *m)
-{- Message *n, *next;
-
- if(m->opened)
- error("internal error: deleted message still open in mesgdel");- /* delete subparts */
- for(n=m->head; n!=nil; n=next){- next = n->next;
- mesgdel(m, n);
}
- /* remove this message from list */
- if(m->next)
- m->next->prev = m->prev;
+ if(add)
+ m->flags |= flg;
else
- mbox->tail = m->prev;
- if(m->prev)
- m->prev->next = m->next;
- else
- mbox->head = m->next;
-
- mesgfreeparts(m);
-}
-
-int
-deliver(char *folder, char *file)
-{- char *av[4];
- int pid, wpid, nz;
- Waitmsg *w;
-
- pid = fork();
- switch(pid){- case -1:
- return -1;
- case 0:
- av[0] = "mbappend";
- av[1] = folder;
- av[2] = file;
- av[3] = 0;
- exec("/bin/upas/mbappend", av);- _exits("b0rked");- return -1;
- default:
- while(w = wait()){- nz = !w->msg || !w->msg[0];
- if(!nz)
- werrstr("%s", w->msg);- wpid = w->pid;
- free(w);
- if(wpid == pid)
- return nz? 0: -1;
+ m->flags &= ~flg;
+ if(strlen(f[0]) != 0){+ path = estrjoin(mbox.path, "/", m->name, "/flags", nil);
+ if((fd = open(path, OWRITE)) != -1){+ fprint(fd, f[0]);
+ close(fd);
}
- return -1;
+ free(path);
}
+ mbredraw(m, 0, 0);
}
-int
-mesgsave(Message *m, char *s)
-{- char *t;
- int ret;
- t = smprint("%s/%s/rawunix", mbox.name, m->name);- if(s[0] != '/')
- s = estrdup(s);
- else
- s = smprint("%s/%s", mailboxdir, s);- ret = 1;
- if(deliver(s, t) == -1){- fprint(2, "Mail: save failed: can't write %s: %r\n", s);
- ret = 0;
- }
- setflags(m, "S");
- free(s);
- free(t);
- return ret;
-}
-
-int
-mesgcommand(Message *m, char *cmd)
+static void
+mesgquit(Mesg *m, char **, int)
{- char *s;
- char *args[10];
- int ok, ret, nargs;
-
- s = cmd;
- ret = 1;
- nargs = tokenize(s, args, nelem(args));
- if(nargs == 0)
- return 0;
- if(strcmp(args[0], "Post") == 0){- mesgsend(m);
- goto Return;
- }
- if(strncmp(args[0], "Save", 4) == 0){- if(m->isreply)
- goto Return;
- s = estrdup("\t[saved");- if(nargs==1 || strcmp(args[1], "")==0){- ok = mesgsave(m, "stored");
- }else{- ok = mesgsave(m, args[1]);
- s = eappend(s, " ", args[1]);
- }
- if(ok){- s = egrow(s, "]", nil);
- mesgmenumark(mbox.w, m->name, s);
- }
- free(s);
- setflags(m, "S");
- goto Return;
- }
- if(strcmp(args[0], "Reply")==0){- if(nargs>=2 && strcmp(args[1], "all")==0)
- mkreply(m, "Replyall", nil, nil, nil);
- else
- mkreply(m, "Reply", nil, nil, nil);
- goto Return;
- }
- if(strcmp(args[0], "Q") == 0){- s = winselection(m->w); /* will be freed by mkreply */
- if(nargs>=3 && strcmp(args[1], "Reply")==0 && strcmp(args[2], "all")==0)
- mkreply(m, "QReplyall", nil, nil, s);
- else
- mkreply(m, "QReply", nil, nil, s);
- goto Return;
- }
- if(strcmp(args[0], "Del") == 0){- if(windel(m->w, 0)){- chanfree(m->w->cevent);
- free(m->w);
- m->w = nil;
- if(m->isreply)
- delreply(m);
- else{- m->opened = 0;
- m->tagposted = 0;
- }
- free(cmd);
- threadexits(nil);
- }
- goto Return;
- }
- if(strcmp(args[0], "Delmesg") == 0){- if(!m->isreply){- mesgmenumarkdel(wbox, &mbox, m, 1);
- free(cmd); /* mesgcommand might not return */
- mesgcommand(m, estrdup("Del"));- return 1;
- }
-// setflags(m, "d");
- goto Return;
- }
- if(strcmp(args[0], "UnDelmesg") == 0){- if(!m->isreply && m->deleted)
- mesgmenumarkundel(wbox, &mbox, m);
-// setflags(m, "-d");
- goto Return;
- }
-// if(strcmp(args[0], "Headers") == 0){-// m->showheaders();
-// return True;
-// }
-
- ret = 0;
-
- Return:
- free(cmd);
- return ret;
-}
-
-void
-mesgtagpost(Message *m)
-{- if(m->tagposted)
+ if(fprint(m->ctl, "del\n") == -1)
return;
- wintagwrite(m->w, " Post", 5);
- m->tagposted = 1;
+ m->quitting = 1;
+ m->open = 0;
}
-/* need to expand selection more than default word */
-#pragma varargck argpos eval 2
+static Fn mesgfn[] = {+ {"Reply", reply},+ {"Delmesg", delmesg},+ {"Del", mesgquit},+ {"Mark", markone},+#ifdef NOTYET
+ {"Save", nil},+#endif
+ {nil}+};
-long
-eval(Window *w, char *s, ...)
+static void
+mesgmain(void *mp)
{- char buf[64];
- va_list arg;
+ char *path, *f[32];
+ Event ev;
+ Mesg *m, **pm;
+ Fn *p;
+ int nf;
- va_start(arg, s);
- vsnprint(buf, sizeof buf, s, arg);
- va_end(arg);
+ m = mp;
+ m->quitting = 0;
+ m->qnext = mbox.openmesg;
+ mbox.openmesg = m;
- if(winsetaddr(w, buf, 1)==0)
- return -1;
+ path = estrjoin(mbox.path, m->name, nil);
+ wininit(m, path);
+ free(path);
- if(pread(w->addr, buf, 24, 0) != 24)
- return -1;
- return strtol(buf, 0, 10);
-}
-
-int
-isemail(char *s)
-{- int nat;
-
- nat = 0;
- for(; *s; s++)
- if(*s == '@')
- nat++;
- else if(!isalpha(*s) && !isdigit(*s) && !strchr("_.-+/", *s))- return 0;
- return nat==1;
-}
-
-char addrdelim[] = "/[ \t\\n<>()\\[\\]]/";
-char*
-expandaddr(Window *w, Event *e)
-{- char *s;
- long q0, q1;
-
- if(e->q0 != e->q1) /* cannot happen */
- return nil;
-
- q0 = eval(w, "#%d-%s", e->q0, addrdelim);
- if(q0 == -1) /* bad char not found */
- q0 = 0;
- else /* increment past bad char */
- q0++;
-
- q1 = eval(w, "#%d+%s", e->q0, addrdelim);
- if(q1 < 0){- q1 = eval(w, "$");
- if(q1 < 0)
- return nil;
- }
- if(q0 >= q1)
- return nil;
- s = emalloc((q1-q0)*UTFmax+1);
- winread(w, q0, q1, s);
- return s;
-}
-
-int
-replytoaddr(Window *w, Message *m, Event *e, char *s)
-{- int did;
- char *buf;
- Plumbmsg *pm;
-
- buf = nil;
- did = 0;
- if(e->flag & 2){- /* autoexpanded; use our own bigger expansion */
- buf = expandaddr(w, e);
- if(buf == nil)
- return 0;
- s = buf;
- }
- if(isemail(s)){- did = 1;
- pm = emalloc(sizeof(Plumbmsg));
- pm->src = estrdup("Mail");- pm->dst = estrdup("sendmail");- pm->data = estrdup(s);
- pm->ndata = -1;
- if(m->subject && m->subject[0]){- pm->attr = emalloc(sizeof(Plumbattr));
- pm->attr->name = estrdup("Subject");- if(tolower(m->subject[0]) != 'r' || tolower(m->subject[1]) != 'e' || m->subject[2] != ':')
- pm->attr->value = estrstrdup("Re: ", m->subject);+ wintagwrite(m, "Reply all Delmesg Save ");
+ mesgshow(m);
+ fprint(m->ctl, "clean\n");
+ mbox.nopen++;
+ while(!m->quitting){+ if(winevent(m, &ev) != 'M')
+ continue;
+ if(strcmp(ev.text, "Del") == 0)
+ break;
+ switch(ev.type){+ case 'l':
+ case 'L':
+ if(matchmesg(m, ev.text))
+ mesgopen(ev.text, nil);
else
- pm->attr->value = estrdup(m->subject);
- pm->attr->next = nil;
- }
- if(plumbsend(plumbsendfd, pm) < 0)
- fprint(2, "error writing plumb message: %r\n");
- plumbfree(pm);
- }
- free(buf);
- return did;
-}
-
-
-void
-mesgctl(void *v)
-{- Message *m;
- Window *w;
- Event *e, *eq, *e2, *ea;
- int na, nopen, i, j;
- char *os, *s, *t, *buf;
-
- m = v;
- w = m->w;
- threadsetname("mesgctl");- proccreate(wineventproc, w, STACK);
- for(;;){- e = recvp(w->cevent);
- switch(e->c1){- default:
- Unk:
- print("unknown message %c%c\n", e->c1, e->c2);+ winreturn(m, &ev);
break;
-
- case 'E': /* write to body; can't affect us */
- break;
-
- case 'F': /* generated by our actions; ignore */
- break;
-
- case 'K': /* type away; we don't care */
- case 'M':
- switch(e->c2){- case 'x': /* mouse only */
- case 'X':
- ea = nil;
- eq = e;
- if(e->flag & 2){- e2 = recvp(w->cevent);
- eq = e2;
+ case 'x':
+ case 'X':
+ if((nf = tokenize(ev.text, f, nelem(f))) == 0)
+ continue;
+ for(p = mesgfn; p->fn != nil; p++){+ if(strcmp(p->name, f[0]) == 0 && p->fn != nil){+ p->fn(m, &f[1], nf - 1);
+ break;
}
- if(e->flag & 8){- ea = recvp(w->cevent);
- recvp(w->cevent);
- na = ea->nb;
- }else
- na = 0;
- if(eq->q1>eq->q0 && eq->nb==0){- s = emalloc((eq->q1-eq->q0)*UTFmax+1);
- winread(w, eq->q0, eq->q1, s);
- }else
- s = estrdup(eq->b);
- if(na){- t = emalloc(strlen(s)+1+na+1);
- sprint(t, "%s %s", s, ea->b);
- free(s);
- s = t;
- }
- if(!mesgcommand(m, s)) /* send it back */
- winwriteevent(w, e);
- break;
-
- case 'l': /* mouse only */
- case 'L':
- buf = nil;
- eq = e;
- if(e->flag & 2){- e2 = recvp(w->cevent);
- eq = e2;
- }
- s = eq->b;
- if(eq->q1>eq->q0 && eq->nb==0){- buf = emalloc((eq->q1-eq->q0)*UTFmax+1);
- winread(w, eq->q0, eq->q1, buf);
- s = buf;
- }
- os = s;
- nopen = 0;
- do{- /* skip mail box name if present */
- if(strncmp(s, mbox.name, strlen(mbox.name)) == 0)
- s += strlen(mbox.name);
- if(strstr(s, "body") != nil){- /* strip any known extensions */
- for(i=0; exts[i].ext!=nil; i++){- j = strlen(exts[i].ext);
- if(strlen(s)>j && strcmp(s+strlen(s)-j, exts[i].ext)==0){- s[strlen(s)-j] = '\0';
- break;
- }
- }
- if(strlen(s)>5 && strcmp(s+strlen(s)-5, "/body")==0)
- s[strlen(s)-4] = '\0'; /* leave / in place */
- }
- nopen += mesgopen(&mbox, mbox.name, s, m, 0, nil);
- while(*s!=0 && *s++!='\n')
- ;
- }while(*s);
- if(nopen == 0 && e->c1 == 'L')
- nopen += replytoaddr(w, m, e, os);
- if(nopen == 0)
- winwriteevent(w, e);
- free(buf);
- break;
-
- case 'I': /* modify away; we don't care */
- case 'D':
- mesgtagpost(m);
- /* fall through */
- case 'd':
- case 'i':
- break;
-
- default:
- goto Unk;
}
+ if(p->fn == nil)
+ winreturn(m, &ev);
+ break;
}
}
-}
-
-void
-mesgline(Message *m, char *header, char *value)
-{- if(strlen(value) > 0)
- Bprint(m->w->body, "%s: %s\n", header, value);
-}
-
-int
-isprintable(char *type)
-{- int i;
-
- for(i=0; goodtypes[i]!=nil; i++)
- if(strcmp(type, goodtypes[i])==0)
- return 1;
- return 0;
-}
-
-char*
-ext(char *type)
-{- int i;
-
- for(i=0; exts[i].type!=nil; i++)
- if(strcmp(type, exts[i].type)==0)
- return exts[i].ext;
- return "";
-}
-
-void
-mimedisplay(Message *m, char *name, char *rootdir, Window *w, int fileonly)
-{- char *dest, *maildest;
-
- if(strcmp(m->disposition, "file")==0 || strlen(m->filename)!=0){- if(strlen(m->filename) == 0){- dest = estrdup(m->name);
- dest[strlen(dest)-1] = '\0';
- }else
- dest = estrdup(m->filename);
- if(maildest = getenv("maildest")){- maildest = eappend(maildest, "/", dest);
- Bprint(w->body, "\tcp %s%sbody%s %q\n", rootdir, name, ext(m->type), maildest);
- free(maildest);
+ for(pm = &mbox.openmesg; *pm != nil; pm = &(*pm)->qnext)
+ if(*pm == m){+ *pm = m->qnext;
+ break;
}
- if(m->filename[0] != '/')
- dest = egrow(estrdup(home), "/", dest);
- Bprint(w->body, "\tcp %s%sbody%s %q\n", rootdir, name, ext(m->type), dest);
- free(dest);
- }else if(!fileonly)
- Bprint(w->body, "\tfile is %s%sbody%s\n", rootdir, name, ext(m->type));
+ mbox.nopen--;
+ m->qnext = nil;
+ m->state &= ~Sopen;
+ winclose(m);
+ threadexits(nil);
}
-void
-printheader(char *dir, Biobuf *b, char **okheaders)
-{- char *s;
- char *lines[100];
- int i, j, n;
-
- s = readfile(dir, "header", nil);
- if(s == nil)
- return;
- n = getfields(s, lines, nelem(lines), 0, "\n");
- for(i=0; i<n; i++)
- for(j=0; okheaders[j]; j++)
- if(cistrncmp(lines[i], okheaders[j], strlen(okheaders[j])) == 0)
- Bprint(b, "%s\n", lines[i]);
- free(s);
-}
-
-void
-mesgload(Message *m, char *rootdir, char *file, Window *w)
-{- char *s, *subdir, *name, *dir;
- Message *mp, *thisone;
- int n;
-
- dir = estrstrdup(rootdir, file);
-
- if(strcmp(m->type, "message/rfc822") != 0){ /* suppress headers of envelopes */- if(strlen(m->from) > 0){- Bprint(w->body, "From: %s\n", m->from);
- mesgline(m, "Date", m->date);
- mesgline(m, "To", m->to);
- mesgline(m, "CC", m->cc);
- mesgline(m, "Subject", m->subject);
- printheader(dir, w->body, extraheaders);
- }else{- printheader(dir, w->body, okheaders);
- printheader(dir, w->body, extraheaders);
- }
- Bprint(w->body, "\n");
- }
-
- if(m->level == 1 && m->recursed == 0){- m->recursed = 1;
- readmbox(m, rootdir, m->name);
- }
- if(m->head == nil){ /* single part message */- if(strcmp(m->type, "text")==0 || strncmp(m->type, "text/", 5)==0){- mimedisplay(m, m->name, rootdir, w, 1);
- s = readbody(m->type, dir, &n);
- winwritebody(w, s, n);
- free(s);
- }else
- mimedisplay(m, m->name, rootdir, w, 0);
- }else{- /* multi-part message, either multipart/* or message/rfc822 */
- thisone = nil;
- if(strcmp(m->type, "multipart/alternative") == 0){- thisone = m->head; /* in case we can't find a good one */
- for(mp=m->head; mp!=nil; mp=mp->next)
- if(isprintable(mp->type)){- thisone = mp;
- break;
- }
- }
- for(mp=m->head; mp!=nil; mp=mp->next){- if(thisone!=nil && mp!=thisone)
- continue;
- subdir = estrstrdup(dir, mp->name);
- name = estrstrdup(file, mp->name);
- /* skip first element in name because it's already in window name */
- if(mp != m->head)
- Bprint(w->body, "\n===> %s (%s) [%s]\n", strchr(name, '/')+1, mp->type, mp->disposition);
- if(strcmp(mp->type, "text")==0 || strncmp(mp->type, "text/", 5)==0){- mimedisplay(mp, name, rootdir, w, 1);
- printheader(subdir, w->body, okheaders);
- printheader(subdir, w->body, extraheaders);
- winwritebody(w, "\n", 1);
- s = readbody(mp->type, subdir, &n);
- winwritebody(w, s, n);
- free(s);
- }else{- if(strncmp(mp->type, "multipart/", 10)==0 || strcmp(mp->type, "message/rfc822")==0){- mp->w = w;
- mesgload(mp, rootdir, name, w);
- mp->w = nil;
- }else
- mimedisplay(mp, name, rootdir, w, 0);
- }
- free(name);
- free(subdir);
- }
- }
- free(dir);
-}
-
int
-tokenizec(char *str, char **args, int max, char *splitc)
+mesgflagparse(char *fstr, int *add)
{- int na;
- int intok = 0;
+ int flg;
- if(max <= 0)
- return 0;
- for(na=0; *str != '\0';str++){- if(strchr(splitc, *str) == nil){- if(intok)
- continue;
- args[na++] = str;
- intok = 1;
- }else{- /* it's a separator/skip character */
- *str = '\0';
- if(intok){- intok = 0;
- if(na >= max)
- break;
- }
+ flg = 0;
+ *add = (*fstr == '+');
+ if(*fstr == '-' || *fstr == '+')
+ fstr++;
+ for(; *fstr; fstr++){+ switch(*fstr){+ case 'a':
+ flg |= Fresp;
+ break;
+ case 's':
+ flg |= Fseen;
+ break;
+ case 'D':
+ flg |= Ftodel;
+ memcpy(fstr, fstr +1, strlen(fstr));
+ break;
+ default:
+ fprint(2, "unknown flag %c", *fstr);
+ return -1;
}
}
- return na;
+ return flg;
}
-Message*
-mesglookup(Message *mbox, char *name, char *digest)
+void
+mesgpath2name(char *buf, int nbuf, char *name)
{+ char *p, *e;
int n;
- Message *m;
- char *t;
- if(digest){- /* can find exactly */
- for(m=mbox->head; m!=nil; m=m->next)
- if(strcmp(digest, m->digest) == 0)
- break;
- return m;
- }
-
- n = strlen(name);
- if(n == 0)
- return nil;
- if(name[n-1] == '/')
- t = estrdup(name);
+ n = strlen(mbox.path);
+ if(strncmp(name, mbox.path, n) == 0)
+ e = strecpy(buf, buf+nbuf-2, name + n);
else
- t = estrstrdup(name, "/");
- for(m=mbox->head; m!=nil; m=m->next)
- if(strcmp(t, m->name) == 0)
- break;
- free(t);
- return m;
+ e = strecpy(buf, buf+nbuf-2, name);
+ if((p = strchr(buf, '/')) == nil)
+ p = e;
+ p[0] = '/';
+ p[1] = 0;
}
-/*
- * Find plumb port, knowing type is text, given file name (by extension)
- */
int
-plumbportbysuffix(char *file)
+mesgmatch(Mesg *m, char *name, char *digest)
{- char *suf;
- int i, nsuf, nfile;
-
- nfile = strlen(file);
- for(i=0; ports[i].type!=nil; i++){- suf = ports[i].suffix;
- nsuf = strlen(suf);
- if(nfile > nsuf)
- if(cistrncmp(file+nfile-nsuf, suf, nsuf) == 0)
- return i;
- }
+ if(!(m->state & Sdummy) && strcmp(m->name, name) == 0)
+ return digest == nil || strcmp(m->digest, digest) == 0;
return 0;
}
-/*
- * Find plumb port using type and file name (by extension)
- */
-int
-plumbport(char *type, char *file)
+Mesg*
+mesglookup(char *name, char *digest)
{+ char buf[32];
int i;
- for(i=0; ports[i].type!=nil; i++)
- if(strncmp(type, ports[i].type, strlen(ports[i].type)) == 0)
- return i;
- /* see if it's a text type */
- for(i=0; goodtypes[i]!=nil; i++)
- if(strncmp(type, goodtypes[i], strlen(goodtypes[i])) == 0)
- return plumbportbysuffix(file);
- return -1;
+ mesgpath2name(buf, sizeof(buf), name);
+ for(i = 0; i < mbox.nmesg; i++)
+ if(mesgmatch(mbox.mesg[i], buf, digest))
+ return mbox.mesg[i];
+ return nil;
}
-void
-plumb(Message *m, char *dir)
+Mesg*
+mesgopen(char *name, char *digest)
{- int i;
- char *port;
- Plumbmsg *pm;
+ Mesg *m;
+ char *path;
+ int fd;
- if(strlen(m->type) == 0)
- return;
- i = plumbport(m->type, m->filename);
- if(i < 0)
- fprint(2, "can't find destination for message subpart\n");
- else{- port = ports[i].port;
- pm = emalloc(sizeof(Plumbmsg));
- pm->src = estrdup("Mail");- if(port)
- pm->dst = estrdup(port);
- else
- pm->dst = nil;
- pm->wdir = nil;
- pm->type = estrdup("text");- pm->ndata = -1;
- pm->data = estrstrdup(dir, "body");
- pm->data = eappend(pm->data, "", ports[i].suffix);
- if(plumbsend(plumbsendfd, pm) < 0)
- fprint(2, "error writing plumb message: %r\n");
- plumbfree(pm);
- }
-}
+ m = mesglookup(name, digest);
+ if(m == nil || (m->state & Sopen))
+ return nil;
-int
-mesgopen(Message *mbox, char *dir, char *s, Message *mesg, int plumbed, char *digest)
-{- char *t, *u, *v;
- Message *m;
- char *direlem[10];
- int i, ndirelem, reuse;
-
- /* find white-space-delimited first word */
- for(t=s; *t!='\0' && !isspace(*t); t++)
- ;
- u = emalloc(t-s+1);
- memmove(u, s, t-s);
- /* separate it on slashes */
- ndirelem = tokenizec(u, direlem, nelem(direlem), "/");
- if(ndirelem <= 0){- Error:
- free(u);
- return 0;
- }
- if(plumbed){- write(wctlfd, "top", 3);
- write(wctlfd, "current", 7);
- }
- /* open window for message */
- m = mesglookup(mbox, direlem[0], digest);
- if(m == nil)
- goto Error;
- if(mesg!=nil && m!=mesg) /* string looked like subpart but isn't part of this message */
- goto Error;
- if(m->opened == 0){- if(m->w == nil){- reuse = 0;
- m->w = newwindow();
- }else{- reuse = 1;
- /* re-use existing window */
- if(winsetaddr(m->w, "0,$", 1)){- if(m->w->data < 0)
- m->w->data = winopenfile(m->w, "data");
- write(m->w->data, "", 0);
- }
+ assert(!(m->state & Sdummy));
+ m->state |= Sopen;
+ if(!(m->flags & Fseen)){+ m->flags |= Fseen;
+ path = estrjoin(mbox.path, "/", m->name, "/flags", nil);
+ if((fd = open(path, OWRITE)) != -1){+ fprint(fd, "+s");
+ close(fd);
}
- v = estrstrdup(mbox->name, m->name);
- winname(m->w, v);
- free(v);
- if(!reuse){- if(m->deleted)
- wintagwrite(m->w, "Q Reply all UnDelmesg Save ", 2+6+4+10+5);
- else
- wintagwrite(m->w, "Q Reply all Delmesg Save ", 2+6+4+8+5);
- }
- threadcreate(mesgctl, m, STACK);
- winopenbody(m->w, OWRITE);
- mesgload(m, dir, m->name, m->w);
- winclosebody(m->w);
- winclean(m->w);
- m->opened = 1;
- setflags(m, "s");
- mesgmenureflag(mbox->w, m);
- if(ndirelem == 1){- free(u);
- return 1;
- }
+ mbredraw(m, 0, 0);
+ free(path);
}
- if(ndirelem == 1 && plumbport(m->type, m->filename) <= 0){- /* make sure dot is visible */
- ctlprint(m->w->ctl, "show\n");
- return 0;
- }
- /* walk to subpart */
- dir = estrstrdup(dir, m->name);
- for(i=1; i<ndirelem; i++){- m = mesglookup(m, direlem[i], digest);
- if(m == nil)
- break;
- dir = egrow(dir, m->name, nil);
- }
- if(m != nil && plumbport(m->type, m->filename) > 0)
- plumb(m, dir);
- free(dir);
- free(u);
- return 1;
+ threadcreate(mesgmain, m, Stack);
+ return m;
}
-void
-rewritembox(Window *w, Message *mbox)
+Biobuf*
+mesgopenbody(Mesg *m)
{- Message *m, *next;
- char *deletestr, *t;
- int nopen;
+ char *path;
+ int rfd;
+ Mesg *b;
- deletestr = estrstrdup("delete ", fsname);-
- nopen = 0;
- for(m=mbox->head; m!=nil; m=next){- next = m->next;
- if(m->deleted == 0)
- continue;
- if(m->opened){- nopen++;
- continue;
- }
- if(m->writebackdel){- /* messages deleted by plumb message are not removed again */
- t = estrdup(m->name);
- if(strlen(t) > 0)
- t[strlen(t)-1] = '\0';
- deletestr = egrow(deletestr, " ", t);
- }
- mesgmenudel(w, mbox, m);
- mesgdel(mbox, m);
- }
- if(write(mbox->ctlfd, deletestr, strlen(deletestr)) < 0)
- fprint(2, "Mail: warning: error removing mail message files: %r\n");
- free(deletestr);
- winselect(w, "0", 0);
- if(nopen == 0)
- winclean(w);
- mbox->dirty = 0;
-}
-
-/* name is a full file name, but it might not belong to us */
-Message*
-mesglookupfile(Message *mbox, char *name, char *digest)
-{- int k, n;
-
- k = strlen(name);
- n = strlen(mbox->name);
- if(k==0 || strncmp(name, mbox->name, n) != 0){-// fprint(2, "Mail: message %s not in this mailbox\n", name);
+ b = readparts(m);
+ path = estrjoin(mbox.path, b->name, "body", nil);
+ if(strcmp(b->type, "text/html") == 0)
+ rfd = htmlfmt(m, path);
+ else
+ rfd = open(path, OREAD);
+ free(path);
+ if(rfd == -1)
return nil;
- }
- return mesglookup(mbox, name+n, digest);
+ return Bfdopen(rfd, OREAD);
}
--- a/sys/src/cmd/upas/Mail/mkfile
+++ b/sys/src/cmd/upas/Mail/mkfile
@@ -1,25 +1,14 @@
</$objtype/mkfile
+BIN=/acme/bin/$objtype
TARG=Mail
OFILES=\
- html.$O\
- mail.$O\
+ mbox.$O\
mesg.$O\
- reply.$O\
+ comp.$O\
util.$O\
- win.$O\
+ win.$O
-HFILES=dat.h
+HFILES=mail.h
-# BIN=/acme/bin/$objtype
-BIN=$ABIN
-
</sys/src/cmd/mkone
-<../mkupas
-
-$O.out: $OFILES
- $LD -o $target $LDFLAGS $OFILES
-
-syms:V:
- $CC -a mail.c >syms
- $CC -aa mesg.c reply.c util.c win.c >>syms
--- a/sys/src/cmd/upas/Mail/reply.c
+++ /dev/null
@@ -1,578 +1,0 @@
-#include <u.h>
-#include <libc.h>
-#include <bio.h>
-#include <thread.h>
-#include <ctype.h>
-#include <plumb.h>
-#include "dat.h"
-
-static int replyid;
-
-int
-quote(Message *m, Biobuf *b, char *dir, char *quotetext)
-{- char *body, *type;
- int i, n, nlines;
- char **lines;
-
- if(quotetext){- body = quotetext;
- n = strlen(body);
- type = nil;
- }else{- /* look for first textual component to quote */
- type = readfile(dir, "type", &n);
- if(type == nil){- print("no type in %s\n", dir);- return 0;
- }
- if(strncmp(type, "multipart/", 10)==0 || strncmp(type, "message/", 8)==0){- dir = estrstrdup(dir, "1/");
- if(quote(m, b, dir, nil)){- free(type);
- free(dir);
- return 1;
- }
- free(dir);
- }
- if(strncmp(type, "text", 4) != 0){- free(type);
- return 0;
- }
- body = readbody(m->type, dir, &n);
- if(body == nil)
- return 0;
- }
- nlines = 0;
- for(i=0; i<n; i++)
- if(body[i] == '\n')
- nlines++;
- nlines++;
- lines = emalloc(nlines*sizeof(char*));
- nlines = getfields(body, lines, nlines, 0, "\n");
- /* delete leading and trailing blank lines */
- i = 0;
- while(i<nlines && lines[i][0]=='\0')
- i++;
- while(i<nlines && lines[nlines-1][0]=='\0')
- nlines--;
- while(i < nlines){- Bprint(b, ">%s%s\n", lines[i][0]=='>'? "" : " ", lines[i]);
- i++;
- }
- free(lines);
- free(body); /* will free quotetext if non-nil */
- free(type);
- return 1;
-}
-
-void
-mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
-{- Message *r;
- char *dir, *t;
- int quotereply;
- Plumbattr *a;
-
- quotereply = (label[0] == 'Q');
- r = emalloc(sizeof(Message));
- r->isreply = 1;
- if(m != nil){- r->replyname = estrdup(m->name);
- r->replydigest = estrdup(m->digest);
- }
- r->next = replies.head;
- r->prev = nil;
- if(replies.head != nil)
- replies.head->prev = r;
- replies.head = r;
- if(replies.tail == nil)
- replies.tail = r;
- r->name = emalloc(strlen(mbox.name)+strlen(label)+10);
- sprint(r->name, "%s%s%d", mbox.name, label, ++replyid);
- r->w = newwindow();
- winname(r->w, r->name);
- ctlprint(r->w->ctl, "cleartag");
- wintagwrite(r->w, "fmt Look Post Undo", 4+5+5+4);
- r->tagposted = 1;
- threadcreate(mesgctl, r, STACK);
- winopenbody(r->w, OWRITE);
- if(to!=nil && to[0]!='\0')
- Bprint(r->w->body, "%s\n", to);
- for(a=attr; a; a=a->next)
- Bprint(r->w->body, "%s: %s\n", a->name, a->value);
- dir = nil;
- if(m != nil){- dir = estrstrdup(mbox.name, m->name);
- if(to == nil && attr == nil){- /* Reply goes to replyto; Reply all goes to From and To and CC */
- if(strstr(label, "all") == nil)
- Bprint(r->w->body, "To: %s\n", m->replyto);
- else{ /* Replyall */- if(strlen(m->from) > 0)
- Bprint(r->w->body, "To: %s\n", m->from);
- if(strlen(m->to) > 0)
- Bprint(r->w->body, "To: %s\n", m->to);
- if(strlen(m->cc) > 0)
- Bprint(r->w->body, "CC: %s\n", m->cc);
- }
- }
- if(strlen(m->subject) > 0){- t = "Subject: Re: ";
- if(strlen(m->subject) >= 3)
- if(tolower(m->subject[0])=='r' && tolower(m->subject[1])=='e' && m->subject[2]==':')
- t = "Subject: ";
- Bprint(r->w->body, "%s%s\n", t, m->subject);
- }
- if(!quotereply){- Bprint(r->w->body, "Include: %sraw\n", dir);
- free(dir);
- }
- }
- Bprint(r->w->body, "\n");
- if(m == nil)
- Bprint(r->w->body, "\n");
- else if(quotereply){- quote(m, r->w->body, dir, quotetext);
- free(dir);
- }
- winclosebody(r->w);
- if(m==nil && (to==nil || to[0]=='\0'))
- winselect(r->w, "0", 0);
- else
- winselect(r->w, "$", 0);
- winclean(r->w);
- windormant(r->w);
-}
-
-void
-delreply(Message *m)
-{- if(m->next == nil)
- replies.tail = m->prev;
- else
- m->next->prev = m->prev;
- if(m->prev == nil)
- replies.head = m->next;
- else
- m->prev->next = m->next;
- mesgfreeparts(m);
- free(m);
-}
-
-/* copy argv to stack and free the incoming strings, so we don't leak argument vectors */
-void
-buildargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
-{- int i, n;
- char *s, *a;
-
- s = args;
- for(i=0; i<NARGS; i++){- a = inargv[i];
- if(a == nil)
- break;
- n = strlen(a)+1;
- if((s-args)+n >= NARGCHAR) /* too many characters */
- break;
- argv[i] = s;
- memmove(s, a, n);
- s += n;
- free(a);
- }
- argv[i] = nil;
-}
-
-void
-execproc(void *v)
-{- Exec *e;
- int p[2], q[2];
- char *prog;
- char *argv[NARGS+1], args[NARGCHAR];
-
- e = v;
- p[0] = e->p[0];
- p[1] = e->p[1];
- q[0] = e->q[0];
- q[1] = e->q[1];
- prog = e->prog; /* known not to be malloc'ed */
- rfork(RFFDG);
- sendul(e->sync, 1);
- buildargv(e->argv, argv, args);
- free(e->argv);
- chanfree(e->sync);
- free(e);
- dup(p[0], 0);
- close(p[0]);
- close(p[1]);
- if(q[0]){- dup(q[1], 1);
- close(q[0]);
- close(q[1]);
- }
- procexec(nil, prog, argv);
-//fprint(2, "exec: %s", e->prog);
-//{int i;-//for(i=0; argv[i]; i++) print(" '%s'", argv[i]);-//print("\n");-//}
-//argv[0] = "cat";
-//argv[1] = nil;
-//procexec(nil, "/bin/cat", argv);
- fprint(2, "Mail: can't exec %s: %r\n", prog);
- threadexits("can't exec");-}
-
-enum{- ATTACH,
- BCC,
- CC,
- FROM,
- INCLUDE,
- TO,
-};
-
-char *headers[] = {- "attach:",
- "bcc:",
- "cc:",
- "from:",
- "include:",
- "to:",
- nil,
-};
-
-int
-whichheader(char *h)
-{- int i;
-
- for(i=0; headers[i]!=nil; i++)
- if(cistrcmp(h, headers[i]) == 0)
- return i;
- return -1;
-}
-
-char *tolist[200];
-char *cclist[200];
-char *bcclist[200];
-int ncc, nbcc, nto;
-char *attlist[200];
-char included[200];
-
-int
-addressed(char *name)
-{- int i;
-
- for(i=0; i<nto; i++)
- if(strcmp(name, tolist[i]) == 0)
- return 1;
- for(i=0; i<ncc; i++)
- if(strcmp(name, cclist[i]) == 0)
- return 1;
- for(i=0; i<nbcc; i++)
- if(strcmp(name, bcclist[i]) == 0)
- return 1;
- return 0;
-}
-
-char*
-skipbl(char *s, char *e)
-{- while(s < e){- if(*s!=' ' && *s!='\t' && *s!=',')
- break;
- s++;
- }
- return s;
-}
-
-char*
-findbl(char *s, char *e)
-{- while(s < e){- if(*s==' ' || *s=='\t' || *s==',')
- break;
- s++;
- }
- return s;
-}
-
-/*
- * comma-separate possibly blank-separated strings in line; e points before newline
- */
-void
-commas(char *s, char *e)
-{- char *t;
-
- /* may have initial blanks */
- s = skipbl(s, e);
- while(s < e){- s = findbl(s, e);
- if(s == e)
- break;
- t = skipbl(s, e);
- if(t == e) /* no more words */
- break;
- /* patch comma */
- *s++ = ',';
- while(s < t)
- *s++ = ' ';
- }
-}
-
-int
-print2(int fd, int ofd, char *fmt, ...)
-{- int m, n;
- char *s;
- va_list arg;
-
- va_start(arg, fmt);
- s = vsmprint(fmt, arg);
- va_end(arg);
- if(s == nil)
- return -1;
- m = strlen(s);
- n = write(fd, s, m);
- if(ofd >= 0)
- write(ofd, s, m);
- return n;
-}
-
-int
-write2(int fd, int ofd, char *buf, int n, int nofrom)
-{- char *from, *p;
- int m = 0;
-
- if(fd >= 0)
- m = write(fd, buf, n);
-
- if(ofd < 0)
- return m;
-
- if(nofrom == 0)
- return write(ofd, buf, n);
-
- /* need to escape leading From lines to avoid corrupting 'outgoing' mailbox */
- for(p=buf; *p; p+=m){- from = cistrstr(p, "from");
- if(from == nil)
- m = n;
- else
- m = from - p;
- if(m > 0)
- write(ofd, p, m);
- if(from){- /* escape with space if From is at start of line */
- if(p==buf || from[-1]=='\n')
- write(ofd, " ", 1);
- write(ofd, from, 4);
- m += 4;
- }
- n -= m;
- }
- return p - buf;
-}
-
-void
-mesgsend(Message *m)
-{- char *s, *body, *to;
- int i, j, h, n, natt, p[2];
- Exec *e;
- Channel *sync;
- Message *r;
- int first, nfld, delit, ofd;
- char *copy, *fld[100];
- Tzone *tz;
- Tm now;
-
- body = winreadbody(m->w, &n);
- /* assemble to: list from first line, to: line, and cc: line */
- nto = 0;
- natt = 0;
- ncc = 0;
- nbcc = 0;
- first = 1;
- to = body;
- for(;;){- for(s=to; *s!='\n'; s++)
- if(*s == '\0'){- free(body);
- return;
- }
- if(s++ == to) /* blank line */
- break;
- /* make copy of line to tokenize */
- copy = emalloc(s-to);
- memmove(copy, to, s-to);
- copy[s-to-1] = '\0';
- nfld = tokenizec(copy, fld, nelem(fld), ", \t");
- if(nfld == 0){- free(copy);
- break;
- }
- n -= s-to;
- switch(h = whichheader(fld[0])){- case TO:
- case FROM:
- delit = 1;
- commas(to+strlen(fld[0]), s-1);
- for(i=1; i<nfld && nto<nelem(tolist); i++)
- if(!addressed(fld[i]))
- tolist[nto++] = estrdup(fld[i]);
- break;
- case BCC:
- delit = 1;
- commas(to+strlen(fld[0]), s-1);
- for(i=1; i<nfld && nbcc<nelem(bcclist); i++)
- if(!addressed(fld[i]))
- bcclist[nbcc++] = estrdup(fld[i]);
- break;
- case CC:
- delit = 1;
- commas(to+strlen(fld[0]), s-1);
- for(i=1; i<nfld && ncc<nelem(cclist); i++)
- if(!addressed(fld[i]))
- cclist[ncc++] = estrdup(fld[i]);
- break;
- case ATTACH:
- case INCLUDE:
- delit = 1;
- for(i=1; i<nfld && natt<nelem(attlist); i++){- attlist[natt] = estrdup(fld[i]);
- included[natt++] = (h == INCLUDE);
- }
- break;
- default:
- if(first){- delit = 1;
- for(i=0; i<nfld && nto<nelem(tolist); i++)
- tolist[nto++] = estrdup(fld[i]);
- }else /* ignore it */
- delit = 0;
- break;
- }
- if(delit){- /* delete line from body */
- memmove(to, s, n+1);
- }else
- to = s;
- free(copy);
- first = 0;
- }
-
- ofd = open(outgoing, OWRITE|OCEXEC); /* no error check necessary */
- if(ofd >= 0){- /* From dhog Fri Aug 24 22:13:00 +0500 2001 */
- tz = tzload("local");- tmnow(&now, tz);
- fprint(ofd, "From %s %τ", user, tmfmt(&now, "WW MMM _D hh:mm:ss Z YYYY"));
- fprint(ofd, "From: %s\n", user);
- fprint(ofd, "Date: %τ", tmfmt(&now, "WW MMM _D hh:mm:ss Z YYYY"));
- for(i=0; i<natt; i++)
- if(included[i])
- fprint(ofd, "Include: %s\n", attlist[i]);
- else
- fprint(ofd, "Attach: %s\n", attlist[i]);
- /* needed because mail is by default Latin-1 */
- fprint(ofd, "Content-Type: text/plain; charset=\"UTF-8\"\n");
- fprint(ofd, "Content-Transfer-Encoding: 8bit\n");
- }
-
- e = emalloc(sizeof(Exec));
- if(pipe(p) < 0)
- error("can't create pipe: %r");- e->p[0] = p[0];
- e->p[1] = p[1];
- e->prog = "/bin/upas/marshal";
- e->argv = emalloc((1+1+2+4*natt+1)*sizeof(char*));
- e->argv[0] = estrdup("marshal");- e->argv[1] = estrdup("-8");- j = 2;
- if(m->replyname){- e->argv[j++] = estrdup("-R");- e->argv[j++] = estrstrdup(mbox.name, m->replyname);
- }
- for(i=0; i<natt; i++){- if(included[i])
- e->argv[j++] = estrdup("-A");- else
- e->argv[j++] = estrdup("-a");- e->argv[j++] = estrdup(attlist[i]);
- }
- sync = chancreate(sizeof(int), 0);
- e->sync = sync;
- proccreate(execproc, e, EXECSTACK);
- recvul(sync);
- close(p[0]);
-
- /* using marshal -8, so generate rfc822 headers */
- if(nto > 0){- print2(p[1], ofd, "To: ");
- for(i=0; i<nto-1; i++)
- print2(p[1], ofd, "%s, ", tolist[i]);
- print2(p[1], ofd, "%s\n", tolist[i]);
- }
- if(ncc > 0){- print2(p[1], ofd, "CC: ");
- for(i=0; i<ncc-1; i++)
- print2(p[1], ofd, "%s, ", cclist[i]);
- print2(p[1], ofd, "%s\n", cclist[i]);
- }
- if(nbcc > 0){- print2(p[1], ofd, "BCC: ");
- for(i=0; i<nbcc-1; i++)
- print2(p[1], ofd, "%s, ", bcclist[i]);
- print2(p[1], ofd, "%s\n", bcclist[i]);
- }
-
- i = strlen(body);
- if(i > 0)
- write2(p[1], ofd, body, i, 1);
-
- /* guarantee a blank line, to ensure attachments are separated from body */
- if(i==0 || body[i-1]!='\n')
- write2(p[1], ofd, "\n\n", 2, 0);
- else if(i>1 && body[i-2]!='\n')
- write2(p[1], ofd, "\n", 1, 0);
-
- /* these look like pseudo-attachments in the "outgoing" box */
- if(ofd>=0 && natt>0){- for(i=0; i<natt; i++)
- if(included[i])
- fprint(ofd, "=====> Include: %s\n", attlist[i]);
- else
- fprint(ofd, "=====> Attach: %s\n", attlist[i]);
- }
- if(ofd >= 0)
- write(ofd, "\n", 1);
-
- for(i=0; i<natt; i++)
- free(attlist[i]);
- close(ofd);
- close(p[1]);
- free(body);
-
- if(m->replyname){- if((r = mesglookup(&mbox, m->replyname, m->replydigest)) != nil){- setflags(r, "a");
- mesgmenureflag(mbox.w, r);
- }
- }
- if(m->name[0] == '/')
- s = estrdup(m->name);
- else
- s = estrstrdup(mbox.name, m->name);
- s = egrow(s, "-R", nil);
- winname(m->w, s);
- free(s);
- winclean(m->w);
- /* mark message unopened because it's no longer the original message */
- m->opened = 0;
-}
--- a/sys/src/cmd/upas/Mail/util.c
+++ b/sys/src/cmd/upas/Mail/util.c
@@ -2,104 +2,139 @@
#include <libc.h>
#include <bio.h>
#include <thread.h>
-#include <plumb.h>
-#include "dat.h"
+#include <regexp.h>
-void*
-emalloc(uint n)
-{- void *p;
+#include "mail.h"
- p = malloc(n);
- if(p == nil)
- error("can't malloc: %r");- memset(p, 0, n);
- setmalloctag(p, getcallerpc(&n));
- return p;
+void *
+emalloc(ulong n)
+{+ void *v;
+
+ v = mallocz(n, 1);
+ if(v == nil)
+ sysfatal("malloc: %r");+ setmalloctag(v, getcallerpc(&n));
+ return v;
}
-void*
-erealloc(void *p, uint n)
+void *
+erealloc(void *p, ulong n)
{- p = realloc(p, n);
- if(p == nil)
- error("can't realloc: %r");- setmalloctag(p, getcallerpc(&n));
- return p;
+ void *v;
+
+ v = realloc(p, n);
+ if(v == nil)
+ sysfatal("realloc: %r");+ setmalloctag(v, getcallerpc(&p));
+ return v;
}
char*
estrdup(char *s)
{- char *t;
-
- t = emalloc(strlen(s)+1);
- strcpy(t, s);
- return t;
+ s = strdup(s);
+ if(s == nil)
+ sysfatal("strdup: %r");+ setmalloctag(s, getcallerpc(&s));
+ return s;
}
char*
-estrstrdup(char *s, char *t)
+estrjoin(char *s, ...)
{- char *u;
+ va_list ap;
+ char *r, *t, *p, *e;
+ int n;
- u = emalloc(strlen(s)+strlen(t)+1);
- strcpy(u, s);
- strcat(u, t);
- return u;
+ va_start(ap, s);
+ n = strlen(s) + 1;
+ while((p = va_arg(ap, char*)) != nil)
+ n += strlen(p);
+ va_end(ap);
+
+ r = emalloc(n);
+ e = r + n;
+ va_start(ap, s);
+ t = strecpy(r, e, s);
+ while((p = va_arg(ap, char*)) != nil)
+ t = strecpy(t, e, p);
+ va_end(ap);
+ return r;
}
char*
-eappend(char *s, char *sep, char *t)
+esmprint(char *fmt, ...)
{- char *u;
+ char *s;
+ va_list ap;
- if(t == nil)
- u = estrstrdup(s, sep);
- else{- u = emalloc(strlen(s)+strlen(sep)+strlen(t)+1);
- strcpy(u, s);
- strcat(u, sep);
- strcat(u, t);
- }
- free(s);
- return u;
+ va_start(ap, fmt);
+ s = vsmprint(fmt, ap);
+ va_end(ap);
+ if(s == nil)
+ sysfatal("smprint: %r");+ setmalloctag(s, getcallerpc(&fmt));
+ return s;
}
char*
-egrow(char *s, char *sep, char *t)
+fslurp(int fd, int *nbuf)
{- s = eappend(s, sep, t);
- free(t);
- return s;
+ int n, sz, r;
+ char *buf;
+
+ n = 0;
+ sz = 128;
+ buf = emalloc(sz);
+ while(1){+ r = read(fd, buf + n, sz - n);
+ if(r == 0)
+ break;
+ if(r == -1)
+ goto error;
+ n += r;
+ if(n == sz){+ sz += sz/2;
+ buf = erealloc(buf, sz);
+ }
+ }
+ buf[n] = 0;
+ if(nbuf)
+ *nbuf = n;
+ return buf;
+error:
+ free(buf);
+ return nil;
}
-void
-error(char *fmt, ...)
+char *
+rslurp(Mesg *m, char *f, int *nbuf)
{- Fmt f;
- char buf[64];
- va_list arg;
+ char *path;
+ int fd;
+ char *r;
- fmtfdinit(&f, 2, buf, sizeof buf);
- fmtprint(&f, "Mail: ");
- va_start(arg, fmt);
- fmtvprint(&f, fmt, arg);
- va_end(arg);
- fmtprint(&f, "\n");
- fmtfdflush(&f);
- threadexitsall(fmt);
+ if(m == nil)
+ path = estrjoin(mbox.path, "/", f, nil);
+ else
+ path = estrjoin(mbox.path, "/", m->name, "/", f, nil);
+ fd = open(path, OREAD);
+ free(path);
+ if(fd == -1)
+ return nil;
+ r = fslurp(fd, nbuf);
+ close(fd);
+ return r;
}
-void
-ctlprint(int fd, char *fmt, ...)
+u32int
+strhash(char *s)
{- int n;
- va_list arg;
+ u32int h, c;
- va_start(arg, fmt);
- n = vfprint(fd, fmt, arg);
- va_end(arg);
- if(n <= 0)
- error("control file write error: %r");+ h = 5381;
+ while(c = *s++ & 0xff)
+ h = ((h << 5) + h) + c;
+ return h;
}
--- a/sys/src/cmd/upas/Mail/win.c
+++ b/sys/src/cmd/upas/Mail/win.c
@@ -2,340 +2,280 @@
#include <libc.h>
#include <bio.h>
#include <thread.h>
-#include <plumb.h>
-#include "dat.h"
+#include <regexp.h>
-Window*
-newwindow(void)
-{- char buf[12];
- Window *w;
+#include "mail.h"
- w = emalloc(sizeof(Window));
- w->ctl = open("/mnt/wsys/new/ctl", ORDWR|OCEXEC);- if(w->ctl<0 || read(w->ctl, buf, 12)!=12)
- error("can't open window ctl file: %r");- ctlprint(w->ctl, "noscroll\n");
- w->id = atoi(buf);
- w->event = winopenfile(w, "event");
- w->addr = -1; /* will be opened when needed */
- w->body = nil;
- w->data = -1;
- w->cevent = chancreate(sizeof(Event*), 0);
- return w;
+static int
+procrd(Biobufhdr *f, void *buf, long len)
+{+ return ioread(f->aux, f->fid, buf, len);
}
-void
-winsetdump(Window *w, char *dir, char *cmd)
+static int
+procwr(Biobufhdr *f, void *buf, long len)
{- if(dir != nil)
- ctlprint(w->ctl, "dumpdir %s\n", dir);
- if(cmd != nil)
- ctlprint(w->ctl, "dump %s\n", cmd);
+ return iowrite(f->aux, f->fid, buf, len);
}
-void
-wineventproc(void *v)
+/*
+ * NB: this function consumes integers with
+ * a trailing space, as generated by acme;
+ * it's not a general purpose number parsing
+ * function.
+ */
+static int
+evgetnum(Biobuf *f)
{- Window *w;
- int i;
+ int c, n;
- w = v;
- for(i=0; ; i++){- if(i >= NEVENT)
- i = 0;
- wingetevent(w, &w->e[i]);
- sendp(w->cevent, &w->e[i]);
+ n = 0;
+ while('0'<=(c=Bgetc(f)) && c<='9')+ n = n*10+(c-'0');
+ if(c != ' '){+ werrstr("event number syntax: %c", c);+ return -1;
}
+ return n;
}
static int
-winopenfile1(Window *w, char *f, int m)
+evgetdata(Biobuf *f, Event *e)
{- char buf[64];
- int fd;
+ int i, n, o;
+ Rune r;
- sprint(buf, "/mnt/wsys/%d/%s", w->id, f);
- fd = open(buf, m|OCEXEC);
- if(fd < 0)
- error("can't open window file %s: %r", f);- return fd;
+ o = 0;
+ n = evgetnum(f);
+ for(i = 0; i < n; i++){+ if((r = Bgetrune(f)) == -1)
+ break;
+ o += runetochar(e->text + o, &r);
+ }
+ e->text[o] = 0;
+ return o;
}
int
-winopenfile(Window *w, char *f)
+winevent(Win *w, Event *e)
{- return winopenfile1(w, f, ORDWR);
-}
+ int flags;
-void
-wintagwrite(Window *w, char *s, int n)
-{- int fd;
-
- fd = winopenfile(w, "tag");
- if(write(fd, s, n) != n)
- error("tag write: %r");- close(fd);
+ flags = 0;
+Again:
+ e->action = Bgetc(w->event);
+ e->type = Bgetc(w->event);
+ e->q0 = evgetnum(w->event);
+ e->q1 = evgetnum(w->event);
+ e->flags = evgetnum(w->event);
+ e->ntext = evgetdata(w->event, e);
+ if(Bgetc(w->event) != '\n'){+ werrstr("unterminated message");+ return -1;
+ }
+//fprint(2, "event: %c%c %d %d %x %.*s\n", e->action, e->type, e->q0, e->q1, e->flags, e->ntext, e->text);
+ if(e->flags & 0x2){+ e->p0 = e->q0;
+ flags = e->flags;
+ goto Again;
+ }
+ e->flags |= flags;
+ return e->action;
}
void
-winname(Window *w, char *s)
+winreturn(Win *w, Event *e)
{- ctlprint(w->ctl, "name %s\n", s);
+ if(e->flags & 0x2)
+ fprint(w->revent, "%c%c%d %d\n", e->action, e->type, e->p0, e->p0);
+ else
+ fprint(w->revent, "%c%c%d %d\n", e->action, e->type, e->q0, e->q1);
}
-void
-winopenbody(Window *w, int mode)
+int
+winopen(Win *w, char *f, int mode)
{- char buf[256];
+ char buf[128];
+ int fd;
- sprint(buf, "/mnt/wsys/%d/body", w->id);
- w->body = Bopen(buf, mode|OCEXEC);
- if(w->body == nil)
- error("can't open window body file: %r");+ snprint(buf, sizeof(buf), "/mnt/wsys/%d/%s", w->id, f);
+ if((fd = open(buf, mode|OCEXEC)) == -1)
+ sysfatal("open %s: %r", buf);+ return fd;
}
-void
-winclosebody(Window *w)
+Biobuf*
+bwinopen(Win *w, char *f, int mode)
{- if(w->body != nil){- Bterm(w->body);
- w->body = nil;
- }
-}
+ char buf[128];
+ Biobuf *bfd;
-void
-winwritebody(Window *w, char *s, int n)
-{- if(w->body == nil)
- winopenbody(w, OWRITE);
- if(Bwrite(w->body, s, n) != n)
- error("write error to window: %r");+ snprint(buf, sizeof(buf), "/mnt/wsys/%d/%s", w->id, f);
+ if((bfd = Bopen(buf, mode|OCEXEC)) == nil)
+ sysfatal("open %s: %r", buf);+ bfd->aux = w->io;
+ Biofn(bfd, (mode == OREAD)?procrd:procwr);
+ return bfd;
}
-int
-wingetec(Window *w)
+Biobuf*
+bwindata(Win *w, int mode)
{- if(w->nbuf == 0){- w->nbuf = read(w->event, w->buf, sizeof w->buf);
- if(w->nbuf <= 0){- /* probably because window has exited, and only called by wineventproc, so just shut down */
- threadexits(nil);
- }
- w->bufp = w->buf;
- }
- w->nbuf--;
- return *w->bufp++;
-}
+ int fd;
-int
-wingeten(Window *w)
-{- int n, c;
-
- n = 0;
- while('0'<=(c=wingetec(w)) && c<='9')- n = n*10+(c-'0');
- if(c != ' ')
- error("event number syntax");- return n;
+ if((fd = dup(w->data, -1)) == -1)
+ sysfatal("dup: %r");+ return Bfdopen(fd, mode);
}
-int
-wingeter(Window *w, char *buf, int *nb)
+void
+wininit(Win *w, char *name)
{- Rune r;
- int n;
+ char buf[12];
- r = wingetec(w);
- buf[0] = r;
- n = 1;
- if(r >= Runeself) {- while(!fullrune(buf, n))
- buf[n++] = wingetec(w);
- chartorune(&r, buf);
- }
- *nb = n;
- return r;
+ w->ctl = open("/mnt/wsys/new/ctl", ORDWR|OCEXEC);+ if(w->ctl < 0)
+ sysfatal("winopen: %r");+ if(read(w->ctl, buf, 12)!=12)
+ sysfatal("read ctl: %r");+ if(fprint(w->ctl, "name %s\n", name) == -1)
+ sysfatal("write ctl: %r");+ if(fprint(w->ctl, "noscroll\n") == -1)
+ sysfatal("write ctl: %r");+ w->io = ioproc();
+ w->id = atoi(buf);
+ w->event = bwinopen(w, "event", OREAD);
+ w->revent = winopen(w, "event", OWRITE);
+ w->addr = winopen(w, "addr", ORDWR);
+ w->data = winopen(w, "data", ORDWR);
+ w->open = 1;
}
void
-wingetevent(Window *w, Event *e)
+winclose(Win *w)
{- int i, nb;
-
- e->c1 = wingetec(w);
- e->c2 = wingetec(w);
- e->q0 = wingeten(w);
- e->q1 = wingeten(w);
- e->flag = wingeten(w);
- e->nr = wingeten(w);
- if(e->nr > EVENTSIZE)
- error("event string too long");- e->nb = 0;
- for(i=0; i<e->nr; i++){- e->r[i] = wingeter(w, e->b+e->nb, &nb);
- e->nb += nb;
- }
- e->r[e->nr] = 0;
- e->b[e->nb] = 0;
- if(wingetec(w) != '\n')
- error("event syntax error");+ if(w->open)
+ fprint(w->ctl, "delete\n");
+ if(w->data != -1)
+ close(w->data);
+ if(w->addr != -1)
+ close(w->addr);
+ if(w->event != nil)
+ Bterm(w->event);
+ if(w->revent != -1)
+ close(w->revent);
+ if(w->io)
+ closeioproc(w->io);
+ if(w->ctl != -1)
+ close(w->ctl);
+ w->ctl = -1;
+ w->data = -1;
+ w->addr = -1;
+ w->event = nil;
+ w->revent = -1;
+ w->io = nil;
}
void
-winwriteevent(Window *w, Event *e)
+wintagwrite(Win *w, char *s)
{- fprint(w->event, "%c%c%d %d\n", e->c1, e->c2, e->q0, e->q1);
+ int fd, n;
+
+ n = strlen(s);
+ fd = winopen(w, "tag", OWRITE);
+ if(write(fd, s, n) != n)
+ sysfatal("tag write: %r");+ close(fd);
}
-void
-winread(Window *w, uint q0, uint q1, char *data)
+int
+winread(Win *w, int q0, int q1, char *data, int ndata)
{int m, n, nr;
- char buf[256];
+ char *buf;
- if(w->addr < 0)
- w->addr = winopenfile(w, "addr");
- if(w->data < 0)
- w->data = winopenfile(w, "data");
m = q0;
+ buf = emalloc(Bufsz);
while(m < q1){n = sprint(buf, "#%d", m);
- if(write(w->addr, buf, n) != n)
- error("error writing addr: %r");- n = read(w->data, buf, sizeof buf);
- if(n <= 0)
- error("reading data: %r");+ if(write(w->addr, buf, n) != n){+ fprint(2, "error writing addr: %r");
+ goto err;
+ }
+ n = read(w->data, buf, Bufsz);
+ if(n <= 0){+ fprint(2, "reading data: %r");
+ goto err;
+ }
nr = utfnlen(buf, n);
while(m+nr >q1){do; while(n>0 && (buf[--n]&0xC0)==0x80);
--nr;
}
- if(n == 0)
+ if(n == 0 || n > ndata)
break;
memmove(data, buf, n);
+ ndata -= n;
data += n;
*data = 0;
m += nr;
}
+ free(buf);
+ return 0;
+err:
+ free(buf);
+ return -1;
}
-void
-windormant(Window *w)
+char*
+winreadsel(Win *w)
{- if(w->addr >= 0){- close(w->addr);
- w->addr = -1;
+ int n, q0, q1;
+ char *r;
+
+ wingetsel(w, &q0, &q1);
+ n = UTFmax*(q1-q0);
+ r = emalloc(n + 1);
+ if(winread(w, q0, q1, r, n) == -1){+ free(r);
+ return nil;
}
- if(w->body != nil){- Bterm(w->body);
- w->body = nil;
- }
- if(w->data >= 0){- close(w->data);
- w->data = -1;
- }
+ return r;
}
-
-int
-windel(Window *w, int sure)
+void
+wingetsel(Win *w, int *q0, int *q1)
{- if(sure)
- write(w->ctl, "delete\n", 7);
- else if(write(w->ctl, "del\n", 4) != 4)
- return 0;
- /* event proc will die due to read error from event file */
- windormant(w);
- close(w->ctl);
- w->ctl = -1;
- close(w->event);
- w->event = -1;
- return 1;
+ char *e, buf[25];
+
+ fprint(w->ctl, "addr=dot");
+ if(pread(w->addr, buf, 24, 0) != 24)
+ sysfatal("read addr: %r");+ buf[24] = 0;
+ *q0 = strtol(buf, &e, 10);
+ *q1 = strtol(e, nil, 10);
}
void
-winclean(Window *w)
+winsetsel(Win *w, int q0, int q1)
{- if(w->body)
- Bflush(w->body);
- ctlprint(w->ctl, "clean\n");
+ fprint(w->addr, "#%d,#%d", q0, q1);
+ fprint(w->ctl, "dot=addr");
}
int
-winsetaddr(Window *w, char *addr, int errok)
+matchmesg(Win *, char *text)
{- if(w->addr < 0)
- w->addr = winopenfile(w, "addr");
- if(write(w->addr, addr, strlen(addr)) < 0){- if(!errok)
- error("error writing addr(%s): %r", addr);- return 0;
- }
- return 1;
-}
+ Resub m[3];
-int
-winselect(Window *w, char *addr, int errok)
-{- if(winsetaddr(w, addr, errok)){- ctlprint(w->ctl, "dot=addr\n");
- return 1;
- }
- return 0;
-}
-
-char*
-winreadbody(Window *w, int *np) /* can't use readfile because acme doesn't report the length */
-{- char *s;
- int m, na, n;
-
- if(w->body != nil)
- winclosebody(w);
- winopenbody(w, OREAD);
- s = nil;
- na = 0;
- n = 0;
- for(;;){- if(na < n+512){- na += 1024;
- s = realloc(s, na+1);
+ memset(m, 0, sizeof(m));
+ if(strncmp(text, mbox.path, strlen(mbox.path)) == 0)
+ return strstr(text + strlen(mbox.path), "/body") == nil;
+ else if(regexec(mesgpat, text, m, nelem(m))){+ if(*m[1].ep == 0 || *m[1].ep == '/'){+ *m[1].ep = 0;
+ return 1;
}
- m = Bread(w->body, s+n, na-n);
- if(m <= 0)
- break;
- n += m;
}
- s[n] = 0;
- winclosebody(w);
- *np = n;
- return s;
-}
-
-char*
-winselection(Window *w)
-{- int fd, m, n;
- char *buf;
- char tmp[256];
-
- fd = winopenfile1(w, "rdsel", OREAD);
- if(fd < 0)
- error("can't open rdsel: %r");- n = 0;
- buf = nil;
- for(;;){- m = read(fd, tmp, sizeof tmp);
- if(m <= 0)
- break;
- buf = erealloc(buf, n+m+1);
- memmove(buf+n, tmp, m);
- n += m;
- buf[n] = '\0';
- }
- close(fd);
- return buf;
+ return 0;
}