?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / cmd-inet / usr.lib / mdnsd / mDNSUNP.c
blob0b174e8301b1e61e4bb1bdd83e72a5d60011695d
1 /* -*- Mode: C; tab-width: 4 -*-
2 *
3 * Copyright (c) 2002-2004 Apple Computer, Inc. All rights reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #include "mDNSUNP.h"
19
20 #include <errno.h>
21 #include <assert.h>
22 #include <string.h>
23 #include <stdlib.h>
24 #include <sys/uio.h>
25 #include <sys/ioctl.h>
26 #include <signal.h>
27 #include <unistd.h>
28 #include <stdio.h>
29
30 /* Some weird platforms derived from 4.4BSD Lite (e.g. EFI) need the ALIGN(P)
31 macro, usually defined in <sys/param.h> or someplace like that, to make sure the
32 CMSG_NXTHDR macro is well-formed. On such platforms, the symbol NEED_ALIGN_MACRO
33 should be set to the name of the header to include to get the ALIGN(P) macro.
34 */
35 #ifdef NEED_ALIGN_MACRO
36 #include NEED_ALIGN_MACRO
37 #endif
38
39 /* Solaris defined SIOCGIFCONF etc in <sys/sockio.h> but
40 other platforms don't even have that include file. So,
41 if we haven't yet got a definition, let's try to find
42 <sys/sockio.h>.
43 */
44
45 #ifndef SIOCGIFCONF
46 #include <sys/sockio.h>
47 #endif
48
49 /* sockaddr_dl is only referenced if we're using IP_RECVIF,
50 so only include the header in that case.
51 */
52
53 #ifdef IP_RECVIF
54 #include <net/if_dl.h>
55 #endif
56
57 #if defined(AF_INET6) && HAVE_IPV6 && !HAVE_LINUX
58 #if !HAVE_SOLARIS
59 #include <net/if_var.h>
60 #else
61 #include <alloca.h>
62 #endif /* !HAVE_SOLARIS */
63 #include <netinet/in_var.h>
64 // Note: netinet/in_var.h implicitly includes netinet6/in6_var.h for us
65 #endif
66
67 #if defined(AF_INET6) && HAVE_IPV6 && HAVE_LINUX
68 #include <netdb.h>
69 #include <arpa/inet.h>
70
71 /* Converts a prefix length to IPv6 network mask */
72 void plen_to_mask(int plen, char *addr) {
73 int i;
74 int colons=7; /* Number of colons in IPv6 address */
75 int bits_in_block=16; /* Bits per IPv6 block */
76 for(i=0; i<=colons; i++) {
77 int block, ones=0xffff, ones_in_block;
78 if (plen>bits_in_block) ones_in_block=bits_in_block;
79 else ones_in_block=plen;
80 block = ones & (ones << (bits_in_block-ones_in_block));
81 i==0 ? sprintf(addr, "%x", block) : sprintf(addr, "%s:%x", addr, block);
82 plen -= ones_in_block;
83 }
84 }
85
86 /* Gets IPv6 interface information from the /proc filesystem in linux*/
87 struct ifi_info *get_ifi_info_linuxv6(int family, int doaliases)
88 {
89 struct ifi_info *ifi, *ifihead, **ifipnext, *ifipold, **ifiptr;
90 FILE *fp = NULL;
91 char addr[8][5];
92 int flags, myflags, index, plen, scope;
93 char ifname[9], lastname[IFNAMSIZ];
94 char addr6[32+7+1]; /* don't forget the seven ':' */
95 struct addrinfo hints, *res0;
96 int err;
97 int sockfd = -1;
98 struct ifreq ifr;
99
100 res0=NULL;
101 ifihead = NULL;
102 ifipnext = &ifihead;
103 lastname[0] = 0;
104
105 if ((fp = fopen(PROC_IFINET6_PATH, "r")) != NULL) {
106 sockfd = socket(AF_INET6, SOCK_DGRAM, 0);
107 if (sockfd < 0) {
108 goto gotError;
109 }
110 while (fscanf(fp,
111 "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %8s\n",
112 addr[0],addr[1],addr[2],addr[3],
113 addr[4],addr[5],addr[6],addr[7],
114 &index, &plen, &scope, &flags, ifname) != EOF) {
115
116 myflags = 0;
117 if (strncmp(lastname, ifname, IFNAMSIZ) == 0) {
118 if (doaliases == 0)
119 continue; /* already processed this interface */
120 myflags = IFI_ALIAS;
121 }
122 memcpy(lastname, ifname, IFNAMSIZ);
123 ifi = (struct ifi_info*)calloc(1, sizeof(struct ifi_info));
124 if (ifi == NULL) {
125 goto gotError;
126 }
127
128 ifipold = *ifipnext; /* need this later */
129 ifiptr = ifipnext;
130 *ifipnext = ifi; /* prev points to this new one */
131 ifipnext = &ifi->ifi_next; /* pointer to next one goes here */
132
133 sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
134 addr[0],addr[1],addr[2],addr[3],
135 addr[4],addr[5],addr[6],addr[7]);
136
137 /* Add address of the interface */
138 memset(&hints, 0, sizeof(hints));
139 hints.ai_family = AF_INET6;
140 hints.ai_flags = AI_NUMERICHOST;
141 err = getaddrinfo(addr6, NULL, &hints, &res0);
142 if (err) {
143 goto gotError;
144 }
145 ifi->ifi_addr = calloc(1, sizeof(struct sockaddr_in6));
146 if (ifi->ifi_addr == NULL) {
147 goto gotError;
148 }
149 memcpy(ifi->ifi_addr, res0->ai_addr, sizeof(struct sockaddr_in6));
150
151 /* Add netmask of the interface */
152 char ipv6addr[INET6_ADDRSTRLEN];
153 plen_to_mask(plen, ipv6addr);
154 ifi->ifi_netmask = calloc(1, sizeof(struct sockaddr_in6));
155 if (ifi->ifi_netmask == NULL) {
156 goto gotError;
157 }
158
159 ((struct sockaddr_in6 *)ifi->ifi_netmask)->sin6_family=family;
160 ((struct sockaddr_in6 *)ifi->ifi_netmask)->sin6_scope_id=scope;
161 inet_pton(family, ipv6addr, &((struct sockaddr_in6 *)ifi->ifi_netmask)->sin6_addr);
162
163 /* Add interface name */
164 memcpy(ifi->ifi_name, ifname, IFI_NAME);
165
166 /* Add interface index */
167 ifi->ifi_index = index;
168
169 /* Add interface flags*/
170 memcpy(ifr.ifr_name, ifname, IFNAMSIZ);
171 if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0) {
172 if (errno == EADDRNOTAVAIL) {
173 /*
174 * If the main interface is configured with no IP address but
175 * an alias interface exists with an IP address, you get
176 * EADDRNOTAVAIL for the main interface
177 */
178 free(ifi->ifi_addr);
179 free(ifi->ifi_netmask);
180 free(ifi);
181 ifipnext = ifiptr;
182 *ifipnext = ifipold;
183 continue;
184 } else {
185 goto gotError;
186 }
187 }
188 ifi->ifi_flags = ifr.ifr_flags;
189 freeaddrinfo(res0);
190 res0=NULL;
191 }
192 }
193 goto done;
194
195 gotError:
196 if (ifihead != NULL) {
197 free_ifi_info(ifihead);
198 ifihead = NULL;
199 }
200 if (res0 != NULL) {
201 freeaddrinfo(res0);
202 res0=NULL;
203 }
204 done:
205 if (sockfd != -1) {
206 assert(close(sockfd) == 0);
207 }
208 if (fp != NULL) {
209 fclose(fp);
210 }
211 return(ifihead); /* pointer to first structure in linked list */
212 }
213 #endif // defined(AF_INET6) && HAVE_IPV6 && HAVE_LINUX
214
215 #if HAVE_SOLARIS
216
217 /*
218 * Converts prefix length to network mask. Assumes
219 * addr points to a zeroed out buffer and prefix <= sizeof(addr)
220 * Unlike plen_to_mask returns netmask in binary form and not
221 * in text form.
222 */
223 static void plen_to_netmask(int prefix, unsigned char *addr) {
224 for (; prefix > 8; prefix -= 8)
225 *addr++ = 0xff;
226 for (; prefix > 0; prefix--)
227 *addr = (*addr >> 1) | 0x80;
228 }
229
230 /*
231 * This function goes through all the IP interfaces associated with a
232 * physical interface and finds the best matched one for use by mDNS.
233 * Returns NULL when none of the IP interfaces associated with a physical
234 * interface are usable. Otherwise returns the best matched interface
235 * information and a pointer to the best matched lifreq.
236 */
237 struct ifi_info *
238 select_src_ifi_info_solaris(int sockfd, int numifs,
239 struct lifreq *lifrlist, const char *curifname,
240 struct lifreq **best_lifr)
241 {
242 struct lifreq *lifr;
243 struct lifreq lifrcopy;
244 struct ifi_info *ifi;
245 char *chptr;
246 char cmpifname[LIFNAMSIZ];
247 int i;
248 uint64_t best_lifrflags = 0;
249 uint64_t ifflags;
250
251 *best_lifr = NULL;
252
253 /*
254 * Check all logical interfaces associated with the physical
255 * interface and figure out which one works best for us.
256 */
257 for (i = numifs, lifr = lifrlist; i > 0; --i, ++lifr) {
258
259 if (strlcpy(cmpifname, lifr->lifr_name, sizeof(cmpifname)) >= sizeof(cmpifname))
260 continue; /* skip interface */
261
262 /* Strip logical interface number before checking ifname */
263 if ((chptr = strchr(cmpifname, ':')) != NULL)
264 *chptr = '\0';
265
266 /*
267 * Check ifname to see if the logical interface is associated
268 * with the physical interface we are interested in.
269 */
270 if (strcmp(cmpifname, curifname) != 0)
271 continue;
272
273 lifrcopy = *lifr;
274 if (ioctl(sockfd, SIOCGLIFFLAGS, &lifrcopy) < 0) {
275 /* interface removed */
276 if (errno == ENXIO)
277 continue;
278 return(NULL);
279 }
280 ifflags = lifrcopy.lifr_flags;
281
282 /* ignore address if not up */
283 if ((ifflags & IFF_UP) == 0)
284 continue;
285 /*
286 * Avoid address if any of the following flags are set:
287 * IFF_NOXMIT: no packets transmitted over interface
288 * IFF_NOLOCAL: no address
289 * IFF_PRIVATE: is not advertised
290 */
291 if (ifflags & (IFF_NOXMIT | IFF_NOLOCAL | IFF_PRIVATE))
292 continue;
293
294 /* A DHCP client will have IFF_UP set yet the address is zero. Ignore */
295 if (lifr->lifr_addr.ss_family == AF_INET) {
296 struct sockaddr_in *sinptr;
297
298 sinptr = (struct sockaddr_in *) &lifr->lifr_addr;
299 if (sinptr->sin_addr.s_addr == INADDR_ANY)
300 continue;
301 }
302
303 if (*best_lifr != NULL) {
304 /*
305 * Check if we found a better interface by checking
306 * the flags. If flags are identical we prefer
307 * the new found interface.
308 */
309 uint64_t diff_flags = best_lifrflags ^ ifflags;
310
311 /* If interface has a different set of flags */
312 if (diff_flags != 0) {
313 /* Check flags in increasing order of ones we prefer */
314
315 /* Address temporary? */
316 if ((diff_flags & IFF_TEMPORARY) &&
317 (ifflags & IFF_TEMPORARY))
318 continue;
319 /* Deprecated address? */
320 if ((diff_flags & IFF_DEPRECATED) &&
321 (ifflags & IFF_DEPRECATED))
322 continue;
323 /* Last best-matched interface address has preferred? */
324 if ((diff_flags & IFF_PREFERRED) &&
325 ((ifflags & IFF_PREFERRED) == 0))
326 continue;
327 }
328 }
329
330 /* Set best match interface & flags */
331 *best_lifr = lifr;
332 best_lifrflags = ifflags;
333 }
334
335 if (*best_lifr == NULL)
336 return(NULL);
337
338 /* Found a match: return the interface information */
339 ifi = calloc(1, sizeof(struct ifi_info));
340 if (ifi == NULL)
341 return(NULL);
342
343 ifi->ifi_flags = best_lifrflags;
344 ifi->ifi_index = if_nametoindex((*best_lifr)->lifr_name);
345 if (strlcpy(ifi->ifi_name, (*best_lifr)->lifr_name, sizeof(ifi->ifi_name)) >= sizeof(ifi->ifi_name)) {
346 free(ifi);
347 return(NULL);
348 }
349 return(ifi);
350 }
351
352 /*
353 * Returns a list of IP interface information on Solaris. The function
354 * returns all IP interfaces on the system with IPv4 address assigned
355 * when passed AF_INET and returns IP interfaces with IPv6 address assigned
356 * when AF_INET6 is passed.
357 */
358 struct ifi_info *get_ifi_info_solaris(int family)
359 {
360 struct ifi_info *ifi, *ifihead, **ifipnext;
361 int sockfd;
362 int len;
363 char *buf;
364 char *cptr;
365 char ifname[LIFNAMSIZ], cmpifname[LIFNAMSIZ];
366 struct sockaddr_in *sinptr;
367 struct lifnum lifn;
368 struct lifconf lifc;
369 struct lifreq *lifrp, *best_lifr;
370 struct lifreq lifrcopy;
371 int numifs, nlifr, n;
372 #if defined(AF_INET6) && HAVE_IPV6
373 struct sockaddr_in6 *sinptr6;
374 #endif
375
376 ifihead = NULL;
377
378 sockfd = socket(family, SOCK_DGRAM, 0);
379 if (sockfd < 0)
380 goto gotError;
381
382 again:
383 lifn.lifn_family = family;
384 lifn.lifn_flags = 0;
385 if (ioctl(sockfd, SIOCGLIFNUM, &lifn) < 0)
386 goto gotError;
387 /*
388 * Pad interface count to detect & retrieve any
389 * additional interfaces between IFNUM & IFCONF calls.
390 */
391 lifn.lifn_count += 4;
392 numifs = lifn.lifn_count;
393 len = numifs * sizeof (struct lifreq);
394 buf = alloca(len);
395
396 lifc.lifc_family = family;
397 lifc.lifc_len = len;
398 lifc.lifc_buf = buf;
399 lifc.lifc_flags = 0;
400
401 if (ioctl(sockfd, SIOCGLIFCONF, &lifc) < 0)
402 goto gotError;
403
404 nlifr = lifc.lifc_len / sizeof(struct lifreq);
405 if (nlifr >= numifs)
406 goto again;
407
408 lifrp = lifc.lifc_req;
409 ifipnext = &ifihead;
410
411 for (n = nlifr; n > 0; n--, lifrp++) {
412
413 if (lifrp->lifr_addr.ss_family != family)
414 continue;
415
416 /*
417 * See if we have already processed the interface
418 * by checking the interface names.
419 */
420 if (strlcpy(ifname, lifrp->lifr_name, sizeof(ifname)) >= sizeof(ifname))
421 goto gotError;
422 if ((cptr = strchr(ifname, ':')) != NULL)
423 *cptr = '\0';
424
425 /*
426 * If any of the interfaces found so far share the physical
427 * interface name then we have already processed the interface.
428 */
429 for (ifi = ifihead; ifi != NULL; ifi = ifi->ifi_next) {
430
431 /* Retrieve physical interface name */
432 (void) strlcpy(cmpifname, ifi->ifi_name, sizeof(cmpifname));
433
434 /* Strip logical interface number before checking ifname */
435 if ((cptr = strchr(cmpifname, ':')) != NULL)
436 *cptr = '\0';
437
438 if (strcmp(cmpifname, ifname) == 0)
439 break;
440 }
441 if (ifi != NULL)
442 continue; /* already processed */
443
444 /*
445 * New interface, find the one with the preferred source
446 * address for our use in Multicast DNS.
447 */
448 if ((ifi = select_src_ifi_info_solaris(sockfd, nlifr,
449 lifc.lifc_req, ifname, &best_lifr)) == NULL)
450 continue;
451
452 assert(best_lifr != NULL);
453 assert((best_lifr->lifr_addr.ss_family == AF_INET6) ||
454 (best_lifr->lifr_addr.ss_family == AF_INET));
455
456 switch (best_lifr->lifr_addr.ss_family) {
457
458 #if defined(AF_INET6) && HAVE_IPV6
459 case AF_INET6:
460 sinptr6 = (struct sockaddr_in6 *) &best_lifr->lifr_addr;
461 ifi->ifi_addr = malloc(sizeof(struct sockaddr_in6));
462 if (ifi->ifi_addr == NULL)
463 goto gotError;
464 memcpy(ifi->ifi_addr, sinptr6, sizeof(struct sockaddr_in6));
465
466 ifi->ifi_netmask = calloc(1, sizeof(struct sockaddr_in6));
467 if (ifi->ifi_netmask == NULL)
468 goto gotError;
469 sinptr6 = (struct sockaddr_in6 *)(ifi->ifi_netmask);
470 sinptr6->sin6_family = AF_INET6;
471 plen_to_netmask(best_lifr->lifr_addrlen,
472 (unsigned char *) &(sinptr6->sin6_addr));
473 break;
474 #endif
475
476 case AF_INET:
477 sinptr = (struct sockaddr_in *) &best_lifr->lifr_addr;
478 ifi->ifi_addr = malloc(sizeof(struct sockaddr_in));
479 if (ifi->ifi_addr == NULL)
480 goto gotError;
481
482 memcpy(ifi->ifi_addr, sinptr, sizeof(struct sockaddr_in));
483
484 lifrcopy = *best_lifr;
485 if (ioctl(sockfd, SIOCGLIFNETMASK, &lifrcopy) < 0) {
486 /* interface removed */
487 if (errno == ENXIO) {
488 free(ifi->ifi_addr);
489 free(ifi);
490 continue;
491 }
492 goto gotError;
493 }
494
495 ifi->ifi_netmask = malloc(sizeof(struct sockaddr_in));
496 if (ifi->ifi_netmask == NULL)
497 goto gotError;
498 sinptr = (struct sockaddr_in *) &lifrcopy.lifr_addr;
499 sinptr->sin_family = AF_INET;
500 memcpy(ifi->ifi_netmask, sinptr, sizeof(struct sockaddr_in));
501 break;
502
503 default:
504 /* never reached */
505 break;
506 }
507
508 *ifipnext = ifi; /* prev points to this new one */
509 ifipnext = &ifi->ifi_next; /* pointer to next one goes here */
510 }
511
512 (void) close(sockfd);
513 return(ifihead); /* pointer to first structure in linked list */
514
515 gotError:
516 if (sockfd != -1)
517 (void) close(sockfd);
518 if (ifihead != NULL)
519 free_ifi_info(ifihead);
520 return(NULL);
521 }
522
523 #endif /* HAVE_SOLARIS */
524
525 struct ifi_info *get_ifi_info(int family, int doaliases)
526 {
527 int junk;
528 struct ifi_info *ifi, *ifihead, **ifipnext, *ifipold, **ifiptr;
529 int sockfd, sockf6, len, lastlen, flags, myflags;
530 #ifdef NOT_HAVE_IF_NAMETOINDEX
531 int index = 200;
532 #endif
533 char *ptr, *buf, lastname[IFNAMSIZ], *cptr;
534 struct ifconf ifc;
535 struct ifreq *ifr, ifrcopy;
536 struct sockaddr_in *sinptr;
537
538 #if defined(AF_INET6) && HAVE_IPV6
539 struct sockaddr_in6 *sinptr6;
540 #endif
541
542 #if defined(AF_INET6) && HAVE_IPV6 && HAVE_LINUX
543 if (family == AF_INET6) return get_ifi_info_linuxv6(family, doaliases);
544 #elif HAVE_SOLARIS
545 return get_ifi_info_solaris(family);
546 #endif
547
548 sockfd = -1;
549 sockf6 = -1;
550 buf = NULL;
551 ifihead = NULL;
552
553 sockfd = socket(AF_INET, SOCK_DGRAM, 0);
554 if (sockfd < 0) {
555 goto gotError;
556 }
557
558 lastlen = 0;
559 len = 100 * sizeof(struct ifreq); /* initial buffer size guess */
560 for ( ; ; ) {
561 buf = (char*)malloc(len);
562 if (buf == NULL) {
563 goto gotError;
564 }
565 ifc.ifc_len = len;
566 ifc.ifc_buf = buf;
567 if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
568 if (errno != EINVAL || lastlen != 0) {
569 goto gotError;
570 }
571 } else {
572 if (ifc.ifc_len == lastlen)
573 break; /* success, len has not changed */
574 lastlen = ifc.ifc_len;
575 }
576 len += 10 * sizeof(struct ifreq); /* increment */
577 free(buf);
578 }
579 ifihead = NULL;
580 ifipnext = &ifihead;
581 lastname[0] = 0;
582 /* end get_ifi_info1 */
583
584 /* include get_ifi_info2 */
585 for (ptr = buf; ptr < buf + ifc.ifc_len; ) {
586 ifr = (struct ifreq *) ptr;
587
588 /* Advance to next one in buffer */
589 if (sizeof(struct ifreq) > sizeof(ifr->ifr_name) + GET_SA_LEN(ifr->ifr_addr))
590 ptr += sizeof(struct ifreq);
591 else
592 ptr += sizeof(ifr->ifr_name) + GET_SA_LEN(ifr->ifr_addr);
593
594 // fprintf(stderr, "intf %p name=%s AF=%d\n", index, ifr->ifr_name, ifr->ifr_addr.sa_family);
595
596 if (ifr->ifr_addr.sa_family != family)
597 continue; /* ignore if not desired address family */
598
599 myflags = 0;
600 if ( (cptr = strchr(ifr->ifr_name, ':')) != NULL)
601 *cptr = 0; /* replace colon will null */
602 if (strncmp(lastname, ifr->ifr_name, IFNAMSIZ) == 0) {
603 if (doaliases == 0)
604 continue; /* already processed this interface */
605 myflags = IFI_ALIAS;
606 }
607 memcpy(lastname, ifr->ifr_name, IFNAMSIZ);
608
609 ifrcopy = *ifr;
610 if (ioctl(sockfd, SIOCGIFFLAGS, &ifrcopy) < 0) {
611 goto gotError;
612 }
613
614 flags = ifrcopy.ifr_flags;
615 if ((flags & IFF_UP) == 0)
616 continue; /* ignore if interface not up */
617
618 ifi = (struct ifi_info*)calloc(1, sizeof(struct ifi_info));
619 if (ifi == NULL) {
620 goto gotError;
621 }
622 ifipold = *ifipnext; /* need this later */
623 ifiptr = ifipnext;
624 *ifipnext = ifi; /* prev points to this new one */
625 ifipnext = &ifi->ifi_next; /* pointer to next one goes here */
626
627 ifi->ifi_flags = flags; /* IFF_xxx values */
628 ifi->ifi_myflags = myflags; /* IFI_xxx values */
629 #ifndef NOT_HAVE_IF_NAMETOINDEX
630 ifi->ifi_index = if_nametoindex(ifr->ifr_name);
631 #else
632 ifrcopy = *ifr;
633 #ifdef SIOCGIFINDEX
634 if ( 0 >= ioctl(sockfd, SIOCGIFINDEX, &ifrcopy))
635 ifi->ifi_index = ifrcopy.ifr_index;
636 else
637 #endif
638 ifi->ifi_index = index++; /* SIOCGIFINDEX is broken on Solaris 2.5ish, so fake it */
639 #endif
640 memcpy(ifi->ifi_name, ifr->ifr_name, IFI_NAME);
641 ifi->ifi_name[IFI_NAME-1] = '\0';
642 /* end get_ifi_info2 */
643 /* include get_ifi_info3 */
644 switch (ifr->ifr_addr.sa_family) {
645 case AF_INET:
646 sinptr = (struct sockaddr_in *) &ifr->ifr_addr;
647 if (ifi->ifi_addr == NULL) {
648 ifi->ifi_addr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
649 if (ifi->ifi_addr == NULL) {
650 goto gotError;
651 }
652 memcpy(ifi->ifi_addr, sinptr, sizeof(struct sockaddr_in));
653
654 #ifdef SIOCGIFNETMASK
655 if (ioctl(sockfd, SIOCGIFNETMASK, &ifrcopy) < 0) {
656 if (errno == EADDRNOTAVAIL) {
657 /*
658 * If the main interface is configured with no IP address but
659 * an alias interface exists with an IP address, you get
660 * EADDRNOTAVAIL for the main interface
661 */
662 free(ifi->ifi_addr);
663 free(ifi);
664 ifipnext = ifiptr;
665 *ifipnext = ifipold;
666 continue;
667 } else {
668 goto gotError;
669 }
670 }
671
672 ifi->ifi_netmask = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
673 if (ifi->ifi_netmask == NULL) goto gotError;
674 sinptr = (struct sockaddr_in *) &ifrcopy.ifr_addr;
675 /* The BSD ioctls (including Mac OS X) stick some weird values in for sin_len and sin_family */
676 #ifndef NOT_HAVE_SA_LEN
677 sinptr->sin_len = sizeof(struct sockaddr_in);
678 #endif
679 sinptr->sin_family = AF_INET;
680 memcpy(ifi->ifi_netmask, sinptr, sizeof(struct sockaddr_in));
681 #endif
682
683 #ifdef SIOCGIFBRDADDR
684 if (flags & IFF_BROADCAST) {
685 if (ioctl(sockfd, SIOCGIFBRDADDR, &ifrcopy) < 0) {
686 goto gotError;
687 }
688 sinptr = (struct sockaddr_in *) &ifrcopy.ifr_broadaddr;
689 /* The BSD ioctls (including Mac OS X) stick some weird values in for sin_len and sin_family */
690 #ifndef NOT_HAVE_SA_LEN
691 sinptr->sin_len = sizeof( struct sockaddr_in );
692 #endif
693 sinptr->sin_family = AF_INET;
694 ifi->ifi_brdaddr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
695 if (ifi->ifi_brdaddr == NULL) {
696 goto gotError;
697 }
698 memcpy(ifi->ifi_brdaddr, sinptr, sizeof(struct sockaddr_in));
699 }
700 #endif
701
702 #ifdef SIOCGIFDSTADDR
703 if (flags & IFF_POINTOPOINT) {
704 if (ioctl(sockfd, SIOCGIFDSTADDR, &ifrcopy) < 0) {
705 goto gotError;
706 }
707 sinptr = (struct sockaddr_in *) &ifrcopy.ifr_dstaddr;
708 /* The BSD ioctls (including Mac OS X) stick some weird values in for sin_len and sin_family */
709 #ifndef NOT_HAVE_SA_LEN
710 sinptr->sin_len = sizeof( struct sockaddr_in );
711 #endif
712 sinptr->sin_family = AF_INET;
713 ifi->ifi_dstaddr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
714 if (ifi->ifi_dstaddr == NULL) {
715 goto gotError;
716 }
717 memcpy(ifi->ifi_dstaddr, sinptr, sizeof(struct sockaddr_in));
718 }
719 #endif
720 }
721 break;
722
723 #if defined(AF_INET6) && HAVE_IPV6
724 case AF_INET6:
725 sinptr6 = (struct sockaddr_in6 *) &ifr->ifr_addr;
726 if (ifi->ifi_addr == NULL) {
727 ifi->ifi_addr = calloc(1, sizeof(struct sockaddr_in6));
728 if (ifi->ifi_addr == NULL) {
729 goto gotError;
730 }
731
732 /* Some platforms (*BSD) inject the prefix in IPv6LL addresses */
733 /* We need to strip that out */
734 if (IN6_IS_ADDR_LINKLOCAL(&sinptr6->sin6_addr))
735 sinptr6->sin6_addr.s6_addr[2] = sinptr6->sin6_addr.s6_addr[3] = 0;
736 memcpy(ifi->ifi_addr, sinptr6, sizeof(struct sockaddr_in6));
737
738 #ifdef SIOCGIFNETMASK_IN6
739 {
740 struct in6_ifreq ifr6;
741 if (sockf6 == -1)
742 sockf6 = socket(AF_INET6, SOCK_DGRAM, 0);
743 memset(&ifr6, 0, sizeof(ifr6));
744 memcpy(&ifr6.ifr_name, &ifr->ifr_name, sizeof(ifr6.ifr_name ));
745 memcpy(&ifr6.ifr_ifru.ifru_addr, &ifr->ifr_addr, sizeof(ifr6.ifr_ifru.ifru_addr));
746 if (ioctl(sockf6, SIOCGIFNETMASK_IN6, &ifr6) < 0) {
747 if (errno == EADDRNOTAVAIL) {
748 /*
749 * If the main interface is configured with no IP address but
750 * an alias interface exists with an IP address, you get
751 * EADDRNOTAVAIL for the main interface
752 */
753 free(ifi->ifi_addr);
754 free(ifi);
755 ifipnext = ifiptr;
756 *ifipnext = ifipold;
757 continue;
758 } else {
759 goto gotError;
760 }
761 }
762 ifi->ifi_netmask = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in6));
763 if (ifi->ifi_netmask == NULL) goto gotError;
764 sinptr6 = (struct sockaddr_in6 *) &ifr6.ifr_ifru.ifru_addr;
765 memcpy(ifi->ifi_netmask, sinptr6, sizeof(struct sockaddr_in6));
766 }
767 #endif
768 }
769 break;
770 #endif
771
772 default:
773 break;
774 }
775 }
776 goto done;
777
778 gotError:
779 if (ifihead != NULL) {
780 free_ifi_info(ifihead);
781 ifihead = NULL;
782 }
783
784 done:
785 if (buf != NULL) {
786 free(buf);
787 }
788 if (sockfd != -1) {
789 junk = close(sockfd);
790 assert(junk == 0);
791 }
792 if (sockf6 != -1) {
793 junk = close(sockf6);
794 assert(junk == 0);
795 }
796 return(ifihead); /* pointer to first structure in linked list */
797 }
798 /* end get_ifi_info3 */
799
800 /* include free_ifi_info */
801 void
802 free_ifi_info(struct ifi_info *ifihead)
803 {
804 struct ifi_info *ifi, *ifinext;
805
806 for (ifi = ifihead; ifi != NULL; ifi = ifinext) {
807 if (ifi->ifi_addr != NULL)
808 free(ifi->ifi_addr);
809 if (ifi->ifi_netmask != NULL)
810 free(ifi->ifi_netmask);
811 if (ifi->ifi_brdaddr != NULL)
812 free(ifi->ifi_brdaddr);
813 if (ifi->ifi_dstaddr != NULL)
814 free(ifi->ifi_dstaddr);
815 ifinext = ifi->ifi_next; /* can't fetch ifi_next after free() */
816 free(ifi); /* the ifi_info{} itself */
817 }
818 }
819 /* end free_ifi_info */
820
821 ssize_t
822 recvfrom_flags(int fd, void *ptr, size_t nbytes, int *flagsp,
823 struct sockaddr *sa, socklen_t *salenptr, struct my_in_pktinfo *pktp, u_char *ttl)
824 {
825 struct msghdr msg;
826 struct iovec iov[1];
827 ssize_t n;
828
829 #ifdef CMSG_FIRSTHDR
830 struct cmsghdr *cmptr;
831 union {
832 struct cmsghdr cm;
833 char control[1024];
834 pad64_t align8; /* ensure structure is 8-byte aligned on sparc */
835 } control_un;
836
837 *ttl = 255; // If kernel fails to provide TTL data then assume the TTL was 255 as it should be
838
839 msg.msg_control = (void *) control_un.control;
840 msg.msg_controllen = sizeof(control_un.control);
841 msg.msg_flags = 0;
842 #else
843 memset(&msg, 0, sizeof(msg)); /* make certain msg_accrightslen = 0 */
844 #endif /* CMSG_FIRSTHDR */
845
846 msg.msg_name = (char *) sa;
847 msg.msg_namelen = *salenptr;
848 iov[0].iov_base = (char *)ptr;
849 iov[0].iov_len = nbytes;
850 msg.msg_iov = iov;
851 msg.msg_iovlen = 1;
852
853 if ( (n = recvmsg(fd, &msg, *flagsp)) < 0)
854 return(n);
855
856 *salenptr = msg.msg_namelen; /* pass back results */
857 if (pktp) {
858 /* 0.0.0.0, i/f = -1 */
859 /* We set the interface to -1 so that the caller can
860 tell whether we returned a meaningful value or
861 just some default. Previously this code just
862 set the value to 0, but I'm concerned that 0
863 might be a valid interface value.
864 */
865 memset(pktp, 0, sizeof(struct my_in_pktinfo));
866 pktp->ipi_ifindex = -1;
867 }
868 /* end recvfrom_flags1 */
869
870 /* include recvfrom_flags2 */
871 #ifndef CMSG_FIRSTHDR
872 #warning CMSG_FIRSTHDR not defined. Will not be able to determine destination address, received interface, etc.
873 *flagsp = 0; /* pass back results */
874 return(n);
875 #else
876
877 *flagsp = msg.msg_flags; /* pass back results */
878 if (msg.msg_controllen < (socklen_t)sizeof(struct cmsghdr) ||
879 (msg.msg_flags & MSG_CTRUNC) || pktp == NULL)
880 return(n);
881
882 for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL;
883 cmptr = CMSG_NXTHDR(&msg, cmptr)) {
884
885 #ifdef IP_PKTINFO
886 #if in_pktinfo_definition_is_missing
887 struct in_pktinfo
888 {
889 int ipi_ifindex;
890 struct in_addr ipi_spec_dst;
891 struct in_addr ipi_addr;
892 };
893 #endif
894 if (cmptr->cmsg_level == IPPROTO_IP &&
895 cmptr->cmsg_type == IP_PKTINFO) {
896 struct in_pktinfo *tmp;
897 struct sockaddr_in *sin = (struct sockaddr_in*)&pktp->ipi_addr;
898
899 tmp = (struct in_pktinfo *) CMSG_DATA(cmptr);
900 sin->sin_family = AF_INET;
901 sin->sin_addr = tmp->ipi_addr;
902 sin->sin_port = 0;
903 pktp->ipi_ifindex = tmp->ipi_ifindex;
904 continue;
905 }
906 #endif
907
908 #ifdef IP_RECVDSTADDR
909 if (cmptr->cmsg_level == IPPROTO_IP &&
910 cmptr->cmsg_type == IP_RECVDSTADDR) {
911 struct sockaddr_in *sin = (struct sockaddr_in*)&pktp->ipi_addr;
912
913 sin->sin_family = AF_INET;
914 sin->sin_addr = *(struct in_addr*)CMSG_DATA(cmptr);
915 sin->sin_port = 0;
916 continue;
917 }
918 #endif
919
920 #ifdef IP_RECVIF
921 if (cmptr->cmsg_level == IPPROTO_IP &&
922 cmptr->cmsg_type == IP_RECVIF) {
923 struct sockaddr_dl *sdl = (struct sockaddr_dl *) CMSG_DATA(cmptr);
924 #ifndef HAVE_BROKEN_RECVIF_NAME
925 int nameLen = (sdl->sdl_nlen < IFI_NAME - 1) ? sdl->sdl_nlen : (IFI_NAME - 1);
926 strncpy(pktp->ipi_ifname, sdl->sdl_data, nameLen);
927 #endif
928 /*
929 * the is memcpy used for sparc? no idea;)
930 * pktp->ipi_ifindex = sdl->sdl_index;
931 */
932 (void) memcpy(&pktp->ipi_ifindex, CMSG_DATA(cmptr), sizeof(uint_t));
933 #ifdef HAVE_BROKEN_RECVIF_NAME
934 if (sdl->sdl_index == 0) {
935 pktp->ipi_ifindex = *(uint_t*)sdl;
936 }
937 #endif
938 assert(pktp->ipi_ifname[IFI_NAME - 1] == 0);
939 // null terminated because of memset above
940 continue;
941 }
942 #endif
943
944 #ifdef IP_RECVTTL
945 if (cmptr->cmsg_level == IPPROTO_IP &&
946 cmptr->cmsg_type == IP_RECVTTL) {
947 *ttl = *(u_char*)CMSG_DATA(cmptr);
948 continue;
949 }
950 else if (cmptr->cmsg_level == IPPROTO_IP &&
951 cmptr->cmsg_type == IP_TTL) { // some implementations seem to send IP_TTL instead of IP_RECVTTL
952 *ttl = *(int*)CMSG_DATA(cmptr);
953 continue;
954 }
955 #endif
956
957 #if defined(IPV6_PKTINFO) && HAVE_IPV6
958 if (cmptr->cmsg_level == IPPROTO_IPV6 &&
959 cmptr->cmsg_type == IPV6_PKTINFO) {
960 struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&pktp->ipi_addr;
961 struct in6_pktinfo *ip6_info = (struct in6_pktinfo*)CMSG_DATA(cmptr);
962
963 sin6->sin6_family = AF_INET6;
964 #ifndef NOT_HAVE_SA_LEN
965 sin6->sin6_len = sizeof(*sin6);
966 #endif
967 sin6->sin6_addr = ip6_info->ipi6_addr;
968 sin6->sin6_flowinfo = 0;
969 sin6->sin6_scope_id = 0;
970 sin6->sin6_port = 0;
971 pktp->ipi_ifindex = ip6_info->ipi6_ifindex;
972 continue;
973 }
974 #endif
975
976 #if defined(IPV6_HOPLIMIT) && HAVE_IPV6
977 if (cmptr->cmsg_level == IPPROTO_IPV6 &&
978 cmptr->cmsg_type == IPV6_HOPLIMIT) {
979 *ttl = *(int*)CMSG_DATA(cmptr);
980 continue;
981 }
982 #endif
983 assert(0); // unknown ancillary data
984 }
985 return(n);
986 #endif /* CMSG_FIRSTHDR */
987 }
988
989 // **********************************************************************************************
990
991 // daemonize the process. Adapted from "Unix Network Programming" vol 1 by Stevens, section 12.4.
992 // Returns 0 on success, -1 on failure.
993
994 #ifdef NOT_HAVE_DAEMON
995 #include <fcntl.h>
996 #include <sys/stat.h>
997 #include <sys/signal.h>
998
999 int daemon(int nochdir, int noclose)
1000 {
1001 switch (fork())
1002 {
1003 case -1: return (-1); // Fork failed
1004 case 0: break; // Child -- continue
1005 default: _exit(0); // Parent -- exit
1006 }
1007
1008 if (setsid() == -1) return(-1);
1009
1010 signal(SIGHUP, SIG_IGN);
1011
1012 switch (fork()) // Fork again, primarily for reasons of Unix trivia
1013 {
1014 case -1: return (-1); // Fork failed
1015 case 0: break; // Child -- continue
1016 default: _exit(0); // Parent -- exit
1017 }
1018
1019 if (!nochdir) (void)chdir("/");
1020 umask(0);
1021
1022 if (!noclose)
1023 {
1024 int fd = open("/dev/null", O_RDWR, 0);
1025 if (fd != -1)
1026 {
1027 // Avoid unnecessarily duplicating a file descriptor to itself
1028 if (fd != STDIN_FILENO) (void)dup2(fd, STDIN_FILENO);
1029 if (fd != STDOUT_FILENO) (void)dup2(fd, STDOUT_FILENO);
1030 if (fd != STDERR_FILENO) (void)dup2(fd, STDERR_FILENO);
1031 if (fd != STDIN_FILENO && fd != STDOUT_FILENO && fd != STDERR_FILENO)
1032 (void)close (fd);
1033 }
1034 }
1035 return (0);
1036 }
1037 #endif /* NOT_HAVE_DAEMON */
unleashed repo fork