linux 或 windows 获取唯一的硬件信息 - 命令行和 c++ 代码

最编程 2024-06-27 15:21:40

...

linux

使用dmidecode

CPU ID
// 代码:
sudo dmidecode -t 4 | grep ID
// 主板序列号
代码:
sudo dmidecode -t 2 | grep Serial
// MAC地址
代码:
sudo lshw -c network | grep serial | head -n 1

这个需要使用root权限，同时对于jetson 板子，dmidecode没用

14、获取CPU序列号或者主板序列号

sudodmidecode –t 4 | grep ID



15、查看序列号：

sudodmidecode | grep Serial | more



16、查看cpu

sudodmidecode –t 4 | more



17、查看BIOS信息

sudodmidecode –t 0 | more



18、查看主板信息

sudodmidecode –t 2 | more



19、查看OEM

Sudodmidecode –t 11 | more



20、显示当前内存大小

free –m| grep “Mem” | awk ‘{print $2}’



21：显示系统运行时间

uptime



22:查看内核限制

23:查看Ubuntu版本信息

cat /etc/issue

或 cat/etc/lsb-release

或 lsb_release–dsc



24：查看系统是32位还是64位

#查看long的位数，返回32或64

getconf LONG_BIT

#查看文件信息，包含32-bit就是32位，包含64-bit就是64位

file /sbin/init

linux使用dmidecode代码获取主板序列号

/* ************************************************************************
*       Filename:  system_test.c
*    Description:
*        Version:  1.0
*        Created:  2015年04月12日 10时41分49秒
*       Revision:  none
*       Compiler:  gcc
*         Author:  YOUR NAME (),
*        Company:
* ************************************************************************/
 
 
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
int main( int argc, char *argv[] )
{
        pid_t	pid;
        int	ret	= 0;
        int	fd[2]	= { 0 };
 
/* 创建管道 */
        ret = pipe( fd );
        if ( ret == -1 )
        {
                perror( "pipe" );
                _exit( 1 );
        }
 
/* 创建子进程，目的  1exec 2复制管道文件描述符 */
        pid = vfork();
        if ( pid < 0 )
        {
                perror( "vfork" );
        }else if ( pid == 0 )
        {
                dup2( fd[1], 1 );                       /* 标准输出重定向到管道的写端 */
 
        char str[50] = "dmidecode -s system-serial-number";
        execlp( "/bin/sh", "sh", "-c", str, NULL );
        }else  {
                char result[100] = "";
                read( fd[0], result, sizeof(result) );  /* 从管道的读端读取数据 */
 
        char msg[100] = "";
        sprintf( msg, "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c:%c%c",
                 result[7], result[8], result[10], result[11], result[13], result[14], result[16], result[17],
                 result[19], result[20], result[22], result[23], result[25],
                 result[26], result[28], result[29], result[31], result[32],
                 result[34], result[35], result[37], result[38], result[40],
                 result[41], result[43], result[44], result[46], result[47],
                 result[49], result[50], result[52], result[53] );
        printf( "---->%s\n", msg );
        }
        return(0);
}

获取CPUID：

CPUID并不是所有的Intel CPU都支持的。如果支持，汇编调用为：eax置0000_0003，调用cpuid。
以下为实现代码（在我的CPU上，并没有得到）：

#define cpuid(in,a,b,c,d)  asm("cpuid": "=a" (a), "=b" (b), "=c" (c), "=d" (d) : "a" (in));
 
static int getcpuid (char *id, size_t max)
{
    int i;
    unsigned long li, maxi, maxei, ebx, ecx, edx, unused;
 
    cpuid (0, maxi, unused, unused, unused);
    maxi &= 0xffff;
 
    if (maxi < 3)
    {
        return -1;
    }
 
    cpuid (3, eax, ebx, ecx, edx);
 
    snprintf (id, max, "%08lx %08lx %08lx %08lx", eax, ebx, ecx, edx);
    fprintf (stdout, "get cpu id: %s/n", id);
 
    return 0;
}

或者

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <arpa/inet.h>
#include <string>
#include <fstream>
 
static bool get_cpu_id_by_asm(std::string & cpu_id)
{
    cpu_id.clear();
 
    unsigned int s1 = 0;
    unsigned int s2 = 0;
    asm volatile
    (
        "movl $0x01, %%eax; \n\t"
        "xorl %%edx, %%edx; \n\t"
        "cpuid; \n\t"
        "movl %%edx, %0; \n\t"
        "movl %%eax, %1; \n\t"
        : "=m"(s1), "=m"(s2)
    );
 
    if (0 == s1 && 0 == s2)
    {
        return(false);
    }
 
    char cpu[32] = { 0 };
    snprintf(cpu, sizeof(cpu), "%08X%08X", htonl(s2), htonl(s1));
    std::string(cpu).swap(cpu_id);
 
    return(true);
}
 
