[rsync/rsync.git] / lib / getaddrinfo.c

/*
PostgreSQL Database Management System
(formerly known as Postgres, then as Postgres95)

Portions Copyright (c) 1996-2005, The PostgreSQL Global Development Group

Portions Copyright (c) 1994, The Regents of the University of California

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose, without fee, and without a written agreement
is hereby granted, provided that the above copyright notice and this paragraph
and the following two paragraphs appear in all copies.

IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS
TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

*/

/*-------------------------------------------------------------------------
 *
 * getaddrinfo.c
 *	  Support getaddrinfo() on platforms that don't have it.
 *
 * We also supply getnameinfo() here, assuming that the platform will have
 * it if and only if it has getaddrinfo().	If this proves false on some
 * platform, we'll need to split this file and provide a separate configure
 * test for getnameinfo().
 *
 * Copyright (c) 2003-2007, PostgreSQL Global Development Group
 *
 * Copyright (C) 2007 Jeremy Allison.
 * Modified to return multiple IPv4 addresses for Samba.
 *
 *-------------------------------------------------------------------------
 */

#include "rsync.h"

#ifndef SMB_MALLOC
#define SMB_MALLOC(s) malloc(s)
#endif

#ifndef SMB_STRDUP
#define SMB_STRDUP(s) strdup(s)
#endif

#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 255
#endif

static int check_hostent_err(struct hostent *hp)
{
#ifndef INET6
	extern int h_errno;
#endif
	if (!hp) {
		switch (h_errno) {
			case HOST_NOT_FOUND:
			case NO_DATA:
				return EAI_NONAME;
			case TRY_AGAIN:
				return EAI_AGAIN;
			case NO_RECOVERY:
			default:
				return EAI_FAIL;
		}
	}
	if (!hp->h_name || hp->h_addrtype != AF_INET) {
		return EAI_FAIL;
	}
	return 0;
}

static char *canon_name_from_hostent(struct hostent *hp,
				int *perr)
{
	char *ret = NULL;

	*perr = check_hostent_err(hp);
	if (*perr) {
		return NULL;
	}
	ret = SMB_STRDUP(hp->h_name);
	if (!ret) {
		*perr = EAI_MEMORY;
	}
	return ret;
}

static char *get_my_canon_name(int *perr)
{
	char name[HOST_NAME_MAX+1];

	if (gethostname(name, HOST_NAME_MAX) == -1) {
		*perr = EAI_FAIL;
		return NULL;
	}
	/* Ensure null termination. */
	name[HOST_NAME_MAX] = '\0';
	return canon_name_from_hostent(gethostbyname(name), perr);
}

static char *get_canon_name_from_addr(struct in_addr ip,
				int *perr)
{
	return canon_name_from_hostent(
			gethostbyaddr((void *)&ip, sizeof ip, AF_INET),
			perr);
}

static struct addrinfo *alloc_entry(const struct addrinfo *hints,
				struct in_addr ip,
				unsigned short port)
{
	struct sockaddr_in *psin = NULL;
	struct addrinfo *ai = SMB_MALLOC(sizeof(*ai));

	if (!ai) {
		return NULL;
	}
	memset(ai, '\0', sizeof(*ai));

	psin = SMB_MALLOC(sizeof(*psin));
	if (!psin) {
		free(ai);
		return NULL;
	}

	memset(psin, '\0', sizeof(*psin));

	psin->sin_family = AF_INET;
	psin->sin_port = htons(port);
	psin->sin_addr = ip;

	ai->ai_flags = 0;
	ai->ai_family = AF_INET;
	ai->ai_socktype = hints->ai_socktype;
	ai->ai_protocol = hints->ai_protocol;
	ai->ai_addrlen = sizeof(*psin);
	ai->ai_addr = (struct sockaddr *) psin;
	ai->ai_canonname = NULL;
	ai->ai_next = NULL;

	return ai;
}

/*
 * get address info for a single ipv4 address.
 *
 *	Bugs:	- servname can only be a number, not text.
 */

static int getaddr_info_single_addr(const char *service,
				uint32 addr,
				const struct addrinfo *hints,
				struct addrinfo **res)
{

