C++ QNetworkInterface::hardwareAddress方法代码示例

//---------------------------------------------
//-----------------DHCP PACKET-----------------
//---------------------------------------------
dhcp_packet::dhcp_packet(QHostAddress ip, QHostAddress netmask, QNetworkInterface inter)
{
    this->op = 0x01;

    this->htype = 0x01;

    this->hlen = 0x06;

    this->hops = 0x00;

    this->xid[0] = 0x63;
    this->xid[1] = 0x9F;
    this->xid[2] = 0xC0;
    this->xid[3] = 0x4B;

    this->secs[0] = 0x00;
    this->secs[1] =0x00;

    this->flags[0] = 0x00;
    this->flags[1] = 0x00;

    this->ciaddr = ip.toIPv4Address();

    this->yiaddr = 0x00000000;

    this->siaddr = ip.toIPv4Address() & netmask.toIPv4Address();

    for (int i = 0; i < 4; i++)
        this->giaddr[i] = 0x00;


    qDebug() << inter.hardwareAddress();
    bool ok;
    this->chaddr[0] = QString::fromStdString(inter.hardwareAddress().toStdString().substr(0, 2)).toInt(&ok, 16);
    this->chaddr[1] = QString::fromStdString(inter.hardwareAddress().toStdString().substr(3, 2)).toInt(&ok, 16);
    this->chaddr[2] = QString::fromStdString(inter.hardwareAddress().toStdString().substr(6, 2)).toInt(&ok, 16);
    this->chaddr[3] = QString::fromStdString(inter.hardwareAddress().toStdString().substr(9, 2)).toInt(&ok, 16);
    this->chaddr[4] = QString::fromStdString(inter.hardwareAddress().toStdString().substr(12, 2)).toInt(&ok, 16);
    this->chaddr[5] = QString::fromStdString(inter.hardwareAddress().toStdString().substr(15, 2)).toInt(&ok, 16);
    for (int i = 0; i < 5; i++)
        qDebug() << chaddr[i];
    for (int i = 0; i < 10; i++)
        this->chaddr[i+6] = 0x00;

    for (int i = 0; i < 64; i++)
        this->sname[i] = 0x00;

    for (int i = 0; i < 128; i++)
        this->file[i] = 0x00;

    //DHCP protocols
    options.append(0x63);
    options.append(0x82);
    options.append(0x53);
    options.append(0x63);
}

//someone selected another interface
void ApplicationWindow::interfaceBoxIndexChanged(int boxIndex)
{
    //get the right index data
    int interfaceIndex=interfaceBox->itemData(boxIndex).toInt();
    QNetworkInterface tmpInterface = QNetworkInterface::interfaceFromIndex (interfaceIndex);

    macLine->setText(tmpInterface.hardwareAddress());
   // indexLine->setText(QString("%1").arg(interfaceIndex));

    QList<QNetworkAddressEntry> interfaceAdresses;
    interfaceAdresses=tmpInterface.addressEntries();

    if (interfaceAdresses.size()>0)
    {
        ipLine->setText(interfaceAdresses[0].ip().toString());
        maskLine->setText(interfaceAdresses[0].netmask().toString());
    }
    else
    {
        ipLine->setText("");
        maskLine->setText("");
    }
        writeLog(createHeaderText());

}

QString DeviceManager::getDeviceMac()
{
    QNetworkInterface *qni;
    qni = new QNetworkInterface();
    *qni = qni->interfaceFromName(QString("%1").arg("wlan0"));
    return qni->hardwareAddress();
}

 //Source : http://stackoverflow.com/a/7616111
 foreach(QNetworkInterface netInterface, QNetworkInterface::allInterfaces())
     {
         // Return only the first non-loopback MAC Address
         if (!(netInterface.flags() & QNetworkInterface::IsLoopBack)){
             macAddress = netInterface.hardwareAddress();
             break;
         }
     }

OrderSave::OrderSave(QObject *parent) :
    QObject(parent)
{
      QNetworkInterface *qni;
      qni = new QNetworkInterface();
      *qni = qni->interfaceFromName(QString("%1").arg("eth0"));
      mac = qni->hardwareAddress();
      //»ñÈ¡MACµØÖ·
}

void PJobRunnerNetworkScanner::scan(const QNetworkInterface& interface){
    foreach(const QNetworkAddressEntry& address_entry, interface.addressEntries()){
        if(m_want_stop) break;
        quint32 netmask = address_entry.netmask().toIPv4Address();
        quint32 local_ip = address_entry.ip().toIPv4Address();
        quint32 address_to_try = (local_ip & netmask) + 1;
        //quint32 inv_netmask = ~netmask;

        if(interface.humanReadableName() == "lo"){
            std::cout << "Skipping interface \"lo\"." << std::endl;
            continue;
        }

        if(!interface.isValid()){
            std::cout << "Skipping interface \"" << interface.humanReadableName().toStdString() << "\"." << std::endl;
            continue;
        }

        if(address_entry.ip().protocol() != QAbstractSocket::IPv4Protocol){
            std::cout << "Skipping non-IPv4 interface." << std::endl;
            continue;
        }

        if(address_entry.ip() == QHostAddress::LocalHost){
            std::cout << "Skipping loopback interface." << std::endl;
            continue;
        }

        if(address_entry.ip().isNull()){
            continue;
        }

        std::cout << "Probing interface " << interface.humanReadableName().toStdString() << std::endl;
        std::cout << "Local address is " << interface.hardwareAddress().toStdString() << std::endl;
        std::cout << "Netmask: " << address_entry.netmask().toString().toStdString() << std::endl;
        std::cout << "Searching local network..." << std::endl;
        while((address_to_try & netmask) == (local_ip & netmask)){
            if(m_want_stop) break;
            std::cout << "\r" << QHostAddress(address_to_try).toString().toStdString();
            std::cout.flush();
            emit probing_host(QHostAddress(address_to_try));
            PJobRunnerSessionWrapper* session = new PJobRunnerSessionWrapper(QHostAddress(address_to_try), 50);
            if(session->is_valid()) found(session);
            else delete session;
            address_to_try++;
        }
    }
    emit finished_scanning();
    m_want_stop = false;
}

