Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/asr/gethostnamadr.c	Lines:	0	84	0.0 %
Date:	2017-11-07	Branches:	0	40	0.0 %


/*	$OpenBSD: gethostnamadr.c,v 1.13 2015/09/14 07:38:37 guenther Exp $	*/
/*
 * Copyright (c) 2012,2013 Eric Faurot <eric@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>	/* ALIGN */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#include <asr.h>
#include <errno.h>
#include <resolv.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

static int _gethostbyname(const char *, int, struct hostent *, char *, size_t,
    int *);
static int _fillhostent(const struct hostent *, struct hostent *, char *,
    size_t);

static struct hostent	 _hostent;
static char		 _entbuf[4096];

static char *_empty[] = { NULL, };

static int
_fillhostent(const struct hostent *h, struct hostent *r, char *buf, size_t len)
{
	char	**ptr, *end, *pos;
	size_t	n, i;
	int	naliases, naddrs;

	bzero(buf, len);
	bzero(r, sizeof(*r));
	r->h_aliases = _empty;
	r->h_addr_list = _empty;

	end = buf + len;
	ptr = (char **)ALIGN(buf);

	if ((char *)ptr >= end)
		return (ERANGE);

	for (naliases = 0; h->h_aliases[naliases]; naliases++)
		;
	for (naddrs = 0; h->h_addr_list[naddrs]; naddrs++)
		;

	pos = (char *)(ptr + (naliases + 1) + (naddrs + 1));
	if (pos >= end)
		return (ERANGE);

	r->h_name = NULL;
	r->h_addrtype = h->h_addrtype;
	r->h_length = h->h_length;
	r->h_aliases = ptr;
	r->h_addr_list = ptr + naliases + 1;

	n = strlcpy(pos, h->h_name, end - pos);
	if (n >= end - pos)
		return (ERANGE);
	r->h_name = pos;
	pos += n + 1;

	for (i = 0; i < naliases; i++) {
		n = strlcpy(pos, h->h_aliases[i], end - pos);
		if (n >= end - pos)
			return (ERANGE);
		r->h_aliases[i] = pos;
		pos += n + 1;
	}

	pos = (char *)ALIGN(pos);
	if (pos >= end)
		return (ERANGE);

	for (i = 0; i < naddrs; i++) {
		if (r->h_length > end - pos)
			return (ERANGE);
		memmove(pos, h->h_addr_list[i], r->h_length);
		r->h_addr_list[i] = pos;
		pos += r->h_length;
	}

	return (0);
}

static int
_gethostbyname(const char *name, int af, struct hostent *ret, char *buf,
    size_t buflen, int *h_errnop)
{
	struct asr_query *as;
	struct asr_result ar;
	int r;

	if (af == -1)
		as = gethostbyname_async(name, NULL);
	else
		as = gethostbyname2_async(name, af, NULL);

	if (as == NULL)
		return (errno);

	asr_run_sync(as, &ar);

	errno = ar.ar_errno;
	*h_errnop = ar.ar_h_errno;
	if (ar.ar_hostent == NULL)
		return (0);

	r = _fillhostent(ar.ar_hostent, ret, buf, buflen);
	free(ar.ar_hostent);

	return (r);
}

struct hostent *
gethostbyname(const char *name)
{
	struct hostent	*h;

	res_init();

	if (_res.options & RES_USE_INET6 &&
	    (h = gethostbyname2(name, AF_INET6)))
		return (h);

	return gethostbyname2(name, AF_INET);
}
DEF_WEAK(gethostbyname);

struct hostent *
gethostbyname2(const char *name, int af)
{
	int	r;

	res_init();

	r = _gethostbyname(name, af, &_hostent, _entbuf, sizeof(_entbuf),
	    &h_errno);
	if (r) {
		h_errno = NETDB_INTERNAL;
		errno = r;
	}

	if (h_errno)
		return (NULL);

	return (&_hostent);
}
DEF_WEAK(gethostbyname2);