	struct addrinfo *ai = NULL;
	struct in_addr ip;
	unsigned short port = 0;

	if (service) {
		port = (unsigned short)atoi(service);
	}
	ip.s_addr = htonl(addr);

	ai = alloc_entry(hints, ip, port);
	if (!ai) {
		return EAI_MEMORY;
	}

	/* If we're asked for the canonical name,
	 * make sure it returns correctly. */
	if (!(hints->ai_flags & AI_NUMERICSERV) &&
			hints->ai_flags & AI_CANONNAME) {
		int err;
		if (addr == INADDR_LOOPBACK || addr == INADDR_ANY) {
			ai->ai_canonname = get_my_canon_name(&err);
		} else {
			ai->ai_canonname =
			get_canon_name_from_addr(ip,&err);
		}
		if (ai->ai_canonname == NULL) {
			freeaddrinfo(ai);
			return err;
		}
	}

	*res = ai;
	return 0;
}

/*
 * get address info for multiple ipv4 addresses.
 *
 *	Bugs:	- servname can only be a number, not text.
 */

static int getaddr_info_name(const char *node,
				const char *service,
				const struct addrinfo *hints,
				struct addrinfo **res)
{
	struct addrinfo *listp = NULL, *prevp = NULL;
	char **pptr = NULL;
	int err;
	struct hostent *hp = NULL;
	unsigned short port = 0;

	if (service) {
		port = (unsigned short)atoi(service);
	}

	hp = gethostbyname(node);
	err = check_hostent_err(hp);
	if (err) {
		return err;
	}

	for(pptr = hp->h_addr_list; *pptr; pptr++) {
		struct in_addr ip = *(struct in_addr *)*pptr;
		struct addrinfo *ai = alloc_entry(hints, ip, port);

		if (!ai) {
			freeaddrinfo(listp);
			return EAI_MEMORY;
		}

		if (!listp) {
			listp = ai;
			prevp = ai;
			ai->ai_canonname = SMB_STRDUP(hp->h_name);
			if (!ai->ai_canonname) {
				freeaddrinfo(listp);
				return EAI_MEMORY;
			}
		} else {
			prevp->ai_next = ai;
			prevp = ai;
		}
	}
	*res = listp;
	return 0;
}

/*
 * get address info for ipv4 sockets.
 *
 *	Bugs:	- servname can only be a number, not text.
 */

int getaddrinfo(const char *node,
		const char *service,
		const struct addrinfo * hintp,
		struct addrinfo ** res)
{
	struct addrinfo hints;

	/* Setup the hints struct. */
	if (hintp == NULL) {
		memset(&hints, 0, sizeof(hints));
		hints.ai_family = AF_INET;
		hints.ai_socktype = SOCK_STREAM;
	} else {
		memcpy(&hints, hintp, sizeof(hints));
	}

	if (hints.ai_family != AF_INET && hints.ai_family != AF_UNSPEC) {
		return EAI_FAMILY;
	}

	if (hints.ai_socktype == 0) {
		hints.ai_socktype = SOCK_STREAM;
	}

	if (!node && !service) {
		return EAI_NONAME;
	}

	if (node) {
		if (node[0] == '\0') {
			return getaddr_info_single_addr(service,
					INADDR_ANY,
					&hints,
					res);
		} else if (hints.ai_flags & AI_NUMERICHOST) {
			struct in_addr ip;
			if (!inet_aton(node, &ip)) {
				return EAI_FAIL;
			}
			return getaddr_info_single_addr(service,
					ntohl(ip.s_addr),
					&hints,
					res);
		} else {
			return getaddr_info_name(node,
						service,
						&hints,
						res);
		}
	} else if (hints.ai_flags & AI_PASSIVE) {
		return getaddr_info_single_addr(service,
					INADDR_ANY,
					&hints,
					res);
	}
	return getaddr_info_single_addr(service,
					INADDR_LOOPBACK,
					&hints,
					res);
}


