Qt在linux和widows下获取IP列表，网关，子网掩码，广播地址

Qt获取IP列表，网关，子网掩码，广播地址
linux下根据IP获取子网掩码还有网关
首先获取出IP列表，然后根据传入的IP地址进行判断，然后获取子网掩码和网关

#if defined(Q_OS_WIN32)
#else
    #include "getGateway.h"
    #include "arpa/inet.h"  //for in_addr
    #include "linux/rtnetlink.h"    //for rtnetlink
    #include "net/if.h" //for IF_NAMESIZ, route_info
    #include <stdlib.h> //for malloc(), free()
    #include <string.h> //for strstr(), memset()
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>
#endif
#define BUFSIZE 8192

struct route_info{
 u_int dstAddr;
 u_int srcAddr;
 u_int gateWay;
 char ifName[IF_NAMESIZE];
};
int readNlSock(int sockFd, char *bufPtr, int seqNum, int pId)
{
  struct nlmsghdr *nlHdr;
  int readLen = 0, msgLen = 0;
  do{
    //收到内核的应答
    if((readLen = recv(sockFd, bufPtr, BUFSIZE - msgLen, 0)) < 0)
    {
      perror("SOCK READ: ");
      return -1;
    }

    nlHdr = (struct nlmsghdr *)bufPtr;
    //检查header是否有效
    if((NLMSG_OK(nlHdr, readLen) == 0) || (nlHdr->nlmsg_type == NLMSG_ERROR))
    {
      perror("Error in recieved packet");
      return -1;
    }


    if(nlHdr->nlmsg_type == NLMSG_DONE)
    {
      break;
    }
    else
    {

      bufPtr += readLen;
      msgLen += readLen;
    }


    if((nlHdr->nlmsg_flags & NLM_F_MULTI) == 0)
    {

     break;
    }
  } while((nlHdr->nlmsg_seq != seqNum) || (nlHdr->nlmsg_pid != pId));
  return msgLen;
}
//分析返回的路由信息
void parseRoutes(struct nlmsghdr *nlHdr, struct route_info *rtInfo,char *gateway)
{
  struct rtmsg *rtMsg;
  struct rtattr *rtAttr;
  int rtLen;
  char *tempBuf = NULL;
  struct in_addr dst;
  struct in_addr gate;

  tempBuf = (char *)malloc(100);
  rtMsg = (struct rtmsg *)NLMSG_DATA(nlHdr);
  // If the route is not for AF_INET or does not belong to main routing table
  //then return.
  if((rtMsg->rtm_family != AF_INET) || (rtMsg->rtm_table != RT_TABLE_MAIN))
  return;

  rtAttr = (struct rtattr *)RTM_RTA(rtMsg);
  rtLen = RTM_PAYLOAD(nlHdr);
  for(;RTA_OK(rtAttr,rtLen);rtAttr = RTA_NEXT(rtAttr,rtLen)){
   switch(rtAttr->rta_type) {
   case RTA_OIF:
    if_indextoname(*(int *)RTA_DATA(rtAttr), rtInfo->ifName);
    break;
   case RTA_GATEWAY:
    rtInfo->gateWay = *(u_int *)RTA_DATA(rtAttr);
    break;
   case RTA_PREFSRC:
    rtInfo->srcAddr = *(u_int *)RTA_DATA(rtAttr);
    break;
   case RTA_DST:
    rtInfo->dstAddr = *(u_int *)RTA_DATA(rtAttr);
    break;
   }
  }
  dst.s_addr = rtInfo->dstAddr;
  if (strstr((char *)inet_ntoa(dst), "0.0.0.0"))
  {
    printf("oif:%s",rtInfo->ifName);
    gate.s_addr = rtInfo->gateWay;
    sprintf(gateway, (char *)inet_ntoa(gate));
    printf("%s\n",gateway);
    gate.s_addr = rtInfo->srcAddr;
    printf("src:%s\n",(char *)inet_ntoa(gate));
    gate.s_addr = rtInfo->dstAddr;
    printf("dst:%s\n",(char *)inet_ntoa(gate));
  }
  free(tempBuf);
  return;
}

