c++取网络收发字节数

最新推荐文章于 2023-05-15 17:37:24 发布
最新推荐文章于 2023-05-15 17:37:24 发布
阅读量573 收藏
点赞数
分类专栏： c/c++
本文链接：https://blog.csdn.net/defaultbyzt/article/details/119647003
版权

c++

c++取网络收发字节数

#ifndef UNICODE
#define UNICODE
#endif

#include <winsock2.h>
#include <ws2tcpip.h>
#include <iphlpapi.h>
#include <stdio.h>
#include <iostream>
#pragma comment(lib, "iphlpapi.lib")

void ShowInterfaceInfo();

void Show1();
int Show2();
int Show3();


std::string UnicodeToANSI(const wchar_t* unicode);

#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))

/* Note: could also use malloc() and free() */

int main()
{
    while (1)
    {
        system("cls");
        //Show1();
        //Show2();
        //ShowInterfaceInfo();
        Show3();
        Sleep(1000);
    }
    return 0;
}



void Show1()
{
    DWORD dwRetval;
    MIB_IPSTATS *pStats;
    pStats = (MIB_IPSTATS *)MALLOC(sizeof(MIB_IPSTATS));
    if (pStats == NULL) {
        wprintf(L"Unable to allocate memory for MIB_IPSTATS\n");
        exit(1);
    }
    dwRetval = GetIpStatistics(pStats);
    if (dwRetval != NO_ERROR) {
        wprintf(L"GetIpStatistics call failed with %d\n", dwRetval);
        exit(1);
    }
    else {

        wprintf(L"IP forwarding: \t\t");
        switch (pStats->dwForwarding) {
        case MIB_IP_FORWARDING:
            wprintf(L"Enabled\n");
            break;
        case MIB_IP_NOT_FORWARDING:
            wprintf(L"Disabled\n");
            break;
        default:
            wprintf(L"unknown value = %d\n", pStats->dwForwarding);
            break;
        }

        wprintf(L"Default initial TTL: \t\t\t\t\t%u\n", pStats->dwDefaultTTL);

        wprintf(L"Number of received datagrams: \t\t\t\t%u\n", pStats->dwInReceives);
        wprintf(L"Number of received datagrams with header errors: \t%u\n", pStats->dwInHdrErrors);
        wprintf(L"Number of received datagrams with address errors: \t%u\n", pStats->dwInAddrErrors);

        wprintf(L"Number of datagrams forwarded: \t\t\t\t%ld\n", pStats->dwForwDatagrams);

        wprintf(L"Number of received datagrams with an unknown protocol: \t%u\n", pStats->dwInUnknownProtos);
        wprintf(L"Number of received datagrams discarded: \t\t%u\n", pStats->dwInDiscards);
        wprintf(L"Number of received datagrams delivered: \t\t%u\n", pStats->dwInDelivers);

        wprintf(L"Number of outgoing datagrams requested to transmit: \t%u\n", pStats->dwOutRequests);
        wprintf(L"Number of outgoing datagrams discarded for routing: \t%u\n", pStats->dwRoutingDiscards);
        wprintf(L"Number of outgoing datagrams discarded: \t\t%u\n", pStats->dwOutDiscards);
        wprintf(L"Number of outgoing datagrams with no route to destination discarded: %u\n", pStats->dwOutNoRoutes);

        wprintf(L"Fragment reassembly timeout: \t\t\t\t%u\n", pStats->dwReasmTimeout);
        wprintf(L"Number of datagrams that required reassembly: \t\t%u\n", pStats->dwReasmReqds);
        wprintf(L"Number of datagrams successfully reassembled: \t\t%u\n", pStats->dwReasmOks);
        wprintf(L"Number of datagrams that could not be reassembled: \t%u\n", pStats->dwReasmFails);

        wprintf(L"Number of datagrams fragmented successfully: \t\t%u\n", pStats->dwFragOks);
        wprintf(L"Number of datagrams not fragmented and discarded: \t%u\n", pStats->dwFragFails);
        wprintf(L"Number of fragments created: \t\t\t\t%u\n", pStats->dwFragCreates);

        wprintf(L"Number of interfaces: \t\t\t\t\t%u\n", pStats->dwNumIf);
        wprintf(L"Number of IP addresses: \t\t\t\t%u\n", pStats->dwNumAddr);
        wprintf(L"Number of routes: \t\t\t\t\t%u\n", pStats->dwNumRoutes);
    }
    // Free memory allocated for the MIB_IPSTATS structure
    if (pStats)
        FREE(pStats);
}