void freeaddrinfo(struct addrinfo *res)
{
	struct addrinfo *next = NULL;

	for (;res; res = next) {
		next = res->ai_next;
		if (res->ai_canonname) {
			free(res->ai_canonname);
		}
		if (res->ai_addr) {
			free(res->ai_addr);
		}
		free(res);
	}
}


const char *gai_strerror(int errcode)
{
#ifdef HAVE_HSTRERROR
	int			hcode;

	switch (errcode)
	{
		case EAI_NONAME:
			hcode = HOST_NOT_FOUND;
			break;
		case EAI_AGAIN:
			hcode = TRY_AGAIN;
			break;
		case EAI_FAIL:
		default:
			hcode = NO_RECOVERY;
			break;
	}

	return hstrerror(hcode);
#else							/* !HAVE_HSTRERROR */

	switch (errcode)
	{
		case EAI_NONAME:
			return "Unknown host";
		case EAI_AGAIN:
			return "Host name lookup failure";
#ifdef EAI_BADFLAGS
		case EAI_BADFLAGS:
			return "Invalid argument";
#endif
#ifdef EAI_FAMILY
		case EAI_FAMILY:
			return "Address family not supported";
#endif
#ifdef EAI_MEMORY
		case EAI_MEMORY:
			return "Not enough memory";
#endif
#ifdef EAI_NODATA
		case EAI_NODATA:
			return "No host data of that type was found";
#endif
#ifdef EAI_SERVICE
		case EAI_SERVICE:
			return "Class type not found";
#endif
#ifdef EAI_SOCKTYPE
		case EAI_SOCKTYPE:
			return "Socket type not supported";
#endif
		default:
			return "Unknown server error";
	}
#endif   /* HAVE_HSTRERROR */
}

static int gethostnameinfo(const struct sockaddr *sa,
			char *node,
			size_t nodelen,
			int flags)
{
	int ret = -1;
	char *p = NULL;

	if (!(flags & NI_NUMERICHOST)) {
		struct hostent *hp = gethostbyaddr(
				(void *)&((struct sockaddr_in *)sa)->sin_addr,
				sizeof (struct in_addr),
				sa->sa_family);
		ret = check_hostent_err(hp);
		if (ret == 0) {
			/* Name looked up successfully. */
			ret = snprintf(node, nodelen, "%s", hp->h_name);
			if (ret < 0 || (size_t)ret >= nodelen) {
				return EAI_MEMORY;
			}
			if (flags & NI_NOFQDN) {
				p = strchr(node,'.');
				if (p) {
					*p = '\0';
				}
			}
			return 0;
		}

		if (flags & NI_NAMEREQD) {
			/* If we require a name and didn't get one,
			 * automatically fail. */
			return ret;
		}
		/* Otherwise just fall into the numeric host code... */
	}
	p = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
	ret = snprintf(node, nodelen, "%s", p);
	if (ret < 0 || (size_t)ret >= nodelen) {
		return EAI_MEMORY;
	}
	return 0;
}

static int getservicenameinfo(const struct sockaddr *sa,
			char *service,
			size_t servicelen,
			int flags)
{
	int ret = -1;
	int port = ntohs(((struct sockaddr_in *)sa)->sin_port);

	if (!(flags & NI_NUMERICSERV)) {
		struct servent *se = getservbyport(
				port,
				(flags & NI_DGRAM) ? "udp" : "tcp");
		if (se && se->s_name) {
			/* Service name looked up successfully. */
			ret = snprintf(service, servicelen, "%s", se->s_name);
			if (ret < 0 || (size_t)ret >= servicelen) {
				return EAI_MEMORY;
			}
			return 0;
		}
		/* Otherwise just fall into the numeric service code... */
	}
	ret = snprintf(service, servicelen, "%d", port);
	if (ret < 0 || (size_t)ret >= servicelen) {
		return EAI_MEMORY;
	}
	return 0;
}

/*
 * Convert an ipv4 address to a hostname.
 *
 * Bugs:	- No IPv6 support.
 */
