sys/src/cmd/upas/Mail/reply.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <thread.h>
   5 #include <ctype.h>
   6 #include <plumb.h>
   7 #include "dat.h"
   8
   9 static int      replyid;
  10
  11 int
  12 quote(Message *m, Biobuf *b, char *dir, char *quotetext)
  13 {
  14         char *body, *type;
  15         int i, n, nlines;
  16         char **lines;
  17
  18         if(quotetext){
  19                 body = quotetext;
  20                 n = strlen(body);
  21                 type = nil;
  22         }else{
  23                 /* look for first textual component to quote */
  24                 type = readfile(dir, "type", &n);
  25                 if(type == nil){
  26                         print("no type in %s\n", dir);
  27                         return 0;
  28                 }
  29                 if(strncmp(type, "multipart/", 10)==0 || strncmp(type, "message/", 8)==0){
  30                         dir = estrstrdup(dir, "1/");
  31                         if(quote(m, b, dir, nil)){
  32                                 free(type);
  33                                 free(dir);
  34                                 return 1;
  35                         }
  36                         free(dir);
  37                 }
  38                 if(strncmp(type, "text", 4) != 0){
  39                         free(type);
  40                         return 0;
  41                 }
  42                 body = readbody(m->type, dir, &n);
  43                 if(body == nil)
  44                         return 0;
  45         }
  46         nlines = 0;
  47         for(i=0; i<n; i++)
  48                 if(body[i] == '\n')
  49                         nlines++;
  50         nlines++;
  51         lines = emalloc(nlines*sizeof(char*));
  52         nlines = getfields(body, lines, nlines, 0, "\n");
  53         /* delete leading and trailing blank lines */
  54         i = 0;
  55         while(i<nlines && lines[i][0]=='\0')
  56                 i++;
  57         while(i<nlines && lines[nlines-1][0]=='\0')
  58                 nlines--;
  59         while(i < nlines){
  60                 Bprint(b, ">%s%s\n", lines[i][0]=='>'? "" : " ", lines[i]);
  61                 i++;
  62         }
  63         free(lines);
  64         free(body);     /* will free quotetext if non-nil */
  65         free(type);
  66         return 1;
  67 }
  68
  69 void
  70 mkreply(Message *m, char *label, char *to, Plumbattr *attr, char *quotetext)
  71 {
  72         Message *r;
  73         char *dir, *t;
  74         int quotereply;
  75         Plumbattr *a;
  76
  77         quotereply = (label[0] == 'Q');
  78         r = emalloc(sizeof(Message));
  79         r->isreply = 1;
  80         if(m != nil)
  81                 r->replyname = estrdup(m->name);
  82         r->next = replies.head;
  83         r->prev = nil;
  84         if(replies.head != nil)
  85                 replies.head->prev = r;
  86         replies.head = r;
  87         if(replies.tail == nil)
  88                 replies.tail = r;
  89         r->name = emalloc(strlen(mbox.name)+strlen(label)+10);
  90         sprint(r->name, "%s%s%d", mbox.name, label, ++replyid);
  91         r->w = newwindow();
  92         winname(r->w, r->name);
  93         ctlprint(r->w->ctl, "cleartag");
  94         wintagwrite(r->w, "fmt Look Post Undo", 4+5+5+4);
  95         r->tagposted = 1;
  96         threadcreate(mesgctl, r, STACK);
  97         winopenbody(r->w, OWRITE);
  98         if(to!=nil && to[0]!='\0')
  99                 Bprint(r->w->body, "%s\n", to);
 100         for(a=attr; a; a=a->next)
 101                 Bprint(r->w->body, "%s: %s\n", a->name, a->value);
 102         dir = nil;
 103         if(m != nil){
 104                 dir = estrstrdup(mbox.name, m->name);
 105                 if(to == nil && attr == nil){
 106                         /* Reply goes to replyto; Reply all goes to From and To and CC */
 107                         if(strstr(label, "all") == nil)
 108                                 Bprint(r->w->body, "To: %s\n", m->replyto);
 109                         else{   /* Replyall */
 110                                 if(strlen(m->from) > 0)
 111                                         Bprint(r->w->body, "To: %s\n", m->from);
 112                                 if(strlen(m->to) > 0)
 113                                         Bprint(r->w->body, "To: %s\n", m->to);
 114                                 if(strlen(m->cc) > 0)
 115                                         Bprint(r->w->body, "CC: %s\n", m->cc);
 116                         }
 117                 }
 118                 if(strlen(m->subject) > 0){
 119                         t = "Subject: Re: ";
 120                         if(strlen(m->subject) >= 3)
 121                                 if(tolower(m->subject[0])=='r' && tolower(m->subject[1])=='e' && m->subject[2]==':')
 122                                         t = "Subject: ";
 123                         Bprint(r->w->body, "%s%s\n", t, m->subject);
 124                 }
 125                 if(!quotereply){
 126                         Bprint(r->w->body, "Include: %sraw\n", dir);
 127                         free(dir);
 128                 }
 129         }
 130         Bprint(r->w->body, "\n");
 131         if(m == nil)
 132                 Bprint(r->w->body, "\n");
 133         else if(quotereply){
 134                 quote(m, r->w->body, dir, quotetext);
 135                 free(dir);
 136         }
 137         winclosebody(r->w);
 138         if(m==nil && (to==nil || to[0]=='\0'))
 139                 winselect(r->w, "0", 0);
 140         else
 141                 winselect(r->w, "$", 0);
 142         winclean(r->w);
 143         windormant(r->w);
 144 }
 145
 146 void
 147 delreply(Message *m)
 148 {
 149         if(m->next == nil)
 150                 replies.tail = m->prev;
 151         else
 152                 m->next->prev = m->prev;
 153         if(m->prev == nil)
 154                 replies.head = m->next;
 155         else
 156                 m->prev->next = m->next;
 157         mesgfreeparts(m);
 158         free(m);
 159 }
 160
 161 /* copy argv to stack and free the incoming strings, so we don't leak argument vectors */
 162 void
 163 buildargv(char **inargv, char *argv[NARGS+1], char args[NARGCHAR])
 164 {
 165         int i, n;
 166         char *s, *a;
 167
 168         s = args;
 169         for(i=0; i<NARGS; i++){
 170                 a = inargv[i];
 171                 if(a == nil)
 172                         break;
 173                 n = strlen(a)+1;
 174                 if((s-args)+n >= NARGCHAR)      /* too many characters */
 175                         break;
 176                 argv[i] = s;
 177                 memmove(s, a, n);
 178                 s += n;
 179                 free(a);
 180         }
 181         argv[i] = nil;
 182 }
 183
 184 void
 185 execproc(void *v)
 186 {
 187         struct Exec *e;
 188         int p[2], q[2];
 189         char *prog;
 190         char *argv[NARGS+1], args[NARGCHAR];
 191
 192         e = v;
 193         p[0] = e->p[0];
 194         p[1] = e->p[1];
 195         q[0] = e->q[0];
 196         q[1] = e->q[1];
 197         prog = e->prog; /* known not to be malloc'ed */
 198         rfork(RFFDG);
 199         sendul(e->sync, 1);
 200         buildargv(e->argv, argv, args);
 201         free(e->argv);
 202         chanfree(e->sync);
 203         free(e);
 204         dup(p[0], 0);
 205         close(p[0]);
 206         close(p[1]);
 207         if(q[0]){
 208                 dup(q[1], 1);
 209                 close(q[0]);
 210                 close(q[1]);
 211         }
 212         procexec(nil, prog, argv);
 213 //fprint(2, "exec: %s", e->prog);
 214 //{int i;
 215 //for(i=0; argv[i]; i++) print(" '%s'", argv[i]);
 216 //print("\n");
 217 //}
 218 //argv[0] = "cat";
 219 //argv[1] = nil;
 220 //procexec(nil, "/bin/cat", argv);
 221         fprint(2, "Mail: can't exec %s: %r\n", prog);
 222         threadexits("can't exec");
 223 }
 224
 225 enum{
 226         ATTACH,
 227         BCC,
 228         CC,
 229         FROM,
 230         INCLUDE,
 231         TO,
 232 };
 233
 234 char *headers[] = {
 235         "attach:",
 236         "bcc:",
 237         "cc:",
 238         "from:",
 239         "include:",
 240         "to:",
 241         nil,
 242 };
 243
 244 int
 245 whichheader(char *h)
 246 {
 247         int i;
 248
 249         for(i=0; headers[i]!=nil; i++)
 250                 if(cistrcmp(h, headers[i]) == 0)
 251                         return i;
 252         return -1;
 253 }
 254
 255 char *tolist[200];
 256 char    *cclist[200];
 257 char    *bcclist[200];
 258 int ncc, nbcc, nto;
 259 char    *attlist[200];
 260 char    included[200];
 261
 262 int
 263 addressed(char *name)
 264 {
 265         int i;
 266
 267         for(i=0; i<nto; i++)
 268                 if(strcmp(name, tolist[i]) == 0)
 269                         return 1;
 270         for(i=0; i<ncc; i++)
 271                 if(strcmp(name, cclist[i]) == 0)
 272                         return 1;
 273         for(i=0; i<nbcc; i++)
 274                 if(strcmp(name, bcclist[i]) == 0)
 275                         return 1;
 276         return 0;
 277 }
 278
 279 char*
 280 skipbl(char *s, char *e)
 281 {
 282         while(s < e){
 283                 if(*s!=' ' && *s!='\t' && *s!=',')
 284                         break;
 285                 s++;
 286         }
 287         return s;
 288 }
 289
 290 char*
 291 findbl(char *s, char *e)
 292 {
 293         while(s < e){
 294                 if(*s==' ' || *s=='\t' || *s==',')
 295                         break;
 296                 s++;
 297         }
 298         return s;
 299 }
 300
 301 /*
 302  * comma-separate possibly blank-separated strings in line; e points before newline
 303  */
 304 void
 305 commas(char *s, char *e)
 306 {
 307         char *t;
 308
 309         /* may have initial blanks */
 310         s = skipbl(s, e);
 311         while(s < e){
 312                 s = findbl(s, e);
 313                 if(s == e)
 314                         break;
 315                 t = skipbl(s, e);
 316                 if(t == e)      /* no more words */
 317                         break;
 318                 /* patch comma */
 319                 *s++ = ',';
 320                 while(s < t)
 321                         *s++ = ' ';
 322         }
 323 }
 324
 325 int
 326 print2(int fd, int ofd, char *fmt, ...)
 327 {
 328         int m, n;
 329         char *s;
 330         va_list arg;
 331
 332         va_start(arg, fmt);
 333         s = vsmprint(fmt, arg);
 334         va_end(arg);
 335         if(s == nil)
 336                 return -1;
 337         m = strlen(s);
 338         n = write(fd, s, m);
 339         if(ofd > 0)
 340                 write(ofd, s, m);
 341         return n;
 342 }
 343
 344 int
 345 write2(int fd, int ofd, char *buf, int n, int nofrom)
 346 {
 347         char *from, *p;
 348         int m = 0;
 349
 350         if(fd >= 0)
 351                 m = write(fd, buf, n);
 352
 353         if(ofd <= 0)
 354                 return m;
 355
 356         if(nofrom == 0)
 357                 return write(ofd, buf, n);
 358
 359         /* need to escape leading From lines to avoid corrupting 'outgoing' mailbox */
 360         for(p=buf; *p; p+=m){
 361                 from = cistrstr(p, "from");
 362                 if(from == nil)
 363                         m = n;
 364                 else
 365                         m = from - p;
 366                 if(m > 0)
 367                         write(ofd, p, m);
 368                 if(from){
 369                         /* escape with space if From is at start of line */
 370                         if(p==buf || from[-1]=='\n')
 371                                 write(ofd, " ", 1);
 372                         write(ofd, from, 4);
 373                         m += 4;
 374                 }
 375                 n -= m;
 376         }
 377         return p - buf;
 378 }
 379
 380 void
 381 mesgsend(Message *m)
 382 {
 383         char *s, *body, *to;
 384         int i, j, h, n, natt, p[2];
 385         struct Exec *e;
 386         Channel *sync;
 387         int first, nfld, delit, ofd;
 388         char *copy, *fld[100], *now;
 389
 390         body = winreadbody(m->w, &n);
 391         /* assemble to: list from first line, to: line, and cc: line */
 392         nto = 0;
 393         natt = 0;
 394         ncc = 0;
 395         nbcc = 0;
 396         first = 1;
 397         to = body;
 398         for(;;){
 399                 for(s=to; *s!='\n'; s++)
 400                         if(*s == '\0'){
 401                                 free(body);
 402                                 return;
 403                         }
 404                 if(s++ == to)   /* blank line */
 405                         break;
 406                 /* make copy of line to tokenize */
 407                 copy = emalloc(s-to);
 408                 memmove(copy, to, s-to);
 409                 copy[s-to-1] = '\0';
 410                 nfld = tokenizec(copy, fld, nelem(fld), ", \t");
 411                 if(nfld == 0){
 412                         free(copy);
 413                         break;
 414                 }
 415                 n -= s-to;
 416                 switch(h = whichheader(fld[0])){
 417                 case TO:
 418                 case FROM:
 419                         delit = 1;
 420                         commas(to+strlen(fld[0]), s-1);
 421                         for(i=1; i<nfld && nto<nelem(tolist); i++)
 422                                 if(!addressed(fld[i]))
 423                                         tolist[nto++] = estrdup(fld[i]);
 424                         break;
 425                 case BCC:
 426                         delit = 1;
 427                         commas(to+strlen(fld[0]), s-1);
 428                         for(i=1; i<nfld && nbcc<nelem(bcclist); i++)
 429                                 if(!addressed(fld[i]))
 430                                         bcclist[nbcc++] = estrdup(fld[i]);
 431                         break;
 432                 case CC:
 433                         delit = 1;
 434                         commas(to+strlen(fld[0]), s-1);
 435                         for(i=1; i<nfld && ncc<nelem(cclist); i++)
 436                                 if(!addressed(fld[i]))
 437                                         cclist[ncc++] = estrdup(fld[i]);
 438                         break;
 439                 case ATTACH:
 440                 case INCLUDE:
 441                         delit = 1;
 442                         for(i=1; i<nfld && natt<nelem(attlist); i++){
 443                                 attlist[natt] = estrdup(fld[i]);
 444                                 included[natt++] = (h == INCLUDE);
 445                         }
 446                         break;
 447                 default:
 448                         if(first){
 449                                 delit = 1;
 450                                 for(i=0; i<nfld && nto<nelem(tolist); i++)
 451                                         tolist[nto++] = estrdup(fld[i]);
 452                         }else   /* ignore it */
 453                                 delit = 0;
 454                         break;
 455                 }
 456                 if(delit){
 457                         /* delete line from body */
 458                         memmove(to, s, n+1);
 459                 }else
 460                         to = s;
 461                 free(copy);
 462                 first = 0;
 463         }
 464
 465         ofd = open(outgoing, OWRITE|OCEXEC);    /* no error check necessary */
 466         if(ofd > 0){
 467                 /* From dhog Fri Aug 24 22:13:00 EDT 2001 */
 468                 now = ctime(time(0));
 469                 fprint(ofd, "From %s %s", user, now);
 470                 fprint(ofd, "From: %s\n", user);
 471                 fprint(ofd, "Date: %s", now);
 472                 for(i=0; i<natt; i++)
 473                         if(included[i])
 474                                 fprint(ofd, "Include: %s\n", attlist[i]);
 475                         else
 476                                 fprint(ofd, "Attach: %s\n", attlist[i]);
 477                 /* needed because mail is by default Latin-1 */
 478                 fprint(ofd, "Content-Type: text/plain; charset=\"UTF-8\"\n");
 479                 fprint(ofd, "Content-Transfer-Encoding: 8bit\n");
 480         }
 481
 482         e = emalloc(sizeof(struct Exec));
 483         if(pipe(p) < 0)
 484                 error("can't create pipe: %r");
 485         e->p[0] = p[0];
 486         e->p[1] = p[1];
 487         e->prog = "/bin/upas/marshal";
 488         e->argv = emalloc((1+1+2+4*natt+1)*sizeof(char*));
 489         e->argv[0] = estrdup("marshal");
 490         e->argv[1] = estrdup("-8");
 491         j = 2;
 492         if(m->replyname){
 493                 e->argv[j++] = estrdup("-R");
 494                 e->argv[j++] = estrstrdup(mbox.name, m->replyname);
 495         }
 496         for(i=0; i<natt; i++){
 497                 if(included[i])
 498                         e->argv[j++] = estrdup("-A");
 499                 else
 500                         e->argv[j++] = estrdup("-a");
 501                 e->argv[j++] = estrdup(attlist[i]);
 502         }
 503         sync = chancreate(sizeof(int), 0);
 504         e->sync = sync;
 505         proccreate(execproc, e, EXECSTACK);
 506         recvul(sync);
 507         close(p[0]);
 508
 509         /* using marshal -8, so generate rfc822 headers */
 510         if(nto > 0){
 511                 print2(p[1], ofd, "To: ");
 512                 for(i=0; i<nto-1; i++)
 513                         print2(p[1], ofd, "%s, ", tolist[i]);
 514                 print2(p[1], ofd, "%s\n", tolist[i]);
 515         }
 516         if(ncc > 0){
 517                 print2(p[1], ofd, "CC: ");
 518                 for(i=0; i<ncc-1; i++)
 519                         print2(p[1], ofd, "%s, ", cclist[i]);
 520                 print2(p[1], ofd, "%s\n", cclist[i]);
 521         }
 522         if(nbcc > 0){
 523                 print2(p[1], ofd, "BCC: ");
 524                 for(i=0; i<nbcc-1; i++)
 525                         print2(p[1], ofd, "%s, ", bcclist[i]);
 526                 print2(p[1], ofd, "%s\n", bcclist[i]);
 527         }
 528
 529         i = strlen(body);
 530         if(i > 0)
 531                 write2(p[1], ofd, body, i, 1);
 532
 533         /* guarantee a blank line, to ensure attachments are separated from body */
 534         if(i==0 || body[i-1]!='\n')
 535                 write2(p[1], ofd, "\n\n", 2, 0);
 536         else if(i>1 && body[i-2]!='\n')
 537                 write2(p[1], ofd, "\n", 1, 0);
 538
 539         /* these look like pseudo-attachments in the "outgoing" box */
 540         if(ofd>0 && natt>0){
 541                 for(i=0; i<natt; i++)
 542                         if(included[i])
 543                                 fprint(ofd, "=====> Include: %s\n", attlist[i]);
 544                         else
 545                                 fprint(ofd, "=====> Attach: %s\n", attlist[i]);
 546         }
 547         if(ofd > 0)
 548                 write(ofd, "\n", 1);
 549
 550         for(i=0; i<natt; i++)
 551                 free(attlist[i]);
 552         close(ofd);
 553         close(p[1]);
 554         free(body);
 555
 556         if(m->replyname != nil)
 557                 mesgmenumark(mbox.w, m->replyname, "\t[replied]");
 558         if(m->name[0] == '/')
 559                 s = estrdup(m->name);
 560         else
 561                 s = estrstrdup(mbox.name, m->name);
 562         s = egrow(s, "-R", nil);
 563         winname(m->w, s);
 564         free(s);
 565         winclean(m->w);
 566         /* mark message unopened because it's no longer the original message */
 567         m->opened = 0;
 568 }