common.c revision 234837 
1/*-
2 * Copyright (c) 1998-2011 Dag-Erling Sm��rgrav
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer
10 *    in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 *    derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <sys/cdefs.h>
30__FBSDID("$FreeBSD: head/lib/libfetch/common.c 234837 2012-04-30 12:11:45Z des $");
31
32#include <sys/param.h>
33#include <sys/socket.h>
34#include <sys/time.h>
35#include <sys/uio.h>
36
37#include <netinet/in.h>
38
39#include <ctype.h>
40#include <errno.h>
41#include <fcntl.h>
42#include <netdb.h>
43#include <pwd.h>
44#include <stdarg.h>
45#include <stdlib.h>
46#include <stdio.h>
47#include <string.h>
48#include <unistd.h>
49
50#include "fetch.h"
51#include "common.h"
52
53
54/*** Local data **************************************************************/
55
56/*
57 * Error messages for resolver errors
58 */
59static struct fetcherr netdb_errlist[] = {
60#ifdef EAI_NODATA
61	{ EAI_NODATA,	FETCH_RESOLV,	"Host not found" },
62#endif
63	{ EAI_AGAIN,	FETCH_TEMP,	"Transient resolver failure" },
64	{ EAI_FAIL,	FETCH_RESOLV,	"Non-recoverable resolver failure" },
65	{ EAI_NONAME,	FETCH_RESOLV,	"No address record" },
66	{ -1,		FETCH_UNKNOWN,	"Unknown resolver error" }
67};
68
69/* End-of-Line */
70static const char ENDL[2] = "\r\n";
71
72
73/*** Error-reporting functions ***********************************************/
74
75/*
76 * Map error code to string
77 */
78static struct fetcherr *
79fetch_finderr(struct fetcherr *p, int e)
80{
81	while (p->num != -1 && p->num != e)
82		p++;
83	return (p);
84}
85
86/*
87 * Set error code
88 */
89void
90fetch_seterr(struct fetcherr *p, int e)
91{
92	p = fetch_finderr(p, e);
93	fetchLastErrCode = p->cat;
94	snprintf(fetchLastErrString, MAXERRSTRING, "%s", p->string);
95}
96
97/*
98 * Set error code according to errno
99 */
100void
101fetch_syserr(void)
102{
103	switch (errno) {
104	case 0:
105		fetchLastErrCode = FETCH_OK;
106		break;
107	case EPERM:
108	case EACCES:
109	case EROFS:
110	case EAUTH:
111	case ENEEDAUTH:
112		fetchLastErrCode = FETCH_AUTH;
113		break;
114	case ENOENT:
115	case EISDIR: /* XXX */
116		fetchLastErrCode = FETCH_UNAVAIL;
117		break;
118	case ENOMEM:
119		fetchLastErrCode = FETCH_MEMORY;
120		break;
121	case EBUSY:
122	case EAGAIN:
123		fetchLastErrCode = FETCH_TEMP;
124		break;
125	case EEXIST:
126		fetchLastErrCode = FETCH_EXISTS;
127		break;
128	case ENOSPC:
129		fetchLastErrCode = FETCH_FULL;
130		break;
131	case EADDRINUSE:
132	case EADDRNOTAVAIL:
133	case ENETDOWN:
134	case ENETUNREACH:
135	case ENETRESET:
136	case EHOSTUNREACH:
137		fetchLastErrCode = FETCH_NETWORK;
138		break;
139	case ECONNABORTED:
140	case ECONNRESET:
141		fetchLastErrCode = FETCH_ABORT;
142		break;
143	case ETIMEDOUT:
144		fetchLastErrCode = FETCH_TIMEOUT;
145		break;
146	case ECONNREFUSED:
147	case EHOSTDOWN:
148		fetchLastErrCode = FETCH_DOWN;
149		break;
150default:
151		fetchLastErrCode = FETCH_UNKNOWN;
152	}
153	snprintf(fetchLastErrString, MAXERRSTRING, "%s", strerror(errno));
154}
155
156
157/*
158 * Emit status message
159 */
160void
161fetch_info(const char *fmt, ...)
162{
163	va_list ap;
164
165	va_start(ap, fmt);
166	vfprintf(stderr, fmt, ap);
167	va_end(ap);
168	fputc('\n', stderr);
169}
170
171
172/*** Network-related utility functions ***************************************/
173
174/*
175 * Return the default port for a scheme
176 */
177int
178fetch_default_port(const char *scheme)
179{
180	struct servent *se;
181
182	if ((se = getservbyname(scheme, "tcp")) != NULL)
183		return (ntohs(se->s_port));
184	if (strcasecmp(scheme, SCHEME_FTP) == 0)
185		return (FTP_DEFAULT_PORT);
186	if (strcasecmp(scheme, SCHEME_HTTP) == 0)
187		return (HTTP_DEFAULT_PORT);
188	return (0);
189}
190
191/*
192 * Return the default proxy port for a scheme
193 */
194int
195fetch_default_proxy_port(const char *scheme)
196{
197	if (strcasecmp(scheme, SCHEME_FTP) == 0)
198		return (FTP_DEFAULT_PROXY_PORT);
199	if (strcasecmp(scheme, SCHEME_HTTP) == 0)
200		return (HTTP_DEFAULT_PROXY_PORT);
201	return (0);
202}
203
204
205/*
206 * Create a connection for an existing descriptor.
207 */
208conn_t *
209fetch_reopen(int sd)
210{
211	conn_t *conn;
212
213	/* allocate and fill connection structure */
214	if ((conn = calloc(1, sizeof(*conn))) == NULL)
215		return (NULL);
216	fcntl(sd, F_SETFD, FD_CLOEXEC);
217	conn->sd = sd;
218	++conn->ref;
219	return (conn);
220}
221
222
223/*
224 * Bump a connection's reference count.
225 */
226conn_t *
227fetch_ref(conn_t *conn)
228{
229
230	++conn->ref;
231	return (conn);
232}
233
234
235/*
236 * Bind a socket to a specific local address
237 */
238int
239fetch_bind(int sd, int af, const char *addr)
240{
241	struct addrinfo hints, *res, *res0;
242	int err;
243
244	memset(&hints, 0, sizeof(hints));
245	hints.ai_family = af;
246	hints.ai_socktype = SOCK_STREAM;
247	hints.ai_protocol = 0;
248	if ((err = getaddrinfo(addr, NULL, &hints, &res0)) != 0)
249		return (-1);
250	for (res = res0; res; res = res->ai_next)
251		if (bind(sd, res->ai_addr, res->ai_addrlen) == 0)
252			return (0);
253	return (-1);
254}
255
256
257/*
258 * Establish a TCP connection to the specified port on the specified host.
259 */
260conn_t *
261fetch_connect(const char *host, int port, int af, int verbose)
262{
263	conn_t *conn;
264	char pbuf[10];
265	const char *bindaddr;
266	struct addrinfo hints, *res, *res0;
267	int sd, err;
268
269	DEBUG(fprintf(stderr, "---> %s:%d\n", host, port));
270
271	if (verbose)
272		fetch_info("looking up %s", host);
273
274	/* look up host name and set up socket address structure */
275	snprintf(pbuf, sizeof(pbuf), "%d", port);
276	memset(&hints, 0, sizeof(hints));
277	hints.ai_family = af;
278	hints.ai_socktype = SOCK_STREAM;
279	hints.ai_protocol = 0;
280	if ((err = getaddrinfo(host, pbuf, &hints, &res0)) != 0) {
281		netdb_seterr(err);
282		return (NULL);
283	}
284	bindaddr = getenv("FETCH_BIND_ADDRESS");
285
286	if (verbose)
287		fetch_info("connecting to %s:%d", host, port);
288
289	/* try to connect */
290	for (sd = -1, res = res0; res; sd = -1, res = res->ai_next) {
291		if ((sd = socket(res->ai_family, res->ai_socktype,
292			 res->ai_protocol)) == -1)
293			continue;
294		if (bindaddr != NULL && *bindaddr != '\0' &&
295		    fetch_bind(sd, res->ai_family, bindaddr) != 0) {
296			fetch_info("failed to bind to '%s'", bindaddr);
297			close(sd);
298			continue;
299		}
300		if (connect(sd, res->ai_addr, res->ai_addrlen) == 0 &&
301		    fcntl(sd, F_SETFL, O_NONBLOCK) == 0)
302			break;
303		close(sd);
304	}
305	freeaddrinfo(res0);
306	if (sd == -1) {
307		fetch_syserr();
308		return (NULL);
309	}
310
311	if ((conn = fetch_reopen(sd)) == NULL) {
312		fetch_syserr();
313		close(sd);
314	}
315	return (conn);
316}
317
318
319/*
320 * Enable SSL on a connection.
321 */
322int
323fetch_ssl(conn_t *conn, int verbose)
324{
325#ifdef WITH_SSL
326	int ret, ssl_err;
327
328	/* Init the SSL library and context */
329	if (!SSL_library_init()){
330		fprintf(stderr, "SSL library init failed\n");
331		return (-1);
332	}
333
334	SSL_load_error_strings();
335
336	conn->ssl_meth = SSLv23_client_method();
337	conn->ssl_ctx = SSL_CTX_new(conn->ssl_meth);
338	SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY);
339
340	conn->ssl = SSL_new(conn->ssl_ctx);
341	if (conn->ssl == NULL){
342		fprintf(stderr, "SSL context creation failed\n");
343		return (-1);
344	}
345	SSL_set_fd(conn->ssl, conn->sd);
346	while ((ret = SSL_connect(conn->ssl)) == -1) {
347		ssl_err = SSL_get_error(conn->ssl, ret);
348		if (ssl_err != SSL_ERROR_WANT_READ &&
349		    ssl_err != SSL_ERROR_WANT_WRITE) {
350			ERR_print_errors_fp(stderr);
351			return (-1);
352		}
353	}
354
355	if (verbose) {
356		X509_NAME *name;
357		char *str;
358
359		fprintf(stderr, "SSL connection established using %s\n",
360		    SSL_get_cipher(conn->ssl));
361		conn->ssl_cert = SSL_get_peer_certificate(conn->ssl);
362		name = X509_get_subject_name(conn->ssl_cert);
363		str = X509_NAME_oneline(name, 0, 0);
364		printf("Certificate subject: %s\n", str);
365		free(str);
366		name = X509_get_issuer_name(conn->ssl_cert);
367		str = X509_NAME_oneline(name, 0, 0);
368		printf("Certificate issuer: %s\n", str);
369		free(str);
370	}
371
372	return (0);
373#else
374	(void)conn;
375	(void)verbose;
376	fprintf(stderr, "SSL support disabled\n");
377	return (-1);
378#endif
379}
380
381#define FETCH_READ_WAIT		-2
382#define FETCH_READ_ERROR	-1
383#define FETCH_READ_DONE		 0
384
385#ifdef WITH_SSL
386static ssize_t
387fetch_ssl_read(SSL *ssl, char *buf, size_t len)
388{
389	ssize_t rlen;
390	int ssl_err;
391
392	rlen = SSL_read(ssl, buf, len);
393	if (rlen < 0) {
394		ssl_err = SSL_get_error(ssl, rlen);
395		if (ssl_err == SSL_ERROR_WANT_READ ||
396		    ssl_err == SSL_ERROR_WANT_WRITE) {
397			return (FETCH_READ_WAIT);
398		} else {
399			ERR_print_errors_fp(stderr);
400			return (FETCH_READ_ERROR);
401		}
402	}
403	return (rlen);
404}
405#endif
406
407/*
408 * Cache some data that was read from a socket but cannot be immediately
409 * returned because of an interrupted system call.
410 */
411static int
412fetch_cache_data(conn_t *conn, char *src, size_t nbytes)
413{
414	char *tmp;
415
416	if (conn->cache.size < nbytes) {
417		tmp = realloc(conn->cache.buf, nbytes);
418		if (tmp == NULL) {
419			fetch_syserr();
420			return (-1);
421		}
422		conn->cache.buf = tmp;
423		conn->cache.size = nbytes;
424	}
425
426	memcpy(conn->cache.buf, src, nbytes);
427	conn->cache.len = nbytes;
428	conn->cache.pos = 0;
429
430	return (0);
431}
432
433
434static ssize_t
435fetch_socket_read(int sd, char *buf, size_t len)
436{
437	ssize_t rlen;
438
439	rlen = read(sd, buf, len);
440	if (rlen < 0) {
441		if (errno == EAGAIN || (errno == EINTR && fetchRestartCalls))
442			return (FETCH_READ_WAIT);
443		else
444			return (FETCH_READ_ERROR);
445	}
446	return (rlen);
447}
448
449/*
450 * Read a character from a connection w/ timeout
451 */
452ssize_t
453fetch_read(conn_t *conn, char *buf, size_t len)
454{
455	struct timeval now, timeout, delta;
456	fd_set readfds;
457	ssize_t rlen, total;
458	char *start;
459
460	if (fetchTimeout > 0) {
461		gettimeofday(&timeout, NULL);
462		timeout.tv_sec += fetchTimeout;
463	}
464
465	total = 0;
466	start = buf;
467
468	if (conn->cache.len > 0) {
469		/*
470		 * The last invocation of fetch_read was interrupted by a
471		 * signal after some data had been read from the socket. Copy
472		 * the cached data into the supplied buffer before trying to
473		 * read from the socket again.
474		 */
475		total = (conn->cache.len < len) ? conn->cache.len : len;
476		memcpy(buf, conn->cache.buf, total);
477
478		conn->cache.len -= total;
479		conn->cache.pos += total;
480		len -= total;
481		buf += total;
482	}
483
484	while (len > 0) {
485		/*
486		 * The socket is non-blocking.  Instead of the canonical
487		 * select() -> read(), we do the following:
488		 *
489		 * 1) call read() or SSL_read().
490		 * 2) if an error occurred, return -1.
491		 * 3) if we received data but we still expect more,
492		 *    update our counters and loop.
493		 * 4) if read() or SSL_read() signaled EOF, return.
494		 * 5) if we did not receive any data but we're not at EOF,
495		 *    call select().
496		 *
497		 * In the SSL case, this is necessary because if we
498		 * receive a close notification, we have to call
499		 * SSL_read() one additional time after we've read
500		 * everything we received.
501		 *
502		 * In the non-SSL case, it may improve performance (very
503		 * slightly) when reading small amounts of data.
504		 */
505#ifdef WITH_SSL
506		if (conn->ssl != NULL)
507			rlen = fetch_ssl_read(conn->ssl, buf, len);
508		else
509#endif
510			rlen = fetch_socket_read(conn->sd, buf, len);
511		if (rlen == 0) {
512			break;
513		} else if (rlen > 0) {
514			len -= rlen;
515			buf += rlen;
516			total += rlen;
517			continue;
518		} else if (rlen == FETCH_READ_ERROR) {
519			if (errno == EINTR)
520				fetch_cache_data(conn, start, total);
521			return (-1);
522		}
523		// assert(rlen == FETCH_READ_WAIT);
524		FD_ZERO(&readfds);
525		while (!FD_ISSET(conn->sd, &readfds)) {
526			FD_SET(conn->sd, &readfds);
527			if (fetchTimeout > 0) {
528				gettimeofday(&now, NULL);
529				if (!timercmp(&timeout, &now, >)) {
530					errno = ETIMEDOUT;
531					fetch_syserr();
532					return (-1);
533				}
534				timersub(&timeout, &now, &delta);
535			}
536			errno = 0;
537			if (select(conn->sd + 1, &readfds, NULL, NULL,
538				fetchTimeout > 0 ? &delta : NULL) < 0) {
539				if (errno == EINTR) {
540					if (fetchRestartCalls)
541						continue;
542					/* Save anything that was read. */
543					fetch_cache_data(conn, start, total);
544				}
545				fetch_syserr();
546				return (-1);
547			}
548		}
549	}
550	return (total);
551}
552
553
554/*
555 * Read a line of text from a connection w/ timeout
556 */
557#define MIN_BUF_SIZE 1024
558
559int
560fetch_getln(conn_t *conn)
561{
562	char *tmp;
563	size_t tmpsize;
564	ssize_t len;
565	char c;
566
567	if (conn->buf == NULL) {
568		if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
569			errno = ENOMEM;
570			return (-1);
571		}
572		conn->bufsize = MIN_BUF_SIZE;
573	}
574
575	conn->buf[0] = '\0';
576	conn->buflen = 0;
577
578	do {
579		len = fetch_read(conn, &c, 1);
580		if (len == -1)
581			return (-1);
582		if (len == 0)
583			break;
584		conn->buf[conn->buflen++] = c;
585		if (conn->buflen == conn->bufsize) {
586			tmp = conn->buf;
587			tmpsize = conn->bufsize * 2 + 1;
588			if ((tmp = realloc(tmp, tmpsize)) == NULL) {
589				errno = ENOMEM;
590				return (-1);
591			}
592			conn->buf = tmp;
593			conn->bufsize = tmpsize;
594		}
595	} while (c != '\n');
596
597	conn->buf[conn->buflen] = '\0';
598	DEBUG(fprintf(stderr, "<<< %s", conn->buf));
599	return (0);
600}
601
602
603/*
604 * Write to a connection w/ timeout
605 */
606ssize_t
607fetch_write(conn_t *conn, const char *buf, size_t len)
608{
609	struct iovec iov;
610
611	iov.iov_base = __DECONST(char *, buf);
612	iov.iov_len = len;
613	return fetch_writev(conn, &iov, 1);
614}
615
616/*
617 * Write a vector to a connection w/ timeout
618 * Note: can modify the iovec.
619 */
620ssize_t
621fetch_writev(conn_t *conn, struct iovec *iov, int iovcnt)
622{
623	struct timeval now, timeout, delta;
624	fd_set writefds;
625	ssize_t wlen, total;
626	int r;
627
628	if (fetchTimeout) {
629		FD_ZERO(&writefds);
630		gettimeofday(&timeout, NULL);
631		timeout.tv_sec += fetchTimeout;
632	}
633
634	total = 0;
635	while (iovcnt > 0) {
636		while (fetchTimeout && !FD_ISSET(conn->sd, &writefds)) {
637			FD_SET(conn->sd, &writefds);
638			gettimeofday(&now, NULL);
639			delta.tv_sec = timeout.tv_sec - now.tv_sec;
640			delta.tv_usec = timeout.tv_usec - now.tv_usec;
641			if (delta.tv_usec < 0) {
642				delta.tv_usec += 1000000;
643				delta.tv_sec--;
644			}
645			if (delta.tv_sec < 0) {
646				errno = ETIMEDOUT;
647				fetch_syserr();
648				return (-1);
649			}
650			errno = 0;
651			r = select(conn->sd + 1, NULL, &writefds, NULL, &delta);
652			if (r == -1) {
653				if (errno == EINTR && fetchRestartCalls)
654					continue;
655				return (-1);
656			}
657		}
658		errno = 0;
659#ifdef WITH_SSL
660		if (conn->ssl != NULL)
661			wlen = SSL_write(conn->ssl,
662			    iov->iov_base, iov->iov_len);
663		else
664#endif
665			wlen = writev(conn->sd, iov, iovcnt);
666		if (wlen == 0) {
667			/* we consider a short write a failure */
668			/* XXX perhaps we shouldn't in the SSL case */
669			errno = EPIPE;
670			fetch_syserr();
671			return (-1);
672		}
673		if (wlen < 0) {
674			if (errno == EINTR && fetchRestartCalls)
675				continue;
676			return (-1);
677		}
678		total += wlen;
679		while (iovcnt > 0 && wlen >= (ssize_t)iov->iov_len) {
680			wlen -= iov->iov_len;
681			iov++;
682			iovcnt--;
683		}
684		if (iovcnt > 0) {
685			iov->iov_len -= wlen;
686			iov->iov_base = __DECONST(char *, iov->iov_base) + wlen;
687		}
688	}
689	return (total);
690}
691
692
693/*
694 * Write a line of text to a connection w/ timeout
695 */
696int
697fetch_putln(conn_t *conn, const char *str, size_t len)
698{
699	struct iovec iov[2];
700	int ret;
701
702	DEBUG(fprintf(stderr, ">>> %s\n", str));
703	iov[0].iov_base = __DECONST(char *, str);
704	iov[0].iov_len = len;
705	iov[1].iov_base = __DECONST(char *, ENDL);
706	iov[1].iov_len = sizeof(ENDL);
707	if (len == 0)
708		ret = fetch_writev(conn, &iov[1], 1);
709	else
710		ret = fetch_writev(conn, iov, 2);
711	if (ret == -1)
712		return (-1);
713	return (0);
714}
715
716
717/*
718 * Close connection
719 */
720int
721fetch_close(conn_t *conn)
722{
723	int ret;
724
725	if (--conn->ref > 0)
726		return (0);
727	ret = close(conn->sd);
728	free(conn->cache.buf);
729	free(conn->buf);
730	free(conn);
731	return (ret);
732}
733
734
735/*** Directory-related utility functions *************************************/
736
737int
738fetch_add_entry(struct url_ent **p, int *size, int *len,
739    const char *name, struct url_stat *us)
740{
741	struct url_ent *tmp;
742
743	if (*p == NULL) {
744		*size = 0;
745		*len = 0;
746	}
747
748	if (*len >= *size - 1) {
749		tmp = realloc(*p, (*size * 2 + 1) * sizeof(**p));
750		if (tmp == NULL) {
751			errno = ENOMEM;
752			fetch_syserr();
753			return (-1);
754		}
755		*size = (*size * 2 + 1);
756		*p = tmp;
757	}
758
759	tmp = *p + *len;
760	snprintf(tmp->name, PATH_MAX, "%s", name);
761	memcpy(&tmp->stat, us, sizeof(*us));
762
763	(*len)++;
764	(++tmp)->name[0] = 0;
765
766	return (0);
767}
768
769
770/*** Authentication-related utility functions ********************************/
771
772static const char *
773fetch_read_word(FILE *f)
774{
775	static char word[1024];
776
777	if (fscanf(f, " %1023s ", word) != 1)
778		return (NULL);
779	return (word);
780}
781
782/*
783 * Get authentication data for a URL from .netrc
784 */
785int
786fetch_netrc_auth(struct url *url)
787{
788	char fn[PATH_MAX];
789	const char *word;
790	char *p;
791	FILE *f;
792
793	if ((p = getenv("NETRC")) != NULL) {
794		if (snprintf(fn, sizeof(fn), "%s", p) >= (int)sizeof(fn)) {
795			fetch_info("$NETRC specifies a file name "
796			    "longer than PATH_MAX");
797			return (-1);
798		}
799	} else {
800		if ((p = getenv("HOME")) != NULL) {
801			struct passwd *pwd;
802
803			if ((pwd = getpwuid(getuid())) == NULL ||
804			    (p = pwd->pw_dir) == NULL)
805				return (-1);
806		}
807		if (snprintf(fn, sizeof(fn), "%s/.netrc", p) >= (int)sizeof(fn))
808			return (-1);
809	}
810
811	if ((f = fopen(fn, "r")) == NULL)
812		return (-1);
813	while ((word = fetch_read_word(f)) != NULL) {
814		if (strcmp(word, "default") == 0) {
815			DEBUG(fetch_info("Using default .netrc settings"));
816			break;
817		}
818		if (strcmp(word, "machine") == 0 &&
819		    (word = fetch_read_word(f)) != NULL &&
820		    strcasecmp(word, url->host) == 0) {
821			DEBUG(fetch_info("Using .netrc settings for %s", word));
822			break;
823		}
824	}
825	if (word == NULL)
826		goto ferr;
827	while ((word = fetch_read_word(f)) != NULL) {
828		if (strcmp(word, "login") == 0) {
829			if ((word = fetch_read_word(f)) == NULL)
830				goto ferr;
831			if (snprintf(url->user, sizeof(url->user),
832				"%s", word) > (int)sizeof(url->user)) {
833				fetch_info("login name in .netrc is too long");
834				url->user[0] = '\0';
835			}
836		} else if (strcmp(word, "password") == 0) {
837			if ((word = fetch_read_word(f)) == NULL)
838				goto ferr;
839			if (snprintf(url->pwd, sizeof(url->pwd),
840				"%s", word) > (int)sizeof(url->pwd)) {
841				fetch_info("password in .netrc is too long");
842				url->pwd[0] = '\0';
843			}
844		} else if (strcmp(word, "account") == 0) {
845			if ((word = fetch_read_word(f)) == NULL)
846				goto ferr;
847			/* XXX not supported! */
848		} else {
849			break;
850		}
851	}
852	fclose(f);
853	return (0);
854 ferr:
855	fclose(f);
856	return (-1);
857}
858
859/*
860 * The no_proxy environment variable specifies a set of domains for
861 * which the proxy should not be consulted; the contents is a comma-,
862 * or space-separated list of domain names.  A single asterisk will
863 * override all proxy variables and no transactions will be proxied
864 * (for compatability with lynx and curl, see the discussion at
865 * <http://curl.haxx.se/mail/archive_pre_oct_99/0009.html>).
866 */
867int
868fetch_no_proxy_match(const char *host)
869{
870	const char *no_proxy, *p, *q;
871	size_t h_len, d_len;
872
873	if ((no_proxy = getenv("NO_PROXY")) == NULL &&
874	    (no_proxy = getenv("no_proxy")) == NULL)
875		return (0);
876
877	/* asterisk matches any hostname */
878	if (strcmp(no_proxy, "*") == 0)
879		return (1);
880
881	h_len = strlen(host);
882	p = no_proxy;
883	do {
884		/* position p at the beginning of a domain suffix */
885		while (*p == ',' || isspace((unsigned char)*p))
886			p++;
887
888		/* position q at the first separator character */
889		for (q = p; *q; ++q)
890			if (*q == ',' || isspace((unsigned char)*q))
891				break;
892
893		d_len = q - p;
894		if (d_len > 0 && h_len >= d_len &&
895		    strncasecmp(host + h_len - d_len,
896			p, d_len) == 0) {
897			/* domain name matches */
898			return (1);
899		}
900
901		p = q + 1;
902	} while (*q);
903
904	return (0);
905}
906