int getnameinfo(const struct sockaddr *sa, socklen_t salen,
			char *node, size_t nodelen,
			char *service, size_t servicelen, int flags)
{

	/* Invalid arguments. */
	if (sa == NULL || (node == NULL && service == NULL)) {
		return EAI_FAIL;
	}

	if (sa->sa_family != AF_INET) {
		return EAI_FAIL;
	}

	if (salen < (socklen_t)sizeof (struct sockaddr_in)) {
		return EAI_FAIL;
	}

	if (node) {
		int ret = gethostnameinfo(sa, node, nodelen, flags);
		if (ret)
			return ret;
	}

	if (service) {
		return getservicenameinfo(sa, service, servicelen, flags);
	}
	return 0;
}
Commit	Line	Data
9f802c72 WD	1	/*
	2	PostgreSQL Database Management System
	3	(formerly known as Postgres, then as Postgres95)
	4
	5	Portions Copyright (c) 1996-2005, The PostgreSQL Global Development Group
	6
	7	Portions Copyright (c) 1994, The Regents of the University of California
	8
	9	Permission to use, copy, modify, and distribute this software and its
	10	documentation for any purpose, without fee, and without a written agreement
	11	is hereby granted, provided that the above copyright notice and this paragraph
	12	and the following two paragraphs appear in all copies.
	13
	14	IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
	15	DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
	16	LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
	17	EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
	18	SUCH DAMAGE.
	19
	20	THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
	21	INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
	22	AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
	23	ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS
	24	TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
	25
	26	*/
	27
	28	/*-------------------------------------------------------------------------
	29	*
	30	* getaddrinfo.c
	31	* Support getaddrinfo() on platforms that don't have it.
	32	*
	33	* We also supply getnameinfo() here, assuming that the platform will have
	34	* it if and only if it has getaddrinfo(). If this proves false on some
	35	* platform, we'll need to split this file and provide a separate configure
	36	* test for getnameinfo().
	37	*
	38	* Copyright (c) 2003-2007, PostgreSQL Global Development Group
	39	*
	40	* Copyright (C) 2007 Jeremy Allison.
	41	* Modified to return multiple IPv4 addresses for Samba.
	42	*
	43	*-------------------------------------------------------------------------
	44	*/
	45
	46	#include "rsync.h"
	47
	48	#ifndef SMB_MALLOC
	49	#define SMB_MALLOC(s) malloc(s)
	50	#endif
	51
	52	#ifndef SMB_STRDUP
	53	#define SMB_STRDUP(s) strdup(s)
	54	#endif
	55
94564346 WD	56	#ifndef HOST_NAME_MAX
	57	#define HOST_NAME_MAX 255
	58	#endif
	59
