struct netent *getnetbyname(const char *name)
{
char *buf = _net_buf();
if (!buf)
return NULL;
return getnetbyname_r(name, (struct netent *) buf,
buf + sizeof(struct netent), NET_BUFSIZE);
}
struct netent *
getnetbyname(const char *nam)
{
nss_XbyY_buf_t *b;
struct netent *res = 0;
if ((b = GETBUF()) != 0) {
res = getnetbyname_r(nam, b->result, b->buffer, b->buflen);
}
return (res);
}
int
netmatch(struct netbuf *nb, char *name)
{
uint_t claddr;
struct netent n, *np;
char *mp, *p;
uint_t addr, mask;
int i, bits;
char buff[256];
/*
* Check if it's an IPv4 addr
*/
if (nb->len != sizeof (struct sockaddr_in))
return (0);
(void) memcpy(&claddr,
/* LINTED pointer alignment */
&((struct sockaddr_in *)nb->buf)->sin_addr.s_addr,
sizeof (struct in_addr));
claddr = ntohl(claddr);
mp = strchr(name, '/');
if (mp)
*mp++ = '\0';
if (isdigit(*name)) {
/*
* Convert a dotted IP address
* to an IP address. The conversion
* is not the same as that in inet_addr().
*/
p = name;
addr = 0;
for (i = 0; i < 4; i++) {
addr |= atoi(p) << ((3-i) * 8);
p = strchr(p, '.');
if (p == NULL)
break;
p++;
}
} else {
/*
* Turn the netname into
* an IP address.
*/
np = getnetbyname_r(name, &n, buff, sizeof (buff));
if (np == NULL) {
syslog(LOG_DEBUG, "getnetbyname_r: %s: %m", name);
return (0);
}
addr = np->n_net;
}
/*
* If the mask is specified explicitly then
* use that value, e.g.
*
* @109.104.56/28
*
* otherwise assume a mask from the zero octets
* in the least significant bits of the address, e.g.
*
* @109.104 or @109.104.0.0
*/
if (mp) {
bits = atoi(mp);
mask = bits ? ~0 << ((sizeof (struct in_addr) * NBBY) - bits)
: 0;
addr &= mask;
} else {
if ((addr & 0x00ffffff) == 0)
mask = 0xff000000;
else if ((addr & 0x0000ffff) == 0)
mask = 0xffff0000;
else if ((addr & 0x000000ff) == 0)
mask = 0xffffff00;
}
return ((claddr & mask) == addr);
}
/*
* Convert net name to internet address.
* Return 0 upon failure.
* XXX - not guaranteed to be thread-safe! See below for platforms
* on which it is thread-safe and on which it isn't.
*/
bpf_u_int32
pcap_nametonetaddr(const char *name)
{
#ifdef _WIN32
/*
* There's no "getnetbyname()" on Windows.
*
* XXX - I guess we could use the BSD code to read
* C:\Windows\System32\drivers\etc/networks, assuming
* that's its home on all the versions of Windows
* we use, but that file probably just has the loopback
* network on 127/24 on 99 44/100% of Windows machines.
*
* (Heck, these days it probably just has that on 99 44/100%
* of *UN*X* machines.)
*/
return 0;
#else
/*
* UN*X.
*/
struct netent *np;
#if defined(HAVE_LINUX_GETNETBYNAME_R)
/*
* We have Linux's reentrant getnetbyname_r().
*/
struct netent result_buf;
char buf[1024]; /* arbitrary size */
int h_errnoval;
int err;
err = getnetbyname_r(name, &result_buf, buf, sizeof buf, &np,
&h_errnoval);
if (err != 0) {
/*
* XXX - dynamically allocate the buffer, and make it
* bigger if we get ERANGE back?
*/
return 0;
}
#elif defined(HAVE_SOLARIS_IRIX_GETNETBYNAME_R)
/*
* We have Solaris's and IRIX's reentrant getnetbyname_r().
*/
struct netent result_buf;
char buf[1024]; /* arbitrary size */
np = getnetbyname_r(name, &result_buf, buf, (int)sizeof buf);
#elif defined(HAVE_AIX_GETNETBYNAME_R)
/*
* We have AIX's reentrant getnetbyname_r().
*/
struct netent result_buf;
struct netent_data net_data;
if (getnetbyname_r(name, &result_buf, &net_data) == -1)
np = NULL;
else
np = &result_buf;
#else
/*
* We don't have any getnetbyname_r(); either we have a
* getnetbyname() that uses thread-specific data, in which
* case we're thread-safe (sufficiently recent FreeBSD,
* sufficiently recent Darwin-based OS, sufficiently recent
* HP-UX, sufficiently recent Tru64 UNIX), or we have the
* traditional getnetbyname() (everything else, including
* current NetBSD and OpenBSD), in which case we're not
* thread-safe.
*/
np = getnetbyname(name);
#endif
if (np != NULL)
return np->n_net;
else
return 0;
#endif /* _WIN32 */
}