AdapterInfo.cpp

#include "AdapterInfo.h"
#include <iostream>
#include <winsock2.h>
#include <iphlpapi.h>
#include <stdlib.h>
#include <stdio.h>
 
#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "ws2_32.lib")
 
  AdapterInfo::AdapterInfo() {
    QueryAdapterInfo();
    }
 
  void AdapterInfo::QueryAdapterInfo() {
        PIP_ADAPTER_INFO pAdapterInfo;
        PIP_ADAPTER_INFO pAdapter = NULL;
        DWORD dwRetVal = 0;
 
        ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
        pAdapterInfo = (IP_ADAPTER_INFO*)malloc(sizeof(IP_ADAPTER_INFO));
        if (pAdapterInfo == NULL) {
            std::cerr << "Error allocating memory needed to call GetAdaptersinfo\n";
            return;
        }
 
        // Make an initial call to GetAdaptersInfo to get the necessary size into ulOutBufLen
        if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
            free(pAdapterInfo);
            pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen);
            if (pAdapterInfo == NULL) {
                std::cerr << "Error allocating memory needed to call GetAdaptersinfo\n";
                return;
            }
        }
 
        if ((dwRetVal = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR) {
            pAdapter = pAdapterInfo;
            while (pAdapter) {
 
                if (pAdapter->GatewayList.IpAddress.String[0] != '0') { // Check if gateway is defined
                    IPAddress = pAdapter->IpAddressList.IpAddress.String;
                    NetMask = pAdapter->IpAddressList.IpMask.String;
                    GateWay = pAdapter->GatewayList.IpAddress.String;
                    break;
                }
 
                pAdapter = pAdapter->Next;
            }
        }
        else {
            std::cerr << "GetAdaptersInfo failed with error: " << dwRetVal << "\n";
        }
 
        if (pAdapterInfo) {
            free(pAdapterInfo);
        }
 
   }
 
 std::string AdapterInfo::longToIp(unsigned long ip) {
      return std::to_string((ip >> 24) & 0xFF) + "." +
          std::to_string((ip >> 16) & 0xFF) + "." +
          std::to_string((ip >> 8) & 0xFF) + "." +
          std::to_string(ip & 0xFF);
  }
 
 unsigned long AdapterInfo::ipToLong(const std::string& ip) {
     unsigned long ipBytes[4] = { 0 };
     int count = sscanf_s(ip.c_str(), "%lu.%lu.%lu.%lu", &ipBytes[3], &ipBytes[2], &ipBytes[1], &ipBytes[0]);
     if (count != 4) {         
         std::cerr << "Error parsing IP address." << std::endl;
         return 0; 
     }
     return (ipBytes[3] << 24) | (ipBytes[2] << 16) | (ipBytes[1] << 8) | ipBytes[0];
 }
 
std::string AdapterInfo::CalculateBroadcastAddress(const std::string& ip, const std::string& netmask) {
     unsigned long ipLong = ipToLong(ip);
     unsigned long netmaskLong = ipToLong(netmask);
     unsigned long wildcardMask = ~netmaskLong;
     unsigned long broadcastAddress = ipLong | wildcardMask;
     return longToIp(broadcastAddress);
 }
 
std::string AdapterInfo::GetBroadcastAddress() {
    return CalculateBroadcastAddress(IPAddress, NetMask);
 
  }
 
  std::string AdapterInfo::GetIPAddress() {
      return IPAddress;
  }
 
  std::string AdapterInfo::GetNetMask() {
      return NetMask;
  }
 
  std::string AdapterInfo::GetGateWay() {
      return GateWay;
  }