static void parse_cpu_id(const char * file_name, const char * match_words, std::string & cpu_id)
{
    cpu_id.c_str();
 
    std::ifstream ifs(file_name, std::ios::binary);
    if (!ifs.is_open())
    {
        return;
    }
 
    char line[4096] = { 0 };
    while (!ifs.eof())
    {
        ifs.getline(line, sizeof(line));
        if (!ifs.good())
        {
            break;
        }
 
        const char * cpu = strstr(line, match_words);
        if (NULL == cpu)
        {
            continue;
        }
        cpu += strlen(match_words);
 
        while ('\0' != cpu[0])
        {
            if (' ' != cpu[0])
            {
                cpu_id.push_back(cpu[0]);
            }
            ++cpu;
        }
 
        if (!cpu_id.empty())
        {
            break;
        }
    }
 
    ifs.close();
}
 
static bool get_cpu_id_by_system(std::string & cpu_id)
{
    cpu_id.c_str();
 
    const char * dmidecode_result = ".dmidecode_result.txt";
    char command[512] = { 0 };
    snprintf(command, sizeof(command), "dmidecode -t 4 | grep ID > %s", dmidecode_result);
 
    if (0 == system(command))
    {
        parse_cpu_id(dmidecode_result, "ID:", cpu_id);
    }
 
    unlink(dmidecode_result);
 
    return(!cpu_id.empty());
}
 
static bool get_cpu_id(std::string & cpu_id)
{
    if (get_cpu_id_by_asm(cpu_id))
    {
        return(true);
    }
    if (0 == getuid())
    {
        if (get_cpu_id_by_system(cpu_id))
        {
            return(true);
        }
    }
    return(false);
}
 
static void test_1()
{
    std::string cpu_id;
    if (get_cpu_id(cpu_id))
    {
        printf("cpu_id: [%s]\n", cpu_id.c_str());
    }
    else
    {
        printf("can not get cpu id\n");
    }
}
 
static void test_2()
{
    {
        std::string cpu_id;
        if (get_cpu_id_by_asm(cpu_id))
        {
            printf("cpu_id_by_asm: [%s]\n", cpu_id.c_str());
        }
        else
        {
            printf("can not get cpu id\n");
        }
    }
    {
        std::string cpu_id;
        if (get_cpu_id_by_system(cpu_id))
        {
            printf("cpu_id_by_sys: [%s]\n", cpu_id.c_str());
        }
        else
        {
            printf("can not get cpu id\n");
        }
    }
}
 
int main(int argc, char* argv[])
{
    test_1();
    test_2();
    return(0);
}

获取MAC地址：(可以考虑加入ifconfig -a的解析，因为lshw实在太慢了)

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include <fstream>
 
bool get_mac_address_by_ioctl(std::string & mac_address)
{
    mac_address.clear();
 
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0)
    {
        return(false);
    }
 
    struct ifreq ifr = { 0 };
    strncpy(ifr.ifr_name, "eth0", sizeof(ifr.ifr_name) - 1);
    bool ret = (ioctl(sock, SIOCGIFHWADDR, &ifr) >= 0);
 
    close(sock);
 
    const char hex[] = 
    {
        '0', '1', '2', '3', '4', '5', '6', '7', 
        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' 
    };
    char mac[16] = { 0 };
    for (int index = 0; index < 6; ++index)
    {
         size_t value = ifr.ifr_hwaddr.sa_data[index] & 0xFF;
         mac[2 * index + 0] = hex[value / 16];
         mac[2 * index + 1] = hex[value % 16];
    }
    std::string(mac).swap(mac_address);
 
    return(ret);
}
 
static void parse_mac_address(const char * file_name, const char * match_words, std::string & mac_address)
{
    mac_address.c_str();
 
    std::ifstream ifs(file_name, std::ios::binary);
    if (!ifs.is_open())
    {
        return;
    }
 
    char line[4096] = { 0 };
    while (!ifs.eof())
    {
        ifs.getline(line, sizeof(line));
        if (!ifs.good())
        {
            break;
        }
 
        const char * mac = strstr(line, match_words);
        if (NULL == mac)
        {
            continue;
        }
        mac += strlen(match_words);
 
        while ('\0' != mac[0])
        {
            if (' ' != mac[0] && ':' != mac[0])
            {
                mac_address.push_back(mac[0]);
            }
            ++mac;
        }
 
        if (!mac_address.empty())
        {
            break;
        }
    }
 
    ifs.close();
}
 
