用windows api获取mac地址和硬盘id编号

1. 获取机器的MAC地址真的有很多种方法。可以通过windows api，可以通过wmi服务等。MSDN上面的例子是使用IP helper函数GetAdaptersInfo。其实还有一个api，是GetAdaptersAddresses。NetBios和DDK的方法不推荐使用，低于api层次的调用不保证微软会淘汰掉。建立一个支持MFC的控制台程序:

stdafx.h

1. #include <vector>
   
2. #include <string>
   
3. typedef std::vector< std::string > MACAddresses;
   
4. typedef MACAddresses::iterator vsIt;

GetNetBiosMacAddresses.cpp

1. #include "stdafx.h" 
   
2. #include <windows.h> 
   
3. #include <wincon.h> 
   
4. #include <stdio.h> 
   
5. #include <nb30.h> 
   
6. // Netbios is not supported on Windows Vista, Windows Server 2008, and subsequent versions of the operating system]l
   
7. // For using NetAPI to get MAC, should include nb30.h
   
8. #define MACSESION 6
   
9. #pragma warning( disable : 4996 )
   
10. #pragma comment(lib,"Netapi32.lib")
    
11. typedef struct _ASTAT_ 
    
12. { 
    
13.     ADAPTER_STATUS adapt; 
    
14.     NAME_BUFFER NameBuff [30]; 
    
15. }ASTAT, * PASTAT; 
    
16.   
    
17. ASTAT Adapter; // to store MAC information 
    
18. // input parameter: lana_num start from 0, but in windows, not continuously allocated, so not reliable.
    
19. std::string getmac_one( int lana_num )
    
20. { 
    
21.     NCB ncb; 
    
22.     UCHAR uRetCode; 
    
23.   
    
24.     memset( &ncb, 0, sizeof( ncb ) ); 
    
25.     ncb.ncb_command = NCBRESET; 
    
26.     ncb.ncb_lana_num = lana_num; 
    
27.     
    
28.     uRetCode = Netbios( &ncb ); 
    
29.     //printf( "The NCBRESET return code is:0x%x \n", uRetCode ); 
    
30.   
    
31.     memset( &ncb, 0, sizeof( ncb ) ); 
    
32.     ncb.ncb_command = NCBASTAT; 
    
33.     ncb.ncb_lana_num = lana_num; 
    
34.   
    
35.     strcpy( (char *)ncb.ncb_callname, "* " ); 
    
36.     ncb.ncb_buffer = ( unsigned char * ) &Adapter; 
    
37.   
    
38.     ncb.ncb_length = sizeof( Adapter ); 
    
39.     uRetCode = Netbios( &ncb ); 
    
40.     // printf( "The NCBASTAT return code is: 0x%x \n", uRetCode );
    
41.     std::string s;
    
42.     if ( uRetCode == 0 ) 
    
43.     {
    
44.         int bAddressInt [ MACSESION ];
    
45.         char CommarSeperatedAddress[ MACSESION * 3 ]={0};
    
46.         for( int i = 0; i < MACSESION; ++i )
    
47.         {
    
48.             bAddressInt[ i ] = Adapter.adapt.adapter_address[ i ];
    
49.             bAddressInt[ i ] &= 0x000000ff; // avoid "ff" leading bytes when "char" is lager then 0x7f
    
50.         }
    
51.         sprintf( CommarSeperatedAddress, "%02x:%02x:%02x:%02x:%02x:%02x",
    
52.                                bAddressInt[ 0 ],
    
53.                                bAddressInt[ 1 ],
    
54.                                bAddressInt[ 2 ],
    
55.                                bAddressInt[ 3 ],
    
56.                                bAddressInt[ 4 ],
    
57.                                bAddressInt[ 5 ]); // Should use scl::FormatString inside 
    
58.         s = CommarSeperatedAddress;
    
59.     }
    
60.     return s;
    
61. }
    
62. 
    
63. MACAddresses GetNetBiosMacAddresses()
    
