imap4.c (16518B)
1 #include "common.h" 2 #include <ctype.h> 3 #include <plumb.h> 4 #include <libsec.h> 5 #include <auth.h> 6 #include "dat.h" 7 8 #pragma varargck argpos imap4cmd 2 9 #pragma varargck type "Z" char* 10 11 int doublequote(Fmt*); 12 int pipeline = 1; 13 14 /* static char Eio[] = "i/o error"; jpc */ 15 16 typedef struct Imap Imap; 17 struct Imap { 18 char *freep; /* free this to free the strings below */ 19 20 char *host; 21 char *user; 22 char *mbox; 23 24 int mustssl; 25 int refreshtime; 26 int debug; 27 28 ulong tag; 29 ulong validity; 30 int nmsg; 31 int size; 32 char *base; 33 char *data; 34 35 vlong *uid; 36 int nuid; 37 int muid; 38 39 Thumbprint *thumb; 40 41 /* open network connection */ 42 Biobuf bin; 43 Biobuf bout; 44 int fd; 45 }; 46 47 static char* 48 removecr(char *s) 49 { 50 char *r, *w; 51 52 for(r=w=s; *r; r++) 53 if(*r != '\r') 54 *w++ = *r; 55 *w = '\0'; 56 return s; 57 } 58 59 /* */ 60 /* send imap4 command */ 61 /* */ 62 static void 63 imap4cmd(Imap *imap, char *fmt, ...) 64 { 65 char buf[128], *p; 66 va_list va; 67 68 va_start(va, fmt); 69 p = buf+sprint(buf, "9X%lud ", imap->tag); 70 vseprint(p, buf+sizeof(buf), fmt, va); 71 va_end(va); 72 73 p = buf+strlen(buf); 74 if(p > (buf+sizeof(buf)-3)) 75 sysfatal("imap4 command too long"); 76 77 if(imap->debug) 78 fprint(2, "-> %s\n", buf); 79 strcpy(p, "\r\n"); 80 Bwrite(&imap->bout, buf, strlen(buf)); 81 Bflush(&imap->bout); 82 } 83 84 enum { 85 OK, 86 NO, 87 BAD, 88 BYE, 89 EXISTS, 90 STATUS, 91 FETCH, 92 UNKNOWN 93 }; 94 95 static char *verblist[] = { 96 [OK] "OK", 97 [NO] "NO", 98 [BAD] "BAD", 99 [BYE] "BYE", 100 [EXISTS] "EXISTS", 101 [STATUS] "STATUS", 102 [FETCH] "FETCH" 103 }; 104 105 static int 106 verbcode(char *verb) 107 { 108 int i; 109 char *q; 110 111 if(q = strchr(verb, ' ')) 112 *q = '\0'; 113 114 for(i=0; i<nelem(verblist); i++) 115 if(verblist[i] && strcmp(verblist[i], verb)==0){ 116 if(q) 117 *q = ' '; 118 return i; 119 } 120 if(q) 121 *q = ' '; 122 return UNKNOWN; 123 } 124 125 static void 126 strupr(char *s) 127 { 128 for(; *s; s++) 129 if('a' <= *s && *s <= 'z') 130 *s += 'A'-'a'; 131 } 132 133 static void 134 imapgrow(Imap *imap, int n) 135 { 136 int i; 137 138 if(imap->data == nil){ 139 imap->base = emalloc(n+1); 140 imap->data = imap->base; 141 imap->size = n+1; 142 } 143 if(n >= imap->size){ 144 /* friggin microsoft - reallocate */ 145 i = imap->data - imap->base; 146 imap->base = erealloc(imap->base, i+n+1); 147 imap->data = imap->base + i; 148 imap->size = n+1; 149 } 150 } 151 152 153 /* */ 154 /* get imap4 response line. there might be various */ 155 /* data or other informational lines mixed in. */ 156 /* */ 157 static char* 158 imap4resp(Imap *imap) 159 { 160 char *line, *p, *ep, *op, *q, *r, *en, *verb; 161 int i, n; 162 static char error[256]; 163 164 while(p = Brdline(&imap->bin, '\n')){ 165 ep = p+Blinelen(&imap->bin); 166 while(ep > p && (ep[-1]=='\n' || ep[-1]=='\r')) 167 *--ep = '\0'; 168 169 if(imap->debug) 170 fprint(2, "<- %s\n", p); 171 strupr(p); 172 173 switch(p[0]){ 174 case '+': 175 if(imap->tag == 0) 176 fprint(2, "unexpected: %s\n", p); 177 break; 178 179 /* ``unsolicited'' information; everything happens here. */ 180 case '*': 181 if(p[1]!=' ') 182 continue; 183 p += 2; 184 line = p; 185 n = strtol(p, &p, 10); 186 if(*p==' ') 187 p++; 188 verb = p; 189 190 if(p = strchr(verb, ' ')) 191 p++; 192 else 193 p = verb+strlen(verb); 194 195 switch(verbcode(verb)){ 196 case OK: 197 case NO: 198 case BAD: 199 /* human readable text at p; */ 200 break; 201 case BYE: 202 /* early disconnect */ 203 /* human readable text at p; */ 204 break; 205 206 /* * 32 EXISTS */ 207 case EXISTS: 208 imap->nmsg = n; 209 break; 210 211 /* * STATUS Inbox (MESSAGES 2 UIDVALIDITY 960164964) */ 212 case STATUS: 213 if(q = strstr(p, "MESSAGES")) 214 imap->nmsg = atoi(q+8); 215 if(q = strstr(p, "UIDVALIDITY")) 216 imap->validity = strtoul(q+11, 0, 10); 217 break; 218 219 case FETCH: 220 /* * 1 FETCH (uid 8889 RFC822.SIZE 3031 body[] {3031} */ 221 /* <3031 bytes of data> */ 222 /* ) */ 223 if(strstr(p, "RFC822.SIZE") && strstr(p, "BODY[]")){ 224 if((q = strchr(p, '{')) 225 && (n=strtol(q+1, &en, 0), *en=='}')){ 226 if(imap->data == nil || n >= imap->size) 227 imapgrow(imap, n); 228 if((i = Bread(&imap->bin, imap->data, n)) != n){ 229 snprint(error, sizeof error, 230 "short read %d != %d: %r\n", 231 i, n); 232 return error; 233 } 234 if(imap->debug) 235 fprint(2, "<- read %d bytes\n", n); 236 imap->data[n] = '\0'; 237 if(imap->debug) 238 fprint(2, "<- %s\n", imap->data); 239 imap->data += n; 240 imap->size -= n; 241 p = Brdline(&imap->bin, '\n'); 242 if(imap->debug) 243 fprint(2, "<- ignoring %.*s\n", 244 Blinelen(&imap->bin), p); 245 }else if((q = strchr(p, '"')) && (r = strchr(q+1, '"'))){ 246 *r = '\0'; 247 q++; 248 n = r-q; 249 if(imap->data == nil || n >= imap->size) 250 imapgrow(imap, n); 251 memmove(imap->data, q, n); 252 imap->data[n] = '\0'; 253 imap->data += n; 254 imap->size -= n; 255 }else 256 return "confused about FETCH response"; 257 break; 258 } 259 260 /* * 1 FETCH (UID 1 RFC822.SIZE 511) */ 261 if(q=strstr(p, "RFC822.SIZE")){ 262 imap->size = atoi(q+11); 263 break; 264 } 265 266 /* * 1 FETCH (UID 1 RFC822.HEADER {496} */ 267 /* <496 bytes of data> */ 268 /* ) */ 269 /* * 1 FETCH (UID 1 RFC822.HEADER "data") */ 270 if(strstr(p, "RFC822.HEADER") || strstr(p, "RFC822.TEXT")){ 271 if((q = strchr(p, '{')) 272 && (n=strtol(q+1, &en, 0), *en=='}')){ 273 if(imap->data == nil || n >= imap->size) 274 imapgrow(imap, n); 275 if((i = Bread(&imap->bin, imap->data, n)) != n){ 276 snprint(error, sizeof error, 277 "short read %d != %d: %r\n", 278 i, n); 279 return error; 280 } 281 if(imap->debug) 282 fprint(2, "<- read %d bytes\n", n); 283 imap->data[n] = '\0'; 284 if(imap->debug) 285 fprint(2, "<- %s\n", imap->data); 286 imap->data += n; 287 imap->size -= n; 288 p = Brdline(&imap->bin, '\n'); 289 if(imap->debug) 290 fprint(2, "<- ignoring %.*s\n", 291 Blinelen(&imap->bin), p); 292 }else if((q = strchr(p, '"')) && (r = strchr(q+1, '"'))){ 293 *r = '\0'; 294 q++; 295 n = r-q; 296 if(imap->data == nil || n >= imap->size) 297 imapgrow(imap, n); 298 memmove(imap->data, q, n); 299 imap->data[n] = '\0'; 300 imap->data += n; 301 imap->size -= n; 302 }else 303 return "confused about FETCH response"; 304 break; 305 } 306 307 /* * 1 FETCH (UID 1) */ 308 /* * 2 FETCH (UID 6) */ 309 if(q = strstr(p, "UID")){ 310 if(imap->nuid < imap->muid) 311 imap->uid[imap->nuid++] = ((vlong)imap->validity<<32)|strtoul(q+3, nil, 10); 312 break; 313 } 314 } 315 316 if(imap->tag == 0) 317 return line; 318 break; 319 320 case '9': /* response to our message */ 321 op = p; 322 if(p[1]=='X' && strtoul(p+2, &p, 10)==imap->tag){ 323 while(*p==' ') 324 p++; 325 imap->tag++; 326 return p; 327 } 328 fprint(2, "expected %lud; got %s\n", imap->tag, op); 329 break; 330 331 default: 332 if(imap->debug || *p) 333 fprint(2, "unexpected line: %s\n", p); 334 } 335 } 336 snprint(error, sizeof error, "i/o error: %r\n"); 337 return error; 338 } 339 340 static int 341 isokay(char *resp) 342 { 343 return strncmp(resp, "OK", 2)==0; 344 } 345 346 /* */ 347 /* log in to IMAP4 server, select mailbox, no SSL at the moment */ 348 /* */ 349 static char* 350 imap4login(Imap *imap) 351 { 352 char *s; 353 UserPasswd *up; 354 355 imap->tag = 0; 356 s = imap4resp(imap); 357 if(!isokay(s)) 358 return "error in initial IMAP handshake"; 359 360 if(imap->user != nil) 361 up = auth_getuserpasswd(auth_getkey, "proto=pass role=client service=imap server=%q user=%q", imap->host, imap->user); 362 else 363 up = auth_getuserpasswd(auth_getkey, "proto=pass role=client service=imap server=%q", imap->host); 364 if(up == nil) 365 return "cannot find IMAP password"; 366 367 imap->tag = 1; 368 imap4cmd(imap, "LOGIN %Z %Z", up->user, up->passwd); 369 free(up); 370 if(!isokay(s = imap4resp(imap))) 371 return s; 372 373 imap4cmd(imap, "SELECT %Z", imap->mbox); 374 if(!isokay(s = imap4resp(imap))) 375 return s; 376 377 return nil; 378 } 379 380 /* */ 381 /* push tls onto a connection */ 382 /* */ 383 int 384 mypushtls(int fd) 385 { 386 int p[2]; 387 char buf[10]; 388 389 if(pipe(p) < 0) 390 return -1; 391 392 switch(fork()){ 393 case -1: 394 close(p[0]); 395 close(p[1]); 396 return -1; 397 case 0: 398 close(p[1]); 399 dup(p[0], 0); 400 dup(p[0], 1); 401 sprint(buf, "/fd/%d", fd); 402 execl("/bin/tlsrelay", "tlsrelay", "-f", buf, nil); 403 _exits(nil); 404 default: 405 break; 406 } 407 close(fd); 408 close(p[0]); 409 return p[1]; 410 } 411 412 /* */ 413 /* dial and handshake with the imap server */ 414 /* */ 415 static char* 416 imap4dial(Imap *imap) 417 { 418 char *err, *port; 419 uchar digest[SHA1dlen]; 420 int sfd; 421 TLSconn conn; 422 423 if(imap->fd >= 0){ 424 imap4cmd(imap, "noop"); 425 if(isokay(imap4resp(imap))) 426 return nil; 427 close(imap->fd); 428 imap->fd = -1; 429 } 430 431 if(imap->mustssl) 432 port = "imaps"; 433 else 434 port = "imap"; 435 436 if((imap->fd = dial(netmkaddr(imap->host, "net", port), 0, 0, 0)) < 0) 437 return geterrstr(); 438 439 if(imap->mustssl){ 440 memset(&conn, 0, sizeof conn); 441 sfd = tlsClient(imap->fd, &conn); 442 if(sfd < 0) 443 sysfatal("tlsClient: %r"); 444 if(conn.cert==nil || conn.certlen <= 0) 445 sysfatal("server did not provide TLS certificate"); 446 sha1(conn.cert, conn.certlen, digest, nil); 447 if(!imap->thumb || !okThumbprint(digest, imap->thumb)){ 448 fmtinstall('H', encodefmt); 449 sysfatal("server certificate %.*H not recognized", SHA1dlen, digest); 450 } 451 free(conn.cert); 452 close(imap->fd); 453 imap->fd = sfd; 454 455 if(imap->debug){ 456 char fn[128]; 457 int fd; 458 459 snprint(fn, sizeof fn, "%s/ctl", conn.dir); 460 fd = open(fn, ORDWR); 461 if(fd < 0) 462 fprint(2, "opening ctl: %r\n"); 463 if(fprint(fd, "debug") < 0) 464 fprint(2, "writing ctl: %r\n"); 465 close(fd); 466 } 467 } 468 Binit(&imap->bin, imap->fd, OREAD); 469 Binit(&imap->bout, imap->fd, OWRITE); 470 471 if(err = imap4login(imap)) { 472 close(imap->fd); 473 return err; 474 } 475 476 return nil; 477 } 478 479 /* */ 480 /* close connection */ 481 /* */ 482 #if 0 /* jpc */ 483 static void 484 imap4hangup(Imap *imap) 485 { 486 imap4cmd(imap, "LOGOUT"); 487 imap4resp(imap); 488 close(imap->fd); 489 } 490 #endif 491 492 /* */ 493 /* download a single message */ 494 /* */ 495 static char* 496 imap4fetch(Mailbox *mb, Message *m) 497 { 498 int i; 499 char *p, *s, sdigest[2*SHA1dlen+1]; 500 Imap *imap; 501 502 imap = mb->aux; 503 504 imap->size = 0; 505 506 if(!isokay(s = imap4resp(imap))) 507 return s; 508 509 p = imap->base; 510 if(p == nil) 511 return "did not get message body"; 512 513 removecr(p); 514 free(m->start); 515 m->start = p; 516 m->end = p+strlen(p); 517 m->bend = m->rbend = m->end; 518 m->header = m->start; 519 520 imap->base = nil; 521 imap->data = nil; 522 523 parse(m, 0, mb, 1); 524 525 /* digest headers */ 526 sha1((uchar*)m->start, m->end - m->start, m->digest, nil); 527 for(i = 0; i < SHA1dlen; i++) 528 sprint(sdigest+2*i, "%2.2ux", m->digest[i]); 529 m->sdigest = s_copy(sdigest); 530 531 return nil; 532 } 533 534 /* */ 535 /* check for new messages on imap4 server */ 536 /* download new messages, mark deleted messages */ 537 /* */ 538 static char* 539 imap4read(Imap *imap, Mailbox *mb, int doplumb) 540 { 541 char *s; 542 int i, ignore, nnew, t; 543 Message *m, *next, **l; 544 545 imap4cmd(imap, "STATUS %Z (MESSAGES UIDVALIDITY)", imap->mbox); 546 if(!isokay(s = imap4resp(imap))) 547 return s; 548 549 imap->nuid = 0; 550 imap->uid = erealloc(imap->uid, imap->nmsg*sizeof(imap->uid[0])); 551 imap->muid = imap->nmsg; 552 553 if(imap->nmsg > 0){ 554 imap4cmd(imap, "UID FETCH 1:* UID"); 555 if(!isokay(s = imap4resp(imap))) 556 return s; 557 } 558 559 l = &mb->root->part; 560 for(i=0; i<imap->nuid; i++){ 561 ignore = 0; 562 while(*l != nil){ 563 if((*l)->imapuid == imap->uid[i]){ 564 ignore = 1; 565 l = &(*l)->next; 566 break; 567 }else{ 568 /* old mail, we don't have it anymore */ 569 if(doplumb) 570 mailplumb(mb, *l, 1); 571 (*l)->inmbox = 0; 572 (*l)->deleted = 1; 573 l = &(*l)->next; 574 } 575 } 576 if(ignore) 577 continue; 578 579 /* new message */ 580 m = newmessage(mb->root); 581 m->mallocd = 1; 582 m->inmbox = 1; 583 m->imapuid = imap->uid[i]; 584 585 /* add to chain, will download soon */ 586 *l = m; 587 l = &m->next; 588 } 589 590 /* whatever is left at the end of the chain is gone */ 591 while(*l != nil){ 592 if(doplumb) 593 mailplumb(mb, *l, 1); 594 (*l)->inmbox = 0; 595 (*l)->deleted = 1; 596 l = &(*l)->next; 597 } 598 599 /* download new messages */ 600 t = imap->tag; 601 if(pipeline) 602 switch(rfork(RFPROC|RFMEM)){ 603 case -1: 604 sysfatal("rfork: %r"); 605 default: 606 break; 607 case 0: 608 for(m = mb->root->part; m != nil; m = m->next){ 609 if(m->start != nil) 610 continue; 611 if(imap->debug) 612 fprint(2, "9X%d UID FETCH %lud (UID RFC822.SIZE BODY[])\r\n", 613 t, (ulong)m->imapuid); 614 Bprint(&imap->bout, "9X%d UID FETCH %lud (UID RFC822.SIZE BODY[])\r\n", 615 t++, (ulong)m->imapuid); 616 } 617 Bflush(&imap->bout); 618 _exits(nil); 619 } 620 621 nnew = 0; 622 for(m=mb->root->part; m!=nil; m=next){ 623 next = m->next; 624 if(m->start != nil) 625 continue; 626 627 if(!pipeline){ 628 Bprint(&imap->bout, "9X%lud UID FETCH %lud (UID RFC822.SIZE BODY[])\r\n", 629 (ulong)imap->tag, (ulong)m->imapuid); 630 Bflush(&imap->bout); 631 } 632 633 if(s = imap4fetch(mb, m)){ 634 /* message disappeared? unchain */ 635 fprint(2, "download %lud: %s\n", (ulong)m->imapuid, s); 636 delmessage(mb, m); 637 mb->root->subname--; 638 continue; 639 } 640 nnew++; 641 if(doplumb) 642 mailplumb(mb, m, 0); 643 } 644 if(pipeline) 645 waitpid(); 646 647 if(nnew || mb->vers == 0){ 648 mb->vers++; 649 henter(PATH(0, Qtop), mb->name, 650 (Qid){PATH(mb->id, Qmbox), mb->vers, QTDIR}, nil, mb); 651 } 652 return nil; 653 } 654 655 /* */ 656 /* sync mailbox */ 657 /* */ 658 static void 659 imap4purge(Imap *imap, Mailbox *mb) 660 { 661 int ndel; 662 Message *m, *next; 663 664 ndel = 0; 665 for(m=mb->root->part; m!=nil; m=next){ 666 next = m->next; 667 if(m->deleted && m->refs==0){ 668 if(m->inmbox && (ulong)(m->imapuid>>32)==imap->validity){ 669 imap4cmd(imap, "UID STORE %lud +FLAGS (\\Deleted)", (ulong)m->imapuid); 670 if(isokay(imap4resp(imap))){ 671 ndel++; 672 delmessage(mb, m); 673 } 674 }else 675 delmessage(mb, m); 676 } 677 } 678 679 if(ndel){ 680 imap4cmd(imap, "EXPUNGE"); 681 imap4resp(imap); 682 } 683 } 684 685 /* */ 686 /* connect to imap4 server, sync mailbox */ 687 /* */ 688 static char* 689 imap4sync(Mailbox *mb, int doplumb) 690 { 691 char *err; 692 Imap *imap; 693 694 imap = mb->aux; 695 696 if(err = imap4dial(imap)){ 697 mb->waketime = time(0) + imap->refreshtime; 698 return err; 699 } 700 701 if((err = imap4read(imap, mb, doplumb)) == nil){ 702 imap4purge(imap, mb); 703 mb->d->atime = mb->d->mtime = time(0); 704 } 705 /* 706 * don't hang up; leave connection open for next time. 707 */ 708 /* imap4hangup(imap); */ 709 mb->waketime = time(0) + imap->refreshtime; 710 return err; 711 } 712 713 static char Eimap4ctl[] = "bad imap4 control message"; 714 715 static char* 716 imap4ctl(Mailbox *mb, int argc, char **argv) 717 { 718 int n; 719 Imap *imap; 720 721 imap = mb->aux; 722 if(argc < 1) 723 return Eimap4ctl; 724 725 if(argc==1 && strcmp(argv[0], "debug")==0){ 726 imap->debug = 1; 727 return nil; 728 } 729 730 if(argc==1 && strcmp(argv[0], "nodebug")==0){ 731 imap->debug = 0; 732 return nil; 733 } 734 735 if(argc==1 && strcmp(argv[0], "thumbprint")==0){ 736 if(imap->thumb) 737 freeThumbprints(imap->thumb); 738 imap->thumb = initThumbprints("/sys/lib/tls/mail", "/sys/lib/tls/mail.exclude"); 739 } 740 if(strcmp(argv[0], "refresh")==0){ 741 if(argc==1){ 742 imap->refreshtime = 60; 743 return nil; 744 } 745 if(argc==2){ 746 n = atoi(argv[1]); 747 if(n < 15) 748 return Eimap4ctl; 749 imap->refreshtime = n; 750 return nil; 751 } 752 } 753 754 return Eimap4ctl; 755 } 756 757 /* */ 758 /* free extra memory associated with mb */ 759 /* */ 760 static void 761 imap4close(Mailbox *mb) 762 { 763 Imap *imap; 764 765 imap = mb->aux; 766 free(imap->freep); 767 free(imap->base); 768 free(imap->uid); 769 if(imap->fd >= 0) 770 close(imap->fd); 771 free(imap); 772 } 773 774 /* */ 775 /* open mailboxes of the form /imap/host/user */ 776 /* */ 777 char* 778 imap4mbox(Mailbox *mb, char *path) 779 { 780 char *f[10]; 781 int mustssl, nf; 782 Imap *imap; 783 784 quotefmtinstall(); 785 fmtinstall('Z', doublequote); 786 if(strncmp(path, "/imap/", 6) != 0 && strncmp(path, "/imaps/", 7) != 0) 787 return Enotme; 788 mustssl = (strncmp(path, "/imaps/", 7) == 0); 789 790 path = strdup(path); 791 if(path == nil) 792 return "out of memory"; 793 794 nf = getfields(path, f, 5, 0, "/"); 795 if(nf < 3){ 796 free(path); 797 return "bad imap path syntax /imap[s]/system[/user[/mailbox]]"; 798 } 799 800 imap = emalloc(sizeof(*imap)); 801 imap->fd = -1; 802 imap->debug = debug; 803 imap->freep = path; 804 imap->mustssl = mustssl; 805 imap->host = f[2]; 806 if(nf < 4) 807 imap->user = nil; 808 else 809 imap->user = f[3]; 810 if(nf < 5) 811 imap->mbox = "Inbox"; 812 else 813 imap->mbox = f[4]; 814 imap->thumb = initThumbprints("/sys/lib/tls/mail", "/sys/lib/tls/mail.exclude"); 815 816 mb->aux = imap; 817 mb->sync = imap4sync; 818 mb->close = imap4close; 819 mb->ctl = imap4ctl; 820 mb->d = emalloc(sizeof(*mb->d)); 821 /*mb->fetch = imap4fetch; */ 822 823 return nil; 824 } 825 826 /* */ 827 /* Formatter for %" */ 828 /* Use double quotes to protect white space, frogs, \ and " */ 829 /* */ 830 enum 831 { 832 Qok = 0, 833 Qquote, 834 Qbackslash 835 }; 836 837 static int 838 needtoquote(Rune r) 839 { 840 if(r >= Runeself) 841 return Qquote; 842 if(r <= ' ') 843 return Qquote; 844 if(r=='\\' || r=='"') 845 return Qbackslash; 846 return Qok; 847 } 848 849 int 850 doublequote(Fmt *f) 851 { 852 char *s, *t; 853 int w, quotes; 854 Rune r; 855 856 s = va_arg(f->args, char*); 857 if(s == nil || *s == '\0') 858 return fmtstrcpy(f, "\"\""); 859 860 quotes = 0; 861 for(t=s; *t; t+=w){ 862 w = chartorune(&r, t); 863 quotes |= needtoquote(r); 864 } 865 if(quotes == 0) 866 return fmtstrcpy(f, s); 867 868 fmtrune(f, '"'); 869 for(t=s; *t; t+=w){ 870 w = chartorune(&r, t); 871 if(needtoquote(r) == Qbackslash) 872 fmtrune(f, '\\'); 873 fmtrune(f, r); 874 } 875 return fmtrune(f, '"'); 876 }