Blob


1 #include <u.h>
2 #include <libc.h>
3 #include <ctype.h>
4 #include <bio.h>
5 #include <ip.h>
6 #include <libsec.h>
7 #include <auth.h>
8 #include <thread.h>
10 typedef struct URL URL;
11 struct URL
12 {
13 int method;
14 char *host;
15 char *port;
16 char *page;
17 char *etag;
18 char *redirect;
19 char *postbody;
20 char *cred;
21 long mtime;
22 };
24 typedef struct Range Range;
25 struct Range
26 {
27 long start; /* only 2 gig supported, tdb */
28 long end;
29 };
31 typedef struct Out Out;
32 struct Out
33 {
34 int fd;
35 int offset; /* notional current offset in output */
36 int written; /* number of bytes successfully transferred to output */
37 DigestState *curr; /* digest state up to offset (if known) */
38 DigestState *hiwat; /* digest state of all bytes written */
39 };
41 enum
42 {
43 Http,
44 Https,
45 Ftp,
46 Other
47 };
49 enum
50 {
51 Eof = 0,
52 Error = -1,
53 Server = -2,
54 Changed = -3
55 };
57 int debug;
58 char *ofile;
61 int doftp(URL*, URL*, Range*, Out*, long);
62 int dohttp(URL*, URL*, Range*, Out*, long);
63 int crackurl(URL*, char*);
64 Range* crackrange(char*);
65 int getheader(int, char*, int);
66 int httpheaders(int, int, URL*, Range*);
67 int httprcode(int);
68 int cistrncmp(char*, char*, int);
69 int cistrcmp(char*, char*);
70 void initibuf(void);
71 int readline(int, char*, int);
72 int readibuf(int, char*, int);
73 int dfprint(int, char*, ...);
74 void unreadline(char*);
75 int output(Out*, char*, int);
76 void setoffset(Out*, int);
78 int verbose;
79 char *net;
80 char tcpdir[NETPATHLEN];
81 int headerprint;
83 struct {
84 char *name;
85 int (*f)(URL*, URL*, Range*, Out*, long);
86 } method[] = {
87 { "http", dohttp },
88 { "https", dohttp },
89 { "ftp", doftp },
90 { "_______", nil },
91 };
93 void
94 usage(void)
95 {
96 fprint(2, "usage: %s [-hv] [-o outfile] [-p body] [-x netmtpt] url\n", argv0);
97 threadexitsall("usage");
98 }
100 void
101 threadmain(int argc, char **argv)
103 URL u;
104 Range r;
105 int errs, n;
106 ulong mtime;
107 Dir *d;
108 char postbody[4096], *p, *e, *t, *hpx;
109 URL px; /* Proxy */
110 Out out;
112 ofile = nil;
113 p = postbody;
114 e = p + sizeof(postbody);
115 r.start = 0;
116 r.end = -1;
117 mtime = 0;
118 memset(&u, 0, sizeof(u));
119 memset(&px, 0, sizeof(px));
120 hpx = getenv("httpproxy");
122 ARGBEGIN {
123 case 'o':
124 ofile = ARGF();
125 break;
126 case 'd':
127 debug = 1;
128 break;
129 case 'h':
130 headerprint = 1;
131 break;
132 case 'v':
133 verbose = 1;
134 break;
135 case 'x':
136 net = ARGF();
137 if(net == nil)
138 usage();
139 break;
140 case 'p':
141 t = ARGF();
142 if(t == nil)
143 usage();
144 if(p != postbody)
145 p = seprint(p, e, "&%s", t);
146 else
147 p = seprint(p, e, "%s", t);
148 u.postbody = postbody;
150 break;
151 default:
152 usage();
153 } ARGEND;
155 if(net != nil){
156 if(strlen(net) > sizeof(tcpdir)-5)
157 sysfatal("network mount point too long");
158 snprint(tcpdir, sizeof(tcpdir), "%s/tcp", net);
159 } else
160 snprint(tcpdir, sizeof(tcpdir), "tcp");
162 if(argc != 1)
163 usage();
166 out.fd = 1;
167 out.written = 0;
168 out.offset = 0;
169 out.curr = nil;
170 out.hiwat = nil;
171 if(ofile != nil){
172 d = dirstat(ofile);
173 if(d == nil){
174 out.fd = create(ofile, OWRITE, 0664);
175 if(out.fd < 0)
176 sysfatal("creating %s: %r", ofile);
177 } else {
178 out.fd = open(ofile, OWRITE);
179 if(out.fd < 0)
180 sysfatal("can't open %s: %r", ofile);
181 r.start = d->length;
182 mtime = d->mtime;
183 free(d);
187 errs = 0;
189 if(crackurl(&u, argv[0]) < 0)
190 sysfatal("%r");
191 if(hpx && crackurl(&px, hpx) < 0)
192 sysfatal("%r");
194 for(;;){
195 setoffset(&out, 0);
196 /* transfer data */
197 werrstr("");
198 n = (*method[u.method].f)(&u, &px, &r, &out, mtime);
200 switch(n){
201 case Eof:
202 threadexitsall(0);
203 break;
204 case Error:
205 if(errs++ < 10)
206 continue;
207 sysfatal("too many errors with no progress %r");
208 break;
209 case Server:
210 sysfatal("server returned: %r");
211 break;
214 /* forward progress */
215 errs = 0;
216 r.start += n;
217 if(r.start >= r.end)
218 break;
221 threadexitsall(0);
224 int
225 crackurl(URL *u, char *s)
227 char *p;
228 int i;
230 if(u->host != nil){
231 free(u->host);
232 u->host = nil;
234 if(u->page != nil){
235 free(u->page);
236 u->page = nil;
239 /* get type */
240 u->method = Other;
241 for(p = s; *p; p++){
242 if(*p == '/'){
243 u->method = Http;
244 p = s;
245 break;
247 if(*p == ':' && *(p+1)=='/' && *(p+2)=='/'){
248 *p = 0;
249 p += 3;
250 for(i = 0; i < nelem(method); i++){
251 if(cistrcmp(s, method[i].name) == 0){
252 u->method = i;
253 break;
256 break;
260 if(u->method == Other){
261 werrstr("unsupported URL type %s", s);
262 return -1;
265 /* get system */
266 s = p;
267 p = strchr(s, '/');
268 if(p == nil){
269 u->host = strdup(s);
270 u->page = strdup("/");
271 } else {
272 u->page = strdup(p);
273 *p = 0;
274 u->host = strdup(s);
275 *p = '/';
278 if(p = strchr(u->host, ':')) {
279 *p++ = 0;
280 u->port = p;
281 } else
282 u->port = method[u->method].name;
284 if(*(u->host) == 0){
285 werrstr("bad url, null host");
286 return -1;
289 return 0;
292 char *day[] = {
293 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
294 };
296 char *month[] = {
297 "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
298 };
300 struct
302 int fd;
303 long mtime;
304 } note;
306 void
307 catch(void *v, char *s)
309 Dir d;
311 USED(v);
312 USED(s);
314 nulldir(&d);
315 d.mtime = note.mtime;
316 if(dirfwstat(note.fd, &d) < 0)
317 sysfatal("catch: can't dirfwstat: %r");
318 noted(NDFLT);
321 int
322 dohttp(URL *u, URL *px, Range *r, Out *out, long mtime)
324 int fd, cfd;
325 int redirect, auth, loop;
326 int n, rv, code;
327 long tot, vtime;
328 Tm *tm;
329 char buf[1024];
330 char err[ERRMAX];
333 /* always move back to a previous 512 byte bound because some
334 * servers can't seem to deal with requests that start at the
335 * end of the file
336 */
337 if(r->start)
338 r->start = ((r->start-1)/512)*512;
340 /* loop for redirects, requires reading both response code and headers */
341 fd = -1;
342 for(loop = 0; loop < 32; loop++){
343 if(px->host == nil){
344 fd = dial(netmkaddr(u->host, tcpdir, u->port), 0, 0, 0);
345 } else {
346 fd = dial(netmkaddr(px->host, tcpdir, px->port), 0, 0, 0);
348 if(fd < 0)
349 return Error;
351 if(u->method == Https){
352 int tfd;
353 TLSconn conn;
355 memset(&conn, 0, sizeof conn);
356 tfd = tlsClient(fd, &conn);
357 if(tfd < 0){
358 fprint(2, "tlsClient: %r\n");
359 close(fd);
360 return Error;
362 /* BUG: check cert here? */
363 if(conn.cert)
364 free(conn.cert);
365 close(fd);
366 fd = tfd;
369 /* write request, use range if not start of file */
370 if(u->postbody == nil){
371 if(px->host == nil){
372 dfprint(fd, "GET %s HTTP/1.0\r\n"
373 "Host: %s\r\n"
374 "User-agent: Plan9/hget\r\n"
375 "Cache-Control: no-cache\r\n"
376 "Pragma: no-cache\r\n",
377 u->page, u->host);
378 } else {
379 dfprint(fd, "GET http://%s%s HTTP/1.0\r\n"
380 "Host: %s\r\n"
381 "User-agent: Plan9/hget\r\n"
382 "Cache-Control: no-cache\r\n"
383 "Pragma: no-cache\r\n",
384 u->host, u->page, u->host);
386 if(u->cred)
387 dfprint(fd, "Authorization: Basic %s\r\n",
388 u->cred);
389 } else {
390 dfprint(fd, "POST %s HTTP/1.0\r\n"
391 "Host: %s\r\n"
392 "Content-type: application/x-www-form-urlencoded\r\n"
393 "Content-length: %d\r\n"
394 "User-agent: Plan9/hget\r\n"
395 "\r\n",
396 u->page, u->host, strlen(u->postbody));
397 dfprint(fd, "%s", u->postbody);
399 if(r->start != 0){
400 dfprint(fd, "Range: bytes=%d-\n", r->start);
401 if(u->etag != nil){
402 dfprint(fd, "If-range: %s\n", u->etag);
403 } else {
404 tm = gmtime(mtime);
405 dfprint(fd, "If-range: %s, %d %s %d %2d:%2.2d:%2.2d GMT\n",
406 day[tm->wday], tm->mday, month[tm->mon],
407 tm->year+1900, tm->hour, tm->min, tm->sec);
410 if((cfd = open("/mnt/webcookies/http", ORDWR)) >= 0){
411 if(fprint(cfd, "http://%s%s", u->host, u->page) > 0){
412 while((n = read(cfd, buf, sizeof buf)) > 0){
413 if(debug)
414 write(2, buf, n);
415 write(fd, buf, n);
417 }else{
418 close(cfd);
419 cfd = -1;
423 dfprint(fd, "\r\n", u->host);
425 auth = 0;
426 redirect = 0;
427 initibuf();
428 code = httprcode(fd);
429 switch(code){
430 case Error: /* connection timed out */
431 case Eof:
432 close(fd);
433 close(cfd);
434 return code;
436 case 200: /* OK */
437 case 201: /* Created */
438 case 202: /* Accepted */
439 if(ofile == nil && r->start != 0)
440 sysfatal("page changed underfoot");
441 break;
443 case 204: /* No Content */
444 sysfatal("No Content");
446 case 206: /* Partial Content */
447 setoffset(out, r->start);
448 break;
450 case 301: /* Moved Permanently */
451 case 302: /* Moved Temporarily */
452 redirect = 1;
453 u->postbody = nil;
454 break;
456 case 304: /* Not Modified */
457 break;
459 case 400: /* Bad Request */
460 sysfatal("Bad Request");
462 case 401: /* Unauthorized */
463 if (auth)
464 sysfatal("Authentication failed");
465 auth = 1;
466 break;
468 case 402: /* ??? */
469 sysfatal("Unauthorized");
471 case 403: /* Forbidden */
472 sysfatal("Forbidden by server");
474 case 404: /* Not Found */
475 sysfatal("Not found on server");
477 case 407: /* Proxy Authentication */
478 sysfatal("Proxy authentication required");
480 case 500: /* Internal server error */
481 sysfatal("Server choked");
483 case 501: /* Not implemented */
484 sysfatal("Server can't do it!");
486 case 502: /* Bad gateway */
487 sysfatal("Bad gateway");
489 case 503: /* Service unavailable */
490 sysfatal("Service unavailable");
492 default:
493 sysfatal("Unknown response code %d", code);
496 if(u->redirect != nil){
497 free(u->redirect);
498 u->redirect = nil;
501 rv = httpheaders(fd, cfd, u, r);
502 close(cfd);
503 if(rv != 0){
504 close(fd);
505 return rv;
508 if(!redirect && !auth)
509 break;
511 if (redirect){
512 if(u->redirect == nil)
513 sysfatal("redirect: no URL");
514 if(crackurl(u, u->redirect) < 0)
515 sysfatal("redirect: %r");
519 /* transfer whatever you get */
520 if(ofile != nil && u->mtime != 0){
521 note.fd = out->fd;
522 note.mtime = u->mtime;
523 notify(catch);
526 tot = 0;
527 vtime = 0;
528 for(;;){
529 n = readibuf(fd, buf, sizeof(buf));
530 if(n <= 0)
531 break;
532 if(output(out, buf, n) != n)
533 break;
534 tot += n;
535 if(verbose && (vtime != time(0) || r->start == r->end)) {
536 vtime = time(0);
537 fprint(2, "%ld %ld\n", r->start+tot, r->end);
540 notify(nil);
541 close(fd);
543 if(ofile != nil && u->mtime != 0){
544 Dir d;
546 rerrstr(err, sizeof err);
547 nulldir(&d);
548 d.mtime = u->mtime;
549 if(dirfwstat(out->fd, &d) < 0)
550 fprint(2, "couldn't set mtime: %r\n");
551 errstr(err, sizeof err);
554 return tot;
557 /* get the http response code */
558 int
559 httprcode(int fd)
561 int n;
562 char *p;
563 char buf[256];
565 n = readline(fd, buf, sizeof(buf)-1);
566 if(n <= 0)
567 return n;
568 if(debug)
569 fprint(2, "%d <- %s\n", fd, buf);
570 p = strchr(buf, ' ');
571 if(strncmp(buf, "HTTP/", 5) != 0 || p == nil){
572 werrstr("bad response from server");
573 return -1;
575 buf[n] = 0;
576 return atoi(p+1);
579 /* read in and crack the http headers, update u and r */
580 void hhetag(char*, URL*, Range*);
581 void hhmtime(char*, URL*, Range*);
582 void hhclen(char*, URL*, Range*);
583 void hhcrange(char*, URL*, Range*);
584 void hhuri(char*, URL*, Range*);
585 void hhlocation(char*, URL*, Range*);
586 void hhauth(char*, URL*, Range*);
588 struct {
589 char *name;
590 void (*f)(char*, URL*, Range*);
591 } headers[] = {
592 { "etag:", hhetag },
593 { "last-modified:", hhmtime },
594 { "content-length:", hhclen },
595 { "content-range:", hhcrange },
596 { "uri:", hhuri },
597 { "location:", hhlocation },
598 { "WWW-Authenticate:", hhauth },
599 };
600 int
601 httpheaders(int fd, int cfd, URL *u, Range *r)
603 char buf[2048];
604 char *p;
605 int i, n;
607 for(;;){
608 n = getheader(fd, buf, sizeof(buf));
609 if(n <= 0)
610 break;
611 if(cfd >= 0)
612 fprint(cfd, "%s\n", buf);
613 for(i = 0; i < nelem(headers); i++){
614 n = strlen(headers[i].name);
615 if(cistrncmp(buf, headers[i].name, n) == 0){
616 /* skip field name and leading white */
617 p = buf + n;
618 while(*p == ' ' || *p == '\t')
619 p++;
621 (*headers[i].f)(p, u, r);
622 break;
626 return n;
629 /*
630 * read a single mime header, collect continuations.
632 * this routine assumes that there is a blank line twixt
633 * the header and the message body, otherwise bytes will
634 * be lost.
635 */
636 int
637 getheader(int fd, char *buf, int n)
639 char *p, *e;
640 int i;
642 n--;
643 p = buf;
644 for(e = p + n; ; p += i){
645 i = readline(fd, p, e-p);
646 if(i < 0)
647 return i;
649 if(p == buf){
650 /* first line */
651 if(strchr(buf, ':') == nil)
652 break; /* end of headers */
653 } else {
654 /* continuation line */
655 if(*p != ' ' && *p != '\t'){
656 unreadline(p);
657 *p = 0;
658 break; /* end of this header */
662 if(headerprint)
663 print("%s\n", buf);
665 if(debug)
666 fprint(2, "%d <- %s\n", fd, buf);
667 return p-buf;
670 void
671 hhetag(char *p, URL *u, Range *r)
673 USED(r);
675 if(u->etag != nil){
676 if(strcmp(u->etag, p) != 0)
677 sysfatal("file changed underfoot");
678 } else
679 u->etag = strdup(p);
682 char* monthchars = "janfebmaraprmayjunjulaugsepoctnovdec";
684 void
685 hhmtime(char *p, URL *u, Range *r)
687 char *month, *day, *yr, *hms;
688 char *fields[6];
689 Tm tm, now;
690 int i;
692 USED(r);
694 i = getfields(p, fields, 6, 1, " \t");
695 if(i < 5)
696 return;
698 day = fields[1];
699 month = fields[2];
700 yr = fields[3];
701 hms = fields[4];
703 /* default time */
704 now = *gmtime(time(0));
705 tm = now;
706 tm.yday = 0;
708 /* convert ascii month to a number twixt 1 and 12 */
709 if(*month >= '0' && *month <= '9'){
710 tm.mon = atoi(month) - 1;
711 if(tm.mon < 0 || tm.mon > 11)
712 tm.mon = 5;
713 } else {
714 for(p = month; *p; p++)
715 *p = tolower((uchar)*p);
716 for(i = 0; i < 12; i++)
717 if(strncmp(&monthchars[i*3], month, 3) == 0){
718 tm.mon = i;
719 break;
723 tm.mday = atoi(day);
725 if(hms) {
726 tm.hour = strtoul(hms, &p, 10);
727 if(*p == ':') {
728 p++;
729 tm.min = strtoul(p, &p, 10);
730 if(*p == ':') {
731 p++;
732 tm.sec = strtoul(p, &p, 10);
735 if(tolower((uchar)*p) == 'p')
736 tm.hour += 12;
739 if(yr) {
740 tm.year = atoi(yr);
741 if(tm.year >= 1900)
742 tm.year -= 1900;
743 } else {
744 if(tm.mon > now.mon || (tm.mon == now.mon && tm.mday > now.mday+1))
745 tm.year--;
748 strcpy(tm.zone, "GMT");
749 /* convert to epoch seconds */
750 u->mtime = tm2sec(&tm);
753 void
754 hhclen(char *p, URL *u, Range *r)
756 USED(u);
758 r->end = atoi(p);
761 void
762 hhcrange(char *p, URL *u, Range *r)
764 char *x;
765 vlong l;
767 USED(u);
768 l = 0;
769 x = strchr(p, '/');
770 if(x)
771 l = atoll(x+1);
772 if(l == 0)
773 x = strchr(p, '-');
774 if(x)
775 l = atoll(x+1);
776 if(l)
777 r->end = l;
780 void
781 hhuri(char *p, URL *u, Range *r)
783 USED(r);
785 if(*p != '<')
786 return;
787 u->redirect = strdup(p+1);
788 p = strchr(u->redirect, '>');
789 if(p != nil)
790 *p = 0;
793 void
794 hhlocation(char *p, URL *u, Range *r)
796 USED(r);
798 u->redirect = strdup(p);
801 void
802 hhauth(char *p, URL *u, Range *r)
804 char *f[4];
805 UserPasswd *up;
806 char *s, cred[64];
808 USED(r);
810 if (cistrncmp(p, "basic ", 6) != 0)
811 sysfatal("only Basic authentication supported");
813 if (gettokens(p, f, nelem(f), "\"") < 2)
814 sysfatal("garbled auth data");
816 if ((up = auth_getuserpasswd(auth_getkey, "proto=pass service=http dom=%q relm=%q",
817 u->host, f[1])) == nil)
818 sysfatal("cannot authenticate");
820 s = smprint("%s:%s", up->user, up->passwd);
821 if(enc64(cred, sizeof(cred), (uchar *)s, strlen(s)) == -1)
822 sysfatal("enc64");
823 free(s);
825 assert(u->cred = strdup(cred));
828 enum
830 /* ftp return codes */
831 Extra= 1,
832 Success= 2,
833 Incomplete= 3,
834 TempFail= 4,
835 PermFail= 5,
837 Nnetdir= 64, /* max length of network directory paths */
838 Ndialstr= 64 /* max length of dial strings */
839 };
841 int ftpcmd(int, char*, ...);
842 int ftprcode(int, char*, int);
843 int hello(int);
844 int logon(int);
845 int xfertype(int, char*);
846 int passive(int, URL*);
847 int active(int, URL*);
848 int ftpxfer(int, Out*, Range*);
849 int terminateftp(int, int);
850 int getaddrport(char*, uchar*, uchar*);
851 int ftprestart(int, Out*, URL*, Range*, long);
853 int
854 doftp(URL *u, URL *px, Range *r, Out *out, long mtime)
856 int pid, ctl, data, rv;
857 Waitmsg *w;
858 char msg[64];
860 /* untested, proxy dosn't work with ftp (I think) */
861 if(px->host == nil){
862 ctl = dial(netmkaddr(u->host, tcpdir, u->port), 0, 0, 0);
863 } else {
864 ctl = dial(netmkaddr(px->host, tcpdir, px->port), 0, 0, 0);
867 if(ctl < 0)
868 return Error;
869 if(net == nil)
870 strcpy(tcpdir, "tcp");
872 initibuf();
874 rv = hello(ctl);
875 if(rv < 0)
876 return terminateftp(ctl, rv);
878 rv = logon(ctl);
879 if(rv < 0)
880 return terminateftp(ctl, rv);
882 rv = xfertype(ctl, "I");
883 if(rv < 0)
884 return terminateftp(ctl, rv);
886 /* if file is up to date and the right size, stop */
887 if(ftprestart(ctl, out, u, r, mtime) > 0){
888 close(ctl);
889 return Eof;
892 /* first try passive mode, then active */
893 data = passive(ctl, u);
894 if(data < 0){
895 data = active(ctl, u);
896 if(data < 0)
897 return Error;
900 /* fork */
901 switch(pid = fork()){
902 case -1:
903 close(data);
904 return terminateftp(ctl, Error);
905 case 0:
906 ftpxfer(data, out, r);
907 close(data);
908 #undef _exits
909 _exits(0);
910 default:
911 close(data);
912 break;
915 /* wait for reply message */
916 rv = ftprcode(ctl, msg, sizeof(msg));
917 close(ctl);
919 /* wait for process to terminate */
920 w = nil;
921 for(;;){
922 free(w);
923 w = wait();
924 if(w == nil)
925 return Error;
926 if(w->pid == pid){
927 if(w->msg[0] == 0){
928 free(w);
929 break;
931 werrstr("xfer: %s", w->msg);
932 free(w);
933 return Error;
937 switch(rv){
938 case Success:
939 return Eof;
940 case TempFail:
941 return Server;
942 default:
943 return Error;
947 int
948 ftpcmd(int ctl, char *fmt, ...)
950 va_list arg;
951 char buf[2*1024], *s;
953 va_start(arg, fmt);
954 s = vseprint(buf, buf + (sizeof(buf)-4) / sizeof(*buf), fmt, arg);
955 va_end(arg);
956 if(debug)
957 fprint(2, "%d -> %s\n", ctl, buf);
958 *s++ = '\r';
959 *s++ = '\n';
960 if(write(ctl, buf, s - buf) != s - buf)
961 return -1;
962 return 0;
965 int
966 ftprcode(int ctl, char *msg, int len)
968 int rv;
969 int i;
970 char *p;
972 len--; /* room for terminating null */
973 for(;;){
974 *msg = 0;
975 i = readline(ctl, msg, len);
976 if(i < 0)
977 break;
978 if(debug)
979 fprint(2, "%d <- %s\n", ctl, msg);
981 /* stop if not a continuation */
982 rv = strtol(msg, &p, 10);
983 if(rv >= 100 && rv < 600 && p==msg+3 && *p == ' ')
984 return rv/100;
986 *msg = 0;
988 return -1;
991 int
992 hello(int ctl)
994 char msg[1024];
996 /* wait for hello from other side */
997 if(ftprcode(ctl, msg, sizeof(msg)) != Success){
998 werrstr("HELLO: %s", msg);
999 return Server;
1001 return 0;
1004 int
1005 getdec(char *p, int n)
1007 int x = 0;
1008 int i;
1010 for(i = 0; i < n; i++)
1011 x = x*10 + (*p++ - '0');
1012 return x;
1015 int
1016 ftprestart(int ctl, Out *out, URL *u, Range *r, long mtime)
1018 Tm tm;
1019 char msg[1024];
1020 long x, rmtime;
1022 ftpcmd(ctl, "MDTM %s", u->page);
1023 if(ftprcode(ctl, msg, sizeof(msg)) != Success){
1024 r->start = 0;
1025 return 0; /* need to do something */
1028 /* decode modification time */
1029 if(strlen(msg) < 4 + 4 + 2 + 2 + 2 + 2 + 2){
1030 r->start = 0;
1031 return 0; /* need to do something */
1033 memset(&tm, 0, sizeof(tm));
1034 tm.year = getdec(msg+4, 4) - 1900;
1035 tm.mon = getdec(msg+4+4, 2) - 1;
1036 tm.mday = getdec(msg+4+4+2, 2);
1037 tm.hour = getdec(msg+4+4+2+2, 2);
1038 tm.min = getdec(msg+4+4+2+2+2, 2);
1039 tm.sec = getdec(msg+4+4+2+2+2+2, 2);
1040 strcpy(tm.zone, "GMT");
1041 rmtime = tm2sec(&tm);
1042 if(rmtime > mtime)
1043 r->start = 0;
1045 /* get size */
1046 ftpcmd(ctl, "SIZE %s", u->page);
1047 if(ftprcode(ctl, msg, sizeof(msg)) == Success){
1048 x = atol(msg+4);
1049 if(r->start == x)
1050 return 1; /* we're up to date */
1051 r->end = x;
1054 /* seek to restart point */
1055 if(r->start > 0){
1056 ftpcmd(ctl, "REST %lud", r->start);
1057 if(ftprcode(ctl, msg, sizeof(msg)) == Incomplete){
1058 setoffset(out, r->start);
1059 }else
1060 r->start = 0;
1063 return 0; /* need to do something */
1066 int
1067 logon(int ctl)
1069 char msg[1024];
1071 /* login anonymous */
1072 ftpcmd(ctl, "USER anonymous");
1073 switch(ftprcode(ctl, msg, sizeof(msg))){
1074 case Success:
1075 return 0;
1076 case Incomplete:
1077 break; /* need password */
1078 default:
1079 werrstr("USER: %s", msg);
1080 return Server;
1083 /* send user id as password */
1084 sprint(msg, "%s@closedmind.org", getuser());
1085 ftpcmd(ctl, "PASS %s", msg);
1086 if(ftprcode(ctl, msg, sizeof(msg)) != Success){
1087 werrstr("PASS: %s", msg);
1088 return Server;
1091 return 0;
1094 int
1095 xfertype(int ctl, char *t)
1097 char msg[1024];
1099 ftpcmd(ctl, "TYPE %s", t);
1100 if(ftprcode(ctl, msg, sizeof(msg)) != Success){
1101 werrstr("TYPE %s: %s", t, msg);
1102 return Server;
1105 return 0;
1108 int
1109 passive(int ctl, URL *u)
1111 char msg[1024];
1112 char ipaddr[32];
1113 char *f[6];
1114 char *p;
1115 int fd;
1116 int port;
1117 char aport[12];
1119 ftpcmd(ctl, "PASV");
1120 if(ftprcode(ctl, msg, sizeof(msg)) != Success)
1121 return Error;
1123 /* get address and port number from reply, this is AI */
1124 p = strchr(msg, '(');
1125 if(p == nil){
1126 for(p = msg+3; *p; p++)
1127 if(isdigit((uchar)*p))
1128 break;
1129 } else
1130 p++;
1131 if(getfields(p, f, 6, 0, ",)") < 6){
1132 werrstr("ftp protocol botch");
1133 return Server;
1135 snprint(ipaddr, sizeof(ipaddr), "%s.%s.%s.%s",
1136 f[0], f[1], f[2], f[3]);
1137 port = ((atoi(f[4])&0xff)<<8) + (atoi(f[5])&0xff);
1138 sprint(aport, "%d", port);
1140 /* open data connection */
1141 fd = dial(netmkaddr(ipaddr, tcpdir, aport), 0, 0, 0);
1142 if(fd < 0){
1143 werrstr("passive mode failed: %r");
1144 return Error;
1147 /* tell remote to send a file */
1148 ftpcmd(ctl, "RETR %s", u->page);
1149 if(ftprcode(ctl, msg, sizeof(msg)) != Extra){
1150 werrstr("RETR %s: %s", u->page, msg);
1151 return Error;
1153 return fd;
1156 int
1157 active(int ctl, URL *u)
1159 char msg[1024];
1160 char dir[40], ldir[40];
1161 uchar ipaddr[4];
1162 uchar port[2];
1163 int lcfd, dfd, afd;
1165 /* announce a port for the call back */
1166 snprint(msg, sizeof(msg), "%s!*!0", tcpdir);
1167 afd = announce(msg, dir);
1168 if(afd < 0)
1169 return Error;
1171 /* get a local address/port of the annoucement */
1172 if(getaddrport(dir, ipaddr, port) < 0){
1173 close(afd);
1174 return Error;
1177 /* tell remote side address and port*/
1178 ftpcmd(ctl, "PORT %d,%d,%d,%d,%d,%d", ipaddr[0], ipaddr[1], ipaddr[2],
1179 ipaddr[3], port[0], port[1]);
1180 if(ftprcode(ctl, msg, sizeof(msg)) != Success){
1181 close(afd);
1182 werrstr("active: %s", msg);
1183 return Error;
1186 /* tell remote to send a file */
1187 ftpcmd(ctl, "RETR %s", u->page);
1188 if(ftprcode(ctl, msg, sizeof(msg)) != Extra){
1189 close(afd);
1190 werrstr("RETR: %s", msg);
1191 return Server;
1194 /* wait for a connection */
1195 lcfd = listen(dir, ldir);
1196 if(lcfd < 0){
1197 close(afd);
1198 return Error;
1200 dfd = accept(lcfd, ldir);
1201 if(dfd < 0){
1202 close(afd);
1203 close(lcfd);
1204 return Error;
1206 close(afd);
1207 close(lcfd);
1209 return dfd;
1212 int
1213 ftpxfer(int in, Out *out, Range *r)
1215 char buf[1024];
1216 long vtime;
1217 int i, n;
1219 vtime = 0;
1220 for(n = 0;;n += i){
1221 i = read(in, buf, sizeof(buf));
1222 if(i == 0)
1223 break;
1224 if(i < 0)
1225 return Error;
1226 if(output(out, buf, i) != i)
1227 return Error;
1228 r->start += i;
1229 if(verbose && (vtime != time(0) || r->start == r->end)) {
1230 vtime = time(0);
1231 fprint(2, "%ld %ld\n", r->start, r->end);
1234 return n;
1237 int
1238 terminateftp(int ctl, int rv)
1240 close(ctl);
1241 return rv;
1245 * case insensitive strcmp (why aren't these in libc?)
1247 int
1248 cistrncmp(char *a, char *b, int n)
1250 while(n-- > 0){
1251 if(tolower((uchar)*a++) != tolower((uchar)*b++))
1252 return -1;
1254 return 0;
1257 int
1258 cistrcmp(char *a, char *b)
1260 while(*a || *b)
1261 if(tolower((uchar)*a++) != tolower((uchar)*b++))
1262 return -1;
1264 return 0;
1268 * buffered io
1270 struct
1272 char *rp;
1273 char *wp;
1274 char buf[4*1024];
1275 } b;
1277 void
1278 initibuf(void)
1280 b.rp = b.wp = b.buf;
1284 * read a possibly buffered line, strip off trailing while
1286 int
1287 readline(int fd, char *buf, int len)
1289 int n;
1290 char *p;
1291 int eof = 0;
1293 len--;
1295 for(p = buf;;){
1296 if(b.rp >= b.wp){
1297 n = read(fd, b.wp, sizeof(b.buf)/2);
1298 if(n < 0)
1299 return -1;
1300 if(n == 0){
1301 eof = 1;
1302 break;
1304 b.wp += n;
1306 n = *b.rp++;
1307 if(len > 0){
1308 *p++ = n;
1309 len--;
1311 if(n == '\n')
1312 break;
1315 /* drop trailing white */
1316 for(;;){
1317 if(p <= buf)
1318 break;
1319 n = *(p-1);
1320 if(n != ' ' && n != '\t' && n != '\r' && n != '\n')
1321 break;
1322 p--;
1324 *p = 0;
1326 if(eof && p == buf)
1327 return -1;
1329 return p-buf;
1332 void
1333 unreadline(char *line)
1335 int i, n;
1337 i = strlen(line);
1338 n = b.wp-b.rp;
1339 memmove(&b.buf[i+1], b.rp, n);
1340 memmove(b.buf, line, i);
1341 b.buf[i] = '\n';
1342 b.rp = b.buf;
1343 b.wp = b.rp + i + 1 + n;
1346 int
1347 readibuf(int fd, char *buf, int len)
1349 int n;
1351 n = b.wp-b.rp;
1352 if(n > 0){
1353 if(n > len)
1354 n = len;
1355 memmove(buf, b.rp, n);
1356 b.rp += n;
1357 return n;
1359 return read(fd, buf, len);
1362 int
1363 dfprint(int fd, char *fmt, ...)
1365 char buf[4*1024];
1366 va_list arg;
1368 va_start(arg, fmt);
1369 vseprint(buf, buf+sizeof(buf), fmt, arg);
1370 va_end(arg);
1371 if(debug)
1372 fprint(2, "%d -> %s", fd, buf);
1373 return fprint(fd, "%s", buf);
1376 int
1377 getaddrport(char *dir, uchar *ipaddr, uchar *port)
1379 char buf[256];
1380 int fd, i;
1381 char *p;
1383 snprint(buf, sizeof(buf), "%s/local", dir);
1384 fd = open(buf, OREAD);
1385 if(fd < 0)
1386 return -1;
1387 i = read(fd, buf, sizeof(buf)-1);
1388 close(fd);
1389 if(i <= 0)
1390 return -1;
1391 buf[i] = 0;
1392 p = strchr(buf, '!');
1393 if(p != nil)
1394 *p++ = 0;
1395 v4parseip(ipaddr, buf);
1396 i = atoi(p);
1397 port[0] = i>>8;
1398 port[1] = i;
1399 return 0;
1402 void
1403 md5free(DigestState *state)
1405 uchar x[MD5dlen];
1406 md5(nil, 0, x, state);
1409 DigestState*
1410 md5dup(DigestState *state)
1412 DigestState *s2;
1414 s2 = malloc(sizeof(DigestState));
1415 if(s2 == nil)
1416 sysfatal("malloc: %r");
1417 *s2 = *state;
1418 s2->malloced = 1;
1419 return s2;
1422 void
1423 setoffset(Out *out, int offset)
1425 md5free(out->curr);
1426 if(offset == 0)
1427 out->curr = md5(nil, 0, nil, nil);
1428 else
1429 out->curr = nil;
1430 out->offset = offset;
1434 * write some output, discarding it (but keeping track)
1435 * if we've already written it. if we've gone backwards,
1436 * verify that everything previously written matches
1437 * that which would have been written from the current
1438 * output.
1440 int
1441 output(Out *out, char *buf, int nb)
1443 int n, d;
1444 uchar m0[MD5dlen], m1[MD5dlen];
1446 n = nb;
1447 d = out->written - out->offset;
1448 assert(d >= 0);
1449 if(d > 0){
1450 if(n < d){
1451 if(out->curr != nil)
1452 md5((uchar*)buf, n, nil, out->curr);
1453 out->offset += n;
1454 return n;
1456 if(out->curr != nil){
1457 md5((uchar*)buf, d, m0, out->curr);
1458 out->curr = nil;
1459 md5(nil, 0, m1, md5dup(out->hiwat));
1460 if(memcmp(m0, m1, MD5dlen) != 0){
1461 fprint(2, "integrity check failure at offset %d\n", out->written);
1462 return -1;
1465 buf += d;
1466 n -= d;
1467 out->offset += d;
1469 if(n > 0){
1470 out->hiwat = md5((uchar*)buf, n, nil, out->hiwat);
1471 n = write(out->fd, buf, n);
1472 if(n > 0){
1473 out->offset += n;
1474 out->written += n;
1477 return n + d;