64. {
    
65.     NCB ncb; 
    
66.     UCHAR uRetCode; 
    
67.     LANA_ENUM lana_enum; 
    
68.     memset( &ncb, 0, sizeof( ncb ) ); 
    
69.     ncb.ncb_command = NCBENUM; 
    
70.   
    
71.     ncb.ncb_buffer = (unsigned char *) &lana_enum; 
    
72.     ncb.ncb_length = sizeof( lana_enum ); 
    
73.   
    
74.     uRetCode = Netbios( &ncb ); 
    
75.     //printf( "The NCBENUM return code is:0x%x \n", uRetCode );
    
76.     MACAddresses vAdd;
    
77.     if ( uRetCode == 0 ) 
    
78.     { 
    
79.         //printf( "Ethernet Count is : %d\n\n", lana_enum.length); 
    
80.         for ( int i=0; i < lana_enum.length; ++i )
    
81.         {
    
82.             std::string s = getmac_one( lana_enum.lana[i] ); 
    
83.             if( ! s.empty() )
    
84.             {
    
85.                 vAdd.push_back( s );
    
86.             }
    
87.         }
    
88.     }
    
89.     return vAdd;
    
90. }

GetMacAddresses.cpp

1. #include "stdafx.h"
   
2. #include <Winsock2.h>
   
3. #include <Iphlpapi.h>
   
4. #pragma comment(lib,"Iphlpapi")
   
5. #pragma warning( disable : 4996 )
   
6. #define MACSESION 6
   
7. MACAddresses GetINETMacAddresses()
   
8. {
   
9.     PIP_ADAPTER_ADDRESSES pAddresses = NULL;
   
10.     ULONG family = AF_INET;
    
11.     ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
    
12.     ULONG outBufLen = sizeof( IP_ADAPTER_ADDRESSES );
    
13. 
    
14.     // Make an initial call to GetAdaptersAddresses to get the 
    
15.     // size needed into the outBufLen variable
    
16.     if ( GetAdaptersAddresses( family, flags, NULL, pAddresses, &outBufLen ) == ERROR_BUFFER_OVERFLOW )
    
17.     {
    
18.         pAddresses = static_cast<PIP_ADAPTER_ADDRESSES>( HeapAlloc( GetProcessHeap(), 0, outBufLen ) );
    
19.     }
    
20. 
    
21.     _ASSERT( pAddresses );
    
22.     // Make a second call to GetAdapters Addresses to get the
    
23.     // actual data we want
    
24.     DWORD dwRetVal = GetAdaptersAddresses( family, flags, NULL, pAddresses, &outBufLen );
    
25. 
    
26.     MACAddresses vAddress;
    
27.     if ( dwRetVal != ERROR_SUCCESS )
    
28.     {
    
29.         return vAddress;
    
30.     }
    
31.     PIP_ADAPTER_ADDRESSES pFirst = pAddresses;
    
32.     while( pAddresses )
    
33.     {
    
34.         BYTE* pa = pAddresses->PhysicalAddress;
    
35.         if ( ! pa || ! pa[ 0 ] )
    
36.         {
    
37.             break;
    
38.         }
    
39.         char bAddressBytes[ MACSESION ];
    
40.         int bAddressInt [ MACSESION ];
    
41.         memset( bAddressBytes, 0, MACSESION );
    
42.         size_t nAddressSize = pAddresses->PhysicalAddressLength;
    
43.         memcpy( bAddressBytes, pa, ( nAddressSize < MACSESION ? nAddressSize : MACSESION ));
    
44.         char CommarSeperatedAddress[ MACSESION * 3 ]={0};
    
45.         for( int i = 0; i < MACSESION; ++i )
    
46.         {
    
47.             bAddressInt[ i ] = bAddressBytes[ i ];
    
48.             bAddressInt[ i ] &= 0x000000ff; // avoid "ff" leading bytes when "char" is lager then 0x7f
    
49.         }
    
50.         sprintf( CommarSeperatedAddress, "%02x:%02x:%02x:%02x:%02x:%02x",
    
51.                                bAddressInt[ 0 ],
    
52.                                bAddressInt[ 1 ],
    
53.                                bAddressInt[ 2 ],
    
54.                                bAddressInt[ 3 ],
    
55.                                bAddressInt[ 4 ],
    
56.                                bAddressInt[ 5 ]); // Should use scl::FormatString inside 
    
57.         pAddresses = pAddresses->Next ? pAddresses->Next : NULL;
    
58.         vAddress.push_back( std::string( CommarSeperatedAddress ) );
    
59.     }
    
60.     HeapFree( GetProcessHeap(), 0, pFirst );
    
61.     return vAddress;
    
62. }

