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); }