int mupnp_net_gethostinterfaces(mUpnpNetworkInterfaceList* netIfList) { mupnp_log_debug_l4("Entering...\n"); mUpnpNetworkInterface* netIf; struct hostent hostEnt; B buf[HBUFLEN]; ERR err; char* ifname = MUPNP_NET_DEFAULT_IFNAME; char ifaddr[32]; mupnp_net_interfacelist_clear(netIfList); err = so_gethostbyname("localhost", &hostEnt, buf); if (err != 0) return 0; inet_ntop(hostEnt.h_addrtype, hostEnt.h_addr, ifaddr, sizeof(ifname)); netIf = mupnp_net_interface_new(); mupnp_net_interface_setname(netIf, ifname); mupnp_net_interface_setaddress(netIf, ifaddr); mupnp_net_interfacelist_add(netIfList, netIf); mupnp_log_debug_l4("Leaving...\n"); return mupnp_net_interfacelist_size(netIfList); }
bool mupnp_upnpav_dms_updatenetworkinterfaces(mUpnpAvServer *dms) { mupnp_upnpav_dms_lock(dms); mupnp_net_interfacelist_clear(dms->networkInterfaceList); mupnp_net_gethostinterfaces(dms->networkInterfaceList); mupnp_upnpav_dms_unlock(dms); return (0 < mupnp_net_interfacelist_size(dms->networkInterfaceList)) ? true : false; }
int mupnp_net_gethostinterfaces(mUpnpNetworkInterfaceList* netIfList) { mupnp_log_debug_l4("Entering...\n"); mUpnpNetworkInterface* netIf; FILE* fd; int s; char buffer[256 + 1]; char ifaddr[20 + 1]; char* ifname; char* sep; mupnp_net_interfacelist_clear(netIfList); s = socket(AF_INET, SOCK_DGRAM, 0); if (s < 0) return 0; fd = fopen(PATH_PROC_NET_DEV, "r"); fgets(buffer, sizeof(buffer) - 1, fd); fgets(buffer, sizeof(buffer) - 1, fd); while (!feof(fd)) { ifname = buffer; sep; if (fgets(buffer, sizeof(buffer) - 1, fd) == NULL) break; sep = strrchr(buffer, ':'); if (sep) *sep = 0; while (*ifname == ' ') ifname++; struct ifreq req; strcpy(req.ifr_name, ifname); if (ioctl(s, SIOCGIFFLAGS, &req) < 0) continue; if (!(req.ifr_flags & IFF_UP)) continue; if (req.ifr_flags & IFF_LOOPBACK) continue; if (ioctl(s, SIOCGIFADDR, &req) < 0) continue; strncpy(ifaddr, inet_ntoa(((struct sockaddr_in*)&req.ifr_addr)->sin_addr), sizeof(ifaddr) - 1); netIf = mupnp_net_interface_new(); mupnp_net_interface_setname(netIf, ifname); mupnp_net_interface_setaddress(netIf, ifaddr); mupnp_net_interfacelist_add(netIfList, netIf); mupnp_log_debug("Interface name: %s, address: %s\n", ifname, ifaddr); //cout << ifname << ", " << ifaddr << endl; } fclose(fd); close(s); return mupnp_net_interfacelist_size(netIfList); mupnp_log_debug_l4("Leaving...\n"); }
int mupnp_net_gethostinterfaces(mUpnpNetworkInterfaceList* netIfList) { #if !defined(MUPNP_USE_WIN32_GETHOSTADDRESSES) && !defined(MUPNP_USE_WIN32_GETADAPTERSINFO) mUpnpNetworkInterface* netIf; SOCKET sd; int nNumInterfaces; INTERFACE_INFO InterfaceList[20]; unsigned long nBytesReturned, *pnBytesReturned = &nBytesReturned; struct sockaddr_in* pAddress; struct sockaddr_in* pNetmask; char* host; char* netmask; u_long nFlags; int i; mupnp_socket_startup(); mupnp_net_interfacelist_clear(netIfList); sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0); //Theo Beisch WINSOCK2API WSASocket will return INVALID_SOCKET on error, not SOCKET_ERROR if (sd == INVALID_SOCKET) { return 0; } if (WSAIoctl(sd, SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList, sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR) return 0; nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO); for (i = 0; i < nNumInterfaces; ++i) { nFlags = InterfaceList[i].iiFlags; //if (CyberNet::HostInterface::USE_ONLY_IPV4_ADDR == false) { if (nFlags & IFF_LOOPBACK) continue; //} if (!(nFlags & IFF_UP)) continue; //if (IsUseAddress(host) == false) // continue; netIf = mupnp_net_interface_new(); pAddress = (struct sockaddr_in*)&(InterfaceList[i].iiAddress); host = inet_ntoa(pAddress->sin_addr); mupnp_net_interface_setaddress(netIf, host); pNetmask = (struct sockaddr_in*)&(InterfaceList[i].iiNetmask); netmask = inet_ntoa(pNetmask->sin_addr); mupnp_net_interface_setnetmask(netIf, netmask); mupnp_net_interfacelist_add(netIfList, netIf); } #elif defined(MUPNP_USE_WIN32_GETADAPTERSINFO) #pragma comment(lib, "Iphlpapi.lib") mUpnpNetworkInterface* netIf; PIP_ADAPTER_INFO pAdapterInfo = NULL, pAdapter = NULL; ULONG ulOutBufLen; DWORD dwRetVal; DWORD nOfInterfaces; mupnp_socket_startup(); mupnp_net_interfacelist_clear(netIfList); ulOutBufLen = sizeof(IP_ADAPTER_INFO); pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen); if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) { free(pAdapterInfo); pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen); } if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) { for (pAdapter = pAdapterInfo, nOfInterfaces = 0; pAdapter; pAdapter = pAdapter->Next, ++nOfInterfaces) { if (pAdapter->Type == MIB_IF_TYPE_LOOPBACK) continue; if (mupnp_streq(pAdapter->IpAddressList.IpAddress.String, "0.0.0.0")) continue; netIf = mupnp_net_interface_new(); mupnp_net_interface_setaddress(netIf, pAdapter->IpAddressList.IpAddress.String); mupnp_net_interface_setnetmask(netIf, pAdapter->IpAddressList.IpMask.String); if (pAdapter->AddressLength == MUPNP_NET_MACADDR_SIZE) mupnp_net_interface_setmacaddress(netIf, pAdapter->Address); mupnp_net_interfacelist_add(netIfList, netIf); } } free(pAdapterInfo); #elif defined(MUPNP_USE_WIN32_GETHOSTADDRESSES) #pragma comment(lib, "Iphlpapi.lib") IP_ADAPTER_ADDRESSES *pAdapterAddresses, *ai; DWORD ifFlags; ULONG outBufLen; IP_ADAPTER_UNICAST_ADDRESS* uai; SOCKET_ADDRESS sockaddr; SOCKADDR* saddr; INT saddrlen; char addr[NI_MAXHOST]; char port[NI_MAXSERV]; int namInfoRet; int ifIdx; mUpnpNetworkInterface* netIf; mupnp_socket_startup(); mupnp_net_interfacelist_clear(netIfList); outBufLen = 0; ifFlags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_FRIENDLY_NAME | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER; GetAdaptersAddresses(AF_UNSPEC, ifFlags, NULL, NULL, &outBufLen); pAdapterAddresses = (IP_ADAPTER_ADDRESSES*)LocalAlloc(LMEM_ZEROINIT, outBufLen); GetAdaptersAddresses(AF_UNSPEC, ifFlags, NULL, pAdapterAddresses, &outBufLen); ai = pAdapterAddresses; while (ai != NULL) { if (ai->OperStatus != IfOperStatusUp) { ai = ai->Next; continue; } if (ai->IfType == IF_TYPE_SOFTWARE_LOOPBACK) { ai = ai->Next; continue; } if (ai->IfType == IF_TYPE_TUNNEL) { ai = ai->Next; continue; } uai = ai->FirstUnicastAddress; while (uai != NULL) { sockaddr = uai->Address; saddr = sockaddr.lpSockaddr; saddrlen = sockaddr.iSockaddrLength; namInfoRet = getnameinfo(saddr, saddrlen, addr, sizeof(addr), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV); if (namInfoRet == 0) { //if (IsUseAddress(addr) == true) { ifIdx = 0; if (mupnp_net_isipv6address(addr) == true) ifIdx = mupnp_net_getipv6scopeid(addr); netIf = mupnp_net_interface_new(); mupnp_net_interface_setaddress(netIf, addr); if (ai->PhysicalAddressLength == MUPNP_NET_MACADDR_SIZE) mupnp_net_interface_setmacaddress(netIf, ai->PhysicalAddress); mupnp_net_interface_setindex(netIf, ifIdx); mupnp_net_interfacelist_add(netIfList, netIf); //} } else { int err = WSAGetLastError(); } uai = uai->Next; } ai = ai->Next; } LocalFree(pAdapterAddresses); #endif return mupnp_net_interfacelist_size(netIfList); }
int mupnp_net_gethostinterfaces(mUpnpNetworkInterfaceList* netIfList) { mUpnpNetworkInterface* netIf; struct ifaddrs* ifaddr; char addr[NI_MAXHOST + 1]; char netmask[NI_MAXHOST + 1]; char* ifname; struct ifaddrs* i; #if defined(HAVE_SOCKADDR_DL) struct sockaddr_dl* dladdr; #elif defined(HAVE_SIOCGIFHWADDR) int sock; struct ifreq ifr; #endif mupnp_log_debug_l4("Entering...\n"); mupnp_net_interfacelist_clear(netIfList); if (getifaddrs(&ifaddr) != 0) { mupnp_log_debug("No addresses for interfaces!\n"); return 0; } for (i = ifaddr; i != NULL; i = i->ifa_next) { // Thanks for Ricardo Rivldo (04/10/12) // - for some reason, vmware and virtualbox \"virtual\" interfaces does not return ifa_addr if (i->ifa_addr == NULL || i->ifa_netmask == NULL) continue; // Thanks for Tobias.Gansen (01/15/06) if (i->ifa_addr->sa_family != AF_INET) continue; if (!(i->ifa_flags & IFF_UP)) continue; if (i->ifa_flags & IFF_LOOPBACK) continue; if (getnameinfo(i->ifa_addr, sizeof(struct sockaddr), addr, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0) continue; if (getnameinfo(i->ifa_netmask, sizeof(struct sockaddr), netmask, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0) continue; ifname = i->ifa_name; mupnp_log_debug("Interface name: %s, address: %s\n", ifname, addr); netIf = mupnp_net_interface_new(); mupnp_net_interface_setname(netIf, ifname); mupnp_net_interface_setaddress(netIf, addr); mupnp_net_interface_setnetmask(netIf, netmask); #if defined(HAVE_SOCKADDR_DL) dladdr = (struct sockaddr_dl*)(i->ifa_addr); mupnp_net_interface_setmacaddress(netIf, LLADDR(dladdr)); #elif defined(HAVE_SIOCGIFHWADDR) sock = socket(AF_INET, SOCK_DGRAM, 0); strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1); ifr.ifr_addr.sa_family = AF_INET; ioctl(sock, SIOCGIFHWADDR, &ifr); mupnp_net_interface_setmacaddress(netIf, ifr.ifr_hwaddr.sa_data); close(sock); #endif mupnp_net_interfacelist_add(netIfList, netIf); } freeifaddrs(ifaddr); mupnp_log_debug_l4("Leaving...\n"); return mupnp_net_interfacelist_size(netIfList); }
int mupnp_net_gethostinterfaces(mUpnpNetworkInterfaceList* netIfList) { mUpnpNetworkInterface* netIf; //iphelper API vars PIP_ADAPTER_INFO pAdapterInfo = NULL, pAdapter = NULL; ULONG ulOutBufLen; DWORD dwRetVal; DWORD nOfInterfaces; int i = 0; //mupnp_socket_startup(); mupnp_net_interfacelist_clear(netIfList); // new code to determine interfaces available //try with default for single adapter ulOutBufLen = sizeof(IP_ADAPTER_INFO); pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen); if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) { free(pAdapterInfo); pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen); } if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) { for (pAdapter = pAdapterInfo, nOfInterfaces = 0; pAdapter; ++nOfInterfaces) { #if defined(DEBUG) printf("IF Name:%s\n", pAdapter->AdapterName); printf("IF Desc:%s\n", pAdapter->Description); printf("IF Addr:%ld\n", pAdapter->Address); printf("IF Type:%d\n", pAdapter->Type); printf("IF Address:%s\n", pAdapter->IpAddressList.IpAddress.String); printf("IF Mask:%s\n", pAdapter->IpAddressList.IpMask.String); printf("IF Gateway:%s\n", pAdapter->GatewayList.IpAddress.String); #endif /* if (pAdapter->DhcpEnabled) { printf("\tDHCP Enabled: Yes\n"); printf("\t\tDHCP Server: \t%s\n", pAdapter->DhcpServer.IpAddress.String); printf("\tLease Obtained: %ld\n", pAdapter->LeaseObtained); } else printf("\tDHCP Enabled: No\n"); if (pAdapter->HaveWins) { printf("\tHave Wins: Yes\n"); printf("\t\tPrimary Wins Server: \t%s\n", pAdapter->PrimaryWinsServer.IpAddress.String); printf("\t\tSecondary Wins Server: \t%s\n", pAdapter->SecondaryWinsServer.IpAddress.String); } else printf("\tHave Wins: No\n"); */ // now add adapter to list if (pAdapter->Type == MIB_IF_TYPE_ETHERNET) { // List will not contain loopback // IFF_UP check not required, ce only returns UP interfaces here //host = inet_ntoa(pAdapter->Address); netIf = mupnp_net_interface_new(); mupnp_net_interface_setaddress(netIf, pAdapter->IpAddressList.IpAddress.String); mupnp_net_interface_setmacaddress(netIf, pAdapter->IpAddressList.Address.String); mupnp_net_interfacelist_add(netIfList, netIf); } pAdapter = pAdapter->Next; } #if defined(DEBUG) printf("* %d Adapters found\n", nOfInterfaces); printf(" %d usable\n", mupnp_net_interfacelist_size(netIfList)); #endif } free(pAdapterInfo); i = mupnp_net_interfacelist_size(netIfList); if (i == 0) { printf("* no Adapters found - try at least localhost\n"); netIf = mupnp_net_interface_new(); mupnp_net_interface_setaddress(netIf, MUPNP_NET_IPV4_LOOPBACK); mupnp_net_interfacelist_add(netIfList, netIf); } return mupnp_net_interfacelist_size(netIfList); }