continue;
}
- if (ismyip(dest_ip)) {
+ if (ismyip_v4(dest_ip)) {
DEBUG(1,("Password server loop - disabling password server %s\n",desthost));
continue;
}
snprintf(name_type_hex, sizeof(name_type_hex), "#%X", name_type);
fstrcat(server_name, name_type_hex);
- zero_ip(&ip);
+ zero_ip_v4(&ip);
if (have_ip)
ip = dest_ip;
case 'I':
{
dest_ip = *interpret_addr2(poptGetOptArg(pc));
- if (is_zero_ip(dest_ip))
+ if (is_zero_ip_v4(dest_ip))
exit(1);
have_ip = True;
-/*
+/*
This structure is used by lib/interfaces.c to return the list of network
interfaces on the machine
*/
struct iface_struct {
char name[16];
- sa_family_t sa_family;
- union {
- struct in_addr ip;
-#ifdef AF_INET6
- struct in6_addr ip6;
-#endif
- } iface_addr;
- union {
- struct in_addr netmask;
-#ifdef AF_INET6
- struct in6_addr netmask6;
-#endif
- } iface_netmask;
+ int flags;
+ struct sockaddr_storage ip;
+ struct sockaddr_storage netmask;
+ struct sockaddr_storage bcast;
};
/* used for network interfaces */
struct interface {
struct interface *next, *prev;
- struct in_addr ip;
- struct in_addr bcast;
- struct in_addr nmask;
+ char *name;
+ int flags;
+ struct sockaddr_storage ip;
+ struct sockaddr_storage netmask;
+ struct sockaddr_storage bcast;
};
/* Internal message queue for deferred opens. */
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
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
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);
}
/****************************************************************************
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<total_probed;i++) {
if (gen_fnmatch(token, probed_ifaces[i].name) == 0) {
- add_interface(probed_ifaces[i].iface_addr.ip,
- probed_ifaces[i].iface_netmask.netmask);
- added = 1;
+ add_interface(&probed_ifaces[i]);
+ added = true;
}
}
- if (added) return;
+ if (added) {
+ return;
+ }
/* maybe it is a DNS name */
p = strchr_m(token,'/');
- if (!p) {
- ip = *interpret_addr2(token);
+ if (!p && interpret_string_addr(&ss, token)) {
for (i=0;i<total_probed;i++) {
- if (ip.s_addr == probed_ifaces[i].iface_addr.ip.s_addr
- && !ip_equal(allones_ip,
- probed_ifaces[i].iface_netmask.netmask)) {
- add_interface(probed_ifaces[i].iface_addr.ip,
- probed_ifaces[i].iface_netmask.netmask);
+ if (addr_equal(&ss, &probed_ifaces[i].ip)) {
+ add_interface(&probed_ifaces[i]);
return;
}
}
- DEBUG(2,("can't determine netmask for %s\n", token));
+ DEBUG(2,("interpret_interface: "
+ "can't determine interface for %s\n",
+ token));
return;
}
/* parse it into an IP address/netmasklength pair */
*p = 0;
- ip = *interpret_addr2(token);
+ goodaddr = interpret_string_addr(&ss, token);
*p++ = '/';
+ if (!goodaddr) {
+ DEBUG(2,("interpret_interface: "
+ "can't determine interface for %s\n",
+ token));
+ return;
+ }
+
if (strlen(p) > 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;i<total_probed;i++) {
- if (same_net(ip, probed_ifaces[i].iface_addr.ip,
- nmask)) {
- add_interface(probed_ifaces[i].iface_addr.ip,
- nmask);
+ if (same_net(&ss, &probed_ifaces[i].ip, &ss_mask)) {
+ /* Temporarily replace netmask on
+ * the detected interface - user knows
+ * best.... */
+ struct sockaddr_storage saved_mask =
+ probed_ifaces[i].netmask;
+ probed_ifaces[i].netmask = ss_mask;
+ DEBUG(2,("interpret_interface: "
+ "using netmask value %s from "
+ "config file on interface %s\n",
+ p,
+ probed_ifaces[i].name));
+ add_interface(&probed_ifaces[i]);
+ probed_ifaces[i].netmask = saved_mask;
return;
}
}
- DEBUG(2,("Can't determine ip for broadcast address %s\n",
- token));
+ DEBUG(2,("interpret_interface: Can't determine ip for "
+ "broadcast address %s\n",
+ token));
return;
}
- add_interface(ip, nmask);
+ /* Just fake up the interface definition. User knows best. */
+
+ DEBUG(2,("interpret_interface: Adding interface %s\n",
+ token));
+
+ ZERO_STRUCT(ifs);
+ safe_strcpy(ifs.name, token, sizeof(ifs.name)-1);
+ ifs.flags = IFF_BROADCAST;
+ ifs.ip = ss;
+ ifs.netmask = ss_mask;
+ ifs.bcast = ss_bcast;
+ add_interface(&ifs);
}
/****************************************************************************
void load_interfaces(void)
{
- const char **ptr;
- int i;
struct iface_struct ifaces[MAX_INTERFACES];
-
- ptr = lp_interfaces();
-
- allones_ip = *interpret_addr2("255.255.255.255");
- loopback_ip = *interpret_addr2("127.0.0.1");
+ const char **ptr = lp_interfaces();
+ int i;
SAFE_FREE(probed_ifaces);
while (local_interfaces) {
struct interface *iface = local_interfaces;
DLIST_REMOVE(local_interfaces, local_interfaces);
- ZERO_STRUCTPN(iface);
+ SAFE_FREE(iface->name);
SAFE_FREE(iface);
}
- /* probe the kernel for interfaces */
+ /* Probe the kernel for interfaces */
total_probed = get_interfaces(ifaces, MAX_INTERFACES);
if (total_probed > 0) {
exit(1);
}
for (i=0;i<total_probed;i++) {
- if (
-#if !defined(__s390__)
- probed_ifaces[i].iface_netmask.netmask.s_addr !=
- allones_ip.s_addr &&
-#endif
- probed_ifaces[i].iface_addr.ip.s_addr !=
- loopback_ip.s_addr) {
- add_interface(probed_ifaces[i].iface_addr.ip,
- probed_ifaces[i].iface_netmask.netmask);
+ if (probed_ifaces[i].flags & IFF_BROADCAST) {
+ add_interface(&probed_ifaces[i]);
}
}
return;
while (local_interfaces) {
struct interface *iface = local_interfaces;
DLIST_REMOVE(local_interfaces, local_interfaces);
- ZERO_STRUCTPN(iface);
+ SAFE_FREE(iface->name);
SAFE_FREE(iface);
}
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];
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;
}
struct ifaddrs *iflist = NULL;
struct ifaddrs *ifptr = NULL;
int total = 0;
+ size_t copy_size;
if (getifaddrs(&iflist) < 0) {
return -1;
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);
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;
/* 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++;
}
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;
/* Loop through interfaces */
for (i = 0; i<n && total < max_interfaces; i++) {
+
+ memset(&ifaces[total], '\0', sizeof(ifaces[total]));
+
ifreq = ifr[i];
strioctl.ic_cmd = SIOCGIFFLAGS;
continue;
}
- if (!(ifreq.ifr_flags & IFF_UP)) {
+ ifaces[total].flags = ifreq.ifr_flags;
+
+ if (!(ifaces[total].flags & IFF_UP)) {
continue;
}
continue;
}
- ipaddr = (*(struct sockaddr_in *) &ifreq.ifr_addr).sin_addr;
- iname = ifreq.ifr_name;
+ strncpy(ifaces[total].name, iname,
+ sizeof(ifaces[total].name)-1);
+ ifaces[total].name[sizeof(ifaces[total].name)-1] = 0;
+
+ memcpy(&ifaces[total].ip, &ifreq.ifr_addr,
+ sizeof(struct sockaddr_in));
strioctl.ic_cmd = SIOCGIFNETMASK;
strioctl.ic_dp = (char *)&ifreq;
continue;
}
- nmask = ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_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++;
}
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) {
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++;
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;
}
#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;
}
for (i=0;i<total;i++) {
char addr[INET6_ADDRSTRLEN];
+ int ret;
printf("%-10s ", ifaces[i].name);
- printf("IP=%s ", inet_ntop(ifaces[i].sa_family,
- (const void *)&ifaces[i].iface_addr.ip,
- addr,
- sizeof(addr)));
- printf("NETMASK=%s\n", inet_ntop(ifaces[i].sa_family,
- (const void *)&ifaces[i].iface_netmask.netmask,
- addr,
- sizeof(addr)));
+ addr[0] = '\0';
+ ret = getnameinfo((struct sockaddr *)&ifaces[i].ip,
+ sizeof(ifaces[i].ip),
+ addr, sizeof(addr),
+ NULL, 0, NI_NUMERICHOST);
+ printf("IP=%s ", addr);
+ addr[0] = '\0';
+ ret = getnameinfo((struct sockaddr *)&ifaces[i].netmask,
+ sizeof(ifaces[i].netmask),
+ addr, sizeof(addr),
+ NULL, 0, NI_NUMERICHOST);
+ printf("NETMASK=%s ", addr);
+ addr[0] = '\0';
+ ret = getnameinfo((struct sockaddr *)&ifaces[i].bcast,
+ sizeof(ifaces[i].bcast),
+ addr, sizeof(addr),
+ NULL, 0, NI_NUMERICHOST);
+ printf("BCAST=%s\n", addr);
}
return 0;
}
return(def);
}
-/****************************************************************************
- Return true if a string could be a pure IP address.
-****************************************************************************/
-
-BOOL is_ipaddress(const char *str)
-{
- 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(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);
-}
-
-/*******************************************************************
- 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))
/******************************************************************
#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?
****************************************************************************/
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<n; i++) {
- if (ip == nics[i].iface_addr.ip.s_addr)
- return True;
- }
- }
-
- /* no match */
- return False;
-}
-
/*******************************************************************
Is the name specified our workgroup/domain.
Returns true if it is equal, false otherwise.
static char client_ip_string[INET6_ADDRSTRLEN];
/****************************************************************************
- Pritn out an IPv4 or IPv6 address from a struct sockaddr_storage.
+ Return true if a string could be a pure IPv4 address.
****************************************************************************/
-char *print_sockaddr(char *dest,
- size_t destlen,
- struct sockaddr_storage *psa)
+bool is_ipaddress_v4(const char *str)
{
- if (destlen > 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;
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;
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;
char *client_name(void)
{
- return get_peer_name(client_fd,False);
+ return get_peer_name(client_fd,false);
}
char *client_addr(void)
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;
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++)
Send a keepalive packet (rfc1002).
****************************************************************************/
-BOOL send_keepalive(int client)
+bool send_keepalive(int client)
{
unsigned char buf[4];
{
ssize_t len=0;
int msg_type;
- BOOL ok = False;
+ bool ok = false;
while (!ok) {
if (timeout > 0) {
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,
}
/* 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) {
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;
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;
}
/****************************************************************************
int port,
int dlevel,
uint32 socket_addr,
- BOOL rebind )
+ bool rebind )
{
struct sockaddr_in sock;
int res;
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) );
}
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) );
}
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));
}
/* set it blocking again */
- set_blocking(res,True);
+ set_blocking(res,true);
return res;
}
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;
sockets = SMB_MALLOC_ARRAY(int, num_addrs);
if (sockets == NULL)
- return False;
+ return false;
resulting_index = -1;
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<num_addrs; i++) {
errno == EAGAIN || errno == EINTR) {
/* These are the error messages that something is
progressing. */
- good_connect = True;
+ good_connect = true;
} else if (errno != 0) {
/* There was a direct error */
close(sockets[i]);
if (resulting_index >= 0) {
*fd_index = resulting_index;
*fd = sockets[*fd_index];
- set_blocking(*fd, True);
+ set_blocking(*fd, true);
}
free(sockets);
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;
if ((hp = sys_gethostbyname(remotehost)) == 0) {
DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n",
remotehost));
- return False;
+ return false;
}
/*
&& !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;
}
/*
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;
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);
}
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<n; i++) {
+ if (nics[i].ip.ss_family != AF_INET) {
+ continue;
+ }
+ if (addr_equal(&nics[i].ip, &ss)) {
+ return true;
+ }
+ }
+ }
+
+ /* no match */
+ return false;
+}
#include "includes.h"
-extern struct in_addr loopback_ip;
-
/*
This is pretty much a complete rewrite of the earlier code. The main
aim of the rewrite is to add support for having multiple wins server
{
char *keystr;
- if (is_zero_ip(wins_ip) || wins_srv_is_dead(wins_ip, src_ip))
+ if (is_zero_ip_v4(wins_ip) || wins_srv_is_dead(wins_ip, src_ip))
return;
keystr = wins_srv_keystr(wins_ip, src_ip);
/* if we are a wins server then we always just talk to ourselves */
if (lp_wins_support()) {
+ struct in_addr loopback_ip;
+ loopback_ip.s_addr = htonl(INADDR_LOOPBACK);
return loopback_ip;
}
list = lp_wins_server_list();
if (!list || !list[0]) {
struct in_addr ip;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
return ip;
}
}
/* this can't happen?? */
- zero_ip(&t_ip.ip);
+ zero_ip_v4(&t_ip.ip);
return t_ip.ip;
}
NTSTATUS ndr_push_ipv4address(struct ndr_push *ndr, int ndr_flags, const char *address)
{
uint32_t addr;
- if (!is_ipaddress(address)) {
+ if (!is_ipaddress_v4(address)) {
return ndr_push_error(ndr, NDR_ERR_IPV4ADDRESS,
"Invalid IPv4 address: '%s'",
address);
*p = 0;
}
- if (!ip || is_zero_ip(*ip)) {
+ if (!ip || is_zero_ip_v4(*ip)) {
if (!resolve_name(cli->desthost, &cli->dest_ip, name_type)) {
return NT_STATUS_BAD_NETWORK_NAME;
}
char *p;
DEBUG(1,("session request to %s failed (%s)\n",
called.name, cli_errstr(cli)));
- if ((p=strchr(called.name, '.')) && !is_ipaddress(called.name)) {
+ if ((p=strchr(called.name, '.')) && !is_ipaddress_v4(called.name)) {
*p = 0;
goto again;
}
* then use *SMBSERVER immediately.
*/
- if(is_ipaddress(desthost)) {
+ if(is_ipaddress_v4(desthost)) {
make_nmb_name(&called, "*SMBSERVER", 0x20);
} else {
make_nmb_name(&called, desthost, 0x20);
if (NT_STATUS_IS_OK(nt_status)) {
return cli;
- } else if (is_ipaddress(server)) {
+ } else if (is_ipaddress_v4(server)) {
/* windows 9* needs a correct NMB name for connections */
fstring remote_name;
server_n = server;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
make_nmb_name(&calling, global_myname(), 0x0);
make_nmb_name(&called , server, name_type);
again:
- zero_ip(&ip);
+ zero_ip_v4(&ip);
if (have_ip)
ip = dest_ip;
* back to netbios lookups is that our DNS server doesn't know
* anything about the DC's -- jerry */
- if (!is_zero_ip(r->ip)) {
+ if (!is_zero_ip_v4(r->ip)) {
(*return_count)++;
continue;
}
const char *username_used;
NTSTATUS status;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
ZERO_STRUCT(c);
if (server[0] == 0) {
again:
slprintf(ipenv,sizeof(ipenv)-1,"HOST_%s", server_n);
- zero_ip(&ip);
+ zero_ip_v4(&ip);
/* have to open a new connection */
if ((c = cli_initialise()) == NULL) {
/* Only try this if server is an IP address ... */
- if (is_ipaddress(server) && !tried_reverse) {
+ if (is_ipaddress_v4(server) && !tried_reverse) {
fstring remote_name;
struct in_addr rem_ip;
flags |= CLI_FULL_CONNECTION_USE_KERBEROS;
}
- zero_ip(&ip);
+ zero_ip_v4(&ip);
nt_status = cli_full_connection(&ipc_cli,
global_myname(), server,
&ip, 0, "IPC$", "?????",
* LMB or DMB
*/
if (!srv &&
- !is_ipaddress(server) &&
+ !is_ipaddress_v4(server) &&
(resolve_name(server, &rem_ip, 0x1d) || /* LMB */
resolve_name(server, &rem_ip, 0x1b) )) { /* DMB */
{
int max_bits1=0, max_bits2=0;
int num_interfaces = iface_count();
+ struct sockaddr_storage ss;
int i;
for (i=0;i<num_interfaces;i++) {
+ const struct sockaddr_storage *pss = iface_n_bcast(i);
struct in_addr ip;
int bits1, bits2;
- ip = *iface_n_bcast(i);
+
+ if (pss->ss_family != AF_INET) {
+ continue;
+ }
+ ip = ((const struct sockaddr_in *)pss)->sin_addr;
bits1 = matching_quad_bits((uchar *)&ip1->s_addr, (uchar *)&ip.s_addr);
bits2 = matching_quad_bits((uchar *)&ip2->s_addr, (uchar *)&ip.s_addr);
max_bits1 = MAX(bits1, max_bits1);
}
/* bias towards directly reachable IPs */
- if (iface_local(*ip1)) {
+ in_addr_to_sockaddr_storage(&ss, *ip1);
+ if (iface_local(&ss)) {
max_bits1 += 32;
}
- if (iface_local(*ip2)) {
+ in_addr_to_sockaddr_storage(&ss, *ip1);
+ if (iface_local(&ss)) {
max_bits2 += 32;
}
/* one loop to remove duplicates */
for ( i=0; i<count; i++ ) {
- if ( is_zero_ip(iplist[i].ip) )
+ if ( is_zero_ip_v4(iplist[i].ip) )
continue;
for ( j=i+1; j<count; j++ ) {
if ( ip_service_equal(iplist[i], iplist[j]) )
- zero_ip(&iplist[j].ip);
+ zero_ip_v4(&iplist[j].ip);
}
}
/* one loop to clean up any holes we left */
/* first ip should never be a zero_ip() */
for (i = 0; i<count; ) {
- if ( is_zero_ip(iplist[i].ip) ) {
+ if ( is_zero_ip_v4(iplist[i].ip) ) {
if (i != count-1 )
memmove(&iplist[i], &iplist[i+1], (count - i - 1)*sizeof(iplist[i]));
count--;
*/
for( i = num_interfaces-1; i >= 0; i--) {
struct in_addr sendto_ip;
+ const struct sockaddr_storage *ss = iface_n_bcast(i);
int flags;
+
/* Done this way to fix compiler error on IRIX 5.x */
- sendto_ip = *iface_n_bcast(i);
+ if (!ss || ss->ss_family != AF_INET) {
+ continue;
+ }
+ sendto_ip = ((const struct sockaddr_in *)ss)->sin_addr;
ip_list = name_query(sock, name, name_type, True,
True, sendto_ip, return_count, &flags, NULL);
if( ip_list )
wins_ip = wins_srv_ip_tag(wins_tags[t], src_ip);
- if (global_in_nmbd && ismyip(wins_ip)) {
+ if (global_in_nmbd && ismyip_v4(wins_ip)) {
/* yikes! we'll loop forever */
continue;
}
The standard reason for falling back to netbios lookups is that
our DNS server doesn't know anything about the DC's -- jerry */
- if ( ! is_zero_ip(r->ip) )
+ if ( ! is_zero_ip_v4(r->ip) )
(*return_count)++;
}
const char *ptr;
BOOL allones = (strcmp(name,"255.255.255.255") == 0);
BOOL allzeros = (strcmp(name,"0.0.0.0") == 0);
- BOOL is_address = is_ipaddress(name);
+ BOOL is_address = is_ipaddress_v4(name);
NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
int i;
char *sitename = sitename_fetch(lp_realm()); /* wild guess */
int count = 0;
- if (is_ipaddress(name)) {
+ if (is_ipaddress_v4(name)) {
*return_ip = *interpret_addr2(name);
SAFE_FREE(sitename);
return True;
int count, i;
NTSTATUS result;
- zero_ip(&exclude_ip);
+ zero_ip_v4(&exclude_ip);
/* get a list of all domain controllers */
/* Remove the entry we've already failed with (should be the PDC). */
for (i = 0; i < count; i++) {
- if (is_zero_ip(ip_list[i].ip))
+ if (is_zero_ip_v4(ip_list[i].ip))
continue;
if (name_status_find(domain, 0x1c, 0x20, ip_list[i].ip, srv_name)) {
BOOL ret;
BOOL our_domain = False;
- zero_ip(&dc_ip);
+ zero_ip_v4(&dc_ip);
ret = False;
int global_nmb_port = -1;
extern BOOL rescan_listen_set;
-extern struct in_addr loopback_ip;
extern BOOL global_in_nmbd;
extern BOOL override_logfile;
/* find any interfaces that need adding */
for (n=iface_count() - 1; n >= 0; n--) {
- struct interface *iface = get_interface(n);
+ char str[INET6_ADDRSTRLEN];
+ const struct interface *iface = get_interface(n);
+ struct in_addr ip, nmask;
if (!iface) {
DEBUG(2,("reload_interfaces: failed to get interface %d\n", n));
continue;
}
+ /* Ensure we're only dealing with IPv4 here. */
+ if (iface->ip.ss_family != AF_INET) {
+ DEBUG(2,("reload_interfaces: "
+ "ignoring non IPv4 interface.\n"));
+ continue;
+ }
+
+ ip = ((struct sockaddr_in *)&iface->ip)->sin_addr;
+ nmask = ((struct sockaddr_in *)&iface->netmask)->sin_addr;
+
/*
* We don't want to add a loopback interface, in case
* someone has added 127.0.0.1 for smbd, nmbd needs to
* ignore it here. JRA.
*/
- if (ip_equal(iface->ip, loopback_ip)) {
- DEBUG(2,("reload_interfaces: Ignoring loopback interface %s\n", inet_ntoa(iface->ip)));
+ if (is_loopback_addr(&iface->ip)) {
+ DEBUG(2,("reload_interfaces: Ignoring loopback "
+ "interface %s\n",
+ print_sockaddr(str, sizeof(str),
+ &iface->ip, sizeof(iface->ip)) ));
continue;
}
for (subrec=subnetlist; subrec; subrec=subrec->next) {
- if (ip_equal(iface->ip, subrec->myip) &&
- ip_equal(iface->nmask, subrec->mask_ip)) break;
+ if (ip_equal(ip, subrec->myip) &&
+ ip_equal(nmask, subrec->mask_ip)) break;
}
if (!subrec) {
/* it wasn't found! add it */
DEBUG(2,("Found new interface %s\n",
- inet_ntoa(iface->ip)));
+ print_sockaddr(str, sizeof(str),
+ &iface->ip, sizeof(iface->ip)) ));
subrec = make_normal_subnet(iface);
if (subrec)
register_my_workgroup_one_subnet(subrec);
for (subrec=subnetlist; subrec; subrec=subrec->next) {
for (n=iface_count() - 1; n >= 0; n--) {
struct interface *iface = get_interface(n);
- if (ip_equal(iface->ip, subrec->myip) &&
- ip_equal(iface->nmask, subrec->mask_ip)) break;
+ struct in_addr ip, nmask;
+ if (!iface) {
+ continue;
+ }
+ /* Ensure we're only dealing with IPv4 here. */
+ if (iface->ip.ss_family != AF_INET) {
+ DEBUG(2,("reload_interfaces: "
+ "ignoring non IPv4 interface.\n"));
+ continue;
+ }
+ ip = ((struct sockaddr_in *)&iface->ip)->sin_addr;
+ nmask = ((struct sockaddr_in *)&iface->netmask)->sin_addr;
+ if (ip_equal(ip, subrec->myip) &&
+ ip_equal(nmask, subrec->mask_ip)) break;
}
if (n == -1) {
/* oops, an interface has disapeared. This is
{
struct packet_struct *p = (struct packet_struct *)data->data;
struct subnet_record *subrec;
- struct in_addr *local_ip;
+ struct sockaddr_storage ss;
+ const struct sockaddr_storage *pss;
+ const struct in_addr *local_ip;
DEBUG(10, ("Received send_packet from %d\n", procid_to_pid(&src)));
return;
}
- local_ip = iface_ip(p->ip);
+ in_addr_to_sockaddr_storage(&ss, p->ip);
+ pss = iface_ip(&ss);
- if (local_ip == NULL) {
+ if (pss == NULL) {
DEBUG(2, ("Could not find ip for packet from %d\n",
procid_to_pid(&src)));
return;
}
+ local_ip = &((const struct sockaddr_in *)pss)->sin_addr;
subrec = FIRST_SUBNET;
p->fd = (p->packet_type == NMB_PACKET) ?
#include "includes.h"
-extern struct in_addr allones_ip;
-
extern uint16 samba_nb_type; /* Samba's NetBIOS type. */
static void become_domain_master_browser_bcast(const char *);
if( subrec == unicast_subnet ) {
struct nmb_name nmbname;
struct in_addr my_first_ip;
- struct in_addr *nip;
+ const struct in_addr *nip;
/* Put our name and first IP address into the
workgroup struct as domain master browser. This
make_nmb_name(&nmbname, global_myname(), 0x20);
work->dmb_name = nmbname;
- /* Pick the first interface ip address as the domain master browser ip. */
- nip = iface_n_ip(0);
+ /* Pick the first interface IPv4 address as the domain master browser ip. */
+ nip = first_ipv4_iface();
if (!nip) {
- DEBUG(0,("become_domain_master_stage2: Error. iface_n_ip returned NULL\n"));
+ DEBUG(0,("become_domain_master_stage2: "
+ "Error. get_interface returned NULL\n"));
return;
}
-
my_first_ip = *nip;
putip((char *)&work->dmb_addr, &my_first_ip);
static void become_domain_master_query_success(struct subnet_record *subrec,
struct userdata_struct *userdata,
- struct nmb_name *nmbname, struct in_addr ip,
+ struct nmb_name *nmbname, struct in_addr ip,
struct res_rec *rrec)
{
unstring name;
+ struct in_addr allones_ip;
+
pull_ascii_nstring(name, sizeof(name), nmbname->name);
/* If the given ip is not ours, then we can't become a domain
/* BUG note. Samba 1.9.16p11 servers seem to return the broadcast
address or zero ip for this query. Pretend this is ok. */
- if(ismyip(ip) || ip_equal(allones_ip, ip) || is_zero_ip(ip)) {
+ allones_ip.s_addr = htonl(INADDR_BROADCAST);
+
+ if(ismyip_v4(ip) || ip_equal(allones_ip, ip) || is_zero_ip_v4(ip)) {
if( DEBUGLVL( 3 ) ) {
dbgtext( "become_domain_master_query_success():\n" );
dbgtext( "Our address (%s) ", inet_ntoa(ip) );
unstring dmb_name;
char *p;
- if(ismyip(work->dmb_addr)) {
+ if(ismyip_v4(work->dmb_addr)) {
if( DEBUGLVL( 2 ) ) {
dbgtext( "announce_local_master_browser_to_domain_master_browser:\n" );
dbgtext( "We are both a domain and a local master browser for " );
/* First check if we already have a dmb for this workgroup. */
- if(!is_zero_ip(work->dmb_addr) && ip_equal(work->dmb_addr, answer_ip)) {
+ if(!is_zero_ip_v4(work->dmb_addr) && ip_equal(work->dmb_addr, answer_ip)) {
/* Do the local master browser announcement to the domain
master browser name and IP. */
announce_local_master_browser_to_domain_master_browser( work );
sync_with_dmb(work);
return;
} else {
- zero_ip(&work->dmb_addr);
+ zero_ip_v4(&work->dmb_addr);
}
/* Now initiate the node status request. */
* Don't send node status requests to ourself.
*/
- if(ismyip( send_ip )) {
+ if(ismyip_v4( send_ip )) {
if( DEBUGLVL( 5 ) ) {
dbgtext( "find_all_domain_master_names_query_succes:\n" );
dbgtext( "Not sending node status to our own IP " );
subrec->subnet_name, inet_ntoa(owner_ip)));
/* If someone is releasing a broadcast group name, just ignore it. */
- if( group && !ismyip(owner_ip) )
+ if( group && !ismyip_v4(owner_ip) )
return;
/*
*/
pull_ascii_nstring(qname, sizeof(qname), question->name);
- if( !group && !ismyip(owner_ip) && strequal(qname, lp_workgroup()) &&
+ if( !group && !ismyip_v4(owner_ip) && strequal(qname, lp_workgroup()) &&
((question->name_type == 0x0) || (question->name_type == 0x1e))) {
DEBUG(6,("process_name_release_request: FTP OnNet bug workaround. Ignoring \
group release name %s from IP %s on subnet %s with no group bit set.\n",
if (namerec->data.source == WINS_PROXY_NAME) {
for( i = 0; i < namerec->data.num_ips; i++) {
- if (same_net(namerec->data.ip[i], subrec->myip, subrec->mask_ip)) {
+ if (same_net_v4(namerec->data.ip[i], subrec->myip, subrec->mask_ip)) {
DEBUG(5,("process_name_query_request: name %s is a WINS proxy name and is also on the same subnet (%s) as the requestor. Not replying.\n",
nmb_namestr(&namerec->name), subrec->subnet_name ));
return;
/* We find a relevent subnet to put this entry on, then add it. */
/* Go through all the broadcast subnets and see if the mask matches. */
for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
- if(same_net(ipaddr, subrec->bcast_ip, subrec->mask_ip))
+ if(same_net_v4(ipaddr, subrec->bcast_ip, subrec->mask_ip))
break;
}
#include "includes.h"
-extern struct in_addr allones_ip;
-
extern uint16 samba_nb_type; /* Samba's NetBIOS type. */
/****************************************************************************
struct nmb_name *question_name = &rrec->packet->packet.nmb.question.question_name;
struct in_addr answer_ip;
- zero_ip(&answer_ip);
+ zero_ip_v4(&answer_ip);
/* Ensure we don't retry the query but leave the response record cleanup
to the timeout code. We may get more answer responses in which case
extern int num_response_packets;
-extern struct in_addr loopback_ip;
-
static void queue_packet(struct packet_struct *packet);
BOOL rescan_listen_set = False;
BOOL loopback_this_packet = False;
/* Check if we are sending to or from ourselves as a WINS server. */
- if(ismyip(p->ip) && (p->port == global_nmb_port))
+ if(ismyip_v4(p->ip) && (p->port == global_nmb_port))
loopback_this_packet = True;
if(loopback_this_packet) {
static BOOL create_and_init_additional_record(struct packet_struct *packet,
uint16 nb_flags,
- struct in_addr *register_ip)
+ const struct in_addr *register_ip)
{
struct nmb_packet *nmb = &packet->packet.nmb;
if((nmb->additional = SMB_MALLOC_P(struct res_rec)) == NULL) {
- DEBUG(0,("initiate_name_register_packet: malloc fail for additional record.\n"));
+ DEBUG(0,("create_and_init_additional_record: malloc fail for additional record.\n"));
return False;
}
**************************************************************************/
static BOOL initiate_name_register_packet( struct packet_struct *packet,
- uint16 nb_flags, struct in_addr *register_ip)
+ uint16 nb_flags, const struct in_addr *register_ip)
{
struct nmb_packet *nmb = &packet->packet.nmb;
{
struct packet_struct *p;
struct response_record *rrec;
-
+ struct sockaddr_storage ss;
+ const struct sockaddr_storage *pss = NULL;
if(assert_check_subnet(subrec))
return NULL;
subrec->bcast_ip)) == NULL)
return NULL;
- if(initiate_name_register_packet( p, nb_flags, iface_ip(subrec->bcast_ip)) == False) {
+ in_addr_to_sockaddr_storage(&ss, subrec->bcast_ip);
+ pss = iface_ip(&ss);
+ if (!pss || pss->ss_family != AF_INET) {
+ p->locked = False;
+ free_packet(p);
+ return NULL;
+ }
+
+ if(initiate_name_register_packet(p, nb_flags,
+ &((const struct sockaddr_in *)pss)->sin_addr) == False) {
p->locked = False;
free_packet(p);
return NULL;
/* queries to the WINS server turn up here as queries to IP 0.0.0.0
These need to be handled a bit differently */
- if (subrec->type == UNICAST_SUBNET && is_zero_ip(to_ip)) {
+ if (subrec->type == UNICAST_SUBNET && is_zero_ip_v4(to_ip)) {
/* What we really need to do is loop over each of our wins
* servers and wins server tags here, but that just doesn't
* fit our architecture at the moment (userdata may already
DEBUG(10,("queue_query_name: bind_interfaces_only is set, looking for suitable source IP\n"));
for(i = 0; i < iface_count(); i++) {
- struct in_addr *ifip = iface_n_ip(i);
+ const struct in_addr *ifip = iface_n_ip_v4(i);
- if(ifip == NULL) {
+ if (ifip == NULL) {
DEBUG(0,("queue_query_name: interface %d has NULL IP address !\n", i));
continue;
}
- if (ip_equal(*ifip,loopback_ip)) {
+ if (is_loopback_ip_v4(*ifip)) {
DEBUG(5,("queue_query_name: ignoring loopback interface (%d)\n", i));
continue;
}
const char *packet_type = "unknown";
/* Check if we are sending to or from ourselves. */
- if(ismyip(orig_packet->ip) && (orig_packet->port == global_nmb_port))
+ if(ismyip_v4(orig_packet->ip) && (orig_packet->port == global_nmb_port))
loopback_this_packet = True;
nmb = &packet.packet.nmb;
/* Go through all the broadcast subnets and see if the mask matches. */
for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
- if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
+ if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
return subrec;
}
struct subnet_record *subrec = NULL;
for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
- if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
+ if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
break;
}
/* Go through all the broadcast subnets and see if the mask matches. */
for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
- if(same_net(p->ip, subrec->bcast_ip, subrec->mask_ip))
+ if(same_net_v4(p->ip, subrec->bcast_ip, subrec->mask_ip))
return subrec;
}
* only is set then check it came from one of our local nets.
*/
if(lp_bind_interfaces_only() && (sock_array[i] == ClientNMB) &&
- (!is_local_net(packet->ip))) {
+ (!is_local_net_v4(packet->ip))) {
DEBUG(7,("discarding nmb packet sent to broadcast socket from %s:%d\n",
inet_ntoa(packet->ip),packet->port));
free_packet(packet);
- } else if ((ip_equal(loopback_ip, packet->ip) ||
- ismyip(packet->ip)) && packet->port == global_nmb_port &&
+ } else if ((is_loopback_ip_v4(packet->ip) ||
+ ismyip_v4(packet->ip)) && packet->port == global_nmb_port &&
packet->packet.nmb.header.nm_flags.bcast) {
DEBUG(7,("discarding own bcast packet from %s:%d\n",
inet_ntoa(packet->ip),packet->port));
* only is set then check it came from one of our local nets.
*/
if(lp_bind_interfaces_only() && (sock_array[i] == ClientDGRAM) &&
- (!is_local_net(packet->ip))) {
+ (!is_local_net_v4(packet->ip))) {
DEBUG(7,("discarding dgram packet sent to broadcast socket from %s:%d\n",
inet_ntoa(packet->ip),packet->port));
free_packet(packet);
- } else if ((ip_equal(loopback_ip, packet->ip) ||
- ismyip(packet->ip)) && packet->port == DGRAM_PORT) {
+ } else if ((is_loopback_ip_v4(packet->ip) ||
+ ismyip_v4(packet->ip)) && packet->port == DGRAM_PORT) {
DEBUG(7,("discarding own dgram packet from %s:%d\n",
inet_ntoa(packet->ip),packet->port));
free_packet(packet);
memset((char *)&p,'\0',sizeof(p));
- if(ismyip(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
+ if(ismyip_v4(dest_ip) && (dest_port == DGRAM_PORT)) /* Only if to DGRAM_PORT */
loopback_this_packet = True;
/* generate_name_trn_id(); */ /* Not used, so gone, RJS */
pstring ascuser;
char *unicomp; /* Unicode computer name. */
size_t size;
+ struct sockaddr_storage ss;
+ const struct sockaddr_storage *pss;
+ struct in_addr ip;
+
+ in_addr_to_sockaddr_storage(&ss, p->ip);
+ pss = iface_ip(&ss);
+ if (!pss) {
+ DEBUG(5,("process_logon_packet:can't find outgoing interface "
+ "for packet from IP %s\n",
+ inet_ntoa(p->ip) ));
+ return;
+ }
+ ip = ((struct sockaddr_in *)pss)->sin_addr;
memset(outbuf, 0, sizeof(outbuf));
global_myname(), 0x0,
mach_str,
dgram->source_name.name_type,
- p->ip, *iface_ip(p->ip), p->port);
+ p->ip, ip, p->port);
break;
}
global_myname(), 0x0,
source_name,
dgram->source_name.name_type,
- p->ip, *iface_ip(p->ip), p->port);
+ p->ip, ip, p->port);
return;
}
SIVAL(q, 0, 0x00000002);
q += 4; /* unknown */
- SIVAL(q, 0, (iface_ip(p->ip))->s_addr);
+ SIVAL(q, 0, ntohl(ip.s_addr));
q += 4;
SIVAL(q, 0, 0x00000000);
q += 4; /* unknown */
global_myname(), 0x0,
source_name,
dgram->source_name.name_type,
- p->ip, *iface_ip(p->ip), p->port);
+ p->ip, ip, p->port);
break;
}
#include "includes.h"
-extern struct in_addr loopback_ip;
extern int global_nmb_port;
/* This is the broadcast subnets database. */
Create a normal subnet
**************************************************************************/
-struct subnet_record *make_normal_subnet(struct interface *iface)
+struct subnet_record *make_normal_subnet(const struct interface *iface)
{
+
struct subnet_record *subrec;
+ const struct in_addr *pip = &((const struct sockaddr_in *)&iface->ip)->sin_addr;
+ const struct in_addr *pbcast = &((const struct sockaddr_in *)&iface->bcast)->sin_addr;
+ const struct in_addr *pnmask = &((const struct sockaddr_in *)&iface->netmask)->sin_addr;
- subrec = make_subnet(inet_ntoa(iface->ip), NORMAL_SUBNET,
- iface->ip, iface->bcast, iface->nmask);
+ subrec = make_subnet(inet_ntoa(*pip), NORMAL_SUBNET,
+ *pip, *pbcast, *pnmask);
if (subrec) {
add_subnet(subrec);
}
**************************************************************************/
BOOL create_subnets(void)
-{
- int num_interfaces = iface_count();
+{
+ /* We only count IPv4 interfaces whilst we're waiting. */
+ int num_interfaces = iface_count_v4();
int i;
struct in_addr unicast_ip, ipzero;
DEBUG(0,("create_subnets: No local interfaces !\n"));
DEBUG(0,("create_subnets: Waiting for an interface to appear ...\n"));
- /*
+ /*
* Whilst we're waiting for an interface, allow SIGTERM to
* cause us to exit.
*/
saved_handler = CatchSignal( SIGTERM, SIGNAL_CAST SIG_DFL );
- while (iface_count() == 0) {
+ /* We only count IPv4 interfaces here. */
+ while (iface_count_v4() == 0) {
sleep(5);
load_interfaces();
}
- /*
+ /*
* We got an interface, restore our normal term handler.
*/
CatchSignal( SIGTERM, SIGNAL_CAST saved_handler );
}
+ /*
+ * Here we count v4 and v6 - we know there's at least one
+ * IPv4 interface and we filter on it below.
+ */
num_interfaces = iface_count();
- /*
+ /*
* Create subnets from all the local interfaces and thread them onto
- * the linked list.
+ * the linked list.
*/
for (i = 0 ; i < num_interfaces; i++) {
- struct interface *iface = get_interface(i);
+ const struct interface *iface = get_interface(i);
if (!iface) {
DEBUG(2,("create_subnets: can't get interface %d.\n", i ));
continue;
}
+ /* Ensure we're only dealing with IPv4 here. */
+ if (iface->ip.ss_family != AF_INET) {
+ DEBUG(2,("create_subnets: "
+ "ignoring non IPv4 interface.\n"));
+ continue;
+ }
+
/*
* We don't want to add a loopback interface, in case
* someone has added 127.0.0.1 for smbd, nmbd needs to
* ignore it here. JRA.
*/
- if (ip_equal(iface->ip, loopback_ip)) {
+ if (is_loopback_addr(&iface->ip)) {
DEBUG(2,("create_subnets: Ignoring loopback interface.\n" ));
continue;
}
}
if (lp_we_are_a_wins_server()) {
- /* Pick the first interface ip address as the WINS server ip. */
- struct in_addr *nip = iface_n_ip(0);
+ /* Pick the first interface IPv4 address as the WINS server ip. */
+ const struct in_addr *nip = first_ipv4_iface();
if (!nip) {
return False;
/* note that we do not set the wins server IP here. We just
set it at zero and let the wins registration code cope
with getting the IPs right for each packet */
- zero_ip(&unicast_ip);
+ zero_ip_v4(&unicast_ip);
}
/*
unicast_subnet = make_subnet( "UNICAST_SUBNET", UNICAST_SUBNET,
unicast_ip, unicast_ip, unicast_ip);
- zero_ip(&ipzero);
+ zero_ip_v4(&ipzero);
remote_broadcast_subnet = make_subnet( "REMOTE_BROADCAST_SUBNET",
REMOTE_BROADCAST_SUBNET,
START_PROFILE(sync_browse_lists);
/* Check we're not trying to sync with ourselves. This can
happen if we are a domain *and* a local master browser. */
- if (ismyip(ip)) {
+ if (ismyip_v4(ip)) {
done:
END_PROFILE(sync_browse_lists);
return;
if(namerec && original_packet->packet.nmb.header.nm_flags.bcast) {
for( i = 0; i < namerec->data.num_ips; i++) {
- if( same_net( namerec->data.ip[i], orig_broadcast_subnet->myip,
+ if( same_net_v4( namerec->data.ip[i], orig_broadcast_subnet->myip,
orig_broadcast_subnet->mask_ip ) ) {
DEBUG( 5, ( "wins_proxy_name_query_request_success: name %s is a WINS \
proxy name and is also on the same subnet (%s) as the requestor. \
if ( namerec != NULL ) {
pull_ascii_nstring(name, sizeof(name), namerec->name.name);
if( is_myname(name) ) {
- if(!ismyip(from_ip)) {
+ if(!ismyip_v4(from_ip)) {
DEBUG(3,("wins_process_name_registration_request: Attempt to register name %s. Name \
is one of our (WINS server) names. Denying registration.\n", nmb_namestr(question) ));
send_wins_name_registration_response(RFS_ERR, 0, p);
*/
if((namerec != NULL) && (is_myname(namerec->name.name)) ) {
- if(!ismyip(from_ip)) {
+ if(!ismyip_v4(from_ip)) {
DEBUG(3,("wins_process_multihomed_name_registration_request: Attempt to register name %s. Name \
is one of our (WINS server) names. Denying registration.\n", nmb_namestr(question) ));
send_wins_name_registration_response(RFS_ERR, 0, p);
/* No known domain master browser as yet. */
*work->dmb_name.name = '\0';
- zero_ip(&work->dmb_addr);
+ zero_ip_v4(&work->dmb_addr);
/* WfWg uses 01040b01 */
/* Win95 uses 01041501 */
/* uggh, we have to broadcast to each interface in turn */
for (j=iface_count() - 1;j >= 0;j--) {
- struct in_addr *bcast = iface_n_bcast(j);
+ const struct in_addr *bcast = iface_n_bcast_v4(j);
+ if (!bcast) {
+ continue;
+ }
ret = name_query(fd,name,0x00,True,True,*bcast,count, &flags, NULL);
if (ret) break;
}
struct cli_state *the_cli;
struct in_addr rm_addr;
- if ( is_zero_ip(*client_ip) ) {
+ if ( is_zero_ip_v4(*client_ip) ) {
if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
return False;
}
- if ( ismyip( rm_addr )) {
+ if ( ismyip_v4( rm_addr )) {
DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
return False;
}
/* Now open a listen socket for each of the
interfaces. */
for(i = 0; i < num_interfaces; i++) {
- struct in_addr *ifip = iface_n_ip(i);
+ const struct sockaddr_storage *ifss =
+ iface_n_sockaddr_storage(i);
+ const struct in_addr *ifip;
fstring tok;
const char *ptr;
- if(ifip == NULL) {
+ if (ifss == NULL) {
DEBUG(0,("open_sockets_smbd: interface %d has NULL IP address !\n", i));
continue;
}
+ /* For now only deal with IPv4. */
+ if (ifss->ss_family != AF_INET) {
+ continue;
+ }
+
+ ifip = &((const struct sockaddr_in *)ifss)->sin_addr;
+
for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
unsigned port = atoi(tok);
if (port == 0 || port > 0xffff) {
server_n = server;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
slprintf(myname,sizeof(myname), "lock-%lu-%u", (unsigned long)getpid(), count++);
make_nmb_name(&called , server, 0x20);
again:
- zero_ip(&ip);
+ zero_ip_v4(&ip);
/* have to open a new connection */
if (!(c=cli_initialise())) {
server_n = server;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
make_nmb_name(&calling, "masktest", 0x0);
make_nmb_name(&called , server, 0x20);
again:
- zero_ip(&ip);
+ zero_ip_v4(&ip);
/* have to open a new connection */
if (!(c=cli_initialise())) {
make_nmb_name(&calling, myname, 0x0);
make_nmb_name(&called , host, 0x20);
- zero_ip(&ip);
+ zero_ip_v4(&ip);
if (!(c = cli_initialise())) {
printf("Failed initialize cli_struct to connect with %s\n", host);
BOOL opt_have_ip = False;
struct in_addr opt_dest_ip;
-extern struct in_addr loopback_ip;
extern BOOL AllowDebugChange;
uint32 get_sec_channel_type(const char *param)
if (get_pdc_ip(d, &pdc_ip)) {
fstring dc_name;
- if (is_zero_ip(pdc_ip))
+ if (is_zero_ip_v4(pdc_ip))
return False;
if ( !name_status_find(d, 0x1b, 0x20, pdc_ip, dc_name) )
}
*server_name = SMB_STRDUP(inet_ntoa(opt_dest_ip));
} else if (!(flags & NET_FLAGS_LOCALHOST_DEFAULT_INSANE)) {
- *server_ip = loopback_ip;
+ (*server_ip).s_addr = htonl(INADDR_LOOPBACK);
*server_name = SMB_STRDUP("127.0.0.1");
}
BOOL net_find_pdc(struct in_addr *server_ip, fstring server_name, const char *domain_name)
{
if (get_pdc_ip(domain_name, server_ip)) {
- if (is_zero_ip(*server_ip))
+ if (is_zero_ip_v4(*server_ip))
return False;
if (!name_status_find(domain_name, 0x1b, 0x20, *server_ip, server_name))
TALLOC_CTX *frame = talloc_stackframe();
- zero_ip(&opt_dest_ip);
+ zero_ip_v4(&opt_dest_ip);
load_case_tables();
break;
case 'I':
opt_dest_ip = *interpret_addr2(poptGetOptArg(pc));
- if (is_zero_ip(opt_dest_ip))
+ if (is_zero_ip_v4(opt_dest_ip))
d_fprintf(stderr, "\nInvalid ip address specified\n");
else
opt_have_ip = True;
{
struct iface_struct nics[MAX_INTERFACES];
int i, n;
- struct in_addr loopback_ip = *interpret_addr2("127.0.0.1");
struct in_addr *list;
int count = 0;
}
for ( i=0; i<n; i++ ) {
- if ( nics[i].iface_addr.ip.s_addr != loopback_ip.s_addr ) {
+ if (!is_loopback_ip_v4(nics[i].iface_addr.ip.s_addr)) {
memcpy( &list[count++], &nics[i].iface_addr.ip, sizeof( struct in_addr ) );
}
}
static struct con_struct *create_cs(TALLOC_CTX *ctx, NTSTATUS *perr)
{
NTSTATUS nt_status;
- struct in_addr loopback_ip = *interpret_addr2("127.0.0.1");
+ struct in_addr loopback_ip;
+ loopback_ip.s_addr = htonl(INADDR_LOOPBACK);
*perr = NT_STATUS_OK;
if (cs) {
use_bcast?True:recursion_desired,
bcast_addr,&count, &flags, NULL);
} else {
- struct in_addr *bcast;
+ const struct in_addr *bcast;
for (j=iface_count() - 1;
!ip_list && j >= 0;
j--) {
- bcast = iface_n_bcast(j);
+ bcast = iface_n_bcast_v4(j);
+ if (!bcast) {
+ continue;
+ }
d_printf("querying %s on %s\n",
lookup, inet_ntoa(*bcast));
ip_list = name_query(ServerFD,lookup,lookup_type,
struct cli_state *c;
struct in_addr ip;
NTSTATUS nt_status;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
if (!cmdline_auth_info.got_pass) {
char *pass = getpass("Password: ");
struct cli_state *c;
struct in_addr ip;
NTSTATUS nt_status;
- zero_ip(&ip);
+ zero_ip_v4(&ip);
if (!cmdline_auth_info.got_pass) {
char *pass = getpass("Password: ");
#include "includes.h"
#include "web/swat_proto.h"
-extern struct in_addr loopback_ip;
-
#ifdef WITH_WINBIND
/* check to see if winbind is running by pinging it */
response */
BOOL nmbd_running(void)
{
+ struct in_addr loopback_ip;
int fd, count, flags;
struct in_addr *ip_list;
+ loopback_ip.s_addr = htonl(INADDR_LOOPBACK);
+
if ((fd = open_socket_in(SOCK_DGRAM, 0, 3,
interpret_addr("127.0.0.1"), True)) != -1) {
if ((ip_list = name_query(fd, "__SAMBA__", 0,
then closing it */
BOOL smbd_running(void)
{
+ struct in_addr loopback_ip;
NTSTATUS status;
struct cli_state *cli;
+ loopback_ip.s_addr = htonl(INADDR_LOOPBACK);
+
if ((cli = cli_initialise()) == NULL)
return False;
*addr = addrs[fd_index];
- if (*dcnames[fd_index] != '\0' && !is_ipaddress(dcnames[fd_index])) {
+ if (*dcnames[fd_index] != '\0' && !is_ipaddress_v4(dcnames[fd_index])) {
/* Ok, we've got a name for the DC */
fstrcpy(dcname, dcnames[fd_index]);
return True;
saf_servername, domain->name ));
/* convert an ip address to a name */
- if ( is_ipaddress( saf_servername ) ) {
+ if ( is_ipaddress_v4( saf_servername ) ) {
fstring saf_name;
struct in_addr ip;
for (j=iface_count() - 1;
j >= 0;
j--) {
- struct in_addr *bcast = iface_n_bcast(j);
+ const struct in_addr *bcast = iface_n_bcast_v4(j);
+ if (!bcast) {
+ continue;
+ }
return_ip = name_query(fd,name,0x20,True,True,*bcast,count, &flags, NULL);
if (return_ip) {
break;
git.samba.org / bbaumbach / samba-autobuild / .git / commitdiff