Home | History | Annotate | Download | only in mDNSPosix
      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 #include <net/if_var.h>
     59 #include <netinet/in_var.h>
     60 // Note: netinet/in_var.h implicitly includes netinet6/in6_var.h for us
     61 #endif
     62 
     63 #if defined(AF_INET6) && HAVE_IPV6 && HAVE_LINUX
     64 #include <netdb.h>
     65 #include <arpa/inet.h>
     66 
     67 /* Converts a prefix length to IPv6 network mask */
     68 void plen_to_mask(int plen, char *addr) {
     69 	int i;
     70 	int colons=7; /* Number of colons in IPv6 address */
     71 	int bits_in_block=16; /* Bits per IPv6 block */
     72 	for(i=0;i<=colons;i++) {
     73 		int block, ones=0xffff, ones_in_block;
     74 		if (plen>bits_in_block) ones_in_block=bits_in_block;
     75 		else                    ones_in_block=plen;
     76 		block = ones & (ones << (bits_in_block-ones_in_block));
     77 		i==0 ? sprintf(addr, "%x", block) : sprintf(addr, "%s:%x", addr, block);
     78 		plen -= ones_in_block;
     79 		}
     80 	}
     81 
     82 /* Gets IPv6 interface information from the /proc filesystem in linux*/
     83 struct ifi_info *get_ifi_info_linuxv6(int family, int doaliases)
     84 	{
     85 		struct ifi_info *ifi, *ifihead, **ifipnext, *ifipold, **ifiptr;
     86 	FILE *fp = NULL;
     87 	char addr[8][5];
     88 	int flags, myflags, index, plen, scope;
     89 	char ifname[9], lastname[IFNAMSIZ];
     90 	char addr6[32+7+1]; /* don't forget the seven ':' */
     91 	struct addrinfo hints, *res0;
     92 	struct sockaddr_in6 *sin6;
     93 	struct in6_addr *addrptr;
     94 	int err;
     95 	int sockfd = -1;
     96 	struct ifreq ifr;
     97 
     98 	res0=NULL;
     99 	ifihead = NULL;
    100 	ifipnext = &ifihead;
    101 	lastname[0] = 0;
    102 
    103 	if ((fp = fopen(PROC_IFINET6_PATH, "r")) != NULL) {
    104 		sockfd = socket(AF_INET6, SOCK_DGRAM, 0);
    105 		if (sockfd < 0) {
    106 			goto gotError;
    107 		}
    108 		while (fscanf(fp,
    109 					  "%4s%4s%4s%4s%4s%4s%4s%4s %02x %02x %02x %02x %8s\n",
    110 					  addr[0],addr[1],addr[2],addr[3],
    111 					  addr[4],addr[5],addr[6],addr[7],
    112 					  &index, &plen, &scope, &flags, ifname) != EOF) {
    113 
    114 			myflags = 0;
    115 			if (strncmp(lastname, ifname, IFNAMSIZ) == 0) {
    116 				if (doaliases == 0)
    117 					continue;   /* already processed this interface */
    118 				myflags = IFI_ALIAS;
    119 				}
    120 			strncpy(lastname, ifname, IFNAMSIZ);
    121 			ifi = (struct ifi_info*)calloc(1, sizeof(struct ifi_info));
    122 			if (ifi == NULL) {
    123 				goto gotError;
    124 			}
    125 
    126 			ifipold   = *ifipnext;       /* need this later */
    127 			ifiptr    = ifipnext;
    128 			*ifipnext = ifi;            /* prev points to this new one */
    129 			ifipnext = &ifi->ifi_next;  /* pointer to next one goes here */
    130 
    131 			sprintf(addr6, "%s:%s:%s:%s:%s:%s:%s:%s",
    132 					addr[0],addr[1],addr[2],addr[3],
    133 					addr[4],addr[5],addr[6],addr[7]);
    134 
    135 			/* Add address of the interface */
    136 			memset(&hints, 0, sizeof(hints));
    137 			hints.ai_family = AF_INET6;
    138 			hints.ai_flags = AI_NUMERICHOST;
    139 			err = getaddrinfo(addr6, NULL, &hints, &res0);
    140 			if (err) {
    141 				goto gotError;
    142 				}
    143 			ifi->ifi_addr = calloc(1, sizeof(struct sockaddr_in6));
    144 			if (ifi->ifi_addr == NULL) {
    145 				goto gotError;
    146 				}
    147 			memcpy(ifi->ifi_addr, res0->ai_addr, sizeof(struct sockaddr_in6));
    148 
    149 			/* Add netmask of the interface */
    150 			char ipv6addr[INET6_ADDRSTRLEN];
    151 			plen_to_mask(plen, ipv6addr);
    152 			ifi->ifi_netmask = calloc(1, sizeof(struct sockaddr_in6));
    153 			if (ifi->ifi_addr == NULL) {
    154 				goto gotError;
    155 				}
    156 			sin6=calloc(1, sizeof(struct sockaddr_in6));
    157 			addrptr=calloc(1, sizeof(struct in6_addr));
    158 			inet_pton(family, ipv6addr, addrptr);
    159 			sin6->sin6_family=family;
    160 			sin6->sin6_addr=*addrptr;
    161 			sin6->sin6_scope_id=scope;
    162 			memcpy(ifi->ifi_netmask, sin6, sizeof(struct sockaddr_in6));
    163 			free(sin6);
    164 
    165 
    166 			/* Add interface name */
    167 			strncpy(ifi->ifi_name, ifname, IFI_NAME);
    168 
    169 			/* Add interface index */
    170 			ifi->ifi_index = index;
    171 
    172 			/* Add interface flags*/
    173 			strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
    174 			if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0) {
    175 				if (errno == EADDRNOTAVAIL) {
    176 					/*
    177 					 * If the main interface is configured with no IP address but
    178 					 * an alias interface exists with an IP address, you get
    179 					 * EADDRNOTAVAIL for the main interface
    180 					 */
    181 					free(ifi->ifi_addr);
    182 					free(ifi);
    183 					ifipnext  = ifiptr;
    184 					*ifipnext = ifipold;
    185 					continue;
    186 				} else {
    187 					goto gotError;
    188 				}
    189 			}
    190 			ifi->ifi_flags = ifr.ifr_flags;
    191 			freeaddrinfo(res0);
    192 			res0=NULL;
    193 			}
    194 		}
    195 	goto done;
    196 
    197 	gotError:
    198 	if (ifihead != NULL) {
    199 		free_ifi_info(ifihead);
    200 		ifihead = NULL;
    201 		}
    202 	if (res0 != NULL) {
    203 		freeaddrinfo(res0);
    204 		res0=NULL;
    205 		}
    206 	done:
    207 	if (sockfd != -1) {
    208 // __ANDROID__ : replaced assert(close(..))
    209 		int sockfd_closed = close(sockfd);
    210 		assert(sockfd_closed == 0);
    211 		}
    212 // __ANDROID__ : if fp was opened, it needs to be closed
    213 	if (fp != NULL) {
    214 		int fd_closed = fclose(fp);
    215 		assert(fd_closed == 0);
    216 		}
    217 	return(ifihead);    /* pointer to first structure in linked list */
    218 	}
    219 #endif // defined(AF_INET6) && HAVE_IPV6 && HAVE_LINUX
    220 
    221 struct ifi_info *get_ifi_info(int family, int doaliases)
    222 {
    223     int                 junk;
    224     struct ifi_info     *ifi, *ifihead, **ifipnext, *ifipold, **ifiptr;
    225     int                 sockfd, sockf6, len, lastlen, flags, myflags;
    226 #ifdef NOT_HAVE_IF_NAMETOINDEX
    227     int                 index = 200;
    228 #endif
    229     char                *ptr, *buf, lastname[IFNAMSIZ], *cptr;
    230     struct ifconf       ifc;
    231     struct ifreq        *ifr, ifrcopy;
    232     struct sockaddr_in  *sinptr;
    233 
    234 #if defined(AF_INET6) && HAVE_IPV6
    235     struct sockaddr_in6 *sinptr6;
    236 #endif
    237 
    238 #if defined(AF_INET6) && HAVE_IPV6 && HAVE_LINUX
    239  if (family == AF_INET6) return get_ifi_info_linuxv6(family, doaliases);
    240 #endif
    241 
    242 	sockfd = -1;
    243     sockf6 = -1;
    244     buf = NULL;
    245     ifihead = NULL;
    246 
    247     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    248     if (sockfd < 0) {
    249         goto gotError;
    250     }
    251 
    252     lastlen = 0;
    253     len = 100 * sizeof(struct ifreq);   /* initial buffer size guess */
    254     for ( ; ; ) {
    255         buf = (char*)malloc(len);
    256         if (buf == NULL) {
    257             goto gotError;
    258         }
    259         ifc.ifc_len = len;
    260         ifc.ifc_buf = buf;
    261         if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
    262             if (errno != EINVAL || lastlen != 0) {
    263                 goto gotError;
    264             }
    265         } else {
    266             if (ifc.ifc_len == lastlen)
    267                 break;      /* success, len has not changed */
    268             lastlen = ifc.ifc_len;
    269         }
    270         len += 10 * sizeof(struct ifreq);   /* increment */
    271         free(buf);
    272     }
    273     ifihead = NULL;
    274     ifipnext = &ifihead;
    275     lastname[0] = 0;
    276 /* end get_ifi_info1 */
    277 
    278 /* include get_ifi_info2 */
    279     for (ptr = buf; ptr < buf + ifc.ifc_len; ) {
    280         ifr = (struct ifreq *) ptr;
    281 
    282         /* Advance to next one in buffer */
    283         if (sizeof(struct ifreq) > sizeof(ifr->ifr_name) + GET_SA_LEN(ifr->ifr_addr))
    284             ptr += sizeof(struct ifreq);
    285         else
    286             ptr += sizeof(ifr->ifr_name) + GET_SA_LEN(ifr->ifr_addr);
    287 
    288 //      fprintf(stderr, "intf %p name=%s AF=%d\n", index, ifr->ifr_name, ifr->ifr_addr.sa_family);
    289 
    290         if (ifr->ifr_addr.sa_family != family)
    291             continue;   /* ignore if not desired address family */
    292 
    293         myflags = 0;
    294         if ( (cptr = strchr(ifr->ifr_name, ':')) != NULL)
    295             *cptr = 0;      /* replace colon will null */
    296         if (strncmp(lastname, ifr->ifr_name, IFNAMSIZ) == 0) {
    297             if (doaliases == 0)
    298                 continue;   /* already processed this interface */
    299             myflags = IFI_ALIAS;
    300         }
    301         memcpy(lastname, ifr->ifr_name, IFNAMSIZ);
    302 
    303         ifrcopy = *ifr;
    304         if (ioctl(sockfd, SIOCGIFFLAGS, &ifrcopy) < 0) {
    305             goto gotError;
    306         }
    307 
    308         flags = ifrcopy.ifr_flags;
    309         if ((flags & IFF_UP) == 0)
    310             continue;   /* ignore if interface not up */
    311 
    312         ifi = (struct ifi_info*)calloc(1, sizeof(struct ifi_info));
    313         if (ifi == NULL) {
    314             goto gotError;
    315         }
    316 		ifipold   = *ifipnext;       /* need this later */
    317 		ifiptr    = ifipnext;
    318 		*ifipnext = ifi;             /* prev points to this new one */
    319 		ifipnext  = &ifi->ifi_next;  /* pointer to next one goes here */
    320 
    321         ifi->ifi_flags = flags;     /* IFF_xxx values */
    322         ifi->ifi_myflags = myflags; /* IFI_xxx values */
    323 #ifndef NOT_HAVE_IF_NAMETOINDEX
    324         ifi->ifi_index = if_nametoindex(ifr->ifr_name);
    325 #else
    326         ifrcopy = *ifr;
    327 #ifdef SIOCGIFINDEX
    328 		if ( 0 >= ioctl(sockfd, SIOCGIFINDEX, &ifrcopy))
    329             ifi->ifi_index = ifrcopy.ifr_index;
    330         else
    331 #endif
    332             ifi->ifi_index = index++;	/* SIOCGIFINDEX is broken on Solaris 2.5ish, so fake it */
    333 #endif
    334         memcpy(ifi->ifi_name, ifr->ifr_name, IFI_NAME);
    335         ifi->ifi_name[IFI_NAME-1] = '\0';
    336 /* end get_ifi_info2 */
    337 /* include get_ifi_info3 */
    338         switch (ifr->ifr_addr.sa_family) {
    339         case AF_INET:
    340             sinptr = (struct sockaddr_in *) &ifr->ifr_addr;
    341             if (ifi->ifi_addr == NULL) {
    342                 ifi->ifi_addr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
    343                 if (ifi->ifi_addr == NULL) {
    344                     goto gotError;
    345                 }
    346                 memcpy(ifi->ifi_addr, sinptr, sizeof(struct sockaddr_in));
    347 
    348 #ifdef  SIOCGIFNETMASK
    349 				if (ioctl(sockfd, SIOCGIFNETMASK, &ifrcopy) < 0) {
    350 					if (errno == EADDRNOTAVAIL) {
    351 						/*
    352 						 * If the main interface is configured with no IP address but
    353 						 * an alias interface exists with an IP address, you get
    354 						 * EADDRNOTAVAIL for the main interface
    355 						 */
    356 						free(ifi->ifi_addr);
    357 						free(ifi);
    358 						ifipnext  = ifiptr;
    359 						*ifipnext = ifipold;
    360 						continue;
    361 					} else {
    362 						goto gotError;
    363 					}
    364 				}
    365 
    366 				ifi->ifi_netmask = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
    367 				if (ifi->ifi_netmask == NULL) goto gotError;
    368 				sinptr = (struct sockaddr_in *) &ifrcopy.ifr_addr;
    369 				/* The BSD ioctls (including Mac OS X) stick some weird values in for sin_len and sin_family */
    370 #ifndef NOT_HAVE_SA_LEN
    371 				sinptr->sin_len    = sizeof(struct sockaddr_in);
    372 #endif
    373 				sinptr->sin_family = AF_INET;
    374 				memcpy(ifi->ifi_netmask, sinptr, sizeof(struct sockaddr_in));
    375 #endif
    376 
    377 #ifdef  SIOCGIFBRDADDR
    378                 if (flags & IFF_BROADCAST) {
    379                     if (ioctl(sockfd, SIOCGIFBRDADDR, &ifrcopy) < 0) {
    380                         goto gotError;
    381                     }
    382                     sinptr = (struct sockaddr_in *) &ifrcopy.ifr_broadaddr;
    383 					/* The BSD ioctls (including Mac OS X) stick some weird values in for sin_len and sin_family */
    384 #ifndef NOT_HAVE_SA_LEN
    385 					sinptr->sin_len    = sizeof( struct sockaddr_in );
    386 #endif
    387 					sinptr->sin_family = AF_INET;
    388                     ifi->ifi_brdaddr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
    389                     if (ifi->ifi_brdaddr == NULL) {
    390                         goto gotError;
    391                     }
    392                     memcpy(ifi->ifi_brdaddr, sinptr, sizeof(struct sockaddr_in));
    393                 }
    394 #endif
    395 
    396 #ifdef  SIOCGIFDSTADDR
    397                 if (flags & IFF_POINTOPOINT) {
    398                     if (ioctl(sockfd, SIOCGIFDSTADDR, &ifrcopy) < 0) {
    399                         goto gotError;
    400                     }
    401                     sinptr = (struct sockaddr_in *) &ifrcopy.ifr_dstaddr;
    402                     /* The BSD ioctls (including Mac OS X) stick some weird values in for sin_len and sin_family */
    403 #ifndef NOT_HAVE_SA_LEN
    404 					sinptr->sin_len    = sizeof( struct sockaddr_in );
    405 #endif
    406 					sinptr->sin_family = AF_INET;
    407                     ifi->ifi_dstaddr = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in));
    408                     if (ifi->ifi_dstaddr == NULL) {
    409                         goto gotError;
    410                     }
    411                     memcpy(ifi->ifi_dstaddr, sinptr, sizeof(struct sockaddr_in));
    412                 }
    413 #endif
    414             }
    415             break;
    416 
    417 #if defined(AF_INET6) && HAVE_IPV6
    418         case AF_INET6:
    419             sinptr6 = (struct sockaddr_in6 *) &ifr->ifr_addr;
    420             if (ifi->ifi_addr == NULL) {
    421                 ifi->ifi_addr = calloc(1, sizeof(struct sockaddr_in6));
    422                 if (ifi->ifi_addr == NULL) {
    423                     goto gotError;
    424                 }
    425 
    426                 /* Some platforms (*BSD) inject the prefix in IPv6LL addresses */
    427                 /* We need to strip that out */
    428                 if (IN6_IS_ADDR_LINKLOCAL(&sinptr6->sin6_addr))
    429                 	sinptr6->sin6_addr.s6_addr[2] = sinptr6->sin6_addr.s6_addr[3] = 0;
    430                 memcpy(ifi->ifi_addr, sinptr6, sizeof(struct sockaddr_in6));
    431 
    432 #ifdef  SIOCGIFNETMASK_IN6
    433 				{
    434 				struct in6_ifreq ifr6;
    435 				if (sockf6 == -1)
    436 					sockf6 = socket(AF_INET6, SOCK_DGRAM, 0);
    437 				memset(&ifr6, 0, sizeof(ifr6));
    438 				memcpy(&ifr6.ifr_name,           &ifr->ifr_name, sizeof(ifr6.ifr_name          ));
    439 				memcpy(&ifr6.ifr_ifru.ifru_addr, &ifr->ifr_addr, sizeof(ifr6.ifr_ifru.ifru_addr));
    440 				if (ioctl(sockf6, SIOCGIFNETMASK_IN6, &ifr6) < 0) {
    441 					if (errno == EADDRNOTAVAIL) {
    442 						/*
    443 						 * If the main interface is configured with no IP address but
    444 						 * an alias interface exists with an IP address, you get
    445 						 * EADDRNOTAVAIL for the main interface
    446 						 */
    447 						free(ifi->ifi_addr);
    448 						free(ifi);
    449 						ifipnext  = ifiptr;
    450 						*ifipnext = ifipold;
    451 						continue;
    452 					} else {
    453 						goto gotError;
    454 					}
    455 				}
    456 				ifi->ifi_netmask = (struct sockaddr*)calloc(1, sizeof(struct sockaddr_in6));
    457 				if (ifi->ifi_netmask == NULL) goto gotError;
    458 				sinptr6 = (struct sockaddr_in6 *) &ifr6.ifr_ifru.ifru_addr;
    459 				memcpy(ifi->ifi_netmask, sinptr6, sizeof(struct sockaddr_in6));
    460 				}
    461 #endif
    462             }
    463             break;
    464 #endif
    465 
    466         default:
    467             break;
    468         }
    469     }
    470     goto done;
    471 
    472 gotError:
    473     if (ifihead != NULL) {
    474         free_ifi_info(ifihead);
    475         ifihead = NULL;
    476     }
    477 
    478 done:
    479     if (buf != NULL) {
    480         free(buf);
    481     }
    482     if (sockfd != -1) {
    483         junk = close(sockfd);
    484         assert(junk == 0);
    485     }
    486     if (sockf6 != -1) {
    487         junk = close(sockf6);
    488         assert(junk == 0);
    489     }
    490     return(ifihead);    /* pointer to first structure in linked list */
    491 }
    492 /* end get_ifi_info3 */
    493 
    494 /* include free_ifi_info */
    495 void
    496 free_ifi_info(struct ifi_info *ifihead)
    497 {
    498     struct ifi_info *ifi, *ifinext;
    499 
    500     for (ifi = ifihead; ifi != NULL; ifi = ifinext) {
    501         if (ifi->ifi_addr != NULL)
    502             free(ifi->ifi_addr);
    503         if (ifi->ifi_netmask != NULL)
    504             free(ifi->ifi_netmask);
    505         if (ifi->ifi_brdaddr != NULL)
    506             free(ifi->ifi_brdaddr);
    507         if (ifi->ifi_dstaddr != NULL)
    508             free(ifi->ifi_dstaddr);
    509         ifinext = ifi->ifi_next;    /* can't fetch ifi_next after free() */
    510         free(ifi);                  /* the ifi_info{} itself */
    511     }
    512 }
    513 /* end free_ifi_info */
    514 
    515 ssize_t
    516 recvfrom_flags(int fd, void *ptr, size_t nbytes, int *flagsp,
    517                struct sockaddr *sa, socklen_t *salenptr, struct my_in_pktinfo *pktp, u_char *ttl)
    518 {
    519     struct msghdr   msg;
    520     struct iovec    iov[1];
    521     ssize_t         n;
    522 
    523 #ifdef CMSG_FIRSTHDR
    524     struct cmsghdr  *cmptr;
    525     union {
    526       struct cmsghdr    cm;
    527       char              control[1024];
    528     } control_un;
    529 
    530 	*ttl = 255;			// If kernel fails to provide TTL data then assume the TTL was 255 as it should be
    531 
    532     msg.msg_control = control_un.control;
    533     msg.msg_controllen = sizeof(control_un.control);
    534     msg.msg_flags = 0;
    535 #else
    536     memset(&msg, 0, sizeof(msg));   /* make certain msg_accrightslen = 0 */
    537 #endif /* CMSG_FIRSTHDR */
    538 
    539     msg.msg_name = (char *) sa;
    540     msg.msg_namelen = *salenptr;
    541     iov[0].iov_base = (char *)ptr;
    542     iov[0].iov_len = nbytes;
    543     msg.msg_iov = iov;
    544     msg.msg_iovlen = 1;
    545 
    546     if ( (n = recvmsg(fd, &msg, *flagsp)) < 0)
    547         return(n);
    548 
    549     *salenptr = msg.msg_namelen;    /* pass back results */
    550     if (pktp) {
    551         /* 0.0.0.0, i/f = -1 */
    552         /* We set the interface to -1 so that the caller can
    553            tell whether we returned a meaningful value or
    554            just some default.  Previously this code just
    555            set the value to 0, but I'm concerned that 0
    556            might be a valid interface value.
    557         */
    558         memset(pktp, 0, sizeof(struct my_in_pktinfo));
    559         pktp->ipi_ifindex = -1;
    560     }
    561 /* end recvfrom_flags1 */
    562 
    563 /* include recvfrom_flags2 */
    564 #ifndef CMSG_FIRSTHDR
    565 	#warning CMSG_FIRSTHDR not defined. Will not be able to determine destination address, received interface, etc.
    566     *flagsp = 0;                    /* pass back results */
    567     return(n);
    568 #else
    569 
    570     *flagsp = msg.msg_flags;        /* pass back results */
    571     if (msg.msg_controllen < (socklen_t)sizeof(struct cmsghdr) ||
    572         (msg.msg_flags & MSG_CTRUNC) || pktp == NULL)
    573         return(n);
    574 
    575     for (cmptr = CMSG_FIRSTHDR(&msg); cmptr != NULL;
    576          cmptr = CMSG_NXTHDR(&msg, cmptr)) {
    577 
    578 #ifdef  IP_PKTINFO
    579 #if in_pktinfo_definition_is_missing
    580 struct in_pktinfo
    581 {
    582         int             ipi_ifindex;
    583         struct in_addr  ipi_spec_dst;
    584         struct in_addr  ipi_addr;
    585 };
    586 #endif
    587         if (cmptr->cmsg_level == IPPROTO_IP &&
    588             cmptr->cmsg_type == IP_PKTINFO) {
    589             struct in_pktinfo *tmp;
    590             struct sockaddr_in *sin = (struct sockaddr_in*)&pktp->ipi_addr;
    591 
    592             tmp = (struct in_pktinfo *) CMSG_DATA(cmptr);
    593             sin->sin_family = AF_INET;
    594             sin->sin_addr = tmp->ipi_addr;
    595             sin->sin_port = 0;
    596             pktp->ipi_ifindex = tmp->ipi_ifindex;
    597             continue;
    598         }
    599 #endif
    600 
    601 #ifdef  IP_RECVDSTADDR
    602         if (cmptr->cmsg_level == IPPROTO_IP &&
    603             cmptr->cmsg_type == IP_RECVDSTADDR) {
    604             struct sockaddr_in *sin = (struct sockaddr_in*)&pktp->ipi_addr;
    605 
    606             sin->sin_family = AF_INET;
    607             sin->sin_addr = *(struct in_addr*)CMSG_DATA(cmptr);
    608             sin->sin_port = 0;
    609             continue;
    610         }
    611 #endif
    612 
    613 #ifdef  IP_RECVIF
    614         if (cmptr->cmsg_level == IPPROTO_IP &&
    615             cmptr->cmsg_type == IP_RECVIF) {
    616             struct sockaddr_dl  *sdl = (struct sockaddr_dl *) CMSG_DATA(cmptr);
    617 #ifndef HAVE_BROKEN_RECVIF_NAME
    618             int nameLen = (sdl->sdl_nlen < IFI_NAME - 1) ? sdl->sdl_nlen : (IFI_NAME - 1);
    619             strncpy(pktp->ipi_ifname, sdl->sdl_data, nameLen);
    620 #endif
    621             pktp->ipi_ifindex = sdl->sdl_index;
    622 #ifdef HAVE_BROKEN_RECVIF_NAME
    623 			if (sdl->sdl_index == 0) {
    624 				pktp->ipi_ifindex = *(uint_t*)sdl;
    625 			}
    626 #endif
    627             assert(pktp->ipi_ifname[IFI_NAME - 1] == 0);
    628             // null terminated because of memset above
    629             continue;
    630         }
    631 #endif
    632 
    633 #ifdef  IP_RECVTTL
    634         if (cmptr->cmsg_level == IPPROTO_IP &&
    635             cmptr->cmsg_type == IP_RECVTTL) {
    636 			*ttl = *(u_char*)CMSG_DATA(cmptr);
    637             continue;
    638         }
    639         else if (cmptr->cmsg_level == IPPROTO_IP &&
    640             cmptr->cmsg_type == IP_TTL) {		// some implementations seem to send IP_TTL instead of IP_RECVTTL
    641 			*ttl = *(int*)CMSG_DATA(cmptr);
    642             continue;
    643         }
    644 #endif
    645 
    646 #if defined(IPV6_PKTINFO) && HAVE_IPV6
    647 		if (cmptr->cmsg_level == IPPROTO_IPV6 &&
    648             cmptr->cmsg_type  == IPV6_2292_PKTINFO) {
    649             struct sockaddr_in6 *sin6 = (struct sockaddr_in6*)&pktp->ipi_addr;
    650 			struct in6_pktinfo *ip6_info = (struct in6_pktinfo*)CMSG_DATA(cmptr);
    651 
    652             sin6->sin6_family   = AF_INET6;
    653 #ifndef NOT_HAVE_SA_LEN
    654             sin6->sin6_len      = sizeof(*sin6);
    655 #endif
    656             sin6->sin6_addr     = ip6_info->ipi6_addr;
    657             sin6->sin6_flowinfo = 0;
    658             sin6->sin6_scope_id = 0;
    659             sin6->sin6_port     = 0;
    660 			pktp->ipi_ifindex   = ip6_info->ipi6_ifindex;
    661             continue;
    662         }
    663 #endif
    664 
    665 #if defined(IPV6_HOPLIMIT) && HAVE_IPV6
    666         if (cmptr->cmsg_level == IPPROTO_IPV6 &&
    667             cmptr->cmsg_type == IPV6_2292_HOPLIMIT) {
    668 			*ttl = *(int*)CMSG_DATA(cmptr);
    669             continue;
    670         }
    671 #endif
    672         assert(0);  // unknown ancillary data
    673     }
    674     return(n);
    675 #endif /* CMSG_FIRSTHDR */
    676 }
    677 
    678 // **********************************************************************************************
    679 
    680 // daemonize the process. Adapted from "Unix Network Programming" vol 1 by Stevens, section 12.4.
    681 // Returns 0 on success, -1 on failure.
    682 
    683 #ifdef NOT_HAVE_DAEMON
    684 #include <fcntl.h>
    685 #include <sys/stat.h>
    686 #include <sys/signal.h>
    687 
    688 int daemon(int nochdir, int noclose)
    689     {
    690 	switch (fork())
    691 		{
    692 		case -1: return (-1);	// Fork failed
    693 		case 0: break;		// Child -- continue
    694 		default: _exit(0);	// Parent -- exit
    695 		}
    696 
    697 	if (setsid() == -1) return(-1);
    698 
    699 	signal(SIGHUP, SIG_IGN);
    700 
    701 	switch (fork())				// Fork again, primarily for reasons of Unix trivia
    702 		{
    703 		case -1: return (-1);	// Fork failed
    704 		case 0:  break;			// Child -- continue
    705 		default: _exit(0);		// Parent -- exit
    706 		}
    707 
    708 	if (!nochdir) (void)chdir("/");
    709 	umask(0);
    710 
    711 	if (!noclose)
    712 		{
    713 		int fd = open("/dev/null", O_RDWR, 0);
    714 		if (fd != -1)
    715 			{
    716 			// Avoid unnecessarily duplicating a file descriptor to itself
    717 			if (fd != STDIN_FILENO) (void)dup2(fd, STDIN_FILENO);
    718 			if (fd != STDOUT_FILENO) (void)dup2(fd, STDOUT_FILENO);
    719 			if (fd != STDERR_FILENO) (void)dup2(fd, STDERR_FILENO);
    720 			if (fd != STDIN_FILENO && fd != STDOUT_FILENO && fd != STDERR_FILENO)
    721 				(void)close (fd);
    722 			}
    723 		}
    724 	return (0);
    725     }
    726 #endif /* NOT_HAVE_DAEMON */
    727