2. 获取硬盘的id, api函数得到的都是和windows安装相关的id，也就是windows硬件管理器分配的id，而不是真正的硬件生产厂商的id. 所以，为了得到真正的和硬盘序列号相关的信息，最好是使用WMI服务查询。

GetPartitionVolumeSerialNumber.cpp

1. #include "stdafx.h"
   
2. DWORD GetPartitionVolumeSerialNumber() // Get Disk partition volumn id, not hard disk id
   
3. {
   
4.     TCHAR lpRootPathName[]= _T( "\\\\.\\PhysicalDrive0\\" ); // Use physical drive, not C:disk
   
5.     TCHAR lpVolumeNameBuffer[ 12 ]; //disk volumn
   
6.     DWORD nVolumeNameSize =12; 
   
7.     DWORD VolumeSerialNumber; // Serial number
   
8.     DWORD MaximumComponentLength; 
   
9.     TCHAR lpFileSystemNameBuffer[ 10 ]; 
   
10.     DWORD nFileSystemNameSize = 10; 
    
11.     DWORD FileSystemFlags; 
    
12.     BOOL ret = GetVolumeInformation( lpRootPathName, 
    
13.                                      lpVolumeNameBuffer,
    
14.                                      nVolumeNameSize, 
    
15.                                      &VolumeSerialNumber,
    
16.                                      &MaximumComponentLength, 
    
17.                                      &FileSystemFlags, 
    
18.                                      lpFileSystemNameBuffer,
    
19.                                      nFileSystemNameSize); 
    
20. 
    
21.     printf( "Partition serial number is %0xd\n", VolumeSerialNumber );
    
22.     if( ret )
    
23.     {
    
24.         return VolumeSerialNumber;
    
25.     }
    
26.     else
    
27.     {
    
28.         return FALSE;
    
29.     }
    
30. }

GetPhysicalSerialNumber.cpp

1. #include "stdafx.h"
   
2. #include <Iphlpapi.h>
   
3. #pragma comment(lib,"Iphlpapi")
   
4. //#pragma warning( disable : 4996 )
   
5. // IOCTL command constants
   
6. #define DFP_GET_VERSION 0x00074080
   
7. #define DFP_RECEIVE_DRIVE_DATA 0x0007c088
   
8. // values for IDEREGS.bCommandReg
   
9. #define IDE_ATAPI_IDENTIFY 0xA1
   
10. #define IDE_ATA_IDENTIFY 0xEC
    
11. #define IDENTIFY_BUFFER_SIZE 512
    
12. 
    
13. //save disk information
    
14. typedef struct _GETVERSIONOUTPARAMS
    
15. {
    
16.     BYTE bVersion;
    
17.     BYTE bRevision;
    
18.     BYTE bReserved;
    
19.     BYTE bIDEDeviceMap;
    
20.     DWORD fCapabilities;
    
21.     DWORD dwReserved[4];
    
22. } GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;
    
23. // IDE register information
    
24. typedef struct _IDEREGS
    