int get_gateway(char *gateway)
{
 struct nlmsghdr *nlMsg;
 struct rtmsg *rtMsg;
 struct route_info *rtInfo;
 char msgBuf[BUFSIZE];

 int sock, len, msgSeq = 0;

 if((sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE)) < 0)
 {
  perror("Socket Creation: ");
  return -1;
 }


 memset(msgBuf, 0, BUFSIZE);


 nlMsg = (struct nlmsghdr *)msgBuf;
 rtMsg = (struct rtmsg *)NLMSG_DATA(nlMsg);


 nlMsg->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); // Length of message.
 nlMsg->nlmsg_type = RTM_GETROUTE; // Get the routes from kernel routing table .

 nlMsg->nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST; // The message is a request for dump.
 nlMsg->nlmsg_seq = msgSeq++; // Sequence of the message packet.
 nlMsg->nlmsg_pid = getpid(); // PID of process sending the request.


 if(send(sock, nlMsg, nlMsg->nlmsg_len, 0) < 0){
  printf("Write To Socket Failed…\n");
  return -1;
 }


 if((len = readNlSock(sock, msgBuf, msgSeq, getpid())) < 0) {
  printf("Read From Socket Failed…\n");
  return -1;
 }

 rtInfo = (struct route_info *)malloc(sizeof(struct route_info));
 for(;NLMSG_OK(nlMsg,len);nlMsg = NLMSG_NEXT(nlMsg,len)){
  memset(rtInfo, 0, sizeof(struct route_info));
  parseRoutes(nlMsg, rtInfo,gateway);
 }
 free(rtInfo);
 close(sock);
 return 0;
}
//使用上面的函数，gatewayEnable为true时获取网关，gatewayEnable为false时获取子网掩码
QString getNetmaskGateway(QString IpAddress, bool gatewayEnable)
{
    char buff[256];
    get_gateway(buff);//linux下获取网关
    QList<QNetworkInterface> interfaceList = QNetworkInterface::allInterfaces();
        for (int i = 0; i < interfaceList.count(); i++)
        {
            QNetworkInterface interf = interfaceList.at(i);
            interf.humanReadableName(); //接口名称（网卡）
            QList<QNetworkAddressEntry> entryList = interf.addressEntries(); // 读取一个IP地址列表
            for(int j = 0; j < entryList.count(); j++)
            {
                QNetworkAddressEntry entry = entryList.at(j);
                QString ip = entry.ip().toString();                   //IP地址
                if(ip == IpAddress)
                {
                    if(gatewayEnable)
                    {
                        qDebug()<< " getGateway_ip :  "<< QString(buff);
                        return QString(buff);  //返回获取的网关
                    }
                    else
                        return entry.netmask().toString(); //返回获取的子网掩码
                    QString mask = entry.netmask().toString();            //子网掩码
                    QString bcast = entry.broadcast().toString();         //广播地址
                }
            }
        }

windows下获取IP列表，子网掩码，网关

PIP_ADAPTER_INFO pIpAdapterInfo = new IP_ADAPTER_INFO();
unsigned long stSize = sizeof(IP_ADAPTER_INFO);
int nRel = GetAdaptersInfo(pIpAdapterInfo, &stSize);

    if (ERROR_BUFFER_OVERFLOW == nRel)
    {
        // ERROR_BUFFER_OVERFLOW：内存空间不够
        // 释放原来的内存空间
        delete pIpAdapterInfo;

        // 重新申请内存空间用来存储所有网卡信息
        pIpAdapterInfo = (PIP_ADAPTER_INFO)new BYTE[stSize];

        // 再次调用GetAdaptersInfo
        nRel= GetAdaptersInfo(pIpAdapterInfo,&stSize);
    }

    if (ERROR_SUCCESS == nRel)
    {
        while (pIpAdapterInfo)
        {
            if(pIpAdapterInfo->Type == MIB_IF_TYPE_ETHERNET)
            {
                // 多个网卡、多个IP
                IP_ADDR_STRING *pIpAddrString = &(pIpAdapterInfo->IpAddressList);
                do
                {
                    if(QString(pIpAddrString->IpAddress.String) == IpAddress)
                    {
                        if(gatewayEnable)
                            return QString(pIpAdapterInfo->GatewayList.IpAddress.String);
                        else
                            return QString(pIpAdapterInfo->IpAddressList.IpMask.String);
                    }
                    pIpAddrString=pIpAddrString->Next;

                } while (pIpAddrString);
            }

            pIpAdapterInfo = pIpAdapterInfo->Next;
        }
    }

    //释放内存空间
    if (pIpAdapterInfo)
    {
        delete pIpAdapterInfo;
   }

    return "0.0.0.0";