common.c revision 210568 
1/*-
2 * Copyright (c) 1998-2004 Dag-Erling Co�dan 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 210568 2010-07-28 16:11:22Z 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	conn->sd = sd;
217	++conn->ref;
218	return (conn);
219}
220
221
222/*
223 * Bump a connection's reference count.
224 */
225conn_t *
226fetch_ref(conn_t *conn)
227{
228
229	++conn->ref;
230	return (conn);
231}
232
233
234/*
235 * Bind a socket to a specific local address
236 */
237int
238fetch_bind(int sd, int af, const char *addr)
239{
240	struct addrinfo hints, *res, *res0;
241	int err;
242
243	memset(&hints, 0, sizeof(hints));
244	hints.ai_family = af;
245	hints.ai_socktype = SOCK_STREAM;
246	hints.ai_protocol = 0;
247	if ((err = getaddrinfo(addr, NULL, &hints, &res0)) != 0)
248		return (-1);
249	for (res = res0; res; res = res->ai_next)
250		if (bind(sd, res->ai_addr, res->ai_addrlen) == 0)
251			return (0);
252	return (-1);
253}
254
255
256/*
257 * Establish a TCP connection to the specified port on the specified host.
258 */
259conn_t *
260fetch_connect(const char *host, int port, int af, int verbose)
261{
262	conn_t *conn;
263	char pbuf[10];
264	const char *bindaddr;
265	struct addrinfo hints, *res, *res0;
266	int sd, err;
267
268	DEBUG(fprintf(stderr, "---> %s:%d\n", host, port));
269
270	if (verbose)
271		fetch_info("looking up %s", host);
272
273	/* look up host name and set up socket address structure */
274	snprintf(pbuf, sizeof(pbuf), "%d", port);
275	memset(&hints, 0, sizeof(hints));
276	hints.ai_family = af;
277	hints.ai_socktype = SOCK_STREAM;
278	hints.ai_protocol = 0;
279	if ((err = getaddrinfo(host, pbuf, &hints, &res0)) != 0) {
280		netdb_seterr(err);
281		return (NULL);
282	}
283	bindaddr = getenv("FETCH_BIND_ADDRESS");
284
285	if (verbose)
286		fetch_info("connecting to %s:%d", host, port);
287
288	/* try to connect */
289	for (sd = -1, res = res0; res; sd = -1, res = res->ai_next) {
290		if ((sd = socket(res->ai_family, res->ai_socktype,
291			 res->ai_protocol)) == -1)
292			continue;
293		if (bindaddr != NULL && *bindaddr != '\0' &&
294		    fetch_bind(sd, res->ai_family, bindaddr) != 0) {
295			fetch_info("failed to bind to '%s'", bindaddr);
296			close(sd);
297			continue;
298		}
299		if (connect(sd, res->ai_addr, res->ai_addrlen) == 0 &&
300		    fcntl(sd, F_SETFL, O_NONBLOCK) == 0)
301			break;
302		close(sd);
303	}
304	freeaddrinfo(res0);
305	if (sd == -1) {
306		fetch_syserr();
307		return (NULL);
308	}
309
310	if ((conn = fetch_reopen(sd)) == NULL) {
311		fetch_syserr();
312		close(sd);
313	}
314	return (conn);
315}
316
317
318/*
319 * Enable SSL on a connection.
320 */
321int
322fetch_ssl(conn_t *conn, int verbose)
323{
324	int ret, ssl_err;
325
326#ifdef WITH_SSL
327	/* Init the SSL library and context */
328	if (!SSL_library_init()){
329		fprintf(stderr, "SSL library init failed\n");
330		return (-1);
331	}
332
333	SSL_load_error_strings();
334
335	conn->ssl_meth = SSLv23_client_method();
336	conn->ssl_ctx = SSL_CTX_new(conn->ssl_meth);
337	SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY);
338
339	conn->ssl = SSL_new(conn->ssl_ctx);
340	if (conn->ssl == NULL){
341		fprintf(stderr, "SSL context creation failed\n");
342		return (-1);
343	}
344	SSL_set_fd(conn->ssl, conn->sd);
345	while ((ret = SSL_connect(conn->ssl)) == -1) {
346		ssl_err = SSL_get_error(conn->ssl, ret);
347		if (ssl_err != SSL_ERROR_WANT_READ &&
348		    ssl_err != SSL_ERROR_WANT_WRITE) {
349			ERR_print_errors_fp(stderr);
350			return (-1);
351		}
352	}
353
354	if (verbose) {
355		X509_NAME *name;
356		char *str;
357
358		fprintf(stderr, "SSL connection established using %s\n",
359		    SSL_get_cipher(conn->ssl));
360		conn->ssl_cert = SSL_get_peer_certificate(conn->ssl);
361		name = X509_get_subject_name(conn->ssl_cert);
362		str = X509_NAME_oneline(name, 0, 0);
363		printf("Certificate subject: %s\n", str);
364		free(str);
365		name = X509_get_issuer_name(conn->ssl_cert);
366		str = X509_NAME_oneline(name, 0, 0);
367		printf("Certificate issuer: %s\n", str);
368		free(str);
369	}
370
371	return (0);
372#else
373	(void)conn;
374	(void)verbose;
375	fprintf(stderr, "SSL support disabled\n");
376	return (-1);
377#endif
378}
379
380#define FETCH_READ_WAIT		-2
381#define FETCH_READ_ERROR	-1
382#define FETCH_READ_DONE		 0
383
384#ifdef WITH_SSL
385static ssize_t
386fetch_ssl_read(SSL *ssl, char *buf, size_t len)
387{
388	ssize_t rlen;
389	int ssl_err;
390
391	rlen = SSL_read(ssl, buf, len);
392	if (rlen < 0) {
393		ssl_err = SSL_get_error(ssl, rlen);
394		if (ssl_err == SSL_ERROR_WANT_READ ||
395		    ssl_err == SSL_ERROR_WANT_WRITE) {
396			return (FETCH_READ_WAIT);
397		} else {
398			ERR_print_errors_fp(stderr);
399			return (FETCH_READ_ERROR);
400		}
401	}
402	return (rlen);
403}
404#endif
405
406static ssize_t
407fetch_socket_read(int sd, char *buf, size_t len)
408{
409	ssize_t rlen;
410
411	rlen = read(sd, buf, len);
412	if (rlen < 0) {
413		if (errno == EAGAIN || (errno == EINTR && fetchRestartCalls))
414			return (FETCH_READ_WAIT);
415		else
416			return (FETCH_READ_ERROR);
417	}
418	return (rlen);
419}
420
421/*
422 * Read a character from a connection w/ timeout
423 */
424ssize_t
425fetch_read(conn_t *conn, char *buf, size_t len)
426{
427	struct timeval now, timeout, delta;
428	fd_set readfds;
429	ssize_t rlen, total;
430	int r;
431
432	if (fetchTimeout) {
433		FD_ZERO(&readfds);
434		gettimeofday(&timeout, NULL);
435		timeout.tv_sec += fetchTimeout;
436	}
437
438	total = 0;
439	while (len > 0) {
440		/*
441		 * The socket is non-blocking.  Instead of the canonical
442		 * select() -> read(), we do the following:
443		 *
444		 * 1) call read() or SSL_read().
445		 * 2) if an error occurred, return -1.
446		 * 3) if we received data but we still expect more,
447		 *    update our counters and loop.
448		 * 4) if read() or SSL_read() signaled EOF, return.
449		 * 5) if we did not receive any data but we're not at EOF,
450		 *    call select().
451		 *
452		 * In the SSL case, this is necessary because if we
453		 * receive a close notification, we have to call
454		 * SSL_read() one additional time after we've read
455		 * everything we received.
456		 *
457		 * In the non-SSL case, it may improve performance (very
458		 * slightly) when reading small amounts of data.
459		 */
460#ifdef WITH_SSL
461		if (conn->ssl != NULL)
462			rlen = fetch_ssl_read(conn->ssl, buf, len);
463		else
464#endif
465			rlen = fetch_socket_read(conn->sd, buf, len);
466		if (rlen == 0) {
467			break;
468		} else if (rlen > 0) {
469			len -= rlen;
470			buf += rlen;
471			total += rlen;
472			continue;
473		} else if (rlen == FETCH_READ_ERROR) {
474			return (-1);
475		}
476		// assert(rlen == FETCH_READ_WAIT);
477		while (fetchTimeout && !FD_ISSET(conn->sd, &readfds)) {
478			FD_SET(conn->sd, &readfds);
479			gettimeofday(&now, NULL);
480			delta.tv_sec = timeout.tv_sec - now.tv_sec;
481			delta.tv_usec = timeout.tv_usec - now.tv_usec;
482			if (delta.tv_usec < 0) {
483				delta.tv_usec += 1000000;
484				delta.tv_sec--;
485			}
486			if (delta.tv_sec < 0) {
487				errno = ETIMEDOUT;
488				fetch_syserr();
489				return (-1);
490			}
491			errno = 0;
492			r = select(conn->sd + 1, &readfds, NULL, NULL, &delta);
493			if (r == -1) {
494				if (errno == EINTR && fetchRestartCalls)
495					continue;
496				fetch_syserr();
497				return (-1);
498			}
499		}
500	}
501	return (total);
502}
503
504
505/*
506 * Read a line of text from a connection w/ timeout
507 */
508#define MIN_BUF_SIZE 1024
509
510int
511fetch_getln(conn_t *conn)
512{
513	char *tmp;
514	size_t tmpsize;
515	ssize_t len;
516	char c;
517
518	if (conn->buf == NULL) {
519		if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
520			errno = ENOMEM;
521			return (-1);
522		}
523		conn->bufsize = MIN_BUF_SIZE;
524	}
525
526	conn->buf[0] = '\0';
527	conn->buflen = 0;
528
529	do {
530		len = fetch_read(conn, &c, 1);
531		if (len == -1)
532			return (-1);
533		if (len == 0)
534			break;
535		conn->buf[conn->buflen++] = c;
536		if (conn->buflen == conn->bufsize) {
537			tmp = conn->buf;
538			tmpsize = conn->bufsize * 2 + 1;
539			if ((tmp = realloc(tmp, tmpsize)) == NULL) {
540				errno = ENOMEM;
541				return (-1);
542			}
543			conn->buf = tmp;
544			conn->bufsize = tmpsize;
545		}
546	} while (c != '\n');
547
548	conn->buf[conn->buflen] = '\0';
549	DEBUG(fprintf(stderr, "<<< %s", conn->buf));
550	return (0);
551}
552
553
554/*
555 * Write to a connection w/ timeout
556 */
557ssize_t
558fetch_write(conn_t *conn, const char *buf, size_t len)
559{
560	struct iovec iov;
561
562	iov.iov_base = __DECONST(char *, buf);
563	iov.iov_len = len;
564	return fetch_writev(conn, &iov, 1);
565}
566
567/*
568 * Write a vector to a connection w/ timeout
569 * Note: can modify the iovec.
570 */
571ssize_t
572fetch_writev(conn_t *conn, struct iovec *iov, int iovcnt)
573{
574	struct timeval now, timeout, delta;
575	fd_set writefds;
576	ssize_t wlen, total;
577	int r;
578
579	if (fetchTimeout) {
580		FD_ZERO(&writefds);
581		gettimeofday(&timeout, NULL);
582		timeout.tv_sec += fetchTimeout;
583	}
584
585	total = 0;
586	while (iovcnt > 0) {
587		while (fetchTimeout && !FD_ISSET(conn->sd, &writefds)) {
588			FD_SET(conn->sd, &writefds);
589			gettimeofday(&now, NULL);
590			delta.tv_sec = timeout.tv_sec - now.tv_sec;
591			delta.tv_usec = timeout.tv_usec - now.tv_usec;
592			if (delta.tv_usec < 0) {
593				delta.tv_usec += 1000000;
594				delta.tv_sec--;
595			}
596			if (delta.tv_sec < 0) {
597				errno = ETIMEDOUT;
598				fetch_syserr();
599				return (-1);
600			}
601			errno = 0;
602			r = select(conn->sd + 1, NULL, &writefds, NULL, &delta);
603			if (r == -1) {
604				if (errno == EINTR && fetchRestartCalls)
605					continue;
606				return (-1);
607			}
608		}
609		errno = 0;
610#ifdef WITH_SSL
611		if (conn->ssl != NULL)
612			wlen = SSL_write(conn->ssl,
613			    iov->iov_base, iov->iov_len);
614		else
615#endif
616			wlen = writev(conn->sd, iov, iovcnt);
617		if (wlen == 0) {
618			/* we consider a short write a failure */
619			/* XXX perhaps we shouldn't in the SSL case */
620			errno = EPIPE;
621			fetch_syserr();
622			return (-1);
623		}
624		if (wlen < 0) {
625			if (errno == EINTR && fetchRestartCalls)
626				continue;
627			return (-1);
628		}
629		total += wlen;
630		while (iovcnt > 0 && wlen >= (ssize_t)iov->iov_len) {
631			wlen -= iov->iov_len;
632			iov++;
633			iovcnt--;
634		}
635		if (iovcnt > 0) {
636			iov->iov_len -= wlen;
637			iov->iov_base = __DECONST(char *, iov->iov_base) + wlen;
638		}
639	}
640	return (total);
641}
642
643
644/*
645 * Write a line of text to a connection w/ timeout
646 */
647int
648fetch_putln(conn_t *conn, const char *str, size_t len)
649{
650	struct iovec iov[2];
651	int ret;
652
653	DEBUG(fprintf(stderr, ">>> %s\n", str));
654	iov[0].iov_base = __DECONST(char *, str);
655	iov[0].iov_len = len;
656	iov[1].iov_base = __DECONST(char *, ENDL);
657	iov[1].iov_len = sizeof(ENDL);
658	if (len == 0)
659		ret = fetch_writev(conn, &iov[1], 1);
660	else
661		ret = fetch_writev(conn, iov, 2);
662	if (ret == -1)
663		return (-1);
664	return (0);
665}
666
667
668/*
669 * Close connection
670 */
671int
672fetch_close(conn_t *conn)
673{
674	int ret;
675
676	if (--conn->ref > 0)
677		return (0);
678	ret = close(conn->sd);
679	free(conn->buf);
680	free(conn);
681	return (ret);
682}
683
684
685/*** Directory-related utility functions *************************************/
686
687int
688fetch_add_entry(struct url_ent **p, int *size, int *len,
689    const char *name, struct url_stat *us)
690{
691	struct url_ent *tmp;
692
693	if (*p == NULL) {
694		*size = 0;
695		*len = 0;
696	}
697
698	if (*len >= *size - 1) {
699		tmp = realloc(*p, (*size * 2 + 1) * sizeof(**p));
700		if (tmp == NULL) {
701			errno = ENOMEM;
702			fetch_syserr();
703			return (-1);
704		}
705		*size = (*size * 2 + 1);
706		*p = tmp;
707	}
708
709	tmp = *p + *len;
710	snprintf(tmp->name, PATH_MAX, "%s", name);
711	memcpy(&tmp->stat, us, sizeof(*us));
712
713	(*len)++;
714	(++tmp)->name[0] = 0;
715
716	return (0);
717}
718
719
720/*** Authentication-related utility functions ********************************/
721
722static const char *
723fetch_read_word(FILE *f)
724{
725	static char word[1024];
726
727	if (fscanf(f, " %1023s ", word) != 1)
728		return (NULL);
729	return (word);
730}
731
732/*
733 * Get authentication data for a URL from .netrc
734 */
735int
736fetch_netrc_auth(struct url *url)
737{
738	char fn[PATH_MAX];
739	const char *word;
740	char *p;
741	FILE *f;
742
743	if ((p = getenv("NETRC")) != NULL) {
744		if (snprintf(fn, sizeof(fn), "%s", p) >= (int)sizeof(fn)) {
745			fetch_info("$NETRC specifies a file name "
746			    "longer than PATH_MAX");
747			return (-1);
748		}
749	} else {
750		if ((p = getenv("HOME")) != NULL) {
751			struct passwd *pwd;
752
753			if ((pwd = getpwuid(getuid())) == NULL ||
754			    (p = pwd->pw_dir) == NULL)
755				return (-1);
756		}
757		if (snprintf(fn, sizeof(fn), "%s/.netrc", p) >= (int)sizeof(fn))
758			return (-1);
759	}
760
761	if ((f = fopen(fn, "r")) == NULL)
762		return (-1);
763	while ((word = fetch_read_word(f)) != NULL) {
764		if (strcmp(word, "default") == 0) {
765			DEBUG(fetch_info("Using default .netrc settings"));
766			break;
767		}
768		if (strcmp(word, "machine") == 0 &&
769		    (word = fetch_read_word(f)) != NULL &&
770		    strcasecmp(word, url->host) == 0) {
771			DEBUG(fetch_info("Using .netrc settings for %s", word));
772			break;
773		}
774	}
775	if (word == NULL)
776		goto ferr;
777	while ((word = fetch_read_word(f)) != NULL) {
778		if (strcmp(word, "login") == 0) {
779			if ((word = fetch_read_word(f)) == NULL)
780				goto ferr;
781			if (snprintf(url->user, sizeof(url->user),
782				"%s", word) > (int)sizeof(url->user)) {
783				fetch_info("login name in .netrc is too long");
784				url->user[0] = '\0';
785			}
786		} else if (strcmp(word, "password") == 0) {
787			if ((word = fetch_read_word(f)) == NULL)
788				goto ferr;
789			if (snprintf(url->pwd, sizeof(url->pwd),
790				"%s", word) > (int)sizeof(url->pwd)) {
791				fetch_info("password in .netrc is too long");
792				url->pwd[0] = '\0';
793			}
794		} else if (strcmp(word, "account") == 0) {
795			if ((word = fetch_read_word(f)) == NULL)
796				goto ferr;
797			/* XXX not supported! */
798		} else {
799			break;
800		}
801	}
802	fclose(f);
803	return (0);
804 ferr:
805	fclose(f);
806	return (-1);
807}
808
809/*
810 * The no_proxy environment variable specifies a set of domains for
811 * which the proxy should not be consulted; the contents is a comma-,
812 * or space-separated list of domain names.  A single asterisk will
813 * override all proxy variables and no transactions will be proxied
814 * (for compatability with lynx and curl, see the discussion at
815 * <http://curl.haxx.se/mail/archive_pre_oct_99/0009.html>).
816 */
817int
818fetch_no_proxy_match(const char *host)
819{
820	const char *no_proxy, *p, *q;
821	size_t h_len, d_len;
822
823	if ((no_proxy = getenv("NO_PROXY")) == NULL &&
824	    (no_proxy = getenv("no_proxy")) == NULL)
825		return (0);
826
827	/* asterisk matches any hostname */
828	if (strcmp(no_proxy, "*") == 0)
829		return (1);
830
831	h_len = strlen(host);
832	p = no_proxy;
833	do {
834		/* position p at the beginning of a domain suffix */
835		while (*p == ',' || isspace((unsigned char)*p))
836			p++;
837
838		/* position q at the first separator character */
839		for (q = p; *q; ++q)
840			if (*q == ',' || isspace((unsigned char)*q))
841				break;
842
843		d_len = q - p;
844		if (d_len > 0 && h_len >= d_len &&
845		    strncasecmp(host + h_len - d_len,
846			p, d_len) == 0) {
847			/* domain name matches */
848			return (1);
849		}
850
851		p = q + 1;
852	} while (*q);
853
854	return (0);
855}
856