struct hostent *
_gethostbynisaddr(const void *addr, socklen_t len, int af)
{
#ifdef YP
struct hostent *he;
struct hostent_data *hed;
u_long oresopt;
int error;
res_state statp;
statp = __res_state();
if ((he = __hostent_init()) == NULL ||
(hed = __hostent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
return (NULL);
}
oresopt = statp->options;
statp->options &= ~RES_USE_INET6;
error = _gethostbynisaddr_r(addr, len, af, he, hed);
statp->options = oresopt;
return (error == 0) ? he : NULL;
#else
return (NULL);
#endif
}
int
gethostent_r(struct hostent* hptr, char* buffer, size_t buflen,
struct hostent** result, int* h_errnop) {
struct hostent_data* hed;
struct hostent he;
res_state statp;
statp = __res_state();
if ((statp->options & RES_INIT) == 0 && res_ninit(statp) == -1) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (-1);
}
if ((hed = __hostent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (-1);
}
if (gethostent_p(&he, hed, statp->options & RES_USE_INET6, statp) != 0) {
return (-1);
}
if (__copy_hostent(&he, hptr, buffer, buflen) != 0) {
return (-1);
}
*result = hptr;
return (0);
}
void *tf (void *resp)
{
if (resp == &_res || resp == __res_state ())
abort ();
_res.retry = 24;
return NULL;
}
void do_test (struct __res_state *resp)
{
if (resp != &_res || resp != __res_state ())
abort ();
if (_res.retry != 12)
abort ();
}
int
_ht_gethostbyaddr(void* rval, void* cb_data, va_list ap) {
const void* addr;
socklen_t len;
int af;
char* buffer;
size_t buflen;
int* errnop, *h_errnop;
struct hostent* hptr, he;
struct hostent_data* hed;
res_state statp;
int error;
addr = va_arg(ap, const void*);
len = va_arg(ap, socklen_t);
af = va_arg(ap, int);
hptr = va_arg(ap, struct hostent*);
buffer = va_arg(ap, char*);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int*);
h_errnop = va_arg(ap, int*);
*((struct hostent**)rval) = NULL;
statp = __res_state();
if ((hed = __hostent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
_sethosthtent(0, hed);
while ((error = gethostent_p(&he, hed, 0, statp)) == 0)
if (he.h_addrtype == af && !bcmp(he.h_addr, addr, len)) {
if (he.h_addrtype == AF_INET &&
statp->options & RES_USE_INET6) {
_map_v4v6_address(he.h_addr, he.h_addr);
he.h_length = IN6ADDRSZ;
he.h_addrtype = AF_INET6;
}
break;
}
_endhosthtent(hed);
if (error != 0) {
return (NS_NOTFOUND);
}
if (__copy_hostent(&he, hptr, buffer, buflen) != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
*((struct hostent**)rval) = hptr;
return (NS_SUCCESS);
}
int
_ht_getnetbyname(void *rval, void *cb_data, va_list ap)
{
const char *name;
char *buffer;
size_t buflen;
int *errnop, *h_errnop;
struct netent *nptr, ne;
struct netent_data *ned;
char **cp;
res_state statp;
int error;
name = va_arg(ap, const char *);
nptr = va_arg(ap, struct netent *);
buffer = va_arg(ap, char *);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int *);
h_errnop = va_arg(ap, int *);
statp = __res_state();
if ((ned = __netent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_UNAVAIL);
}
_setnethtent(ned->stayopen, ned);
while ((error = getnetent_p(&ne, ned)) == 0) {
if (strcasecmp(ne.n_name, name) == 0)
break;
for (cp = ne.n_aliases; *cp != 0; cp++)
if (strcasecmp(*cp, name) == 0)
goto found;
}
found:
if (!ned->stayopen)
_endnethtent(ned);
if (error != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (__copy_netent(&ne, nptr, buffer, buflen) != 0) {
*errnop = errno;
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_RETURN);
}
*((struct netent **)rval) = nptr;
return (NS_SUCCESS);
}
void
Settings::ReadConfiguration()
{
BNetworkInterface interface(fName);
BNetworkInterfaceAddress address;
// TODO: We only get the first address
if (interface.GetAddressAt(0, address) != B_OK)
return;
fIP = address.Address().ToString();
fNetmask = address.Mask().ToString();
if (GetDefaultGateway(fGateway) != B_OK)
return;
uint32 flags = interface.Flags();
fAuto = (flags & (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
fDisabled = (flags & IFF_UP) == 0;
// Read wireless network from interfaces
fWirelessNetwork.SetTo(NULL);
BNetworkDevice networkDevice(fName);
if (networkDevice.IsWireless()) {
uint32 networkIndex = 0;
wireless_network wirelessNetwork;
// TODO: We only get the first associated network for now
if (networkDevice.GetNextAssociatedNetwork(networkIndex,
wirelessNetwork) == B_OK) {
fWirelessNetwork.SetTo(wirelessNetwork.name);
}
}
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
int
_nis_gethostbyaddr(void *rval, void *cb_data, va_list ap)
{
#ifdef YP
const void *addr;
socklen_t len;
int af;
char *buffer;
size_t buflen;
int *errnop, *h_errnop;
struct hostent *hptr, he;
struct hostent_data *hed;
res_state statp;
addr = va_arg(ap, const void *);
len = va_arg(ap, socklen_t);
af = va_arg(ap, int);
hptr = va_arg(ap, struct hostent *);
buffer = va_arg(ap, char *);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int *);
h_errnop = va_arg(ap, int *);
*((struct hostent **)rval) = NULL;
statp = __res_state();
if ((hed = __hostent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (_gethostbynisaddr_r(addr, len, af, &he, hed) != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (__copy_hostent(&he, hptr, buffer, buflen) != 0) {
*errnop = errno;
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_RETURN);
}
*((struct hostent **)rval) = hptr;
return (NS_SUCCESS);
#else
*((struct hostent **)rval) = NULL;
return (NS_UNAVAIL);
#endif
}
void
Settings::ReadConfiguration()
{
BNetworkInterface interface(fName);
BNetworkAddress hardwareAddress;
if (interface.GetHardwareAddress(hardwareAddress) != B_OK)
return;
fHardwareAddress = hardwareAddress.ToString();
BNetworkInterfaceAddress address;
// TODO: We only get the first address
if (interface.GetAddressAt(0, address) != B_OK)
return;
fIP = address.Address().ToString();
fNetmask = address.Mask().ToString();
int family = AF_INET;
if (address.Address().Family() != AF_UNSPEC)
family = address.Address().Family();
BNetworkAddress gatewayAddress;
if (interface.GetDefaultRoute(family, gatewayAddress) != B_OK)
return;
fGateway = gatewayAddress.ToString();
uint32 flags = interface.Flags();
fAuto = (flags & (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
fDisabled = (flags & IFF_UP) == 0;
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
int
_ht_getnetbyaddr(void *rval, void *cb_data, va_list ap)
{
uint32_t net;
int type;
char *buffer;
size_t buflen;
int *errnop, *h_errnop;
struct netent *nptr, ne;
struct netent_data *ned;
res_state statp;
int error;
net = va_arg(ap, uint32_t);
type = va_arg(ap, int);
nptr = va_arg(ap, struct netent *);
buffer = va_arg(ap, char *);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int *);
h_errnop = va_arg(ap, int *);
statp = __res_state();
if ((ned = __netent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_UNAVAIL);
}
_setnethtent(ned->stayopen, ned);
while ((error = getnetent_p(&ne, ned)) == 0)
if (ne.n_addrtype == type && ne.n_net == net)
break;
if (!ned->stayopen)
_endnethtent(ned);
if (error != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (__copy_netent(&ne, nptr, buffer, buflen) != 0) {
*errnop = errno;
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_RETURN);
}
*((struct netent **)rval) = nptr;
return (NS_SUCCESS);
}
int
_nis_getnetbyname(void *rval, void *cb_data, va_list ap)
{
#ifdef YP
const char *name;
char *buffer;
size_t buflen;
int *errnop, *h_errnop;
struct netent *nptr, ne;
struct netent_data *ned;
res_state statp;
name = va_arg(ap, const char *);
nptr = va_arg(ap, struct netent *);
buffer = va_arg(ap, char *);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int *);
h_errnop = va_arg(ap, int *);
statp = __res_state();
if ((ned = __netent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_UNAVAIL);
}
if (_getnetbynis(name, "networks.byname", AF_INET, &ne, ned) != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (__copy_netent(&ne, nptr, buffer, buflen) != 0) {
*errnop = errno;
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_RETURN);
}
*((struct netent **)rval) = nptr;
return (NS_SUCCESS);
#else
return (NS_UNAVAIL);
#endif
}
int
getnetent_r(struct netent *nptr, char *buffer, size_t buflen,
struct netent **result, int *h_errnop)
{
struct netent_data *ned;
struct netent ne;
res_state statp;
statp = __res_state();
if ((ned = __netent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (-1);
}
if (getnetent_p(&ne, ned) != 0)
return (-1);
if (__copy_netent(&ne, nptr, buffer, buflen) != 0)
return (-1);
*result = nptr;
return (0);
}
int
_ht_gethostbyname(void* rval, void* cb_data, va_list ap) {
const char* name;
int af;
char* buffer;
size_t buflen;
int* errnop, *h_errnop;
struct hostent* hptr, he;
struct hostent_data* hed;
char** cp;
res_state statp;
int error;
name = va_arg(ap, const char*);
af = va_arg(ap, int);
hptr = va_arg(ap, struct hostent*);
buffer = va_arg(ap, char*);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int*);
h_errnop = va_arg(ap, int*);
*((struct hostent**)rval) = NULL;
statp = __res_state();
if ((hed = __hostent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
_sethosthtent(0, hed);
while ((error = gethostent_p(&he, hed, 0, statp)) == 0) {
if (he.h_addrtype != af) {
continue;
}
if (he.h_addrtype == AF_INET &&
statp->options & RES_USE_INET6) {
_map_v4v6_address(he.h_addr, he.h_addr);
he.h_length = IN6ADDRSZ;
he.h_addrtype = AF_INET6;
}
if (strcasecmp(he.h_name, name) == 0) {
break;
}
for (cp = he.h_aliases; *cp != 0; cp++)
if (strcasecmp(*cp, name) == 0) {
goto found;
}
}
found:
_endhosthtent(hed);
if (error != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (__copy_hostent(&he, hptr, buffer, buflen) != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
*((struct hostent**)rval) = hptr;
return (NS_SUCCESS);
}
int *
__h_errno(void)
{
return (&__res_state()->res_h_errno);
}
static int
_getnetbynis(const char *name, char *map, int af, struct netent *ne,
struct netent_data *ned)
{
char *p, *bp, *ep;
char *cp, **q;
char *result;
int resultlen, len;
char ypbuf[YPMAXRECORD + 2];
switch(af) {
case AF_INET:
break;
default:
case AF_INET6:
errno = EAFNOSUPPORT;
return (-1);
}
if (ned->yp_domain == (char *)NULL)
if (yp_get_default_domain (&ned->yp_domain))
return (-1);
if (yp_match(ned->yp_domain, map, name, strlen(name), &result,
&resultlen))
return (-1);
bcopy((char *)result, (char *)&ypbuf, resultlen);
ypbuf[resultlen] = '\0';
free(result);
result = (char *)&ypbuf;
if ((cp = index(result, '\n')))
*cp = '\0';
cp = strpbrk(result, " \t");
*cp++ = '\0';
bp = ned->netbuf;
ep = ned->netbuf + sizeof ned->netbuf;
len = strlen(result) + 1;
if (ep - bp < len) {
RES_SET_H_ERRNO(__res_state(), NO_RECOVERY);
return (-1);
}
strlcpy(bp, result, ep - bp);
ne->n_name = bp;
bp += len;
while (*cp == ' ' || *cp == '\t')
cp++;
ne->n_net = inet_network(cp);
ne->n_addrtype = AF_INET;
q = ne->n_aliases = ned->net_aliases;
cp = strpbrk(cp, " \t");
if (cp != NULL)
*cp++ = '\0';
while (cp && *cp) {
if (*cp == ' ' || *cp == '\t') {
cp++;
continue;
}
if (q > &ned->net_aliases[_MAXALIASES - 1])
break;
p = strpbrk(cp, " \t");
if (p != NULL)
*p++ = '\0';
len = strlen(cp) + 1;
if (ep - bp < len)
break;
strlcpy(bp, cp, ep - bp);
*q++ = bp;
bp += len;
cp = p;
}
*q = NULL;
return (0);
}
int
_nis_getnetbyaddr(void *rval, void *cb_data, va_list ap)
{
#ifdef YP
uint32_t addr;
int af;
char *buffer;
size_t buflen;
int *errnop, *h_errnop;
struct netent *nptr, ne;
struct netent_data *ned;
char *str, *cp;
uint32_t net2;
int nn;
unsigned int netbr[4];
char buf[MAXDNAME];
res_state statp;
addr = va_arg(ap, uint32_t);
af = va_arg(ap, int);
nptr = va_arg(ap, struct netent *);
buffer = va_arg(ap, char *);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int *);
h_errnop = va_arg(ap, int *);
statp = __res_state();
if ((ned = __netent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_UNAVAIL);
}
if (af != AF_INET) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
errno = EAFNOSUPPORT;
return (NS_UNAVAIL);
}
for (nn = 4, net2 = addr; net2; net2 >>= 8) {
netbr[--nn] = net2 & 0xff;
}
switch (nn) {
case 3: /* Class A */
sprintf(buf, "%u", netbr[3]);
break;
case 2: /* Class B */
sprintf(buf, "%u.%u", netbr[2], netbr[3]);
break;
case 1: /* Class C */
sprintf(buf, "%u.%u.%u", netbr[1], netbr[2], netbr[3]);
break;
case 0: /* Class D - E */
sprintf(buf, "%u.%u.%u.%u", netbr[0], netbr[1],
netbr[2], netbr[3]);
break;
}
str = (char *)&buf;
cp = str + (strlen(str) - 2);
while(!strcmp(cp, ".0")) {
*cp = '\0';
cp = str + (strlen(str) - 2);
}
if (_getnetbynis(str, "networks.byaddr", af, &ne, ned) != 0) {
*h_errnop = statp->res_h_errno;
return (NS_NOTFOUND);
}
if (__copy_netent(&ne, nptr, buffer, buflen) != 0) {
*errnop = errno;
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_RETURN);
}
*((struct netent **)rval) = nptr;
return (NS_SUCCESS);
#else
return (NS_UNAVAIL);
#endif /* YP */
}
static int
getnetent_p(struct netent *ne, struct netent_data *ned)
{
char *p, *bp, *ep;
char *cp, **q;
int len;
char line[BUFSIZ + 1];
if (ned->netf == NULL &&
(ned->netf = fopen(_PATH_NETWORKS, "r")) == NULL)
return (-1);
again:
p = fgets(line, sizeof line, ned->netf);
if (p == NULL)
return (-1);
if (*p == '#')
goto again;
cp = strpbrk(p, "#\n");
if (cp != NULL)
*cp = '\0';
bp = ned->netbuf;
ep = ned->netbuf + sizeof ned->netbuf;
ne->n_name = bp;
cp = strpbrk(p, " \t");
if (cp == NULL)
goto again;
*cp++ = '\0';
len = strlen(p) + 1;
if (ep - bp < len) {
RES_SET_H_ERRNO(__res_state(), NO_RECOVERY);
return (-1);
}
strlcpy(bp, p, ep - bp);
bp += len;
while (*cp == ' ' || *cp == '\t')
cp++;
p = strpbrk(cp, " \t");
if (p != NULL)
*p++ = '\0';
ne->n_net = inet_network(cp);
ne->n_addrtype = AF_INET;
q = ne->n_aliases = ned->net_aliases;
if (p != NULL) {
cp = p;
while (cp && *cp) {
if (*cp == ' ' || *cp == '\t') {
cp++;
continue;
}
if (q >= &ned->net_aliases[_MAXALIASES - 1])
break;
p = strpbrk(cp, " \t");
if (p != NULL)
*p++ = '\0';
len = strlen(cp) + 1;
if (ep - bp < len)
break;
strlcpy(bp, cp, ep - bp);
*q++ = bp;
bp += len;
cp = p;
}
}
*q = NULL;
return (0);
}
int *errnop __unused;
int *h_errnop;
struct netent *nptr, ne;
struct netent_data *ned;
char **cp;
res_state statp;
int error;
name = va_arg(ap, const char *);
nptr = va_arg(ap, struct netent *);
buffer = va_arg(ap, char *);
buflen = va_arg(ap, size_t);
errnop = va_arg(ap, int *);
h_errnop = va_arg(ap, int *);
statp = __res_state();
if ((ned = __netent_data_init()) == NULL) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
*h_errnop = statp->res_h_errno;
return (NS_UNAVAIL);
}
_setnethtent(ned->stayopen, ned);
while ((error = getnetent_p(&ne, ned)) == 0) {
if (strcasecmp(ne.n_name, name) == 0)
break;
for (cp = ne.n_aliases; *cp != NULL; cp++)
if (strcasecmp(*cp, name) == 0)
goto found;
}
found:
int
main(int argc, char **argv)
{
struct hostent_test_data td, td_addr, td_snap;
char *snapshot_file, *hostlist_file;
res_state statp;
int rv;
int c;
if (argc < 2)
usage();
snapshot_file = NULL;
hostlist_file = NULL;
while ((c = getopt(argc, argv, "nad2iod46mAcMs:f:")) != -1)
switch (c) {
case '4':
af_type = AF_INET;
break;
case '6':
af_type = AF_INET6;
break;
case 'M':
af_type = AF_INET6;
use_ipv6_mapping = 1;
ipnode_flags |= AI_V4MAPPED_CFG;
break;
case 'm':
af_type = AF_INET6;
use_ipv6_mapping = 1;
ipnode_flags |= AI_V4MAPPED;
break;
case 'c':
ipnode_flags |= AI_ADDRCONFIG;
break;
case 'A':
ipnode_flags |= AI_ALL;
break;
case 'o':
use_ipnode_functions = 1;
break;
case 'd':
debug = 1;
break;
case 'n':
method = TEST_GETHOSTBYNAME2;
break;
case 'a':
method = TEST_GETHOSTBYADDR;
break;
case '2':
method = TEST_GETHOSTBYNAME2_GETADDRINFO;
break;
case 'i':
method = TEST_GETHOSTBYADDR_GETNAMEINFO;
break;
case 's':
snapshot_file = strdup(optarg);
break;
case 'f':
hostlist_file = strdup(optarg);
break;
default:
usage();
}
if (use_ipnode_functions == 0) {
statp = __res_state();
if ((statp == NULL) || ((statp->options & RES_INIT) == 0 &&
res_ninit(statp) == -1)) {
if (debug)
printf("error: can't init res_state\n");
free(snapshot_file);
free(hostlist_file);
return (-1);
}
if (use_ipv6_mapping == 0)
statp->options &= ~RES_USE_INET6;
else
statp->options |= RES_USE_INET6;
}
TEST_DATA_INIT(hostent, &td, clone_hostent, free_hostent);
TEST_DATA_INIT(hostent, &td_addr, clone_hostent, free_hostent);
TEST_DATA_INIT(hostent, &td_snap, clone_hostent, free_hostent);
if (hostlist_file == NULL)
usage();
if (access(hostlist_file, R_OK) != 0) {
if (debug)
printf("can't access the hostlist file %s\n",
hostlist_file);
usage();
}
if (debug)
printf("building host lists from %s\n", hostlist_file);
rv = TEST_SNAPSHOT_FILE_READ(hostent, hostlist_file, &td,
hostent_read_hostlist_func);
if (rv != 0)
goto fin;
if (snapshot_file != NULL) {
if (access(snapshot_file, W_OK | R_OK) != 0) {
if (errno == ENOENT) {
if (method != TEST_GETHOSTBYADDR)
method = TEST_BUILD_SNAPSHOT;
else
method = TEST_BUILD_ADDR_SNAPSHOT;
} else {
if (debug)
printf("can't access the snapshot file %s\n",
snapshot_file);
rv = -1;
goto fin;
}
} else {
rv = TEST_SNAPSHOT_FILE_READ(hostent, snapshot_file,
&td_snap, hostent_read_snapshot_func);
if (rv != 0) {
if (debug)
printf("error reading snapshot file\n");
goto fin;
}
}
}
switch (method) {
case TEST_GETHOSTBYNAME2:
if (snapshot_file != NULL)
rv = DO_2PASS_TEST(hostent, &td, &td_snap,
compare_hostent, NULL);
break;
case TEST_GETHOSTBYADDR:
rv = DO_1PASS_TEST(hostent, &td,
hostent_test_gethostbyaddr, (void *)&td_addr);
if (snapshot_file != NULL)
rv = DO_2PASS_TEST(hostent, &td_addr, &td_snap,
compare_hostent, NULL);
break;
case TEST_GETHOSTBYNAME2_GETADDRINFO:
rv = DO_1PASS_TEST(hostent, &td,
hostent_test_getaddrinfo_eq, NULL);
break;
case TEST_GETHOSTBYADDR_GETNAMEINFO:
rv = DO_1PASS_TEST(hostent, &td,
hostent_test_getnameinfo_eq, NULL);
break;
case TEST_BUILD_SNAPSHOT:
if (snapshot_file != NULL) {
rv = TEST_SNAPSHOT_FILE_WRITE(hostent, snapshot_file, &td,
sdump_hostent);
}
break;
case TEST_BUILD_ADDR_SNAPSHOT:
if (snapshot_file != NULL) {
rv = DO_1PASS_TEST(hostent, &td,
hostent_test_gethostbyaddr, (void *)&td_addr);
rv = TEST_SNAPSHOT_FILE_WRITE(hostent, snapshot_file,
&td_addr, sdump_hostent);
}
break;
default:
rv = 0;
break;
};
fin:
TEST_DATA_DESTROY(hostent, &td_snap);
TEST_DATA_DESTROY(hostent, &td_addr);
TEST_DATA_DESTROY(hostent, &td);
free(hostlist_file);
free(snapshot_file);
return (rv);
}
void
Setting::ReadConfiguration()
{
ifreq request;
if (!_PrepareRequest(request))
return;
BString text = "dummy";
char address[32];
sockaddr_in* inetAddress = NULL;
// Obtain IP.
if (ioctl(fSocket, SIOCGIFADDR, &request, sizeof(request)) < 0)
return;
inetAddress = (sockaddr_in*)&request.ifr_addr;
if (inet_ntop(AF_INET, &inetAddress->sin_addr, address,
sizeof(address)) == NULL) {
return;
}
fIP = address;
// Obtain netmask.
if (ioctl(fSocket, SIOCGIFNETMASK, &request,
sizeof(request)) < 0) {
return;
}
inetAddress = (sockaddr_in*)&request.ifr_mask;
if (inet_ntop(AF_INET, &inetAddress->sin_addr, address,
sizeof(address)) == NULL) {
return;
}
fNetmask = address;
// Obtain gateway
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(fSocket, SIOCGRTSIZE, &config, sizeof(struct ifconf)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
void *buffer = malloc(size);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(fSocket, SIOCGRTTABLE, &config, sizeof(struct ifconf)) < 0)
return;
ifreq *interface = (ifreq *)buffer;
ifreq *end = (ifreq *)((uint8 *)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if (route.flags & RTF_GATEWAY) {
inetAddress = (sockaddr_in*)route.gateway;
fGateway = inet_ntoa(inetAddress->sin_addr);
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
uint32 flags = 0;
if (ioctl(fSocket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0)
flags = request.ifr_flags;
fAuto = (flags & IFF_AUTO_CONFIGURED) != 0;
fEnabled = (flags & IFF_UP) != 0;
if (ioctl(fSocket, SIOCGIFMEDIA, &request, sizeof(struct ifreq)) == 0)
fMedia = request.ifr_media;
// read resolv.conf for the dns.
fNameservers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameservers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
}
}
static int
host_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
{
res_state statp;
u_long res_options;
const int op_id = 1;
char *str;
void *addr;
socklen_t len;
int type;
size_t desired_size, size;
enum nss_lookup_type lookup_type;
char *p;
int res = NS_UNAVAIL;
statp = __res_state();
res_options = statp->options & (RES_RECURSE | RES_DEFNAMES |
RES_DNSRCH | RES_NOALIASES | RES_USE_INET6);
lookup_type = (enum nss_lookup_type)cache_mdata;
switch (lookup_type) {
case nss_lt_name:
str = va_arg(ap, char *);
type = va_arg(ap, int);
size = strlen(str);
desired_size = sizeof(res_options) + sizeof(int) +
sizeof(enum nss_lookup_type) + sizeof(int) + size + 1;
if (desired_size > *buffer_size) {
res = NS_RETURN;
goto fin;
}
p = buffer;
memcpy(p, &res_options, sizeof(res_options));
p += sizeof(res_options);
memcpy(p, &op_id, sizeof(int));
p += sizeof(int);
memcpy(p, &lookup_type, sizeof(enum nss_lookup_type));
p += sizeof(int);
memcpy(p, &type, sizeof(int));
p += sizeof(int);
memcpy(p, str, size + 1);
res = NS_SUCCESS;
break;
case nss_lt_id:
addr = va_arg(ap, void *);
len = va_arg(ap, socklen_t);
type = va_arg(ap, int);
desired_size = sizeof(res_options) + sizeof(int) +
sizeof(enum nss_lookup_type) + sizeof(int) +
sizeof(socklen_t) + len;
if (desired_size > *buffer_size) {
res = NS_RETURN;
goto fin;
}
p = buffer;
memcpy(p, &res_options, sizeof(res_options));
p += sizeof(res_options);
memcpy(p, &op_id, sizeof(int));
p += sizeof(int);
memcpy(p, &lookup_type, sizeof(enum nss_lookup_type));
p += sizeof(int);
memcpy(p, &type, sizeof(int));
p += sizeof(int);
memcpy(p, &len, sizeof(socklen_t));
p += sizeof(socklen_t);
memcpy(p, addr, len);
res = NS_SUCCESS;
break;
default:
/* should be unreachable */
return (NS_UNAVAIL);
}
fin:
*buffer_size = desired_size;
return (res);
}
/*! ReadConfiguration pulls the current interface settings
from the interfaces via BNetworkInterface and friends
and populates this classes private settings BAddresses
with them.
*/
void
NetworkSettings::ReadConfiguration()
{
fDisabled = (fNetworkInterface->Flags() & IFF_UP) == 0;
for (int index = 0; index < MAX_PROTOCOLS; index++) {
int inet_id = fProtocols[index].inet_id;
if (fProtocols[index].present) {
// --- Obtain IP Addresses
int32 zeroAddr = fNetworkInterface->FindFirstAddress(inet_id);
if (zeroAddr >= 0) {
fNetworkInterface->GetAddressAt(zeroAddr,
fInterfaceAddressMap[inet_id]);
fAddress[inet_id].SetTo(
fInterfaceAddressMap[inet_id].Address());
fNetmask[inet_id].SetTo(
fInterfaceAddressMap[inet_id].Mask());
}
// --- Obtain gateway
// TODO : maybe in the future no ioctls?
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
// Populate config with size of routing table
if (ioctl(fProtocols[index].socket_id, SIOCGRTSIZE,
&config, sizeof(config)) < 0)
return;
uint32 size = (uint32)config.ifc_value;
if (size == 0)
return;
// Malloc a buffer the size of the routing table
void* buffer = malloc(size);
if (buffer == NULL)
return;
MemoryDeleter bufferDeleter(buffer);
config.ifc_len = size;
config.ifc_buf = buffer;
if (ioctl(fProtocols[index].socket_id, SIOCGRTTABLE,
&config, sizeof(config)) < 0)
return;
ifreq* interface = (ifreq*)buffer;
ifreq* end = (ifreq*)((uint8*)buffer + size);
while (interface < end) {
route_entry& route = interface->ifr_route;
if ((route.flags & RTF_GATEWAY) != 0) {
if (inet_id == AF_INET) {
char addressOut[INET_ADDRSTRLEN];
sockaddr_in* socketAddr
= (sockaddr_in*)route.gateway;
inet_ntop(inet_id, &socketAddr->sin_addr,
addressOut, INET_ADDRSTRLEN);
fGateway[inet_id].SetTo(addressOut);
} else if (inet_id == AF_INET6) {
char addressOut[INET6_ADDRSTRLEN];
sockaddr_in6* socketAddr
= (sockaddr_in6*)route.gateway;
inet_ntop(inet_id, &socketAddr->sin6_addr,
addressOut, INET6_ADDRSTRLEN);
fGateway[inet_id].SetTo(addressOut);
} else {
printf("Cannot pull routes for unknown protocol: %d\n",
inet_id);
fGateway[inet_id].SetTo("");
}
}
int32 addressSize = 0;
if (route.destination != NULL)
addressSize += route.destination->sa_len;
if (route.mask != NULL)
addressSize += route.mask->sa_len;
if (route.gateway != NULL)
addressSize += route.gateway->sa_len;
interface = (ifreq *)((addr_t)interface + IF_NAMESIZE
+ sizeof(route_entry) + addressSize);
}
// --- Obtain selfconfiguration options
// TODO : This needs to be determined by protocol flags
// AutoConfiguration on the IP level doesn't exist yet
// ( fInterfaceAddressMap[AF_INET].Flags() )
if (fProtocols[index].socket_id >= 0) {
fAutoConfigure[inet_id] = (fNetworkInterface->Flags()
& (IFF_AUTO_CONFIGURED | IFF_CONFIGURING)) != 0;
}
}
}
// Read wireless network from interfaces
fWirelessNetwork.SetTo(NULL);
BPath path;
find_directory(B_SYSTEM_SETTINGS_DIRECTORY, &path);
path.Append("network");
path.Append("interfaces");
void* handle = load_driver_settings(path.Path());
if (handle != NULL) {
const driver_settings* settings = get_driver_settings(handle);
if (settings != NULL) {
for (int32 i = 0; i < settings->parameter_count; i++) {
driver_parameter& top = settings->parameters[i];
if (!strcmp(top.name, "interface")) {
// The name of the interface can either be the value of
// the "interface" parameter, or a separate "name" parameter
const char* name = NULL;
if (top.value_count > 0) {
name = top.values[0];
if (fName != name)
continue;
}
// search "network" parameter
for (int32 j = 0; j < top.parameter_count; j++) {
driver_parameter& sub = top.parameters[j];
if (name == NULL && !strcmp(sub.name, "name")
&& sub.value_count > 0) {
name = sub.values[0];
if (fName != sub.values[0])
break;
}
if (!strcmp(sub.name, "network")
&& sub.value_count > 0) {
fWirelessNetwork.SetTo(sub.values[0]);
break;
}
}
// We found our interface
if (fName == name)
break;
}
}
}
unload_driver_settings(handle);
}
// read resolv.conf for the dns.
fNameServers.MakeEmpty();
res_init();
res_state state = __res_state();
if (state != NULL) {
for (int i = 0; i < state->nscount; i++) {
fNameServers.AddItem(
new BString(inet_ntoa(state->nsaddr_list[i].sin_addr)));
}
fDomain = state->dnsrch[0];
}
}
static int
_gethostbynis(const char *name, char *map, int af, struct hostent *he,
struct hostent_data *hed)
{
char *p, *bp, *ep;
char *cp, **q;
char *result;
int resultlen, size, addrok = 0;
char ypbuf[YPMAXRECORD + 2];
res_state statp;
statp = __res_state();
switch(af) {
case AF_INET:
size = NS_INADDRSZ;
break;
case AF_INET6:
size = NS_IN6ADDRSZ;
break;
default:
errno = EAFNOSUPPORT;
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
return (-1);
}
if (hed->yp_domain == (char *)NULL)
if (yp_get_default_domain (&hed->yp_domain)) {
RES_SET_H_ERRNO(statp, NETDB_INTERNAL);
return (-1);
}
if (yp_match(hed->yp_domain, map, name, strlen(name), &result,
&resultlen)) {
RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);
return (-1);
}
/* avoid potential memory leak */
bcopy((char *)result, (char *)&ypbuf, resultlen);
ypbuf[resultlen] = '\0';
free(result);
result = (char *)&ypbuf;
if ((cp = strchr(result, '\n')))
*cp = '\0';
cp = strpbrk(result, " \t");
*cp++ = '\0';
he->h_addr_list = hed->h_addr_ptrs;
he->h_addr = (char *)hed->host_addr;
switch (af) {
case AF_INET:
addrok = inet_aton(result, (struct in_addr *)hed->host_addr);
if (addrok != 1)
break;
if (statp->options & RES_USE_INET6) {
_map_v4v6_address((char *)hed->host_addr,
(char *)hed->host_addr);
af = AF_INET6;
size = NS_IN6ADDRSZ;
}
break;
case AF_INET6:
addrok = inet_pton(af, result, hed->host_addr);
break;
}
if (addrok != 1) {
RES_SET_H_ERRNO(statp, HOST_NOT_FOUND);
return (-1);
}
he->h_addr_list[1] = NULL;
he->h_length = size;
he->h_addrtype = af;
while (*cp == ' ' || *cp == '\t')
cp++;
bp = hed->hostbuf;
ep = hed->hostbuf + sizeof hed->hostbuf;
he->h_name = bp;
q = he->h_aliases = hed->host_aliases;
p = strpbrk(cp, " \t");
if (p != NULL)
*p++ = '\0';
size = strlen(cp) + 1;
if (ep - bp < size) {
RES_SET_H_ERRNO(statp, NO_RECOVERY);
return (-1);
}
strlcpy(bp, cp, ep - bp);
bp += size;
cp = p;
while (cp && *cp) {
if (*cp == ' ' || *cp == '\t') {
cp++;
continue;
}
if (q >= &hed->host_aliases[_MAXALIASES - 1])
break;
p = strpbrk(cp, " \t");
if (p != NULL)
*p++ = '\0';
size = strlen(cp) + 1;
if (ep - bp < size)
break;
strlcpy(bp, cp, ep - bp);
*q++ = bp;
bp += size;
cp = p;
}
*q = NULL;
return (0);
}
