void tst_QNetworkAddressEntry::prefixAndNetmask()
{
QFETCH(QHostAddress, ip);
QFETCH(QHostAddress, netmask);
QFETCH(int, prefix);
QNetworkAddressEntry entry;
// first, without setting the IP, all must be invalid:
entry.setNetmask(netmask);
QVERIFY(entry.netmask().isNull());
entry.setPrefixLength(prefix);
QCOMPARE(entry.prefixLength(), -1);
// set the IP:
entry.setIp(ip);
// set the netmask:
if (!netmask.isNull()) {
entry.setNetmask(netmask);
// was it a valid one?
if (prefix != -1) {
QVERIFY(!entry.netmask().isNull());
QCOMPARE(entry.netmask(), netmask);
QCOMPARE(entry.prefixLength(), prefix);
} else {
// not valid
QVERIFY(entry.netmask().isNull());
QCOMPARE(entry.prefixLength(), -1);
}
}
entry.setNetmask(QHostAddress());
QVERIFY(entry.netmask().isNull());
QCOMPARE(entry.prefixLength(), -1);
// set the prefix
if (prefix != -1) {
entry.setPrefixLength(prefix);
// was it a valid one?
if (!netmask.isNull()) {
QVERIFY(!entry.netmask().isNull());
QCOMPARE(entry.netmask(), netmask);
QCOMPARE(entry.prefixLength(), prefix);
} else {
// not valid
QVERIFY(entry.netmask().isNull());
QCOMPARE(entry.prefixLength(), -1);
}
}
entry.setPrefixLength(-1);
QVERIFY(entry.netmask().isNull());
QCOMPARE(entry.prefixLength(), -1);
}
static QList<QNetworkInterfacePrivate *> interfaceListing()
{
TInt err(KErrNone);
QList<QNetworkInterfacePrivate *> interfaces;
QList<QHostAddress> addressesWithEstimatedNetmasks;
// Open dummy socket for interface queries
RSocket socket;
err = socket.Open(qt_symbianGetSocketServer(), _L("udp"));
if (err) {
return interfaces;
}
// Ask socket to start enumerating interfaces
err = socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);
if (err) {
socket.Close();
return interfaces;
}
int ifindex = 0;
TPckgBuf<TSoInetInterfaceInfo> infoPckg;
TSoInetInterfaceInfo &info = infoPckg();
while (socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, infoPckg) == KErrNone) {
if (info.iName != KNullDesC) {
TName address;
QNetworkAddressEntry entry;
QNetworkInterfacePrivate *iface = 0;
iface = new QNetworkInterfacePrivate;
iface->index = ifindex++;
interfaces << iface;
iface->name = qt_TDesC2QString(info.iName);
iface->flags = convertFlags(info);
if (/*info.iFeatures&KIfHasHardwareAddr &&*/ info.iHwAddr.Family() != KAFUnspec) {
for (TInt i = sizeof(SSockAddr); i < sizeof(SSockAddr) + info.iHwAddr.GetUserLen(); i++) {
address.AppendNumFixedWidth(info.iHwAddr[i], EHex, 2);
if ((i + 1) < sizeof(SSockAddr) + info.iHwAddr.GetUserLen())
address.Append(_L(":"));
}
address.UpperCase();
iface->hardwareAddress = qt_TDesC2QString(address);
}
// Get the address of the interface
entry.setIp(qt_QHostAddressFromTInetAddr(info.iAddress));
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "address is" << info.iAddress.Family() << entry.ip();
qDebug() << "netmask is" << info.iNetMask.Family() << qt_QHostAddressFromTInetAddr( info.iNetMask );
#endif
// Get the interface netmask
if (info.iNetMask.IsUnspecified()) {
// For some reason netmask is always 0.0.0.0 for IPv4 interfaces
// and loopback interfaces (which we statically know)
if (info.iAddress.IsV4Mapped()) {
if (info.iFeatures & KIfIsLoopback) {
entry.setPrefixLength(32);
} else {
// Workaround: Let Symbian determine netmask based on IP address class (IPv4 only API)
TInetAddr netmask;
netmask.NetMask(info.iAddress);
entry.setNetmask(QHostAddress(netmask.Address())); //binary convert v4 address
addressesWithEstimatedNetmasks << entry.ip();
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "address class determined netmask" << entry.netmask();
#endif
}
} else {
// For IPv6 interfaces
if (info.iFeatures & KIfIsLoopback) {
entry.setPrefixLength(128);
} else if (info.iNetMask.IsUnspecified()) {
//Don't see this error for IPv6, but try to handle it if it happens
entry.setPrefixLength(64); //most common
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "total guess netmask" << entry.netmask();
#endif
addressesWithEstimatedNetmasks << entry.ip();
}
}
} else {
//Expected code path for IPv6 non loopback interfaces (IPv4 could come here if symbian is fixed)
entry.setNetmask(qt_QHostAddressFromTInetAddr(info.iNetMask));
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug() << "reported netmask" << entry.netmask();
#endif
}
// broadcast address is determined from the netmask in postProcess()
// Add new entry to interface address entries
iface->addressEntries << entry;
#if defined(QNETWORKINTERFACE_DEBUG)
qDebug("\n Found network interface %s, interface flags:\n\
IsUp = %d, IsRunning = %d, CanBroadcast = %d,\n\
IsLoopBack = %d, IsPointToPoint = %d, CanMulticast = %d, \n\
ip = %s, netmask = %s, broadcast = %s,\n\
hwaddress = %s",
iface->name.toLatin1().constData(),
iface->flags & QNetworkInterface::IsUp, iface->flags & QNetworkInterface::IsRunning, iface->flags & QNetworkInterface::CanBroadcast,
iface->flags & QNetworkInterface::IsLoopBack, iface->flags & QNetworkInterface::IsPointToPoint, iface->flags & QNetworkInterface::CanMulticast,
entry.ip().toString().toLatin1().constData(), entry.netmask().toString().toLatin1().constData(), entry.broadcast().toString().toLatin1().constData(),
iface->hardwareAddress.toLatin1().constData());
#endif
}
}
static QList<QNetworkInterfacePrivate *> interfaceListingWinXP()
{
QList<QNetworkInterfacePrivate *> interfaces;
IP_ADAPTER_ADDRESSES staticBuf[2]; // 2 is arbitrary
PIP_ADAPTER_ADDRESSES pAdapter = staticBuf;
ULONG bufSize = sizeof staticBuf;
const QHash<QHostAddress, QHostAddress> &ipv4netmasks = ipv4Netmasks();
ULONG flags = GAA_FLAG_INCLUDE_PREFIX |
GAA_FLAG_SKIP_DNS_SERVER |
GAA_FLAG_SKIP_MULTICAST;
ULONG retval = ptrGetAdaptersAddresses(AF_UNSPEC, flags, NULL, pAdapter, &bufSize);
if (retval == ERROR_BUFFER_OVERFLOW) {
// need more memory
pAdapter = (IP_ADAPTER_ADDRESSES *)malloc(bufSize);
if (!pAdapter)
return interfaces;
// try again
if (ptrGetAdaptersAddresses(AF_UNSPEC, flags, NULL, pAdapter, &bufSize) != ERROR_SUCCESS) {
free(pAdapter);
return interfaces;
}
} else if (retval != ERROR_SUCCESS) {
// error
return interfaces;
}
// iterate over the list and add the entries to our listing
for (PIP_ADAPTER_ADDRESSES ptr = pAdapter; ptr; ptr = ptr->Next) {
QNetworkInterfacePrivate *iface = new QNetworkInterfacePrivate;
interfaces << iface;
iface->index = 0;
if (ptr->Length >= offsetof(IP_ADAPTER_ADDRESSES, Ipv6IfIndex) && ptr->Ipv6IfIndex != 0)
iface->index = ptr->Ipv6IfIndex;
else if (ptr->IfIndex != 0)
iface->index = ptr->IfIndex;
iface->flags = QNetworkInterface::CanBroadcast;
if (ptr->OperStatus == IfOperStatusUp)
iface->flags |= QNetworkInterface::IsUp | QNetworkInterface::IsRunning;
if ((ptr->Flags & IP_ADAPTER_NO_MULTICAST) == 0)
iface->flags |= QNetworkInterface::CanMulticast;
if (ptr->IfType == IF_TYPE_PPP)
iface->flags |= QNetworkInterface::IsPointToPoint;
iface->name = QString::fromLocal8Bit(ptr->AdapterName);
iface->friendlyName = QString::fromWCharArray(ptr->FriendlyName);
if (ptr->PhysicalAddressLength)
iface->hardwareAddress = iface->makeHwAddress(ptr->PhysicalAddressLength,
ptr->PhysicalAddress);
else
// loopback if it has no address
iface->flags |= QNetworkInterface::IsLoopBack;
// The GetAdaptersAddresses call has an interesting semantic:
// It can return a number N of addresses and a number M of prefixes.
// But if you have IPv6 addresses, generally N > M.
// I cannot find a way to relate the Address to the Prefix, aside from stopping
// the iteration at the last Prefix entry and assume that it applies to all addresses
// from that point on.
PIP_ADAPTER_PREFIX pprefix = 0;
if (ptr->Length >= offsetof(IP_ADAPTER_ADDRESSES, FirstPrefix))
pprefix = ptr->FirstPrefix;
for (PIP_ADAPTER_UNICAST_ADDRESS addr = ptr->FirstUnicastAddress; addr; addr = addr->Next) {
QNetworkAddressEntry entry;
entry.setIp(addressFromSockaddr(addr->Address.lpSockaddr));
if (pprefix) {
if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {
entry.setNetmask(ipv4netmasks[entry.ip()]);
// broadcast address is set on postProcess()
} else { //IPV6
entry.setPrefixLength(pprefix->PrefixLength);
}
pprefix = pprefix->Next ? pprefix->Next : pprefix;
}
iface->addressEntries << entry;
}
}
if (pAdapter != staticBuf)
free(pAdapter);
return interfaces;
}
static QList<QNetworkInterfacePrivate *> interfaceListing()
{
QList<QNetworkInterfacePrivate *> interfaces;
QList<HostNameInfo> hostList;
ComPtr<INetworkInformationStatics> hostNameStatics;
GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Connectivity_NetworkInformation).Get(), &hostNameStatics);
ComPtr<IVectorView<HostName *>> hostNames;
hostNameStatics->GetHostNames(&hostNames);
if (!hostNames)
return interfaces;
unsigned int hostNameCount;
hostNames->get_Size(&hostNameCount);
for (unsigned i = 0; i < hostNameCount; ++i) {
HostNameInfo hostInfo;
ComPtr<IHostName> hostName;
hostNames->GetAt(i, &hostName);
HostNameType type;
hostName->get_Type(&type);
if (type == HostNameType_DomainName)
continue;
ComPtr<IIPInformation> ipInformation;
hostName->get_IPInformation(&ipInformation);
ComPtr<INetworkAdapter> currentAdapter;
ipInformation->get_NetworkAdapter(¤tAdapter);
currentAdapter->get_NetworkAdapterId(&hostInfo.adapterId);
ComPtr<IReference<unsigned char>> prefixLengthReference;
ipInformation->get_PrefixLength(&prefixLengthReference);
prefixLengthReference->get_Value(&hostInfo.prefixLength);
// invalid prefixes
if ((type == HostNameType_Ipv4 && hostInfo.prefixLength > 32)
|| (type == HostNameType_Ipv6 && hostInfo.prefixLength > 128))
continue;
HString name;
hostName->get_CanonicalName(name.GetAddressOf());
UINT32 length;
PCWSTR rawString = name.GetRawBuffer(&length);
hostInfo.address = QString::fromWCharArray(rawString, length);
hostList << hostInfo;
}
INetworkInformationStatics *networkInfoStatics;
GetActivationFactory(HString::MakeReference(RuntimeClass_Windows_Networking_Connectivity_NetworkInformation).Get(), &networkInfoStatics);
ComPtr<IVectorView<ConnectionProfile *>> connectionProfiles;
networkInfoStatics->GetConnectionProfiles(&connectionProfiles);
if (!connectionProfiles)
return interfaces;
unsigned int size;
connectionProfiles->get_Size(&size);
for (unsigned int i = 0; i < size; ++i) {
QNetworkInterfacePrivate *iface = new QNetworkInterfacePrivate;
interfaces << iface;
ComPtr<IConnectionProfile> profile;
connectionProfiles->GetAt(i, &profile);
NetworkConnectivityLevel connectivityLevel;
profile->GetNetworkConnectivityLevel(&connectivityLevel);
if (connectivityLevel != NetworkConnectivityLevel_None)
iface->flags = QNetworkInterface::IsUp | QNetworkInterface::IsRunning;
ComPtr<INetworkAdapter> adapter;
profile->get_NetworkAdapter(&adapter);
UINT32 type;
adapter->get_IanaInterfaceType(&type);
if (type == 23)
iface->flags |= QNetworkInterface::IsPointToPoint;
GUID id;
adapter->get_NetworkAdapterId(&id);
OLECHAR adapterName[39]={0};
StringFromGUID2(id, adapterName, 39);
iface->name = QString::fromWCharArray(adapterName);
// According to http://stackoverflow.com/questions/12936193/how-unique-is-the-ethernet-network-adapter-id-in-winrt-it-is-derived-from-the-m
// obtaining the MAC address using WinRT API is impossible
// iface->hardwareAddress = ?
for (int i = 0; i < hostList.length(); ++i) {
const HostNameInfo hostInfo = hostList.at(i);
if (id != hostInfo.adapterId)
continue;
QNetworkAddressEntry entry;
entry.setIp(QHostAddress(hostInfo.address));
entry.setPrefixLength(hostInfo.prefixLength);
iface->addressEntries << entry;
hostList.takeAt(i);
--i;
}
}
return interfaces;
}