9f802c72 WD	60	static int check_hostent_err(struct hostent *hp)
9f802c72 WD	61	{
94564346 WD	62	#ifndef INET6
	63	extern int h_errno;
	64	#endif
9f802c72 WD	65	if (!hp) {
	66	switch (h_errno) {
	67	case HOST_NOT_FOUND:
	68	case NO_DATA:
	69	return EAI_NONAME;
	70	case TRY_AGAIN:
	71	return EAI_AGAIN;
	72	case NO_RECOVERY:
	73	default:
	74	return EAI_FAIL;
	75	}
	76	}
	77	if (!hp->h_name \|\| hp->h_addrtype != AF_INET) {
	78	return EAI_FAIL;
	79	}
	80	return 0;
	81	}
	82
	83	static char canon_name_from_hostent(struct hostent hp,
	84	int *perr)
	85	{
	86	char *ret = NULL;
	87
	88	*perr = check_hostent_err(hp);
	89	if (*perr) {
	90	return NULL;
	91	}
	92	ret = SMB_STRDUP(hp->h_name);
	93	if (!ret) {
	94	*perr = EAI_MEMORY;
	95	}
	96	return ret;
	97	}
	98
	99	static char get_my_canon_name(int perr)
	100	{
	101	char name[HOST_NAME_MAX+1];
	102
	103	if (gethostname(name, HOST_NAME_MAX) == -1) {
	104	*perr = EAI_FAIL;
	105	return NULL;
	106	}
	107	/* Ensure null termination. */
	108	name[HOST_NAME_MAX] = '\0';
	109	return canon_name_from_hostent(gethostbyname(name), perr);
	110	}
	111
	112	static char *get_canon_name_from_addr(struct in_addr ip,
	113	int *perr)
	114	{
	115	return canon_name_from_hostent(
1b411143	116	gethostbyaddr((void *)&ip, sizeof ip, AF_INET),
9f802c72 WD	117	perr);
	118	}
	119
	120	static struct addrinfo alloc_entry(const struct addrinfo hints,
	121	struct in_addr ip,
	122	unsigned short port)
	123	{
	124	struct sockaddr_in *psin = NULL;
	125	struct addrinfo ai = SMB_MALLOC(sizeof(ai));
	126
	127	if (!ai) {
	128	return NULL;
	129	}
	130	memset(ai, '\0', sizeof(*ai));
	131
	132	psin = SMB_MALLOC(sizeof(*psin));
	133	if (!psin) {
	134	free(ai);
	135	return NULL;
	136	}
	137
	138	memset(psin, '\0', sizeof(*psin));
	139
	140	psin->sin_family = AF_INET;
	141	psin->sin_port = htons(port);
	142	psin->sin_addr = ip;
	143
	144	ai->ai_flags = 0;
	145	ai->ai_family = AF_INET;
	146	ai->ai_socktype = hints->ai_socktype;
	147	ai->ai_protocol = hints->ai_protocol;
	148	ai->ai_addrlen = sizeof(*psin);
	149	ai->ai_addr = (struct sockaddr *) psin;
	150	ai->ai_canonname = NULL;
	151	ai->ai_next = NULL;
	152
	153	return ai;
	154	}
	155
	156	/*
	157	* get address info for a single ipv4 address.
	158	*
	159	* Bugs: - servname can only be a number, not text.
	160	*/
	161
	162	static int getaddr_info_single_addr(const char *service,
268da816	163	uint32 addr,
9f802c72 WD	164	const struct addrinfo *hints,
	165	struct addrinfo **res)
	166	{
	167
	168	struct addrinfo *ai = NULL;
	169	struct in_addr ip;
	170	unsigned short port = 0;
	171
	172	if (service) {
	173	port = (unsigned short)atoi(service);
	174	}
	175	ip.s_addr = htonl(addr);
	176
	177	ai = alloc_entry(hints, ip, port);
	178	if (!ai) {
	179	return EAI_MEMORY;
	180	}
	181
	182	/* If we're asked for the canonical name,
	183	* make sure it returns correctly. */
	184	if (!(hints->ai_flags & AI_NUMERICSERV) &&
	185	hints->ai_flags & AI_CANONNAME) {
	186	int err;
	187	if (addr == INADDR_LOOPBACK \|\| addr == INADDR_ANY) {
	188	ai->ai_canonname = get_my_canon_name(&err);
	189	} else {
	190	ai->ai_canonname =
	191	get_canon_name_from_addr(ip,&err);
	192	}
	193	if (ai->ai_canonname == NULL) {
	194	freeaddrinfo(ai);
	195	return err;
	196	}
	197	}
	198
	199	*res = ai;
	200	return 0;
	201	}
	202
	203	/*
	204	* get address info for multiple ipv4 addresses.
	205	*
	206	* Bugs: - servname can only be a number, not text.
	207	*/
	208
	209	static int getaddr_info_name(const char *node,
	210	const char *service,
	211	const struct addrinfo *hints,
	212	struct addrinfo **res)
	213	{
	214	struct addrinfo listp = NULL, prevp = NULL;
	215	char **pptr = NULL;
	216	int err;
	217	struct hostent *hp = NULL;
	218	unsigned short port = 0;
	219
	220	if (service) {
	221	port = (unsigned short)atoi(service);
	222	}
	223
	224	hp = gethostbyname(node);
	225	err = check_hostent_err(hp);
	226	if (err) {
	227	return err;
228	}
229
230	for(pptr = hp->h_addr_list; *pptr; pptr++) {
231	struct in_addr ip = (struct in_addr )*pptr;
232	struct addrinfo *ai = alloc_entry(hints, ip, port);
233
234	if (!ai) {
235	freeaddrinfo(listp);
236	return EAI_MEMORY;
237	}
238
239	if (!listp) {
240	listp = ai;
241	prevp = ai;
242	ai->ai_canonname = SMB_STRDUP(hp->h_name);
243	if (!ai->ai_canonname) {
244	freeaddrinfo(listp);
245	return EAI_MEMORY;
246	}
247	} else {
248	prevp->ai_next = ai;
249	prevp = ai;
250	}
251	}
252	*res = listp;
253	return 0;
254	}
255
256	/*
257	* get address info for ipv4 sockets.
258	*
259	* Bugs: - servname can only be a number, not text.
260	*/
261
262	int getaddrinfo(const char *node,
263	const char *service,
264	const struct addrinfo * hintp,
265	struct addrinfo ** res)
266	{
267	struct addrinfo hints;
268
269	/* Setup the hints struct. */
270	if (hintp == NULL) {
271	memset(&hints, 0, sizeof(hints));
272	hints.ai_family = AF_INET;
273	hints.ai_socktype = SOCK_STREAM;
274	} else {
275	memcpy(&hints, hintp, sizeof(hints));
276	}
277
278	if (hints.ai_family != AF_INET && hints.ai_family != AF_UNSPEC) {
279	return EAI_FAMILY;
280	}
281
282	if (hints.ai_socktype == 0) {
283	hints.ai_socktype = SOCK_STREAM;
284	}
285
286	if (!node && !service) {
287	return EAI_NONAME;
288	}
289
290	if (node) {
291	if (node[0] == '\0') {
292	return getaddr_info_single_addr(service,
293	INADDR_ANY,
294	&hints,
295	res);
296	} else if (hints.ai_flags & AI_NUMERICHOST) {
297	struct in_addr ip;
298	if (!inet_aton(node, &ip)) {
299	return EAI_FAIL;
300	}
301	return getaddr_info_single_addr(service,
302	ntohl(ip.s_addr),
303	&hints,
304	res);
305	} else {
306	return getaddr_info_name(node,
307	service,
308	&hints,
309	res);
310	}
311	} else if (hints.ai_flags & AI_PASSIVE) {
312	return getaddr_info_single_addr(service,
313	INADDR_ANY,
314	&hints,
315	res);
316	}
317	return getaddr_info_single_addr(service,
318	INADDR_LOOPBACK,
319	&hints,
320	res);
321	}
322
323
324	void freeaddrinfo(struct addrinfo *res)
325	{
326	struct addrinfo *next = NULL;
327
328	for (;res; res = next) {
329	next = res->ai_next;
330	if (res->ai_canonname) {
331	free(res->ai_canonname);
332	}
333	if (res->ai_addr) {
334	free(res->ai_addr);
335	}
336	free(res);
337	}
338	}
339
340
341	const char *gai_strerror(int errcode)
342	{
343	#ifdef HAVE_HSTRERROR
344	int hcode;
345
346	switch (errcode)
347	{
348	case EAI_NONAME:
349	hcode = HOST_NOT_FOUND;
350	break;
351	case EAI_AGAIN:
352	hcode = TRY_AGAIN;
353	break;
354	case EAI_FAIL:
355	default:
356	hcode = NO_RECOVERY;
357	break;
358	}
359
360	return hstrerror(hcode);
361	#else /* !HAVE_HSTRERROR */
362
363	switch (errcode)
364	{
365	case EAI_NONAME:
366	return "Unknown host";
367	case EAI_AGAIN:
368	return "Host name lookup failure";
369	#ifdef EAI_BADFLAGS
370	case EAI_BADFLAGS:
371	return "Invalid argument";
372	#endif
373	#ifdef EAI_FAMILY
374	case EAI_FAMILY:
375	return "Address family not supported";
376	#endif
377	#ifdef EAI_MEMORY
378	case EAI_MEMORY:
379	return "Not enough memory";
380	#endif
381	#ifdef EAI_NODATA
382	case EAI_NODATA:
383	return "No host data of that type was found";
384	#endif
385	#ifdef EAI_SERVICE
386	case EAI_SERVICE:
387	return "Class type not found";
388	#endif
389	#ifdef EAI_SOCKTYPE
390	case EAI_SOCKTYPE:
391	return "Socket type not supported";
392	#endif
393	default:
394	return "Unknown server error";
395	}
396	#endif /* HAVE_HSTRERROR */
397	}
398
399	static int gethostnameinfo(const struct sockaddr *sa,
400	char *node,
401	size_t nodelen,
402	int flags)
403	{
404	int ret = -1;
405	char *p = NULL;
406
407	if (!(flags & NI_NUMERICHOST)) {
408	struct hostent *hp = gethostbyaddr(
94564346 WD	409	(void )&((struct sockaddr_in )sa)->sin_addr,
94564346 WD	410	sizeof (struct in_addr),
9f802c72 WD	411	sa->sa_family);
	412	ret = check_hostent_err(hp);
	413	if (ret == 0) {
	414	/* Name looked up successfully. */
	415	ret = snprintf(node, nodelen, "%s", hp->h_name);
	416	if (ret < 0 \|\| (size_t)ret >= nodelen) {
	417	return EAI_MEMORY;
	418	}
	419	if (flags & NI_NOFQDN) {
	420	p = strchr(node,'.');
	421	if (p) {
	422	*p = '\0';
	423	}
	424	}
	425	return 0;
	426	}
	427
	428	if (flags & NI_NAMEREQD) {
	429	/* If we require a name and didn't get one,
	430	* automatically fail. */
	431	return ret;
	432	}
	433	/* Otherwise just fall into the numeric host code... */
	434	}
	435	p = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
	436	ret = snprintf(node, nodelen, "%s", p);
	437	if (ret < 0 \|\| (size_t)ret >= nodelen) {
	438	return EAI_MEMORY;
	439	}
	440	return 0;
	441	}
	442
	443	static int getservicenameinfo(const struct sockaddr *sa,
	444	char *service,
	445	size_t servicelen,
	446	int flags)
	447	{
	448	int ret = -1;
	449	int port = ntohs(((struct sockaddr_in *)sa)->sin_port);
	450
	451	if (!(flags & NI_NUMERICSERV)) {
	452	struct servent *se = getservbyport(
	453	port,
	454	(flags & NI_DGRAM) ? "udp" : "tcp");
	455	if (se && se->s_name) {
	456	/* Service name looked up successfully. */
	457	ret = snprintf(service, servicelen, "%s", se->s_name);
	458	if (ret < 0 \|\| (size_t)ret >= servicelen) {
	459	return EAI_MEMORY;
	460	}
	461	return 0;
	462	}
	463	/* Otherwise just fall into the numeric service code... */
	464	}
	465	ret = snprintf(service, servicelen, "%d", port);
	466	if (ret < 0 \|\| (size_t)ret >= servicelen) {
	467	return EAI_MEMORY;
	468	}
	469	return 0;
	470	}
	471
	472	/*
	473	* Convert an ipv4 address to a hostname.
	474	*
475	* Bugs: - No IPv6 support.
476	*/
477	int getnameinfo(const struct sockaddr *sa, socklen_t salen,
478	char *node, size_t nodelen,
479	char *service, size_t servicelen, int flags)
480	{
481
482	/* Invalid arguments. */
483	if (sa == NULL \|\| (node == NULL && service == NULL)) {
484	return EAI_FAIL;
485	}
486
487	if (sa->sa_family != AF_INET) {
488	return EAI_FAIL;
489	}
490
94564346	491	if (salen < (socklen_t)sizeof (struct sockaddr_in)) {
9f802c72 WD	492	return EAI_FAIL;
	493	}
	494
9f802c72	495	if (node) {
9ddc2b64 WD	496	int ret = gethostnameinfo(sa, node, nodelen, flags);
	497	if (ret)
	498	return ret;
9f802c72 WD	499	}
	500
	501	if (service) {
	502	return getservicenameinfo(sa, service, servicelen, flags);
	503	}
	504	return 0;
	505	}