25. {
    
26.     BYTE bFeaturesReg;
    
27.     BYTE bSectorCountReg;
    
28.     BYTE bSectorNumberReg;
    
29.     BYTE bCylLowReg;
    
30.     BYTE bCylHighReg;
    
31.     BYTE bDriveHeadReg;
    
32.     BYTE bCommandReg;
    
33.     BYTE bReserved;
    
34. } IDEREGS, *PIDEREGS, *LPIDEREGS;
    
35. // disk command input parameter
    
36. typedef struct _SENDCMDINPARAMS
    
37. {
    
38.     DWORD cBufferSize;
    
39.     IDEREGS irDriveRegs;
    
40.     BYTE bDriveNumber;
    
41.     BYTE bReserved[3];
    
42.     DWORD dwReserved[4];
    
43.     BYTE bBuffer[1];
    
44. } SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
    
45. // disk status
    
46. typedef struct _DRIVERSTATUS
    
47. {
    
48.     BYTE bDriverError;
    
49.     BYTE bIDEStatus;
    
50.     BYTE bReserved[2];
    
51.     DWORD dwReserved[2];
    
52. } DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;
    
53. // sent param for disk commands
    
54. typedef struct _SENDCMDOUTPARAMS
    
55. {
    
56.     DWORD cBufferSize;
    
57.     DRIVERSTATUS DriverStatus;
    
58.     BYTE bBuffer[1];
    
59. } SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;
    
60. void GetDiskPhysicalSN(char pchDiskPhysicalSN[14])
    