int Show2()
{

    // Declare and initialize variables.

    // Declare and initialize variables.
    DWORD dwSize = 0;
    DWORD dwRetVal = 0;

    unsigned int i, j;

    /* variables used for GetIfTable and GetIfEntry */
    MIB_IFTABLE *pIfTable;
    MIB_IFROW *pIfRow;

    // Allocate memory for our pointers.
    pIfTable = (MIB_IFTABLE *)MALLOC(sizeof(MIB_IFTABLE));
    if (pIfTable == NULL) {
        printf("Error allocating memory needed to call GetIfTable\n");
        exit(1);
    }
    // Before calling GetIfEntry, we call GetIfTable to make
    // sure there are entries to get and retrieve the interface index.

    // Make an initial call to GetIfTable to get the
    // necessary size into dwSize
    dwSize = sizeof(MIB_IFTABLE);
    if (GetIfTable(pIfTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
        FREE(pIfTable);
        pIfTable = (MIB_IFTABLE *)MALLOC(dwSize);
        if (pIfTable == NULL) {
            printf("Error allocating memory\n");
            exit(1);
        }
    }
    // Make a second call to GetIfTable to get the actual
    // data we want.
    if ((dwRetVal = GetIfTable(pIfTable, &dwSize, 0)) == NO_ERROR) {
        if (pIfTable->dwNumEntries > 0) {
            pIfRow = (MIB_IFROW *)MALLOC(sizeof(MIB_IFROW));
            if (pIfRow == NULL) {
                printf("Error allocating memory\n");
                if (pIfTable != NULL) {
                    FREE(pIfTable);
                    pIfTable = NULL;
                }
                exit(1);
            }

            printf("\tNum Entries: %ld\n\n", pIfTable->dwNumEntries);
            for (i = 0; i < pIfTable->dwNumEntries; i++) {
                pIfRow->dwIndex = pIfTable->table[i].dwIndex;
                if ((dwRetVal = GetIfEntry(pIfRow)) == NO_ERROR) {
                    printf("\tIndex:\t %ld\n", pIfRow->dwIndex);
                    printf("\tInterfaceName[%d]:\t ", i);
                    if (pIfRow->wszName != NULL)
                        printf("%ws", pIfRow->wszName);
                    printf("\n");

                    printf("\tDescription[%d]:\t ", i);
                    for (j = 0; j < pIfRow->dwDescrLen; j++)
                        printf("%c", pIfRow->bDescr[j]);
                    printf("\n");

                    printf("\tIndex[%d]:\t\t %d\n", i, pIfRow->dwIndex);

                    printf("\tType[%d]:\t\t ", i);
                    switch (pIfRow->dwType) {
                    case IF_TYPE_OTHER:
                        printf("Other\n");
                        break;
                    case IF_TYPE_ETHERNET_CSMACD:
                        printf("Ethernet\n");
                        break;
                    case IF_TYPE_ISO88025_TOKENRING:
                        printf("Token Ring\n");
                        break;
                    case IF_TYPE_PPP:
                        printf("PPP\n");
                        break;
                    case IF_TYPE_SOFTWARE_LOOPBACK:
                        printf("Software Lookback\n");
                        break;
                    case IF_TYPE_ATM:
                        printf("ATM\n");
                        break;
                    case IF_TYPE_IEEE80211:
                        printf("IEEE 802.11 Wireless\n");
                        break;
                    case IF_TYPE_TUNNEL:
                        printf("Tunnel type encapsulation\n");
                        break;
                    case IF_TYPE_IEEE1394:
                        printf("IEEE 1394 Firewire\n");
                        break;
                    default:
                        printf("Unknown type %ld\n", pIfRow->dwType);
                        break;
                    }

                    printf("\tMtu[%d]:\t\t %ld\n", i, pIfRow->dwMtu);
                    printf("\tSpeed[%d]:\t\t %ld\n", i, pIfRow->dwSpeed);
                    printf("\tInOctets[%d]:\t\t %ld\n", i, pIfRow->dwInOctets);
                    printf("\tOutOctets[%d]:\t\t %ld\n", i, pIfRow->dwOutOctets);
                    printf("\tPhysical Addr:\t\t ");

                    if (pIfRow->dwPhysAddrLen == 0)
                        printf("\n");
                    //                    for (j = 0; j < (int) pIfRow->dwPhysAddrLen; j++) {
                    for (j = 0; j < pIfRow->dwPhysAddrLen; j++) {
                        if (j == (pIfRow->dwPhysAddrLen - 1))
                            printf("%.2X\n", (int)pIfRow->bPhysAddr[j]);
                        else
                            printf("%.2X-", (int)pIfRow->bPhysAddr[j]);
                    }
                    printf("\tAdmin Status[%d]:\t %ld\n", i,
                        pIfRow->dwAdminStatus);

                    printf("\tOper Status[%d]:\t ", i);
                    switch (pIfRow->dwOperStatus) {
                    case IF_OPER_STATUS_NON_OPERATIONAL:
                        printf("Non Operational\n");
                        break;
                    case IF_OPER_STATUS_UNREACHABLE:
                        printf("Unreasonable\n");
                        break;
                    case IF_OPER_STATUS_DISCONNECTED:
                        printf("Disconnected\n");
                        break;
                    case IF_OPER_STATUS_CONNECTING:
                        printf("Connecting\n");
                        break;
                    case IF_OPER_STATUS_CONNECTED:
                        printf("Connected\n");
                        break;
                    case IF_OPER_STATUS_OPERATIONAL:
                        printf("Operational\n");
                        break;
                    default:
                        printf("Unknown status %ld\n",
                            pIfRow->dwOperStatus);
                        break;
                    }
                    printf("\n");
                }

                else {
                    printf("GetIfEntry failed for index %d with error: %ld\n",
                        i, dwRetVal);
                    // Here you can use FormatMessage to find out why 
                    // it failed.

                }
            }
        }
        else {
            printf("\tGetIfTable failed with error: %ld\n", dwRetVal);
        }

    }
    return 0;
}


void ShowInterfaceInfo()
{
    using namespace std;
    DWORD dwNum = 0;
    DWORD dwRet = GetNumberOfInterfaces(&dwNum);
    if (dwRet != NO_ERROR)
        return;
    PMIB_IFTABLE pIfTable = NULL;
    DWORD dwSize = 0;
    dwRet = GetIfTable(pIfTable, &dwSize, TRUE);
    if (dwRet == ERROR_INSUFFICIENT_BUFFER)
        pIfTable = (PMIB_IFTABLE)malloc(dwSize);
    dwRet = GetIfTable(pIfTable, &dwSize, TRUE);
    if (dwRet != NO_ERROR)
    {
        if (pIfTable != NULL)
            free(pIfTable);
        return;
    }

    for (int i = 0; i < pIfTable->dwNumEntries; i++)
    {
        PMIB_IFROW pIfRow = &pIfTable->table[i];
        if (pIfRow->dwType != IF_TYPE_ETHERNET_CSMACD && pIfRow->dwType != IF_TYPE_IEEE80211)
            continue;
        if (pIfRow->dwPhysAddrLen == 0)
            continue;
        printf("\tIndex:\t %ld\n", pIfRow->dwIndex);
        printf("\tInterfaceName[%d]:\t ", i);
        if (pIfRow->wszName != NULL)
            printf("%ws", pIfRow->wszName);
        printf("\n");

        printf("\tDescription[%d]:\t ", i);
        for (int j = 0; j < pIfRow->dwDescrLen; j++)
            printf("%c", pIfRow->bDescr[j]);
        printf("\n");

        printf("\tIndex[%d]:\t\t %d\n", i, pIfRow->dwIndex);

        printf("\tType[%d]:\t\t ", i);
        switch (pIfRow->dwType) {
        case IF_TYPE_OTHER:
            printf("Other\n");
            break;
        case IF_TYPE_ETHERNET_CSMACD:
            printf("Ethernet\n");
            break;
        case IF_TYPE_ISO88025_TOKENRING:
            printf("Token Ring\n");
            break;
        case IF_TYPE_PPP:
            printf("PPP\n");
            break;
        case IF_TYPE_SOFTWARE_LOOPBACK:
            printf("Software Lookback\n");
            break;
        case IF_TYPE_ATM:
            printf("ATM\n");
            break;
        case IF_TYPE_IEEE80211:
            printf("IEEE 802.11 Wireless\n");
            break;
        case IF_TYPE_TUNNEL:
            printf("Tunnel type encapsulation\n");
            break;
        case IF_TYPE_IEEE1394:
            printf("IEEE 1394 Firewire\n");
            break;
        default:
            printf("Unknown type %ld\n", pIfRow->dwType);
            break;
        }

        printf("\tMtu[%d]:\t\t %ld\n", i, pIfRow->dwMtu);
        printf("\tSpeed[%d]:\t\t %ld\n", i, pIfRow->dwSpeed);
        printf("\tInOctets[%d]:\t\t %ld\n", i, pIfRow->dwInOctets);
        printf("\tOutOctets[%d]:\t\t %ld\n", i, pIfRow->dwOutOctets);
        printf("\tPhysical Addr:\t\t ");

        if (pIfRow->dwPhysAddrLen == 0)
            printf("\n");
        //                    for (j = 0; j < (int) pIfRow->dwPhysAddrLen; j++) {
        for (int j = 0; j < pIfRow->dwPhysAddrLen; j++) {
            if (j == (pIfRow->dwPhysAddrLen - 1))
                printf("%.2X\n", (int)pIfRow->bPhysAddr[j]);
            else
                printf("%.2X-", (int)pIfRow->bPhysAddr[j]);
        }
        printf("\tAdmin Status[%d]:\t %ld\n", i,
            pIfRow->dwAdminStatus);

        printf("\tOper Status[%d]:\t ", i);
        switch (pIfRow->dwOperStatus) {
        case IF_OPER_STATUS_NON_OPERATIONAL:
            printf("Non Operational\n");
            break;
        case IF_OPER_STATUS_UNREACHABLE:
            printf("Unreasonable\n");
            break;
        case IF_OPER_STATUS_DISCONNECTED:
            printf("Disconnected\n");
            break;
        case IF_OPER_STATUS_CONNECTING:
            printf("Connecting\n");
            break;
        case IF_OPER_STATUS_CONNECTED:
            printf("Connected\n");
            break;
        case IF_OPER_STATUS_OPERATIONAL:
            printf("Operational\n");
            break;
        default:
            printf("Unknown status %ld\n",
                pIfRow->dwOperStatus);
            break;
        }
        printf("\n");
    }
    if (pIfTable != NULL)
        free(pIfTable);
}



#define WORKING_BUFFER_SIZE 15000
#define MAX_TRIES 3

int Show3()
{
    /* Declare and initialize variables */
    DWORD dwSize = 0;
    DWORD dwRetVal = 0;

    unsigned int i = 0;

    // Set the flags to pass to GetAdaptersAddresses
    ULONG flags = GAA_FLAG_INCLUDE_PREFIX;

    // default to unspecified address family (both)
    ULONG family = AF_UNSPEC;

    LPVOID lpMsgBuf = NULL;

    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
    ULONG outBufLen = 0;
    ULONG Iterations = 0;

    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
    PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
    PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
    PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
    IP_ADAPTER_DNS_SERVER_ADDRESS *pDnServer = NULL;
    IP_ADAPTER_PREFIX *pPrefix = NULL;

    //if (argc != 2) {
    //    printf(" Usage: getadapteraddresses family\n");
    //    printf("        getadapteraddresses 4 (for IPv4)\n");
    //    printf("        getadapteraddresses 6 (for IPv6)\n");
    //    printf("        getadapteraddresses A (for both IPv4 and IPv6)\n");
    //    exit(1);
    //}

    //if (atoi(argv[1]) == 4)
    //    family = AF_INET;
    //else if (atoi(argv[1]) == 6)
    //    family = AF_INET6;

    printf("Calling GetAdaptersAddresses function with family = ");
    if (family == AF_INET)
        printf("AF_INET\n");
    if (family == AF_INET6)
        printf("AF_INET6\n");
    if (family == AF_UNSPEC)
        printf("AF_UNSPEC\n\n");
    MIB_IFROW *pIfRow = (MIB_IFROW *)MALLOC(sizeof(MIB_IFROW));

    // Allocate a 15 KB buffer to start with.
    outBufLen = WORKING_BUFFER_SIZE;

    do {

        pAddresses = (IP_ADAPTER_ADDRESSES *)MALLOC(outBufLen);
        if (pAddresses == NULL) {
            printf
            ("Memory allocation failed for IP_ADAPTER_ADDRESSES struct\n");
            exit(1);
        }

        dwRetVal =
            GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
        if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
            FREE(pAddresses);
            pAddresses = NULL;
        }
        else {
            break;
        }

        Iterations++;

    } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (Iterations < MAX_TRIES));

    if (dwRetVal == NO_ERROR) {
        // If successful, output some information from the data we received
        pCurrAddresses = pAddresses;
        while (pCurrAddresses) {
            pIfRow->dwIndex = pCurrAddresses->IfIndex;
            if ((dwRetVal = GetIfEntry(pIfRow)) == NO_ERROR) {
                ;
            }
            else
            {
                // 拿不到信息
                pCurrAddresses = pCurrAddresses->Next;
                continue;
            }
            if (!pCurrAddresses->FriendlyName)
            {
                // 没有显示名
                pCurrAddresses = pCurrAddresses->Next;
                continue;
            }
            if (0 == pCurrAddresses->PhysicalAddressLength)
            {
                // 没有mac
                pCurrAddresses = pCurrAddresses->Next;
                continue;
            }

            std::string name = UnicodeToANSI(pCurrAddresses->FriendlyName);
            printf("\tFriendly name: %s\n", name.c_str());

            printf("\tLength of the IP_ADAPTER_ADDRESS struct: %ld\n",
                pCurrAddresses->Length);
            printf("\tIfIndex (IPv4 interface): %u\n", pCurrAddresses->IfIndex);
            printf("\tAdapter name: %s\n", pCurrAddresses->AdapterName);
            // 接收
            printf("\tInOctets[%d]:\t\t %ld\n", pCurrAddresses->IfIndex, pIfRow->dwInOctets);
            // 发送
            printf("\tOutOctets[%d]:\t\t %ld\n", pCurrAddresses->IfIndex, pIfRow->dwOutOctets);

            pUnicast = pCurrAddresses->FirstUnicastAddress;
            if (pUnicast != NULL) {
                for (i = 0; pUnicast != NULL; i++)
                    pUnicast = pUnicast->Next;
                printf("\tNumber of Unicast Addresses: %d\n", i);
            }
            else
                printf("\tNo Unicast Addresses\n");

            pAnycast = pCurrAddresses->FirstAnycastAddress;
            if (pAnycast) {
                for (i = 0; pAnycast != NULL; i++)
                    pAnycast = pAnycast->Next;
                printf("\tNumber of Anycast Addresses: %d\n", i);
            }
            else
                printf("\tNo Anycast Addresses\n");

            pMulticast = pCurrAddresses->FirstMulticastAddress;
            if (pMulticast) {
                for (i = 0; pMulticast != NULL; i++)
                    pMulticast = pMulticast->Next;
                printf("\tNumber of Multicast Addresses: %d\n", i);
            }
            else
                printf("\tNo Multicast Addresses\n");

            pDnServer = pCurrAddresses->FirstDnsServerAddress;
            if (pDnServer) {
                for (i = 0; pDnServer != NULL; i++)
                    pDnServer = pDnServer->Next;
                printf("\tNumber of DNS Server Addresses: %d\n", i);
            }
            else
                printf("\tNo DNS Server Addresses\n");

            printf("\tDNS Suffix: %wS\n", pCurrAddresses->DnsSuffix);
            printf("\tDescription: %wS\n", pCurrAddresses->Description);
            //printf("\tFriendly name: %wS\n", pCurrAddresses->FriendlyName);

            if (pCurrAddresses->PhysicalAddressLength != 0) {
                printf("\tPhysical address: ");
                for (i = 0; i < (int)pCurrAddresses->PhysicalAddressLength;
                    i++) {
                    if (i == (pCurrAddresses->PhysicalAddressLength - 1))
                        printf("%.2X\n",
                        (int)pCurrAddresses->PhysicalAddress[i]);
                    else
                        printf("%.2X-",
                        (int)pCurrAddresses->PhysicalAddress[i]);
                }
            }
            printf("\tFlags: %ld\n", pCurrAddresses->Flags);
            printf("\tMtu: %lu\n", pCurrAddresses->Mtu);
            printf("\tIfType: %ld\n", pCurrAddresses->IfType);


            printf("\tOperStatus: %ld\n", pCurrAddresses->OperStatus);
            printf("\tIpv6IfIndex (IPv6 interface): %u\n",
                pCurrAddresses->Ipv6IfIndex);
            printf("\tZoneIndices (hex): ");
            for (i = 0; i < 16; i++)
                printf("%lx ", pCurrAddresses->ZoneIndices[i]);
            printf("\n");

            printf("\tTransmit link speed: %I64u\n", pCurrAddresses->TransmitLinkSpeed);
            printf("\tReceive link speed: %I64u\n", pCurrAddresses->ReceiveLinkSpeed);

            pPrefix = pCurrAddresses->FirstPrefix;
            if (pPrefix) {
                for (i = 0; pPrefix != NULL; i++)
                    pPrefix = pPrefix->Next;
                printf("\tNumber of IP Adapter Prefix entries: %d\n", i);
            }
            else
                printf("\tNumber of IP Adapter Prefix entries: 0\n");

            printf("\n");

            pCurrAddresses = pCurrAddresses->Next;
        }
    }
    else {
        printf("Call to GetAdaptersAddresses failed with error: %d\n",
            dwRetVal);
        if (dwRetVal == ERROR_NO_DATA)
            printf("\tNo addresses were found for the requested parameters\n");
        else {

            if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                NULL, dwRetVal, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                // Default language
                (LPTSTR)& lpMsgBuf, 0, NULL)) {
                printf("\tError: %s", lpMsgBuf);
                LocalFree(lpMsgBuf);
                if (pAddresses)
                    FREE(pAddresses);
                exit(1);
            }
        }
    }

    if (pAddresses) {
        FREE(pAddresses);
    }
    if (pIfRow)
        FREE(pIfRow);

    return 0;
}



