/contrib/ntp/libntp/ntp_rfc2553.c

  1/*
  2 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  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 * 2. Redistributions in binary form must reproduce the above copyright
 11 *    notice, this list of conditions and the following disclaimer in the
 12 *    documentation and/or other materials provided with the distribution.
 13 * 3. Neither the name of the project nor the names of its contributors
 14 *    may be used to endorse or promote products derived from this software
 15 *    without specific prior written permission.
 16 *
 17 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 27 * SUCH DAMAGE.
 28 */
 29
 30/*
 31 * Copyright (c) 1982, 1986, 1990, 1993
 32 *	The Regents of the University of California.  All rights reserved.
 33 *
 34 * Redistribution and use in source and binary forms, with or without
 35 * modification, are permitted provided that the following conditions
 36 * are met:
 37 * 1. Redistributions of source code must retain the above copyright
 38 *    notice, this list of conditions and the following disclaimer.
 39 * 2. Redistributions in binary form must reproduce the above copyright
 40 *    notice, this list of conditions and the following disclaimer in the
 41 *    documentation and/or other materials provided with the distribution.
 42 * 3. All advertising materials mentioning features or use of this software
 43 *    must display the following acknowledgement:
 44 *	This product includes software developed by the University of
 45 *	California, Berkeley and its contributors.
 46 * 4. Neither the name of the University nor the names of its contributors
 47 *    may be used to endorse or promote products derived from this software
 48 *    without specific prior written permission.
 49 *
 50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 53 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 60 * SUCH DAMAGE.
 61 *
 62 */
 63
 64/*
 65 * Compatability shims with the rfc2553 API to simplify ntp.
 66 */
 67
 68#include <config.h>
 69
 70#include <sys/types.h>
 71#include <ctype.h>
 72#include <sys/socket.h>
 73#include <isc/net.h>
 74#ifdef HAVE_NETINET_IN_H
 75#include <netinet/in.h>
 76#endif
 77#include "ntp_rfc2553.h"
 78
 79#include "ntpd.h"
 80#include "ntp_malloc.h"
 81#include "ntp_stdlib.h"
 82#include "ntp_string.h"
 83
 84#ifndef ISC_PLATFORM_HAVEIPV6
 85
 86static char *ai_errlist[] = {
 87	"Success",
 88	"Address family for hostname not supported",	/* EAI_ADDRFAMILY */
 89	"Temporary failure in name resolution",		/* EAI_AGAIN      */
 90	"Invalid value for ai_flags",		       	/* EAI_BADFLAGS   */
 91	"Non-recoverable failure in name resolution", 	/* EAI_FAIL       */
 92	"ai_family not supported",			/* EAI_FAMILY     */
 93	"Memory allocation failure", 			/* EAI_MEMORY     */
 94	"No address associated with hostname", 		/* EAI_NODATA     */
 95	"hostname nor servname provided, or not known",	/* EAI_NONAME     */
 96	"servname not supported for ai_socktype",	/* EAI_SERVICE    */
 97	"ai_socktype not supported", 			/* EAI_SOCKTYPE   */
 98	"System error returned in errno", 		/* EAI_SYSTEM     */
 99	"Invalid value for hints",			/* EAI_BADHINTS	  */
100	"Resolved protocol is unknown",			/* EAI_PROTOCOL   */
101	"Unknown error", 				/* EAI_MAX        */
102};
103
104/*
105 * Local declaration
106 */
107int
108DNSlookup_name(
109	const char *name,
110	int ai_family,
111	struct hostent **Addresses
112);
113
114#ifndef SYS_WINNT
115/*
116 * Encapsulate gethostbyname to control the error code
117 */
118int
119DNSlookup_name(
120	const char *name,
121	int ai_family,
122	struct hostent **Addresses
123)
124{
125	*Addresses = gethostbyname(name);
126	return (h_errno);
127}
128#endif
129
130static	int do_nodename P((const char *nodename, struct addrinfo *ai,
131    const struct addrinfo *hints));
132
133int
134getaddrinfo (const char *nodename, const char *servname,
135	const struct addrinfo *hints, struct addrinfo **res)
136{
137	int rval;
138	struct servent *sp;
139	struct addrinfo *ai = NULL;
140	int port;
141	const char *proto = NULL;
142	int family, socktype, flags, protocol;
143
144
145	/*
146	 * If no name is provide just return an error
147	 */
148	if (nodename == NULL && servname == NULL)
149		return (EAI_NONAME);
150	
151	ai = calloc(sizeof(struct addrinfo), 1);
152	if (ai == NULL)
153		return (EAI_MEMORY);
154
155	/*
156	 * Copy default values from hints, if available
157	 */
158	if (hints != NULL) {
159		ai->ai_flags = hints->ai_flags;
160		ai->ai_family = hints->ai_family;
161		ai->ai_socktype = hints->ai_socktype;
162		ai->ai_protocol = hints->ai_protocol;
163
164		family = hints->ai_family;
165		socktype = hints->ai_socktype;
166		protocol = hints->ai_protocol;
167		flags = hints->ai_flags;
168
169		switch (family) {
170		case AF_UNSPEC:
171			switch (hints->ai_socktype) {
172			case SOCK_STREAM:
173				proto = "tcp";
174				break;
175			case SOCK_DGRAM:
176				proto = "udp";
177				break;
178			}
179			break;
180		case AF_INET:
181		case AF_INET6:
182			switch (hints->ai_socktype) {
183			case 0:
184				break;
185			case SOCK_STREAM:
186				proto = "tcp";
187				break;
188			case SOCK_DGRAM:
189				proto = "udp";
190				break;
191			case SOCK_RAW:
192				break;
193			default:
194				return (EAI_SOCKTYPE);
195			}
196			break;
197#ifdef	AF_LOCAL
198		case AF_LOCAL:
199			switch (hints->ai_socktype) {
200			case 0:
201				break;
202			case SOCK_STREAM:
203				break;
204			case SOCK_DGRAM:
205				break;
206			default:
207				return (EAI_SOCKTYPE);
208			}
209			break;
210#endif
211		default:
212			return (EAI_FAMILY);
213		}
214	} else {
215		protocol = 0;
216		family = 0;
217		socktype = 0;
218		flags = 0;
219	}
220
221	rval = do_nodename(nodename, ai, hints);
222	if (rval != 0) {
223		freeaddrinfo(ai);
224		return (rval);
225	}
226
227	/*
228	 * First, look up the service name (port) if it was
229	 * requested.  If the socket type wasn't specified, then
230	 * try and figure it out.
231	 */
232	if (servname != NULL) {
233		char *e;
234
235		port = strtol(servname, &e, 10);
236		if (*e == '\0') {
237			if (socktype == 0)
238				return (EAI_SOCKTYPE);
239			if (port < 0 || port > 65535)
240				return (EAI_SERVICE);
241			port = htons((unsigned short) port);
242		} else {
243			sp = getservbyname(servname, proto);
244			if (sp == NULL)
245				return (EAI_SERVICE);
246			port = sp->s_port;
247			if (socktype == 0) {
248				if (strcmp(sp->s_proto, "tcp") == 0)
249					socktype = SOCK_STREAM;
250				else if (strcmp(sp->s_proto, "udp") == 0)
251					socktype = SOCK_DGRAM;
252			}
253		}
254	} else
255		port = 0;
256
257	/*
258	 *
259	 * Set up the port number
260	 */
261	if (ai->ai_family == AF_INET)
262		((struct sockaddr_in *)ai->ai_addr)->sin_port = (unsigned short) port;
263	else if (ai->ai_family == AF_INET6)
264		((struct sockaddr_in6 *)ai->ai_addr)->sin6_port = (unsigned short) port;
265	*res = ai;
266	return (0);
267}
268
269void
270freeaddrinfo(struct addrinfo *ai)
271{
272	if (ai->ai_canonname != NULL)
273	{
274		free(ai->ai_canonname);
275		ai->ai_canonname = NULL;
276	}
277	if (ai->ai_addr != NULL)
278	{
279		free(ai->ai_addr);
280		ai->ai_addr = NULL;
281	}
282	free(ai);
283	ai = NULL;
284}
285
286int
287getnameinfo (const struct sockaddr *sa, u_int salen, char *host,
288	size_t hostlen, char *serv, size_t servlen, int flags)
289{
290	struct hostent *hp;
291	int namelen;
292
293	if (sa->sa_family != AF_INET)
294		return (EAI_FAMILY);
295	hp = gethostbyaddr(
296	    (const char *)&((const struct sockaddr_in *)sa)->sin_addr,
297	    4, AF_INET);
298	if (hp == NULL) {
299		if (h_errno == TRY_AGAIN)
300			return (EAI_AGAIN);
301		else
302			return (EAI_FAIL);
303	}
304	if (host != NULL && hostlen > 0) {
305		/*
306		 * Don't exceed buffer
307		 */
308		namelen = min(strlen(hp->h_name), hostlen - 1);
309		if (namelen > 0) {
310			strncpy(host, hp->h_name, namelen);
311			host[namelen] = '\0';
312		}
313	}
314	return (0);
315}
316
317char *
318gai_strerror(int ecode)
319{
320	if (ecode < 0 || ecode > EAI_MAX)
321		ecode = EAI_MAX;
322	return ai_errlist[ecode];
323}
324
325static int
326do_nodename(
327	const char *nodename,
328	struct addrinfo *ai,
329	const struct addrinfo *hints)
330{
331	struct hostent *hp = NULL;
332	struct sockaddr_in *sockin;
333	struct sockaddr_in6 *sockin6;
334	int errval;
335
336	ai->ai_addr = calloc(sizeof(struct sockaddr_storage), 1);
337	if (ai->ai_addr == NULL)
338		return (EAI_MEMORY);
339
340	/*
341	 * For an empty node name just use the wildcard.
342	 * NOTE: We need to assume that the address family is
343	 * set elsewhere so that we can set the appropriate wildcard
344	 */
345	if (nodename == NULL) {
346		ai->ai_addrlen = sizeof(struct sockaddr_storage);
347		if (ai->ai_family == AF_INET)
348		{
349			sockin = (struct sockaddr_in *)ai->ai_addr;
350			sockin->sin_family = (short) ai->ai_family;
351			sockin->sin_addr.s_addr = htonl(INADDR_ANY);
352		}
353		else
354		{
355			sockin6 = (struct sockaddr_in6 *)ai->ai_addr;
356			sockin6->sin6_family = (short) ai->ai_family;
357			/*
358			 * we have already zeroed out the address
359			 * so we don't actually need to do this
360			 * This assignment is causing problems so
361			 * we don't do what this would do.
362			 sockin6->sin6_addr = in6addr_any;
363			 */
364		}
365#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
366		ai->ai_addr->sa_len = SOCKLEN(ai->ai_addr);
367#endif
368
369		return (0);
370	}
371
372	/*
373	 * See if we have an IPv6 address
374	 */
375	if(strchr(nodename, ':') != NULL) {
376		if (inet_pton(AF_INET6, nodename,
377		    &((struct sockaddr_in6 *)ai->ai_addr)->sin6_addr) == 1) {
378			((struct sockaddr_in6 *)ai->ai_addr)->sin6_family = AF_INET6;
379			ai->ai_family = AF_INET6;
380			ai->ai_addrlen = sizeof(struct sockaddr_in6);
381			return (0);
382		}
383	}
384
385	/*
386	 * See if we have an IPv4 address
387	 */
388	if (inet_pton(AF_INET, nodename,
389	    &((struct sockaddr_in *)ai->ai_addr)->sin_addr) == 1) {
390		((struct sockaddr *)ai->ai_addr)->sa_family = AF_INET;
391		ai->ai_family = AF_INET;
392		ai->ai_addrlen = sizeof(struct sockaddr_in);
393		return (0);
394	}
395
396	/*
397	 * If the numeric host flag is set, don't attempt resolution
398	 */
399	if (hints != NULL && (hints->ai_flags & AI_NUMERICHOST))
400		return (EAI_NONAME);
401
402	/*
403	 * Look for a name
404	 */
405
406	errval = DNSlookup_name(nodename, AF_INET, &hp);
407
408	if (hp == NULL) {
409		if (errval == TRY_AGAIN || errval == EAI_AGAIN)
410			return (EAI_AGAIN);
411		else if (errval == EAI_NONAME) {
412			if (inet_pton(AF_INET, nodename,
413			    &((struct sockaddr_in *)ai->ai_addr)->sin_addr) == 1) {
414				((struct sockaddr *)ai->ai_addr)->sa_family = AF_INET;
415				ai->ai_family = AF_INET;
416				ai->ai_addrlen = sizeof(struct sockaddr_in);
417				return (0);
418			}
419			return (errval);
420		}
421		else
422		{
423			return (errval);
424		}
425	}
426	ai->ai_family = hp->h_addrtype;
427	ai->ai_addrlen = sizeof(struct sockaddr);
428	sockin = (struct sockaddr_in *)ai->ai_addr;
429	memcpy(&sockin->sin_addr, hp->h_addr, hp->h_length);
430	ai->ai_addr->sa_family = hp->h_addrtype;
431#ifdef HAVE_SA_LEN_IN_STRUCT_SOCKADDR
432	ai->ai_addr->sa_len = sizeof(struct sockaddr);
433#endif
434	if (hints != NULL && hints->ai_flags & AI_CANONNAME) {
435		ai->ai_canonname = malloc(strlen(hp->h_name) + 1);
436		if (ai->ai_canonname == NULL)
437			return (EAI_MEMORY);
438		strcpy(ai->ai_canonname, hp->h_name);
439	}
440	return (0);
441}
442
443#endif /* !ISC_PLATFORM_HAVEIPV6 */