static bool get_mac_address_by_system(std::string & mac_address)
{
    mac_address.c_str();
 
    const char * lshw_result = ".lshw_result.txt";
    char command[512] = { 0 };
    snprintf(command, sizeof(command), "lshw -c network | grep serial | head -n 1 > %s", lshw_result);
 
    if (0 == system(command))
    {
        parse_mac_address(lshw_result, "serial:", mac_address);
    }
 
    unlink(lshw_result);
 
    return(!mac_address.empty());
}
 
static bool get_mac_address(std::string & mac_address)
{
    if (get_mac_address_by_ioctl(mac_address))
    {
        return(true);
    }
    if (get_mac_address_by_system(mac_address))
    {
        return(true);
    }
    return(false);
}
 
static void test_1()
{
    std::string mac_address;
    if (get_mac_address(mac_address))
    {
        printf("mac_address: [%s]\n", mac_address.c_str());
    }
    else
    {
        printf("can not get mac address\n");
    }
}
 
static void test_2()
{
    {
        std::string mac_address;
        if (get_mac_address_by_ioctl(mac_address))
        {
            printf("mac_address: [%s]\n", mac_address.c_str());
        }
        else
        {
            printf("can not get mac address\n");
        }
    }
    {
        std::string mac_address;
        if (get_mac_address_by_system(mac_address))
        {
            printf("mac_address: [%s]\n", mac_address.c_str());
        }
        else
        {
            printf("can not get mac address\n");
        }
    }
}
 
int main(int argc, char * argv[])
{
    test_1();
    test_2();
    return(0);
}

获取硬盘序列号：

#include <cctype>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <unistd.h>
#include <scsi/sg.h>
#include <sys/ioctl.h>
#include <linux/hdreg.h>
#include <string>
#include <fstream>
 
static bool get_disk_name(std::string & disk_name)
{
    disk_name.c_str();
 
    std::ifstream ifs("/etc/mtab", std::ios::binary);
    if (!ifs.is_open())
    {
        return(false);
    }
 
    char line[4096] = { 0 };
    while (!ifs.eof())
    {
        ifs.getline(line, sizeof(line));
        if (!ifs.good())
        {
            break;
        }
 
        const char * disk = line;
        while (isspace(disk[0]))
        {
            ++disk;
        }
 
        const char * space = strchr(disk, ' ');
        if (NULL == space)
        {
            continue;
        }
 
        const char * mount = space + 1;
        while (isspace(mount[0]))
        {
            ++mount;
        }
        if ('/' != mount[0] || ' ' != mount[1])
        {
            continue;
        }
 
        while (space > disk && isdigit(space[-1]))
        {
            --space;
        }
 
        if (space > disk)
        {
            std::string(disk, space).swap(disk_name);
            break;
        }
    }
 
    ifs.close();
 
    return(!disk_name.empty());
}
 
static void trim_serial(const void * serial, size_t serial_len, std::string & serial_no)
{
    const char * serial_s = static_cast<const char *>(serial);
    const char * serial_e = serial_s + serial_len;
    while (serial_s < serial_e)
    {
        if (isspace(serial_s[0]))
        {
            ++serial_s;
        }
        else if ('\0' == serial_e[-1] || isspace(serial_e[-1]))
        {
            --serial_e;
        }
        else
        {
            break;
        }
    }
 
    if (serial_s < serial_e)
    {
        std::string(serial_s, serial_e).swap(serial_no);
    }
}
 
static bool get_disk_serial_by_way_1(const std::string & disk_name, std::string & serial_no)
{
    serial_no.clear();
 
    int fd = open(disk_name.c_str(), O_RDONLY);
    if (-1 == fd)
    {
        return(false);
    }
 
    struct hd_driveid drive = { 0 };
    if (0 == ioctl(fd, HDIO_GET_IDENTITY, &drive))
    {
        trim_serial(drive.serial_no, sizeof(drive.serial_no), serial_no);
    }
 
    close(fd);
 
    return(!serial_no.empty());
}
 