DeviceList::DeviceList() :
    QObject(NULL), _scanner() {
    qRegisterMetaType<DeviceInfo>("DeviceInfo");
    _started = false;
    _currentDev = NULL;

    QNetworkInterface iface = NetUtils::getPreferedInterface();
    DeviceInfo computer;
    computer.mac = NetUtils::strToMac(iface.hardwareAddress());
    computer.ip = NetUtils::getIp(iface).toString();
    computer.name = "Cet Ordinateur";
    computer.status = Device::CurrentComputer;
    computer.type = Device::ChapiServer;
    _currentDev = generateDevice(computer, true);
    _devices.insert(computer.mac, _currentDev);
}

void squeezeLiteGui::getplayerMACAddress(void)
{
    DEBUGF("");
    MacAddress = QByteArray( "00:00:00:00:00:04" );

    QList<QNetworkInterface> netList = QNetworkInterface::allInterfaces();
    QListIterator<QNetworkInterface> i( netList );

    QNetworkInterface t;

    while( i.hasNext() ) {  // note: this grabs the first functional, non-loopback address there is.  It may not the be interface on which you really connect to the slimserver
        t = i.next();
        if( !t.flags().testFlag( QNetworkInterface::IsLoopBack ) &&
                t.flags().testFlag( QNetworkInterface::IsUp ) &&
                t.flags().testFlag( QNetworkInterface::IsRunning ) ) {
            MacAddress = t.hardwareAddress().toLatin1().toLower();
            if(!MacAddress.contains("%3A")) // not escape encoded
                encodedMacAddress = QString(MacAddress).toLatin1().toPercentEncoding();
            return;
        }
    }
}

void QGenericEngine::doRequestUpdate()
{
#ifndef QT_NO_NETWORKINTERFACE
    QMutexLocker locker(&mutex);

    // Immediately after connecting with a wireless access point
    // QNetworkInterface::allInterfaces() will sometimes return an empty list. Calling it again a
    // second time results in a non-empty list. If we loose interfaces we will end up removing
    // network configurations which will break current sessions.
    QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
    if (interfaces.isEmpty())
        interfaces = QNetworkInterface::allInterfaces();

    QStringList previous = accessPointConfigurations.keys();

    // create configuration for each interface
    while (!interfaces.isEmpty()) {
        QNetworkInterface interface = interfaces.takeFirst();

        if (!interface.isValid())
            continue;

        // ignore loopback interface
        if (interface.flags() & QNetworkInterface::IsLoopBack)
            continue;

        // ignore WLAN interface handled in separate engine
        if (qGetInterfaceType(interface.name()) == QNetworkConfiguration::BearerWLAN)
            continue;

        uint identifier;
        if (interface.index())
            identifier = qHash(QLatin1String("generic:") + QString::number(interface.index()));
        else
            identifier = qHash(QLatin1String("generic:") + interface.hardwareAddress());

        const QString id = QString::number(identifier);

        previous.removeAll(id);

        QString name = interface.humanReadableName();
        if (name.isEmpty())
            name = interface.name();

        QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined;
        if((interface.flags() & QNetworkInterface::IsUp) && !interface.addressEntries().isEmpty())
            state |= QNetworkConfiguration::Active;

        if (accessPointConfigurations.contains(id)) {
            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);

            bool changed = false;

            ptr->mutex.lock();

            if (!ptr->isValid) {
                ptr->isValid = true;
                changed = true;
            }

            if (ptr->name != name) {
                ptr->name = name;
                changed = true;
            }

            if (ptr->id != id) {
                ptr->id = id;
                changed = true;
            }

            if (ptr->state != state) {
                ptr->state = state;
                changed = true;
            }

            ptr->mutex.unlock();

            if (changed) {
                locker.unlock();
                emit configurationChanged(ptr);
                locker.relock();
            }
        } else {
            QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);

            ptr->name = name;
            ptr->isValid = true;
            ptr->id = id;
            ptr->state = state;
            ptr->type = QNetworkConfiguration::InternetAccessPoint;
            ptr->bearerType = qGetInterfaceType(interface.name());

            accessPointConfigurations.insert(id, ptr);
            configurationInterface.insert(id, interface.name());

            locker.unlock();
            emit configurationAdded(ptr);
            locker.relock();
        }
    }
//.........这里部分代码省略.........

	foreach( QNetworkInterface netIf, QNetworkInterface::allInterfaces( ) ) {
		if( !( netIf.flags( ) & QNetworkInterface::IsLoopBack ) ) {
			return netIf.hardwareAddress( );
		}
	}