61. {
    
62.     BYTE IdOutCmd[530];
    
63.     HANDLE drive=CreateFile(L"\\\\.\\PhysicalDrive0", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL );
    
64.     if ( drive == INVALID_HANDLE_VALUE )
    
65.     {
    
66.         pchDiskPhysicalSN[ 0 ] = 0;
    
67.         return ;
    
68.     }
    
69.     GETVERSIONOUTPARAMS VersionParams;
    
70.     DWORD cbBytesReturned = 0;
    
71.     memset( ( void* ) &VersionParams, 0, sizeof( VersionParams ) );
    
72.     if ( ! DeviceIoControl( drive, DFP_GET_VERSION, NULL, 0, &VersionParams, sizeof( VersionParams ), &cbBytesReturned, NULL ) )
    
73.     {
    
74.         pchDiskPhysicalSN[ 0 ] = 0;
    
75.         return ;
    
76.     }
    
77.     if (VersionParams.bIDEDeviceMap<=0)
    
78.     {
    
79.         pchDiskPhysicalSN[ 0 ] = 0;
    
80.         return ;
    
81.     }
    
82.     BYTE bIDCmd = 0;
    
83.     SENDCMDINPARAMS scip;
    
84.     bIDCmd = ( VersionParams.bIDEDeviceMap >> 0 & 0x10 ) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
    
85.     memset( &scip, 0, sizeof( scip) );
    
86.     memset( IdOutCmd, 0, sizeof( IdOutCmd ) );
    
87.     scip.cBufferSize = IDENTIFY_BUFFER_SIZE;
    
88.     scip.irDriveRegs.bFeaturesReg = 0;
    
89.     scip.irDriveRegs.bSectorCountReg = 1;
    
90.     scip.irDriveRegs.bSectorNumberReg = 1;
    
91.     scip.irDriveRegs.bCylLowReg = 0;
    
92.     scip.irDriveRegs.bCylHighReg = 0;
    
93.     scip.irDriveRegs.bDriveHeadReg= 0xA0 | ( ( ( BYTE ) drive & 1 ) << 4 );
    
94.     scip.irDriveRegs.bCommandReg = bIDCmd;
    
95.     scip.bDriveNumber = ( BYTE ) drive;
    
96.     scip.cBufferSize = IDENTIFY_BUFFER_SIZE;
    
97.     if ( ! DeviceIoControl( drive, DFP_RECEIVE_DRIVE_DATA, &scip, sizeof( SENDCMDINPARAMS)- 1, ( LPVOID )&IdOutCmd, sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE - 1, &cbBytesReturned, NULL ) )
    
98.     {
    
99.         pchDiskPhysicalSN[ 0 ] = 0;
    
100.         return ;
     
101.     }
     
102.     USHORT *pIdSector = ( USHORT * )( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer;
     
103.     int nPosition = 0;
     
104.     for( int nIndex = 13; nIndex < 20; nIndex++ )
     
105.     {
     
106.         pchDiskPhysicalSN[ nPosition++ ]=( unsigned char )( pIdSector[ nIndex ] / 256 );
     
107.         pchDiskPhysicalSN[ nPosition++ ]=( unsigned char )( pIdSector[ nIndex ] % 256 );
     
108.     }
     
109. }
     
110. 
     
111. void GetDiskPhysicalSerialNumber( char* pchSerialNumber )
     
112. {
     
113.     char pchDiskPhysicalSN[ 14 ];
     
114.     GetDiskPhysicalSN( pchDiskPhysicalSN );
     
115.     int nSerial[ 14 ];
     
116.     for( int i = 0 ; i < 14; ++ i )
     
117.     {
     
118.         nSerial[ i ] = pchDiskPhysicalSN[ i ];
     
119.         nSerial[ i ] &= 0x000000ff;
     
120.     }
     
121.     sprintf( pchSerialNumber, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
     
122.                                nSerial[ 0 ],
     
123.                                nSerial[ 1 ],
     
124.                                nSerial[ 2 ],
     
125.                                nSerial[ 3 ],
     
126.                                nSerial[ 4 ],
     
127.                                nSerial[ 5 ],
     
128.                                nSerial[ 6 ],
     
129.                                nSerial[ 7 ],
     
130.                                nSerial[ 8 ],
     
131.                                nSerial[ 9 ],
     
132.                                nSerial[ 10 ],
     
133.                                nSerial[ 11 ],
     
134.                                nSerial[ 12 ],
     
135.                                nSerial[ 13 ]); // Should use scl::FormatString inside 
     
136. }

main.cpp

1. #include "stdafx.h" 
   
2. MACAddresses GetINETMacAddresses();
   
3. MACAddresses GetNetBiosMacAddresses();
   
4. DWORD GetPartitionVolumeSerialNumber();
   
5. void GetDiskPhysicalSerialNumber( char* pchDiskPhysicalSN );
   
6. int main(int argc, char* argv[]) 
   
7. {
   
8.     DWORD VolumeSerialNumber = 0;
   
9.     if( ! GetPartitionVolumeSerialNumber() )
   
10.     {
    
11.         TRACE( "(Get Disk Partition ID met error : %d)\n", GetLastError() );
    
12.     }
    
13.     else
    
14.     {
    
15.         printf( "Disk Partition ID = %0xd\n", VolumeSerialNumber );
    
16.     }
    
17.     char pchSerialNumber[ 50 ];
    
18.     GetDiskPhysicalSerialNumber( pchSerialNumber );
    
19.     printf("PhysicalSerialNumber is %s\n", pchSerialNumber );
    
20.     printf("--------\n");
    
21. 
    
22.     MACAddresses& vAddresses = GetINETMacAddresses();
    
23.     for( vsIt it = vAddresses.begin(); it != vAddresses.end(); ++ it )
    
24.     {
    
25.         printf( "INET MAC addresses = %s\n", it->c_str() );
    
26.     }
    
27.     MACAddresses& vAddresses2 = GetNetBiosMacAddresses();
    
28.     for( vsIt it = vAddresses2.begin(); it != vAddresses2.end(); ++ it )
    
29.     {
    
30.         printf( "NetBios MAC addresses = %s\n", it->c_str() );
    
31.     }
    
32.     return 0; 
    
33. }

FROM:  http://blog.chinaunix.net/uid-22754909-id-332321.html

参考：

VC获取mac地址

 

http://blog.sina.com.cn/s/blog_5fbf45780100k5lh.html

.获取MAC地址方法大全

http://blog.csdn.net/han2814675/article/details/6223617