static bool scsi_io(
                int fd, unsigned char * cdb, 
                unsigned char cdb_size, int xfer_dir, 
                unsigned char * data, unsigned int data_size, 
                unsigned char * sense, unsigned int sense_len
            )
{
    sg_io_hdr_t io_hdr = { 0 };
    io_hdr.interface_id = 'S';
    io_hdr.cmdp = cdb;
    io_hdr.cmd_len = cdb_size;
    io_hdr.sbp = sense;
    io_hdr.mx_sb_len = sense_len;
    io_hdr.dxfer_direction = xfer_dir;
    io_hdr.dxferp = data;
    io_hdr.dxfer_len = data_size;
    io_hdr.timeout = 5000;
 
    if (ioctl(fd, SG_IO, &io_hdr) < 0)
    {
        return(false);
    }
 
    if (SG_INFO_OK != (io_hdr.info & SG_INFO_OK_MASK) && io_hdr.sb_len_wr > 0)
    {
        return(false);
    }
 
    if (io_hdr.masked_status || io_hdr.host_status || io_hdr.driver_status)
    {
        return(false);
    }
 
    return(true);
}
 
static bool get_disk_serial_by_way_2(const std::string & disk_name, std::string & serial_no)
{
    serial_no.clear();
 
    int fd = open(disk_name.c_str(), O_RDONLY);
    if (-1 == fd)
    {
        return(false);
    }
 
    int version = 0;
    if (ioctl(fd, SG_GET_VERSION_NUM, &version) < 0 || version < 30000)
    {
        close(fd);
        return(false);
    }
 
    const unsigned int data_size = 0x00ff;
    unsigned char data[data_size] = { 0 };
    const unsigned int sense_len = 32;
    unsigned char sense[sense_len] = { 0 };
    unsigned char cdb[] = { 0x12, 0x01, 0x80, 0x00, 0x00, 0x00 };
    cdb[3] = (data_size >> 8) & 0xff;
    cdb[4] = (data_size & 0xff);
 
    if (scsi_io(fd, cdb, sizeof(cdb), SG_DXFER_FROM_DEV, data, data_size, sense, sense_len))
    {
        int page_len = data[3];
        trim_serial(data + 4, page_len, serial_no);
    }
 
    close(fd);
 
    return(!serial_no.empty());
}
 
static bool parse_serial(const char * line, int line_size, const char * match_words, std::string & serial_no)
{
    const char * serial_s = strstr(line, match_words);
    if (NULL == serial_s)
    {
        return(false);
    }
    serial_s += strlen(match_words);
    while (isspace(serial_s[0]))
    {
        ++serial_s;
    }
 
    const char * serial_e = line + line_size;
    const char * comma = strchr(serial_s, ',');
    if (NULL != comma)
    {
        serial_e = comma;
    }
 
    while (serial_e > serial_s && isspace(serial_e[-1]))
    {
        --serial_e;
    }
 
    if (serial_e <= serial_s)
    {
        return(false);
    }
 
    std::string(serial_s, serial_e).swap(serial_no);
 
    return(true);
}
 
static void get_serial(const char * file_name, const char * match_words, std::string & serial_no)
{
    serial_no.c_str();
 
    std::ifstream ifs(file_name, std::ios::binary);
    if (!ifs.is_open())
    {
        return;
    }
 
    char line[4096] = { 0 };
    while (!ifs.eof())
    {
        ifs.getline(line, sizeof(line));
        if (!ifs.good())
        {
            break;
        }
 
        if (0 == ifs.gcount())
        {
            continue;
        }
 
        if (parse_serial(line, ifs.gcount() - 1, match_words, serial_no))
        {
            break;
        }
    }
 
    ifs.close();
}
 
static bool get_disk_serial_by_way_3(const std::string & disk_name, std::string & serial_no)
{
    serial_no.c_str();
 
    const char * hdparm_result = ".hdparm_result.txt";
    char command[512] = { 0 };
    snprintf(command, sizeof(command), "hdparm -i %s | grep SerialNo > %s", disk_name.c_str(), hdparm_result);
 
    if (0 == system(command))
    {
        get_serial(hdparm_result, "SerialNo=", serial_no);
    }
 
    unlink(hdparm_result);
 
    return(!serial_no.empty());
}
 
static bool get_disk_serial_by_way_4(std::string & serial_no)
{
    serial_no.c_str();
 
    const char * lshw_result = ".lshw_result.txt";
    char command[512] = { 0 };
    snprintf(command, sizeof(command), "lshw -class disk | grep serial > %s", lshw_result);
 
    if (0 == system(command))
    {
        get_serial(lshw_result, "serial:", serial_no);
    }
 
    unlink(lshw_result);
 
    return(!serial_no.empty());
}
 
