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:
56: #ifndef HOST_NAME_MAX
57: #define HOST_NAME_MAX 255
58: #endif
59:
60: static int check_hostent_err(struct hostent *hp)
61: {
62: #ifndef INET6
63: extern int h_errno;
64: #endif
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(
116: gethostbyaddr((void *)&ip, sizeof ip, AF_INET),
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,
163: uint32 addr,
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_pton(AF_INET, node, &ip) <= 0)
299: return EAI_FAIL;
300: return getaddr_info_single_addr(service,
301: ntohl(ip.s_addr),
302: &hints,
303: res);
304: } else {
305: return getaddr_info_name(node,
306: service,
307: &hints,
308: res);
309: }
310: } else if (hints.ai_flags & AI_PASSIVE) {
311: return getaddr_info_single_addr(service,
312: INADDR_ANY,
313: &hints,
314: res);
315: }
316: return getaddr_info_single_addr(service,
317: INADDR_LOOPBACK,
318: &hints,
319: res);
320: }
321:
322:
323: void freeaddrinfo(struct addrinfo *res)
324: {
325: struct addrinfo *next = NULL;
326:
327: for (;res; res = next) {
328: next = res->ai_next;
329: if (res->ai_canonname) {
330: free(res->ai_canonname);
331: }
332: if (res->ai_addr) {
333: free(res->ai_addr);
334: }
335: free(res);
336: }
337: }
338:
339:
340: const char *gai_strerror(int errcode)
341: {
342: #ifdef HAVE_HSTRERROR
343: int hcode;
344:
345: switch (errcode)
346: {
347: case EAI_NONAME:
348: hcode = HOST_NOT_FOUND;
349: break;
350: case EAI_AGAIN:
351: hcode = TRY_AGAIN;
352: break;
353: case EAI_FAIL:
354: default:
355: hcode = NO_RECOVERY;
356: break;
357: }
358:
359: return hstrerror(hcode);
360: #else /* !HAVE_HSTRERROR */
361:
362: switch (errcode)
363: {
364: case EAI_NONAME:
365: return "Unknown host";
366: case EAI_AGAIN:
367: return "Host name lookup failure";
368: #ifdef EAI_BADFLAGS
369: case EAI_BADFLAGS:
370: return "Invalid argument";
371: #endif
372: #ifdef EAI_FAMILY
373: case EAI_FAMILY:
374: return "Address family not supported";
375: #endif
376: #ifdef EAI_MEMORY
377: case EAI_MEMORY:
378: return "Not enough memory";
379: #endif
380: #ifdef EAI_NODATA
381: case EAI_NODATA:
382: return "No host data of that type was found";
383: #endif
384: #ifdef EAI_SERVICE
385: case EAI_SERVICE:
386: return "Class type not found";
387: #endif
388: #ifdef EAI_SOCKTYPE
389: case EAI_SOCKTYPE:
390: return "Socket type not supported";
391: #endif
392: default:
393: return "Unknown server error";
394: }
395: #endif /* HAVE_HSTRERROR */
396: }
397:
398: static int gethostnameinfo(const struct sockaddr *sa,
399: char *node,
400: size_t nodelen,
401: int flags)
402: {
403: int ret = -1;
404: char *p = NULL;
405:
406: if (!(flags & NI_NUMERICHOST)) {
407: struct hostent *hp = gethostbyaddr(
408: (void *)&((struct sockaddr_in *)sa)->sin_addr,
409: sizeof (struct in_addr),
410: sa->sa_family);
411: ret = check_hostent_err(hp);
412: if (ret == 0) {
413: /* Name looked up successfully. */
414: ret = snprintf(node, nodelen, "%s", hp->h_name);
415: if (ret < 0 || (size_t)ret >= nodelen) {
416: return EAI_MEMORY;
417: }
418: if (flags & NI_NOFQDN) {
419: p = strchr(node,'.');
420: if (p) {
421: *p = '\0';
422: }
423: }
424: return 0;
425: }
426:
427: if (flags & NI_NAMEREQD) {
428: /* If we require a name and didn't get one,
429: * automatically fail. */
430: return ret;
431: }
432: /* Otherwise just fall into the numeric host code... */
433: }
434: p = inet_ntoa(((struct sockaddr_in *)sa)->sin_addr);
435: ret = snprintf(node, nodelen, "%s", p);
436: if (ret < 0 || (size_t)ret >= nodelen) {
437: return EAI_MEMORY;
438: }
439: return 0;
440: }
441:
442: static int getservicenameinfo(const struct sockaddr *sa,
443: char *service,
444: size_t servicelen,
445: int flags)
446: {
447: int ret = -1;
448: int port = ntohs(((struct sockaddr_in *)sa)->sin_port);
449:
450: if (!(flags & NI_NUMERICSERV)) {
451: struct servent *se = getservbyport(
452: port,
453: (flags & NI_DGRAM) ? "udp" : "tcp");
454: if (se && se->s_name) {
455: /* Service name looked up successfully. */
456: ret = snprintf(service, servicelen, "%s", se->s_name);
457: if (ret < 0 || (size_t)ret >= servicelen) {
458: return EAI_MEMORY;
459: }
460: return 0;
461: }
462: /* Otherwise just fall into the numeric service code... */
463: }
464: ret = snprintf(service, servicelen, "%d", port);
465: if (ret < 0 || (size_t)ret >= servicelen) {
466: return EAI_MEMORY;
467: }
468: return 0;
469: }
470:
471: /*
472: * Convert an ipv4 address to a hostname.
473: *
474: * Bugs: - No IPv6 support.
475: */
476: int getnameinfo(const struct sockaddr *sa, socklen_t salen,
477: char *node, size_t nodelen,
478: char *service, size_t servicelen, int flags)
479: {
480:
481: /* Invalid arguments. */
482: if (sa == NULL || (node == NULL && service == NULL)) {
483: return EAI_FAIL;
484: }
485:
486: if (sa->sa_family != AF_INET) {
487: return EAI_FAIL;
488: }
489:
490: if (salen < (socklen_t)sizeof (struct sockaddr_in)) {
491: return EAI_FAIL;
492: }
493:
494: if (node) {
495: int ret = gethostnameinfo(sa, node, nodelen, flags);
496: if (ret)
497: return ret;
498: }
499:
500: if (service) {
501: return getservicenameinfo(sa, service, servicelen, flags);
502: }
503: return 0;
504: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to getaddrinfo.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / lib