int route_add(route_t *route, const struct route_entry *entry) { MIB_IPFORWARDROW ipfrow; struct addr net; memset(&ipfrow, 0, sizeof(ipfrow)); if (GetBestInterface(entry->route_gw.addr_ip, &ipfrow.dwForwardIfIndex) != NO_ERROR) return (-1); if (addr_net(&entry->route_dst, &net) < 0 || net.addr_type != ADDR_TYPE_IP) return (-1); ipfrow.dwForwardDest = net.addr_ip; addr_btom(entry->route_dst.addr_bits, &ipfrow.dwForwardMask, IP_ADDR_LEN); ipfrow.dwForwardNextHop = entry->route_gw.addr_ip; ipfrow.dwForwardType = 4; /* XXX - next hop != final dest */ ipfrow.dwForwardProto = 3; /* XXX - MIB_PROTO_NETMGMT */ if (CreateIpForwardEntry(&ipfrow) != NO_ERROR) return (-1); return (0); }
///////////////////////////////////////////////////////////////////////////////// // Initializes m_localIP variable, for future access to GetLocalIP() ///////////////////////////////////////////////////////////////////////////////// void MyUPnP::InitLocalIP() { #ifndef _DEBUG try #endif { DWORD best_if_index; GetBestInterface(inet_addr("223.255.255.255"), &best_if_index); PMIB_IPADDRTABLE ip_addr_table; char buffer[1024]; ip_addr_table = (PMIB_IPADDRTABLE)buffer; DWORD size = sizeof(buffer); GetIpAddrTable(ip_addr_table, &size, 0); DWORD local_ip = 0; for (DWORD i=0; i<ip_addr_table->dwNumEntries; i++) { if (ip_addr_table->table[i].dwIndex == best_if_index) { local_ip = ip_addr_table->table[i].dwAddr; break; } } if (local_ip) { struct in_addr addr; addr.S_un.S_addr = local_ip; m_slocalIP = inet_ntoa(addr); m_uLocalIP = local_ip; } else { char szHost[256]; if (gethostname(szHost, sizeof szHost) == 0){ hostent* pHostEnt = gethostbyname(szHost); if (pHostEnt != NULL && pHostEnt->h_length == 4 && pHostEnt->h_addr_list[0] != NULL){ UPNPNAT_MAPPING mapping; struct in_addr addr; memcpy(&addr, pHostEnt->h_addr_list[0], sizeof(struct in_addr)); m_slocalIP = inet_ntoa(addr); m_uLocalIP = addr.S_un.S_addr; } else{ m_slocalIP = _T(""); m_uLocalIP = 0; } } else{ m_slocalIP = _T(""); m_uLocalIP = 0; } } } #ifndef _DEBUG catch(...){ m_slocalIP = _T(""); m_uLocalIP = 0; } #endif }
/*! * @if jp * @brief 宛先アドレスから利用されるエンドポイントアドレスを得る * @else * @brief Getting network interface name from destination address * @endif */ bool dest_to_endpoint(std::string dest_addr, std::string& endpoint) { Winsock winsock; { struct hostent* hp; hp = ::gethostbyname(dest_addr.c_str()); if (hp == 0) { return false; } int i(0); while (hp->h_addr_list[i] != 0) { if(hp->h_addrtype == AF_INET) { struct sockaddr_in addr; memset((char*)&addr, 0, sizeof(addr)); memcpy((char*)&addr.sin_addr, hp->h_addr_list[i], hp->h_length); dest_addr = inet_ntoa(addr.sin_addr); break; } ++i; } } UINT ipaddress(inet_addr(dest_addr.c_str())); if (ipaddress == INADDR_NONE) { return false; } DWORD bestifindex; if (NO_ERROR != GetBestInterface(ipaddress, &bestifindex)) { return false; } PMIB_IPADDRTABLE ipaddr_table; ipaddr_table = (MIB_IPADDRTABLE *) MALLOC(sizeof (MIB_IPADDRTABLE)); if (ipaddr_table == 0) { return false; } // Make an initial call to GetIpAddrTable to get the // necessary size into the size variable DWORD size(0); if (GetIpAddrTable(ipaddr_table, &size, 0) == ERROR_INSUFFICIENT_BUFFER) { FREE(ipaddr_table); ipaddr_table = (MIB_IPADDRTABLE *) MALLOC(size); } if (ipaddr_table == 0) { return false; } if (GetIpAddrTable(ipaddr_table, &size, 0) != NO_ERROR) { return false; } for (int i(0); i < (int) ipaddr_table->dwNumEntries; ++i) { if (bestifindex == ipaddr_table->table[i].dwIndex) { IN_ADDR inipaddr; inipaddr.S_un.S_addr = (u_long) ipaddr_table->table[i].dwAddr; endpoint = inet_ntoa(inipaddr); return true; } } return false; }
void vmsTrafficUsageModeMgr::CheckIfBestInterfaceChanged () { vmsIpHelper iph; if (!iph.GetAdaptersInfo ()) return; DWORD dwIfIndex; if (NO_ERROR != GetBestInterface (inet_addr ("8.8.8.8"), &dwIfIndex)) return; PIP_ADAPTER_INFO pAdapter = iph.FindAdapterByIfIndex (dwIfIndex); if (!pAdapter) return; if (pAdapter->IpAddressList.IpAddress.String == m_strCurrentIP) return; if (!(m_dwState & TUMM_SPEEDS_INFO_CAN_BE_INCORRECT)) SaveCurrentAdapterInfo (); std::string strAdapterAddress; for (UINT i = 0; i < pAdapter->AddressLength; i++) { char sz [10]; itoa (pAdapter->Address [i], sz, 16); if (sz [1] == 0) strAdapterAddress += '0'; strAdapterAddress += sz; } m_strCurrentAdapterAddress = strAdapterAddress; m_strCurrentIP = pAdapter->IpAddressList.IpAddress.String; vmsAUTOLOCKSECTION (m_csMisc); m_dwState |= TUMM_SPEEDS_INFO_CAN_BE_INCORRECT; vmsAUTOLOCKSECTION_UNLOCK (m_csMisc); vmsAUTOLOCKSECTION (m_csManageForSpeed); for (size_t i = 0; i < m_vpManageForSpeed.size (); i++) { ManageForSpeedItemsList *pList = m_vpManageForSpeed [i]; for (size_t j = 0; j < pList->vItems.size (); j++) pList->vItems [j].state |= ManageForSpeedItem::MSIS_MAY_USE_NOT_CURRENT_ADAPTER; } vmsAUTOLOCKSECTION_UNLOCK (m_csManageForSpeed); ResetAllSpeedsInfo (); }
/** * Retrieve the MAC address of the system */ unsigned pixie_get_mac_address(unsigned char macaddr[6]) { memset(macaddr, 0, 6); #ifdef WIN32 { DWORD dwStatus; IP_ADAPTER_INFO *p; IP_ADAPTER_INFO AdapterInfo[16]; DWORD dwBufLen = sizeof(AdapterInfo); DWORD interface_index = -1; GetBestInterface(0x01010101, &interface_index); dwStatus = GetAdaptersInfo(AdapterInfo, &dwBufLen); if (dwStatus != ERROR_SUCCESS) return 1; for (p=AdapterInfo; p; p = p->Next) { if (p->Index == interface_index || interface_index == -1) { memcpy(macaddr, p->Address, 6); return 0; } /*( printf("[%02x:%02x:%02x:%02x:%02x:%02x]\n", mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5] ); printf(" %s\n", p->AdapterName); printf(" %s\n", p->Description); printf(" IP: "); for (a = &p->IpAddressList; a; a = a->Next) { printf("%s ", a->IpAddress.String); } printf("\n"); */ } } #else return -1; #endif return -1; }
// ---------------------------------------------------------------------------- // SnoopAutoDetectAdapter // ---------------------------------------------------------------------------- int SnoopAutoDetectAdapter::detect(QString& host) { IP ip; DWORD bestIfIndex; ip = htonl(VNet::resolve(host)); DWORD res = GetBestInterface(ip, &bestIfIndex); if (res != NO_ERROR) { LOG_FATAL("GetBestInterface return %d", res); return snoop::INVALID_ADAPTER_INDEX; } foreach (const SnoopInterface& intf, SnoopInterfaces::instance()) { if (intf.adapterInfo != NULL && intf.adapterInfo->Index == bestIfIndex) return intf.index; } LOG_FATAL("can not find appropriate adapter for %s", qPrintable(host)); return snoop::INVALID_ADAPTER_INDEX;; }
UINT MeasureNet::GetBestInterfaceOrByName(const WCHAR* iface) { if (c_Table == nullptr) return 0; if (_wcsicmp(iface, L"BEST") == 0) { DWORD dwBestIndex; if (NO_ERROR == GetBestInterface(INADDR_ANY, &dwBestIndex)) { MIB_IF_ROW2* table = (MIB_IF_ROW2*)c_Table->Table; for (size_t i = 0; i < c_NumOfTables; ++i) { if (table[i].InterfaceIndex == (NET_IFINDEX)dwBestIndex) { if (GetRainmeter().GetDebug()) { LogDebugF(this, L"Using network interface: Number=(%i), Name=\"%s\"", i + 1, table[i].Description); } return (UINT)(i + 1); } } } } else { MIB_IF_ROW2* table = (MIB_IF_ROW2*)c_Table->Table; for (size_t i = 0; i < c_NumOfTables; ++i) { if (_wcsicmp(iface, table[i].Description) == 0) { return (UINT)(i + 1); } } } LogErrorF(this, L"Cannot find interface: \"%s\"", iface); return 0; }
int intf_get_dst(intf_t *intf, struct intf_entry *entry, struct addr *dst) { MIB_IFROW ifrow; if (dst->addr_type != ADDR_TYPE_IP) { errno = EINVAL; return (-1); } if (GetBestInterface(dst->addr_ip, &ifrow.dwIndex) != NO_ERROR) return (-1); if (GetIfEntry(&ifrow) != NO_ERROR) return (-1); if (_refresh_tables(intf) < 0) return (-1); _ifrow_to_entry(intf, &ifrow, entry); return (0); }
UINT MeasureNet::GetBestInterfaceOrByName(const WCHAR* iface) { if (c_Table == nullptr) return 0; if (_wcsicmp(iface, L"BEST") == 0) { DWORD dwBestIndex; if (NO_ERROR == GetBestInterface(INADDR_ANY, &dwBestIndex)) { if (c_GetIfTable2) { MIB_IF_ROW2* table = (MIB_IF_ROW2*)((MIB_IF_TABLE2*)c_Table)->Table; for (size_t i = 0; i < c_NumOfTables; ++i) { if (table[i].InterfaceIndex == (NET_IFINDEX)dwBestIndex) { if (GetRainmeter().GetDebug()) { LogDebugF(this, L"Using network interface: Number=(%i), Name=\"%s\"", i + 1, table[i].Description); } return (i + 1); } } } else { MIB_IFROW* table = (MIB_IFROW*)((MIB_IFTABLE*)c_Table)->table; for (size_t i = 0; i < c_NumOfTables; ++i) { if (table[i].dwIndex == (NET_IFINDEX)dwBestIndex) { if (GetRainmeter().GetDebug()) { LogDebugF(this, L"Using network interface: Number=(%i), Name=\"%.*S\"", (int)i + 1, table[i].dwDescrLen, (char*)table[i].bDescr); } return (i + 1); } } } } } else { if (c_GetIfTable2) { MIB_IF_ROW2* table = (MIB_IF_ROW2*)((MIB_IF_TABLE2*)c_Table)->Table; for (size_t i = 0; i < c_NumOfTables; ++i) { if (_wcsicmp(iface, table[i].Description) == 0) { return (i + 1); } } } else { MIB_IFROW* table = (MIB_IFROW*)((MIB_IFTABLE*)c_Table)->table; for (size_t i = 0; i < c_NumOfTables; ++i) { if (_wcsicmp(iface, StringUtil::Widen((char*)table[i].bDescr).c_str()) == 0) { return (i + 1); } } } } LogErrorF(this, L"Cannot find interface: \"%s\"", iface); return 0; }
int eXosip_guess_ip_for_via (int family, char *address, int size) { /* w2000 and W95/98 */ unsigned long best_interface_index; DWORD hr; /* NT4 (sp4 only?) */ PMIB_IPFORWARDTABLE ipfwdt; DWORD siz_ipfwd_table = 0; unsigned int ipf_cnt; address[0] = '\0'; best_interface_index = -1; /* w2000 and W95/98 only */ hr = GetBestInterface(inet_addr("217.12.3.11"),&best_interface_index); if (hr) { LPVOID lpMsgBuf; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &lpMsgBuf, 0, NULL); OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO4, NULL, "GetBestInterface: %s\r\n", lpMsgBuf)); best_interface_index = -1; } if (best_interface_index != -1) { /* probably W2000 or W95/W98 */ char *servername; char *serverip; char *netmask; OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO4, NULL, "Default Interface found %i\r\n", best_interface_index)); if (0 == ppl_dns_get_local_fqdn(&servername, &serverip, &netmask, best_interface_index)) { osip_strncpy(address, serverip, size); osip_free(servername); osip_free(serverip); osip_free(netmask); return 0; } return -1; } if (!GetIpForwardTable(NULL, &siz_ipfwd_table, FALSE) == ERROR_INSUFFICIENT_BUFFER || !(ipfwdt = (PMIB_IPFORWARDTABLE) alloca (siz_ipfwd_table))) { OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO4, NULL, "Allocation error\r\n")); return -1; } /* NT4 (sp4 support only?) */ if (!GetIpForwardTable(ipfwdt, &siz_ipfwd_table, FALSE)) { for (ipf_cnt = 0; ipf_cnt < ipfwdt->dwNumEntries; ++ipf_cnt) { if (ipfwdt->table[ipf_cnt].dwForwardDest == 0) { /* default gateway found */ char *servername; char *serverip; char *netmask; OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO4, NULL, "Default Interface found %i\r\n", ipfwdt->table[ipf_cnt].dwForwardIfIndex)); if (0 == ppl_dns_get_local_fqdn(&servername, &serverip, &netmask, ipfwdt->table[ipf_cnt].dwForwardIfIndex)) { osip_strncpy(address, serverip, size); osip_free(servername); osip_free(serverip); osip_free(netmask); return 0; } return -1; } } } /* no default gateway interface found */ return -1; }
/** * @returns #GNUNET_OK on success, #GNUNET_SYSERR on error */ int EnumNICs3 (struct EnumNICs3_results **results, int *results_count) { DWORD dwRetVal = 0; int count = 0; ULONG flags = /*GAA_FLAG_INCLUDE_PREFIX |*/ GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER; struct sockaddr_in6 examplecom6; IPAddr examplecom; DWORD best_interface = 0; DWORD best_interface6 = 0; int use_enum2 = 0; INTERFACE_INFO *interfaces4 = NULL; int interfaces4_len = 0; SOCKET_ADDRESS_LIST *interfaces6 = NULL; unsigned long outBufLen = sizeof (IP_ADAPTER_ADDRESSES); IP_ADAPTER_ADDRESSES *pCurrentAddress = NULL; IP_ADAPTER_ADDRESSES *pAddresses = (IP_ADAPTER_ADDRESSES *) GNUNET_malloc (outBufLen); if (GetAdaptersAddresses (AF_UNSPEC, flags, NULL, pAddresses, &outBufLen) == ERROR_BUFFER_OVERFLOW) { GNUNET_free (pAddresses); pAddresses = (IP_ADAPTER_ADDRESSES *) GNUNET_malloc (outBufLen); } dwRetVal = GetAdaptersAddresses (AF_UNSPEC, flags, NULL, pAddresses, &outBufLen); if (dwRetVal != NO_ERROR) { GNUNET_free (pAddresses); return GNUNET_SYSERR; } if (pAddresses->Length < sizeof (IP_ADAPTER_ADDRESSES_VISTA)) { use_enum2 = 1; /* Enumerate NICs using WSAIoctl() */ if (GNUNET_OK != EnumNICs2 (&interfaces4, &interfaces4_len, &interfaces6)) { GNUNET_free (pAddresses); return GNUNET_SYSERR; } } examplecom = inet_addr("192.0.34.166"); /* www.example.com */ if (GetBestInterface (examplecom, &best_interface) != NO_ERROR) best_interface = 0; if (GNGetBestInterfaceEx != NULL) { examplecom6.sin6_family = AF_INET6; examplecom6.sin6_port = 0; examplecom6.sin6_flowinfo = 0; examplecom6.sin6_scope_id = 0; inet_pton (AF_INET6, "2001:500:88:200:0:0:0:10", (struct sockaddr *) &examplecom6.sin6_addr); dwRetVal = GNGetBestInterfaceEx ((struct sockaddr *) &examplecom6, &best_interface6); if (dwRetVal != NO_ERROR) best_interface6 = 0; } /* Give IPv6 a priority */ if (best_interface6 != 0) best_interface = best_interface6; count = 0; for (pCurrentAddress = pAddresses; pCurrentAddress != NULL; pCurrentAddress = pCurrentAddress->Next) { if (pCurrentAddress->OperStatus == IfOperStatusUp) { IP_ADAPTER_UNICAST_ADDRESS *unicast = NULL; for (unicast = pCurrentAddress->FirstUnicastAddress; unicast != NULL; unicast = unicast->Next) { if ((unicast->Address.lpSockaddr->sa_family == AF_INET || unicast->Address.lpSockaddr->sa_family == AF_INET6) && (unicast->DadState == IpDadStateDeprecated || unicast->DadState == IpDadStatePreferred)) count += 1; } } } if (count == 0) { *results = NULL; *results_count = 0; GNUNET_free (pAddresses); GNUNET_free_non_null (interfaces4); GNUNET_free_non_null (interfaces6); return GNUNET_OK; } *results = (struct EnumNICs3_results *) GNUNET_malloc ( sizeof (struct EnumNICs3_results) * count); *results_count = count; count = 0; for (pCurrentAddress = pAddresses; pCurrentAddress != NULL; pCurrentAddress = pCurrentAddress->Next) { struct EnumNICs3_results *r; IP_ADAPTER_UNICAST_ADDRESS *unicast = NULL; if (pCurrentAddress->OperStatus != IfOperStatusUp) continue; for (unicast = pCurrentAddress->FirstUnicastAddress; unicast != NULL; unicast = unicast->Next) { int i, j; int mask_length = -1; char dst[INET6_ADDRSTRLEN + 1]; if ((unicast->Address.lpSockaddr->sa_family != AF_INET && unicast->Address.lpSockaddr->sa_family != AF_INET6) || (unicast->DadState != IpDadStateDeprecated && unicast->DadState != IpDadStatePreferred)) continue; r = &(*results)[count]; r->flags = 0; if (pCurrentAddress->IfIndex > 0 && pCurrentAddress->IfIndex == best_interface && unicast->Address.lpSockaddr->sa_family == AF_INET) r->is_default = 1; else if (pCurrentAddress->Ipv6IfIndex > 0 && pCurrentAddress->Ipv6IfIndex == best_interface6 && unicast->Address.lpSockaddr->sa_family == AF_INET6) r->is_default = 1; else r->is_default = 0; /* Don't choose default interface twice */ if (r->is_default) best_interface = best_interface6 = 0; if (!use_enum2) { memcpy (&r->address, unicast->Address.lpSockaddr, unicast->Address.iSockaddrLength); memset (&r->mask, 0, sizeof (struct sockaddr)); mask_length = ((IP_ADAPTER_UNICAST_ADDRESS_VISTA *) unicast)-> OnLinkPrefixLength; /* OnLinkPrefixLength is the number of leading 1s in the mask. * OnLinkPrefixLength is available on Vista and later (hence use_enum2). */ if (unicast->Address.lpSockaddr->sa_family == AF_INET) { struct sockaddr_in *m = (struct sockaddr_in *) &r->mask; for (i = 0; i < mask_length; i++) ((unsigned char *) &m->sin_addr)[i / 8] |= 0x80 >> (i % 8); } else if (unicast->Address.lpSockaddr->sa_family == AF_INET6) { struct sockaddr_in6 *m = (struct sockaddr_in6 *) &r->mask; struct sockaddr_in6 *b = (struct sockaddr_in6 *) &r->broadcast; for (i = 0; i < mask_length; i++) ((unsigned char *) &m->sin6_addr)[i / 8] |= 0x80 >> (i % 8); memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength); for (i = mask_length; i < 128; i++) ((unsigned char *) &b->sin6_addr)[i / 8] |= 0x80 >> (i % 8); } r->flags |= ENUMNICS3_MASK_OK; } else {
bool NetworkObserver::canConnect() { #if defined(WIN32) /* w2000 and W95/98 */ unsigned long best_interface_index; DWORD hr; /* NT4 (sp4 only?) */ PMIB_IPFORWARDTABLE ipfwdt; DWORD siz_ipfwd_table = 0; unsigned int ipf_cnt; best_interface_index = -1; /* w2000 and W95/98 only */ hr = GetBestInterface(inet_addr("216.151.151.59"),&best_interface_index); // VOXOX -ASV- 07-09-2009: we ping voxox.com to know if voxox has internet if (hr) { LPVOID lpMsgBuf; FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, hr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &lpMsgBuf, 0, NULL); best_interface_index = -1; } if (best_interface_index != -1) { /* probably W2000 or W95/W98 */ char *servername; char *serverip; char *netmask; if (ppl_dns_get_local_fqdn(&servername, &serverip, &netmask, best_interface_index)) { /*if(servername) delete servername; if(serverip) delete serverip; if(netmask) delete netmask;*/ return true; } return false; } if (!GetIpForwardTable(NULL, &siz_ipfwd_table, FALSE) == ERROR_INSUFFICIENT_BUFFER || !(ipfwdt = (PMIB_IPFORWARDTABLE) alloca (siz_ipfwd_table))) { return false; } /* NT4 (sp4 support only?) */ if (!GetIpForwardTable(ipfwdt, &siz_ipfwd_table, FALSE)) { for (ipf_cnt = 0; ipf_cnt < ipfwdt->dwNumEntries; ++ipf_cnt) { if (ipfwdt->table[ipf_cnt].dwForwardDest == 0) { /* default gateway found */ char *servername; char *serverip; char *netmask; if (ppl_dns_get_local_fqdn(&servername, &serverip, &netmask, ipfwdt->table[ipf_cnt].dwForwardIfIndex)) { delete servername; delete serverip; delete netmask; return true; } return false; } } } /* no default gateway interface found */ return true; #else #if defined(OS_MACOSX) socklen_t len; #else unsigned int len; #endif int sock_rt, on=1; struct sockaddr_in iface_out; struct sockaddr_in remote; memset(&remote, 0, sizeof(struct sockaddr_in)); remote.sin_family = AF_INET; remote.sin_addr.s_addr = inet_addr("216.151.151.59");// VOXOX -ASV- 07-09-2009: we ping voxox.com to know if voxox has internet remote.sin_port = htons(80); memset(&iface_out, 0, sizeof(iface_out)); sock_rt = socket(AF_INET, SOCK_DGRAM, 0 ); if (setsockopt(sock_rt, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) == -1) { close(sock_rt); return false; } if (::connect(sock_rt, (struct sockaddr*)&remote, sizeof(struct sockaddr_in)) == -1 ) { close(sock_rt); return false; } len = sizeof(iface_out); if (getsockname(sock_rt, (struct sockaddr *)&iface_out, &len) == -1 ) { close(sock_rt); return false; } close(sock_rt); if (iface_out.sin_addr.s_addr == 0) { /* what is this case?? */ return false; } return true; #endif }
IPCCommandResult NetIPTop::HandleGetInterfaceOptRequest(const IOCtlVRequest& request) { const u32 param = Memory::Read_U32(request.in_vectors[0].address); const u32 param2 = Memory::Read_U32(request.in_vectors[0].address + 4); const u32 param3 = Memory::Read_U32(request.io_vectors[0].address); const u32 param4 = Memory::Read_U32(request.io_vectors[1].address); u32 param5 = 0; if (request.io_vectors[0].size >= 8) { param5 = Memory::Read_U32(request.io_vectors[0].address + 4); } INFO_LOG(IOS_NET, "IOCTLV_SO_GETINTERFACEOPT(%08X, %08X, %X, %X, %X) " "BufferIn: (%08x, %i), BufferIn2: (%08x, %i) ", param, param2, param3, param4, param5, request.in_vectors[0].address, request.in_vectors[0].size, request.in_vectors.size() > 1 ? request.in_vectors[1].address : 0, request.in_vectors.size() > 1 ? request.in_vectors[1].size : 0); switch (param2) { case 0xb003: // dns server table { u32 address = 0; #ifdef _WIN32 if (!Core::WantsDeterminism()) { PIP_ADAPTER_ADDRESSES AdapterAddresses = nullptr; ULONG OutBufferLength = 0; ULONG RetVal = 0, i; for (i = 0; i < 5; ++i) { RetVal = GetAdaptersAddresses(AF_INET, 0, nullptr, AdapterAddresses, &OutBufferLength); if (RetVal != ERROR_BUFFER_OVERFLOW) { break; } if (AdapterAddresses != nullptr) { FREE(AdapterAddresses); } AdapterAddresses = (PIP_ADAPTER_ADDRESSES)MALLOC(OutBufferLength); if (AdapterAddresses == nullptr) { RetVal = GetLastError(); break; } } if (RetVal == NO_ERROR) { unsigned long dwBestIfIndex = 0; IPAddr dwDestAddr = (IPAddr)0x08080808; // If successful, output some information from the data we received PIP_ADAPTER_ADDRESSES AdapterList = AdapterAddresses; if (GetBestInterface(dwDestAddr, &dwBestIfIndex) == NO_ERROR) { while (AdapterList) { if (AdapterList->IfIndex == dwBestIfIndex && AdapterList->FirstDnsServerAddress && AdapterList->OperStatus == IfOperStatusUp) { INFO_LOG(IOS_NET, "Name of valid interface: %S", AdapterList->FriendlyName); INFO_LOG( IOS_NET, "DNS: %u.%u.%u.%u", (unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2], (unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[3], (unsigned char)AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[4], (unsigned char) AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[5]); address = Common::swap32( *(u32*)(&AdapterList->FirstDnsServerAddress->Address.lpSockaddr->sa_data[2])); break; } AdapterList = AdapterList->Next; } } } if (AdapterAddresses != nullptr) { FREE(AdapterAddresses); } } #endif if (address == 0) address = 0x08080808; Memory::Write_U32(address, request.io_vectors[0].address); Memory::Write_U32(0x08080404, request.io_vectors[0].address + 4); break; } case 0x1003: // error Memory::Write_U32(0, request.io_vectors[0].address); break; case 0x1004: // mac address u8 address[Common::MAC_ADDRESS_SIZE]; IOS::Net::GetMACAddress(address); Memory::CopyToEmu(request.io_vectors[0].address, address, sizeof(address)); break; case 0x1005: // link state Memory::Write_U32(1, request.io_vectors[0].address); break; case 0x3001: // hardcoded value Memory::Write_U32(0x10, request.io_vectors[0].address); break; case 0x4002: // ip addr numberHandle Memory::Write_U32(1, request.io_vectors[0].address); break; case 0x4003: // ip addr table Memory::Write_U32(0xC, request.io_vectors[1].address); Memory::Write_U32(inet_addr(10, 0, 1, 30), request.io_vectors[0].address); Memory::Write_U32(inet_addr(255, 255, 255, 0), request.io_vectors[0].address + 4); Memory::Write_U32(inet_addr(10, 0, 255, 255), request.io_vectors[0].address + 8); break; case 0x4005: // hardcoded value Memory::Write_U32(0x20, request.io_vectors[0].address); break; case 0x6003: // hardcoded value Memory::Write_U32(0x80, request.io_vectors[0].address); break; case 0x600a: // hardcoded value Memory::Write_U32(0x80, request.io_vectors[0].address); break; case 0x600c: // hardcoded value Memory::Write_U32(0x80, request.io_vectors[0].address); break; case 0xb002: // hardcoded value Memory::Write_U32(2, request.io_vectors[0].address); break; default: ERROR_LOG(IOS_NET, "Unknown param2: %08X", param2); break; } return GetDefaultReply(0); }