unsigned int BroadcastSocketService::discoverBroadcastAddress() {
struct ifconf interfaces;
struct ifreq* netInterface;
struct sockaddr_in* myAddr;
int numOfInterfaces, result, i;
string interfaceName;
bool validInterface;
char buffer[1024000];
interfaces.ifc_len = sizeof(buffer);
interfaces.ifc_buf = buffer;
result = ioctl(sd, SIOCGIFCONF, (char *) &interfaces);
netInterface = interfaces.ifc_req;
numOfInterfaces = interfaces.ifc_len/sizeof(struct ifreq);
#ifdef __DARWIN_UNIX03
struct ifaddrs *ifaddr, *ifa;
int family, s;
char host[NI_MAXHOST];
if (getifaddrs(&ifaddr) == -1) {
perror("getifaddrs");
exit(EXIT_FAILURE);
}
/* Walk through linked list, maintaining head pointer so we
can free list later */
for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
family = ifa->ifa_addr->sa_family;
/* Display interface name and family (including symbolic
form of the latter for the common families) */
printf("%s address family: %d%s\n",
ifa->ifa_name, family,
(family == AF_INET) ? " (AF_INET)" :
(family == AF_INET6) ? " (AF_INET6)" : "");
/* For an AF_INET* interface address, display the address */
validInterface = (strcmp("en0", ifa->ifa_name) == 0);
if (validInterface && (family == AF_INET || family == AF_INET6)) {
s = getnameinfo(ifa->ifa_addr,
(family == AF_INET) ? sizeof(struct sockaddr_in) :
sizeof(struct sockaddr_in6),
host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
if (s != 0) {
cout << "BroadcastSocketService::discoverBroadcastAddress";
cout << " getnameinfo() failed: " << gai_strerror(s);
cout << endl;
return 0;
}
broadcast_addr.sin_family = AF_INET;
broadcast_addr.sin_port = htons(port);
broadcast_addr_len = sizeof(broadcast_addr);
broadcast_addr.sin_addr.s_addr = inet_addr(inet_ntoa(
((struct sockaddr_in *)ifa->ifa_broadaddr)->sin_addr));
/*cout << "Broadcast addr = ";
cout << inet_ntoa(
((struct sockaddr_in *)ifa->ifa_broadaddr)->sin_addr);
cout << endl;*/
memset(
broadcast_addr.sin_zero,
'\0',
sizeof(broadcast_addr.sin_zero));
if (result >= 0) {
cout << "BroadcastSocketService::";
cout << "discoverBroadcastAddress interfaceName: '";
cout << ifa->ifa_name;
inet_aton(
host,
&(((struct sockaddr_in *)ifa->ifa_addr)->sin_addr));
freeifaddrs(ifaddr);
return (unsigned int)(((struct sockaddr_in *)
ifa->ifa_addr)->sin_addr.s_addr);
}
}
}
freeifaddrs(ifaddr);
#else //Linux
for (i = 0; i < numOfInterfaces; netInterface++) {
interfaceName = netInterface->ifr_name;
validInterface = ((INTERFACE_NAME_A == interfaceName) ||
(INTERFACE_NAME_B == interfaceName));
if (validInterface && netInterface->ifr_addr.sa_family == AF_INET
&& (netInterface->ifr_flags & IFF_BROADCAST)) {
result = ioctl(sd, SIOCGIFBRDADDR, (char *) netInterface);
if (result >= 0) {
memcpy(
(char *)&broadcast_addr,
(char *)(&(netInterface->ifr_broadaddr)),
sizeof(netInterface->ifr_broadaddr));
broadcast_addr.sin_port = htons(port);
broadcast_addr_len = sizeof(broadcast_addr);
result = ioctl(sd, SIOCGIFADDR, netInterface);
if (result >= 0) {
myAddr = (struct sockaddr_in*)&(netInterface->ifr_addr);
cout << "BroadcastSocketService::";
cout << "discoverBroadcastAddress interfaceName: '";
cout << netInterface->ifr_name;
cout << endl;
return (unsigned int)(myAddr->sin_addr.s_addr);
}
}
}
i++;
}
#endif
cout << "BroadcastSocketService::discoverBroadcastAddress Warning!";
cout << " can't discover broadcast address" << endl;
return 0;
}
AStringVector cNetwork::EnumLocalIPAddresses(void)
{
AStringVector res;
#ifdef _WIN32
// Query the OS for all adapters' addresses:
char buffer[64 KiB]; // A buffer backing the address list
PIP_ADAPTER_ADDRESSES pAddresses = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(&buffer);
ULONG outBufLen = sizeof(buffer);
DWORD dwRetVal = GetAdaptersAddresses(
AF_UNSPEC,
GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME, nullptr,
pAddresses, &outBufLen
);
if (dwRetVal != ERROR_SUCCESS)
{
LOG("GetAdaptersAddresses() failed: %u", dwRetVal);
return res;
}
// Enumerate all active adapters
for (auto pCurrAddresses = pAddresses; pCurrAddresses != nullptr; pCurrAddresses = pCurrAddresses->Next)
{
if (pCurrAddresses->OperStatus != IfOperStatusUp)
{
// Adapter not active, skip it:
continue;
}
// Collect all IP addresses on this adapter:
for (auto pUnicast = pCurrAddresses->FirstUnicastAddress; pUnicast != nullptr; pUnicast = pUnicast->Next)
{
auto Address = PrintAddress(pUnicast->Address);
if (!Address.empty())
{
res.push_back(Address);
}
} // for pUnicast
} // for pCurrAddresses
#else // _WIN32
struct ifaddrs * ifAddrStruct = nullptr;
getifaddrs(&ifAddrStruct);
for (auto ifa = ifAddrStruct; ifa != nullptr; ifa = ifa->ifa_next)
{
if (ifa->ifa_addr == nullptr)
{
continue;
}
auto Address = PrintAddress(ifa);
if (!Address.empty())
{
res.emplace_back(Address);
}
}
if (ifAddrStruct != nullptr)
{
freeifaddrs(ifAddrStruct);
}
#endif // else _WIN32
return res;
}
int
getifaddr(const char * ifname, char * buf, int len,
struct in_addr * addr, struct in_addr * mask)
{
#ifndef USE_GETIFADDRS
/* use ioctl SIOCGIFADDR. Works only for ip v4 */
/* SIOCGIFADDR struct ifreq * */
int s;
struct ifreq ifr;
int ifrlen;
struct sockaddr_in * ifaddr;
ifrlen = sizeof(ifr);
if(!ifname || ifname[0]=='\0')
return -1;
s = socket(PF_INET, SOCK_DGRAM, 0);
if(s < 0)
{
syslog(LOG_ERR, "socket(PF_INET, SOCK_DGRAM): %m");
return -1;
}
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
if(ioctl(s, SIOCGIFFLAGS, &ifr, &ifrlen) < 0)
{
syslog(LOG_DEBUG, "ioctl(s, SIOCGIFFLAGS, ...): %m");
close(s);
return -1;
}
if ((ifr.ifr_flags & IFF_UP) == 0)
{
syslog(LOG_DEBUG, "network interface %s is down", ifname);
close(s);
return -1;
}
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
if(ioctl(s, SIOCGIFADDR, &ifr, &ifrlen) < 0)
{
syslog(LOG_ERR, "ioctl(s, SIOCGIFADDR, ...): %m");
close(s);
return -1;
}
ifaddr = (struct sockaddr_in *)&ifr.ifr_addr;
if(addr) *addr = ifaddr->sin_addr;
if(buf)
{
if(!inet_ntop(AF_INET, &ifaddr->sin_addr, buf, len))
{
syslog(LOG_ERR, "inet_ntop(): %m");
close(s);
return -1;
}
}
if(mask)
{
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
if(ioctl(s, SIOCGIFNETMASK, &ifr, &ifrlen) < 0)
{
syslog(LOG_ERR, "ioctl(s, SIOCGIFNETMASK, ...): %m");
close(s);
return -1;
}
#ifdef ifr_netmask
*mask = ((struct sockaddr_in *)&ifr.ifr_netmask)->sin_addr;
#else
*mask = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
#endif
}
close(s);
#else /* ifndef USE_GETIFADDRS */
/* Works for all address families (both ip v4 and ip v6) */
struct ifaddrs * ifap;
struct ifaddrs * ife;
if(!ifname || ifname[0]=='\0')
return -1;
if(getifaddrs(&ifap)<0)
{
syslog(LOG_ERR, "getifaddrs: %m");
return -1;
}
for(ife = ifap; ife; ife = ife->ifa_next)
{
/* skip other interfaces if one was specified */
if(ifname && (0 != strcmp(ifname, ife->ifa_name)))
continue;
if(ife->ifa_addr == NULL)
continue;
switch(ife->ifa_addr->sa_family)
{
case AF_INET:
if(buf)
{
inet_ntop(ife->ifa_addr->sa_family,
&((struct sockaddr_in *)ife->ifa_addr)->sin_addr,
buf, len);
}
if(addr) *addr = ((struct sockaddr_in *)ife->ifa_addr)->sin_addr;
if(mask) *mask = ((struct sockaddr_in *)ife->ifa_netmask)->sin_addr;
break;
/*
case AF_INET6:
inet_ntop(ife->ifa_addr->sa_family,
&((struct sockaddr_in6 *)ife->ifa_addr)->sin6_addr,
buf, len);
*/
}
}
freeifaddrs(ifap);
#endif
return 0;
}
/*
* Get a list of all interfaces that are up and that we can open.
* Returns -1 on error, 0 otherwise.
* The list, as returned through "alldevsp", may be null if no interfaces
* were up and could be opened.
*
* This is the implementation used on platforms that have "getifaddrs()".
*/
int
pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf)
{
pcap_if_t *devlist = NULL;
struct ifaddrs *ifap, *ifa;
struct sockaddr *addr, *netmask, *broadaddr, *dstaddr;
size_t addr_size, broadaddr_size, dstaddr_size;
int ret = 0;
char *p, *q;
/*
* Get the list of interface addresses.
*
* Note: this won't return information about interfaces
* with no addresses; are there any such interfaces
* that would be capable of receiving packets?
* (Interfaces incapable of receiving packets aren't
* very interesting from libpcap's point of view.)
*
* LAN interfaces will probably have link-layer
* addresses; I don't know whether all implementations
* of "getifaddrs()" now, or in the future, will return
* those.
*/
if (getifaddrs(&ifap) != 0) {
(void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
"getifaddrs: %s", pcap_strerror(errno));
return (-1);
}
for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
/*
* Is this interface up?
*/
if (!(ifa->ifa_flags & IFF_UP)) {
/*
* No, so don't add it to the list.
*/
continue;
}
/*
* "ifa_addr" was apparently null on at least one
* interface on some system.
*
* "ifa_broadaddr" may be non-null even on
* non-broadcast interfaces, and was null on
* at least one OpenBSD 3.4 system on at least
* one interface with IFF_BROADCAST set.
*
* "ifa_dstaddr" was, on at least one FreeBSD 4.1
* system, non-null on a non-point-to-point
* interface.
*
* Therefore, we supply the address and netmask only
* if "ifa_addr" is non-null (if there's no address,
* there's obviously no netmask), and supply the
* broadcast and destination addresses if the appropriate
* flag is set *and* the appropriate "ifa_" entry doesn't
* evaluate to a null pointer.
*/
if (ifa->ifa_addr != NULL) {
addr = ifa->ifa_addr;
addr_size = SA_LEN(addr);
netmask = ifa->ifa_netmask;
} else {
addr = NULL;
addr_size = 0;
netmask = NULL;
}
if (ifa->ifa_flags & IFF_BROADCAST &&
ifa->ifa_broadaddr != NULL) {
broadaddr = ifa->ifa_broadaddr;
broadaddr_size = SA_LEN(broadaddr);
} else {
broadaddr = NULL;
broadaddr_size = 0;
}
if (ifa->ifa_flags & IFF_POINTOPOINT &&
ifa->ifa_dstaddr != NULL) {
dstaddr = ifa->ifa_dstaddr;
dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
} else {
dstaddr = NULL;
dstaddr_size = 0;
}
/*
* If this entry has a colon followed by a number at
* the end, we assume it's a logical interface. Those
* are just the way you assign multiple IP addresses to
* a real interface on Linux, so an entry for a logical
* interface should be treated like the entry for the
* real interface; we do that by stripping off the ":"
* and the number.
*
* XXX - should we do this only on Linux?
*/
p = strchr(ifa->ifa_name, ':');
if (p != NULL) {
/*
* We have a ":"; is it followed by a number?
*/
q = p + 1;
while (isdigit((unsigned char)*q))
q++;
if (*q == '\0') {
/*
* All digits after the ":" until the end.
* Strip off the ":" and everything after
* it.
*/
*p = '\0';
}
}
/*
* Add information for this address to the list.
*/
if (add_addr_to_iflist(&devlist, ifa->ifa_name,
ifa->ifa_flags, addr, addr_size, netmask, addr_size,
broadaddr, broadaddr_size, dstaddr, dstaddr_size,
errbuf) < 0) {
ret = -1;
break;
}
}
freeifaddrs(ifap);
if (ret != -1) {
/*
* We haven't had any errors yet; do any platform-specific
* operations to add devices.
*/
if (pcap_platform_finddevs(&devlist, errbuf) < 0)
ret = -1;
}
if (ret == -1) {
/*
* We had an error; free the list we've been constructing.
*/
if (devlist != NULL) {
pcap_freealldevs(devlist);
devlist = NULL;
}
}
*alldevsp = devlist;
return (ret);
}
gchar *
vino_util_get_local_hostname (const gchar *server_iface)
{
char *retval, buf[INET6_ADDRSTRLEN];
struct ifaddrs *myaddrs, *ifa;
void *sin;
GHashTable *ipv4, *ipv6;
GHashTableIter iter;
gpointer key, value;
retval = NULL;
ipv4 = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
ipv6 = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
getifaddrs (&myaddrs);
for (ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
{
if (ifa->ifa_addr == NULL || ifa->ifa_name == NULL || (ifa->ifa_flags & IFF_UP) == 0)
continue;
switch (ifa->ifa_addr->ADDR_FAMILY_MEMBER)
{
case AF_INET:
sin = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
inet_ntop (AF_INET, sin, buf, INET6_ADDRSTRLEN);
g_hash_table_insert (ipv4,
ifa->ifa_name,
g_strdup (buf));
break;
case AF_INET6:
sin = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
inet_ntop (AF_INET6, sin, buf, INET6_ADDRSTRLEN);
g_hash_table_insert (ipv6,
ifa->ifa_name,
g_strdup (buf));
break;
default: continue;
}
}
if (server_iface && server_iface[0] != '\0')
{
if ((retval = g_strdup (g_hash_table_lookup (ipv4, server_iface))))
goto the_end;
if ((retval = g_strdup (g_hash_table_lookup (ipv6, server_iface))))
goto the_end;
}
g_hash_table_iter_init (&iter, ipv4);
while (g_hash_table_iter_next (&iter, &key, &value))
{
if (strncmp (key, "lo", 2) == 0)
continue;
retval = g_strdup (value);
goto the_end;
}
g_hash_table_iter_init (&iter, ipv6);
while (g_hash_table_iter_next (&iter, &key, &value))
{
if (strncmp (key, "lo", 2) == 0)
continue;
retval = g_strdup (value);
goto the_end;
}
if ((retval = g_strdup (g_hash_table_lookup (ipv4, "lo"))))
goto the_end;
if ((retval = g_strdup (g_hash_table_lookup (ipv6, "lo"))))
goto the_end;
the_end:
freeifaddrs (myaddrs);
g_hash_table_destroy (ipv4);
g_hash_table_destroy (ipv6);
return retval;
}
/*! Returns a chained list of all interfaces.
We follow BSD semantics, and only return one entry per interface,
not per address; since this is mainly used by NetBSD's netresolv, it's
probably what it expects.
*/
int
getifaddrs(struct ifaddrs** _ifaddrs)
{
if (_ifaddrs == NULL) {
errno = B_BAD_VALUE;
return -1;
}
int socket = ::socket(AF_INET, SOCK_DGRAM, 0);
if (socket < 0)
return -1;
FileDescriptorCloser closer(socket);
// Get interface count
ifconf config;
config.ifc_len = sizeof(config.ifc_value);
if (ioctl(socket, SIOCGIFCOUNT, &config, sizeof(struct ifconf)) < 0)
return -1;
size_t count = (size_t)config.ifc_value;
if (count == 0) {
errno = B_BAD_VALUE;
return -1;
}
// Allocate a buffer for ifreqs for all interfaces
char* buffer = (char*)malloc(count * sizeof(struct ifreq));
if (buffer == NULL) {
errno = B_NO_MEMORY;
return -1;
}
MemoryDeleter deleter(buffer);
// Get interfaces configuration
config.ifc_len = count * sizeof(struct ifreq);
config.ifc_buf = buffer;
if (ioctl(socket, SIOCGIFCONF, &config, sizeof(struct ifconf)) < 0)
return -1;
ifreq* interfaces = (ifreq*)buffer;
ifreq* end = (ifreq*)(buffer + config.ifc_len);
struct ifaddrs* previous = NULL;
for (uint32_t i = 0; interfaces < end; i++) {
struct ifaddrs* current = new(std::nothrow) ifaddrs();
if (current == NULL) {
freeifaddrs(previous);
errno = B_NO_MEMORY;
return -1;
}
// Chain this interface with the next one
current->ifa_next = previous;
previous = current;
current->ifa_name = strdup(interfaces[0].ifr_name);
current->ifa_addr = copy_address(interfaces[0].ifr_addr);
current->ifa_netmask = NULL;
current->ifa_dstaddr = NULL;
current->ifa_data = NULL;
ifreq request;
strlcpy(request.ifr_name, interfaces[0].ifr_name, IF_NAMESIZE);
if (ioctl(socket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0)
current->ifa_flags = request.ifr_flags;
if (ioctl(socket, SIOCGIFNETMASK, &request, sizeof(struct ifreq))
== 0) {
current->ifa_netmask = copy_address(request.ifr_mask);
}
if (ioctl(socket, SIOCGIFDSTADDR, &request, sizeof(struct ifreq))
== 0) {
current->ifa_dstaddr = copy_address(request.ifr_dstaddr);
}
// Move on to next interface
interfaces = (ifreq*)((uint8_t*)interfaces
+ _SIZEOF_ADDR_IFREQ(interfaces[0]));
}
*_ifaddrs = previous;
return 0;
}
static int interface_read (void)
{
#if HAVE_GETIFADDRS
struct ifaddrs *if_list;
struct ifaddrs *if_ptr;
/* Darin/Mac OS X and possible other *BSDs */
#if HAVE_STRUCT_IF_DATA
# define IFA_DATA if_data
# define IFA_RX_BYTES ifi_ibytes
# define IFA_TX_BYTES ifi_obytes
# define IFA_RX_PACKT ifi_ipackets
# define IFA_TX_PACKT ifi_opackets
# define IFA_RX_ERROR ifi_ierrors
# define IFA_TX_ERROR ifi_oerrors
/* #endif HAVE_STRUCT_IF_DATA */
#elif HAVE_STRUCT_NET_DEVICE_STATS
# define IFA_DATA net_device_stats
# define IFA_RX_BYTES rx_bytes
# define IFA_TX_BYTES tx_bytes
# define IFA_RX_PACKT rx_packets
# define IFA_TX_PACKT tx_packets
# define IFA_RX_ERROR rx_errors
# define IFA_TX_ERROR tx_errors
#else
# error "No suitable type for `struct ifaddrs->ifa_data' found."
#endif
struct IFA_DATA *if_data;
if (getifaddrs (&if_list) != 0)
return (-1);
for (if_ptr = if_list; if_ptr != NULL; if_ptr = if_ptr->ifa_next)
{
if ((if_data = (struct IFA_DATA *) if_ptr->ifa_data) == NULL)
continue;
if_submit (if_ptr->ifa_name, "if_octets",
if_data->IFA_RX_BYTES,
if_data->IFA_TX_BYTES);
if_submit (if_ptr->ifa_name, "if_packets",
if_data->IFA_RX_PACKT,
if_data->IFA_TX_PACKT);
if_submit (if_ptr->ifa_name, "if_errors",
if_data->IFA_RX_ERROR,
if_data->IFA_TX_ERROR);
}
freeifaddrs (if_list);
/* #endif HAVE_GETIFADDRS */
#elif KERNEL_LINUX
FILE *fh;
char buffer[1024];
unsigned long long incoming, outgoing;
char *device;
char *dummy;
char *fields[16];
int numfields;
if ((fh = fopen ("/proc/net/dev", "r")) == NULL)
{
char errbuf[1024];
WARNING ("interface plugin: fopen: %s",
sstrerror (errno, errbuf, sizeof (errbuf)));
return (-1);
}
while (fgets (buffer, 1024, fh) != NULL)
{
if (!(dummy = strchr(buffer, ':')))
continue;
dummy[0] = '\0';
dummy++;
device = buffer;
while (device[0] == ' ')
device++;
if (device[0] == '\0')
continue;
numfields = strsplit (dummy, fields, 16);
if (numfields < 11)
continue;
incoming = atoll (fields[0]);
outgoing = atoll (fields[8]);
if_submit (device, "if_octets", incoming, outgoing);
incoming = atoll (fields[1]);
outgoing = atoll (fields[9]);
if_submit (device, "if_packets", incoming, outgoing);
incoming = atoll (fields[2]);
outgoing = atoll (fields[10]);
if_submit (device, "if_errors", incoming, outgoing);
}
fclose (fh);
/* #endif KERNEL_LINUX */
#elif HAVE_LIBKSTAT
int i;
unsigned long long rx;
unsigned long long tx;
if (kc == NULL)
return (-1);
for (i = 0; i < numif; i++)
{
if (kstat_read (kc, ksp[i], NULL) == -1)
continue;
rx = get_kstat_value (ksp[i], "rbytes");
tx = get_kstat_value (ksp[i], "obytes");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_octets", rx, tx);
rx = get_kstat_value (ksp[i], "ipackets");
tx = get_kstat_value (ksp[i], "opackets");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_packets", rx, tx);
rx = get_kstat_value (ksp[i], "ierrors");
tx = get_kstat_value (ksp[i], "oerrors");
if ((rx != -1LL) || (tx != -1LL))
if_submit (ksp[i]->ks_name, "if_errors", rx, tx);
}
/* #endif HAVE_LIBKSTAT */
#elif defined(HAVE_LIBSTATGRAB)
sg_network_io_stats *ios;
int i, num;
ios = sg_get_network_io_stats (&num);
for (i = 0; i < num; i++)
if_submit (ios[i].interface_name, "if_octets", ios[i].rx, ios[i].tx);
#endif /* HAVE_LIBSTATGRAB */
return (0);
} /* int interface_read */
std::vector<Interface>
Interface::get(void)
{
std::vector<Interface> itfs;
#if defined(DUNE_SYS_HAS_IFADDRS_H)
struct ifaddrs* ifa;
getifaddrs(&ifa);
struct ifaddrs* next = ifa;
do
{
// No address.
if (next->ifa_addr == 0)
continue;
// Not IPv4.
if (next->ifa_addr->sa_family != AF_INET)
continue;
// Not active.
if ((next->ifa_flags & IFF_UP) != IFF_UP)
continue;
Interface itf;
itf.m_name = next->ifa_name;
itf.m_addr = next->ifa_addr;
itf.m_bcast = next->ifa_broadaddr;
if (next->ifa_flags & IFF_MULTICAST)
itf.m_features |= FeatureMulticast;
if (next->ifa_flags & IFF_BROADCAST)
itf.m_features |= FeatureBroadcast;
itfs.push_back(itf);
}
while ((next = next->ifa_next));
freeifaddrs(ifa);
// Microsoft Windows implementation.
#elif defined(DUNE_SYS_HAS_IPHLPAPI_H)
ULONG adps_len = 16 * 1024;
PIP_ADAPTER_ADDRESSES adps = (PIP_ADAPTER_ADDRESSES) std::malloc(adps_len);
int rv = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, 0, adps, &adps_len);
if (rv != ERROR_SUCCESS)
return itfs;
PIP_ADAPTER_ADDRESSES padp = adps;
while (padp)
{
if (padp->OperStatus == IfOperStatusUp)
{
if (padp->FirstUnicastAddress)
{
Interface itf;
itf.m_name = padp->AdapterName;
itf.m_addr = padp->FirstUnicastAddress->Address.lpSockaddr;
itfs.push_back(itf);
}
}
padp = padp->Next;
}
free(adps);
#endif
return itfs;
}
static Iface_DEFUN sendMessage(struct Message* msg, struct Iface* iface)
{
struct ETHInterface_pvt* ctx =
Identity_containerOf(iface, struct ETHInterface_pvt, pub.generic.iface);
struct Sockaddr* sa = (struct Sockaddr*) msg->bytes;
Assert_true(msg->length >= Sockaddr_OVERHEAD);
Assert_true(sa->addrLen <= ETHInterface_Sockaddr_SIZE);
struct ETHInterface_Sockaddr sockaddr = { .generic = { .addrLen = 0 } };
Message_pop(msg, &sockaddr, sa->addrLen, NULL);
struct sockaddr_ll addr;
Bits_memcpy(&addr, &ctx->addrBase, sizeof(struct sockaddr_ll));
if (sockaddr.generic.flags & Sockaddr_flags_BCAST) {
Bits_memset(addr.sll_addr, 0xff, 6);
} else {
Bits_memcpy(addr.sll_addr, sockaddr.mac, 6);
}
struct ETHInterface_Header hdr = {
.version = ETHInterface_CURRENT_VERSION,
.zero = 0,
.length_be = Endian_hostToBigEndian16(msg->length + ETHInterface_Header_SIZE),
.fc00_be = Endian_hostToBigEndian16(0xfc00)
};
Message_push(msg, &hdr, ETHInterface_Header_SIZE, NULL);
struct Except* eh = NULL;
sendMessageInternal(msg, &addr, ctx, eh);
return NULL;
}
static void handleEvent2(struct ETHInterface_pvt* context, struct Allocator* messageAlloc)
{
struct Message* msg = Message_new(MAX_PACKET_SIZE, PADDING, messageAlloc);
struct sockaddr_ll addr;
uint32_t addrLen = sizeof(struct sockaddr_ll);
// Knock it out of alignment by 2 bytes so that it will be
// aligned when the idAndPadding is shifted off.
Message_shift(msg, 2, NULL);
int rc = recvfrom(context->socket,
msg->bytes,
msg->length,
0,
(struct sockaddr*) &addr,
&addrLen);
if (rc < ETHInterface_Header_SIZE) {
Log_debug(context->logger, "Failed to receive eth frame");
return;
}
Assert_true(msg->length >= rc);
msg->length = rc;
//Assert_true(addrLen == SOCKADDR_LL_LEN);
struct ETHInterface_Header hdr;
Message_pop(msg, &hdr, ETHInterface_Header_SIZE, NULL);
// here we could put a switch statement to handle different versions differently.
if (hdr.version != ETHInterface_CURRENT_VERSION) {
Log_debug(context->logger, "DROP unknown version");
return;
}
uint16_t reportedLength = Endian_bigEndianToHost16(hdr.length_be);
reportedLength -= ETHInterface_Header_SIZE;
if (msg->length != reportedLength) {
if (msg->length < reportedLength) {
Log_debug(context->logger, "DROP size field is larger than frame");
return;
}
msg->length = reportedLength;
}
if (hdr.fc00_be != Endian_hostToBigEndian16(0xfc00)) {
Log_debug(context->logger, "DROP bad magic");
return;
}
struct ETHInterface_Sockaddr sockaddr = { .zero = 0 };
Bits_memcpy(sockaddr.mac, addr.sll_addr, 6);
sockaddr.generic.addrLen = ETHInterface_Sockaddr_SIZE;
if (addr.sll_pkttype == PACKET_BROADCAST) {
sockaddr.generic.flags |= Sockaddr_flags_BCAST;
}
Message_push(msg, &sockaddr, ETHInterface_Sockaddr_SIZE, NULL);
Assert_true(!((uintptr_t)msg->bytes % 4) && "Alignment fault");
Iface_send(&context->pub.generic.iface, msg);
}
static void handleEvent(void* vcontext)
{
struct ETHInterface_pvt* context = Identity_check((struct ETHInterface_pvt*) vcontext);
struct Allocator* messageAlloc = Allocator_child(context->pub.generic.alloc);
handleEvent2(context, messageAlloc);
Allocator_free(messageAlloc);
}
List* ETHInterface_listDevices(struct Allocator* alloc, struct Except* eh)
{
List* out = List_new(alloc);
#ifndef android
struct ifaddrs* ifaddr = NULL;
if (getifaddrs(&ifaddr) || ifaddr == NULL) {
Except_throw(eh, "getifaddrs() -> errno:%d [%s]", errno, strerror(errno));
}
for (struct ifaddrs* ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_PACKET) {
List_addString(out, String_new(ifa->ifa_name, alloc), alloc);
}
}
freeifaddrs(ifaddr);
#endif
return out;
}
static int closeSocket(struct Allocator_OnFreeJob* j)
{
struct ETHInterface_pvt* ctx = Identity_check((struct ETHInterface_pvt*) j->userData);
close(ctx->socket);
return 0;
}
struct ETHInterface* ETHInterface_new(struct EventBase* eventBase,
const char* bindDevice,
struct Allocator* alloc,
struct Except* exHandler,
struct Log* logger)
{
struct ETHInterface_pvt* ctx = Allocator_calloc(alloc, sizeof(struct ETHInterface_pvt), 1);
Identity_set(ctx);
ctx->pub.generic.iface.send = sendMessage;
ctx->pub.generic.alloc = alloc;
ctx->logger = logger;
struct ifreq ifr = { .ifr_ifindex = 0 };
ctx->socket = socket(AF_PACKET, SOCK_DGRAM, Ethernet_TYPE_CJDNS);
if (ctx->socket == -1) {
Except_throw(exHandler, "call to socket() failed. [%s]", strerror(errno));
}
Allocator_onFree(alloc, closeSocket, ctx);
CString_strncpy(ifr.ifr_name, bindDevice, IFNAMSIZ - 1);
ctx->ifName = String_new(bindDevice, alloc);
if (ioctl(ctx->socket, SIOCGIFINDEX, &ifr) == -1) {
Except_throw(exHandler, "failed to find interface index [%s]", strerror(errno));
}
ctx->ifindex = ifr.ifr_ifindex;
if (ioctl(ctx->socket, SIOCGIFFLAGS, &ifr) < 0) {
Except_throw(exHandler, "ioctl(SIOCGIFFLAGS) [%s]", strerror(errno));
}
if (!((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING))) {
Log_info(logger, "Bringing up interface [%s]", ifr.ifr_name);
ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
if (ioctl(ctx->socket, SIOCSIFFLAGS, &ifr) < 0) {
Except_throw(exHandler, "ioctl(SIOCSIFFLAGS) [%s]", strerror(errno));
}
}
ctx->addrBase = (struct sockaddr_ll) {
.sll_family = AF_PACKET,
.sll_protocol = Ethernet_TYPE_CJDNS,
.sll_ifindex = ctx->ifindex,
.sll_hatype = ARPHRD_ETHER,
.sll_pkttype = PACKET_OTHERHOST,
.sll_halen = ETH_ALEN
};
if (bind(ctx->socket, (struct sockaddr*) &ctx->addrBase, sizeof(struct sockaddr_ll))) {
Except_throw(exHandler, "call to bind() failed [%s]", strerror(errno));
}
Socket_makeNonBlocking(ctx->socket);
Event_socketRead(handleEvent, ctx, ctx->socket, eventBase, alloc, exHandler);
return &ctx->pub;
}
ipaddr mill_iplocal_(const char *name, int port, int mode) {
if(!name)
return mill_ipany(port, mode);
ipaddr addr = mill_ipliteral(name, port, mode);
#if defined __sun
return addr;
#else
if(errno == 0)
return addr;
/* Address is not a literal. It must be an interface name then. */
struct ifaddrs *ifaces = NULL;
int rc = getifaddrs (&ifaces);
mill_assert (rc == 0);
mill_assert (ifaces);
/* Find first IPv4 and first IPv6 address. */
struct ifaddrs *ipv4 = NULL;
struct ifaddrs *ipv6 = NULL;
struct ifaddrs *it;
for(it = ifaces; it != NULL; it = it->ifa_next) {
if(!it->ifa_addr)
continue;
if(strcmp(it->ifa_name, name) != 0)
continue;
switch(it->ifa_addr->sa_family) {
case AF_INET:
mill_assert(!ipv4);
ipv4 = it;
break;
case AF_INET6:
mill_assert(!ipv6);
ipv6 = it;
break;
}
if(ipv4 && ipv6)
break;
}
/* Choose the correct address family based on mode. */
switch(mode) {
case IPADDR_IPV4:
ipv6 = NULL;
break;
case IPADDR_IPV6:
ipv4 = NULL;
break;
case 0:
case IPADDR_PREF_IPV4:
if(ipv4)
ipv6 = NULL;
break;
case IPADDR_PREF_IPV6:
if(ipv6)
ipv4 = NULL;
break;
default:
mill_assert(0);
}
if(ipv4) {
struct sockaddr_in *inaddr = (struct sockaddr_in*)&addr;
memcpy(inaddr, ipv4->ifa_addr, sizeof (struct sockaddr_in));
inaddr->sin_port = htons(port);
freeifaddrs(ifaces);
errno = 0;
return addr;
}
if(ipv6) {
struct sockaddr_in6 *inaddr = (struct sockaddr_in6*)&addr;
memcpy(inaddr, ipv6->ifa_addr, sizeof (struct sockaddr_in6));
inaddr->sin6_port = htons(port);
freeifaddrs(ifaces);
errno = 0;
return addr;
}
freeifaddrs(ifaces);
((struct sockaddr*)&addr)->sa_family = AF_UNSPEC;
errno = ENODEV;
return addr;
#endif
}
int getiflist(char **ifacelist)
{
#if defined(__linux__)
char interface[32];
FILE *fp;
DIR *dp;
struct dirent *di;
char procline[512], temp[64];
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__FreeBSD_kernel__)
struct ifaddrs *ifap, *ifa;
#endif
/* initialize list */
*ifacelist = malloc(sizeof(char));
*ifacelist[0] = '\0';
#if defined(__linux__)
if ((fp=fopen(PROCNETDEV, "r"))!=NULL) {
/* make list of interfaces */
while (fgets(procline, 512, fp)!=NULL) {
sscanf(procline, "%64s", temp);
if (isdigit(temp[(strlen(temp)-1)]) || temp[(strlen(temp)-1)]==':') {
sscanf(temp, "%32[^':']s", interface);
*ifacelist = realloc(*ifacelist, ( ( strlen(*ifacelist) + strlen(interface) + 2 ) * sizeof(char)) );
strncat(*ifacelist, interface, strlen(interface));
strcat(*ifacelist, " ");
}
}
fclose(fp);
return 1;
} else {
if ((dp=opendir("/sys/class/net"))!=NULL) {
/* make list of interfaces */
while ((di=readdir(dp))) {
if (di->d_name[0]!='.') {
*ifacelist = realloc(*ifacelist, ( ( strlen(*ifacelist) + strlen(di->d_name) + 2 ) * sizeof(char)) );
strncat(*ifacelist, di->d_name, strlen(di->d_name));
strcat(*ifacelist, " ");
}
}
closedir(dp);
return 1;
}
}
#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__FreeBSD_kernel__)
if (getifaddrs(&ifap) >= 0) {
/* make list of interfaces */
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr->sa_family == AF_LINK) {
*ifacelist = realloc(*ifacelist, ( ( strlen(*ifacelist) + strlen(ifa->ifa_name) + 2 ) * sizeof(char)) );
strncat(*ifacelist, ifa->ifa_name, strlen(ifa->ifa_name));
strcat(*ifacelist, " ");
}
}
freeifaddrs(ifap);
return 1;
}
#endif
return 0;
}
TEST(ifaddrs, freeifaddrs_null) {
freeifaddrs(nullptr);
}
static
DWORD
VmAfSrvGetIPAddresses(
VMDNS_IP4_ADDRESS* pIpV4Addrs,
PDWORD pdwV4Addrs,
VMDNS_IP6_ADDRESS* pIpV6Addrs,
PDWORD pdwV6Addrs
)
{
DWORD dwError = 0;
DWORD dwNumV4Addrs = 0;
DWORD dwNumV6Addrs = 0;
struct sockaddr_in *pIp4Addr = NULL;
struct sockaddr_in6 *pIp6Addr = NULL;
#ifndef _WIN32
struct ifaddrs * addrList = NULL;
struct ifaddrs * ifa = NULL;
#else
PADDRINFOA addrList = NULL;
PADDRINFOA ifa = NULL;
unsigned long loopbackAddr = 0;
struct addrinfo hints = {0};
BYTE loopbackAddr6[16] =
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
#endif
if (!pdwV4Addrs || !pdwV6Addrs)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
#ifndef _WIN32
dwError = getifaddrs(&addrList);
#else
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
loopbackAddr = inet_addr("127.0.0.1");
if (getaddrinfo( "", NULL, &hints, &addrList ) != 0 )
{
dwError = WSAGetLastError();
}
#endif
BAIL_ON_VMAFD_ERROR(dwError);
for (ifa = addrList; ifa != NULL; ifa = VMAFD_ADDR_INFO_NEXT(ifa))
{
if ((VMAFD_ADDR_INFO_ADDR(ifa) == NULL)
#ifndef _WIN32 // because getaddrinfo() does NOT set ai_flags in the returned address info structures.
|| ((VMAFD_ADDR_INFO_FLAGS(ifa) & IFF_UP) == 0)
|| ((VMAFD_ADDR_INFO_FLAGS(ifa) & IFF_LOOPBACK) != 0)
#endif
)
{
continue;
}
if (VMAFD_ADDR_INFO_ADDR(ifa)->sa_family == AF_INET)
{
pIp4Addr = (struct sockaddr_in *) VMAFD_ADDR_INFO_ADDR(ifa);
#ifdef _WIN32
if (memcmp(&pIp4Addr->sin_addr.s_addr,
&loopbackAddr,
sizeof(loopbackAddr)) == 0)
{
continue;
}
#endif
if (IS_IPV4_LINKLOCAL((unsigned char*)&pIp4Addr->sin_addr.s_addr))
{
continue;
}
if (pIpV4Addrs)
{
if (dwNumV4Addrs < *pdwV4Addrs)
{
pIpV4Addrs[dwNumV4Addrs] = ntohl(pIp4Addr->sin_addr.s_addr);
}
else
{
dwError = ERROR_INSUFFICIENT_BUFFER;
BAIL_ON_VMAFD_ERROR(dwError);
}
}
++dwNumV4Addrs;
}
else if (VMAFD_ADDR_INFO_ADDR(ifa)->sa_family == AF_INET6)
{
pIp6Addr = (struct sockaddr_in6 *) VMAFD_ADDR_INFO_ADDR(ifa);
#ifdef _WIN32
if (memcmp(&pIp6Addr->sin6_addr.s6_addr,
&loopbackAddr6,
sizeof(loopbackAddr6)) == 0)
{
continue;
}
#endif
if (IS_IPV6_LINKLOCAL(pIp6Addr->sin6_addr.s6_addr))
{
continue;
}
if (pIpV6Addrs)
{
if (dwNumV6Addrs < *pdwV6Addrs)
{
memcpy(
pIpV6Addrs[dwNumV6Addrs].IP6Byte,
pIp6Addr->sin6_addr.s6_addr,
sizeof(pIp6Addr->sin6_addr.s6_addr));
}
else
{
dwError = ERROR_INSUFFICIENT_BUFFER;
BAIL_ON_VMAFD_ERROR(dwError);
}
}
++dwNumV6Addrs;
}
}
*pdwV4Addrs = dwNumV4Addrs;
*pdwV6Addrs = dwNumV6Addrs;
if (!pIpV4Addrs && !pIpV6Addrs)
{
dwError = ERROR_INSUFFICIENT_BUFFER;
BAIL_ON_VMAFD_ERROR(dwError);
}
cleanup:
if (addrList)
{
#ifndef _WIN32
freeifaddrs(addrList);
#else
freeaddrinfo(addrList);
#endif
}
return dwError;
error:
goto cleanup;
}
LWS_VISIBLE int
lws_interface_to_sa(int ipv6, const char *ifname, struct sockaddr_in *addr,
size_t addrlen)
{
int rc = -1;
struct ifaddrs *ifr;
struct ifaddrs *ifc;
#ifdef LWS_USE_IPV6
struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
#endif
getifaddrs(&ifr);
for (ifc = ifr; ifc != NULL && rc; ifc = ifc->ifa_next) {
if (!ifc->ifa_addr)
continue;
lwsl_info(" interface %s vs %s\n", ifc->ifa_name, ifname);
if (strcmp(ifc->ifa_name, ifname))
continue;
switch (ifc->ifa_addr->sa_family) {
case AF_INET:
#ifdef LWS_USE_IPV6
if (ipv6) {
/* map IPv4 to IPv6 */
bzero((char *)&addr6->sin6_addr,
sizeof(struct in6_addr));
addr6->sin6_addr.s6_addr[10] = 0xff;
addr6->sin6_addr.s6_addr[11] = 0xff;
memcpy(&addr6->sin6_addr.s6_addr[12],
&((struct sockaddr_in *)ifc->ifa_addr)->sin_addr,
sizeof(struct in_addr));
} else
#endif
memcpy(addr,
(struct sockaddr_in *)ifc->ifa_addr,
sizeof(struct sockaddr_in));
break;
#ifdef LWS_USE_IPV6
case AF_INET6:
memcpy(&addr6->sin6_addr,
&((struct sockaddr_in6 *)ifc->ifa_addr)->sin6_addr,
sizeof(struct in6_addr));
break;
#endif
default:
continue;
}
rc = 0;
}
freeifaddrs(ifr);
if (rc == -1) {
/* check if bind to IP adddress */
#ifdef LWS_USE_IPV6
if (inet_pton(AF_INET6, ifname, &addr6->sin6_addr) == 1)
rc = 0;
else
#endif
if (inet_pton(AF_INET, ifname, &addr->sin_addr) == 1)
rc = 0;
}
return rc;
}
int getifaddrs(struct ifaddrs **ifap)
{
struct ifconf ifc;
char buff[8192];
int fd, i, n;
struct ifreq *ifr=nullptr;
struct ifaddrs *curif;
struct ifaddrs *lastif = nullptr;
*ifap = nullptr;
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
return -1;
}
ifc.ifc_len = sizeof(buff);
ifc.ifc_buf = buff;
if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
close(fd);
return -1;
}
ifr = ifc.ifc_req;
n = ifc.ifc_len / sizeof(struct ifreq);
/* Loop through interfaces, looking for given IP address */
for (i=n-1; i>=0; i--) {
if (ioctl(fd, SIOCGIFFLAGS, &ifr[i]) == -1) {
freeifaddrs(*ifap);
close(fd);
return -1;
}
curif = (struct ifaddrs *)calloc(1, sizeof(struct ifaddrs));
if (curif == nullptr) {
freeifaddrs(*ifap);
close(fd);
return -1;
}
curif->ifa_name = strdup(ifr[i].ifr_name);
if (curif->ifa_name == nullptr) {
free(curif);
freeifaddrs(*ifap);
close(fd);
return -1;
}
curif->ifa_flags = ifr[i].ifr_flags;
curif->ifa_dstaddr = nullptr;
curif->ifa_data = nullptr;
curif->ifa_next = nullptr;
curif->ifa_addr = nullptr;
if (ioctl(fd, SIOCGIFADDR, &ifr[i]) != -1) {
curif->ifa_addr = sockaddr_dup(&ifr[i].ifr_addr);
if (curif->ifa_addr == nullptr) {
free(curif->ifa_name);
free(curif);
freeifaddrs(*ifap);
close(fd);
return -1;
}
}
curif->ifa_netmask = nullptr;
if (ioctl(fd, SIOCGIFNETMASK, &ifr[i]) != -1) {
curif->ifa_netmask = sockaddr_dup(&ifr[i].ifr_addr);
if (curif->ifa_netmask == nullptr) {
if (curif->ifa_addr != nullptr) {
free(curif->ifa_addr);
}
free(curif->ifa_name);
free(curif);
freeifaddrs(*ifap);
close(fd);
return -1;
}
}
if (lastif == nullptr) {
*ifap = curif;
} else {
lastif->ifa_next = curif;
}
lastif = curif;
}
close(fd);
return 0;
}
int uv_interface_addresses(uv_interface_address_t** addresses, int* count) {
struct ifaddrs *addrs, *ent;
uv_interface_address_t* address;
int i;
struct sockaddr_dl *sa_addr;
if (getifaddrs(&addrs))
return -errno;
*count = 0;
/* Count the number of interfaces */
for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)) ||
(ent->ifa_addr == NULL) ||
(ent->ifa_addr->sa_family == AF_LINK)) {
continue;
}
(*count)++;
}
*addresses = uv__malloc(*count * sizeof(**addresses));
if (!(*addresses)) {
freeifaddrs(addrs);
return -ENOMEM;
}
address = *addresses;
for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)))
continue;
if (ent->ifa_addr == NULL)
continue;
/*
* On Mac OS X getifaddrs returns information related to Mac Addresses for
* various devices, such as firewire, etc. These are not relevant here.
*/
if (ent->ifa_addr->sa_family == AF_LINK)
continue;
address->name = uv__strdup(ent->ifa_name);
if (ent->ifa_addr->sa_family == AF_INET6) {
address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr);
} else {
address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr);
}
if (ent->ifa_netmask->sa_family == AF_INET6) {
address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask);
} else {
address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask);
}
address->is_internal = !!(ent->ifa_flags & IFF_LOOPBACK);
address++;
}
/* Fill in physical addresses for each interface */
for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)) ||
(ent->ifa_addr == NULL) ||
(ent->ifa_addr->sa_family != AF_LINK)) {
continue;
}
address = *addresses;
for (i = 0; i < (*count); i++) {
if (strcmp(address->name, ent->ifa_name) == 0) {
sa_addr = (struct sockaddr_dl*)(ent->ifa_addr);
memcpy(address->phys_addr, LLADDR(sa_addr), sizeof(address->phys_addr));
}
address++;
}
}
freeifaddrs(addrs);
return 0;
}
CAMLprim value
freeifaddrs_stub(value ifap)
{
freeifaddrs((struct ifaddrs *)ifap);
return Val_unit;
}
/*
* Query the kernel to find network interfaces that are multicast-capable
* and install them in the uvifs array.
*/
void
config_vifs_from_kernel(void)
{
struct ifaddrs *ifa, *ifap;
struct uvif *v;
vifi_t vifi;
u_int32_t addr, mask, subnet;
short flags;
if (getifaddrs(&ifap) < 0)
logit(LOG_ERR, errno, "getifaddrs");
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
/*
* Ignore any interface for an address family other than IP.
*/
if (ifa->ifa_addr->sa_family != AF_INET)
continue;
addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr;
/*
* Ignore loopback interfaces and interfaces that do not support
* multicast.
*/
flags = ifa->ifa_flags;
if ((flags & (IFF_LOOPBACK|IFF_MULTICAST)) != IFF_MULTICAST)
continue;
/*
* Ignore any interface whose address and mask do not define a
* valid subnet number, or whose address is of the form {subnet,0}
* or {subnet,-1}.
*/
mask = ((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr.s_addr;
subnet = addr & mask;
if (!inet_valid_subnet(subnet, mask) ||
addr == subnet ||
addr == (subnet | ~mask)) {
logit(LOG_WARNING, 0,
"ignoring %s, has invalid address (%s) and/or mask (%s)",
ifa->ifa_name, inet_fmt(addr),
inet_fmt(mask));
continue;
}
/*
* Ignore any interface that is connected to the same subnet as
* one already installed in the uvifs array.
*/
for (vifi = 0, v = uvifs; vifi < numvifs; ++vifi, ++v) {
if ((addr & v->uv_subnetmask) == v->uv_subnet ||
(v->uv_subnet & mask) == subnet) {
logit(LOG_WARNING, 0, "ignoring %s, same subnet as %s",
ifa->ifa_name, v->uv_name);
break;
}
}
if (vifi != numvifs)
continue;
/*
* If there is room in the uvifs array, install this interface.
*/
if (numvifs == MAXVIFS) {
logit(LOG_WARNING, 0, "too many vifs, ignoring %s", ifa->ifa_name);
continue;
}
v = &uvifs[numvifs];
v->uv_flags = 0;
v->uv_metric = DEFAULT_METRIC;
v->uv_rate_limit = DEFAULT_PHY_RATE_LIMIT;
v->uv_threshold = DEFAULT_THRESHOLD;
v->uv_lcl_addr = addr;
v->uv_rmt_addr = 0;
v->uv_subnet = subnet;
v->uv_subnetmask = mask;
v->uv_subnetbcast = subnet | ~mask;
strlcpy(v->uv_name, ifa->ifa_name, sizeof(v->uv_name));
v->uv_groups = NULL;
v->uv_neighbors = NULL;
v->uv_acl = NULL;
v->uv_addrs = NULL;
logit(LOG_INFO,0,"installing %s (%s on subnet %s) as vif #%u - rate=%d",
v->uv_name, inet_fmt(addr),
inet_fmts(subnet, mask),
numvifs, v->uv_rate_limit);
++numvifs;
/*
* If the interface is not yet up, set the vifs_down flag to
* remind us to check again later.
*/
if (!(flags & IFF_UP)) {
v->uv_flags |= VIFF_DOWN;
vifs_down = TRUE;
}
}
freeifaddrs(ifap);
}
int main(int argc, const char * argv[])
{
struct ifaddrs *ifaddr, *p;
struct addr_ll *addr_list = NULL;
int status;
char ipstr[INET6_ADDRSTRLEN];
struct addr_ll *curr = NULL;
struct addr_ll *next = NULL;
ssize_t bytes;
int i;
addr_list = (struct addr_ll *)malloc(sizeof(struct addr_ll));
addr_list->active = IFDOWN;
addr_list->next = NULL;
if ((status = getifaddrs(&ifaddr)) != 0) {
fprintf(stderr, "getifaddrs: %s\n",gai_strerror(status));
return 2;
}
// Go through each of the available IP addresses and store them.
for (p = ifaddr; p!=NULL; p=p->ifa_next) {
if (p->ifa_addr != NULL) {
if (p->ifa_addr->sa_family == AF_INET) {
//Determine if address is the loopback or is already registered as active
int ignore = 0;
struct sockaddr_in *ipv4 = (struct sockaddr_in *)p->ifa_addr;
inet_ntop(AF_INET, &ipv4->sin_addr, ipstr, sizeof(ipstr));
if (strcmp(ipstr, "127.0.0.1")) {
for (curr = addr_list; curr->next != NULL; curr = curr->next) {
if (curr->active == IFUP && &(curr->addr.sin_addr) == &(ipv4->sin_addr)) {
ignore = 1;
break;
}
}
} else {
ignore = 1;
}
//If it is not already registered
if (ignore == 0) {
if (curr->active == IFUP) {
next = (struct addr_ll *)malloc(sizeof(struct addr_ll));
curr->next = next;
} else {
next = curr;
}
next->active = IFUP;
next->addr = *ipv4;
strcpy(next->if_name,p->ifa_name);
next->next = NULL;
}
}
}
}
// Print out each available interface and its IPv4 address
printf("My IP addresses are:\n\n");
curr = addr_list;
while (1) {
if (curr->active == IFUP) {
inet_ntop(curr->addr.sin_family,&(curr->addr.sin_addr),ipstr,sizeof(ipstr));
printf("%s: %s\n",curr->if_name,ipstr);
}
curr = curr->next;
if (curr == NULL)
break;
}
freeifaddrs(ifaddr);
// Now setup a socket on each interface and transmit a message
char buf[13] = "Hello World!";
struct sockaddr_in remote;
inet_pton(AF_INET, REMOTE_ADDR, &(remote.sin_addr));
remote.sin_port = htons(REMOTE_PORT);
remote.sin_family = AF_INET;
// Code for generating messages using sendmsg: //
struct iovec iov;
struct msghdr msg = {0};
struct cmsghdr *cmsg;
struct in_pktinfo *pktinfo;
char control[sizeof(struct cmsghdr)+12];
const int on=1, off=0;
// End sendmsg code
curr = addr_list;
while (1) {
if (curr->active == IFUP) {
if ((curr->sk = socket(curr->addr.sin_family, SOCK_DGRAM, 0)) == -1) {
perror("socket");
continue;
}
// Code used when sendmsg is used
setsockopt(curr->sk, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
setsockopt(curr->sk, IPPROTO_IP, IP_PKTINFO, &on, sizeof(on));
// End code for sendmsg
curr->addr.sin_port = htons(7777);
if (bind(curr->sk, (struct sockaddr *)&curr->addr, sizeof(curr->addr)) == -1) {
close(curr->sk);
perror("bind");
continue;
}
for (i = 0; i < 10; i++) {
// Code for generating message for sendmsg:
iov.iov_base = buf;
iov.iov_len = sizeof(buf);
msg.msg_name = &remote;
msg.msg_namelen = sizeof(remote);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = control;
msg.msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo));
msg.msg_flags = 0;
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = IPPROTO_IP;
cmsg->cmsg_type = IP_PKTINFO;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
pktinfo = (struct in_pktinfo *)CMSG_DATA(cmsg);
//pktinfo->ipi_ifindex = if_nametoindex(curr->if_name);
pktinfo->ipi_ifindex = 0;
pktinfo->ipi_spec_dst = curr->addr.sin_addr;
pktinfo->ipi_addr = remote.sin_addr;
if ((bytes = sendmsg(curr->sk, &msg, 0)) == -1) {
perror("send");
exit(1);
}
// End sendmsg code
/*
* // Code used for sendto
* if ((bytes = sendto(curr->sk,buf,sizeof(buf),0,(struct sockaddr *)&remote,sizeof(remote))) == -1) {
* perror("send");
* exit(1);
}
// End sendto code
*/
}
}
close(curr->sk);
curr = curr->next;
if (curr == NULL)
break;
}
return 0;
}
main() {
#ifdef SIOCRPHYSADDR
struct ifdevea req = { 0 };
#endif
struct ifconf list = { 0 };
int s = { 0 };
int i = { 0 };
union {
struct ifreq a;
char b[4096];
} buf;
struct ifreq* p = { 0 };
#ifdef HAS_GETIFADDRS
struct ifaddrs* if1;
struct ifaddrs* if2;
#endif
memset(&buf, 0, sizeof(buf));
s = socket(AF_UNIX, SOCK_STREAM, PF_UNSPEC);
if (s < 0) {
perror("socket");
exit(1);
}
#ifdef HAS_GETIFADDRS
getifaddrs(&if1);
for (if2 = if1; if2; if2 = if2->ifa_next)
{
if (if2->ifa_addr->sa_family == AF_LINK)
{
struct sockaddr_dl* dl = (struct sockaddr_dl*)if2->ifa_addr;
unsigned char* mac = (unsigned char*)LLADDR(dl);
if (dl->sdl_alen == 6) /* 48 bits */
{
printf("%s %02X:%02X:%02X:%02X:%02X:%02X\n",
if2->ifa_name,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
else if (dl->sdl_alen == 8) /* 64 bits IP over firewire */
{
printf("%s %02X:%02X:%02X:%02X:%02X:%02X:%02X:%02X\n",
if2->ifa_name,
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], mac[6], mac[7]);
}
breakpoint();
}
}
freeifaddrs(if1);
#endif
list.ifc_len = sizeof(buf);
list.ifc_req = &buf.a;
if (-1 == ioctl(s, SIOCGIFCONF, &list))
{perror("SIOCGIFCONF"); exit(2);}
printf("list.ifc_len %d\n", list.ifc_len);
for (i = 0; i < list.ifc_len; i += _SIZEOF_ADDR_IFREQ(*p)) {
p = (struct ifreq*)&buf.b[i];
printf("buf[%d] = %s\n", i, p->ifr_name);
#ifdef SIOCRPHYSADDR
strcpy(req.ifr_name, p->ifr_name);
if (-1 == ioctl(s, SIOCRPHYSADDR, &req)) {
perror(" SIOCRPHYSADDR");
} else {
printf(" Device address %02x%02x%02x%02x%02x%02x\n",
req.default_pa[0], req.default_pa[1],
req.default_pa[2], req.default_pa[3],
req.default_pa[4], req.default_pa[5]);}
}
#endif
}
static int
if_getaddrs (void)
{
int ret;
struct ifaddrs *ifap;
struct ifaddrs *ifapfree;
struct interface_FOO *ifp;
int prefixlen;
ret = getifaddrs (&ifap);
if (ret != 0)
{
zlog_err ("getifaddrs(): %s", safe_strerror (errno));
return -1;
}
for (ifapfree = ifap; ifap; ifap = ifap->ifa_next)
{
if (ifap->ifa_addr == NULL)
{
zlog_err ("%s: nonsensical ifaddr with NULL ifa_addr, ifname %s",
__func__, (ifap->ifa_name ? ifap->ifa_name : "(null)"));
continue;
}
ifp = if_lookup_by_name (ifap->ifa_name);
if (ifp == NULL)
{
zlog_err ("if_getaddrs(): Can't lookup interface %s\n",
ifap->ifa_name);
continue;
}
if (ifap->ifa_addr->sa_family == AF_INET)
{
struct sockaddr_in *addr;
struct sockaddr_in *mask;
struct sockaddr_in *dest;
struct in_addr *dest_pnt;
int flags = 0;
addr = (struct sockaddr_in *) ifap->ifa_addr;
mask = (struct sockaddr_in *) ifap->ifa_netmask;
prefixlen = ip_masklen (mask->sin_addr);
dest_pnt = NULL;
if (ifap->ifa_dstaddr &&
!IPV4_ADDR_SAME(&addr->sin_addr,
&((struct sockaddr_in *)
ifap->ifa_dstaddr)->sin_addr))
{
dest = (struct sockaddr_in *) ifap->ifa_dstaddr;
dest_pnt = &dest->sin_addr;
flags = ZEBRA_IFA_PEER;
}
else if (ifap->ifa_broadaddr &&
!IPV4_ADDR_SAME(&addr->sin_addr,
&((struct sockaddr_in *)
ifap->ifa_broadaddr)->sin_addr))
{
dest = (struct sockaddr_in *) ifap->ifa_broadaddr;
dest_pnt = &dest->sin_addr;
}
connected_add_ipv4 (ifp, flags, &addr->sin_addr,
prefixlen, dest_pnt, NULL);
}
#ifdef HAVE_IPV6
if (ifap->ifa_addr->sa_family == AF_INET6)
{
struct sockaddr_in6 *addr;
struct sockaddr_in6 *mask;
struct sockaddr_in6 *dest;
struct in6_addr *dest_pnt;
int flags = 0;
addr = (struct sockaddr_in6 *) ifap->ifa_addr;
mask = (struct sockaddr_in6 *) ifap->ifa_netmask;
prefixlen = ip6_masklen (mask->sin6_addr);
dest_pnt = NULL;
if (ifap->ifa_dstaddr &&
!IPV6_ADDR_SAME(&addr->sin6_addr,
&((struct sockaddr_in6 *)
ifap->ifa_dstaddr)->sin6_addr))
{
dest = (struct sockaddr_in6 *) ifap->ifa_dstaddr;
dest_pnt = &dest->sin6_addr;
flags = ZEBRA_IFA_PEER;
}
else if (ifap->ifa_broadaddr &&
!IPV6_ADDR_SAME(&addr->sin6_addr,
&((struct sockaddr_in6 *)
ifap->ifa_broadaddr)->sin6_addr))
{
dest = (struct sockaddr_in6 *) ifap->ifa_broadaddr;
dest_pnt = &dest->sin6_addr;
}
#if defined(KAME)
if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr))
{
addr->sin6_scope_id =
ntohs(*(u_int16_t *)&addr->sin6_addr.s6_addr[2]);
addr->sin6_addr.s6_addr[2] = addr->sin6_addr.s6_addr[3] = 0;
}
#endif
connected_add_ipv6 (ifp, flags, &addr->sin6_addr, prefixlen,
dest_pnt, NULL);
}
#endif /* HAVE_IPV6 */
}
freeifaddrs (ifapfree);
return 0;
}
s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
{
cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x (%s), info=*0x%x)", code, InfoCodeToName(code), info);
if (code == CELL_NET_CTL_INFO_MTU)
{
#ifdef _WIN32
ULONG bufLen = sizeof(PIP_ADAPTER_ADDRESSES) + 1;
PIP_ADAPTER_ADDRESSES pAddresses = (PIP_ADAPTER_ADDRESSES)malloc(bufLen);
DWORD ret;
ret = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, nullptr, pAddresses, &bufLen);
if (ret == ERROR_BUFFER_OVERFLOW)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): GetAdaptersAddresses buffer overflow.");
free(pAddresses);
pAddresses = (PIP_ADAPTER_ADDRESSES)malloc(bufLen);
if (pAddresses == nullptr)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Unable to allocate memory for pAddresses.");
return CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED;
}
}
ret = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, nullptr, pAddresses, &bufLen);
if (ret == NO_ERROR)
{
PIP_ADAPTER_ADDRESSES pCurrAddresses = pAddresses;
for (int c = 0; c < rpcs3::config.misc.net._interface.value(); c++)
{
pCurrAddresses = pCurrAddresses->Next;
}
info->mtu = pCurrAddresses->Mtu;
}
else
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Call to GetAdaptersAddresses failed. (%d)", ret);
info->mtu = 1500; // Seems to be the default value on Windows 10.
}
free(pAddresses);
#else
struct ifaddrs *ifaddr, *ifa;
s32 family, n;
if (getifaddrs(&ifaddr) == -1)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Call to getifaddrs returned negative.");
}
for (ifa = ifaddr, n = 0; ifa != nullptr; ifa = ifa->ifa_next, n++)
{
if (ifa->ifa_addr == nullptr)
{
continue;
}
if (n < rpcs3::config.misc.net._interface.value())
{
continue;
}
family = ifa->ifa_addr->sa_family;
if (family == AF_INET)
{
u32 fd = open("/proc/net/dev", O_RDONLY);
struct ifreq freq;
if (ioctl(fd, SIOCGIFMTU, &freq) == -1)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Call to ioctl failed.");
}
else
{
info->mtu = (u32)freq.ifr_mtu;
}
close(fd);
}
}
freeifaddrs(ifaddr);
#endif
}
else if (code == CELL_NET_CTL_INFO_LINK)
{
if (rpcs3::config.misc.net.status.value() == misc_net_status::ip_obtained)
{
info->link = CELL_NET_CTL_LINK_CONNECTED;
}
else
{
info->link = CELL_NET_CTL_LINK_DISCONNECTED;
}
}
else if (code == CELL_NET_CTL_INFO_IP_ADDRESS)
{
// 0.0.0.0 seems to be the default address when no ethernet cables are connected to the PS3
strcpy_trunc(info->ip_address, "0.0.0.0");
#ifdef _WIN32
ULONG bufLen = sizeof(IP_ADAPTER_INFO);
PIP_ADAPTER_INFO pAdapterInfo = (IP_ADAPTER_INFO*)malloc(bufLen);
DWORD ret;
ret = GetAdaptersInfo(pAdapterInfo, &bufLen);
if (ret == ERROR_BUFFER_OVERFLOW)
{
cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): GetAdaptersInfo buffer overflow.");
free(pAdapterInfo);
pAdapterInfo = (IP_ADAPTER_INFO*)malloc(bufLen);
if (pAdapterInfo == nullptr)
{
cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): Unable to allocate memory for pAddresses.");
return CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED;
}
}
ret = GetAdaptersInfo(pAdapterInfo, &bufLen);
if (ret == NO_ERROR)
{
PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
for (int c = 0; c < rpcs3::config.misc.net._interface.value(); c++)
{
pAdapter = pAdapter->Next;
}
strcpy_trunc(info->ip_address, pAdapter->IpAddressList.IpAddress.String);
}
else
{
cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): Call to GetAdaptersInfo failed. (%d)", ret);
}
free(pAdapterInfo);
#else
struct ifaddrs *ifaddr, *ifa;
s32 family, n;
if (getifaddrs(&ifaddr) == -1)
{
cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): Call to getifaddrs returned negative.");
}
for (ifa = ifaddr, n = 0; ifa != nullptr; ifa = ifa->ifa_next, n++)
{
if (ifa->ifa_addr == nullptr)
{
continue;
}
if (n < rpcs3::config.misc.net._interface.value())
{
continue;
}
family = ifa->ifa_addr->sa_family;
if (family == AF_INET)
{
strcpy_trunc(info->ip_address, ifa->ifa_addr->sa_data);
}
}
freeifaddrs(ifaddr);
#endif
}
else if (code == CELL_NET_CTL_INFO_NETMASK)
{
#ifdef _WIN32
ULONG bufLen = sizeof(IP_ADAPTER_INFO) + 1;
PIP_ADAPTER_INFO pAdapterInfo = (PIP_ADAPTER_INFO)malloc(bufLen);
DWORD ret;
ret = GetAdaptersInfo(pAdapterInfo, &bufLen);
if (ret == ERROR_BUFFER_OVERFLOW)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): GetAdaptersInfo buffer overflow.");
free(pAdapterInfo);
pAdapterInfo = (IP_ADAPTER_INFO*)malloc(bufLen);
if (pAdapterInfo == nullptr)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): Unable to allocate memory for pAddresses.");
return CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED;
}
}
ret = GetAdaptersInfo(pAdapterInfo, &bufLen);
if (ret == NO_ERROR)
{
PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
for (int c = 0; c < rpcs3::config.misc.net._interface.value(); c++)
{
pAdapter = pAdapter->Next;
}
for (int c = 0; c < 4; c++)
{
info->netmask[c] = (s8)pAdapter->IpAddressList.IpMask.String;
}
}
else
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): Call to GetAdaptersInfo failed. (%d)", ret);
// TODO: Is this the default netmask?
info->netmask[0] = 255;
info->netmask[1] = 255;
info->netmask[2] = 255;
info->netmask[3] = 0;
}
free(pAdapterInfo);
#else
struct ifaddrs *ifaddr, *ifa;
s32 family, n;
if (getifaddrs(&ifaddr) == -1)
{
cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): Call to getifaddrs returned negative.");
}
for (ifa = ifaddr, n = 0; ifa != nullptr; ifa = ifa->ifa_next, n++)
{
if (ifa->ifa_addr == nullptr)
{
continue;
}
if (n < rpcs3::config.misc.net._interface.value())
{
continue;
}
family = ifa->ifa_addr->sa_family;
if (family == AF_INET)
{
strcpy_trunc(info->ip_address, ifa->ifa_netmask->sa_data);
}
}
freeifaddrs(ifaddr);
#endif
}
return CELL_OK;
}
int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list)
{
int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
if (sock < 0)
{
Log(("NetIfList: socket() -> %d\n", errno));
return NULL;
}
struct ifaddrs *IfAddrs, *pAddr;
int rc = getifaddrs(&IfAddrs);
if (rc)
{
close(sock);
Log(("NetIfList: getifaddrs() -> %d\n", rc));
return VERR_INTERNAL_ERROR;
}
PDARWINETHERNIC pEtherNICs = DarwinGetEthernetControllers();
while (pEtherNICs)
{
size_t cbNameLen = strlen(pEtherNICs->szName) + 1;
PNETIFINFO pNew = (PNETIFINFO)RTMemAllocZ(RT_OFFSETOF(NETIFINFO, szName[cbNameLen]));
pNew->MACAddress = pEtherNICs->Mac;
pNew->enmMediumType = NETIF_T_ETHERNET;
pNew->Uuid = pEtherNICs->Uuid;
Assert(sizeof(pNew->szShortName) > sizeof(pEtherNICs->szBSDName));
memcpy(pNew->szShortName, pEtherNICs->szBSDName, sizeof(pEtherNICs->szBSDName));
pNew->szShortName[sizeof(pEtherNICs->szBSDName)] = '\0';
memcpy(pNew->szName, pEtherNICs->szName, cbNameLen);
struct ifreq IfReq;
RTStrCopy(IfReq.ifr_name, sizeof(IfReq.ifr_name), pNew->szShortName);
if (ioctl(sock, SIOCGIFFLAGS, &IfReq) < 0)
{
Log(("NetIfList: ioctl(SIOCGIFFLAGS) -> %d\n", errno));
pNew->enmStatus = NETIF_S_UNKNOWN;
}
else
pNew->enmStatus = (IfReq.ifr_flags & IFF_UP) ? NETIF_S_UP : NETIF_S_DOWN;
for (pAddr = IfAddrs; pAddr != NULL; pAddr = pAddr->ifa_next)
{
if (strcmp(pNew->szShortName, pAddr->ifa_name))
continue;
struct sockaddr_in *pIPAddr, *pIPNetMask;
struct sockaddr_in6 *pIPv6Addr, *pIPv6NetMask;
switch (pAddr->ifa_addr->sa_family)
{
case AF_INET:
if (pNew->IPAddress.u)
break;
pIPAddr = (struct sockaddr_in *)pAddr->ifa_addr;
Assert(sizeof(pNew->IPAddress) == sizeof(pIPAddr->sin_addr));
pNew->IPAddress.u = pIPAddr->sin_addr.s_addr;
pIPNetMask = (struct sockaddr_in *)pAddr->ifa_netmask;
Assert(pIPNetMask->sin_family == AF_INET);
Assert(sizeof(pNew->IPNetMask) == sizeof(pIPNetMask->sin_addr));
pNew->IPNetMask.u = pIPNetMask->sin_addr.s_addr;
break;
case AF_INET6:
if (pNew->IPv6Address.s.Lo || pNew->IPv6Address.s.Hi)
break;
pIPv6Addr = (struct sockaddr_in6 *)pAddr->ifa_addr;
Assert(sizeof(pNew->IPv6Address) == sizeof(pIPv6Addr->sin6_addr));
memcpy(pNew->IPv6Address.au8,
pIPv6Addr->sin6_addr.__u6_addr.__u6_addr8,
sizeof(pNew->IPv6Address));
pIPv6NetMask = (struct sockaddr_in6 *)pAddr->ifa_netmask;
Assert(pIPv6NetMask->sin6_family == AF_INET6);
Assert(sizeof(pNew->IPv6NetMask) == sizeof(pIPv6NetMask->sin6_addr));
memcpy(pNew->IPv6NetMask.au8,
pIPv6NetMask->sin6_addr.__u6_addr.__u6_addr8,
sizeof(pNew->IPv6NetMask));
break;
}
}
ComObjPtr<HostNetworkInterface> IfObj;
IfObj.createObject();
if (SUCCEEDED(IfObj->init(Bstr(pEtherNICs->szName), HostNetworkInterfaceType_Bridged, pNew)))
list.push_back(IfObj);
RTMemFree(pNew);
/* next, free current */
void *pvFree = pEtherNICs;
pEtherNICs = pEtherNICs->pNext;
RTMemFree(pvFree);
}
freeifaddrs(IfAddrs);
close(sock);
return VINF_SUCCESS;
}
int main(int argc, char *argv[]){
int listenfd,
i=0,
iPort,
fd,
err,
status;
char client[MAX_CANON],
command[MAX_CANON],
ip[IP_MAX],
*saveptr,
*sPort,
*sIp,
a,
*c;
struct dirent *direntp;
DIR *dirp;
struct sigaction sigIntHandler;
struct ifaddrs *myaddrs, *ifa;
request_t request, request2;
flag_t flag;
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigIntHandler.sa_handler = signalHandler;
if(argc != 2)
usage("2 arguman girmelisiniz\t./client <server IP>:<server port number>");
else{
if (sigemptyset(&sigIntHandler.sa_mask) == -1 || sigaction(SIGINT, &sigIntHandler, NULL) || sigaction(SIGUSR1, &sigIntHandler, NULL))
err_sys("signal handler");
sigIntHandler.sa_flags = 0;
saveptr=command;
sIp=strtok_r(argv[1], ":", &saveptr);
sPort=strtok_r(NULL, ":", &saveptr);
printf("%s\n", argv[1]);
if(sPort!=NULL)
iPort=atoi(sPort);
else
usage("./client <server IP>:<server port number>");
socketFD = callSocket(sIp, iPort);
if(socketFD==-1)
err_sys("connection error");
getcwd(request2.path, PATH_MAX);
if(write(socketFD, &request2, sizeof(request2))<0)
err_sys("write");
if(read(socketFD, &id, sizeof(int))<0)
err_sys("read");
pthread_mutex_init(&mutex, NULL);
if (err = pthread_create(&tid, NULL, (void *)readFromServer, &c)<0)
perror("pthread_create");
status = getifaddrs(&myaddrs);
if (status != 0)
err_sys("getifaddrs failed!");
freeifaddrs(myaddrs);
system("clear");
printf("Port Number: %d ",iPort);
for (ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
if ((ifa->ifa_flags & IFF_UP) != 0 && NULL != ifa->ifa_addr)
printIPAddress(ifa);
fprintf(stderr, "\nPlease enter a command.\nEnter 'help' for display the available commands and their usage.\n");
while(1){
printf("\nClient ID: %d\n >\t", id);
fgets(command, 50, stdin);
printf("\n");
command[strlen(command)-1]='\0';
if(strcmp(command, "help") == 0)
menu();
else if(strcmp(command,"listLocal") == 0){
char cwd[255];
getcwd(cwd, 255);
if((dirp = opendir(cwd)) == NULL)
err_sys("opendir");
printf("List of local files in %s\n", cwd);
while((direntp = readdir(dirp)) != NULL) {
if(strcmp(direntp->d_name,".") != 0 && strcmp(direntp->d_name,"..") != 0){
fprintf(stderr, "%s\n", direntp->d_name);
}
}
}
else if(strcmp(command,"lsClients") == 0){
sprintf(request.command, "%s", "lsClients");
if(write(socketFD, &request, sizeof(request))<0)
perror("write");
}
else if(strncmp(command,"sendFile", 8) == 0){
bool status=true;
char *fileName, *id1, *saveptr;
saveptr=command;
strtok_r(command, " ", &saveptr);
fileName = strtok_r(NULL, " " , &saveptr);
id1 = strtok_r(NULL, " ", &saveptr);
if(fileName==NULL){
fprintf(stderr, "Please enter a current filename.\n");
status=false;
}
else{
sprintf(request.file.name, "%s", fileName);
if((fd = open(fileName, O_RDONLY))<0){
fprintf(stderr, "%s isn't a current file name. Try again!\n", fileName);
request.status=-3;
status=false;
}
}
if(id1==NULL) { /*dosyayi sadece server'a yolla. */
request.status=-1;
request.clientID=id;
printf("nULL\n");
if((fd = open(fileName, O_RDONLY))<0){
fprintf(stderr, "%s isn't a current file name. Try again!\n", fileName);
status=false;
printf("Status: %d\n", status);
}
}
else{
request.status=1;
request.clientID=atoi(id1);
}
struct stat st;
stat(fileName, &st);
request.file.size = st.st_size;
strcpy(request.command,"sendFile");
if(status){
flagWrite=1;
pthread_sigmask(SIG_BLOCK, &set, NULL);
if(write(socketFD, &request, sizeof(request))<0)
err_sys("write");
else{
int j=0;
while(j<request.file.size){
if(read(fd, &a, sizeof(char))<0)
perror("read1");
write(socketFD, &a, sizeof(char));
++j;
}
close(fd);
flagWrite=0;
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
}
}
}
else if(strcmp(command,"listServer") == 0){
sprintf(request.command, "%s", "listServer");
if(write(socketFD, &request, sizeof(request))<0)
perror("write");
}
else
fprintf(stderr, "Please enter a current command.\n");
}
}
}
uv_err_t uv_interface_addresses(uv_interface_address_t** addresses,
int* count) {
#ifndef HAVE_IFADDRS_H
return uv__new_artificial_error(UV_ENOSYS);
#else
struct ifaddrs* addrs, *ent;
char ip[INET6_ADDRSTRLEN];
uv_interface_address_t* address;
if (getifaddrs(&addrs) != 0) {
return uv__new_sys_error(errno);
}
*count = 0;
/* Count the number of interfaces */
for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
if (!(ent->ifa_flags & IFF_UP && ent->ifa_flags & IFF_RUNNING) ||
(ent->ifa_addr == NULL) || (ent->ifa_addr->sa_family == PF_PACKET)) {
continue;
}
(*count)++;
}
*addresses =
(uv_interface_address_t*)malloc(*count * sizeof(uv_interface_address_t));
if (!(*addresses)) {
return uv__new_artificial_error(UV_ENOMEM);
}
address = *addresses;
for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
bzero(&ip, sizeof(ip));
if (!(ent->ifa_flags & IFF_UP && ent->ifa_flags & IFF_RUNNING)) {
continue;
}
if (ent->ifa_addr == NULL) {
continue;
}
/*
* On Linux getifaddrs returns information related to the raw underlying
* devices. We're not interested in this information.
*/
if (ent->ifa_addr->sa_family == PF_PACKET) {
continue;
}
address->name = strdup(ent->ifa_name);
if (ent->ifa_addr->sa_family == AF_INET6) {
address->address.address6 = *((struct sockaddr_in6*)ent->ifa_addr);
} else {
address->address.address4 = *((struct sockaddr_in*)ent->ifa_addr);
}
address->is_internal = ent->ifa_flags & IFF_LOOPBACK ? 1 : 0;
address++;
}
freeifaddrs(addrs);
return uv_ok_;
#endif
}
/*
* this function gets the hardware type and address of an interface,
* determines the link layer token length and checks it against
* the defined prefixes
*/
int
setup_deviceinfo(struct Interface *iface)
{
struct ifaddrs *addresses = 0, *ifa;
struct ifreq ifr;
struct AdvPrefix *prefix;
char zero[sizeof(iface->if_addr)];
if(if_nametoindex(iface->Name) == 0){
flog(LOG_ERR, "%s not found: %s", iface->Name, strerror(errno));
goto ret;
}
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, iface->Name, IFNAMSIZ-1);
ifr.ifr_name[IFNAMSIZ-1] = '\0';
if (ioctl(sock, SIOCGIFMTU, &ifr) < 0) {
flog(LOG_ERR, "ioctl(SIOCGIFMTU) failed for %s: %s", iface->Name, strerror(errno));
goto ret;
}
dlog(LOG_DEBUG, 3, "mtu for %s is %d", iface->Name, ifr.ifr_mtu);
iface->if_maxmtu = ifr.ifr_mtu;
if (getifaddrs(&addresses) != 0)
{
flog(LOG_ERR, "getifaddrs failed: %s(%d)", strerror(errno), errno);
goto ret;
}
for (ifa = addresses; ifa != NULL; ifa = ifa->ifa_next)
{
if (strcmp(ifa->ifa_name, iface->Name) != 0)
continue;
if (ifa->ifa_addr == NULL)
continue;
if (ifa->ifa_addr->sa_family != AF_LINK)
continue;
struct sockaddr_dl *dl = (struct sockaddr_dl*)ifa->ifa_addr;
if (dl->sdl_alen > sizeof(iface->if_addr))
{
flog(LOG_ERR, "address length %d too big for",
dl->sdl_alen,
iface->Name);
goto ret;
}
memcpy(iface->if_hwaddr, LLADDR(dl), dl->sdl_alen);
iface->if_hwaddr_len = dl->sdl_alen << 3;
switch(dl->sdl_type) {
case IFT_ETHER:
case IFT_ISO88023:
iface->if_prefix_len = 64;
break;
case IFT_FDDI:
iface->if_prefix_len = 64;
break;
default:
iface->if_prefix_len = -1;
iface->if_maxmtu = -1;
break;
}
dlog(LOG_DEBUG, 3, "link layer token length for %s is %d", iface->Name,
iface->if_hwaddr_len);
dlog(LOG_DEBUG, 3, "prefix length for %s is %d", iface->Name,
iface->if_prefix_len);
if (iface->if_prefix_len != -1) {
memset(zero, 0, dl->sdl_alen);
if (!memcmp(iface->if_hwaddr, zero, dl->sdl_alen))
flog(LOG_WARNING, "WARNING, MAC address on %s is all zero!",
iface->Name);
}
prefix = iface->AdvPrefixList;
while (prefix)
{
if ((iface->if_prefix_len != -1) &&
(iface->if_prefix_len != prefix->PrefixLen))
{
flog(LOG_WARNING, "prefix length should be %d for %s",
iface->if_prefix_len, iface->Name);
}
prefix = prefix->next;
}
freeifaddrs(addresses);
return 0;
}
ret:
iface->if_maxmtu = -1;
iface->if_hwaddr_len = -1;
iface->if_prefix_len = -1;
if (addresses != 0)
freeifaddrs(addresses);
return -1;
}
/* XXX I don't know if this function should return
* IPv4 or IPv6 if both are enabled... */
int getifaddr_in6(const char * ifname, struct in6_addr * addr)
{
#if defined(ENABLE_IPV6) || defined(USE_GETIFADDRS)
struct ifaddrs * ifap;
struct ifaddrs * ife;
#ifdef ENABLE_IPV6
const struct sockaddr_in6 * tmpaddr;
#endif /* ENABLE_IPV6 */
int found = 0;
if(!ifname || ifname[0]=='\0')
return -1;
if(getifaddrs(&ifap)<0)
{
syslog(LOG_ERR, "getifaddrs: %m");
return -1;
}
for(ife = ifap; ife && !found; ife = ife->ifa_next)
{
/* skip other interfaces if one was specified */
if(ifname && (0 != strcmp(ifname, ife->ifa_name)))
continue;
if(ife->ifa_addr == NULL)
continue;
switch(ife->ifa_addr->sa_family)
{
case AF_INET:
/* IPv4-mapped IPv6 address ::ffff:1.2.3.4 */
memset(addr->s6_addr, 0, 10);
addr->s6_addr[10] = 0xff;
addr->s6_addr[11] = 0xff;
memcpy(addr->s6_addr + 12,
&(((struct sockaddr_in *)ife->ifa_addr)->sin_addr.s_addr),
4);
found = 1;
break;
#ifdef ENABLE_IPV6
case AF_INET6:
tmpaddr = (const struct sockaddr_in6 *)ife->ifa_addr;
if(!IN6_IS_ADDR_LOOPBACK(&tmpaddr->sin6_addr)
&& !IN6_IS_ADDR_LINKLOCAL(&tmpaddr->sin6_addr))
{
memcpy(addr->s6_addr,
&tmpaddr->sin6_addr,
16);
found = 1;
}
break;
#endif /* ENABLE_IPV6 */
}
}
freeifaddrs(ifap);
return (found ? 0 : -1);
#else /* defined(ENABLE_IPV6) || defined(USE_GETIFADDRS) */
/* IPv4 only */
struct in_addr addr4;
if(getifaddr(ifname, NULL, 0, &addr4, NULL) < 0)
return -1;
/* IPv4-mapped IPv6 address ::ffff:1.2.3.4 */
memset(addr->s6_addr, 0, 10);
addr->s6_addr[10] = 0xff;
addr->s6_addr[11] = 0xff;
memcpy(addr->s6_addr + 12, &addr4.s_addr, 4);
return 0;
#endif
}
void CAEthernetGetInterfaceInformation(const char *interfaceNamePrefix,char **interfaceName,
char **ipAddress, char **subnetMask)
{
if (!interfaceName || !ipAddress || !subnetMask)
{
OIC_LOG(ERROR, ETHERNET_MONITOR_TAG, "Invalid input: interface/ipaddress/subnet mask holder is NULL!");
return;
}
struct ifaddrs *ifp = NULL;
if (-1 == getifaddrs(&ifp))
{
OIC_LOG_V(ERROR, ETHERNET_MONITOR_TAG, "Failed to get interface list!, Error code: %s",
strerror(errno));
return;
}
struct ifaddrs *ifa = NULL;
for (ifa = ifp; ifa; ifa = ifa->ifa_next)
{
char interfaceAddress[CA_IPADDR_SIZE];
char interfaceSubnetMask[CA_IPADDR_SIZE] = {0};
socklen_t len = sizeof(struct sockaddr_in);
if (NULL == ifa->ifa_addr)
{
continue;
}
int type = ifa->ifa_addr->sa_family;
if (ifa->ifa_flags & IFF_LOOPBACK
|| !((ifa->ifa_flags & IFF_UP) && (ifa->ifa_flags & IFF_RUNNING)))
{
continue;
}
if (AF_INET != type)
{
continue;
}
int matchNameLen = strlen(interfaceNamePrefix);
if (!strncasecmp(ifa->ifa_name, interfaceNamePrefix, matchNameLen))
{
// get the interface ip address
if (0 != getnameinfo(ifa->ifa_addr, len, interfaceAddress,
sizeof(interfaceAddress), NULL, 0, NI_NUMERICHOST))
{
OIC_LOG_V(ERROR, ETHERNET_MONITOR_TAG, "Failed to get IPAddress, Error code: %s",
strerror(errno));
break;
}
// get the interface subnet mask
if (0 != getnameinfo(ifa->ifa_netmask, len, interfaceSubnetMask,
sizeof(interfaceSubnetMask), NULL, 0, NI_NUMERICHOST))
{
OIC_LOG_V(ERROR, ETHERNET_MONITOR_TAG, "Failed to get subnet mask, Error code: %s",
strerror(errno));
break;
}
// set interface name
*interfaceName = strndup(ifa->ifa_name, strlen(ifa->ifa_name));
// set local ip address
*ipAddress = strndup(interfaceAddress, strlen(interfaceAddress));
// set subnet mask
*subnetMask = strndup(interfaceSubnetMask, strlen(interfaceSubnetMask));
break;
}
}
freeifaddrs(ifp);
}
gboolean
arv_gv_fake_camera_start (ArvGvFakeCamera *gv_fake_camera)
{
struct ifaddrs *ifap = NULL;
struct ifaddrs *ifap_iter;
int return_value;
gboolean interface_found = FALSE;
gboolean binding_error = FALSE;
g_return_val_if_fail (ARV_IS_GV_FAKE_CAMERA (gv_fake_camera), FALSE);
return_value = getifaddrs (&ifap);
if (return_value < 0) {
arv_warning_device ("[GvFakeCamera::start] No network interface found");
return FALSE;
}
for (ifap_iter = ifap ;ifap_iter != NULL && !interface_found; ifap_iter = ifap_iter->ifa_next) {
if ((ifap_iter->ifa_flags & IFF_UP) != 0 &&
(ifap_iter->ifa_flags & IFF_POINTOPOINT) == 0 &&
(ifap_iter->ifa_addr->sa_family == AF_INET) &&
g_strcmp0 (ifap_iter->ifa_name, gv_fake_camera->priv->interface_name) == 0) {
GSocketAddress *socket_address;
GSocketAddress *inet_socket_address;
GInetAddress *inet_address;
char *gvcp_address_string;
char *discovery_address_string;
socket_address = g_socket_address_new_from_native (ifap_iter->ifa_addr,
sizeof (struct sockaddr));
inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address));
gvcp_address_string = g_inet_address_to_string (inet_address);
arv_debug_device ("[GvFakeCamera::start] Interface address = %s", gvcp_address_string);
inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT);
gv_fake_camera->priv->gvcp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_fake_camera->priv->gvcp_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_socket_set_blocking (gv_fake_camera->priv->gvcp_socket, FALSE);
arv_fake_camera_set_inet_address (gv_fake_camera->priv->camera, inet_address);
g_object_unref (inet_socket_address);
inet_socket_address = g_inet_socket_address_new (inet_address, 0);
gv_fake_camera->priv->gvsp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_fake_camera->priv->gvsp_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_clear_object (&inet_socket_address);
g_clear_object (&socket_address);
inet_address = g_inet_address_new_from_string ("255.255.255.255");
discovery_address_string = g_inet_address_to_string (inet_address);
arv_debug_device ("[GvFakeCamera::start] Discovery address = %s", discovery_address_string);
inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT);
if (g_strcmp0 (gvcp_address_string, discovery_address_string) == 0)
gv_fake_camera->priv->discovery_socket = NULL;
else {
gv_fake_camera->priv->discovery_socket = g_socket_new (G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
if (!g_socket_bind (gv_fake_camera->priv->discovery_socket, inet_socket_address, FALSE, NULL))
binding_error = TRUE;
g_socket_set_blocking (gv_fake_camera->priv->discovery_socket, FALSE);
}
g_clear_object (&inet_socket_address);
g_clear_object (&inet_address);
g_free (gvcp_address_string);
g_free (discovery_address_string);
gv_fake_camera->priv->gvcp_fds[0].fd = g_socket_get_fd (gv_fake_camera->priv->gvcp_socket);
gv_fake_camera->priv->gvcp_fds[0].events = G_IO_IN;
gv_fake_camera->priv->gvcp_fds[0].revents = 0;
if (gv_fake_camera->priv->discovery_socket != NULL) {
gv_fake_camera->priv->gvcp_fds[1].fd = g_socket_get_fd (gv_fake_camera->priv->discovery_socket);
gv_fake_camera->priv->gvcp_fds[1].events = G_IO_IN;
gv_fake_camera->priv->gvcp_fds[1].revents = 0;
gv_fake_camera->priv->n_gvcp_fds = 2;
} else
gv_fake_camera->priv->n_gvcp_fds = 1;
interface_found = TRUE;
}
}
freeifaddrs (ifap);
if (binding_error) {
g_clear_object (&gv_fake_camera->priv->gvcp_socket);
g_clear_object (&gv_fake_camera->priv->gvsp_socket);
g_clear_object (&gv_fake_camera->priv->discovery_socket);
return FALSE;
}
if (!interface_found) {
return FALSE;
}
gv_fake_camera->priv->cancel = FALSE;
gv_fake_camera->priv->thread = g_thread_new ("arv_fake_gv_fake_camera", _thread, gv_fake_camera);
return TRUE;
}
bool NetworkDevice::init() {
debugAssert(! initialized);
// Used for combining the MAC and ip information
typedef Table<std::string, EthernetAdapter> AdapterTable;
AdapterTable table;
// Head of a linked list of network interfaces on this machine
ifaddrs* ifap = NULL;
int r = getifaddrs(&ifap);
if (r != 0) {
logPrintf("ERROR: getifaddrs returned %d\n", r);
return false;
}
ifaddrs* current = ifap;
if (current == NULL) {
logPrintf("WARNING: No network interfaces found\n");
EthernetAdapter a;
a.name = "fallback";
a.hostname = "localhost";
a.ip = (127 << 24) | 1;
a.broadcast = 0xFFFFFFFF;
a.subnet = 0x000000FF;
addAdapter(a);
} else {
while (current != NULL) {
bool up = (current->ifa_flags & IFF_UP);
bool loopback = (current->ifa_flags & IFF_LOOPBACK);
if (! up || loopback) {
// Skip this adapter; it is offline or is a loopback
current = current->ifa_next;
continue;
}
if (! table.containsKey(current->ifa_name)) {
EthernetAdapter a;
a.name = current->ifa_name;
table.set(a.name, a);
}
// This adapter must exist because it was created above
EthernetAdapter& adapter = table[current->ifa_name];
const sockaddr_in* interfaceAddress = castToIP4(current->ifa_addr);
const sockaddr_in* broadcastAddress = castToIP4(current->ifa_dstaddr);
const sockaddr_in* subnetMask = castToIP4(current->ifa_netmask);
uint32 ip = getIP(interfaceAddress);
uint32 ba = getIP(broadcastAddress);
uint32 sn = getIP(subnetMask);
if (ip != 0) {
adapter.ip = ip;
}
if (ba != 0) {
adapter.broadcast = ba;
}
if (sn != 0) {
adapter.subnet = sn;
}
uint8_t* MAC = NULL;
// Extract MAC address
if ((current->ifa_addr != NULL) && (current->ifa_addr->sa_family == AF_LINK)) {
# ifdef __linux__
{
// Linux
struct ifreq ifr;
int fd = socket(AF_INET, SOCK_DGRAM, 0);
ifr.ifr_addr.sa_family = AF_INET;
strcpy(ifr.ifr_name, current->ifa_name);
ioctl(fd, SIOCGIFHWADDR, &ifr);
close(fd);
MAC = reinterpret_cast<uint8_t*>(ifr.ifr_hwaddr.sa_data);
}
# else
{
// The MAC address and the interfaceAddress come in as
// different interfaces with the same name.
// Posix/FreeBSD/Mac OS
sockaddr_dl* sdl = (struct sockaddr_dl *)current->ifa_addr;
MAC = reinterpret_cast<uint8_t*>(LLADDR(sdl));
}
# endif
// See if there was a MAC address
if (MAC != NULL) {
bool anyNonZero = false;
for (int i = 0; i < 6; ++i) {
anyNonZero = anyNonZero || (MAC[i] != 0);
}
if (anyNonZero) {
System::memcpy(adapter.mac, MAC, 6);
}
}
}
current = current->ifa_next;
}
freeifaddrs(ifap);
ifap = NULL;
}
// Extract all interesting adapters from the table
for (AdapterTable::Iterator it = table.begin(); it.hasMore(); ++it) {
const EthernetAdapter& adapter = it->value;
// Only add adapters that have IP addresses
if (adapter.ip != 0) {
addAdapter(adapter);
} else {
logPrintf("NetworkDevice: Ignored adapter %s because ip = 0\n", adapter.name.c_str());
}
}
initialized = true;
return true;
}