static bool get_disk_serial_number(std::string & serial_no)
{
    if (0 != getuid())
    {
        return(false);
    }
 
    std::string disk_name;
    if (get_disk_name(disk_name))
    {
        if (get_disk_serial_by_way_1(disk_name, serial_no))
        {
            return(true);
        }
        if (get_disk_serial_by_way_2(disk_name, serial_no))
        {
            return(true);
        }
        if (get_disk_serial_by_way_3(disk_name, serial_no))
        {
            return(true);
        }
    }
    if (get_disk_serial_by_way_4(serial_no))
    {
        return(true);
    }
    return(false);
}
 
static void test_1()
{
    std::string serial_no;
    if (get_disk_serial_number(serial_no))
    {
        printf("serial_number: [%s]\n", serial_no.c_str());
    }
    else
    {
        printf("get serial number failed\n");
    }
}
 
static void test_2()
{
    std::string disk_name;
    if (get_disk_name(disk_name))
    {
        printf("disk_name:[%s]\n", disk_name.c_str());
        {
            std::string serial_no;
            get_disk_serial_by_way_1(disk_name, serial_no);
            printf("get_serial_by_way_1:[%s]\n", serial_no.c_str());
        }
        {
            std::string serial_no;
            get_disk_serial_by_way_2(disk_name, serial_no);
            printf("get_serial_by_way_2:[%s]\n", serial_no.c_str());
        }
        {
            std::string serial_no;
            get_disk_serial_by_way_3(disk_name, serial_no);
            printf("get_serial_by_way_3:[%s]\n", serial_no.c_str());
        }
    }
    {
        std::string serial_no;
        get_disk_serial_by_way_4(serial_no);
        printf("get_serial_by_way_4:[%s]\n", serial_no.c_str());
    }
}
 
int main(int argc, char * argv[])
{
    printf("---------------\n");
    test_1();
    printf("---------------\n");
    test_2();
    printf("---------------\n");
    return(0);
}

简化：

#include <stdio.h>
#include <sys/ioctl.h>
#include <linux/hdreg.h>
#include <sys/stat.h>
#include <fcntl.h> 
 
static int getdiskid (char *hardc)
{
    int fd;
    struct hd_driveid hid;
    fd = open ("/dev/sda", O_RDONLY);
    if (fd < 0)
    {
        return -1;
    }
    if (ioctl (fd, HDIO_GET_IDENTITY, &hid) < 0)
    {
        return -1;
    }
    close (fd);
    sprintf(hardc,"%s", hid.serial_no);
    return 0;
}
 
int main(void)
{
                 char hardseri[50];
                 getdiskid(hardseri);
                 printf("%s",hardseri);
                 return 0;
}

获取主板序列号：(没有找到纯代码的实现方法)

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <string>
#include <fstream>
 
static void parse_board_serial(const char * file_name, const char * match_words, std::string & board_serial)
{
    board_serial.c_str();
 
    std::ifstream ifs(file_name, std::ios::binary);
    if (!ifs.is_open())
    {
        return;
    }
 
    char line[4096] = { 0 };
    while (!ifs.eof())
    {
        ifs.getline(line, sizeof(line));
        if (!ifs.good())
        {
            break;
        }
 
        const char * board = strstr(line, match_words);
        if (NULL == board)
        {
            continue;
        }
        board += strlen(match_words);
 
        while ('\0' != board[0])
        {
            if (' ' != board[0])
            {
                board_serial.push_back(board[0]);
            }
            ++board;
        }
 
        if ("None" == board_serial)
        {
            board_serial.clear();
            continue;
        }
 
        if (!board_serial.empty())
        {
            break;
        }
    }
 
    ifs.close();
}
 
static bool get_board_serial_by_system(std::string & board_serial)
{
    board_serial.c_str();
 
    const char * dmidecode_result = ".dmidecode_result.txt";
    char command[512] = { 0 };
    snprintf(command, sizeof(command), "dmidecode -t 2 | grep Serial > %s", dmidecode_result);
 
    if (0 == system(command))
    {
        parse_board_serial(dmidecode_result, "Serial Number:", board_serial);
    }
 
    unlink(dmidecode_result);
 
    return(!board_serial.empty());
}
 
static bool get_board_serial_number(std::string & board_serial)
{
    if (0 == getuid())
    {
        if (get_board_serial_by_system(board_serial))
        {
            return(true);
        }
    }
    return(false);
}
 
static void test()
{
    std::string board_serial;
    if (get_board_serial_number(board_serial))
    {
        printf("board_serial: [%s]\n", board_serial.c_str());
    }
    else
    {
        printf("can not get board id\n");
    }
}
 
int main(int argc, char* argv[])
{
    test();
    return(0);
}

方便测试的Makefile:

