From 8e54530b52fd256137740107e9fdf000f00a7a30 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 10 Oct 2007 18:25:16 -0700 Subject: Add start of IPv6 implementation. Currently most of this is avoiding IPv6 in winbindd, but moves most of the socket functions that were wrongly in lib/util.c into lib/util_sock.c and provides generic IPv4/6 independent versions of most things. Still lots of work to do, but now I can see how I'll fix the access check code. Nasty part that remains is the name resolution code which is used to returning arrays of in_addr structs. Jeremy. (This used to be commit 3f6bd0e1ec5cc6670f3d08f76fc2cd94c9cd1a08) --- source3/lib/access.c | 2 +- source3/lib/interface.c | 644 +++++++++++++++++++++++++++++++++-------------- source3/lib/interfaces.c | 258 +++++++++++++------ source3/lib/util.c | 189 -------------- source3/lib/util_sock.c | 515 +++++++++++++++++++++++++++++++++---- source3/lib/wins_srv.c | 10 +- 6 files changed, 1112 insertions(+), 506 deletions(-) (limited to 'source3/lib') diff --git a/source3/lib/access.c b/source3/lib/access.c index 303e3ed4c4..17f4c367eb 100644 --- a/source3/lib/access.c +++ b/source3/lib/access.c @@ -279,7 +279,7 @@ static BOOL only_ipaddrs_in_list(const char** list) continue; } - if (!is_ipaddress(*list)) { + if (!is_ipaddress_v4(*list)) { /* * if we failed, make sure that it was not because the token * was a network/netmask pair. Only network/netmask pairs diff --git a/source3/lib/interface.c b/source3/lib/interface.c index 5982d82e47..1471a06f46 100644 --- a/source3/lib/interface.c +++ b/source3/lib/interface.c @@ -2,6 +2,7 @@ Unix SMB/CIFS implementation. multiple interface handling Copyright (C) Andrew Tridgell 1992-1998 + Copyright (C) Jeremy Allison 2007 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -22,66 +23,404 @@ static struct iface_struct *probed_ifaces; static int total_probed; -struct in_addr allones_ip; -struct in_addr loopback_ip; - static struct interface *local_interfaces; -#define ALLONES ((uint32)0xFFFFFFFF) -#define MKBCADDR(_IP, _NM) ((_IP & _NM) | (_NM ^ ALLONES)) -#define MKNETADDR(_IP, _NM) (_IP & _NM) +/**************************************************************************** + Check if an IP is one of mine. +**************************************************************************/ + +bool ismyaddr(const struct sockaddr_storage *ip) +{ + struct interface *i; + for (i=local_interfaces;i;i=i->next) { + if (addr_equal(&i->ip,ip)) { + return true; + } + } + return false; +} + +bool ismyip_v4(struct in_addr ip) +{ + struct sockaddr_storage ss; + in_addr_to_sockaddr_storage(&ss, ip); + return ismyaddr(&ss); +} /**************************************************************************** Try and find an interface that matches an ip. If we cannot, return NULL. **************************************************************************/ -static struct interface *iface_find(struct in_addr ip, BOOL CheckMask) +static struct interface *iface_find(const struct sockaddr_storage *ip, + bool check_mask) { struct interface *i; - if (is_zero_ip(ip)) return local_interfaces; - for (i=local_interfaces;i;i=i->next) - if (CheckMask) { - if (same_net(i->ip,ip,i->nmask)) return i; - } else if ((i->ip).s_addr == ip.s_addr) return i; + if (is_address_any(ip)) { + return local_interfaces; + } + + for (i=local_interfaces;i;i=i->next) { + if (check_mask) { + if (same_net(ip, &i->ip, &i->netmask)) { + return i; + } + } else if (addr_equal(&i->ip, ip)) { + return i; + } + } return NULL; } +/**************************************************************************** + Check if a packet is from a local (known) net. +**************************************************************************/ + +bool is_local_net(const struct sockaddr_storage *from) +{ + struct interface *i; + for (i=local_interfaces;i;i=i->next) { + if (same_net(from, &i->ip, &i->netmask)) { + return true; + } + } + return false; +} + +/**************************************************************************** + Check if a packet is from a local (known) net. +**************************************************************************/ + +bool is_local_net_v4(struct in_addr from) +{ + struct sockaddr_storage ss; + + in_addr_to_sockaddr_storage(&ss, from); + return is_local_net(&ss); +} + +/**************************************************************************** + How many interfaces do we have ? +**************************************************************************/ + +int iface_count(void) +{ + int ret = 0; + struct interface *i; + + for (i=local_interfaces;i;i=i->next) { + ret++; + } + return ret; +} + +/**************************************************************************** + How many interfaces do we have (v4 only) ? +**************************************************************************/ + +int iface_count_v4(void) +{ + int ret = 0; + struct interface *i; + + for (i=local_interfaces;i;i=i->next) { + if (i->ip.ss_family == AF_INET) { + ret++; + } + } + return ret; +} + +/**************************************************************************** + Return a pointer to the in_addr of the first IPv4 interface. +**************************************************************************/ + +const struct in_addr *first_ipv4_iface(void) +{ + struct interface *i; + + for (i=local_interfaces;i ;i=i->next) { + if (i->ip.ss_family == AF_INET) { + break; + } + } + + if (!i) { + return NULL; + } + return &((const struct sockaddr_in *)&i->ip)->sin_addr; +} + +/**************************************************************************** + Return the Nth interface. +**************************************************************************/ + +struct interface *get_interface(int n) +{ + struct interface *i; + + for (i=local_interfaces;i && n;i=i->next) { + n--; + } + + if (i) { + return i; + } + return NULL; +} + +/**************************************************************************** + Return IP sockaddr_storage of the Nth interface. +**************************************************************************/ + +const struct sockaddr_storage *iface_n_sockaddr_storage(int n) +{ + struct interface *i; + + for (i=local_interfaces;i && n;i=i->next) { + n--; + } + + if (i) { + return &i->ip; + } + return NULL; +} + +/**************************************************************************** + Return IPv4 of the Nth interface (if a v4 address). NULL otherwise. +**************************************************************************/ + +const struct in_addr *iface_n_ip_v4(int n) +{ + struct interface *i; + + for (i=local_interfaces;i && n;i=i->next) { + n--; + } + + if (i && i->ip.ss_family == AF_INET) { + return &((const struct sockaddr_in *)&i->ip)->sin_addr; + } + return NULL; +} + +/**************************************************************************** + Return IPv4 bcast of the Nth interface (if a v4 address). NULL otherwise. +**************************************************************************/ + +const struct in_addr *iface_n_bcast_v4(int n) +{ + struct interface *i; + + for (i=local_interfaces;i && n;i=i->next) { + n--; + } + + if (i && i->ip.ss_family == AF_INET) { + return &((const struct sockaddr_in *)&i->bcast)->sin_addr; + } + return NULL; +} + +/**************************************************************************** + Return bcast of the Nth interface. +**************************************************************************/ + +const struct sockaddr_storage *iface_n_bcast(int n) +{ + struct interface *i; + + for (i=local_interfaces;i && n;i=i->next) { + n--; + } + + if (i) { + return &i->bcast; + } + return NULL; +} + +/* these 3 functions return the ip/bcast/nmask for the interface + most appropriate for the given ip address. If they can't find + an appropriate interface they return the requested field of the + first known interface. */ + +const struct sockaddr_storage *iface_ip(const struct sockaddr_storage *ip) +{ + struct interface *i = iface_find(ip, true); + if (i) { + return &i->ip; + } + + /* Search for the first interface with + * matching address family. */ + + for (i=local_interfaces;i;i=i->next) { + if (i->ip.ss_family == ip->ss_family) { + return &i->ip; + } + } + return NULL; +} + +/* + return True if a IP is directly reachable on one of our interfaces +*/ + +bool iface_local(struct sockaddr_storage *ip) +{ + return iface_find(ip, True) ? true : false; +} + /**************************************************************************** Add an interface to the linked list of interfaces. ****************************************************************************/ -static void add_interface(struct in_addr ip, struct in_addr nmask) +static void add_interface(const struct iface_struct *ifs) { + char addr[INET6_ADDRSTRLEN]; struct interface *iface; - if (iface_find(ip, False)) { - DEBUG(3,("not adding duplicate interface %s\n",inet_ntoa(ip))); + + if (iface_find(&ifs->ip, False)) { + DEBUG(3,("add_interface: not adding duplicate interface %s\n", + print_sockaddr(addr, sizeof(addr), + &ifs->ip, sizeof(struct sockaddr_storage)) )); return; } -#if !defined(__s390__) - if (ip_equal(nmask, allones_ip)) { + if (!(ifs->flags & IFF_BROADCAST)) { DEBUG(3,("not adding non-broadcast interface %s\n", - inet_ntoa(ip))); + ifs->name )); return; } -#endif iface = SMB_MALLOC_P(struct interface); - if (!iface) return; + if (!iface) { + return; + } ZERO_STRUCTPN(iface); - iface->ip = ip; - iface->nmask = nmask; - iface->bcast.s_addr = MKBCADDR(iface->ip.s_addr, iface->nmask.s_addr); + iface->name = SMB_STRDUP(ifs->name); + if (!iface->name) { + SAFE_FREE(iface); + return; + } + iface->flags = ifs->flags; + iface->ip = ifs->ip; + iface->netmask = ifs->netmask; + iface->bcast = ifs->bcast; DLIST_ADD(local_interfaces, iface); - DEBUG(2,("added interface ip=%s ",inet_ntoa(iface->ip))); - DEBUG(2,("bcast=%s ",inet_ntoa(iface->bcast))); - DEBUG(2,("nmask=%s\n",inet_ntoa(iface->nmask))); + DEBUG(2,("added interface %s ip=%s ", + iface->name, + print_sockaddr(addr, sizeof(addr), + &iface->ip, sizeof(struct sockaddr_storage)) )); + DEBUG(2,("bcast=%s ", + print_sockaddr(addr, sizeof(addr), + &iface->bcast, + sizeof(struct sockaddr_storage)) )); + DEBUG(2,("netmask=%s\n", + print_sockaddr(addr, sizeof(addr), + &iface->netmask, + sizeof(struct sockaddr_storage)) )); +} + +/**************************************************************************** + Create a struct sockaddr_storage with the netmask bits set to 1. +****************************************************************************/ + +static bool make_netmask(struct sockaddr_storage *pss_out, + const struct sockaddr_storage *pss_in, + unsigned long masklen) +{ + *pss_out = *pss_in; + /* Now apply masklen bits of mask. */ +#if defined(AF_INET6) + if (pss_in->ss_family == AF_INET6) { + char *p = (char *)&((struct sockaddr_in6 *)pss_out)->sin6_addr; + unsigned int i; + + if (masklen > 128) { + return false; + } + for (i = 0; masklen >= 8; masklen -= 8, i++) { + *p++ = 0xff; + } + /* Deal with the partial byte. */ + *p++ &= (0xff & ~(0xff>>masklen)); + i++; + for (;i < sizeof(struct in6_addr); i++) { + *p++ = '\0'; + } + return true; + } +#endif + if (pss_in->ss_family == AF_INET) { + if (masklen > 32) { + return false; + } + ((struct sockaddr_in *)pss_out)->sin_addr.s_addr = + htonl(((0xFFFFFFFFL >> masklen) ^ 0xFFFFFFFFL)); + return true; + } + return false; +} + +/**************************************************************************** + Create a struct sockaddr_storage set to the broadcast or network adress from + an incoming sockaddr_storage. +****************************************************************************/ + +static void make_bcast_or_net(struct sockaddr_storage *pss_out, + const struct sockaddr_storage *pss_in, + const struct sockaddr_storage *nmask, + bool make_bcast) +{ + unsigned int i = 0, len = 0; + char *pmask = NULL; + char *p = NULL; + *pss_out = *pss_in; + + /* Set all zero netmask bits to 1. */ +#if defined(AF_INET6) + if (pss_in->ss_family == AF_INET6) { + p = (char *)&((struct sockaddr_in6 *)pss_out)->sin6_addr; + pmask = (char *)&((struct sockaddr_in6 *)nmask)->sin6_addr; + len = 16; + } +#endif + if (pss_in->ss_family == AF_INET) { + p = (char *)&((struct sockaddr_in *)pss_out)->sin_addr; + pmask = (char *)&((struct sockaddr_in *)nmask)->sin_addr; + len = 4; + } + + for (i = 0; i < len; i++, p++, pmask++) { + if (make_bcast) { + *p = (*p & *pmask) | (*pmask ^ 0xff); + } else { + /* make_net */ + *p = (*p & *pmask); + } + } +} + +static void make_bcast(struct sockaddr_storage *pss_out, + const struct sockaddr_storage *pss_in, + const struct sockaddr_storage *nmask) +{ + make_bcast_or_net(pss_out, pss_in, nmask, true); +} + +static void make_net(struct sockaddr_storage *pss_out, + const struct sockaddr_storage *pss_in, + const struct sockaddr_storage *nmask) +{ + make_bcast_or_net(pss_out, pss_in, nmask, false); } /**************************************************************************** @@ -98,68 +437,121 @@ static void add_interface(struct in_addr ip, struct in_addr nmask) static void interpret_interface(char *token) { - struct in_addr ip, nmask; + struct sockaddr_storage ss; + struct sockaddr_storage ss_mask; + struct sockaddr_storage ss_net; + struct sockaddr_storage ss_bcast; + struct iface_struct ifs; char *p; - int i, added=0; - - zero_ip(&ip); - zero_ip(&nmask); + int i; + bool added=false; + bool goodaddr = false; /* first check if it is an interface name */ for (i=0;i 2) { - nmask = *interpret_addr2(p); + goodaddr = interpret_string_addr(&ss_mask, p); + if (!goodaddr) { + DEBUG(2,("interpret_interface: " + "can't determine netmask from %s\n", + p)); + return; + } } else { - nmask.s_addr = htonl(((ALLONES >> atoi(p)) ^ ALLONES)); + char *endp = NULL; + unsigned long val = strtoul(p, &endp, 0); + if (p == endp || (endp && *endp != '\0')) { + DEBUG(2,("interpret_interface: " + "can't determine netmask value from %s\n", + p)); + return; + } + if (!make_netmask(&ss_mask, &ss, val)) { + DEBUG(2,("interpret_interface: " + "can't apply netmask value %lu from %s\n", + val, + p)); + return; + } } - /* maybe the first component was a broadcast address */ - if (ip.s_addr == MKBCADDR(ip.s_addr, nmask.s_addr) || - ip.s_addr == MKNETADDR(ip.s_addr, nmask.s_addr)) { + make_bcast(&ss_bcast, &ss, &ss_mask); + make_net(&ss_net, &ss, &ss_mask); + + /* Maybe the first component was a broadcast address. */ + if (addr_equal(&ss_bcast, &ss) || addr_equal(&ss_net, &ss)) { for (i=0;iname); SAFE_FREE(iface); } - /* probe the kernel for interfaces */ + /* Probe the kernel for interfaces */ total_probed = get_interfaces(ifaces, MAX_INTERFACES); if (total_probed > 0) { @@ -208,15 +595,8 @@ void load_interfaces(void) exit(1); } for (i=0;iname); SAFE_FREE(iface); } @@ -255,7 +635,7 @@ void gfree_interfaces(void) Return True if the list of probed interfaces has changed. ****************************************************************************/ -BOOL interfaces_changed(void) +bool interfaces_changed(void) { int n; struct iface_struct ifaces[MAX_INTERFACES]; @@ -263,115 +643,9 @@ BOOL interfaces_changed(void) n = get_interfaces(ifaces, MAX_INTERFACES); if ((n > 0 )&& (n != total_probed || - memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n))) { - return True; - } - - return False; -} - -/**************************************************************************** - Check if an IP is one of mine. -**************************************************************************/ - -BOOL ismyip(struct in_addr ip) -{ - struct interface *i; - for (i=local_interfaces;i;i=i->next) - if (ip_equal(i->ip,ip)) return True; - return False; -} - -/**************************************************************************** - Check if a packet is from a local (known) net. -**************************************************************************/ - -BOOL is_local_net(struct in_addr from) -{ - struct interface *i; - for (i=local_interfaces;i;i=i->next) { - if((from.s_addr & i->nmask.s_addr) == - (i->ip.s_addr & i->nmask.s_addr)) - return True; + memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n))) { + return true; } - return False; -} - -/**************************************************************************** - How many interfaces do we have -**************************************************************************/ - -int iface_count(void) -{ - int ret = 0; - struct interface *i; - - for (i=local_interfaces;i;i=i->next) - ret++; - return ret; -} - -/**************************************************************************** - Return the Nth interface. -**************************************************************************/ - -struct interface *get_interface(int n) -{ - struct interface *i; - - for (i=local_interfaces;i && n;i=i->next) - n--; - - if (i) return i; - return NULL; -} - -/**************************************************************************** - Return IP of the Nth interface. -**************************************************************************/ - -struct in_addr *iface_n_ip(int n) -{ - struct interface *i; - - for (i=local_interfaces;i && n;i=i->next) - n--; - - if (i) return &i->ip; - return NULL; -} - -/**************************************************************************** - Return bcast of the Nth interface. -**************************************************************************/ - -struct in_addr *iface_n_bcast(int n) -{ - struct interface *i; - - for (i=local_interfaces;i && n;i=i->next) - n--; - - if (i) return &i->bcast; - return NULL; -} -/* these 3 functions return the ip/bcast/nmask for the interface - most appropriate for the given ip address. If they can't find - an appropriate interface they return the requested field of the - first known interface. */ - -struct in_addr *iface_ip(struct in_addr ip) -{ - struct interface *i = iface_find(ip, True); - return(i ? &i->ip : &local_interfaces->ip); -} - -/* - return True if a IP is directly reachable on one of our interfaces -*/ - -BOOL iface_local(struct in_addr ip) -{ - return iface_find(ip, True) ? True : False; + return false; } diff --git a/source3/lib/interfaces.c b/source3/lib/interfaces.c index 632b38f2b6..c56155c64e 100644 --- a/source3/lib/interfaces.c +++ b/source3/lib/interfaces.c @@ -101,6 +101,7 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) struct ifaddrs *iflist = NULL; struct ifaddrs *ifptr = NULL; int total = 0; + size_t copy_size; if (getifaddrs(&iflist) < 0) { return -1; @@ -111,25 +112,40 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) ifptr != NULL && total < max_interfaces; ifptr = ifptr->ifa_next) { + memset(&ifaces[total], '\0', sizeof(ifaces[total])); + + copy_size = sizeof(struct sockaddr_in); + if (!ifptr->ifa_addr || !ifptr->ifa_netmask) { continue; } - /* Skip ipv6 for now. */ - if (ifptr->ifa_addr->sa_family != AF_INET) { - continue; - } - if (!(ifptr->ifa_flags & IFF_UP)) { + ifaces[total].flags = ifptr->ifa_flags; + + /* Check the interface is up. */ + if (!(ifaces[total].flags & IFF_UP)) { continue; } - ifaces[total].sa_family = ifptr->ifa_addr->sa_family; - - ifaces[total].iface_addr.ip = - ((struct sockaddr_in *)ifptr->ifa_addr)->sin_addr; +#ifdef AF_INET6 + if (ifptr->ifa_addr->sa_family == AF_INET6) { + copy_size = sizeof(struct sockaddr_in6); + } +#endif - ifaces[total].iface_netmask.netmask = - ((struct sockaddr_in *)ifptr->ifa_netmask)->sin_addr; + memcpy(&ifaces[total].ip, ifptr->ifa_addr, copy_size); + memcpy(&ifaces[total].netmask, ifptr->ifa_netmask, copy_size); + if (ifaces[total].flags & IFF_BROADCAST) { + memcpy(&ifaces[total].bcast, + ifptr->ifa_broadaddr, + copy_size); + } else if (ifaces[total].flags & IFF_POINTOPOINT) { + memcpy(&ifaces[total].bcast, + ifptr->ifa_dstaddr, + copy_size); + } else { + continue; + } strncpy(ifaces[total].name, ifptr->ifa_name, sizeof(ifaces[total].name)-1); @@ -162,9 +178,6 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) int fd, i, n; struct ifreq *ifr=NULL; int total = 0; - struct in_addr ipaddr; - struct in_addr nmask; - char *iname; if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { return -1; @@ -184,32 +197,54 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) /* Loop through interfaces, looking for given IP address */ for (i=n-1;i>=0 && total < max_interfaces;i--) { - if (ioctl(fd, SIOCGIFADDR, &ifr[i]) != 0) { + + memset(&ifaces[total], '\0', sizeof(ifaces[total])); + + /* Check the interface is up. */ + if (ioctl(fd, SIOCGIFFLAGS, &ifr[i]) != 0) { continue; } - iname = ifr[i].ifr_name; - ipaddr = (*(struct sockaddr_in *)&ifr[i].ifr_addr).sin_addr; + ifaces[total].flags = ifr[i].ifr_flags; - if (ioctl(fd, SIOCGIFFLAGS, &ifr[i]) != 0) { + if (!(flags & IFF_UP)) { continue; } - if (!(ifr[i].ifr_flags & IFF_UP)) { + if (ioctl(fd, SIOCGIFADDR, &ifr[i]) != 0) { continue; } + strncpy(ifaces[total].name, ifr[i].ifr_name, + sizeof(ifaces[total].name)-1); + ifaces[total].name[sizeof(ifaces[total].name)-1] = 0; + + memcpy(&ifaces[total].ip, &ifr[i].ifr_addr, + sizeof(struct sockaddr_in)); + if (ioctl(fd, SIOCGIFNETMASK, &ifr[i]) != 0) { continue; } - nmask = ((struct sockaddr_in *)&ifr[i].ifr_addr)->sin_addr; + memcpy(&ifaces[total].netmask, &ifr[i].ifr_netmask, + sizeof(struct sockaddr_in)); + + if (ifaces[total].flags & IFF_BROADCAST) { + if (ioctl(fd, SIOCGIFBRDADDR, &ifr[i]) != 0) { + continue; + } + memcpy(&ifaces[total].bcast, &ifr[i].ifr_broadaddr, + sizeof(struct sockaddr_in)); + } else if (ifaces[total].flags & IFF_POINTOPOINT) { + if (ioctl(fd, SIOCGIFDSTADDR, &ifr[i]) != 0) { + continue; + } + memcpy(&ifaces[total].bcast, &ifr[i].ifr_dstaddr, + sizeof(struct sockaddr_in)); + } else { + continue; + } - strncpy(ifaces[total].name, iname, sizeof(ifaces[total].name)-1); - ifaces[total].name[sizeof(ifaces[total].name)-1] = 0; - ifaces[total].sa_family = AF_INET; - ifaces[total].iface_addr.ip = ipaddr; - ifaces[total].iface_netmask.netmask = nmask; total++; } @@ -239,9 +274,6 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) int fd, i, n; struct ifreq *ifr=NULL; int total = 0; - struct in_addr ipaddr; - struct in_addr nmask; - char *iname; if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { return -1; @@ -271,6 +303,9 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) /* Loop through interfaces */ for (i = 0; isin_addr; + memcpy(&ifaces[total].netmask, &ifreq.ifr_addr, + sizeof(struct sockaddr_in)); - strncpy(ifaces[total].name, iname, sizeof(ifaces[total].name)-1); - ifaces[total].name[sizeof(ifaces[total].name)-1] = 0; - ifaces[total].sa_family = AF_INET; - ifaces[total].iface_addr.ip = ipaddr; - ifaces[total].iface_netmask.netmask = nmask; + if (ifaces[total].flags & IFF_BROADCAST) { + strioctl.ic_cmd = SIOCGIFBRDADDR; + strioctl.ic_dp = (char *)&ifreq; + strioctl.ic_len = sizeof(struct ifreq); + if (ioctl(fd, I_STR, &strioctl) != 0) { + continue; + } + memcpy(&ifaces[total].bcast, &ifreq.ifr_broadaddr, + sizeof(struct sockaddr_in)); + } else if (ifaces[total].flags & IFF_POINTOPOINT) { + strioctl.ic_cmd = SIOCGIFDSTADDR; + strioctl.ic_dp = (char *)&ifreq; + strioctl.ic_len = sizeof(struct ifreq); + if (ioctl(fd, I_STR, &strioctl) != 0) { + continue; + } + memcpy(&ifaces[total].bcast, &ifreq.ifr_dstaddr, + sizeof(struct sockaddr_in)); + } else { + continue; + } total++; } @@ -331,9 +389,6 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) int fd, i; struct ifconf ifc; struct ifreq *ifr=NULL; - struct in_addr ipaddr; - struct in_addr nmask; - char *iname; int total = 0; if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { @@ -357,34 +412,54 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) while (i > 0 && total < max_interfaces) { uint_t inc; + memset(&ifaces[total], '\0', sizeof(ifaces[total])); + inc = ifr->ifr_addr.sa_len; - if (ioctl(fd, SIOCGIFADDR, ifr) != 0) { + if (ioctl(fd, SIOCGIFFLAGS, ifr) != 0) { goto next; } - ipaddr = (*(struct sockaddr_in *) &ifr->ifr_addr).sin_addr; - iname = ifr->ifr_name; + ifaces[total].flags = ifr->ifr_flags; - if (ioctl(fd, SIOCGIFFLAGS, ifr) != 0) { + if (!(ifaces[total].flags & IFF_UP)) { goto next; } - if (!(ifr->ifr_flags & IFF_UP)) { + if (ioctl(fd, SIOCGIFADDR, ifr) != 0) { goto next; } + memcpy(&ifaces[total].ip, &ifr->ifr_addr, + sizeof(struct sockaddr_in)); + + strncpy(ifaces[total].name, ifr->ifr_name, + sizeof(ifaces[total].name)-1); + ifaces[total].name[sizeof(ifaces[total].name)-1] = 0; + if (ioctl(fd, SIOCGIFNETMASK, ifr) != 0) { goto next; } - nmask = ((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr; + memcpy(&ifaces[total].netmask, &ifr->ifr_addr, + sizeof(struct sockaddr_in)); + + if (ifaces[total].flags & IFF_BROADCAST) { + if (ioctl(fd, SIOCGIFBRDADDR, &ifr[i]) != 0) { + continue; + } + memcpy(&ifaces[total].bcast, &ifr[i].ifr_broadaddr, + sizeof(struct sockaddr_in)); + } else if (ifaces[total].flags & IFF_POINTOPOINT) { + if (ioctl(fd, SIOCGIFDSTADDR, &ifr[i]) != 0) { + continue; + } + memcpy(&ifaces[total].bcast, &ifr[i].ifr_dstaddr, + sizeof(struct sockaddr_in)); + } else { + continue; + } - strncpy(ifaces[total].name, iname, sizeof(ifaces[total].name)-1); - ifaces[total].name[sizeof(ifaces[total].name)-1] = 0; - ifaces[total].sa_family = AF_INET; - ifaces[total].iface_addr.ip = ipaddr; - ifaces[total].iface_netmask.netmask = nmask; total++; @@ -421,25 +496,36 @@ static int _get_interfaces(struct iface_struct *ifaces, int max_interfaces) static int iface_comp(struct iface_struct *i1, struct iface_struct *i2) { int r; - r = strcmp(i1->name, i2->name); - if (r) { - return r; - } - r = i1->sa_family - i2->sa_family; - if (r) { - return r; - } #ifdef AF_INET6 - if (i1->sa_family == AF_INET6) { - r = memcmp(&i1->iface_addr.ip6, - &i2->iface_addr.ip6, + /* + * If we have IPv6 - sort these interfaces lower + * than any IPv4 ones. + */ + if (i1->ip.ss_family == AF_INET6 && + i2->ip.ss_family == AF_INET) { + return -1; + } else if (i1->ip.ss_family == AF_INET && + i2->ip.ss_family == AF_INET6) { + return 1; + } + + if (i1->ip.ss_family == AF_INET6) { + struct sockaddr_in6 *s1 = (struct sockaddr_in6 *)&i1->ip; + struct sockaddr_in6 *s2 = (struct sockaddr_in6 *)&i2->ip; + + r = memcmp(&s1->sin6_addr, + &s2->sin6_addr, sizeof(struct in6_addr)); if (r) { return r; } - r = memcmp(&i1->iface_netmask.netmask6, - &i1->iface_netmask.netmask6, + + s1 = (struct sockaddr_in6 *)&i1->netmask; + s2 = (struct sockaddr_in6 *)&i2->netmask; + + r = memcmp(&s1->sin6_addr, + &s2->sin6_addr, sizeof(struct in6_addr)); if (r) { return r; @@ -447,14 +533,21 @@ static int iface_comp(struct iface_struct *i1, struct iface_struct *i2) } #endif - if (i1->sa_family == AF_INET) { - r = ntohl(i1->iface_addr.ip.s_addr) - - ntohl(i2->iface_addr.ip.s_addr); + if (i1->ip.ss_family == AF_INET) { + struct sockaddr_in *s1 = (struct sockaddr_in *)&i1->ip; + struct sockaddr_in *s2 = (struct sockaddr_in *)&i2->ip; + + r = ntohl(s1->sin_addr.s_addr) - + ntohl(s2->sin_addr.s_addr); if (r) { return r; } - r = ntohl(i1->iface_netmask.netmask.s_addr) - - ntohl(i2->iface_netmask.netmask.s_addr); + + s1 = (struct sockaddr_in *)&i1->netmask; + s2 = (struct sockaddr_in *)&i2->netmask; + + r = ntohl(s1->sin_addr.s_addr) - + ntohl(s2->sin_addr.s_addr); } return r; } @@ -503,15 +596,26 @@ int get_interfaces(struct iface_struct *ifaces, int max_interfaces) for (i=0;ih_addr == NULL) { - DEBUG(3,("sys_gethostbyname: host address is invalid for host %s\n",str)); - return 0; - } - putip((char *)&res,(char *)hp->h_addr); - } - - if (res == (uint32)-1) - return(0); - - return(res); -} - -/******************************************************************* - A convenient addition to interpret_addr(). -******************************************************************/ - -struct in_addr *interpret_addr2(const char *str) -{ - static struct in_addr ret; - uint32 a = interpret_addr(str); - ret.s_addr = a; - return(&ret); -} - -/******************************************************************* - Check if an IP is the 0.0.0.0. -******************************************************************/ - -BOOL is_zero_ip(struct in_addr ip) -{ - uint32 a; - putip((char *)&a,(char *)&ip); - return(a == 0); -} - -/******************************************************************* - Set an IP to 0.0.0.0. -******************************************************************/ - -void zero_ip(struct in_addr *ip) -{ - static BOOL init; - static struct in_addr ipzero; - - if (!init) { - ipzero = *interpret_addr2("0.0.0.0"); - init = True; - } - - *ip = ipzero; -} #if (defined(HAVE_NETGROUP) && defined(WITH_AUTOMOUNT)) /****************************************************************** @@ -1506,22 +1410,6 @@ char *automount_lookup(const char *user_name) #endif /* WITH_NISPLUS_HOME */ #endif -/******************************************************************* - Are two IPs on the same subnet? -********************************************************************/ - -BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask) -{ - uint32 net1,net2,nmask; - - nmask = ntohl(mask.s_addr); - net1 = ntohl(ip1.s_addr); - net2 = ntohl(ip2.s_addr); - - return((net1 & nmask) == (net2 & nmask)); -} - - /**************************************************************************** Check if a process exists. Does this work on all unixes? ****************************************************************************/ @@ -2097,83 +1985,6 @@ BOOL is_myname(const char *s) return(ret); } -BOOL is_myname_or_ipaddr(const char *s) -{ - fstring name, dnsname; - char *servername; - - if ( !s ) - return False; - - /* santize the string from '\\name' */ - - fstrcpy( name, s ); - - servername = strrchr_m( name, '\\' ); - if ( !servername ) - servername = name; - else - servername++; - - /* optimize for the common case */ - - if (strequal(servername, global_myname())) - return True; - - /* check for an alias */ - - if (is_myname(servername)) - return True; - - /* check for loopback */ - - if (strequal(servername, "127.0.0.1")) - return True; - - if (strequal(servername, "localhost")) - return True; - - /* maybe it's my dns name */ - - if ( get_mydnsfullname( dnsname ) ) - if ( strequal( servername, dnsname ) ) - return True; - - /* handle possible CNAME records */ - - if ( !is_ipaddress( servername ) ) { - /* use DNS to resolve the name, but only the first address */ - struct hostent *hp; - - if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) { - struct in_addr return_ip; - putip( (char*)&return_ip, (char*)hp->h_addr ); - fstrcpy( name, inet_ntoa( return_ip ) ); - servername = name; - } - } - - /* maybe its an IP address? */ - if (is_ipaddress(servername)) { - struct iface_struct nics[MAX_INTERFACES]; - int i, n; - uint32 ip; - - ip = interpret_addr(servername); - if ((ip==0) || (ip==0xffffffff)) - return False; - - n = get_interfaces(nics, MAX_INTERFACES); - for (i=0; i 0) { - dest[0] = '\0'; + bool pure_address = true; + int i; + + for (i=0; pure_address && str[i]; i++) { + if (!(isdigit((int)str[i]) || str[i] == '.')) { + pure_address = false; + } + } + + /* Check that a pure number is not misinterpreted as an IP */ + pure_address = pure_address && (strchr_m(str, '.') != NULL); + return pure_address; +} + +/**************************************************************************** + Interpret an internet address or name into an IP address in 4 byte form. +****************************************************************************/ + +uint32 interpret_addr(const char *str) +{ + struct hostent *hp; + uint32 res; + + if (strcmp(str,"0.0.0.0") == 0) + return(0); + if (strcmp(str,"255.255.255.255") == 0) + return(0xFFFFFFFF); + + /* if it's in the form of an IP address then + * get the lib to interpret it */ + if (is_ipaddress_v4(str)) { + res = inet_addr(str); + } else { + /* otherwise assume it's a network name of some sort and use + sys_gethostbyname */ + if ((hp = sys_gethostbyname(str)) == 0) { + DEBUG(3,("sys_gethostbyname: Unknown host. %s\n",str)); + return 0; + } + + if(hp->h_addr == NULL) { + DEBUG(3,("sys_gethostbyname: host address is " + "invalid for host %s\n",str)); + return 0; + } + putip((char *)&res,(char *)hp->h_addr); + } + + if (res == (uint32)-1) + return(0); + + return(res); +} + +/******************************************************************* + A convenient addition to interpret_addr(). +******************************************************************/ + +struct in_addr *interpret_addr2(const char *str) +{ + static struct in_addr ret; + uint32 a = interpret_addr(str); + ret.s_addr = a; + return(&ret); +} + +/******************************************************************* + Map a text hostname or IP address (IPv4 or IPv6) into a + struct sockaddr_storage. +******************************************************************/ + +bool interpret_string_addr(struct sockaddr_storage *pss, const char *str) +{ + int ret; + struct addrinfo *res = NULL; + struct addrinfo hints; + + memset(pss,'\0', sizeof(*pss)); + + memset(&hints, '\0', sizeof(hints)); + /* By default make sure it supports TCP. */ + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_ADDRCONFIG; + + ret = getaddrinfo(str, NULL, + &hints, + &res); + + if (ret) { + DEBUG(3,("interpret_string_addr: getaddrinfo failed for " + "name %s [%s]\n", + str, + gai_strerror(ret) )); + return false; + } + + /* Copy the first sockaddr. */ + memcpy(pss, res->ai_addr, res->ai_addrlen); + freeaddrinfo(res); + return true; +} + +/******************************************************************* + Check if an IPv7 is 127.0.0.1 +******************************************************************/ + +bool is_loopback_ip_v4(struct in_addr ip) +{ + struct in_addr a; + a.s_addr = htonl(INADDR_LOOPBACK); + return(ip.s_addr == a.s_addr); +} + +/******************************************************************* + Check if a struct sockaddr_storage is the loopback address. +******************************************************************/ + +bool is_loopback_addr(const struct sockaddr_storage *pss) +{ +#if defined(AF_INET6) + if (pss->ss_family == AF_INET) { + struct in6_addr *pin6 = &((struct sockaddr_in6 *)pss)->sin6_addr; + return IN6_IS_ADDR_LOOPBACK(pin6); + } +#endif + if (pss->ss_family == AF_INET) { + struct in_addr *pin = &((struct sockaddr_in *)pss)->sin_addr; + return is_loopback_ip_v4(*pin); + } + return false; +} + +/******************************************************************* + Check if an IPv4 is 0.0.0.0. +******************************************************************/ + +bool is_zero_ip_v4(struct in_addr ip) +{ + uint32 a; + putip((char *)&a,(char *)&ip); + return(a == 0); +} + +/******************************************************************* + Check if a struct sockaddr_storage has an unspecified address. +******************************************************************/ + +bool is_zero_addr(const struct sockaddr_storage *pss) +{ +#if defined(AF_INET6) + if (pss->ss_family == AF_INET) { + struct in6_addr *pin6 = &((struct sockaddr_in6 *)pss)->sin6_addr; + return IN6_IS_ADDR_UNSPECIFIED(pin6); + } +#endif + if (pss->ss_family == AF_INET) { + struct in_addr *pin = &((struct sockaddr_in *)pss)->sin_addr; + return is_zero_ip_v4(*pin); } + return false; +} + +/******************************************************************* + Set an IP to 0.0.0.0. +******************************************************************/ + +void zero_ip_v4(struct in_addr *ip) +{ + static bool init; + static struct in_addr ipzero; + + if (!init) { + ipzero = *interpret_addr2("0.0.0.0"); + init = true; + } + + *ip = ipzero; +} + +/******************************************************************* + Are two IPs on the same subnet - IPv4 version ? +********************************************************************/ + +bool same_net_v4(struct in_addr ip1,struct in_addr ip2,struct in_addr mask) +{ + uint32 net1,net2,nmask; + + nmask = ntohl(mask.s_addr); + net1 = ntohl(ip1.s_addr); + net2 = ntohl(ip2.s_addr); + + return((net1 & nmask) == (net2 & nmask)); +} + +/******************************************************************* + Convert an IPv4 struct in_addr to a struct sockaddr_storage. +********************************************************************/ + +void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss, + struct in_addr ip) +{ + struct sockaddr_in *sa = (struct sockaddr_in *)ss; + memset(ss, '\0', sizeof(*ss)); + ss->ss_family = AF_INET; + sa->sin_addr = ip; +} + +#ifdef AF_INET6 +/******************************************************************* + Convert an IPv6 struct in_addr to a struct sockaddr_storage. +********************************************************************/ + +void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss, + struct in6_addr ip) +{ + struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss; + memset(ss, '\0', sizeof(*ss)); + ss->ss_family = AF_INET6; + sa->sin6_addr = ip; +} +#endif + +/******************************************************************* + Are two IPs on the same subnet? +********************************************************************/ + +bool same_net(const struct sockaddr_storage *ip1, + const struct sockaddr_storage *ip2, + const struct sockaddr_storage *mask) +{ + if (ip1->ss_family != ip2->ss_family) { + /* Never on the same net. */ + return false; + } + +#ifdef AF_INET6 + if (ip1->ss_family == AF_INET6) { + struct sockaddr_in6 ip1_6 = *(struct sockaddr_in6 *)ip1; + struct sockaddr_in6 ip2_6 = *(struct sockaddr_in6 *)ip2; + struct sockaddr_in6 mask_6 = *(struct sockaddr_in6 *)mask; + char *p1 = (char *)&ip1_6.sin6_addr; + char *p2 = (char *)&ip2_6.sin6_addr; + char *m = (char *)&mask_6.sin6_addr; + int i; + + for (i = 0; i < sizeof(struct in6_addr); i++) { + *p1++ &= *m; + *p2++ &= *m; + m++; + } + return (memcmp(&ip1_6.sin6_addr, + &ip2_6.sin6_addr, + sizeof(struct in6_addr)) == 0); + } +#endif + if (ip1->ss_family == AF_INET) { + return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr, + ((const struct sockaddr_in *)ip2)->sin_addr, + ((const struct sockaddr_in *)mask)->sin_addr); + } + return false; +} + +/******************************************************************* + Are two sockaddr_storage's the same family and address ? Ignore port etc. +********************************************************************/ + +bool addr_equal(const struct sockaddr_storage *ip1, + const struct sockaddr_storage *ip2) +{ + if (ip1->ss_family != ip2->ss_family) { + /* Never the same. */ + return false; + } + +#ifdef AF_INET6 + if (ip1->ss_family == AF_INET6) { + return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr, + &((const struct sockaddr_in6 *)ip2)->sin6_addr, + sizeof(struct in6_addr)) == 0); + } +#endif + if (ip1->ss_family == AF_INET) { + return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr, + &((const struct sockaddr_in *)ip2)->sin_addr, + sizeof(struct in_addr)) == 0); + } + return false; +} + + +/**************************************************************************** + Is an IP address the INADDR_ANY or in6addr_any value ? +****************************************************************************/ + +bool is_address_any(const struct sockaddr_storage *psa) +{ #ifdef AF_INET6 if (psa->ss_family == AF_INET6) { - inet_ntop(AF_INET6, - &((struct sockaddr_in6 *)psa)->sin6_addr, - dest, - destlen); + struct sockaddr_in6 *si6 = (struct sockaddr_in6 *)psa; + if (memcmp(&in6addr_any, + &si6->sin6_addr, + sizeof(in6addr_any)) == 0) { + return true; + } + return false; } #endif if (psa->ss_family == AF_INET) { - inet_ntop(AF_INET, - &((struct sockaddr_in *)psa)->sin_addr, - dest, - destlen); + struct sockaddr_in *si = (struct sockaddr_in *)psa; + if (si->sin_addr.s_addr == INADDR_ANY) { + return true; + } + return false; } + return false; +} + +/**************************************************************************** + Print out an IPv4 or IPv6 address from a struct sockaddr_storage. +****************************************************************************/ + +char *print_sockaddr(char *dest, + size_t destlen, + const struct sockaddr_storage *psa, + socklen_t psalen) +{ + if (destlen > 0) { + dest[0] = '\0'; + } + (void)getnameinfo((const struct sockaddr *)psa, + psalen, + dest, destlen, + NULL, 0, + NI_NUMERICHOST); return dest; } +/**************************************************************************** + Set the global client_fd variable. +****************************************************************************/ + void client_setfd(int fd) { client_fd = fd; @@ -64,6 +384,10 @@ void client_setfd(int fd) sizeof(client_ip_string)-1); } +/**************************************************************************** + Return a static string of an IP address (IPv4 or IPv6). +****************************************************************************/ + static char *get_socket_addr(int fd) { struct sockaddr_storage sa; @@ -87,9 +411,13 @@ static char *get_socket_addr(int fd) return addr_buf; } - return print_sockaddr(addr_buf, sizeof(addr_buf), &sa); + return print_sockaddr(addr_buf, sizeof(addr_buf), &sa, length); } +/**************************************************************************** + Return the port number we've bound to on a socket. +****************************************************************************/ + static int get_socket_port(int fd) { struct sockaddr_storage sa; @@ -118,7 +446,7 @@ static int get_socket_port(int fd) char *client_name(void) { - return get_peer_name(client_fd,False); + return get_peer_name(client_fd,false); } char *client_addr(void) @@ -142,7 +470,7 @@ int smb_read_error = 0; Determine if a file descriptor is in fact a socket. ****************************************************************************/ -BOOL is_a_socket(int fd) +bool is_a_socket(int fd) { int v; socklen_t l; @@ -247,12 +575,12 @@ void set_socket_options(int fd, const char *options) int ret=0,i; int value = 1; char *p; - BOOL got_value = False; + bool got_value = false; if ((p = strchr_m(tok,'='))) { *p = 0; value = atoi(p+1); - got_value = True; + got_value = true; } for (i=0;socket_options[i].name;i++) @@ -559,7 +887,7 @@ ssize_t write_data(int fd, const char *buffer, size_t N) Send a keepalive packet (rfc1002). ****************************************************************************/ -BOOL send_keepalive(int client) +bool send_keepalive(int client) { unsigned char buf[4]; @@ -583,7 +911,7 @@ static ssize_t read_smb_length_return_keepalive(int fd, { ssize_t len=0; int msg_type; - BOOL ok = False; + bool ok = false; while (!ok) { if (timeout > 0) { @@ -809,23 +1137,23 @@ static ssize_t receive_smb_raw_talloc(TALLOC_CTX *mem_ctx, int fd, Checks the MAC on signed packets. ****************************************************************************/ -BOOL receive_smb(int fd, char *buffer, unsigned int timeout) +bool receive_smb(int fd, char *buffer, unsigned int timeout) { if (receive_smb_raw(fd, buffer, timeout, 0) < 0) { - return False; + return false; } /* Check the incoming SMB signature. */ - if (!srv_check_sign_mac(buffer, True)) { + if (!srv_check_sign_mac(buffer, true)) { DEBUG(0, ("receive_smb: SMB Signature verification " "failed on incoming packet!\n")); if (smb_read_error == 0) { smb_read_error = READ_BAD_SIG; } - return False; + return false; } - return True; + return true; } ssize_t receive_smb_talloc(TALLOC_CTX *mem_ctx, int fd, char **buffer, @@ -840,7 +1168,7 @@ ssize_t receive_smb_talloc(TALLOC_CTX *mem_ctx, int fd, char **buffer, } /* Check the incoming SMB signature. */ - if (!srv_check_sign_mac(*buffer, True)) { + if (!srv_check_sign_mac(*buffer, true)) { DEBUG(0, ("receive_smb: SMB Signature verification failed on " "incoming packet!\n")); if (smb_read_error == 0) { @@ -856,7 +1184,7 @@ ssize_t receive_smb_talloc(TALLOC_CTX *mem_ctx, int fd, char **buffer, Send an smb to a fd. ****************************************************************************/ -BOOL send_smb(int fd, char *buffer) +bool send_smb(int fd, char *buffer) { size_t len; size_t nwritten=0; @@ -872,12 +1200,12 @@ BOOL send_smb(int fd, char *buffer) if (ret <= 0) { DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n", (int)len,(int)ret, strerror(errno) )); - return False; + return false; } nwritten += ret; } - return True; + return true; } /**************************************************************************** @@ -888,7 +1216,7 @@ int open_socket_in(int type, int port, int dlevel, uint32 socket_addr, - BOOL rebind ) + bool rebind ) { struct sockaddr_in sock; int res; @@ -919,7 +1247,7 @@ int open_socket_in(int type, if( DEBUGLVL( dlevel ) ) { dbgtext( "open_socket_in(): setsockopt: " ); dbgtext( "SO_REUSEADDR = %s ", - val?"True":"False" ); + val?"true":"false" ); dbgtext( "on port %d failed ", port ); dbgtext( "with error = %s\n", strerror(errno) ); } @@ -930,7 +1258,7 @@ int open_socket_in(int type, if( DEBUGLVL( dlevel ) ) { dbgtext( "open_socket_in(): setsockopt: "); dbgtext( "SO_REUSEPORT = %s ", - val?"True":"False" ); + val?"true":"false" ); dbgtext( "on port %d failed ", port ); dbgtext( "with error = %s\n", strerror(errno) ); } @@ -984,7 +1312,7 @@ int open_socket_out(int type, struct in_addr *addr, int port ,int timeout) sock_out.sin_family = PF_INET; /* set it non-blocking */ - set_blocking(res,False); + set_blocking(res,false); DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port)); @@ -1029,7 +1357,7 @@ int open_socket_out(int type, struct in_addr *addr, int port ,int timeout) } /* set it blocking again */ - set_blocking(res,True); + set_blocking(res,true); return res; } @@ -1040,12 +1368,12 @@ int open_socket_out(int type, struct in_addr *addr, int port ,int timeout) of DC's all of which are equivalent for our purposes. **************************************************************************/ -BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs, +bool open_any_socket_out(struct sockaddr_in *addrs, int num_addrs, int timeout, int *fd_index, int *fd) { int i, resulting_index, res; int *sockets; - BOOL good_connect; + bool good_connect; fd_set r_fds, wr_fds; struct timeval tv; @@ -1058,7 +1386,7 @@ BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs, sockets = SMB_MALLOC_ARRAY(int, num_addrs); if (sockets == NULL) - return False; + return false; resulting_index = -1; @@ -1069,11 +1397,11 @@ BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs, sockets[i] = socket(PF_INET, SOCK_STREAM, 0); if (sockets[i] < 0) goto done; - set_blocking(sockets[i], False); + set_blocking(sockets[i], false); } connect_again: - good_connect = False; + good_connect = false; for (i=0; i= 0) { *fd_index = resulting_index; *fd = sockets[*fd_index]; - set_blocking(*fd, True); + set_blocking(*fd, true); } free(sockets); @@ -1223,7 +1551,7 @@ int open_udp_socket(const char *host, int port) confirm a hostname lookup to prevent spoof attacks. ******************************************************************/ -static BOOL matchname(char *remotehost,struct in_addr addr) +static bool matchname(char *remotehost,struct in_addr addr) { struct hostent *hp; int i; @@ -1231,7 +1559,7 @@ static BOOL matchname(char *remotehost,struct in_addr addr) if ((hp = sys_gethostbyname(remotehost)) == 0) { DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost)); - return False; + return false; } /* @@ -1246,13 +1574,13 @@ static BOOL matchname(char *remotehost,struct in_addr addr) && !strequal(remotehost, "localhost")) { DEBUG(0,("host name/name mismatch: %s != %s\n", remotehost, hp->h_name)); - return False; + return false; } /* Look up the host address in the address list we just got. */ for (i = 0; hp->h_addr_list[i]; i++) { if (memcmp(hp->h_addr_list[i], (char *)&addr,sizeof(addr)) == 0) - return True; + return true; } /* @@ -1263,14 +1591,14 @@ static BOOL matchname(char *remotehost,struct in_addr addr) DEBUG(0,("host name/address mismatch: %s != %s\n", inet_ntoa(addr), hp->h_name)); - return False; + return false; } /******************************************************************* Return the DNS name of the remote end of a socket. ******************************************************************/ -char *get_peer_name(int fd, BOOL force_lookup) +char *get_peer_name(int fd, bool force_lookup) { static pstring name_buf; pstring tmp_name; @@ -1283,7 +1611,7 @@ char *get_peer_name(int fd, BOOL force_lookup) situations won't work because many networks don't link dhcp with dns. To avoid the delay we avoid the lookup if possible */ - if (!lp_hostname_lookups() && (force_lookup == False)) { + if (!lp_hostname_lookups() && (force_lookup == false)) { return get_peer_addr(fd); } @@ -1450,3 +1778,92 @@ out_umask: return -1; #endif /* HAVE_UNIXSOCKET */ } + +/************************************************************ + Is this my name ? Needs fixing for IPv6. +************************************************************/ + +bool is_myname_or_ipaddr(const char *s) +{ + fstring name, dnsname; + char *servername; + + if ( !s ) + return false; + + /* santize the string from '\\name' */ + + fstrcpy( name, s ); + + servername = strrchr_m( name, '\\' ); + if ( !servername ) + servername = name; + else + servername++; + + /* optimize for the common case */ + + if (strequal(servername, global_myname())) + return true; + + /* check for an alias */ + + if (is_myname(servername)) + return true; + + /* check for loopback */ + + if (strequal(servername, "127.0.0.1")) + return true; + + if (strequal(servername, "localhost")) + return true; + + /* maybe it's my dns name */ + + if ( get_mydnsfullname( dnsname ) ) + if ( strequal( servername, dnsname ) ) + return true; + + /* handle possible CNAME records */ + + if ( !is_ipaddress_v4( servername ) ) { + /* use DNS to resolve the name, but only the first address */ + struct hostent *hp; + + if (((hp = sys_gethostbyname(name)) != NULL) && (hp->h_addr != NULL)) { + struct in_addr return_ip; + putip( (char*)&return_ip, (char*)hp->h_addr ); + fstrcpy( name, inet_ntoa( return_ip ) ); + servername = name; + } + } + + /* maybe its an IP address? */ + if (is_ipaddress_v4(servername)) { + struct sockaddr_storage ss; + struct iface_struct nics[MAX_INTERFACES]; + int i, n; + struct in_addr ip; + + ip = *interpret_addr2(servername); + if (is_zero_ip_v4(ip) || is_loopback_ip_v4(ip)) { + return false; + } + + in_addr_to_sockaddr_storage(&ss, ip); + + n = get_interfaces(nics, MAX_INTERFACES); + for (i=0; i