static void
test_network (void)
{
struct netent *nptr;
u_int32_t ip;
/*
This test needs the following line in /etc/networks:
loopback 127.0.0.0
*/
nptr = getnetbyname ("loopback");
output_netent ("getnetbyname (\"loopback\")",nptr);
nptr = getnetbyname ("LoopBACK");
output_netent ("getnetbyname (\"LoopBACK\")",nptr);
ip = inet_network ("127.0.0.0");
nptr = getnetbyaddr (ip, AF_INET);
output_netent ("getnetbyaddr (inet_network (\"127.0.0.0\"), AF_INET)",nptr);
setnetent (0);
do
{
nptr = getnetent ();
output_netent ("getnetent ()", nptr);
}
while (nptr != NULL);
endnetent ();
}
struct netent *wp_getnetbyname (const char *name)
{
struct netent *p;
if ((p = getnetbyname (name)) == NULL)
wp_warning ("getnetbyname() error");
return p;
}
/*
* Input an Internet address and convert to binary.
*/
int
iw_in_inet(char *name, struct sockaddr *sap)
{
struct hostent *hp;
struct netent *np;
struct sockaddr_in *sain = (struct sockaddr_in *) sap;
/* Grmpf. -FvK */
sain->sin_family = AF_INET;
sain->sin_port = 0;
/* Default is special, meaning 0.0.0.0. */
if (!strcmp(name, "default")) {
sain->sin_addr.s_addr = INADDR_ANY;
return(1);
}
/* Try the NETWORKS database to see if this is a known network. */
if ((np = getnetbyname(name)) != (struct netent *)NULL) {
sain->sin_addr.s_addr = htonl(np->n_net);
strcpy(name, np->n_name);
return(1);
}
/* Always use the resolver (DNS name + IP addresses) */
if ((hp = gethostbyname(name)) == (struct hostent *)NULL) {
errno = h_errno;
return(-1);
}
memcpy((char *) &sain->sin_addr, (char *) hp->h_addr_list[0], hp->h_length);
strcpy(name, hp->h_name);
return(0);
}
/*
* getnetbyname/addr - get entries from network database
*/
int
dogetnet(const char **list)
{
struct netent *np;
int rc = EXC_SUCCESS;
if (list == NULL || *list == NULL) {
while ((np = getnetent()) != NULL)
(void) putnetent(np, stdout);
} else {
for (; *list != NULL; list++) {
long addr = inet_network(*list);
if (addr != -1)
np = getnetbyaddr(addr, AF_INET);
else
np = getnetbyname(*list);
if (np == NULL)
rc = EXC_NAME_NOT_FOUND;
else
(void) putnetent(np, stdout);
}
}
return (rc);
}
int getnetorhostname(char *type, char *name, struct sockaddr_in *sin)
{
#ifndef EMBED
if (strcmp(type, "net") == 0) {
struct netent *np = getnetbyname(name);
int n;
if (np == 0)
n = inet_network(name);
else {
if (np->n_addrtype != AF_INET)
return (0);
n = np->n_net;
/*
* getnetbyname returns right-adjusted value.
*/
if (n < 128)
n <<= IN_CLASSA_NSHIFT;
else if (n < 65536)
n <<= IN_CLASSB_NSHIFT;
else
n <<= IN_CLASSC_NSHIFT;
}
sin->sin_family = AF_INET;
sin->sin_addr = inet_makeaddr(n, INADDR_ANY);
return (1);
}
if (strcmp(type, "host") == 0)
return (gethostnameornumber(name, sin));
#endif
return (0);
}
int
main(int argc, char **argv)
{
char *ptr, **pptr;
struct netent *nptr;
while (--argc > 0) {
ptr = *++argv;
if ( (nptr = getnetbyname(ptr)) == NULL) {
err_msg("getnetbyname error for net: %s: %s",
ptr, hstrerror(h_errno));
continue;
}
printf("official netname: %s\n", nptr->n_name);
for (pptr = nptr->n_aliases; *pptr != NULL; pptr++)
printf(" alias: %s\n", *pptr);
switch (nptr->n_addrtype) {
case AF_INET:
#ifdef AF_INET6
case AF_INET6:
#endif
break;
default:
err_ret("unknown address type");
break;
}
}
exit(0);
}
static int
networks(int argc, char *argv[])
{
int i, rv = RV_OK;
struct netent *ne;
in_addr_t net;
setnetent(1);
if (argc == 2) {
while ((ne = getnetent()) != NULL)
networksprint(ne);
} else {
for (i = 2; i < argc; i++) {
net = inet_network(argv[i]);
if (net != INADDR_NONE)
ne = getnetbyaddr(net, AF_INET);
else
ne = getnetbyname(argv[i]);
if (ne != NULL)
networksprint(ne);
else {
rv = RV_NOTFOUND;
break;
}
}
}
endnetent();
return rv;
}
int FAST_FUNC INET_resolve(const char *name, struct sockaddr_in *s_in, int hostfirst)
{
struct hostent *hp;
#if ENABLE_FEATURE_ETC_NETWORKS
struct netent *np;
#endif
/* Grmpf. -FvK */
s_in->sin_family = AF_INET;
s_in->sin_port = 0;
/* Default is special, meaning 0.0.0.0. */
if (!strcmp(name, bb_str_default)) {
s_in->sin_addr.s_addr = INADDR_ANY;
return 1;
}
/* Look to see if it's a dotted quad. */
if (inet_aton(name, &s_in->sin_addr)) {
return 0;
}
/* If we expect this to be a hostname, try hostname database first */
#ifdef DEBUG
if (hostfirst) {
bb_error_msg("gethostbyname(%s)", name);
}
#endif
if (hostfirst) {
hp = gethostbyname(name);
if (hp != NULL) {
memcpy(&s_in->sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
return 0;
}
}
#if ENABLE_FEATURE_ETC_NETWORKS
/* Try the NETWORKS database to see if this is a known network. */
#ifdef DEBUG
bb_error_msg("getnetbyname(%s)", name);
#endif
np = getnetbyname(name);
if (np != NULL) {
s_in->sin_addr.s_addr = htonl(np->n_net);
return 1;
}
#endif
if (hostfirst) {
/* Don't try again */
return -1;
}
#ifdef DEBUG
res_init();
_res.options |= RES_DEBUG;
bb_error_msg("gethostbyname(%s)", name);
#endif
hp = gethostbyname(name);
if (hp == NULL) {
return -1;
}
memcpy(&s_in->sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
return 0;
}
/*
* Convert net name to internet address.
* Return 0 upon failure.
*/
bpf_u_int32
pcap_nametonetaddr(const char *name)
{
#ifndef _WIN32
struct netent *np;
if ((np = getnetbyname(name)) != NULL)
return np->n_net;
else
return 0;
#else
/*
* 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;
#endif
}
int INET_resolve(const char *name, struct sockaddr_in *s_in, int hostfirst)
{
struct hostent *hp;
struct netent *np;
/* Grmpf. -FvK */
s_in->sin_family = AF_INET;
s_in->sin_port = 0;
/* Default is special, meaning 0.0.0.0. */
if (!strcmp(name, bb_INET_default)) {
s_in->sin_addr.s_addr = INADDR_ANY;
return (1);
}
/* Look to see if it's a dotted quad. */
if (inet_aton(name, &s_in->sin_addr)) {
return 0;
}
/* If we expect this to be a hostname, try hostname database first */
#ifdef DEBUG
if (hostfirst) {
bb_error_msg("gethostbyname (%s)", name);
}
#endif
if (hostfirst && (hp = gethostbyname(name)) != (struct hostent *) NULL) {
memcpy((char *) &s_in->sin_addr, (char *) hp->h_addr_list[0],
sizeof(struct in_addr));
return 0;
}
/* Try the NETWORKS database to see if this is a known network. */
#ifdef DEBUG
bb_error_msg("getnetbyname (%s)", name);
#endif
if ((np = getnetbyname(name)) != (struct netent *) NULL) {
s_in->sin_addr.s_addr = htonl(np->n_net);
return 1;
}
if (hostfirst) {
/* Don't try again */
errno = h_errno;
return -1;
}
#ifdef DEBUG
res_init();
_res.options |= RES_DEBUG;
#endif
#ifdef DEBUG
bb_error_msg("gethostbyname (%s)", name);
#endif
if ((hp = gethostbyname(name)) == (struct hostent *) NULL) {
errno = h_errno;
return -1;
}
memcpy((char *) &s_in->sin_addr, (char *) hp->h_addr_list[0],
sizeof(struct in_addr));
return 0;
}
/* netid */
static int _netid(char const * network)
{
struct netent * ne;
if((ne = getnetbyname(network)) == NULL)
return -_netid_error(network, 1);
printf("%u\n", ne->n_net);
return 0;
}
/*
* Convert net name to internet address.
* Return 0 upon failure.
*/
bpf_u_int32
pcap_nametonetaddr(const char *name)
{
struct netent *np;
if ((np = getnetbyname(name)) != NULL)
return np->n_net;
else
return 0;
}
/* _lib7_NetDB_getnetbyname : String -> (String * String list * addr_family * sysword) option
*/
lib7_val_t _lib7_NetDB_getnetbyname (lib7_state_t *lib7_state, lib7_val_t arg)
{
#if defined(OPSYS_WIN32)
/* FIXME: getnetbyname() does not seem to exist under Windows. What is
the equivalent? */
return RAISE_ERROR(lib7_state, "<getnetbyname not implemented>");
#else
return _util_NetDB_mknetent (lib7_state, getnetbyname (STR_LIB7toC(arg)));
#endif
} /* end of _lib7_NetDB_getnetbyname */
static struct in_addr *network_to_ipaddr(const char *name)
{
static struct in_addr addr;
struct netent *net;
if ((net = getnetbyname(name)) != NULL) {
if (net->n_addrtype != AF_INET)
return NULL;
addr.s_addr = htonl(net->n_net);
return &addr;
}
return NULL;
}
/*
* Convert net name to internet address.
* Return 0 upon failure.
*/
bpf_u_int32 pcap_nametonetaddr(const char *name)
{
#ifndef WIN32
struct netent *np;
if ((np = getnetbyname(name)) != NULL)
return np->n_net;
else
return 0;
#else
/*
* There's no "getnetbyname()" on Windows.
*/
return 0;
#endif
}
int
main(int argc, char *argv[])
{
int i, ch, nflag = 0;
struct netent *n;
char *host;
while((ch = getopt(argc, argv, "en")) != -1) {
switch(ch) {
case 'e':
long_err += 1;
break;
case 'n':
nflag = 1;
break;
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
for(i = 0; i < argc; i++) {
if (i)
printf("\n");
printf("===> \"%s\"\n", argv[i]);
host = gethostarg(argv[i]);
errno = 0;
h_errno = 0;
gai_errno = 0;
rrset_errno = 0;
if (nflag)
n = getnetbyname(host);
else
n = getnetbyaddr(inet_network(host), AF_INET);
if (n)
print_netent(n);
print_errors();
}
return (0);
}
static void
in_getaddr(const char *s, int which)
{
#define MIN(a,b) ((a)<(b)?(a):(b))
struct sockaddr_in *sin = sintab[which];
struct hostent *hp;
struct netent *np;
sin->sin_len = sizeof(*sin);
if (which != MASK)
sin->sin_family = AF_INET;
if (which == ADDR) {
char *p = NULL;
if((p = strrchr(s, '/')) != NULL) {
const char *errstr;
/* address is `name/masklen' */
int masklen;
struct sockaddr_in *min = sintab[MASK];
*p = '\0';
if (!isdigit(*(p + 1)))
errstr = "invalid";
else
masklen = (int)strtonum(p + 1, 0, 32, &errstr);
if (errstr != NULL) {
*p = '/';
errx(1, "%s: bad value (width %s)", s, errstr);
}
min->sin_len = sizeof(*min);
min->sin_addr.s_addr = htonl(~((1LL << (32 - masklen)) - 1) &
0xffffffff);
}
}
if (inet_aton(s, &sin->sin_addr))
return;
if ((hp = gethostbyname(s)) != 0)
bcopy(hp->h_addr, (char *)&sin->sin_addr,
MIN((size_t)hp->h_length, sizeof(sin->sin_addr)));
else if ((np = getnetbyname(s)) != 0)
sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
else
errx(1, "%s: bad value", s);
#undef MIN
}
static void
in_getaddr(const char *s, int which)
{
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif /* MIN */
struct sockaddr_in *sin = sintab[which];
struct hostent *hp;
struct netent *np;
sin->sin_len = sizeof(*sin);
if (which != MASK)
sin->sin_family = AF_INET;
if (which == ADDR) {
char *p = NULL;
if((p = strrchr(s, '/')) != NULL) {
/* address is `name/masklen' */
int masklen;
int ret;
struct sockaddr_in *min = sintab[MASK];
*p = '\0';
ret = sscanf(p+1, "%u", &masklen);
if(ret != 1 || (masklen < 0 || masklen > 32)) {
*p = '/';
errx(1, "%s: bad value", s);
}
min->sin_len = sizeof(*min);
min->sin_addr.s_addr = htonl(~((1LL << (32 - masklen)) - 1) &
0xffffffff);
}
}
if (inet_aton(s, &sin->sin_addr))
return;
if ((hp = gethostbyname(s)) != 0)
bcopy(hp->h_addr, (char *)&sin->sin_addr,
MIN(hp->h_length, sizeof(sin->sin_addr)));
else if ((np = getnetbyname(s)) != 0)
sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
else
errx(1, "%s: bad value", s);
#undef MIN
}
void
in_getaddr(char *s, int which)
{
struct sockaddr_in *sin = sintab[which];
struct hostent *hp;
struct netent *np;
sin->sin_len = sizeof(*sin);
sin->sin_family = AF_INET;
if (inet_aton(s, &sin->sin_addr))
;
else if ((hp = gethostbyname(s)) != NULL)
bcopy(hp->h_addr, (char *)&sin->sin_addr, hp->h_length);
else if ((np = getnetbyname(s)) != NULL)
sin->sin_addr = inet_makeaddr(np->n_net, INADDR_ANY);
else
errx(1, "%s: bad value", s);
}
static int
INET_resolve(char *name, struct sockaddr_in *sin)
{
struct hostent *hp;
struct netent *np;
/* Grmpf. -FvK */
sin->sin_family = AF_INET;
sin->sin_port = 0;
/* Default is special, meaning 0.0.0.0. */
if (!strcmp(name, "default")) {
sin->sin_addr.s_addr = INADDR_ANY;
return(1);
}
/* gethostbyname doesnt resolve this (Pavel Krauz) */
if (!(strcmp(name, "255.255.255.255"))) {
sin->sin_addr.s_addr = htonl(INADDR_BROADCAST);
return (1);
}
/* Try the NETWORKS database to see if this is a known network. */
if ((np = getnetbyname(name)) != (struct netent *)NULL) {
sin->sin_addr.s_addr = htonl(np->n_net);
strcpy(name, np->n_name);
return(1);
}
#ifdef DEBUG
res_init();
_res.options |= RES_DEBUG;
#endif
if ((hp = gethostbyname(name)) == (struct hostent *)NULL) {
errno = h_errno;
return(-1);
}
memcpy((char *) &sin->sin_addr, (char *) hp->h_addr_list[0], hp->h_length);
strcpy(name, hp->h_name);
return(0);
}
NET_R_RETURN
getnetbyname_r(const char *name, struct netent *nptr, NET_R_ARGS) {
struct netent *ne = getnetbyname(name);
#ifdef NET_R_SETANSWER
int n = 0;
if (ne == NULL || (n = copy_netent(ne, nptr, NET_R_COPY)) != 0)
*answerp = NULL;
else
*answerp = ne;
if (ne == NULL)
*h_errnop = h_errno;
return (n);
#else
if (ne == NULL)
return (NET_R_BAD);
return (copy_netent(ne, nptr, NET_R_COPY));
#endif
}
/** Translate the network name into an IP address
@param[in] Argc The number of arguments
@param[in] Argv The argument value array
@retval 0 The application exited normally.
@retval Other An error occurred.
**/
int
main (
IN int Argc,
IN char **Argv
)
{
UINT8 * pIpAddress;
struct netent * pNetwork;
DEBUG (( DEBUG_INFO,
"%a starting\r\n",
Argv[0]));
// Determine if the network name is specified
if ( 1 == Argc ) {
Print ( L"%a <network name>\r\n", Argv[0]);
}
else {
// Translate the net name
pNetwork = getnetbyname ( Argv[1]);
if ( NULL == pNetwork ) {
Print ( L"ERROR - network not found, errno: %d\r\n", errno );
}
else {
pIpAddress = (UINT8 *)(UINTN)&pNetwork->n_net;
Print ( L"%a: Type %d, %d.%d.%d.%d\r\n",
pNetwork->n_name,
pNetwork->n_addrtype,
pIpAddress[0],
pIpAddress[1],
pIpAddress[2],
pIpAddress[3]);
}
}
// All done
return errno;
}
int main(int argc, char *argv[])
{
struct netent *netent;
ipaddr_t gateway, destination, netmask, defaultmask=0;
u8_t high_byte;
nwio_route_t route;
int ip_fd, itab;
int r;
int metric;
char *check;
char *ip_device;
char *netmask_str, *metric_str, *destination_str, *gateway_str;
int c;
char *d_arg, *g_arg, *m_arg, *n_arg, *I_arg;
int i_flag, o_flag, D_flag, v_flag;
int cidr;
prog_name= strrchr(argv[0], '/');
if (prog_name == NULL) prog_name= argv[0]; else prog_name++;
if (strcmp(prog_name, "add_route") == 0)
action= ADD;
else if (strcmp(prog_name, "del_route") == 0)
action= DEL;
else
{
fprintf(stderr, "Don't know what to do when named '%s'\n",
prog_name);
exit(1);
}
i_flag= 0;
o_flag= 0;
D_flag= 0;
v_flag= 0;
g_arg= NULL;
d_arg= NULL;
m_arg= NULL;
n_arg= NULL;
I_arg= NULL;
while ((c= getopt(argc, argv, "iovDg:d:m:n:I:?")) != -1)
{
switch(c)
{
case 'i':
if (i_flag)
usage();
i_flag= 1;
break;
case 'o':
if (o_flag)
usage();
o_flag= 1;
break;
case 'v':
if (v_flag)
usage();
v_flag= 1;
break;
case 'D':
if (D_flag)
usage();
D_flag= 1;
break;
case 'g':
if (g_arg)
usage();
g_arg= optarg;
break;
case 'd':
if (d_arg)
usage();
d_arg= optarg;
break;
case 'm':
if (m_arg)
usage();
m_arg= optarg;
break;
case 'n':
if (n_arg)
usage();
n_arg= optarg;
break;
case 'I':
if (I_arg)
usage();
I_arg= optarg;
break;
case '?':
usage();
default:
fprintf(stderr, "%s: getopt failed\n", prog_name);
exit(1);
}
}
if (optind != argc)
usage();
if (i_flag && o_flag)
usage();
itab= i_flag;
if (i_flag)
{
if (g_arg == NULL || d_arg == NULL || m_arg == NULL)
usage();
}
else
{
if (g_arg == NULL || (d_arg == NULL && n_arg != NULL))
{
usage();
}
}
gateway_str= g_arg;
destination_str= d_arg;
metric_str= m_arg;
netmask_str= n_arg;
ip_device= I_arg;
if (!name_to_ip(gateway_str, &gateway))
{
fprintf(stderr, "%s: unknown host '%s'\n", prog_name,
gateway_str);
exit(1);
}
destination= 0;
netmask= 0;
cidr= 0;
if (destination_str)
{
if (parse_cidr(destination_str, &destination, &netmask))
cidr= 1;
else if (inet_aton(destination_str, &destination))
;
else if ((netent= getnetbyname(destination_str)) != NULL)
destination= netent->n_net;
else if (!name_to_ip(destination_str, &destination))
{
fprintf(stderr, "%s: unknown network/host '%s'\n",
prog_name, destination_str);
exit(1);
}
high_byte= *(u8_t *)&destination;
if (!(high_byte & 0x80)) /* class A or 0 */
{
if (destination)
defaultmask= HTONL(0xff000000);
}
else if (!(high_byte & 0x40)) /* class B */
{
defaultmask= HTONL(0xffff0000);
}
else if (!(high_byte & 0x20)) /* class C */
{
defaultmask= HTONL(0xffffff00);
}
else /* class D is multicast ... */
{
fprintf(stderr, "%s: Warning: Martian address '%s'\n",
prog_name, inet_ntoa(destination));
defaultmask= HTONL(0xffffffff);
}
if (destination & ~defaultmask)
{
/* host route */
defaultmask= HTONL(0xffffffff);
}
if (!cidr)
netmask= defaultmask;
}
if (netmask_str)
{
if (cidr)
usage();
if (inet_aton(netmask_str, &netmask) == 0)
{
fprintf(stderr, "%s: illegal netmask'%s'\n", prog_name,
netmask_str);
exit(1);
}
}
if (metric_str)
{
metric= strtol(metric_str, &check, 0);
if (check[0] != '\0' || metric < 1)
{
fprintf(stderr, "%s: illegal metric %s\n",
prog_name, metric_str);
}
}
else
metric= 1;
if (!ip_device)
ip_device= getenv("IP_DEVICE");
if (!ip_device)
ip_device= IP_DEVICE;
ip_fd= open(ip_device, O_RDWR);
if (ip_fd == -1)
{
fprintf(stderr, "%s: unable to open('%s'): %s\n",
prog_name, ip_device, strerror(errno));
exit(1);
}
if (v_flag)
{
printf("%s %s route to %s ",
action == ADD ? "adding" : "deleting",
itab ? "input" : "output",
inet_ntoa(destination));
printf("with netmask %s ", inet_ntoa(netmask));
printf("using gateway %s", inet_ntoa(gateway));
if (itab && action == ADD)
printf(" at distance %d", metric);
printf("\n");
}
route.nwr_ent_no= 0;
route.nwr_dest= destination;
route.nwr_netmask= netmask;
route.nwr_gateway= gateway;
route.nwr_dist= action == ADD ? metric : 0;
route.nwr_flags= (action == DEL && D_flag) ? 0 : NWRF_STATIC;
route.nwr_pref= 0;
route.nwr_mtu= 0;
if (action == ADD)
r= ioctl(ip_fd, itab ? NWIOSIPIROUTE : NWIOSIPOROUTE, &route);
else
r= ioctl(ip_fd, itab ? NWIODIPIROUTE : NWIODIPOROUTE, &route);
if (r == -1)
{
fprintf(stderr, "%s: NWIO%cIP%cROUTE: %s\n",
prog_name,
action == ADD ? 'S' : 'D',
itab ? 'I' : 'O',
strerror(errno));
exit(1);
}
return(0);
}
struct netent *
nw_getnetbyname(char *name)
{
return (struct netent *)getnetbyname(name);
}
/*
* 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 */
}
static int
ip_addr_check(u_int32_t addr, struct wordlist *addrs)
{
int x, y;
u_int32_t a, mask, ah;
int accept;
char *ptr_word, *ptr_mask;
struct hostent *hp;
struct netent *np;
/* don't allow loopback or multicast address */
if (bad_ip_adrs(addr))
return 0;
if (addrs == NULL)
return !auth_required; /* no addresses authorized */
x = y = 0;
for (; addrs != NULL; addrs = addrs->next) {
y++;
/* "-" means no addresses authorized, "*" means any address allowed */
ptr_word = addrs->word;
if (strcmp(ptr_word, "-") == 0)
break;
if (strcmp(ptr_word, "*") == 0)
return 1;
/*
* A colon in the string means that we wish to force a specific
* local:remote address, but we ignore these for now.
*/
if (strchr(addrs->word, ':') != NULL)
x++;
else {
accept = 1;
if (*ptr_word == '!') {
accept = 0;
++ptr_word;
}
mask = ~ (u_int32_t) 0;
ptr_mask = strchr (ptr_word, '/');
if (ptr_mask != NULL) {
int bit_count;
bit_count = (int) strtol (ptr_mask+1, NULL, 10);
if (bit_count <= 0 || bit_count > 32) {
syslog (LOG_WARNING,
"invalid address length %s in auth. address list",
ptr_mask);
continue;
}
*ptr_mask = '\0';
mask <<= 32 - bit_count;
}
hp = gethostbyname(ptr_word);
if (hp != NULL && hp->h_addrtype == AF_INET) {
a = *(u_int32_t *)hp->h_addr;
} else {
np = getnetbyname (ptr_word);
if (np != NULL && np->n_addrtype == AF_INET) {
a = htonl (*(u_int32_t *)np->n_net);
if (ptr_mask == NULL) {
/* calculate appropriate mask for net */
ah = ntohl(a);
if (IN_CLASSA(ah))
mask = IN_CLASSA_NET;
else if (IN_CLASSB(ah))
mask = IN_CLASSB_NET;
else if (IN_CLASSC(ah))
mask = IN_CLASSC_NET;
}
} else {
a = inet_addr (ptr_word);
}
}
if (ptr_mask != NULL)
*ptr_mask = '/';
if (a == (u_int32_t)-1L)
syslog (LOG_WARNING,
"unknown host %s in auth. address list",
addrs->word);
else
/* Here a and addr are in network byte order,
and mask is in host order. */
if (((addr ^ a) & htonl(mask)) == 0)
return accept;
} /* else */
}
return x == y; /* not in list => can't have it */
}
int
acl_securenet(char *file)
{
char data_line[1024], *p, *k;
int line_no = 0, len, i, allow = TRUE, state;
int error_cnt = 0;
struct in_addr addr, mask;
struct netent *net;
FILE *data_file = NULL;
if (file != NULL)
data_file = fopen(file, "r");
/* Always add a localhost allow first, to be compatible with sun */
addr.s_addr = htonl(0x7f000001);
mask.s_addr = htonl(0xffffffff);
allow = TRUE;
acl_add_net(allow, &addr, &mask);
while (data_file != NULL &&
acl_read_line(data_file, data_line, sizeof(data_line))) {
line_no++;
len = strlen(data_line);
if (len == 0)
continue;
p = (char *) &data_line;
/* State 1: Initial State */
state = ACLS_INIT;
addr.s_addr = mask.s_addr = 0;
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0') {
*p++ = '\0';
state = ACLS_ALLOW_NET_MASK;
}
if (state == ACLS_INIT)
state = ACLE_UEOL;
if (state == ACLS_ALLOW_NET_MASK) {
if (*k >= '0' && *k <= '9') {
(void)inet_aton(k, &mask);
state = ACLS_ALLOW_NET;
} else {
net = getnetbyname(k);
if (net == NULL) {
state = ACLE_NONET;
} else {
mask.s_addr = ntohl(net->n_net);
state = ACLS_ALLOW_NET;
}
}
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0')
*p++ = '\0';
}
if (state == ACLS_ALLOW_NET_MASK)
state = ACLE_UEOL;
if (state == ACLS_ALLOW_NET) {
if (*k >= '0' && *k <= '9') {
(void)inet_aton(k, &addr);
state = ACLS_ALLOW_NET_EOL;
} else {
net = getnetbyname(k);
if (net == NULL) {
state = ACLE_NONET;
} else {
addr.s_addr = ntohl(net->n_net);
state = ACLS_ALLOW_NET_EOL;
}
}
}
if (state == ACLS_ALLOW_NET)
state = ACLE_UEOL;
if (*p == '\0' && state == ACLS_ALLOW_NET_EOL) {
acl_add_net(allow, &addr, &mask);
state = ACLE_OK;
}
switch (state) {
case ACLE_NONET:
error_cnt++;
fprintf(stderr,
"securenet: unknown network at line %d\n",
line_no);
break;
case ACLE_UEOL:
error_cnt++;
fprintf(stderr,
"securenet: unexpected end of line at line %d\n",
line_no);
break;
case ACLE_OK:
break;
default:
error_cnt++;
fprintf(stderr, "securenet: unexpected state %d %s\n",
state, k);
}
}
if (data_file != NULL) {
(void)fflush(stderr);
(void)fclose(data_file);
/* Always add a last deny all if file exists */
addr.s_addr = mask.s_addr = 0;
allow = FALSE;
acl_add_net(allow, &addr, &mask);
}
/* Always add a last allow all if file don't exists */
addr.s_addr = mask.s_addr = 0;
allow = TRUE;
acl_add_net(allow, &addr, &mask);
return(error_cnt);
}
int
acl_init(char *file)
{
char data_line[1024], *p, *k;
int line_no = 0, len, i, state;
int allow = TRUE, error_cnt = 0;
struct in_addr addr, mask, *host_addr;
struct hostent *host;
struct netent *net;
FILE *data_file = NULL;
if (file != NULL)
data_file = fopen(file, "r");
while (data_file != NULL &&
acl_read_line(data_file, data_line, sizeof(data_line))) {
line_no++;
len = strlen(data_line);
if (len == 0)
continue;
p = (char *) &data_line;
/* State 1: Initial State */
state = ACLS_INIT;
addr.s_addr = mask.s_addr = 0;
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0')
*p++ = '\0';
if (strcmp(k, "allow") == 0) {
allow = TRUE;
state = ACLS_ALLOW;
}
if (strcmp(k, "deny") == 0) {
allow = FALSE;
state = ACLS_DENY;
}
if (state == ACLS_INIT)
state = ACLE_UVERB;
/* State 2: allow row */
/* State 3: deny row */
if (*p != '\0' &&
(state == ACLS_ALLOW || state == ACLS_DENY)) {
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0')
*p++ = '\0';
if (strcmp(k, "all") == 0)
state = state + ACLD_ALL;
if (strcmp(k, "host") == 0)
state = state + ACLD_HOST;
if (strcmp(k, "net") == 0)
state = state + ACLD_NET;
if (state == ACLS_ALLOW || state == ACLS_DENY)
state = ACLE_U2VERB;
}
if (state == ACLS_ALLOW || state == ACLS_DENY)
state = ACLE_UEOL;
/* State 4 & 5: all state, remove any comment */
if (*p == '\0' &&
(state == ACLS_ALLOW_ALL || state == ACLS_DENY_ALL)) {
acl_add_net(allow, &addr, &mask);
state = ACLE_OK;
}
/* State 6 & 7: host line */
/* State 8 & 9: net line */
if (*p != '\0' &&
state >= ACLS_ALLOW_HOST && state <= ACLS_DENY_NET) {
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0')
*p++ = '\0';
if (state == ACLS_ALLOW_HOST || state == ACLS_DENY_HOST) {
if (*k >= '0' && *k <= '9') {
(void)inet_aton(k, &addr);
acl_add_host(allow, &addr);
state = state + ACLD_HOST_DONE;
} else {
host = gethostbyname(k);
if (host == NULL) {
state = ACLE_NOHOST;
} else {
if (host->h_addrtype == AF_INET) {
while ((host_addr = (struct in_addr *) *host->h_addr_list++) != NULL)
acl_add_host(allow, host_addr);
}
state = state + ACLD_HOST_DONE;
}
}
}
if (state == ACLS_ALLOW_NET || state == ACLS_DENY_NET) {
if (*k >= '0' && *k <= '9') {
(void)inet_aton(k, &addr);
state = state + ACLD_NET_DONE;
} else {
net = getnetbyname(k);
if (net == NULL) {
state = ACLE_NONET;
} else {
addr.s_addr = ntohl(net->n_net);
state = state + ACLD_NET_DONE;
}
}
}
}
if (state >= ACLS_ALLOW_HOST && state <= ACLS_DENY_NET)
state = ACLE_UEOL;
/* State 10 & 11: allow/deny host line */
if (*p == '\0' &&
(state == ACLS_ALLOW_HOST_DONE || state == ACLS_DENY_HOST_DONE))
state = ACLE_OK;
/* State 12 & 13: allow/deny net line */
if (*p == '\0' &&
(state == ACLS_ALLOW_NET_DONE || state == ACLS_DENY_NET_DONE)) {
mask.s_addr = htonl(0xffffff00);
if (ntohl(addr.s_addr) < 0xc0000000)
mask.s_addr = htonl(0xffff0000);
if (ntohl(addr.s_addr) < 0x80000000)
mask.s_addr = htonl(0xff000000);
acl_add_net(allow, &addr, &mask);
state = ACLE_OK;
}
if (*p != '\0' &&
(state == ACLS_ALLOW_NET_DONE || state == ACLS_DENY_NET_DONE)) {
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0')
*p++ = '\0';
if (strcmp(k, "netmask") == 0)
state = state + ACLD_NET_MASK;
if (state == ACLS_ALLOW_NET_DONE ||
state == ACLS_DENY_NET_DONE)
state = ACLE_NONETMASK;
}
/* State 14 & 15: allow/deny net netmask line */
if (*p != '\0' &&
(state == ACLS_ALLOW_NET_MASK || state == ACLS_DENY_NET_MASK)) {
k = p; /* save start of verb */
i = 0;
while (*p != '\0' && !isspace(*p = (char)tolower(*p))) {
p++;
i++;
}
if (*p != '\0')
*p++ = '\0';
if (state == ACLS_ALLOW_NET_MASK ||
state == ACLS_DENY_NET_MASK) {
if (*k >= '0' && *k <= '9') {
(void)inet_aton(k, &mask);
state = state + ACLD_NET_EOL;
} else {
net = getnetbyname(k);
if (net == NULL) {
state = ACLE_NONET;
} else {
mask.s_addr = ntohl(net->n_net);
state = state + ACLD_NET_EOL;
}
}
}
}
if (state == ACLS_ALLOW_NET_MASK || state == ACLS_DENY_NET_MASK)
state = ACLE_UEOL;
/* State 16 & 17: allow/deny host line */
if (*p == '\0' &&
(state == ACLS_ALLOW_NET_EOL || state == ACLS_DENY_NET_EOL)) {
acl_add_net(allow, &addr, &mask);
state = ACLE_OK;
}
switch (state) {
case ACLE_NONETMASK:
fprintf(stderr,
"acl: excpected \"netmask\" missing at line %d\n",
line_no);
break;
case ACLE_NONET:
error_cnt++;
fprintf(stderr, "acl: unknown network at line %d\n",
line_no);
break;
case ACLE_NOHOST:
error_cnt++;
fprintf(stderr, "acl: unknown host at line %d\n",
line_no);
break;
case ACLE_UVERB:
error_cnt++;
fprintf(stderr, "acl: unknown verb at line %d\n",
line_no);
break;
case ACLE_U2VERB:
error_cnt++;
fprintf(stderr,
"acl: unknown secondary verb at line %d\n",
line_no);
break;
case ACLE_UEOL:
error_cnt++;
fprintf(stderr,
"acl: unexpected end of line at line %d\n",
line_no);
break;
case ACLE_OK:
break;
default:
error_cnt++;
fprintf(stderr, "acl: unexpected state %d %s\n",
state, k);
}
}
if (data_file != NULL) {
(void)fflush(stderr);
(void)fclose(data_file);
}
/* Always add a last allow all if file don't exists or */
/* the file doesn't cover all cases. */
addr.s_addr = mask.s_addr = 0;
allow = TRUE;
acl_add_net(allow, &addr, &mask);
return(error_cnt);
}
main(){
cygwin32_getnetbyname("");
getnetbyname("");
}
/*
* The timedaemons synchronize the clocks of hosts in a local area network.
* One daemon runs as master, all the others as slaves. The master
* performs the task of computing clock differences and sends correction
* values to the slaves.
* Slaves start an election to choose a new master when the latter disappears
* because of a machine crash, network partition, or when killed.
* A resolution protocol is used to kill all but one of the masters
* that happen to exist in segments of a partitioned network when the
* network partition is fixed.
*
* Authors: Riccardo Gusella & Stefano Zatti
*
* overhauled at Silicon Graphics
*/
int
main(int argc, char *argv[])
{
int on;
int ret;
int nflag, iflag;
struct timeval ntime;
struct servent *srvp;
char buf[BUFSIZ], *cp, *cplim;
struct ifconf ifc;
struct ifreq ifreq, ifreqf, *ifr;
register struct netinfo *ntp;
struct netinfo *ntip;
struct netinfo *savefromnet;
struct netent *nentp;
struct nets *nt;
struct sockaddr_in server;
u_short port;
int c;
#ifdef lint
ntip = NULL;
#endif
on = 1;
nflag = OFF;
iflag = OFF;
opterr = 0;
while ((c = getopt(argc, argv, "Mtdn:i:F:G:P:")) != -1) {
switch (c) {
case 'M':
Mflag = 1;
break;
case 't':
trace = 1;
break;
case 'n':
if (iflag) {
errx(1, "-i and -n make no sense together");
} else {
nflag = ON;
addnetname(optarg);
}
break;
case 'i':
if (nflag) {
errx(1, "-i and -n make no sense together");
} else {
iflag = ON;
addnetname(optarg);
}
break;
case 'F':
add_good_host(optarg,1);
while (optind < argc && argv[optind][0] != '-')
add_good_host(argv[optind++], 1);
break;
case 'd':
debug = 1;
break;
case 'G':
if (goodgroup != NULL)
errx(1, "only one net group");
goodgroup = optarg;
break;
default:
usage();
break;
}
}
if (optind < argc)
usage();
/* If we care about which machine is the master, then we must
* be willing to be a master
*/
if (goodgroup != NULL || goodhosts != NULL)
Mflag = 1;
if (gethostname(hostname, sizeof(hostname) - 1) < 0)
err(1, "gethostname");
self.l_bak = &self;
self.l_fwd = &self;
self.h_bak = &self;
self.h_fwd = &self;
self.head = 1;
self.good = 1;
if (goodhosts != NULL) /* trust ourself */
add_good_host(hostname,1);
srvp = getservbyname("timed", "udp");
if (srvp == NULL)
errx(1, "timed/udp: unknown service");
port = srvp->s_port;
bzero(&server, sizeof(struct sockaddr_in));
server.sin_port = srvp->s_port;
server.sin_family = AF_INET;
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
err(1, "socket");
if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&on,
sizeof(on)) < 0)
err(1, "setsockopt");
if (bind(sock, (struct sockaddr*)&server, sizeof(server))) {
if (errno == EADDRINUSE)
warnx("time daemon already running");
else
warn("bind");
exit(1);
}
sequence = arc4random(); /* initial seq number */
(void)gettimeofday(&ntime, NULL);
/* rounds kernel variable time to multiple of 5 ms. */
ntime.tv_sec = 0;
ntime.tv_usec = -((ntime.tv_usec/1000) % 5) * 1000;
(void)adjtime(&ntime, (struct timeval *)0);
for (nt = nets; nt; nt = nt->next) {
nentp = getnetbyname(nt->name);
if (nentp == NULL) {
nt->net = inet_network(nt->name);
if (nt->net != INADDR_NONE)
nentp = getnetbyaddr(nt->net, AF_INET);
}
if (nentp != NULL) {
nt->net = nentp->n_net;
} else if (nt->net == INADDR_NONE) {
errx(1, "unknown net %s", nt->name);
} else if (nt->net == INADDR_ANY) {
errx(1, "bad net %s", nt->name);
} else {
warnx("warning: %s unknown in /etc/networks",
nt->name);
}
if (0 == (nt->net & 0xff000000))
nt->net <<= 8;
if (0 == (nt->net & 0xff000000))
nt->net <<= 8;
if (0 == (nt->net & 0xff000000))
nt->net <<= 8;
}
ifc.ifc_len = sizeof(buf);
ifc.ifc_buf = buf;
if (ioctl(sock, SIOCGIFCONF, (char *)&ifc) < 0)
err(1, "get interface configuration");
ntp = NULL;
#define size(p) max((p).sa_len, sizeof(p))
cplim = buf + ifc.ifc_len; /*skip over if's with big ifr_addr's */
for (cp = buf; cp < cplim;
cp += sizeof (ifr->ifr_name) + size(ifr->ifr_addr)) {
ifr = (struct ifreq *)cp;
if (ifr->ifr_addr.sa_family != AF_INET)
continue;
if (!ntp)
ntp = (struct netinfo*)malloc(sizeof(struct netinfo));
bzero(ntp,sizeof(*ntp));
ntp->my_addr=((struct sockaddr_in *)&ifr->ifr_addr)->sin_addr;
ntp->status = NOMASTER;
ifreq = *ifr;
ifreqf = *ifr;
if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifreqf) < 0) {
warn("get interface flags");
continue;
}
if ((ifreqf.ifr_flags & IFF_UP) == 0)
continue;
if ((ifreqf.ifr_flags & IFF_BROADCAST) == 0 &&
(ifreqf.ifr_flags & IFF_POINTOPOINT) == 0) {
continue;
}
if (ioctl(sock, SIOCGIFNETMASK, (char *)&ifreq) < 0) {
warn("get netmask");
continue;
}
ntp->mask = ((struct sockaddr_in *)
&ifreq.ifr_addr)->sin_addr.s_addr;
if (ifreqf.ifr_flags & IFF_BROADCAST) {
if (ioctl(sock, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
warn("get broadaddr");
continue;
}
ntp->dest_addr = *(struct sockaddr_in *)&ifreq.ifr_broadaddr;
/* What if the broadcast address is all ones?
* So we cannot just mask ntp->dest_addr. */
ntp->net = ntp->my_addr;
ntp->net.s_addr &= ntp->mask;
} else {
if (ioctl(sock, SIOCGIFDSTADDR,
(char *)&ifreq) < 0) {
warn("get destaddr");
continue;
}
ntp->dest_addr = *(struct sockaddr_in *)&ifreq.ifr_dstaddr;
ntp->net = ntp->dest_addr.sin_addr;
}
ntp->dest_addr.sin_port = port;
for (nt = nets; nt; nt = nt->next) {
if (ntp->net.s_addr == htonl(nt->net))
break;
}
if ((nflag && !nt) || (iflag && nt))
continue;
ntp->next = NULL;
if (nettab == NULL) {
nettab = ntp;
} else {
ntip->next = ntp;
}
ntip = ntp;
ntp = NULL;
}
if (ntp)
(void) free((char *)ntp);
if (nettab == NULL)
errx(1, "no network usable");
/* microseconds to delay before responding to a broadcast */
delay1 = casual(1, 100*1000);
/* election timer delay in secs. */
delay2 = casual(MINTOUT, MAXTOUT);
if (!debug)
daemon(debug, 0);
if (trace)
traceon();
openlog("timed", LOG_CONS|LOG_PID, LOG_DAEMON);
/*
* keep returning here
*/
ret = setjmp(jmpenv);
savefromnet = fromnet;
setstatus();
if (Mflag) {
switch (ret) {
case 0:
checkignorednets();
pickslavenet(0);
break;
case 1:
/* Just lost our master */
if (slavenet != NULL)
slavenet->status = election(slavenet);
if (!slavenet || slavenet->status == MASTER) {
checkignorednets();
pickslavenet(0);
} else {
makeslave(slavenet); /* prune extras */
}
break;
case 2:
/* Just been told to quit */
justquit = 1;
pickslavenet(savefromnet);
break;
}
setstatus();
if (!(status & MASTER) && sock_raw != -1) {
/* sock_raw is not being used now */
(void)close(sock_raw);
sock_raw = -1;
}
if (status == MASTER)
master();
else
slave();
} else {
if (sock_raw != -1) {
(void)close(sock_raw);
sock_raw = -1;
}
if (ret) {
/* we just lost our master or were told to quit */
justquit = 1;
}
for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
if (ntp->status == MASTER) {
rmnetmachs(ntp);
ntp->status = NOMASTER;
}
}
checkignorednets();
pickslavenet(0);
setstatus();
slave();
}
/* NOTREACHED */
return(0);
}