struct hostent *
gethostbyaddr(const void *addr, socklen_t len, int af)
{
	struct asr_query *as;
	struct asr_result ar;
	int r;

	res_init();

	as = gethostbyaddr_async(addr, len, af, NULL);
	if (as == NULL) {
		h_errno = NETDB_INTERNAL;
		return (NULL);
	}

	asr_run_sync(as, &ar);

	errno = ar.ar_errno;
	h_errno = ar.ar_h_errno;
	if (ar.ar_hostent == NULL)
		return (NULL);

	r = _fillhostent(ar.ar_hostent, &_hostent, _entbuf, sizeof(_entbuf));
	free(ar.ar_hostent);

	if (r) {
		h_errno = NETDB_INTERNAL;
		errno = r;
		return (NULL);
	}

	return (&_hostent);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: gethostnamadr.c,v 1.13 2015/09/14 07:38:37 guenther Exp $ */
2			/*
3			* Copyright (c) 2012,2013 Eric Faurot <eric@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/param.h> /* ALIGN */
19			#include <sys/types.h>
20			#include <sys/socket.h>
21			#include <netinet/in.h>
22			#include <netdb.h>
23
24			#include <asr.h>
25			#include <errno.h>
26			#include <resolv.h>
27			#include <stdint.h>
28			#include <stdlib.h>
29			#include <string.h>
30
31			static int _gethostbyname(const char , int, struct hostent , char *, size_t,
32			int *);
33			static int _fillhostent(const struct hostent , struct hostent , char *,
34			size_t);
35
36			static struct hostent _hostent;
37			static char _entbuf[4096];
38
39			static char *_empty[] = { NULL, };
40
41			static int
42			_fillhostent(const struct hostent h, struct hostent r, char *buf, size_t len)
43			{
44			char *ptr, end, *pos;
45			size_t n, i;
46			int naliases, naddrs;
47
48			bzero(buf, len);
49			bzero(r, sizeof(*r));
50			r->h_aliases = _empty;
51			r->h_addr_list = _empty;
52
53			end = buf + len;
54			ptr = (char **)ALIGN(buf);
55
56			if ((char *)ptr >= end)
57			return (ERANGE);
58
59			for (naliases = 0; h->h_aliases[naliases]; naliases++)
60			;
61			for (naddrs = 0; h->h_addr_list[naddrs]; naddrs++)
62			;
63
64			pos = (char *)(ptr + (naliases + 1) + (naddrs + 1));
65			if (pos >= end)
66			return (ERANGE);
67
68			r->h_name = NULL;
69			r->h_addrtype = h->h_addrtype;
70			r->h_length = h->h_length;
71			r->h_aliases = ptr;
72			r->h_addr_list = ptr + naliases + 1;
73
74			n = strlcpy(pos, h->h_name, end - pos);
75			if (n >= end - pos)
76			return (ERANGE);
77			r->h_name = pos;
78			pos += n + 1;
79
80			for (i = 0; i < naliases; i++) {
81			n = strlcpy(pos, h->h_aliases[i], end - pos);
82			if (n >= end - pos)
83			return (ERANGE);
84			r->h_aliases[i] = pos;
85			pos += n + 1;
86			}
87
88			pos = (char *)ALIGN(pos);
89			if (pos >= end)
90			return (ERANGE);
91
92			for (i = 0; i < naddrs; i++) {
93			if (r->h_length > end - pos)
94			return (ERANGE);
95			memmove(pos, h->h_addr_list[i], r->h_length);
96			r->h_addr_list[i] = pos;
97			pos += r->h_length;
98			}
99
100			return (0);
101			}
102
103			static int
104			_gethostbyname(const char name, int af, struct hostent ret, char *buf,
105			size_t buflen, int *h_errnop)
106			{
107			struct asr_query *as;
108			struct asr_result ar;
109			int r;
110
111			if (af == -1)
112			as = gethostbyname_async(name, NULL);
113			else
114			as = gethostbyname2_async(name, af, NULL);
115
116			if (as == NULL)
117			return (errno);
118
119			asr_run_sync(as, &ar);
120
121			errno = ar.ar_errno;
122			*h_errnop = ar.ar_h_errno;
123			if (ar.ar_hostent == NULL)
124			return (0);
125
126			r = _fillhostent(ar.ar_hostent, ret, buf, buflen);
127			free(ar.ar_hostent);
128
129			return (r);
130			}
131
132			struct hostent *
133			gethostbyname(const char *name)
134			{
135			struct hostent *h;
136
137			res_init();
138
139			if (_res.options & RES_USE_INET6 &&
140			(h = gethostbyname2(name, AF_INET6)))
141			return (h);
142
143			return gethostbyname2(name, AF_INET);
144			}
145			DEF_WEAK(gethostbyname);
146
147			struct hostent *
148			gethostbyname2(const char *name, int af)
149			{
150			int r;
151
152			res_init();
153
154			r = _gethostbyname(name, af, &_hostent, _entbuf, sizeof(_entbuf),
155			&h_errno);
156			if (r) {
157			h_errno = NETDB_INTERNAL;
158			errno = r;
159			}
160
161			if (h_errno)
162			return (NULL);
163
164			return (&_hostent);
165			}
166			DEF_WEAK(gethostbyname2);
167
168			struct hostent *
169			gethostbyaddr(const void *addr, socklen_t len, int af)
170			{
171			struct asr_query *as;
172			struct asr_result ar;
173			int r;
174
175			res_init();
176
177			as = gethostbyaddr_async(addr, len, af, NULL);
178			if (as == NULL) {
179			h_errno = NETDB_INTERNAL;
180			return (NULL);
181			}
182
183			asr_run_sync(as, &ar);
184
185			errno = ar.ar_errno;
186			h_errno = ar.ar_h_errno;
187			if (ar.ar_hostent == NULL)
188			return (NULL);
189
190			r = _fillhostent(ar.ar_hostent, &_hostent, _entbuf, sizeof(_entbuf));
191			free(ar.ar_hostent);
192
193			if (r) {
194			h_errno = NETDB_INTERNAL;
195			errno = r;
196			return (NULL);
197			}
198
199			return (&_hostent);
200			}