fixed some build file flaws
This commit is contained in:
849
lib/gem-nwif2.c
Normal file
849
lib/gem-nwif2.c
Normal file
@ -0,0 +1,849 @@
|
||||
/*
|
||||
Copyright (c) 2006-2020 Chung, Hyung-Hwan. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
|
||||
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#if 1
|
||||
#include "hawk-prv.h"
|
||||
#include "skad-prv.h"
|
||||
#include <hawk-sio.h>
|
||||
|
||||
|
||||
#if defined(_WIN32)
|
||||
# include <winsock2.h>
|
||||
# include <ws2tcpip.h>
|
||||
/*# include <iphlpapi.h> */
|
||||
#elif defined(__OS2__)
|
||||
# if defined(TCPV40HDRS)
|
||||
# define BSD_SELECT
|
||||
# endif
|
||||
# include <types.h>
|
||||
# include <sys/socket.h>
|
||||
# include <netinet/in.h>
|
||||
# include <sys/ioctl.h>
|
||||
# include <nerrno.h>
|
||||
# if defined(TCPV40HDRS)
|
||||
# define USE_SELECT
|
||||
# include <sys/select.h>
|
||||
# else
|
||||
# include <unistd.h>
|
||||
# endif
|
||||
#elif defined(__DOS__)
|
||||
/* TODO: */
|
||||
#else
|
||||
# include "syscall.h"
|
||||
# include <sys/socket.h>
|
||||
# include <netinet/in.h>
|
||||
# if defined(HAVE_SYS_IOCTL_H)
|
||||
# include <sys/ioctl.h>
|
||||
# endif
|
||||
# if defined(HAVE_NET_IF_H)
|
||||
# include <net/if.h>
|
||||
# endif
|
||||
# if defined(HAVE_NET_IF_DL_H)
|
||||
# include <net/if_dl.h>
|
||||
# endif
|
||||
# if defined(HAVE_NET_ROUTE_H)
|
||||
# include <net/route.h>
|
||||
# endif
|
||||
# if defined(HAVE_SYS_SOCKIO_H)
|
||||
# include <sys/sockio.h>
|
||||
# endif
|
||||
# if defined(HAVE_IFADDRS_H)
|
||||
# include <ifaddrs.h>
|
||||
# endif
|
||||
# if defined(HAVE_SYS_SYSCTL_H)
|
||||
# include <sys/sysctl.h>
|
||||
# endif
|
||||
# if defined(HAVE_SYS_STROPTS_H)
|
||||
# include <sys/stropts.h> /* stream options */
|
||||
# endif
|
||||
# if defined(HAVE_SYS_MACSTAT_H)
|
||||
# include <sys/macstat.h>
|
||||
# endif
|
||||
# if defined(HAVE_LINUX_ETHTOOL_H)
|
||||
# include <linux/ethtool.h>
|
||||
# endif
|
||||
# if defined(HAVE_LINUX_SOCKIOS_H)
|
||||
# include <linux/sockios.h>
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(AF_INET6)
|
||||
static int prefix_to_in6 (int prefix, struct in6_addr* in6)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (prefix < 0 || prefix > HAWK_SIZEOF(*in6) * 8) return -1;
|
||||
|
||||
HAWK_MEMSET (in6, 0, HAWK_SIZEOF(*in6));
|
||||
for (i = 0; ; i++)
|
||||
{
|
||||
if (prefix > 8)
|
||||
{
|
||||
in6->s6_addr[i] = 0xFF;
|
||||
prefix -= 8;
|
||||
}
|
||||
else
|
||||
{
|
||||
in6->s6_addr[i] = 0xFF << (8 - prefix);
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static HAWK_INLINE void copy_to_skad (struct sockaddr* sa, hawk_skad_t* skad)
|
||||
{
|
||||
HAWK_MEMCPY (skad, sa, HAWK_SIZEOF(*skad));
|
||||
}
|
||||
/*
|
||||
|
||||
#if defined(HAVE_NET_IF_DL_H)
|
||||
# include <net/if_dl.h>
|
||||
#endif
|
||||
#ifndef SIOCGLIFHWADDR
|
||||
#define SIOCGLIFHWADDR _IOWR('i', 192, struct lifreq)
|
||||
#endif
|
||||
|
||||
struct lifreq lif;
|
||||
|
||||
memset(&lif, 0, sizeof(lif));
|
||||
strlcpy(lif.lifr_name, ifname, sizeof(lif.lifr_name));
|
||||
|
||||
if (ioctl(sock, SIOCGLIFHWADDR, &lif) != -1) {
|
||||
struct sockaddr_dl *sp;
|
||||
sp = (struct sockaddr_dl *)&lif.lifr_addr;
|
||||
memcpy(buf, &sp->sdl_data[0], sp->sdl_alen);
|
||||
return sp->sdl_alen;
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
#if 0
|
||||
#if defined(SIOCGLIFCONF) && defined(SIOCGLIFNUM) && \
|
||||
defined(HAVE_STRUCT_LIFCONF) && defined(HAVE_STRUCT_LIFREQ)
|
||||
static int get_nwifs (hawk_gem_t* gem, int s, int f, hawk_xptl_t* nwifs)
|
||||
{
|
||||
struct lifnum ifn;
|
||||
struct lifconf ifc;
|
||||
hawk_xptl_t b;
|
||||
hawk_oow_t ifcount;
|
||||
|
||||
ifcount = 0;
|
||||
|
||||
b.ptr = HAWK_NULL;
|
||||
b.len = 0;
|
||||
|
||||
do
|
||||
{
|
||||
ifn.lifn_family = f;
|
||||
ifn.lifn_flags = 0;
|
||||
if (ioctl(s, SIOCGLIFNUM, &ifn) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
goto oops;
|
||||
}
|
||||
|
||||
if (b.ptr)
|
||||
{
|
||||
/* b.ptr won't be HAWK_NULL when retrying */
|
||||
if (ifn.lifn_count <= ifcount) break;
|
||||
}
|
||||
|
||||
/* +1 for extra space to leave empty
|
||||
* if SIOCGLIFCONF returns the same number of
|
||||
* intefaces as SIOCLIFNUM */
|
||||
b.len = (ifn.lifn_count + 1) * HAWK_SIZEOF(struct lifreq);
|
||||
b.ptr = hawk_gem_allocmem(gem, b.len);
|
||||
if (b.ptr == HAWK_NULL)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
goto oops;
|
||||
}
|
||||
|
||||
ifc.lifc_family = f;
|
||||
ifc.lifc_flags = 0;
|
||||
ifc.lifc_len = b.len;
|
||||
ifc.lifc_buf = b.ptr;
|
||||
|
||||
if (ioctl(s, SIOCGLIFCONF, &ifc) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
goto oops;
|
||||
}
|
||||
|
||||
ifcount = ifc.lifc_len / HAWK_SIZEOF(struct lifreq);
|
||||
}
|
||||
while (ifcount > ifn.lifn_count);
|
||||
/* the while condition above is for checking if
|
||||
* the buffer got full. when it's full, there is a chance
|
||||
* that there are more interfaces. */
|
||||
|
||||
nwifs->ptr = b.ptr;
|
||||
nwifs->len = ifcount;
|
||||
return 0;
|
||||
|
||||
oops:
|
||||
if (b.ptr) hawk_gem_freemem (gem, b.ptr);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
static void free_nwifcfg (hawk_gem_t* gem, hawk_ifcfg_node_t* cfg)
|
||||
{
|
||||
hawk_ifcfg_node_t* cur;
|
||||
|
||||
while (cfg)
|
||||
{
|
||||
cur = cfg;
|
||||
cfg = cur->next;
|
||||
if (cur->name) hawk_gem_freemem (gem, cur->name);
|
||||
hawk_gem_freemem (gem, cur);
|
||||
}
|
||||
}
|
||||
|
||||
int hawk_gem_getifcfg (hawk_gem_t* gem, hawk_ifcfg_t* cfg)
|
||||
{
|
||||
#if defined(SIOCGLIFCONF)
|
||||
struct lifreq* ifr, ifrbuf;
|
||||
hawk_oow_t i;
|
||||
int s, f;
|
||||
int s4 = -1;
|
||||
int s6 = -1;
|
||||
hawk_xptl_t nwifs = { HAWK_NULL, 0 };
|
||||
hawk_ifcfg_node_t* head = HAWK_NULL;
|
||||
hawk_ifcfg_node_t* tmp;
|
||||
|
||||
HAWK_ASSERT (cfg->mmgr != HAWK_NULL);
|
||||
|
||||
#if defined(AF_INET) || defined(AF_INET6)
|
||||
#if defined(AF_INET)
|
||||
s4 = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (s4 <= -1) goto sys_oops;
|
||||
#endif
|
||||
|
||||
#if defined(AF_INET6)
|
||||
s6 = socket (AF_INET6, SOCK_DGRAM, 0);
|
||||
if (s6 <= -1) goto oops;
|
||||
#endif
|
||||
#else
|
||||
/* no implementation */
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
goto oops;
|
||||
#endif
|
||||
|
||||
if (get_nwifs(cfg->mmgr, s4, AF_UNSPEC, &nwifs) <= -1) goto oops;
|
||||
|
||||
ifr = nwifs.ptr;
|
||||
for (i = 0; i < nwifs.len; i++, ifr++)
|
||||
{
|
||||
f = ifr->lifr_addr.ss_family;
|
||||
|
||||
if (f == AF_INET) s = s4;
|
||||
else if (f == AF_INET6) s = s6;
|
||||
else continue;
|
||||
|
||||
tmp = hawk_gem_allocmem(gem, HAWK_SIZEOF(*tmp));
|
||||
if (tmp == HAWK_NULL) goto oops;
|
||||
|
||||
HAWK_MEMSET (tmp, 0, HAWK_SIZEOF(*tmp));
|
||||
tmp->next = head;
|
||||
head = tmp;
|
||||
|
||||
#if defined(HAWK_OOCH_IS_BCH)
|
||||
head->name = hawk_gem_dupbcstr(gem, ifr->lifr_name, HAWK_NULL);
|
||||
#else
|
||||
head->name = hawk_gem_dupbtoucstr(gem, ifr->lifr_name, HAWK_NULL, 0);
|
||||
#endif
|
||||
if (head->name == HAWK_NULL) goto oops;
|
||||
|
||||
copy_to_skad ((struct sockaddr*)&ifr->lifr_addr, &head->addr);
|
||||
|
||||
hawk_copy_bcstr (ifrbuf.lifr_name, HAWK_COUNTOF(ifrbuf.lifr_name), ifr->lifr_name);
|
||||
if (ioctl(s, SIOCGLIFFLAGS, &ifrbuf) <= -1) goto sys_oops;
|
||||
if (ifrbuf.lifr_flags & IFF_UP) head->flags |= HAWK_IFCFG_UP;
|
||||
if (ifrbuf.lifr_flags & IFF_BROADCAST)
|
||||
{
|
||||
if (ioctl(s, SIOCGLIFBRDADDR, &ifrbuf) <= -1) goto sys_oops;
|
||||
copy_to_skad ((struct sockaddr*)&ifrbuf.lifr_addr, &head->bcast);
|
||||
head->flags |= HAWK_IFCFG_BCAST;
|
||||
}
|
||||
if (ifrbuf.lifr_flags & IFF_POINTOPOINT)
|
||||
{
|
||||
if (ioctl(s, SIOCGLIFDSTADDR, &ifrbuf) <= -1) goto sys_oops;
|
||||
copy_to_skad ((struct sockaddr*)&ifrbuf.lifr_addr, &head->ptop);
|
||||
head->flags |= HAWK_IFCFG_PTOP;
|
||||
}
|
||||
|
||||
if (ioctl(s, SIOCGLIFINDEX, &ifrbuf) <= -1) goto sys_oops;
|
||||
head->index = ifrbuf.lifr_index;
|
||||
|
||||
if (ioctl(s, SIOCGLIFNETMASK, &ifrbuf) <= -1) goto sys_oops;
|
||||
copy_to_skad ((struct sockaddr*)&ifrbuf.lifr_addr, &head->mask);
|
||||
}
|
||||
|
||||
hawk_gem_freemem (gem, nwifs.ptr);
|
||||
close (s6);
|
||||
close (s4);
|
||||
|
||||
cfg->list = head;
|
||||
return 0;
|
||||
|
||||
sys_oops:
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
oops:
|
||||
if (head) free_nwifcfg (cfg->mmgr, head);
|
||||
if (nwifs.ptr) hawk_gem_freemem (gem, nwifs.ptr);
|
||||
if (s6 >= 0) close (s6);
|
||||
if (s4 >= 0) close (s4);
|
||||
return -1;
|
||||
#else
|
||||
|
||||
/* TODO */
|
||||
return HAWK_NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
void hawk_freenwifcfg (hawk_ifcfg_t* cfg)
|
||||
{
|
||||
free_nwifcfg (cfg->mmgr, cfg->list);
|
||||
cfg->list = HAWK_NULL;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(__linux)
|
||||
static void read_proc_net_if_inet6 (hawk_gem_t* gem, hawk_ifcfg_t* cfg, struct ifreq* ifr)
|
||||
{
|
||||
/*
|
||||
*
|
||||
* # cat /proc/net/if_inet6
|
||||
* 00000000000000000000000000000001 01 80 10 80 lo
|
||||
* +------------------------------+ ++ ++ ++ ++ ++
|
||||
* | | | | | |
|
||||
* 1 2 3 4 5 6
|
||||
*
|
||||
* 1. IPv6 address displayed in 32 hexadecimal chars without colons as separator
|
||||
* 2. Netlink device number (interface index) in hexadecimal (see “ip addr” , too)
|
||||
* 3. Prefix length in hexadecimal
|
||||
* 4. Scope value (see kernel source “ include/net/ipv6.h” and “net/ipv6/addrconf.c” for more)
|
||||
* 5. Interface flags (see “include/linux/rtnetlink.h” and “net/ipv6/addrconf.c” for more)
|
||||
* 6. Device name
|
||||
*/
|
||||
|
||||
hawk_sio_t* sio;
|
||||
hawk_bch_t line[128];
|
||||
hawk_bch_t* ptr, * ptr2;
|
||||
hawk_ooi_t len;
|
||||
hawk_bcs_t tok[6];
|
||||
int count, index;
|
||||
|
||||
/* TODO */
|
||||
|
||||
sio = hawk_sio_open(gem, 0, HAWK_T("/proc/net/if_inet6"), HAWK_SIO_IGNOREECERR | HAWK_SIO_READ);
|
||||
if (sio)
|
||||
{
|
||||
|
||||
while (1)
|
||||
{
|
||||
len = hawk_sio_getbcstr(sio, line, HAWK_COUNTOF(line));
|
||||
if (len <= 0) break;
|
||||
|
||||
count = 0;
|
||||
ptr = line;
|
||||
|
||||
while (ptr && count < 6)
|
||||
{
|
||||
ptr2 = hawk_tokenize_bchars(ptr, len, " \t", 2, &tok[count], 0);
|
||||
|
||||
len -= ptr2 - ptr;
|
||||
ptr = ptr2;
|
||||
count++;
|
||||
}
|
||||
|
||||
if (count >= 6)
|
||||
{
|
||||
index = hawk_bchars_to_int(tok[1].ptr, tok[1].len, HAWK_OOCHARS_TO_INT_MAKE_OPTION(1, 1, 16), HAWK_NULL, HAWK_NULL);
|
||||
if (index == cfg->index)
|
||||
{
|
||||
int ti;
|
||||
hawk_skad_alt_t* skad;
|
||||
|
||||
skad = (hawk_skad_alt_t*)&cfg->addr;
|
||||
if (hawk_bchars_to_bin(tok[0].ptr, tok[0].len, (hawk_uint8_t*)&skad->in6.sin6_addr, HAWK_SIZEOF(skad->in6.sin6_addr)) <= -1) break;
|
||||
/* tok[3] is the scope type, not the actual scope.
|
||||
* i leave this code for reference only.
|
||||
skad->in6.sin6_scope_id = hawk_bchars_to_int(tok[3].ptr, tok[3].len, HAWK_OOCHARS_TO_INT_MAKE_OPTION(1, 1, 16), HAWK_NULL, HAWK_NULL); */
|
||||
skad->in6.sin6_family = HAWK_AF_INET6;
|
||||
|
||||
skad = (hawk_skad_alt_t*)&cfg->mask;
|
||||
ti = hawk_bchars_to_int(tok[2].ptr, tok[0].len, HAWK_OOCHARS_TO_INT_MAKE_OPTION(1, 1, 16), HAWK_NULL, HAWK_NULL);
|
||||
prefix_to_in6 (ti, &skad->in6.sin6_addr);
|
||||
skad->in6.sin6_family = HAWK_AF_INET6;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
done:
|
||||
hawk_sio_close (sio);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static int get_ifcfg (hawk_gem_t* gem, int s, hawk_ifcfg_t* cfg, struct ifreq* ifr)
|
||||
{
|
||||
#if defined(_WIN32)
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
|
||||
#elif defined(__OS2__)
|
||||
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
|
||||
#elif defined(__DOS__)
|
||||
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
|
||||
|
||||
#elif defined(SIOCGLIFADDR) && defined(SIOCGLIFINDEX) && defined(HAVE_STRUCT_LIFCONF) && defined(HAVE_STRUCT_LIFREQ)
|
||||
/* opensolaris */
|
||||
struct lifreq lifrbuf;
|
||||
hawk_oow_t ml, wl;
|
||||
|
||||
HAWK_MEMSET (&lifrbuf, 0, HAWK_SIZEOF(lifrbuf));
|
||||
|
||||
hawk_copy_bcstr (lifrbuf.lifr_name, HAWK_SIZEOF(lifrbuf.lifr_name), ifr->ifr_name);
|
||||
|
||||
if (ioctl(s, SIOCGLIFINDEX, &lifrbuf) <= -1) return -1;
|
||||
cfg->index = lifrbuf.lifr_index;
|
||||
|
||||
if (ioctl(s, SIOCGLIFFLAGS, &lifrbuf) <= -1) return -1;
|
||||
cfg->flags = 0;
|
||||
if (lifrbuf.lifr_flags & IFF_UP) cfg->flags |= HAWK_IFCFG_UP;
|
||||
if (lifrbuf.lifr_flags & IFF_RUNNING) cfg->flags |= HAWK_IFCFG_RUNNING;
|
||||
if (lifrbuf.lifr_flags & IFF_BROADCAST) cfg->flags |= HAWK_IFCFG_BCAST;
|
||||
if (lifrbuf.lifr_flags & IFF_POINTOPOINT) cfg->flags |= HAWK_IFCFG_PTOP;
|
||||
|
||||
if (ioctl (s, SIOCGLIFMTU, &lifrbuf) <= -1) return -1;
|
||||
cfg->mtu = lifrbuf.lifr_mtu;
|
||||
|
||||
hawk_clear_skad (&cfg->addr);
|
||||
hawk_clear_skad (&cfg->mask);
|
||||
hawk_clear_skad (&cfg->bcast);
|
||||
hawk_clear_skad (&cfg->ptop);
|
||||
HAWK_MEMSET (cfg->ethw, 0, HAWK_SIZEOF(cfg->ethw));
|
||||
|
||||
if (ioctl (s, SIOCGLIFADDR, &lifrbuf) >= 0)
|
||||
copy_to_skad ((struct sockaddr*)&lifrbuf.lifr_addr, &cfg->addr);
|
||||
|
||||
if (ioctl (s, SIOCGLIFNETMASK, &lifrbuf) >= 0)
|
||||
copy_to_skad ((struct sockaddr*)&lifrbuf.lifr_addr, &cfg->mask);
|
||||
|
||||
if ((cfg->flags & HAWK_IFCFG_BCAST) &&
|
||||
ioctl (s, SIOCGLIFBRDADDR, &lifrbuf) >= 0)
|
||||
{
|
||||
copy_to_skad ((struct sockaddr*)&lifrbuf.lifr_broadaddr, &cfg->bcast);
|
||||
}
|
||||
if ((cfg->flags & HAWK_IFCFG_PTOP) &&
|
||||
ioctl (s, SIOCGLIFDSTADDR, &lifrbuf) >= 0)
|
||||
{
|
||||
copy_to_skad ((struct sockaddr*)&lifrbuf.lifr_dstaddr, &cfg->ptop);
|
||||
}
|
||||
|
||||
#if defined(SIOCGENADDR)
|
||||
{
|
||||
if (ioctl(s, SIOCGENADDR, ifr) >= 0 &&
|
||||
HAWK_SIZEOF(ifr->ifr_enaddr) >= HAWK_SIZEOF(cfg->ethw))
|
||||
{
|
||||
HAWK_MEMCPY (cfg->ethw, ifr->ifr_enaddr, HAWK_SIZEOF(cfg->ethw));
|
||||
}
|
||||
/* TODO: try DLPI if SIOCGENADDR fails... */
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
|
||||
#elif defined(SIOCGLIFADDR) && defined(HAVE_STRUCT_IF_LADDRREQ) && !defined(SIOCGLIFINDEX)
|
||||
/* freebsd */
|
||||
hawk_oow_t ml, wl;
|
||||
|
||||
#if defined(SIOCGIFINDEX)
|
||||
if (ioctl(s, SIOCGIFINDEX, ifr) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
return -1;
|
||||
}
|
||||
#if defined(HAVE_STRUCT_IFREQ_IFR_IFINDEX)
|
||||
cfg->index = ifr->ifr_ifindex;
|
||||
#else
|
||||
cfg->index = ifr->ifr_index;
|
||||
#endif
|
||||
#else
|
||||
cfg->index = 0;
|
||||
#endif
|
||||
|
||||
if (ioctl(s, SIOCGIFFLAGS, ifr) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
return -1;
|
||||
}
|
||||
cfg->flags = 0;
|
||||
if (ifr->ifr_flags & IFF_UP) cfg->flags |= HAWK_IFCFG_UP;
|
||||
if (ifr->ifr_flags & IFF_RUNNING) cfg->flags |= HAWK_IFCFG_RUNNING;
|
||||
if (ifr->ifr_flags & IFF_BROADCAST) cfg->flags |= HAWK_IFCFG_BCAST;
|
||||
if (ifr->ifr_flags & IFF_POINTOPOINT) cfg->flags |= HAWK_IFCFG_PTOP;
|
||||
|
||||
if (ioctl(s, SIOCGIFMTU, ifr) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
return -1;
|
||||
}
|
||||
#if defined(HAVE_STRUCT_IFREQ_IFR_MTU)
|
||||
cfg->mtu = ifr->ifr_mtu;
|
||||
#else
|
||||
/* well, this is a bit dirty. but since all these are unions,
|
||||
* the name must not really matter. some OSes just omitts defining
|
||||
* the MTU field */
|
||||
cfg->mtu = ifr->ifr_metric;
|
||||
#endif
|
||||
|
||||
hawk_clear_skad (&cfg->addr);
|
||||
hawk_clear_skad (&cfg->mask);
|
||||
hawk_clear_skad (&cfg->bcast);
|
||||
hawk_clear_skad (&cfg->ptop);
|
||||
HAWK_MEMSET (cfg->ethw, 0, HAWK_SIZEOF(cfg->ethw));
|
||||
|
||||
if (cfg->type == HAWK_IFCFG_IN6)
|
||||
{
|
||||
struct if_laddrreq iflrbuf;
|
||||
HAWK_MEMSET (&iflrbuf, 0, HAWK_SIZEOF(iflrbuf));
|
||||
hawk_copy_bcstr (iflrbuf.iflr_name, HAWK_SIZEOF(iflrbuf.iflr_name), ifr->ifr_name);
|
||||
|
||||
if (ioctl(s, SIOCGLIFADDR, &iflrbuf) >= 0)
|
||||
{
|
||||
hawk_skad_alt_t* skad;
|
||||
copy_to_skad ((struct sockaddr*)&iflrbuf.addr, &cfg->addr);
|
||||
|
||||
skad = (hawk_skad_alt_t*)&cfg->mask;
|
||||
skad->in6.sin6_family = HAWK_AF_INET6;
|
||||
prefix_to_in6 (iflrbuf.prefixlen, &skad->in6.sin6_addr);
|
||||
|
||||
if (cfg->flags & HAWK_IFCFG_PTOP)
|
||||
copy_to_skad ((struct sockaddr*)&iflrbuf.dstaddr, &cfg->ptop);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ioctl(s, SIOCGIFADDR, ifr) >= 0)
|
||||
copy_to_skad ((struct sockaddr*)&ifr->ifr_addr, &cfg->addr);
|
||||
|
||||
if (ioctl(s, SIOCGIFNETMASK, ifr) >= 0)
|
||||
copy_to_skad ((struct sockaddr*)&ifr->ifr_addr, &cfg->mask);
|
||||
|
||||
if ((cfg->flags & HAWK_IFCFG_BCAST) && ioctl(s, SIOCGIFBRDADDR, ifr) >= 0)
|
||||
{
|
||||
copy_to_skad ((struct sockaddr*)&ifr->ifr_broadaddr, &cfg->bcast);
|
||||
}
|
||||
|
||||
if ((cfg->flags & HAWK_IFCFG_PTOP) && ioctl(s, SIOCGIFDSTADDR, ifr) >= 0)
|
||||
{
|
||||
copy_to_skad ((struct sockaddr*)&ifr->ifr_dstaddr, &cfg->ptop);
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(CTL_NET) && defined(AF_ROUTE) && defined(AF_LINK)
|
||||
{
|
||||
int mib[6];
|
||||
size_t len;
|
||||
|
||||
mib[0] = CTL_NET;
|
||||
mib[1] = AF_ROUTE;
|
||||
mib[2] = 0;
|
||||
mib[3] = AF_LINK;
|
||||
mib[4] = NET_RT_IFLIST;
|
||||
mib[5] = cfg->index;
|
||||
if (sysctl(mib, HAWK_COUNTOF(mib), HAWK_NULL, &len, HAWK_NULL, 0) >= 0)
|
||||
{
|
||||
hawk_uint8_t* buf;
|
||||
|
||||
buf = hawk_gem_allocmem(gem, len);
|
||||
if (buf)
|
||||
{
|
||||
if (sysctl(mib, HAWK_COUNTOF(mib), buf, &len, HAWK_NULL, 0) >= 0)
|
||||
{
|
||||
hawk_uint8_t* ptr, * end;
|
||||
struct if_msghdr* ifm;
|
||||
struct sockaddr_dl* sadl;
|
||||
|
||||
ptr = buf;
|
||||
end = buf + len;
|
||||
while (ptr < end)
|
||||
{
|
||||
ifm = (struct if_msghdr*)ptr;
|
||||
sadl = (struct sockaddr_dl*)(ifm + 1);
|
||||
|
||||
/* i don't really care if it's really ethernet
|
||||
* so long as the data is long enough */
|
||||
if (sadl->sdl_alen >= HAWK_COUNTOF(cfg->ethw))
|
||||
{
|
||||
HAWK_MEMCPY (cfg->ethw, LLADDR(sadl), HAWK_SIZEOF(cfg->ethw));
|
||||
break;
|
||||
}
|
||||
|
||||
ptr += ifm->ifm_msglen;
|
||||
}
|
||||
}
|
||||
|
||||
hawk_gem_freemem (gem, buf);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
|
||||
#elif defined(SIOCGIFADDR)
|
||||
|
||||
#if defined(SIOCGIFINDEX)
|
||||
if (ioctl(s, SIOCGIFINDEX, ifr) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
#if defined(HAVE_STRUCT_IFREQ_IFR_IFINDEX)
|
||||
cfg->index = ifr->ifr_ifindex;
|
||||
#else
|
||||
cfg->index = ifr->ifr_index;
|
||||
#endif
|
||||
|
||||
#else
|
||||
cfg->index = 0;
|
||||
#endif
|
||||
|
||||
if (ioctl (s, SIOCGIFFLAGS, ifr) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
return -1;
|
||||
}
|
||||
cfg->flags = 0;
|
||||
if (ifr->ifr_flags & IFF_UP) cfg->flags |= HAWK_IFCFG_UP;
|
||||
if (ifr->ifr_flags & IFF_RUNNING) cfg->flags |= HAWK_IFCFG_RUNNING;
|
||||
if (ifr->ifr_flags & IFF_BROADCAST) cfg->flags |= HAWK_IFCFG_BCAST;
|
||||
if (ifr->ifr_flags & IFF_POINTOPOINT) cfg->flags |= HAWK_IFCFG_PTOP;
|
||||
|
||||
if (ioctl(s, SIOCGIFMTU, ifr) <= -1)
|
||||
{
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, hawk_syserr_to_errnum(errno));
|
||||
return -1;
|
||||
}
|
||||
#if defined(HAVE_STRUCT_IFREQ_IFR_MTU)
|
||||
cfg->mtu = ifr->ifr_mtu;
|
||||
#else
|
||||
/* well, this is a bit dirty. but since all these are unions,
|
||||
* the name must not really matter. SCO just omits defining
|
||||
* the MTU field, and uses ifr_metric instead */
|
||||
cfg->mtu = ifr->ifr_metric;
|
||||
#endif
|
||||
|
||||
hawk_clear_skad (&cfg->addr);
|
||||
hawk_clear_skad (&cfg->mask);
|
||||
hawk_clear_skad (&cfg->bcast);
|
||||
hawk_clear_skad (&cfg->ptop);
|
||||
HAWK_MEMSET (cfg->ethw, 0, HAWK_SIZEOF(cfg->ethw));
|
||||
|
||||
if (ioctl(s, SIOCGIFADDR, ifr) >= 0) copy_to_skad ((struct sockaddr*)&ifr->ifr_addr, &cfg->addr);
|
||||
if (ioctl(s, SIOCGIFNETMASK, ifr) >= 0) copy_to_skad ((struct sockaddr*)&ifr->ifr_addr, &cfg->mask);
|
||||
|
||||
#if defined(__linux)
|
||||
if (hawk_skad_get_family(&cfg->addr) == HAWK_AF_UNSPEC && hawk_skad_get_family(&cfg->mask) == HAWK_AF_UNSPEC && cfg->type == HAWK_IFCFG_IN6)
|
||||
{
|
||||
/* access /proc/net/if_inet6 */
|
||||
read_proc_net_if_inet6 (gem, cfg, ifr);
|
||||
}
|
||||
#endif
|
||||
|
||||
if ((cfg->flags & HAWK_IFCFG_BCAST) && ioctl(s, SIOCGIFBRDADDR, ifr) >= 0)
|
||||
{
|
||||
copy_to_skad ((struct sockaddr*)&ifr->ifr_broadaddr, &cfg->bcast);
|
||||
}
|
||||
|
||||
if ((cfg->flags & HAWK_IFCFG_PTOP) && ioctl(s, SIOCGIFDSTADDR, ifr) >= 0)
|
||||
{
|
||||
copy_to_skad ((struct sockaddr*)&ifr->ifr_dstaddr, &cfg->ptop);
|
||||
}
|
||||
|
||||
#if defined(SIOCGIFHWADDR)
|
||||
if (ioctl(s, SIOCGIFHWADDR, ifr) >= 0)
|
||||
if (ioctl(s, SIOCGIFHWADDR, ifr) >= 0)
|
||||
{
|
||||
HAWK_MEMCPY (cfg->ethw, ifr->ifr_hwaddr.sa_data, HAWK_SIZEOF(cfg->ethw));
|
||||
}
|
||||
#elif defined(MACIOC_GETADDR)
|
||||
{
|
||||
/* sco openserver
|
||||
* use the streams interface to get the hardware address.
|
||||
*/
|
||||
int strfd;
|
||||
hawk_bch_t devname[HAWK_COUNTOF(ifr->ifr_name) + 5 + 1];
|
||||
|
||||
hawk_copy_bcstr_unlimited (devname, HAWK_MT("/dev/"));
|
||||
hawk_copy_bcstr_unlimited (&devname[5], ifr->ifr_name);
|
||||
if ((strfd = HAWK_OPEN(devname, O_RDONLY, 0)) >= 0)
|
||||
{
|
||||
hawk_uint8_t buf[HAWK_SIZEOF(cfg->ethw)];
|
||||
struct strioctl strioc;
|
||||
|
||||
strioc.ic_cmd = MACIOC_GETADDR;
|
||||
strioc.ic_timout = -1;
|
||||
strioc.ic_len = HAWK_SIZEOF (buf);
|
||||
strioc.ic_dp = buf;
|
||||
if (ioctl(strfd, I_STR, (char *) &strioc) >= 0)
|
||||
HAWK_MEMCPY (cfg->ethw, buf, HAWK_SIZEOF(cfg->ethw));
|
||||
|
||||
HAWK_CLOSE (strfd);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
#else
|
||||
|
||||
/* TODO */
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void get_moreinfo (int s, hawk_ifcfg_t* cfg, struct ifreq* ifr)
|
||||
{
|
||||
#if defined(ETHTOOL_GLINK)
|
||||
{
|
||||
/* get link status */
|
||||
struct ethtool_value ev;
|
||||
HAWK_MEMSET (&ev, 0, HAWK_SIZEOF(ev));
|
||||
ev.cmd= ETHTOOL_GLINK;
|
||||
ifr->ifr_data = &ev;
|
||||
if (ioctl(s, SIOCETHTOOL, ifr) >= 0) cfg->flags |= ev.data? HAWK_IFCFG_LINKUP: HAWK_IFCFG_LINKDOWN;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
|
||||
#if defined(ETHTOOL_GSTATS)
|
||||
{
|
||||
/* get link statistics */
|
||||
struct ethtool_drvinfo drvinfo;
|
||||
|
||||
drvinfo.cmd = ETHTOOL_GDRVINFO;
|
||||
ifr->ifr_data = &drvinfo;
|
||||
if (ioctl (s, SIOCETHTOOL, ifr) >= 0)
|
||||
{
|
||||
struct ethtool_stats *stats;
|
||||
hawk_uint8_t buf[1000]; /* TODO: make this dynamic according to drvinfo.n_stats */
|
||||
|
||||
stats = buf;
|
||||
stats->cmd = ETHTOOL_GSTATS;
|
||||
stats->n_stats = drvinfo.n_stats * HAWK_SIZEOF(stats->data[0]);
|
||||
ifr->ifr_data = (caddr_t) stats;
|
||||
if (ioctl (s, SIOCETHTOOL, ifr) >= 0)
|
||||
{
|
||||
for (i = 0; i < drvinfo.n_stats; i++)
|
||||
{
|
||||
hawk_printf (HAWK_T(">>> %llu \n"), stats->data[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
/* TOOD: consider how to handle multiple IPv6 addresses on a single interfce.
|
||||
* consider how to get IPv4 addresses on an aliased interface? so mutliple ipv4 addresses */
|
||||
|
||||
int hawk_gem_getifcfg (hawk_gem_t* gem, hawk_ifcfg_t* cfg)
|
||||
{
|
||||
#if defined(_WIN32)
|
||||
/* TODO */
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
#elif defined(__OS2__)
|
||||
/* TODO */
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
#elif defined(__DOS__)
|
||||
/* TODO */
|
||||
hawk_gem_seterrnum (gem, HAWK_NULL, HAWK_ENOIMPL);
|
||||
return -1;
|
||||
#else
|
||||
int x = -1, s = -1;
|
||||
struct ifreq ifr;
|
||||
hawk_oow_t ml, wl;
|
||||
|
||||
if (cfg->type == HAWK_IFCFG_IN4)
|
||||
{
|
||||
#if defined(AF_INET)
|
||||
s = socket (AF_INET, SOCK_DGRAM, 0);
|
||||
#endif
|
||||
}
|
||||
else if (cfg->type == HAWK_IFCFG_IN6)
|
||||
{
|
||||
#if defined(AF_INET6)
|
||||
s = socket(AF_INET6, SOCK_DGRAM, 0);
|
||||
#endif
|
||||
}
|
||||
if (s <= -1) return -1;
|
||||
|
||||
if (cfg->name[0] == HAWK_T('\0')&& cfg->index >= 1)
|
||||
{
|
||||
/* TODO: support lookup by ifindex */
|
||||
}
|
||||
|
||||
HAWK_MEMSET (&ifr, 0, sizeof(ifr));
|
||||
#if defined(HAWK_OOCH_IS_BCH)
|
||||
hawk_copy_bcstr (ifr.ifr_name, HAWK_SIZEOF(ifr.ifr_name), cfg->name);
|
||||
#else
|
||||
ml = HAWK_COUNTOF(ifr.ifr_name);
|
||||
if (hawk_gem_convutobcstr(gem, cfg->name, &wl, ifr.ifr_name, &ml) <= -1) goto oops;
|
||||
#endif
|
||||
|
||||
x = get_ifcfg(gem, s, cfg, &ifr);
|
||||
|
||||
if (x >= 0) get_moreinfo (s, cfg, &ifr);
|
||||
|
||||
oops:
|
||||
HAWK_CLOSE (s);
|
||||
return x;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user