char *
ether_ntoa (const struct ether_addr *addr)
{
static char asc[18];
return ether_ntoa_r (addr, asc);
}
static void print_neigh_attrs(struct ndmsg *ndm, void *addr, void *lladdr,
char *action, int color)
{
char addr_str[INET6_ADDRSTRLEN], ll_str[INET6_ADDRSTRLEN];
char ifname[IFNAMSIZ], output[2048];
int len;
if_indextoname(ndm->ndm_ifindex, ifname);
if (addr)
inet_ntop(ndm->ndm_family, addr, addr_str, INET6_ADDRSTRLEN);
if (lladdr)
ether_ntoa_r(lladdr, ll_str);
len = sprintf(output, "%s neighbor on %s:", action, ifname);
if (addr)
len += sprintf(output+len, " [%s]", addr_str);
if (lladdr)
len += sprintf(output+len," [%s]", ll_str);
eprintf(color, "%s\n", output);
}
char *
ether_ntoa(const struct ether_addr *n)
{
static char a[18];
return (ether_ntoa_r(n, a));
}
void br_dump_bridge_id(const struct ifla_bridge_id *id, char *buf, size_t len)
{
char eaddr[32];
ether_ntoa_r((const struct ether_addr *)id->addr, eaddr);
snprintf(buf, len, "%.2x%.2x.%s", id->prio[0], id->prio[1], eaddr);
}
static int handle_link_attrs(struct ifinfomsg * ifla, struct rtattr *tb[], int type)
{
struct rtattr * rta;
char ifname[IFNAMSIZ];
char * buf;
int mtu;
char brd[18], ll[18];
if (tb[IFLA_BROADCAST]) {
rta = tb[IFLA_BROADCAST];
ether_ntoa_r((struct ether_addr *) RTA_DATA(rta), brd);
}
if (tb[IFLA_IFNAME]) {
rta = tb[IFLA_IFNAME];
strncpy(ifname, (char*) RTA_DATA(rta), rta->rta_len);
}
if (tb[IFLA_ADDRESS]) {
rta = tb[IFLA_ADDRESS];
ether_ntoa_r((struct ether_addr*) RTA_DATA(rta), ll);
}
if (tb[IFLA_MTU]) {
rta = tb[IFLA_MTU];
mtu = *((int*)RTA_DATA(rta));
}
if (tb[IFLA_LINK]) {
tprintf("Unparsed attribute: IFLA_LINK\n");
}
if(tb[IFLA_IFNAME] && tb[IFLA_ADDRESS] && tb[IFLA_MTU]) {
tprintf("%s addr %s mtu %d brd %s \n", ifname, ll, mtu, brd);
}
if (tb[IFLA_WIRELESS]) {
struct rtattr * iwa = tb[IFLA_WIRELESS];
handle_wireless_attr(ifla->ifi_index, RTA_DATA(iwa), RTA_PAYLOAD(iwa));
}
return 0;
}
int
main (int argc, char *argv[])
{
struct ether_addr *valp, val;
int result, r;
char hostname[32], buf[64], *p;
valp = ether_aton ("12:34:56:78:9a:bc");
printf ("ether_aton (\"12:34:56:78:9a:bc\") = %hhx:%hhx:%hhx:%hhx:%hhx:%hhx\n",
valp->ether_addr_octet[0],
valp->ether_addr_octet[1],
valp->ether_addr_octet[2],
valp->ether_addr_octet[3],
valp->ether_addr_octet[4],
valp->ether_addr_octet[5]);
result = (valp->ether_addr_octet[0] != 0x12
|| valp->ether_addr_octet[1] != 0x34
|| valp->ether_addr_octet[2] != 0x56
|| valp->ether_addr_octet[3] != 0x78
|| valp->ether_addr_octet[4] != 0x9a
|| valp->ether_addr_octet[5] != 0xbc);
if ((r = ether_line ("0:c0:f0:46:5f:97 host.ether.com \t# comment",
&val, hostname)) == 0)
{
ether_ntoa_r (&val, buf);
p = strchr (buf, '\0');
*p++ = ' ';
strcpy (p, hostname);
printf ("ether_line (\"0:c0:f0:46:5f:97 host.ether.com\") = \"%s\"\n",
buf);
result |= strcmp ("0:c0:f0:46:5f:97 host.ether.com", buf) != 0;
}
else
{
printf ("ether_line (\"0:c0:f0:46:5f:97 host.ether.com\") = %d\n", r);
result |= 1;
}
r = ether_line ("0:c0:2:d0 foo.bar ", &val, hostname);
printf ("ether_line (\"0:c0:2:d0 foo.bar \") = %d\n", r);
result |= r != -1;
r = ether_line ("0:c0:2:d0:1a:2a ", &val, hostname);
printf ("ether_line (\"0:c0:2:d0:1a:2a \") = %d\n", r);
result |= r != -1;
return result;
}
void arp_print(struct arp_pkt *arp) {
char sha[6*3];
char spa[4*4];
char tha[6*3];
char tpa[4*4];
printf("ARP ");
/*
switch(arp->arp_h.ar_hrd) {
case ARPHRD_ETHER:
case ARPHRD_IEEE802:
case ARPHRD_ARCNET:
case ARPHRD_FRELAY:
case ARPHRD_IEEE11394:
case ARPHRD_INFINIBAND:
default:
}
*/
switch(arp->arp_h.ar_op) {
case ARP_OP_REQUEST:
printf("Request\n");
break;
case ARP_OP_REPLY:
printf("Reply\n");
break;
case ARP_OP_REVREQUEST:
case ARP_OP_REVREPLY:
case ARP_OP_INVREQUEST:
case ARP_OP_INVREPLY:
default:
printf("Unknown Operation\n");
}
ether_ntoa_r(&arp->sha, sha);
inet_ntoa_r(arp->spa, spa, sizeof(spa));
ether_ntoa_r(&arp->tha, tha);
inet_ntoa_r(arp->tpa, tpa, sizeof(tpa));
printf(" Sender: %s (%s)\n", spa, sha);
printf(" Target: %s (%s)\n", tpa, tha);
}
std::string ethernetToText(const char *binaryEthernetAddress) {
ether_addr _binaryEthernetAddress;
char textEthernetAddress[17];
#ifdef __FreeBSD__
memcpy(_binaryEthernetAddress.octet, binaryEthernetAddress, ETHER_ADDR_LEN);
#endif
#ifdef __linux__
memcpy(_binaryEthernetAddress.ether_addr_octet, binaryEthernetAddress,
ETHER_ADDR_LEN);
#endif
ether_ntoa_r(&_binaryEthernetAddress, textEthernetAddress);
return textEthernetAddress;
}
void arp_cache_print(struct arp_cache *arp_cache) {
uint32_t i;
char ip[4*4];
char mac[6*3];
struct in_addr temp;
for (i=0; i < arp_cache->num_entries; i++) {
if (arp_cache->values[i].timestamp.tv_sec == 0)
continue;
temp.s_addr = arp_cache->baseline + htonl(i);
inet_ntoa_r(temp, ip, sizeof(ip));
ether_ntoa_r(&arp_cache->values[i].mac, mac);
printf("arp_cache[%u]: %s->%s\n", i, ip, mac);
}
}
void arp_print_line(struct arp_pkt *arp) {
char sha[6*3];
char spa[4*4];
char tha[6*3];
char tpa[4*4];
printf("ARP_");
switch(arp->arp_h.ar_op) {
case ARP_OP_REQUEST:
printf("REQ");
break;
case ARP_OP_REPLY:
printf("REP");
break;
default:
printf("UNK");
}
ether_ntoa_r(&arp->sha, sha);
inet_ntoa_r(arp->spa, spa, sizeof(spa));
ether_ntoa_r(&arp->tha, tha);
inet_ntoa_r(arp->tpa, tpa, sizeof(tpa));
printf(": %s/%s > %s/%s\n", spa, sha, tpa, tha);
}
static void
test_ether_ntoa_r(void)
{
char buf[256], *cp;
testnum++;
cp = ether_ntoa_r(ðer_ntoa_addr, buf);
if (cp == NULL)
NOTOK("returned NULL");
if (cp != buf)
NOTOK("returned different pointer");
if (strcmp(cp, ether_ntoa_string) != 0)
NOTOK("bad string");
OK();
}
static char *serialize_agent_list()
{
char *table;
struct agent_list_iterator *iter;
struct agent *agent;
int i, n, size;
char ip_str[INET_ADDRSTRLEN];
char mac_str[18];
size = AGENT_TABLE_ROW_STRLEN * list->size;
table = (char *) malloc(size);
if (table == NULL) {
WARNING("can't allocate memory: %m");
return NULL;
}
iter = new_agent_list_iterator(list);
if (iter == NULL) {
WARNING("new_agent_list_iterator() failed");
free(table);
return NULL;
}
i = 0;
while ((agent = next_agent(iter)) != NULL) {
inet_ntop(AF_INET, &agent->ip, ip_str, INET_ADDRSTRLEN);
ether_ntoa_r(&agent->mac, mac_str);
n = snprintf(table + i, size - i,
"%s,%s,%s,%s,%u,%u,%u,%u\n",
agent->hostname,
ip_str,
mac_str,
agent_state_to_string(agent),
(unsigned int) agent->monitored_since,
(unsigned int) agent->total_uptime,
(unsigned int) agent->sleep_time,
(unsigned int) agent->total_downtime);
if (n < 0) {
WARNING("snprintf() failed: %m");
free(table);
delete_agent_list_iterator(iter);
return NULL;
}
i += n;
}
delete_agent_list_iterator(iter);
table[i] = 0;
return table;
}
void
addresslist_dump(struct addresslist *adrlist)
{
struct address_tuple *tuple;
unsigned int n;
char buf1[128], buf2[128];
char ebuf1[sizeof("00:00:00:00:00:00")], ebuf2[sizeof("00:00:00:00:00:00")];
char *bracket_l, *bracket_r;
printf("<addresslist p=%p sorted=%d ntuple=%u curtuple=%u>\n",
adrlist, adrlist->sorted,
adrlist->ntuple, adrlist->curtuple);
tuple = adrlist->tuple;
if (tuple != NULL) {
printf(" <tuple>\n");
for (n = 0; n < adrlist->ntuple; n++) {
switch (tuple[n].saddr.af) {
case AF_INET:
inet_ntop(AF_INET, &tuple[n].saddr.a.addr4, buf1, sizeof(buf1));
break;
case AF_INET6:
inet_ntop(AF_INET6, &tuple[n].saddr.a.addr6, buf1, sizeof(buf1));
break;
default:
sprintf(buf1, "??? (family=%d)", tuple[n].saddr.af);
break;
}
switch (tuple[n].daddr.af) {
case AF_INET:
inet_ntop(AF_INET, &tuple[n].daddr.a.addr4, buf2, sizeof(buf2));
bracket_l = bracket_r = "";
break;
case AF_INET6:
inet_ntop(AF_INET6, &tuple[n].daddr.a.addr6, buf2, sizeof(buf2));
bracket_l = "[";
bracket_r = "]";
break;
default:
sprintf(buf1, "??? (family=%d)", tuple[n].daddr.af);
break;
}
ether_ntoa_r(&tuple[n].seaddr, ebuf1);
ether_ntoa_r(&tuple[n].deaddr, ebuf2);
printf(" %d: %d %s%s%s:%d - %s%s%s:%d (%s - %s)",
n, tuple[n].proto,
bracket_l, buf1, bracket_r,
tuple[n].sport,
bracket_l, buf2, bracket_r,
tuple[n].dport,
ebuf1, ebuf2);
if (adrlist->sorted) {
printf(" => id=%d",
addresslist_tuple2id(adrlist, &tuple[n]));
}
printf("\n");
}
printf(" </tuple>\n");
}
printf("</addresslist>\n");
}
int
main(void)
{
kvm_t *kd;
char errbuf[_POSIX2_LINE_MAX];
u_long ifnetaddr, ifnetaddr_next;
u_long ifaddraddr, ifaddraddr_next;
struct ifnet ifnet;
struct ifnethead ifnethead;
union {
struct ifaddr ifa;
struct in_ifaddr in;
struct in6_ifaddr in6;
} ifaddr;
union {
struct sockaddr *sa;
struct sockaddr_dl *sal;
struct sockaddr_in *sa4;
struct sockaddr_in6 *sa6;
} sa;
char addr[INET6_ADDRSTRLEN];
kd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, errbuf);
if (kd == NULL) {
warnx("kvm_openfiles: %s", errbuf);
exit(0);
}
if (kvm_nlist(kd, nl) < 0) {
warnx("kvm_nlist: %s", kvm_geterr(kd));
goto out;
}
if (nl[N_IFNET].n_type == 0) {
warnx("kvm_nlist: no namelist");
goto out;
}
if (kread(kd, nl[N_IFNET].n_value,
(char *) &ifnethead, sizeof(ifnethead)) != 0)
goto out;
for (ifnetaddr = (u_long) TAILQ_FIRST(&ifnethead);
ifnetaddr != 0;
ifnetaddr = ifnetaddr_next) {
if (kread(kd, ifnetaddr, (char *) &ifnet, sizeof(ifnet)) != 0)
goto out;
ifnetaddr_next = (u_long) TAILQ_NEXT(&ifnet, if_link);
printf("%s\n", ifnet.if_xname);
for (ifaddraddr = (u_long) TAILQ_FIRST(&ifnet.if_addrhead);
ifaddraddr != 0;
ifaddraddr = ifaddraddr_next) {
if (kread(kd, ifaddraddr,
(char *) &ifaddr, sizeof(ifaddr)) != 0)
goto out;
ifaddraddr_next = (u_long)
TAILQ_NEXT(&ifaddr.ifa, ifa_link);
sa.sa = (struct sockaddr *)(
(unsigned char *) ifaddr.ifa.ifa_addr -
(unsigned char *) ifaddraddr +
(unsigned char *) &ifaddr);
switch (sa.sa->sa_family) {
case AF_LINK:
switch (sa.sal->sdl_type) {
case IFT_ETHER:
case IFT_FDDI:
ether_ntoa_r((struct ether_addr * )
LLADDR(sa.sal), addr);
break;
case IFT_LOOP:
strcpy(addr, "loopback");
break;
default:
snprintf(addr, sizeof(addr),
"<Link type %#x>",
sa.sal->sdl_type);
break;
}
break;
case AF_INET:
inet_ntop(AF_INET, &sa.sa4->sin_addr,
addr, sizeof(addr));
break;
case AF_INET6:
inet_ntop(AF_INET6, &sa.sa6->sin6_addr,
addr, sizeof(addr));
break;
default:
snprintf(addr, sizeof(addr), "family=%d",
sa.sa->sa_family);
break;
}
printf("\t%s ifa_refcnt=%u\n",
addr, ifaddr.ifa.ifa_refcnt);
}
}
out:
kvm_close(kd);
return (0);
}
static int get_iface_mac(const nozzle_t nozzle, char **ether_addr)
{
int err = 0, savederrno = 0;
struct ifreq ifr;
char mac[MACADDR_CHAR_MAX];
#ifdef KNET_BSD
struct ifaddrs *ifap = NULL;
struct ifaddrs *ifa;
int found = 0;
#endif
memset(&mac, 0, MACADDR_CHAR_MAX);
memset(&ifr, 0, sizeof(struct ifreq));
strncpy(ifname, nozzle->name, IFNAMSIZ);
#ifdef KNET_LINUX
err = ioctl(lib_cfg.ioctlfd, SIOCGIFHWADDR, &ifr);
if (err) {
savederrno = errno;
goto out_clean;
}
ether_ntoa_r((struct ether_addr *)ifr.ifr_hwaddr.sa_data, mac);
#endif
#ifdef KNET_BSD
/*
* there is no ioctl to get the ether address of an interface on FreeBSD
* (not to be confused with hwaddr). Use workaround described here:
* https://lists.freebsd.org/pipermail/freebsd-hackers/2004-June/007394.html
*/
err = getifaddrs(&ifap);
if (err < 0) {
savederrno = errno;
goto out_clean;
}
ifa = ifap;
while (ifa) {
if (!strncmp(nozzle->name, ifa->ifa_name, IFNAMSIZ)) {
found = 1;
break;
}
ifa=ifa->ifa_next;
}
if (found) {
ether_ntoa_r((struct ether_addr *)LLADDR((struct sockaddr_dl *)ifa->ifa_addr), mac);
} else {
errno = EINVAL;
err = -1;
}
freeifaddrs(ifap);
if (err) {
goto out_clean;
}
#endif
*ether_addr = strdup(mac);
if (!*ether_addr) {
savederrno = errno;
err = -1;
}
out_clean:
errno = savederrno;
return err;
}
std::string to_string() const
{
char ret[18] = {0};
ether_ntoa_r(&addr_, ret);
return std::string(ret);
}
virtual const char* stringify(const struct ether_addr* addr)
{
return ether_ntoa_r(addr, storage());
}
/*
* Convert Ethernet address to standard hex-digits-and-colons printable form.
*/
char *
ether_ntoa (const struct ether_addr *addr)
{
static char buf[18];
return ether_ntoa_r(addr, buf);
}
char* ether_ntoa(const struct ether_addr* p_a) {
static char x[18];
return ether_ntoa_r(p_a, x);
}