build :
        g++ -o get_cpu_id get_cpu_id.cpp
        g++ -o get_mac_address get_mac_address.cpp
        g++ -o get_disk_serial_number get_disk_serial_number.cpp
        g++ -o get_board_serial_number get_board_serial_number.cpp

run   :
        @echo "--------------------"
        @- ./get_cpu_id
        @echo "--------------------"
        @- ./get_mac_address
        @echo "--------------------"
        @- ./get_disk_serial_number
        @echo "--------------------"
        @- ./get_board_serial_number
        @echo "--------------------"

clean : 
        -rm get_cpu_id
        -rm get_mac_address
        -rm get_disk_serial_number
        -rm get_board_serial_number

rebuild : clean build

编译：make 或者 make build

运行：make run 或者 sudo make run (上面大多数信息都需要超级用户权限才能获取到结果)

清理：make clean (这个写得太死了，本来是想删除非cpp文件的，shell写不出来)

重编：make rebuild

windows：

命令行：

查看主机序列号：

C:\Users\Administrator>wmic bios get serialnumber
SerialNumber
WB12345678-------->>>>这是我笔记本的主机序列号,在不换主板的情况下,该序列号应该与机器机身上贴的序列号一致
 
C:\Users\Administrator>

查看磁盘序列号：

一、查看ECS实例中块存储的设备名
lsblk
在这里插入图片描述

二、使用以下命令获取块存储设备的序列号

udevadm info --query=all --name=磁盘设备名 | grep ID_SERIAL

例如

udevadm info --query=all --name=/dev/vda | grep ID_SERIAL

在这里插入图片描述
##获取CPU序列号

C:\Users\jesson>wmic CPU get ProcessorID
ProcessorId
BFEBFBFF000206A7

获取mac地址和ip信息

一台机器上可能不只有一个网卡，但每一个网卡只有一个MAC地址，而每一个网卡可能配置有多个IP地址；如平常的笔记本电脑中，就会有无线网卡和有线网卡（网线接口）两种；因此，如果要获得本机所有网卡的IP和MAC地址信息，则必须顺序获得每个网卡，再依次获取其信息等；在windows sdk中，用IP_ADAPTER_INFO结构体存储网卡信息，包括网卡名、网卡描述、网卡MAC地址、网卡IP等，该结构体的主要描述如下所示：

typedef struct _IP_ADAPTER_INFO {
struct _IP_ADAPTER_INFO* Next;//指向链表中下一个适配器信息的指针
DWORD ComboIndex;//预留值
char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4];//使用ANSI字符串表示的适配器名称
char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4];//使用ANSI字符串表示的适配器描述
UINT AddressLength;//适配器硬件地址以字节计算的长度
BYTE Address[MAX_ADAPTER_ADDRESS_LENGTH];//硬件地址以BYTE数组所表示
DWORD Index;//适配器索引
    UINT Type;//适配器类型,主要有以下几种：
    /*
     *   MIB_IF_TYPE_OTHER     1
     *   MIB_IF_TYPE_ETHERNET     6
     *   MIB_IF_TYPE_TOKENRING     9
     *   MIB_IF_TYPE_FDDI     15
     *   MIB_IF_TYPE_PPP     23
     *   MIB_IF_TYPE_LOOPBACK      24
     *   MIB_IF_TYPE_SLIP      28
     */
UINT DhcpEnabled;//指定这个适配器是否开启DHCP
PIP_ADDR_STRING CurrentIpAddress;//预留值
IP_ADDR_STRING IpAddressList;//该适配器的IPv4地址链表
IP_ADDR_STRING GatewayList;//该适配器的网关IPv4地址链表
IP_ADDR_STRING DhcpServer;//该适配器的DHCP服务器的IPv4 地址链表
BOOL HaveWins;
IP_ADDR_STRING PrimaryWinsServer;
IP_ADDR_STRING SecondaryWinsServer;
time_t LeaseObtained;
time_t LeaseExpires;
} IP_ADAPTER_INFO,*PIP_ADAPTER_INFO;

由于可能有多个网卡，因此struct _IP_ADAPTER_INFO* Next字段为一个链表结构指针，由于一个网卡可能有多个IP，因此IP_ADDR_STRING字段应该也是一个链表结构，其信息如下所示：

typedef struct _IP_ADDR_STRING
{
    struct _IP_ADDR_STRING* Next;  //指向同类型节点，即下一个IP（如果有多IP的话）
    IP_ADDRESS_STRING IpAddress;  //IP地址信息
    IP_MASK_STRING IpMask; //IP子网掩码
    DWORD Context;// 网络表入口。这个值对应着AddIPAddredd和DeleteIPAddress函数中的NTEContext参数
} IP_ADDR_STRING;

