From 56a48c69aacd0a0deef24f7608c10cf3dbaab0a0 Mon Sep 17 00:00:00 2001 From: rsc Date: Fri, 18 Mar 2005 18:57:16 +0000 Subject: add hget (no ftp support) --- src/cmd/hget.c | 1484 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1484 insertions(+) create mode 100644 src/cmd/hget.c (limited to 'src/cmd/hget.c') diff --git a/src/cmd/hget.c b/src/cmd/hget.c new file mode 100644 index 00000000..6c1986dc --- /dev/null +++ b/src/cmd/hget.c @@ -0,0 +1,1484 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +typedef struct URL URL; +struct URL +{ + int method; + char *host; + char *port; + char *page; + char *etag; + char *redirect; + char *postbody; + char *cred; + long mtime; +}; + +typedef struct Range Range; +struct Range +{ + long start; /* only 2 gig supported, tdb */ + long end; +}; + +typedef struct Out Out; +struct Out +{ + int fd; + int offset; /* notional current offset in output */ + int written; /* number of bytes successfully transferred to output */ + DigestState *curr; /* digest state up to offset (if known) */ + DigestState *hiwat; /* digest state of all bytes written */ +}; + +enum +{ + Http, + Https, + Ftp, + Other +}; + +enum +{ + Eof = 0, + Error = -1, + Server = -2, + Changed = -3, +}; + +int debug; +char *ofile; + + +int doftp(URL*, URL*, Range*, Out*, long); +int dohttp(URL*, URL*, Range*, Out*, long); +int crackurl(URL*, char*); +Range* crackrange(char*); +int getheader(int, char*, int); +int httpheaders(int, int, URL*, Range*); +int httprcode(int); +int cistrncmp(char*, char*, int); +int cistrcmp(char*, char*); +void initibuf(void); +int readline(int, char*, int); +int readibuf(int, char*, int); +int dfprint(int, char*, ...); +void unreadline(char*); +int output(Out*, char*, int); +void setoffset(Out*, int); + +int verbose; +char *net; +char tcpdir[NETPATHLEN]; +int headerprint; + +struct { + char *name; + int (*f)(URL*, URL*, Range*, Out*, long); +} method[] = { + [Http] { "http", dohttp }, + [Https] { "https", dohttp }, + [Ftp] { "ftp", doftp }, + [Other] { "_______", nil }, +}; + +void +usage(void) +{ + fprint(2, "usage: %s [-hv] [-o outfile] [-p body] [-x netmtpt] url\n", argv0); + threadexitsall("usage"); +} + +void +threadmain(int argc, char **argv) +{ + URL u; + Range r; + int errs, n; + ulong mtime; + Dir *d; + char postbody[4096], *p, *e, *t, *hpx; + URL px; // Proxy + Out out; + + ofile = nil; + p = postbody; + e = p + sizeof(postbody); + r.start = 0; + r.end = -1; + mtime = 0; + memset(&u, 0, sizeof(u)); + memset(&px, 0, sizeof(px)); + hpx = getenv("httpproxy"); + + ARGBEGIN { + case 'o': + ofile = ARGF(); + break; + case 'd': + debug = 1; + break; + case 'h': + headerprint = 1; + break; + case 'v': + verbose = 1; + break; + case 'x': + net = ARGF(); + if(net == nil) + usage(); + break; + case 'p': + t = ARGF(); + if(t == nil) + usage(); + if(p != postbody) + p = seprint(p, e, "&%s", t); + else + p = seprint(p, e, "%s", t); + u.postbody = postbody; + + break; + default: + usage(); + } ARGEND; + + if(net != nil){ + if(strlen(net) > sizeof(tcpdir)-5) + sysfatal("network mount point too long"); + snprint(tcpdir, sizeof(tcpdir), "%s/tcp", net); + } else + snprint(tcpdir, sizeof(tcpdir), "tcp"); + + if(argc != 1) + usage(); + + + out.fd = 1; + out.written = 0; + out.offset = 0; + out.curr = nil; + out.hiwat = nil; + if(ofile != nil){ + d = dirstat(ofile); + if(d == nil){ + out.fd = create(ofile, OWRITE, 0664); + if(out.fd < 0) + sysfatal("creating %s: %r", ofile); + } else { + out.fd = open(ofile, OWRITE); + if(out.fd < 0) + sysfatal("can't open %s: %r", ofile); + r.start = d->length; + mtime = d->mtime; + free(d); + } + } + + errs = 0; + + if(crackurl(&u, argv[0]) < 0) + sysfatal("%r"); + if(hpx && crackurl(&px, hpx) < 0) + sysfatal("%r"); + + for(;;){ + setoffset(&out, 0); + /* transfer data */ + werrstr(""); + n = (*method[u.method].f)(&u, &px, &r, &out, mtime); + + switch(n){ + case Eof: + threadexitsall(0); + break; + case Error: + if(errs++ < 10) + continue; + sysfatal("too many errors with no progress %r"); + break; + case Server: + sysfatal("server returned: %r"); + break; + } + + /* forward progress */ + errs = 0; + r.start += n; + if(r.start >= r.end) + break; + } + + threadexitsall(0); +} + +int +crackurl(URL *u, char *s) +{ + char *p; + int i; + + if(u->host != nil){ + free(u->host); + u->host = nil; + } + if(u->page != nil){ + free(u->page); + u->page = nil; + } + + /* get type */ + u->method = Other; + for(p = s; *p; p++){ + if(*p == '/'){ + u->method = Http; + p = s; + break; + } + if(*p == ':' && *(p+1)=='/' && *(p+2)=='/'){ + *p = 0; + p += 3; + for(i = 0; i < nelem(method); i++){ + if(cistrcmp(s, method[i].name) == 0){ + u->method = i; + break; + } + } + break; + } + } + + if(u->method == Other){ + werrstr("unsupported URL type %s", s); + return -1; + } + + /* get system */ + s = p; + p = strchr(s, '/'); + if(p == nil){ + u->host = strdup(s); + u->page = strdup("/"); + } else { + u->page = strdup(p); + *p = 0; + u->host = strdup(s); + *p = '/'; + } + + if(p = strchr(u->host, ':')) { + *p++ = 0; + u->port = p; + } else + u->port = method[u->method].name; + + if(*(u->host) == 0){ + werrstr("bad url, null host"); + return -1; + } + + return 0; +} + +char *day[] = { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" +}; + +char *month[] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + +struct +{ + int fd; + long mtime; +} note; + +void +catch(void *v, char *s) +{ + Dir d; + + USED(v); + USED(s); + + nulldir(&d); + d.mtime = note.mtime; + if(dirfwstat(note.fd, &d) < 0) + sysfatal("catch: can't dirfwstat: %r"); + noted(NDFLT); +} + +int +dohttp(URL *u, URL *px, Range *r, Out *out, long mtime) +{ + int fd, cfd; + int redirect, auth, loop; + int n, rv, code; + long tot, vtime; + Tm *tm; + char buf[1024]; + char err[ERRMAX]; + + + /* always move back to a previous 512 byte bound because some + * servers can't seem to deal with requests that start at the + * end of the file + */ + if(r->start) + r->start = ((r->start-1)/512)*512; + + /* loop for redirects, requires reading both response code and headers */ + fd = -1; + for(loop = 0; loop < 32; loop++){ + if(px->host == nil){ + fd = dial(netmkaddr(u->host, tcpdir, u->port), 0, 0, 0); + } else { + fd = dial(netmkaddr(px->host, tcpdir, px->port), 0, 0, 0); + } + if(fd < 0) + return Error; + + if(u->method == Https){ + int tfd; + TLSconn conn; + + memset(&conn, 0, sizeof conn); + tfd = tlsClient(fd, &conn); + if(tfd < 0){ + fprint(2, "tlsClient: %r\n"); + close(fd); + return Error; + } + /* BUG: check cert here? */ + if(conn.cert) + free(conn.cert); + close(fd); + fd = tfd; + } + + /* write request, use range if not start of file */ + if(u->postbody == nil){ + if(px->host == nil){ + dfprint(fd, "GET %s HTTP/1.0\r\n" + "Host: %s\r\n" + "User-agent: Plan9/hget\r\n" + "Cache-Control: no-cache\r\n" + "Pragma: no-cache\r\n", + u->page, u->host); + } else { + dfprint(fd, "GET http://%s%s HTTP/1.0\r\n" + "Host: %s\r\n" + "User-agent: Plan9/hget\r\n" + "Cache-Control: no-cache\r\n" + "Pragma: no-cache\r\n", + u->host, u->page, u->host); + } + if(u->cred) + dfprint(fd, "Authorization: Basic %s\r\n", + u->cred); + } else { + dfprint(fd, "POST %s HTTP/1.0\r\n" + "Host: %s\r\n" + "Content-type: application/x-www-form-urlencoded\r\n" + "Content-length: %d\r\n" + "User-agent: Plan9/hget\r\n" + "\r\n", + u->page, u->host, strlen(u->postbody)); + dfprint(fd, "%s", u->postbody); + } + if(r->start != 0){ + dfprint(fd, "Range: bytes=%d-\n", r->start); + if(u->etag != nil){ + dfprint(fd, "If-range: %s\n", u->etag); + } else { + tm = gmtime(mtime); + dfprint(fd, "If-range: %s, %d %s %d %2d:%2.2d:%2.2d GMT\n", + day[tm->wday], tm->mday, month[tm->mon], + tm->year+1900, tm->hour, tm->min, tm->sec); + } + } + if((cfd = open("/mnt/webcookies/http", ORDWR)) >= 0){ + if(fprint(cfd, "http://%s%s", u->host, u->page) > 0){ + while((n = read(cfd, buf, sizeof buf)) > 0){ + if(debug) + write(2, buf, n); + write(fd, buf, n); + } + }else{ + close(cfd); + cfd = -1; + } + } + + dfprint(fd, "\r\n", u->host); + + auth = 0; + redirect = 0; + initibuf(); + code = httprcode(fd); + switch(code){ + case Error: /* connection timed out */ + case Eof: + close(fd); + close(cfd); + return code; + + case 200: /* OK */ + case 201: /* Created */ + case 202: /* Accepted */ + if(ofile == nil && r->start != 0) + sysfatal("page changed underfoot"); + break; + + case 204: /* No Content */ + sysfatal("No Content"); + + case 206: /* Partial Content */ + setoffset(out, r->start); + break; + + case 301: /* Moved Permanently */ + case 302: /* Moved Temporarily */ + redirect = 1; + u->postbody = nil; + break; + + case 304: /* Not Modified */ + break; + + case 400: /* Bad Request */ + sysfatal("Bad Request"); + + case 401: /* Unauthorized */ + if (auth) + sysfatal("Authentication failed"); + auth = 1; + break; + + case 402: /* ??? */ + sysfatal("Unauthorized"); + + case 403: /* Forbidden */ + sysfatal("Forbidden by server"); + + case 404: /* Not Found */ + sysfatal("Not found on server"); + + case 407: /* Proxy Authentication */ + sysfatal("Proxy authentication required"); + + case 500: /* Internal server error */ + sysfatal("Server choked"); + + case 501: /* Not implemented */ + sysfatal("Server can't do it!"); + + case 502: /* Bad gateway */ + sysfatal("Bad gateway"); + + case 503: /* Service unavailable */ + sysfatal("Service unavailable"); + + default: + sysfatal("Unknown response code %d", code); + } + + if(u->redirect != nil){ + free(u->redirect); + u->redirect = nil; + } + + rv = httpheaders(fd, cfd, u, r); + close(cfd); + if(rv != 0){ + close(fd); + return rv; + } + + if(!redirect && !auth) + break; + + if (redirect){ + if(u->redirect == nil) + sysfatal("redirect: no URL"); + if(crackurl(u, u->redirect) < 0) + sysfatal("redirect: %r"); + } + } + + /* transfer whatever you get */ + if(ofile != nil && u->mtime != 0){ + note.fd = out->fd; + note.mtime = u->mtime; + notify(catch); + } + + tot = 0; + vtime = 0; + for(;;){ + n = readibuf(fd, buf, sizeof(buf)); + if(n <= 0) + break; + if(output(out, buf, n) != n) + break; + tot += n; + if(verbose && vtime != time(0)) { + vtime = time(0); + fprint(2, "%ld %ld\n", r->start+tot, r->end); + } + } + notify(nil); + close(fd); + + if(ofile != nil && u->mtime != 0){ + Dir d; + + rerrstr(err, sizeof err); + nulldir(&d); + d.mtime = u->mtime; + if(dirfwstat(out->fd, &d) < 0) + fprint(2, "couldn't set mtime: %r\n"); + errstr(err, sizeof err); + } + + return tot; +} + +/* get the http response code */ +int +httprcode(int fd) +{ + int n; + char *p; + char buf[256]; + + n = readline(fd, buf, sizeof(buf)-1); + if(n <= 0) + return n; + if(debug) + fprint(2, "%d <- %s\n", fd, buf); + p = strchr(buf, ' '); + if(strncmp(buf, "HTTP/", 5) != 0 || p == nil){ + werrstr("bad response from server"); + return -1; + } + buf[n] = 0; + return atoi(p+1); +} + +/* read in and crack the http headers, update u and r */ +void hhetag(char*, URL*, Range*); +void hhmtime(char*, URL*, Range*); +void hhclen(char*, URL*, Range*); +void hhcrange(char*, URL*, Range*); +void hhuri(char*, URL*, Range*); +void hhlocation(char*, URL*, Range*); +void hhauth(char*, URL*, Range*); + +struct { + char *name; + void (*f)(char*, URL*, Range*); +} headers[] = { + { "etag:", hhetag }, + { "last-modified:", hhmtime }, + { "content-length:", hhclen }, + { "content-range:", hhcrange }, + { "uri:", hhuri }, + { "location:", hhlocation }, + { "WWW-Authenticate:", hhauth }, +}; +int +httpheaders(int fd, int cfd, URL *u, Range *r) +{ + char buf[2048]; + char *p; + int i, n; + + for(;;){ + n = getheader(fd, buf, sizeof(buf)); + if(n <= 0) + break; + if(cfd >= 0) + fprint(cfd, "%s\n", buf); + for(i = 0; i < nelem(headers); i++){ + n = strlen(headers[i].name); + if(cistrncmp(buf, headers[i].name, n) == 0){ + /* skip field name and leading white */ + p = buf + n; + while(*p == ' ' || *p == '\t') + p++; + + (*headers[i].f)(p, u, r); + break; + } + } + } + return n; +} + +/* + * read a single mime header, collect continuations. + * + * this routine assumes that there is a blank line twixt + * the header and the message body, otherwise bytes will + * be lost. + */ +int +getheader(int fd, char *buf, int n) +{ + char *p, *e; + int i; + + n--; + p = buf; + for(e = p + n; ; p += i){ + i = readline(fd, p, e-p); + if(i < 0) + return i; + + if(p == buf){ + /* first line */ + if(strchr(buf, ':') == nil) + break; /* end of headers */ + } else { + /* continuation line */ + if(*p != ' ' && *p != '\t'){ + unreadline(p); + *p = 0; + break; /* end of this header */ + } + } + } + if(headerprint) + print("%s\n", buf); + + if(debug) + fprint(2, "%d <- %s\n", fd, buf); + return p-buf; +} + +void +hhetag(char *p, URL *u, Range *r) +{ + USED(r); + + if(u->etag != nil){ + if(strcmp(u->etag, p) != 0) + sysfatal("file changed underfoot"); + } else + u->etag = strdup(p); +} + +char* monthchars = "janfebmaraprmayjunjulaugsepoctnovdec"; + +void +hhmtime(char *p, URL *u, Range *r) +{ + char *month, *day, *yr, *hms; + char *fields[6]; + Tm tm, now; + int i; + + USED(r); + + i = getfields(p, fields, 6, 1, " \t"); + if(i < 5) + return; + + day = fields[1]; + month = fields[2]; + yr = fields[3]; + hms = fields[4]; + + /* default time */ + now = *gmtime(time(0)); + tm = now; + tm.yday = 0; + + /* convert ascii month to a number twixt 1 and 12 */ + if(*month >= '0' && *month <= '9'){ + tm.mon = atoi(month) - 1; + if(tm.mon < 0 || tm.mon > 11) + tm.mon = 5; + } else { + for(p = month; *p; p++) + *p = tolower(*p); + for(i = 0; i < 12; i++) + if(strncmp(&monthchars[i*3], month, 3) == 0){ + tm.mon = i; + break; + } + } + + tm.mday = atoi(day); + + if(hms) { + tm.hour = strtoul(hms, &p, 10); + if(*p == ':') { + p++; + tm.min = strtoul(p, &p, 10); + if(*p == ':') { + p++; + tm.sec = strtoul(p, &p, 10); + } + } + if(tolower(*p) == 'p') + tm.hour += 12; + } + + if(yr) { + tm.year = atoi(yr); + if(tm.year >= 1900) + tm.year -= 1900; + } else { + if(tm.mon > now.mon || (tm.mon == now.mon && tm.mday > now.mday+1)) + tm.year--; + } + + strcpy(tm.zone, "GMT"); + /* convert to epoch seconds */ + u->mtime = tm2sec(&tm); +} + +void +hhclen(char *p, URL *u, Range *r) +{ + USED(u); + + r->end = atoi(p); +} + +void +hhcrange(char *p, URL *u, Range *r) +{ + char *x; + vlong l; + + USED(u); + l = 0; + x = strchr(p, '/'); + if(x) + l = atoll(x+1); + if(l == 0) + x = strchr(p, '-'); + if(x) + l = atoll(x+1); + if(l) + r->end = l; +} + +void +hhuri(char *p, URL *u, Range *r) +{ + USED(r); + + if(*p != '<') + return; + u->redirect = strdup(p+1); + p = strchr(u->redirect, '>'); + if(p != nil) + *p = 0; +} + +void +hhlocation(char *p, URL *u, Range *r) +{ + USED(r); + + u->redirect = strdup(p); +} + +void +hhauth(char *p, URL *u, Range *r) +{ + char *f[4]; + UserPasswd *up; + char *s, cred[64]; + + USED(r); + + if (cistrncmp(p, "basic ", 6) != 0) + sysfatal("only Basic authentication supported"); + + if (gettokens(p, f, nelem(f), "\"") < 2) + sysfatal("garbled auth data"); + + if ((up = auth_getuserpasswd(auth_getkey, "proto=pass service=http dom=%q relm=%q", + u->host, f[1])) == nil) + sysfatal("cannot authenticate"); + + s = smprint("%s:%s", up->user, up->passwd); + if(enc64(cred, sizeof(cred), (uchar *)s, strlen(s)) == -1) + sysfatal("enc64"); + free(s); + + assert(u->cred = strdup(cred)); +} + +enum +{ + /* ftp return codes */ + Extra= 1, + Success= 2, + Incomplete= 3, + TempFail= 4, + PermFail= 5, + + Nnetdir= 64, /* max length of network directory paths */ + Ndialstr= 64, /* max length of dial strings */ +}; + +int ftpcmd(int, char*, ...); +int ftprcode(int, char*, int); +int hello(int); +int logon(int); +int xfertype(int, char*); +int passive(int, URL*); +int active(int, URL*); +int ftpxfer(int, Out*, Range*); +int terminateftp(int, int); +int getaddrport(char*, uchar*, uchar*); +int ftprestart(int, Out*, URL*, Range*, long); + +int +doftp(URL *u, URL *px, Range *r, Out *out, long mtime) +{ + int pid, ctl, data, rv; + Waitmsg *w; + char msg[64]; + char conndir[NETPATHLEN]; + char *p; + + /* untested, proxy dosn't work with ftp (I think) */ + if(px->host == nil){ + ctl = dial(netmkaddr(u->host, tcpdir, u->port), 0, conndir, 0); + } else { + ctl = dial(netmkaddr(px->host, tcpdir, px->port), 0, conndir, 0); + } + + if(ctl < 0) + return Error; + if(net == nil){ + p = strrchr(conndir, '/'); + *p = 0; + snprint(tcpdir, sizeof(tcpdir), conndir); + } + + initibuf(); + + rv = hello(ctl); + if(rv < 0) + return terminateftp(ctl, rv); + + rv = logon(ctl); + if(rv < 0) + return terminateftp(ctl, rv); + + rv = xfertype(ctl, "I"); + if(rv < 0) + return terminateftp(ctl, rv); + + /* if file is up to date and the right size, stop */ + if(ftprestart(ctl, out, u, r, mtime) > 0){ + close(ctl); + return Eof; + } + + /* first try passive mode, then active */ + data = passive(ctl, u); + if(data < 0){ + data = active(ctl, u); + if(data < 0) + return Error; + } + + /* fork */ + switch(pid = fork()){ + case -1: + close(data); + return terminateftp(ctl, Error); + case 0: + ftpxfer(data, out, r); + close(data); + #undef _exits + _exits(0); + default: + close(data); + break; + } + + /* wait for reply message */ + rv = ftprcode(ctl, msg, sizeof(msg)); + close(ctl); + + /* wait for process to terminate */ + w = nil; + for(;;){ + free(w); + w = wait(); + if(w == nil) + return Error; + if(w->pid == pid){ + if(w->msg[0] == 0){ + free(w); + break; + } + werrstr("xfer: %s", w->msg); + free(w); + return Error; + } + } + + switch(rv){ + case Success: + return Eof; + case TempFail: + return Server; + default: + return Error; + } +} + +int +ftpcmd(int ctl, char *fmt, ...) +{ + va_list arg; + char buf[2*1024], *s; + + va_start(arg, fmt); + s = vseprint(buf, buf + (sizeof(buf)-4) / sizeof(*buf), fmt, arg); + va_end(arg); + if(debug) + fprint(2, "%d -> %s\n", ctl, buf); + *s++ = '\r'; + *s++ = '\n'; + if(write(ctl, buf, s - buf) != s - buf) + return -1; + return 0; +} + +int +ftprcode(int ctl, char *msg, int len) +{ + int rv; + int i; + char *p; + + len--; /* room for terminating null */ + for(;;){ + *msg = 0; + i = readline(ctl, msg, len); + if(i < 0) + break; + if(debug) + fprint(2, "%d <- %s\n", ctl, msg); + + /* stop if not a continuation */ + rv = strtol(msg, &p, 10); + if(rv >= 100 && rv < 600 && p==msg+3 && *p == ' ') + return rv/100; + } + *msg = 0; + + return -1; +} + +int +hello(int ctl) +{ + char msg[1024]; + + /* wait for hello from other side */ + if(ftprcode(ctl, msg, sizeof(msg)) != Success){ + werrstr("HELLO: %s", msg); + return Server; + } + return 0; +} + +int +getdec(char *p, int n) +{ + int x = 0; + int i; + + for(i = 0; i < n; i++) + x = x*10 + (*p++ - '0'); + return x; +} + +int +ftprestart(int ctl, Out *out, URL *u, Range *r, long mtime) +{ + Tm tm; + char msg[1024]; + long x, rmtime; + + ftpcmd(ctl, "MDTM %s", u->page); + if(ftprcode(ctl, msg, sizeof(msg)) != Success){ + r->start = 0; + return 0; /* need to do something */ + } + + /* decode modification time */ + if(strlen(msg) < 4 + 4 + 2 + 2 + 2 + 2 + 2){ + r->start = 0; + return 0; /* need to do something */ + } + memset(&tm, 0, sizeof(tm)); + tm.year = getdec(msg+4, 4) - 1900; + tm.mon = getdec(msg+4+4, 2) - 1; + tm.mday = getdec(msg+4+4+2, 2); + tm.hour = getdec(msg+4+4+2+2, 2); + tm.min = getdec(msg+4+4+2+2+2, 2); + tm.sec = getdec(msg+4+4+2+2+2+2, 2); + strcpy(tm.zone, "GMT"); + rmtime = tm2sec(&tm); + if(rmtime > mtime) + r->start = 0; + + /* get size */ + ftpcmd(ctl, "SIZE %s", u->page); + if(ftprcode(ctl, msg, sizeof(msg)) == Success){ + x = atol(msg+4); + if(r->start == x) + return 1; /* we're up to date */ + r->end = x; + } + + /* seek to restart point */ + if(r->start > 0){ + ftpcmd(ctl, "REST %lud", r->start); + if(ftprcode(ctl, msg, sizeof(msg)) == Incomplete){ + setoffset(out, r->start); + }else + r->start = 0; + } + + return 0; /* need to do something */ +} + +int +logon(int ctl) +{ + char msg[1024]; + + /* login anonymous */ + ftpcmd(ctl, "USER anonymous"); + switch(ftprcode(ctl, msg, sizeof(msg))){ + case Success: + return 0; + case Incomplete: + break; /* need password */ + default: + werrstr("USER: %s", msg); + return Server; + } + + /* send user id as password */ + sprint(msg, "%s@closedmind.org", getuser()); + ftpcmd(ctl, "PASS %s", msg); + if(ftprcode(ctl, msg, sizeof(msg)) != Success){ + werrstr("PASS: %s", msg); + return Server; + } + + return 0; +} + +int +xfertype(int ctl, char *t) +{ + char msg[1024]; + + ftpcmd(ctl, "TYPE %s", t); + if(ftprcode(ctl, msg, sizeof(msg)) != Success){ + werrstr("TYPE %s: %s", t, msg); + return Server; + } + + return 0; +} + +int +passive(int ctl, URL *u) +{ + char msg[1024]; + char ipaddr[32]; + char *f[6]; + char *p; + int fd; + int port; + char aport[12]; + + ftpcmd(ctl, "PASV"); + if(ftprcode(ctl, msg, sizeof(msg)) != Success) + return Error; + + /* get address and port number from reply, this is AI */ + p = strchr(msg, '('); + if(p == nil){ + for(p = msg+3; *p; p++) + if(isdigit(*p)) + break; + } else + p++; + if(getfields(p, f, 6, 0, ",)") < 6){ + werrstr("ftp protocol botch"); + return Server; + } + snprint(ipaddr, sizeof(ipaddr), "%s.%s.%s.%s", + f[0], f[1], f[2], f[3]); + port = ((atoi(f[4])&0xff)<<8) + (atoi(f[5])&0xff); + sprint(aport, "%d", port); + + /* open data connection */ + fd = dial(netmkaddr(ipaddr, tcpdir, aport), 0, 0, 0); + if(fd < 0){ + werrstr("passive mode failed: %r"); + return Error; + } + + /* tell remote to send a file */ + ftpcmd(ctl, "RETR %s", u->page); + if(ftprcode(ctl, msg, sizeof(msg)) != Extra){ + werrstr("RETR %s: %s", u->page, msg); + return Error; + } + return fd; +} + +int +active(int ctl, URL *u) +{ + char msg[1024]; + char dir[40], ldir[40]; + uchar ipaddr[4]; + uchar port[2]; + int lcfd, dfd, afd; + + /* announce a port for the call back */ + snprint(msg, sizeof(msg), "%s!*!0", tcpdir); + afd = announce(msg, dir); + if(afd < 0) + return Error; + + /* get a local address/port of the annoucement */ + if(getaddrport(dir, ipaddr, port) < 0){ + close(afd); + return Error; + } + + /* tell remote side address and port*/ + ftpcmd(ctl, "PORT %d,%d,%d,%d,%d,%d", ipaddr[0], ipaddr[1], ipaddr[2], + ipaddr[3], port[0], port[1]); + if(ftprcode(ctl, msg, sizeof(msg)) != Success){ + close(afd); + werrstr("active: %s", msg); + return Error; + } + + /* tell remote to send a file */ + ftpcmd(ctl, "RETR %s", u->page); + if(ftprcode(ctl, msg, sizeof(msg)) != Extra){ + close(afd); + werrstr("RETR: %s", msg); + return Server; + } + + /* wait for a connection */ + lcfd = listen(dir, ldir); + if(lcfd < 0){ + close(afd); + return Error; + } + dfd = accept(lcfd, ldir); + if(dfd < 0){ + close(afd); + close(lcfd); + return Error; + } + close(afd); + close(lcfd); + + return dfd; +} + +int +ftpxfer(int in, Out *out, Range *r) +{ + char buf[1024]; + long vtime; + int i, n; + + vtime = 0; + for(n = 0;;n += i){ + i = read(in, buf, sizeof(buf)); + if(i == 0) + break; + if(i < 0) + return Error; + if(output(out, buf, i) != i) + return Error; + r->start += i; + if(verbose && vtime != time(0)) { + vtime = time(0); + fprint(2, "%ld %ld\n", r->start, r->end); + } + } + return n; +} + +int +terminateftp(int ctl, int rv) +{ + close(ctl); + return rv; +} + +/* + * case insensitive strcmp (why aren't these in libc?) + */ +int +cistrncmp(char *a, char *b, int n) +{ + while(n-- > 0){ + if(tolower(*a++) != tolower(*b++)) + return -1; + } + return 0; +} + +int +cistrcmp(char *a, char *b) +{ + while(*a || *b) + if(tolower(*a++) != tolower(*b++)) + return -1; + + return 0; +} + +/* + * buffered io + */ +struct +{ + char *rp; + char *wp; + char buf[4*1024]; +} b; + +void +initibuf(void) +{ + b.rp = b.wp = b.buf; +} + +/* + * read a possibly buffered line, strip off trailing while + */ +int +readline(int fd, char *buf, int len) +{ + int n; + char *p; + int eof = 0; + + len--; + + for(p = buf;;){ + if(b.rp >= b.wp){ + n = read(fd, b.wp, sizeof(b.buf)/2); + if(n < 0) + return -1; + if(n == 0){ + eof = 1; + break; + } + b.wp += n; + } + n = *b.rp++; + if(len > 0){ + *p++ = n; + len--; + } + if(n == '\n') + break; + } + + /* drop trailing white */ + for(;;){ + if(p <= buf) + break; + n = *(p-1); + if(n != ' ' && n != '\t' && n != '\r' && n != '\n') + break; + p--; + } + *p = 0; + + if(eof && p == buf) + return -1; + + return p-buf; +} + +void +unreadline(char *line) +{ + int i, n; + + i = strlen(line); + n = b.wp-b.rp; + memmove(&b.buf[i+1], b.rp, n); + memmove(b.buf, line, i); + b.buf[i] = '\n'; + b.rp = b.buf; + b.wp = b.rp + i + 1 + n; +} + +int +readibuf(int fd, char *buf, int len) +{ + int n; + + n = b.wp-b.rp; + if(n > 0){ + if(n > len) + n = len; + memmove(buf, b.rp, n); + b.rp += n; + return n; + } + return read(fd, buf, len); +} + +int +dfprint(int fd, char *fmt, ...) +{ + char buf[4*1024]; + va_list arg; + + va_start(arg, fmt); + vseprint(buf, buf+sizeof(buf), fmt, arg); + va_end(arg); + if(debug) + fprint(2, "%d -> %s", fd, buf); + return fprint(fd, "%s", buf); +} + +int +getaddrport(char *dir, uchar *ipaddr, uchar *port) +{ + char buf[256]; + int fd, i; + char *p; + + snprint(buf, sizeof(buf), "%s/local", dir); + fd = open(buf, OREAD); + if(fd < 0) + return -1; + i = read(fd, buf, sizeof(buf)-1); + close(fd); + if(i <= 0) + return -1; + buf[i] = 0; + p = strchr(buf, '!'); + if(p != nil) + *p++ = 0; + v4parseip(ipaddr, buf); + i = atoi(p); + port[0] = i>>8; + port[1] = i; + return 0; +} + +void +md5free(DigestState *state) +{ + uchar x[MD5dlen]; + md5(nil, 0, x, state); +} + +DigestState* +md5dup(DigestState *state) +{ + DigestState *s2; + + s2 = malloc(sizeof(DigestState)); + if(s2 == nil) + sysfatal("malloc: %r"); + *s2 = *state; + s2->malloced = 1; + return s2; +} + +void +setoffset(Out *out, int offset) +{ + md5free(out->curr); + if(offset == 0) + out->curr = md5(nil, 0, nil, nil); + else + out->curr = nil; + out->offset = offset; +} + +/* + * write some output, discarding it (but keeping track) + * if we've already written it. if we've gone backwards, + * verify that everything previously written matches + * that which would have been written from the current + * output. + */ +int +output(Out *out, char *buf, int nb) +{ + int n, d; + uchar m0[MD5dlen], m1[MD5dlen]; + + n = nb; + d = out->written - out->offset; + assert(d >= 0); + if(d > 0){ + if(n < d){ + if(out->curr != nil) + md5((uchar*)buf, n, nil, out->curr); + out->offset += n; + return n; + } + if(out->curr != nil){ + md5((uchar*)buf, d, m0, out->curr); + out->curr = nil; + md5(nil, 0, m1, md5dup(out->hiwat)); + if(memcmp(m0, m1, MD5dlen) != 0){ + fprint(2, "integrity check failure at offset %d\n", out->written); + return -1; + } + } + buf += d; + n -= d; + out->offset += d; + } + if(n > 0){ + out->hiwat = md5((uchar*)buf, n, nil, out->hiwat); + n = write(out->fd, buf, n); + if(n > 0){ + out->offset += n; + out->written += n; + } + } + return n + d; +} + -- cgit v1.2.3