std::string UnicodeToANSI(const wchar_t* unicode)
{
#ifdef WIN32
    int textlen = WideCharToMultiByte(CP_ACP, 0, unicode, -1, NULL, 0, NULL, NULL);
    char* pBuffer = new char[textlen + 1];
    memset(pBuffer, 0, sizeof(char) * (textlen + 1));
    WideCharToMultiByte(CP_ACP, 0, unicode, -1, pBuffer, textlen, NULL, NULL);
    std::string ansi{ pBuffer };
    delete[] pBuffer;
    return ansi;
#else
    QString string = "...";
    QTextCodec *codec = QTextCodec::codecForName("GBK");
    QByteArray encodedString = codec->fromUnicode(string);

    return nullptr;
#endif
}

参考：

https://docs.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-getadaptersaddresses

https://docs.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-getifentry

https://docs.microsoft.com/en-us/windows/win32/api/iphlpapi/nf-iphlpapi-getiftable

张拓1070410059
关注
专栏目录
手把手写C++服务器(20)：网络字节序与主机字节序、大端、小端与共用体
沉迷单车的追风少年
08-03 665
本系列文章导航： 手把手写C++服务器(0)：专栏文章-汇总导航【更新中】 前言：在正式开始学习socket编程之前，有必要了解网络字节序、主机字节序、大小端、如何判断大小端、在Linux当中如何转换主机字节序与网络字节序。为之后通用socket地址、专用socket地址、地址转换等知识点打下基础。 目录 什么是字节序？ 字节序分类：大端字节序、小端字节序 网络字节序与主机字节序 不同字节序之间传输问题 Linux主机字节序-网络字节序转换API 面试题：写一段程序判断大小端 ...
C++ 网络编程
最新发布
weixin_44585214的博客
05-20 1253
当服务端收到客户端发送的SYN包后，该连接处于半打开状态。半连接队列（SYN队列）用来存储半打开状态的连接→通过哈希表实现→以O(1)的时间复杂度移除元素。当服务端收到客户端的ACK包后，连接建立成功，先将该连接从半连接队列中移除，然后把该连接加入到全连接队列（accept队列）中。如果客户端收到SYN-ACK包后，不回复ACK包：也就是攻击者短时间伪造不同IP地址的SYN包，快速占满SYN队列，使服务端不能为正常用户服务 → SYN泛洪、SYN攻击、DDos攻击。
IO流（C++）
Man9o
03-12 334
C++提供了流输入输出库``，所有的类都继承自`ios_base` ，它是 C++ 标准程序库中的一个类，定义于 `` 头文件中。它封装了 C++ 标准中的流输入输出中不依赖于读写的数据的类型的基本信息，如格式化信息、异常状态、事件回调函数等。
C++获取本机IP地址信息
weixin_30258901的博客
06-09 450
#include<winsock2.h> #include<iostream> #include<string> using namespace std; #pragma comment(lib, "WS2_32.lib") string getIP() { WSADATA WSAData; char hostNa...
java、c++网络通信时的字节顺序
zhangmingCSDN
07-28 1144
目前的字节顺序有两类：BIG_ENGIAN和LITTLE_ENDIAN。各个平台所支持的字节序不同，例如AIX、Tru64Unix、Windows等操作系统平台采用LITTLE_ENDIAN字节序，Solaris等操作系统平台采用BIG_ENGIAN。Java自身采用的是BIG_ENGIAN字节序，当java和运行在其他平台上的其他语言编写的通信程序通信时，则必须考虑到数据的字节序。
C++统计文件字节流操作
aj64994979的博客
06-17 1144
#include<iostream> #include<fstream> #include<iomanip> using namespace std; bool isalph(char); int main02(); void main() { int sum = 0, Nonull = 0; char s[150]; char c; ifstream...
C++ 获取自身函数内存地址附近的字节码
墨鱼菜鸡
12-05 168
// 存放字节码的字符串 string code; // 获取函数地址开始向后 32 字节大小的字节码 for(int i=0;i<32;i++){ code+=to_string((int)*((UCHAR*)...
QT/C++ TCP多线程客户端（收发线程分离，自动粘包处理，自动数据包成型）
09-03
QT/C++ TCP多线程客户端的设计是为了解决在高并发场景下可靠地收发数据的问题。TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，它确保了数据的顺序传输和错误检测。然而，当面对大量...
c++ winpcap开发(9)
swartz_lubel的专栏
07-20 1026
收集网络流量统计 本课程展示了WinPcap的另一个高级功能：收集网络流量统计信息的能力。统计引擎利用内核级包过滤器对传入的数据包进行有效的分类。如果您想了解更多详细信息，可以参考NPF驱动程序内部手册。 为了使用此功能，程序员必须打开适配器并将其置于统计 模式。这可以用pcap_setmode（）完成。特别地，MODE_STAT必须用作该函数的模式参数。 通过统计模式，监控TCP流
Udp.rar_Linux c++ udp _linux UDP_udp收发
09-21
3. 小头开销：UDP头部只有8个字节，相比TCP（20个字节）更节省网络资源。 二、C++实现UDP通信 在C++中，我们可以使用套接字API（socket API）来操作UDP。以下是一些关键步骤： 1. 创建套接字： ```cpp int socket_...
用C/C++实现linux下检测网络接口状态
08-27
主要为大家详细介绍了用c/c++实现linux下检测网络接口状态，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
vc网卡流量监控（网速监控）(GetIfTable)
09-11
程序和源码已打包，编译需XPSP2 PSDK ，写的比较乱，等有时间再整理
C/C++网络传输struct类型数据
02-16
在C/C++编程中，网络传输常常涉及到结构体（struct）数据的传递，因为结构体可以方便地封装多个相关的变量。然而，结构体在网络传输中需要注意一些关键点以确保数据的正确性和一致性。 首先，我们必须遵循两个重要...
用C++实现网络编程---抓取网络数据包的实现方法
dinaoju5134的博客
02-25 853
　　一般都熟悉sniffer这个工具，它可以捕捉流经本地网卡的所有数据包。抓取网络数据包进行分析有很多用处，如分析网络是否有网络病毒等异常数据，通信协议的分析（数据链路层协议、IP、UDP、TCP、甚至各种应用层协议），敏感数据的捕捉等。下面我们就来看看在windows下如何实现数据包的捕获。 下面先对网络嗅探器的原理做简单介绍。 嗅探器设计原理 　　嗅探器作为一种网络通讯程序，也...
游戏安全4-C,C++读取目标内存数据 读4字节
m0_58301616的博客
05-15 551
GetWindowThreadProcessId //返回线程TID和进程PID。ReadProcessMemory //读取指定进程的内存数据。封接读内存接口函数 int R4(void* 地址)通过接口函数读取基址偏移公式里的数据。认识进程句柄HANDLE。
C++遍历windows进程及获取进程的各种信息
qq_41883523的博客
11-15 7099
C++遍历windows进程及获取进程的各种信息遍历进程 遍历进程 struct ProcessInfo { wstring szProcessName; wstring szcmdline; DWORD processId; DWORD numOfthread; int64_t cpuInfo; uint64_t memoryInfo; uint64_t IDiskBytes; uint64_t ODiskBytes; uint64_t INetReceiveBytes; uint64
Windows使用C++获取网卡信息
EnskDeCode
04-26 6384
使用 Windows sdk 提供的 API 函数 GetAdaptersInfo() 可以获得本机所有网卡的网卡名 , 网卡描述 , 网卡 MAC 地址 , 网卡IP , 网卡类型等信息 , 并用 IP_ADAPTER_INFO 结构体存储 ; 使用 GetIfEntry() 可以获取网卡的状态 , 可有效判断出网卡通讯是否正常 , 是否插入网线等状态 ; 代码如下 :#include "stda
获取网卡信息
yaneng的专栏
08-31 2219
用api 函数 GetIfTable() 适用范围： windows98及以上操作系统 包含文件：iphlpapi.h 库文件： iphlpapi.lib 说明： GetIfTable()可以从操作系统维护的MIB库中读出本机各个接口的当前信息，如接口数目、类型、速率、物理地址、接收/发送字节数、错语字节数等等等等。 根据接口类型可以推断出接口的种类，如MIB_IF_TYPE_ETHERNET是指
C/C++ 网络编程基础与实践
"C/C++ 网络编程入门教程，涵盖TCP协议、套接字、聊天程序开发模式、端口侦听、连接服务端、字符串传输、文件收发及异步传输等基础内容，适合初学者。" C/C++ 网络编程涉及到的关键知识点主要包括以下几个方面： 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值