typedef struct _IP_ADDR_STRING
{
    struct _IP_ADDR_STRING* Next;  
						
							上一篇：							
								cpuid 是否唯一？							
						
						
							下一篇：							
								windows get cpuid


															
						
							推荐阅读						
						
														
								
									
										linux 或 windows 获取唯一的硬件信息 - 命令行和 c++ 代码									
								
							
														
								
									
										Windows 平台、C++ 获取 CPU 型号、读取注册表以获取系统硬件和软件信息代码									
								
							
														
								
									
										windows下进程间通信的（13种方法）-摘 要 本文讨论了进程间通信与应用程序间通信的含义及相应的实现技术，并对这些技术的原理、特性等进行了深入的分析和比较。 
  ---- 关键词 信号 管道 消息队列 共享存储段 信号灯 远程过程调用 Socket套接字 MQSeries 
  
1 引言 
  ---- 进程间通信的主要目的是实现同一计算机系统内部的相互协作的进程之间的数据共享与信息交换，由于这些进程处于同一软件和硬件环境下，利用操作系统提供的的编程接口，用户可以方便地在程序中实现这种通信；应用程序间通信的主要目的是实现不同计算机系统中的相互协作的应用程序之间的数据共享与信息交换，由于应用程序分别运行在不同计算机系统中，它们之间要通过网络之间的协议才能实现数据共享与信息交换。进程间通信和应用程序间通信及相应的实现技术有许多相同之处，也各有自己的特色。即使是同一类型的通信也有多种的实现方法，以适应不同情况的需要。 
  ---- 为了充分认识和掌握这两种通信及相应的实现技术，本文将就以下几个方面对这两种通信进行深入的讨论：问题的由来、解决问题的策略和方法、每种方法的工作原理和实现、每种实现方法的特点和适用的范围等。 
  
2 进程间的通信及其实现技术 
  ---- 用户提交给计算机的任务最终都是通过一个个的进程来完成的。在一组并发进程中的任何两个进程之间，如果都不存在公共变量，则称该组进程为不相交的。在不相交的进程组中，每个进程都独立于其它进程，它的运行环境与顺序程序一样，而且它的运行环境也不为别的进程所改变。运行的结果是确定的，不会发生与时间相关的错误。 
  ---- 但是，在实际中，并发进程的各个进程之间并不是完全互相独立的，它们之间往往存在着相互制约的关系。进程之间的相互制约关系表现为两种方式： 
  ---- （1） 间接相互制约：共享CPU 
  ---- （2） 直接相互制约：竞争和协作 
  ---- 竞争——进程对共享资源的竞争。为保证进程互斥地访问共享资源，各进程必须互斥地进入各自的临界段。 
  ---- 协作——进程之间交换数据。为完成一个共同任务而同时运行的一组进程称为同组进程，它们之间必须交换数据，以达到协作完成任务的目的，交换数据可以通知对方可以做某事或者委托对方做某事。 
  ---- 共享CPU问题由操作系统的进程调度来实现，进程间的竞争和协作由进程间的通信来完成。进程间的通信一般由操作系统提供编程接口，由程序员在程序中实现。UNIX在这个方面可以说最具特色，它提供了一整套进程间的数据共享与信息交换的处理方法——进程通信机制（IPC）。因此，我们就以UNIX为例来分析进程间通信的各种实现技术。 
  ---- 在UNIX中，文件（File）、信号（Signal）、无名管道（Unnamed Pipes）、有名管道（FIFOs）是传统IPC功能；新的IPC功能包括消息队列（Message queues）、共享存储段（Shared memory segment）和信号灯（Semapores）。 
  ---- （1） 信号 
  ---- 信号机制是UNIX为进程中断处理而设置的。它只是一组预定义的值，因此不能用于信息交换，仅用于进程中断控制。例如在发生浮点错、非法内存访问、执行无效指令、某些按键（如ctrl-c、del等）等都会产生一个信号，操作系统就会调用有关的系统调用或用户定义的处理过程来处理。 
  ---- 信号处理的系统调用是signal，调用形式是： 
  ---- signal(signalno,action) 
  ---- 其中，signalno是规定信号编号的值，action指明当特定的信号发生时所执行的动作。 
  ---- （2） 无名管道和有名管道 
  ---- 无名管道实际上是内存中的一个临时存储区，它由系统安全控制，并且独立于创建它的进程的内存区。管道对数据采用先进先出方式管理，并严格按顺序操作，例如不能对管道进行搜索，管道中的信息只能读一次。 
  ---- 无名管道只能用于两个相互协作的进程之间的通信，并且访问无名管道的进程必须有共同的祖先。 
  ---- 系统提供了许多标准管道库函数，如： 
  pipe——打开一个可以读写的管道；
close——关闭相应的管道；
read——从管道中读取字符；
write——向管道中写入字符；
 
  ---- 有名管道的操作和无名管道类似，不同的地方在于使用有名管道的进程不需要具有共同的祖先，其它进程，只要知道该管道的名字，就可以访问它。管道非常适合进程之间快速交换信息。 
  ---- （3） 消息队列（MQ） 
  ---- 消息队列是内存中独立于生成它的进程的一段存储区，一旦创建消息队列，任何进程，只要具有正确的的访问权限，都可以访问消息队列，消息队列非常适合于在进程间交换短信息。 
  ---- 消息队列的每条消息由类型编号来分类，这样接收进程可以选择读取特定的消息类型——这一点与管道不同。消息队列在创建后将一直存在，直到使用msgctl系统调用或iqcrm -q命令删除它为止。 
  ---- 系统提供了许多有关创建、使用和管理消息队列的系统调用，如： 
  ---- int msgget(key,flag)——创建一个具有flag权限的MQ及其相应的结构，并返回一个唯一的正整数msqid（MQ的标识符）； 
  ---- int msgsnd(msqid,msgp,msgsz,msgtyp,flag)——向队列中发送信息； 
  ---- int msgrcv(msqid,cmd,buf)——从队列中接收信息； 
  ---- int msgctl(msqid,cmd,buf)——对MQ的控制操作； 
  ---- （4） 共享存储段（SM） 
  ---- 共享存储段是主存的一部分，它由一个或多个独立的进程共享。各进程的数据段与共享存储段相关联，对每个进程来说，共享存储段有不同的虚拟地址。系统提供的有关SM的系统调用有： 
  ---- int shmget(key,size,flag)——创建大小为size的SM段，其相应的数据结构名为key，并返回共享内存区的标识符shmid； 
  ---- char shmat(shmid,address,flag)——将当前进程数据段的地址赋给shmget所返回的名为shmid的SM段； 
  ---- int shmdr(address)——从进程地址空间删除SM段； 
  ---- int shmctl (shmid,cmd,buf)——对SM的控制操作； 
  ---- SM的大小只受主存限制，SM段的访问及进程间的信息交换可以通过同步读写来完成。同步通常由信号灯来实现。SM非常适合进程之间大量数据的共享。 
  ---- （5） 信号灯 
  ---- 在UNIX中，信号灯是一组进程共享的数据结构，当几个进程竞争同一资源时（文件、共享内存或消息队列等），它们的操作便由信号灯来同步，以防止互相干扰。 
  ---- 信号灯保证了某一时刻只有一个进程访问某一临界资源，所有请求该资源的其它进程都将被挂起，一旦该资源得到释放，系统才允许其它进程访问该资源。信号灯通常配对使用，以便实现资源的加锁和解锁。 
  ---- 进程间通信的实现技术的特点是：操作系统提供实现机制和编程接口，由用户在程序中实现，保证进程间可以进行快速的信息交换和大量数据的共享。但是，上述方式主要适合在同一台计算机系统内部的进程之间的通信。 
  
3 应用程序间的通信及其实现技术 
  ---- 同进程之间的相互制约一样，不同的应用程序之间也存在竞争和协作的关系。UNIX操作系统也提供一些可用于应用程序之间实现数据共享与信息交换的编程接口，程序员可以通过自己编程来实现。如远程过程调用和基于TCP/IP协议的套接字（Socket）编程。但是，相对普通程序员来说，它们涉及的技术比较深，编程也比较复杂，实现起来困难较大。 
  ---- 于是，一种新的技术应运而生——通过将有关通信的细节完全掩盖在某个独立软件内部，即底层的通讯工作和相应的维护管理工作由该软件内部来实现，用户只需要将通信任务提交给该软件去完成，而不必理会它的具体工作过程——这就是所谓的中间件技术。 
  ---- 我们在这里分别讨论这三种常用的应用程序间通信的实现技术——远程过程调用、会话编程技术和MQSeries消息队列技术。其中远程过程调用和会话编程属于比较低级的方式，程序员参与的程度较深，而MQSeries消息队列则属于比较高级的方式，即中间件方式，程序员参与的程度较浅。 
  ---- 4．1 远程过程调用（RPC）