Home | History | Annotate | Line # | Download | only in ftp
fetch.c revision 1.8
      1 /*	$NetBSD: fetch.c,v 1.8 1997/04/21 18:45:47 lukem Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1997 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Jason Thorpe and Luke Mewburn.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
     30  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 #ifndef lint
     40 static char rcsid[] = "$NetBSD: fetch.c,v 1.8 1997/04/21 18:45:47 lukem Exp $";
     41 #endif /* not lint */
     42 
     43 /*
     44  * FTP User Program -- Command line file retrieval
     45  */
     46 
     47 #include <sys/types.h>
     48 #include <sys/param.h>
     49 #include <sys/socket.h>
     50 
     51 #include <netinet/in.h>
     52 
     53 #include <arpa/ftp.h>
     54 #include <arpa/inet.h>
     55 
     56 #include <ctype.h>
     57 #include <err.h>
     58 #include <netdb.h>
     59 #include <fcntl.h>
     60 #include <signal.h>
     61 #include <stdio.h>
     62 #include <stdlib.h>
     63 #include <string.h>
     64 #include <unistd.h>
     65 
     66 #include "ftp_var.h"
     67 
     68 #define	FTP_URL		"ftp://"	/* ftp URL prefix */
     69 #define	HTTP_URL	"http://"	/* http URL prefix */
     70 #define FTP_PROXY	"ftp_proxy"	/* env var with ftp proxy location */
     71 #define HTTP_PROXY	"http_proxy"	/* env var with http proxy location */
     72 
     73 
     74 #define EMPTYSTRING(x)	((x) == NULL || (*(x) == '\0'))
     75 
     76 jmp_buf	httpabort;
     77 
     78 /*
     79  * Retrieve URL, via the proxy in $proxyvar if necessary.
     80  * Modifies the string argument given.
     81  * Returns -1 on failure, 0 on success
     82  */
     83 int
     84 url_get(line, proxyenv)
     85 	char *line;
     86 	char *proxyenv;
     87 {
     88 	struct sockaddr_in sin;
     89 	int i, out, port, s;
     90 	size_t buflen, len;
     91 	char c, *cp, *cp2, *savefile, *portnum, *path, buf[4096];
     92 	char *proxy, *host;
     93 	sig_t oldintr;
     94 	off_t hashbytes;
     95 
     96 	s = -1;
     97 	proxy = NULL;
     98 
     99 	if (strncasecmp(line, HTTP_URL, sizeof(HTTP_URL) - 1) == 0)
    100 		host = line + sizeof(HTTP_URL) - 1;
    101 	else if (strncasecmp(line, FTP_URL, sizeof(FTP_URL) - 1) == 0)
    102 		host = line + sizeof(FTP_URL) - 1;
    103 	else
    104 		errx(1, "url_get: invalid url '%s'", line);
    105 
    106 	path = strchr(host, '/');		/* find path */
    107 	if (EMPTYSTRING(path))
    108 		goto cleanup_url_get;
    109 	*path++ = '\0';
    110 	if (EMPTYSTRING(path))
    111 		goto cleanup_url_get;
    112 
    113 	savefile = strrchr(path, '/');			/* find savefile */
    114 	if (savefile != NULL)
    115 		savefile++;
    116 	else
    117 		savefile = path;
    118 	if (EMPTYSTRING(savefile))
    119 		goto cleanup_url_get;
    120 
    121 	if (proxyenv != NULL) {				/* use proxy */
    122 		proxy = strdup(proxyenv);
    123 		if (proxy == NULL)
    124 			errx(1, "Can't allocate memory for proxy url.");
    125 		if (strncasecmp(proxy, HTTP_URL, sizeof(HTTP_URL) - 1) == 0)
    126 			host = proxy + sizeof(HTTP_URL) - 1;
    127 		else if (strncasecmp(proxy, FTP_URL, sizeof(FTP_URL) - 1) == 0)
    128 			host = proxy + sizeof(FTP_URL) - 1;
    129 		else {
    130 			warnx("Malformed proxy URL: %s", proxy);
    131 			goto cleanup_url_get;
    132 		}
    133 		if (EMPTYSTRING(host))
    134 			goto cleanup_url_get;
    135 		*--path = '/';			/* add / back to real path */
    136 		path = strchr(host, '/');	/* remove trailing / on host */
    137 		if (! EMPTYSTRING(path))
    138 			*path++ = '\0';
    139 		path = line;
    140 	}
    141 
    142 	portnum = strchr(host, ':');			/* find portnum */
    143 	if (portnum != NULL)
    144 		*portnum++ = '\0';
    145 
    146 	if (debug)
    147 		printf("host %s, port %s, path %s, save as %s.\n",
    148 		    host, portnum, path, savefile);
    149 
    150 	memset(&sin, 0, sizeof(sin));
    151 	sin.sin_family = AF_INET;
    152 
    153 	if (isdigit(host[0])) {
    154 		if (inet_aton(host, &sin.sin_addr) == 0) {
    155 			warnx("Invalid IP address: %s", host);
    156 			goto cleanup_url_get;
    157 		}
    158 	} else {
    159 		struct hostent *hp;
    160 
    161 		hp = gethostbyname(host);
    162 		if (hp == NULL) {
    163 			warnx("%s: %s", host, hstrerror(h_errno));
    164 			goto cleanup_url_get;
    165 		}
    166 		if (hp->h_addrtype != AF_INET) {
    167 			warnx("%s: not an Internet address?", host);
    168 			goto cleanup_url_get;
    169 		}
    170 		memcpy(&sin.sin_addr, hp->h_addr, hp->h_length);
    171 	}
    172 
    173 	if (! EMPTYSTRING(portnum)) {
    174 		port = atoi(portnum);
    175 		if (port < 1 || (port & 0xffff) != port) {
    176 			warnx("Invalid port: %s", portnum);
    177 			goto cleanup_url_get;
    178 		}
    179 		port = htons(port);
    180 	} else
    181 		port = httpport;
    182 	sin.sin_port = port;
    183 
    184 	s = socket(AF_INET, SOCK_STREAM, 0);
    185 	if (s == -1) {
    186 		warnx("Can't create socket");
    187 		goto cleanup_url_get;
    188 	}
    189 
    190 	if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
    191 		warn("Can't connect to %s", host);
    192 		goto cleanup_url_get;
    193 	}
    194 
    195 	/*
    196 	 * Construct and send the request.  We're expecting a return
    197 	 * status of "200". Proxy requests don't want leading /.
    198 	 */
    199 	if (!proxy)
    200 		printf("Requesting %s:%d/%s\n", line, ntohs(port), path);
    201 	else
    202 		printf("Requesting %s (via %s)\n", line, proxyenv);
    203 	snprintf(buf, sizeof(buf), "GET %s%s HTTP/1.0\n\n",
    204 	    proxy ? "" : "/", path);
    205 	buflen = strlen(buf);
    206 	if (write(s, buf, buflen) < buflen) {
    207 		warn("write");
    208 		goto cleanup_url_get;
    209 	}
    210 	memset(buf, 0, sizeof(buf));
    211 	for (i = 0, buflen = sizeof(buf), cp = buf; i < buflen; cp++, i++) {
    212 		if (read(s, cp, 1) != 1)
    213 			goto improper;
    214 		if (*cp == '\r')
    215 			continue;
    216 		if (*cp == '\n')
    217 			break;
    218 	}
    219 	buf[buflen - 1] = '\0';		/* sanity */
    220 	cp = strchr(buf, ' ');
    221 	if (cp == NULL)
    222 		goto improper;
    223 	else
    224 		cp++;
    225 	if (strncmp(cp, "200", 3)) {
    226 		warnx("Error retrieving file: %s", cp);
    227 		goto cleanup_url_get;
    228 	}
    229 
    230 	/*
    231 	 * Read the rest of the header.
    232 	 */
    233 	memset(buf, 0, sizeof(buf));
    234 	c = '\0';
    235 	for (i = 0, buflen = sizeof(buf), cp = buf; i < buflen; cp++, i++) {
    236 		if (read(s, cp, 1) != 1)
    237 			goto improper;
    238 		if (*cp == '\r')
    239 			continue;
    240 		if (*cp == '\n' && c == '\n')
    241 			break;
    242 		c = *cp;
    243 	}
    244 	buf[buflen - 1] = '\0';		/* sanity */
    245 
    246 	/*
    247 	 * Look for the "Content-length: " header.
    248 	 */
    249 #define CONTENTLEN "Content-Length: "
    250 	for (cp = buf; *cp != '\0'; cp++) {
    251 		if (tolower(*cp) == 'c' &&
    252 		    strncasecmp(cp, CONTENTLEN, sizeof(CONTENTLEN) - 1) == 0)
    253 			break;
    254 	}
    255 	if (*cp == '\0')
    256 		goto improper;
    257 	cp += sizeof(CONTENTLEN) - 1;
    258 	cp2 = strchr(cp, '\n');
    259 	if (cp2 == NULL)
    260 		goto improper;
    261 	else
    262 		*cp2 = '\0';
    263 	filesize = atoi(cp);
    264 	if (filesize < 1)
    265 		goto improper;
    266 
    267 	/* Open the output file. */
    268 	out = open(savefile, O_CREAT | O_WRONLY | O_TRUNC, 0666);
    269 	if (out < 0) {
    270 		warn("Can't open %s", savefile);
    271 		goto cleanup_url_get;
    272 	}
    273 
    274 	/* Trap signals */
    275 	oldintr = NULL;
    276 	if (setjmp(httpabort)) {
    277 		if (oldintr)
    278 			(void)signal(SIGINT, oldintr);
    279 		goto cleanup_url_get;
    280 	}
    281 	oldintr = signal(SIGINT, aborthttp);
    282 
    283 	bytes = 0;
    284 	hashbytes = mark;
    285 	progressmeter(-1);
    286 
    287 	/* Finally, suck down the file. */
    288 	i = 0;
    289 	while ((len = read(s, buf, sizeof(buf))) > 0) {
    290 		bytes += len;
    291 		for (cp = buf; len > 0; len -= i, cp += i) {
    292 			if ((i = write(out, cp, len)) == -1) {
    293 				warn("Writing %s", savefile);
    294 				goto cleanup_url_get;
    295 			}
    296 			else if (i == 0)
    297 				break;
    298 		}
    299 		if (hash && !progress) {
    300 			while (bytes >= hashbytes) {
    301 				(void)putchar('#');
    302 				hashbytes += mark;
    303 			}
    304 			(void)fflush(stdout);
    305 		}
    306 	}
    307 	if (hash && !progress && bytes > 0) {
    308 		if (bytes < mark)
    309 			(void)putchar('#');
    310 		(void)putchar('\n');
    311 		(void)fflush(stdout);
    312 	}
    313 	if (len != 0) {
    314 		warn("Reading from socket");
    315 		goto cleanup_url_get;
    316 	}
    317 	progressmeter(1);
    318 	if (verbose)
    319 		puts("Successfully retrieved file.");
    320 	(void)signal(SIGINT, oldintr);
    321 
    322 	close(s);
    323 	close(out);
    324 	if (proxy)
    325 		free(proxy);
    326 	return (0);
    327 
    328 improper:
    329 	warnx("Improper response from %s", host);
    330 cleanup_url_get:
    331 	if (s != -1)
    332 		close(s);
    333 	if (proxy)
    334 		free(proxy);
    335 	return (-1);
    336 }
    337 
    338 /*
    339  * Abort a http retrieval
    340  */
    341 void
    342 aborthttp(notused)
    343 	int notused;
    344 {
    345 
    346 	alarmtimer(0);
    347 	puts("\nhttp fetch aborted.");
    348 	(void)fflush(stdout);
    349 	longjmp(httpabort, 1);
    350 }
    351 
    352 /*
    353  * Retrieve multiple files from the command line, transferring
    354  * files of the form "host:path", "ftp://host/path" using the
    355  * ftp protocol, and files of the form "http://host/path" using
    356  * the http protocol.
    357  * If path has a trailing "/", then return (-1);
    358  * the path will be cd-ed into and the connection remains open,
    359  * and the function will return -1 (to indicate the connection
    360  * is alive).
    361  * If an error occurs the return value will be the offset+1 in
    362  * argv[] of the file that caused a problem (i.e, argv[x]
    363  * returns x+1)
    364  * Otherwise, 0 is returned if all files retrieved successfully.
    365  */
    366 int
    367 auto_fetch(argc, argv)
    368 	int argc;
    369 	char *argv[];
    370 {
    371 	static char lasthost[MAXHOSTNAMELEN];
    372 	char *xargv[5];
    373 	char *cp, *line, *host, *dir, *file, *portnum;
    374 	char *user, *pass;
    375 	char *ftpproxy, *httpproxy;
    376 	int rval, xargc, argpos;
    377 	int dirhasglob, filehasglob;
    378 	char rempath[MAXPATHLEN];
    379 
    380 	argpos = 0;
    381 
    382 	if (setjmp(toplevel)) {
    383 		if (connected)
    384 			disconnect(0, NULL);
    385 		return (argpos + 1);
    386 	}
    387 	(void)signal(SIGINT, (sig_t)intr);
    388 	(void)signal(SIGPIPE, (sig_t)lostpeer);
    389 
    390 	ftpproxy = getenv(FTP_PROXY);
    391 	httpproxy = getenv(HTTP_PROXY);
    392 
    393 	/*
    394 	 * Loop through as long as there's files to fetch.
    395 	 */
    396 	for (rval = 0; (rval == 0) && (argpos < argc); free(line), argpos++) {
    397 		if (strchr(argv[argpos], ':') == NULL)
    398 			break;
    399 		host = dir = file = portnum = user = pass = NULL;
    400 
    401 		/*
    402 		 * We muck with the string, so we make a copy.
    403 		 */
    404 		line = strdup(argv[argpos]);
    405 		if (line == NULL)
    406 			errx(1, "Can't allocate memory for auto-fetch.");
    407 
    408 		/*
    409 		 * Try HTTP URL-style arguments first.
    410 		 */
    411 		if (strncasecmp(line, HTTP_URL, sizeof(HTTP_URL) - 1) == 0) {
    412 			if (url_get(line, httpproxy) == -1)
    413 				rval = argpos + 1;
    414 			continue;
    415 		}
    416 
    417 		/*
    418 		 * Try FTP URL-style arguments next. If ftpproxy is
    419 		 * set, use url_get() instead of standard ftp.
    420 		 * Finally, try host:file.
    421 		 */
    422 		host = line;
    423 		if (strncasecmp(line, FTP_URL, sizeof(FTP_URL) - 1) == 0) {
    424 			if (ftpproxy) {
    425 				if (url_get(line, ftpproxy) == -1)
    426 					rval = argpos + 1;
    427 				continue;
    428 			}
    429 			host += sizeof(FTP_URL) - 1;
    430 			dir = strchr(host, '/');
    431 
    432 				/* look for [user:pass@]host[:port] */
    433 			pass = strpbrk(host, ":@/");
    434 			if (pass == NULL || *pass == '/') {
    435 				pass = NULL;
    436 				goto parsed_url;
    437 			}
    438 			if (pass == host || *pass == '@') {
    439 bad_ftp_url:
    440 				warnx("Bad ftp URL: %s", argv[argpos]);
    441 				rval = argpos + 1;
    442 				continue;
    443 			}
    444 			*pass++ = '\0';
    445 			cp = strpbrk(pass, ":@/");
    446 			if (cp == NULL || *cp == '/') {
    447 				portnum = pass;
    448 				pass = NULL;
    449 				goto parsed_url;
    450 			}
    451 			if (EMPTYSTRING(cp) || *cp == ':')
    452 				goto bad_ftp_url;
    453 			*cp++ = '\0';
    454 			user = host;
    455 			if (EMPTYSTRING(user))
    456 				goto bad_ftp_url;
    457 			host = cp;
    458 			portnum = strchr(host, ':');
    459 			if (portnum != NULL)
    460 				*portnum++ = '\0';
    461 parsed_url:
    462 		} else {			/* classic style `host:file' */
    463 			dir = strchr(host, ':');
    464 		}
    465 		if (EMPTYSTRING(host)) {
    466 			rval = argpos + 1;
    467 			continue;
    468 		}
    469 
    470 		/*
    471 		 * If cp is NULL, the file wasn't specified
    472 		 * (URL looked something like ftp://host)
    473 		 */
    474 		if (dir != NULL)
    475 			*dir++ = '\0';
    476 
    477 		/*
    478 		 * Extract the file and (if present) directory name.
    479 		 */
    480 		if (! EMPTYSTRING(dir)) {
    481 			cp = strrchr(dir, '/');
    482 			if (cp != NULL) {
    483 				*cp++ = '\0';
    484 				file = cp;
    485 			} else {
    486 				file = dir;
    487 				dir = NULL;
    488 			}
    489 		}
    490 		if (debug)
    491 			printf("user %s:%s host %s port %s dir %s file %s\n",
    492 			    user, pass, host, portnum, dir, file);
    493 
    494 		/*
    495 		 * Set up the connection if we don't have one.
    496 		 */
    497 		if (strcmp(host, lasthost) != 0) {
    498 			int oautologin;
    499 
    500 			(void)strcpy(lasthost, host);
    501 			if (connected)
    502 				disconnect(0, NULL);
    503 			xargv[0] = __progname;
    504 			xargv[1] = host;
    505 			xargv[2] = NULL;
    506 			xargc = 2;
    507 			if (! EMPTYSTRING(portnum)) {
    508 				xargv[2] = portnum;
    509 				xargv[3] = NULL;
    510 				xargc = 3;
    511 			}
    512 			oautologin = autologin;
    513 			if (user != NULL)
    514 				autologin = 0;
    515 			setpeer(xargc, xargv);
    516 			autologin = oautologin;
    517 			if ((connected == 0)
    518 			 || ((connected == 1) && !login(host, user, pass)) ) {
    519 				warnx("Can't connect or login to host `%s'",
    520 				    host);
    521 				rval = argpos + 1;
    522 				continue;
    523 			}
    524 
    525 			/* Always use binary transfers. */
    526 			setbinary(0, NULL);
    527 		}
    528 			/* cd back to '/' */
    529 		xargv[0] = "cd";
    530 		xargv[1] = "/";
    531 		xargv[2] = NULL;
    532 		cd(2, xargv);
    533 		if (! dirchange) {
    534 			rval = argpos + 1;
    535 			continue;
    536 		}
    537 
    538 		dirhasglob = filehasglob = 0;
    539 		if (doglob) {
    540 			if (! EMPTYSTRING(dir) &&
    541 			    strpbrk(dir, "*?[]{}") != NULL)
    542 				dirhasglob = 1;
    543 			if (! EMPTYSTRING(file) &&
    544 			    strpbrk(file, "*?[]{}") != NULL)
    545 				filehasglob = 1;
    546 		}
    547 
    548 		/* Change directories, if necessary. */
    549 		if (! EMPTYSTRING(dir) && !dirhasglob) {
    550 			xargv[0] = "cd";
    551 			xargv[1] = dir;
    552 			xargv[2] = NULL;
    553 			cd(2, xargv);
    554 			if (! dirchange) {
    555 				rval = argpos + 1;
    556 				continue;
    557 			}
    558 		}
    559 
    560 		if (EMPTYSTRING(file)) {
    561 			rval = -1;
    562 			continue;
    563 		}
    564 
    565 		if (!verbose)
    566 			printf("Retrieving %s/%s\n", dir ? dir : "", file);
    567 
    568 		if (dirhasglob) {
    569 			snprintf(rempath, sizeof(rempath), "%s/%s", dir, file);
    570 			file = rempath;
    571 		}
    572 
    573 		/* Fetch the file(s). */
    574 		xargv[0] = "get";
    575 		xargv[1] = file;
    576 		xargv[2] = NULL;
    577 		if (dirhasglob || filehasglob) {
    578 			int ointeractive;
    579 
    580 			ointeractive = interactive;
    581 			interactive = 0;
    582 			xargv[0] = "mget";
    583 			mget(2, xargv);
    584 			interactive = ointeractive;
    585 		} else
    586 			get(2, xargv);
    587 
    588 		if ((code / 100) != COMPLETE)
    589 			rval = argpos + 1;
    590 	}
    591 	if (connected && rval != -1)
    592 		disconnect(0, NULL);
    593 	return (rval);
    594 }
    595