NetBIOS网络编程

最新推荐文章于 2022-09-06 07:43:57 发布
转载 最新推荐文章于 2022-09-06 07:43:57 发布 · 1.2k 阅读 · 2
文章标签：

#c++

本文介绍了NetBIOS网络编程的基础知识及其应用场景，包括NetBIOS的定义、特点及其实现方式。文中还提供了三个示例程序，分别展示了如何获取局域网上的NetBIOS名称、如何获取网络适配器的MAC地址以及如何获取指定计算机的基本信息。

NetBIOS网络编程

        “网络基本输入/输出系统”（Network Basic Input/Output System，NetBIOS）是1983年由Sytex公司为IBM公司开发的一种标准应用程序编程接口，并被微软采用。1985年，IBM改进了NetBIOS，推出了NetBIOS扩展用户接口（NetBIOS Extended User Interface,NetBEUI）通信协议，它占用内存少，配置简单，适用于小型局域网不同计算机之间的通信，但不具有跨网段工作的能力，不支持路由机制。NetBIOS是一种与“协议无关”的编程接口，它使应用程序不用理解网络细节，应用程序可通过TCP/IP、NetBEUI、SPX/IPX运行。

        它定义了一种软件接口以及在应用程序连接介质之间提供通信接口的标准方法，它可以人提供名字服务、会话服务和数据库服务，基于NetBIOS的比较典型的应用是远程计算机的Mac地址、名称和所在工作组等信息。

 

PS：网上很多说NetBIOS网络编程已经过时了，不过还是稍做了解吧~

(以下为个人概括的五点，如有什么不是很对的地方，欢迎指正)

重点1：它是基于会话层的服务。

重点2：它可以让两台机器相互连接，建立通信。

重点3：它可以基于UDP或者TCP实现。

重点4：实现这个NetBIOS与基本的TCP/IP编程的最大不同点就是向另一台机发送的是NetBIOS请求包，接收的是NetBIOS回应包，然后对NetBIOS回应包进行解释，其编程思路与TCP/IP编程基本相似，只是一些recv和send的东西不同。

重点5: 它的实现，也可以在“cmd”中使用nbtstat指令体现。

 

下面是三个与NetBIOS网络编程稍有关系的实例应用：

01. GetNetBIOSNames.cpp -- 获取LANA上所有NetBIOS名字

02. GetMacAddress.cpp -- 获取网络适配器上的MAC地址

03. NbtStat.cpp -- 获取网络中指定计算机的基本信息

 

源代码：

01. GetNetBIOSNames.cpp -- 获取LANA上所有NetBIOS名字

[cpp]  view plain  copy
  1. [cpp] view plaincopyprint?  
  2. 01.// GetNetBIOSNames.cpp -- 获取LANA上所有NetBIOS名字    
  3. 02.    
  4. 03.#include <windows.h>    
  5. 04.#include <stdlib.h>    
  6. 05.#include <stdio.h>    
  7. 06.#include <Nb30.h>    
  8. 07.    
  9. 08.#pragma comment(lib, "netapi32.lib")    
  10. 09.    
  11. 10.// Set LANANUM and LOCALNAME as appropriate for your system    
  12. 11.#define LANANUM     0    
  13. 12.#define LOCALNAME   "UNIQUENAME"    
  14. 13.#define NBCheck(x)  if (NRC_GOODRET != x.ncb_retcode) { \    
  15. 14.                        printf("Line %d: Got 0x%x from NetBios()\n", \    
  16. 15.                               __LINE__, x.ncb_retcode); \    
  17. 16.                    }    
  18. 17.    
  19. 18.void MakeNetbiosName (char *, LPCSTR);    
  20. 19.BOOL NBReset (int, int, int);    
  21. 20.BOOL NBAddName (int, LPCSTR);    
  22. 21.BOOL NBListNames (int, LPCSTR);    
  23. 22.BOOL NBAdapterStatus (int, PVOID, int, LPCSTR);    
  24. 23.    
  25. 24.int main()    
  26. 25.{    
  27. 26.    // 初始化，清空本地名字表和会话表    
  28. 27.    if (!NBReset (LANANUM, 20, 30)){    
  29. 28.        return -1;    
  30. 29.    }    
  31. 30.    // 向本地名字表中添加UNIQUENAME    
  32. 31.    if (!NBAddName (LANANUM, LOCALNAME)) {    
  33. 32.        return -1;    
  34. 33.    }    
  35. 34.    // 列出本地名字表中的名字    
  36. 35.    if (!NBListNames (LANANUM, LOCALNAME)) {    
  37. 36.        return -1;    
  38. 37.    }    
  39. 38.    printf ("Succeeded.\n");    
  40. 39.    system("pause");    
  41. 40.    return 0;    
  42. 41.}    
  43. 42.    
  44. 43./**  
  45. 44. * NCB结构体的定义:  
  46. 45. * typedef struct _NCB{  
  47. 46. *   UCHAR ncb_command;  // 指定命令编码以及表明NCB结构体是否被异步处理的标识  
  48. 47. *   UCHAR ncb_retcode;  // 指定命令的返回编码  
  49. 48. *   UCHAR ncb_lsn;      // 表示本地会话编号，在指定环境中此编号唯一标识一个会话  
  50. 49. *   UCHAR ncb_num;      // 指定本地网络名字编号。  
  51. 50. *   PUCHAR ncb_buffer;  // 指定消息缓冲区。（有发送信息、接收信息、接收请求状态信息三个缓冲区）  
  52. 51. *   WORD ncb_length;    // 指定消息缓冲区的大小，单位为字节。  
  53. 52. *   UCHAR ncb_callname[NCBNAMSZ]; // 指定远程端应用程序的名字  
  54. 53. *   UCHAR ncb_name[NCBNAMSZ];     // 指定应用程序可以识别的名字  
  55. 54. *   UCHAR ncb_rto;                // 指定会话执行接收操作的超时时间  
  56. 55. *   void (CALLBACK * ncb_post)(struct NCB);  
  57. 56. *   UCHAR ncb_lana_num;           // 指定LANA编号  
  58. 57. *   UCHAR ncb_cmd_cplt;           // 指定命令完成标识  
  59. 58. *   UCHAR ncb_reserve[X];         // 保留字段  
  60. 59. *   HANDLE ncb_event;             // 指向事件对象的句柄  
  61. 60. * }NCB, *PNCB;  
  62. 61. **/    
  63. 62.    
  64. 63.    
  65. 64.// 清空本地名字和会话表    
  66. 65.BOOL NBReset (int nLana, int nSessions, int nNames)    
  67. 66.{    
  68. 67.    NCB ncb;    
  69. 68.    memset (&ncb, 0, sizeof (ncb));     // 清空ncb结构体    
  70. 69.    ncb.ncb_command = NCBRESET;         // 执行NCBRESET命令，复位局域网网络适配器，清空指定LANA编号上定义的本地名字表和会话表。    
  71. 70.    ncb.ncb_lsn = 0;                    // 分配新的lana_num资源，Netbios()函数成功执行了NCBCALL命令后返回的编号    
  72. 71.    ncb.ncb_lana_num = nLana;           // 设置lana_num资源，指定本地网络名字编号。    
  73. 72.    ncb.ncb_callname[0] = nSessions;    // 设置最大会话数    
  74. 73.    ncb.ncb_callname[2] = nNames;       // 设置最大名字数    
  75. 74.    Netbios (&ncb);                     // 执行NCBRESET命令    
  76. 75.    NBCheck (ncb);                      // 如果执行结果不正确，则输出ncb.ncb_retcode    
  77. 76.    // 如果成功返回TRUE，否则返回FALSE    
  78. 77.    return (NRC_GOODRET == ncb.ncb_retcode);    
  79. 78.}    
  80. 79.    
  81. 80.    
  82. 81.// 向本地名字表中添加名字    
  83. 82.BOOL NBAddName (int nLana, LPCSTR szName)    
  84. 83.{    
  85. 84.    NCB ncb;    
  86. 85.    memset (&ncb, 0, sizeof (ncb));     // 清空ncb结构体    
  87. 86.    ncb.ncb_command = NCBADDNAME;       // 执行NCBDDNAME命令，向本地名字表中添加一个唯一的名字    
  88. 87.    ncb.ncb_lana_num = nLana;           // 设置lana_num资源，指定本地网络名字编号。    
  89. 88.    MakeNetbiosName ((char*) ncb.ncb_name, szName); // 将szName赋值到ncb.ncb_name中    
  90. 89.    Netbios (&ncb);                     // 执行NCBRESET命令    
  91. 90.    NBCheck (ncb);                      // 如果执行结果不正确，则输出ncb.ncb_retcode    
  92. 91.    // 如果成功返回TRUE，否则返回FALSE    
  93. 92.    return (NRC_GOODRET == ncb.ncb_retcode);    
  94. 93.}    
  95. 94.    
  96. 95.    
  97. 96.// Build a name of length NCBNAMSZ, padding with spaces.    
  98. 97.// 将szSrc中的名字赋值到achDest中，名字的长度为NCBNAMESZ    
  99. 98.// 如果不足，则使用空格补齐    
  100. 99.void MakeNetbiosName (char *achDest, LPCSTR szSrc)    
  101. 100.{    
  102. 101.    int cchSrc = strlen ((char*)szSrc); // 取名字的长度    
  103. 102.    if (cchSrc > NCBNAMSZ){    
  104. 103.        cchSrc = NCBNAMSZ;    
  105. 104.    }    
  106. 105.    memset (achDest, ' ', NCBNAMSZ);    
  107. 106.    memcpy (achDest, szSrc, cchSrc);    
  108. 107.}    
  109. 108.    
  110. 109.// 列出指定LANA上所有的名字    
  111. 110.BOOL NBListNames (int nLana, LPCSTR szName)    
  112. 111.{    
  113. 112.    int cbBuffer;                   // 获取数据的缓冲区    
  114. 113.    ADAPTER_STATUS *pStatus;        // 保存网络适配器的信息    
  115. 114.    NAME_BUFFER *pNames;            // 保存本地名字信息    
  116. 115.    HANDLE hHeap;                   // 当前调用进程的堆句柄    
  117. 116.    
  118. 117.    hHeap = GetProcessHeap();       // 当前调用进程的堆句柄    
  119. 118.    cbBuffer = sizeof (ADAPTER_STATUS) + 255 * sizeof (NAME_BUFFER);// 分配可能的最大缓冲区空间    
  120. 119.    pStatus = (ADAPTER_STATUS *) HeapAlloc (hHeap, 0, cbBuffer);// 为pStatus分配空间    
  121. 120.    if (NULL == pStatus){    
  122. 121.        return FALSE;    
  123. 122.    }    
  124. 123.    // 获取本地网络适配器信息，结果保存到pStatus中    
  125. 124.    if (!NBAdapterStatus (nLana, (PVOID) pStatus, cbBuffer, szName)){    
  126. 125.        HeapFree (hHeap, 0, pStatus);    
  127. 126.        return FALSE;    
  128. 127.    }    
  129. 128.    // 列出跟在ADAPTER_STATUS结构体后面的名字信息    
  130. 129.    pNames = (NAME_BUFFER *) (pStatus + 1);    
  131. 130.    for (int i = 0; i < pStatus->name_count; i++){    
  132. 131.        printf ("\t%.*s\n", NCBNAMSZ, pNames[i].name);    
  133. 132.    }    
  134. 133.    
  135. 134.    HeapFree (hHeap, 0, pStatus);// 释放分配的堆空间    
  136. 135.    
  137. 136.    return TRUE;    
  138. 137.}    
  139. 138.    
  140. 139.// 获取指定LANA的网络适配器信息    
  141. 140.// nLana, LANA编号    
  142. 141.// pBuffer, 获取到的网络适配器缓冲区    
  143. 142.// cbBuffer, 缓冲区长度    
  144. 143.// szName, 主机名字    
  145. 144.BOOL NBAdapterStatus (int nLana, PVOID pBuffer, int cbBuffer,  LPCSTR szName)    
  146. 145.{    
  147. 146.    NCB ncb;    
  148. 147.    memset (&ncb, 0, sizeof (ncb));     // 清空ncb结构体    
  149. 148.    ncb.ncb_command = NCBASTAT;         // 设置执行NCBASTAT命令，获取本地或远程网络适配器的状态    
  150. 149.    ncb.ncb_lana_num = nLana;           // 设置LANA编号    
  151. 150.    
  152. 151.    ncb.ncb_buffer = (PUCHAR) pBuffer;  // 将获取到的数据保存到参数pBuffer中    
  153. 152.    ncb.ncb_length = cbBuffer;          // 设置缓冲区长度    
  154. 153.    
  155. 154.    MakeNetbiosName ((char*) ncb.ncb_callname, szName);// 设置参数ncb.ncb_callname    
  156. 155.    Netbios (&ncb);                     // 执行NetBIOS命令    
  157. 156.    NBCheck (ncb);                      // 如果执行不成功，则输出返回值    
  158. 157.    // 如果成功返回TRUE，否则返回FALSE    
  159. 158.    return (NRC_GOODRET == ncb.ncb_retcode);    
  160. 159.}    


02. GetMacAddress.cpp -- 获取网络适配器上的MAC地址

[cpp]  view plain  copy
  1. [cpp] view plaincopyprint?  
  2. 01.// GetMacAddress.cpp -- 获取网络适配器上的MAC地址    
  3. 02.    
  4. 03.#include <stdio.h>    
  5. 04.#include <stdlib.h>    
  6. 05.#include <windows.h>    
  7. 06.#include <Nb30.h>    
  8. 07.    
  9. 08.#pragma comment(lib, "netapi32.lib")    
  10. 09.    
  11. 10.    
  12. 11./**  
  13. 12. * ADAPTER_STATUS结构体中包含网络适配器的信息  
  14. 13. * typedef struct _ADAPTER_STATUS{  
  15. 14. *   UCHAR adapter_address[6];  // 指定网络适配器的地址  
  16. 15. *   UCHAR rev_major;           // 指定发布软件的主版本号  
  17. 16. *   UCHAR reserved0;           // 保留字段，始终为零  
  18. 17. *   UCHAR adapter_type;        // 指定网络适配器的类型  
  19. 18. *   UCHAR rev_minor;           // 指定发布软件的副版本号  
  20. 19. *   WORD duration;             // 指定报告的时间周期，单位为分钟  
  21. 20. *   WORD frmr_recv;            // 指定接收到的FRMR（帧拒绝）帧数量  
  22. 21. *   WORD frmr_xmit;            // 指定传送的FRMR帧数量  
  23. 22. *   WORD iframe_recv_err;      // 指定接收到的错误帧数量  
  24. 23. *   WORD xmit_aborts;          // 指定终于传输的包数量  
  25. 24. *   DWORD xmit_success;        // 指定成功传输的包数量  
  26. 25. *   DWORD recv_success;        // 指定成功接收的包数量  
  27. 26. *   DWORD iframe_xmit_err;     // 指定传输的错误帧数量  
  28. 27. *   WORD recv_buf_unavail;     // 指定缓冲区无法为远程计算机提供服务次数  
  29. 28. *   WORD tl_timeouts;          // 指定DLC(Data Link Control, 数据链路控制）T1计数器超时的次数  
  30. 29. *   WORD ti_timeouts;          // 指定ti非活动计时器超时的次数。ti计时器用于检测断开的连接  
  31. 30. *   DWORD reservedl;           // 保留字段，始终为0  
  32. 31. *   WORD free_ncbs;            // 指定当前空闲的网络控制块的数量  
  33. 32. *   WORD max_cfg_ncbs;         // 最大网络控制块数据包的大小  
  34. 33. *   WORD max_ncbs;             // 最大网络控制块的数量  
  35. 34. *   WORD xmit_buf_unavail;     // 不可用的传输包的缓冲区  
  36. 35. *   WORD max_dgram_size;       // 包的最大值  
  37. 36. *   WORD pending_sess;         // 指定挂起会话的数量  
  38. 37. *   WORD max_cfg_sess;         // 指定数据包的最大大小，该值至少为512字节  
  39. 38. *   WORD max_sess;             // 最大数量  
  40. 39. *   WORD max_sess_pkt_size;    // 指定会话数据包的最大大小  
  41. 40. *   WORD name_count;           // 指定本地名字表中名字的数量  
  42. 41. * }ADAPTER_STATUS, *PADAPTER_STATUS;  
  43. 42. **/    
  44. 43.    
  45. 44.    
  46. 45.// 结构体ASTAT用于定义网络适配器状态和名字表信息    
  47. 46.typedef struct _ASTAT_    
  48. 47.{    
  49. 48.    ADAPTER_STATUS adapt;       // 网络适配器状态    
  50. 49.    NAME_BUFFER NameBuff [30];  // 名字表信息    
  51. 50.}ASTAT, * PASTAT;    
  52. 51.    
  53. 52.ASTAT Adapter;    
  54. 53.    
  55. 54.int main()    
  56. 55.{    
  57. 56.    NCB ncb;                        // NCB结构体，用于设置执行的NetBIOS命令和参数    
  58. 57.    UCHAR uRetCode;                 // 执行Netbios()函数的返回值    
  59. 58.    memset( &ncb, 0, sizeof(ncb) ); // 初始化ncb结构体    
  60. 59.    ncb.ncb_command = NCBRESET;     // 设置执行NCBRESET，复位网络适配器    
  61. 60.    ncb.ncb_lana_num = 0;           // 设置LANA编号    
  62. 61.    
  63. 62.    uRetCode = Netbios( &ncb );     // 调用Netbios()函数，执行NCBRESET命令    
  64. 63.    // 输出执行NCBRESET命令的结果    
  65. 64.    printf( "The NCBRESET return code is: 0x%x \n", uRetCode );    
  66. 65.    
  67. 66.    memset( &ncb, 0, sizeof(ncb) ); // 初始化ncb    
  68. 67.    ncb.ncb_command = NCBASTAT;     // 执行NCBASTAT命令，获取网络适配器状态    
  69. 68.    ncb.ncb_lana_num = 0;           // 设置LANA编号    
  70. 69.    // 设置执行NCBASTAT命令的参数，将获取到的网络适配器数据保存到Adapter结构体中    
  71. 70.    memcpy( &ncb.ncb_callname, "*               ", 16 );    
  72. 71.    ncb.ncb_buffer = (UCHAR*) &Adapter;    
  73. 72.    ncb.ncb_length = sizeof(Adapter);    
  74. 73.    uRetCode = Netbios( &ncb );     // 调用Netbios()函数，执行NCBASTAT命令    
  75. 74.    printf( "The NCBASTAT return code is: 0x%x \n", uRetCode );    
  76. 75.    if ( uRetCode == 0 ) {          // 输出MAC地址    
  77. 76.        printf( "The Ethernet Number is: %02x-%02x-%02x-%02x-%02x-%02x\n",    
  78. 77.                Adapter.adapt.adapter_address[0],    
  79. 78.                Adapter.adapt.adapter_address[1],    
  80. 79.                Adapter.adapt.adapter_address[2],    
  81. 80.                Adapter.adapt.adapter_address[3],    
  82. 81.                Adapter.adapt.adapter_address[4],    
  83. 82.                Adapter.adapt.adapter_address[5] );    
  84. 83.    }    
  85. 84.    system("pause");    
  86. 85.    return 0;    
  87. 86.}    


03. NbtStat.cpp -- 获取网络中指定计算机的基本信息

[cpp]  view plain  copy
  1. [cpp] view plaincopyprint?  
  2. 01.// NbtStat.cpp -- 获取网络中指定计算机的基本信息    
  3. 02.    
  4. 03.#include <string.h>    
  5. 04.#include <stdio.h>    
  6. 05.#include <winsock2.h>    
  7. 06.#include <map>    
  8. 07.    
  9. 08.#pragma comment(lib, "Ws2_32.lib")    
  10. 09.    
  11. 10.using namespace std;    
  12. 11.    
  13. 12.    
  14. 13.class CDevice    
  15. 14.{    
  16. 15.public:    
  17. 16.    CDevice(void){}    
  18. 17.    CDevice(string ip):IP(ip), Name (""), Mac(""), Workgroup(""){}    
  19. 18.    
  20. 19.public:    
  21. 20.    ~CDevice(void){}    
  22. 21.    
  23. 22.public:    
  24. 23.    string IP;          // IP地址    
  25. 24.    string Name;        // 名称    
  26. 25.    string Mac;         // Mac地址    
  27. 26.    string Workgroup;   // 工作组    
  28. 27.};    
  29. 28.    
  30. 29.    
  31. 30.    
  32. 31.// 通过NbtStat获取计算机名字信息的结构体    
  33. 32.struct names    
  34. 33.{    
  35. 34.    unsigned char nb_name[16];  // 表示接收到的名字    
  36. 35.    unsigned short name_flags;  // 标识名字的含义    
  37. 36.};    
  38. 37.    
  39. 38.    
  40. 39.// 保存获取NetBIOS信息的Socket和IP地址列表    
  41. 40.struct workstationNameThreadStruct    
  42. 41.{    
  43. 42.    SOCKET s;                   // 指定发送和接收NetBIOS数据包的Socket    
  44. 43.    std::map<unsigned long, CDevice*> *ips;   // 指定获取NetBIOS信息的IP地址列表    
  45. 44.};    
  46. 45.    
  47. 46.// 格式化ethernet中的字节为字符串    
  48. 47.void GetEthernetAdapter(unsigned char *ethernet, char *macstr)    
  49. 48.{    
  50. 49.    sprintf(macstr, "%02x %02x %02x %02x %02x %02x",    
  51. 50.        ethernet[0],    ethernet[1],        ethernet[2],    
  52. 51.        ethernet[3],    ethernet[4],        ethernet[5]    
  53. 52.    );    
  54. 53.    return;    
  55. 54.}    
  56. 55.    
  57. 56.    
  58. 57.// 获取设备的名称和MAC地址等信息    
  59. 58./**  
  60. 59. * GetHostInfo()函数的运行过程  
  61. 60. * 创建发送和接收NetBIOS数据包的Socket, 并将其绑定在本地地址的端口0上。  
  62. 61. * 创建接收NetBIOS回应包的线程，参数unionStruct中包含要获取NetBIOS信息的IP地址和通信用的Socket。  
  63. 62. * 使用for循环语句依次向每个IP地址发送NetBIOS请求包，请求包数据保存在字符数组input中。  
  64. 63. * 调用WaitForSingleObject()函数，等待接收线程结束。  
  65. 64. * 如果超时，则结束接收线程NetBiosRecvThreadProc()函数。  
  66. 65. * 关闭线程句柄，释放资源。  
  67. 66. **/    
  68. 67.void GetHostInfo(std::map<unsigned long, CDevice*> &ips, int timeout)    
  69. 68.{    
  70. 69.    DWORD WINAPI NetBiosRecvThreadProc(void *param);    
  71. 70.    
  72. 71.    const int defaultPort = 0;      // 设定默认的绑定端口    
  73. 72.    SOCKET sock;                    // 通信套接字    
  74. 73.    struct sockaddr_in origen;      // 本地地址    
  75. 74.    WSADATA wsaData;                // Windows Sockets环境变量    
  76. 75.    
  77. 76.    if(WSAStartup(MAKEWORD(2,1),&wsaData) != 0){// 初始化Windows Sockets环境    
  78. 77.        return;    
  79. 78.    }    
  80. 79.    if(INVALID_SOCKET ==(sock = socket(AF_INET, SOCK_DGRAM,IPPROTO_UDP))){// 创建TCP/IP套接字    
  81. 80.        return;    
  82. 81.    }    
  83. 82.    // 设置超时时间    
  84. 83.    if(SOCKET_ERROR ==setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout,sizeof(timeout))){    
  85. 84.        closesocket(sock);    
  86. 85.        WSACleanup();    
  87. 86.        return;    
  88. 87.    }    
  89. 88.    // 将套接字绑定到本地地址和端口0    
  90. 89.    memset(&origen, 0, sizeof(origen));    
  91. 90.    origen.sin_family = AF_INET;    
  92. 91.    origen.sin_addr.s_addr = htonl (INADDR_ANY);    
  93. 92.    origen.sin_port = htons (defaultPort);    
  94. 93.    if (bind (sock, (struct sockaddr *) &origen, sizeof(origen)) < 0) { // 套接字连接    
  95. 94.        closesocket(sock);    
  96. 95.        WSACleanup();    
  97. 96.        return;    
  98. 97.    }    
  99. 98.    
  100. 99.    // 为创建接收线程准备数据    
  101. 100.    workstationNameThreadStruct unionStruct;    
  102. 101.    unionStruct.ips = &ips;    
  103. 102.    unionStruct.s = sock;    
  104. 103.    // 启动线程等待接收NetBIOS回应包    
  105. 104.    DWORD pid;    
  106. 105.    HANDLE threadHandle = CreateThread(NULL, 0, NetBiosRecvThreadProc,(void *)&unionStruct, 0, &pid);    
  107. 106.    
  108. 107.    // 依次向ips中的每个IP地址的137端口发送NetBIOS请求包（保存在input字符数组中）    
  109. 108.    std::map<unsigned long, CDevice*>::iterator itr;    
  110. 109.    for(itr=ips.begin();itr != ips.end();itr++)    
  111. 110.    {    
  112. 111.        char input[]="\x80\x94\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\
  113.        x20\x43\x4b\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41
  114.        \x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x41\x00\x00\x21\
  115.        x00\x01";    
  116. 112.        struct sockaddr_in dest;    
  117. 113.        // 发送NetBios请求信息    
  118. 114.        memset(&dest,0,sizeof(dest));    
  119. 115.        dest.sin_addr.s_addr = itr->first;    
  120. 116.        dest.sin_family = AF_INET;    
  121. 117.        dest.sin_port = htons(137);    
  122. 118.        sendto (sock, input, sizeof(input)-1, 0, (struct sockaddr *)&dest, sizeof (dest));    
  123. 119.    }    
  124. 120.    // 等待接收线程NetBiosRecvThreadProc结束    
  125. 121.    DWORD ret = WaitForSingleObject(threadHandle, timeout * 4);    
  126. 122.    // 如果超时，则结束接收线程NetBiosRecvThreadProc    
  127. 123.    if(ret == WAIT_TIMEOUT){    
  128. 124.        TerminateThread(threadHandle, 0);    
  129. 125.    }    
  130. 126.    else{    
  131. 127.        printf("thread success exit\n");    
  132. 128.    }    
  133. 129.    // 关闭线程句柄    
  134. 130.    CloseHandle(threadHandle);    
  135. 131.    
  136. 132.    // 释放资源    
  137. 133.    closesocket(sock);    
  138. 134.    WSACleanup();    
  139. 135.}    
  140. 136.    
  141. 137.    
  142. 138.    
  143. 139.    
  144. 140.// 获取计算机名称以及MAC地址的函数线程    
  145. 141./**  
  146. 142. * NetBiosRecvThreadProc()函数运行过程  
  147. 143. * 在while循环中调用recvfrom()函数，在套接字sock上接收数据.  
  148. 144. * 如果超时，则多重试两次。  
  149. 145. * NetBIOS回应包的前56位是网络适配器状态信息，第57位保存名字表中名字的数量。  
  150. 146. * 依次处理名字表中每个名字项，如果最后一位是0x00，则表示当前名字项用于保有存计算机名或者工作组。  
  151. 147. *　 name_flags字段可以区分当前名字是计算机名还是工作组。  
  152. 148. * 在NetBIOS回应包中，包字表后面的6个字节是计算机的MAC地址。  
  153. 149. *   调用GetEthernetAdapter()函数可以将其转换为字符串。  
  154. 150. * 将获取到的计算机名、工作组和MAC地址保存到ips映射表项中的CDevice对象中。  
  155. 151. **/    
  156. 152.    
  157. 153.DWORD WINAPI NetBiosRecvThreadProc(void *param)    
  158. 154.{    
  159. 155.    char respuesta[1000];                   // 保存接收到的NetBIOS    
  160. 156.    unsigned int count=0;                   // 用于在NetBIOS回应包中定位名字数组的位置    
  161. 157.    unsigned char ethernet[6];          // 保存MAC地址    
  162. 158.    struct sockaddr_in from;                // 发送NetBIOS回应包    
  163. 159.    // 参数是要获取NetBIOS信息的IP地址和套接字    
  164. 160.    workstationNameThreadStruct *unionStruct = (workstationNameThreadStruct *)param;    
  165. 161.    SOCKET sock = unionStruct->s;    // 用于接收NetBIOS回应包的套接字    
  166. 162.    // 要获取NetBIOS信息的IP地址    
  167. 163.    std::map<unsigned long, CDevice*> *ips = unionStruct->ips;    
  168. 164.    int len = sizeof (sockaddr_in);     // 地址长度    
  169. 165.    // 定义名字数组    
  170. 166.    struct names Names[20*sizeof(struct names)];    
  171. 167.    
  172. 168.    int ipsCount = ips->size();          // 要获取NetBIOS信息的IP地址数量    
  173. 169.    int timeoutRetry = 0;                   // 记录超时重试的次数    
  174. 170.    while(true){    
  175. 171.        count = 0;    
  176. 172.        // 在套接字sock上接收消息    
  177. 173.        int res= recvfrom (sock, respuesta, sizeof(respuesta), 0, (sockaddr *)&from, &len);    
  178. 174.        // 如果超时，则重试，但重试次数不超过两次    
  179. 175.        if(res == SOCKET_ERROR) {    
  180. 176.            if(GetLastError() == 10060) {    
  181. 177.                timeoutRetry++;    
  182. 178.                if(timeoutRetry == 2)    
  183. 179.                    break;    
  184. 180.            }    
  185. 181.            continue;    
  186. 182.        }    
  187. 183.        if(res <= 121){    
  188. 184.            continue;    
  189. 185.        }    
  190. 186.    
  191. 187.        // 将count定位到名字表中名字的数量。在NetBIOS回应包中，前面56位是网络适配器的状态信息    
  192. 188.        memcpy(&count, respuesta+56, 1);    
  193. 189.        if(count > 20){      // 最多有20个名字，超出则错误    
  194. 190.            continue;    
  195. 191.        }    
  196. 192.    
  197. 193.        // 将名字表内在复制到Names数组中    
  198. 194.        memcpy(Names,(respuesta+57), count*sizeof(struct names));    
  199. 195.    
  200. 196.        // 将空格字符替换成空    
  201. 197.        for(unsigned int i = 0; i < count;i++) {    
  202. 198.            for(unsigned int j = 0;j < 15;j++){    
  203. 199.                if(Names[i].nb_name[j] == 0x20)    
  204. 200.                    Names[i].nb_name[j]=0;    
  205. 201.            }    
  206. 202.        }    
  207. 203.    
  208. 204.        string mac;    
  209. 205.        // 如果发送回应包的地址在ips中，则处理该包    
  210. 206.        std::map<unsigned long, CDevice*>::iterator itr;    
  211. 207.        if( (itr = ips->find(from.sin_addr.S_un.S_addr)) != ips -> end()){    
  212. 208.            // 获取发送NetBIOS回应包的IP地址    
  213. 209.            in_addr inaddr;    
  214. 210.            inaddr.S_un.S_addr = itr->first;    
  215. 211.            itr->second->IP = inet_ntoa(inaddr);    
  216. 212.            // 处理名字表中的所有名字    
  217. 213.            for(int i=0;i<count;i++){    
  218. 214.                // 如果最后一位是0x00，则表示当前名字表项为保存计算机名或者工作组    
  219. 215.                if(Names[i].nb_name[15] == 0x00){    
  220. 216.                    char buffers[17] = {0};    
  221. 217.                    memcpy(buffers, Names[i].nb_name, 16);    
  222. 218.                    // 使用name_flags字段来区分当前名字是计算机名还是工作组    
  223. 219.                    if((Names[i].name_flags & 128) == 0) {    
  224. 220.                        itr->second->Name = buffers;    
  225. 221.                    }    
  226. 222.                    else{    
  227. 223.                        itr->second->Workgroup = buffers;    
  228. 224.                    }    
  229. 225.                }    
  230. 226.                // 名字表后面是MAC地址    
  231. 227.                memcpy(ethernet,(respuesta+57+count*sizeof(struct names)),6);    
  232. 228.                char mac[20] = {0};    
  233. 229.                // 格式化MAC地址    
  234. 230.                GetEthernetAdapter(ethernet,mac);    
  235. 231.                itr->second->Mac = mac;    
  236. 232.            }    
  237. 233.        }    
  238. 234.    }    
  239. 235.    
  240. 236.    return 0;    
  241. 237.}    
  242. 238.    
  243. 239.    
  244. 240.    
  245. 241.int main()    
  246. 242.{    
  247. 243.    std::map<unsigned long, CDevice*> ips;    
  248. 244.    // 向ips中添加一个设备    
  249. 245.    CDevice dev1("10.5.1.5");    
  250. 246.    unsigned long ip1 = inet_addr(dev1.IP.c_str());    
  251. 247.    ips.insert(make_pair(ip1, &dev1));    
  252. 248.    // 向ips中添加第2个设备    
  253. 249.    CDevice dev2("10.10.10.1");    
  254. 250.    unsigned long ip2 = inet_addr(dev2.IP.c_str());    
  255. 251.    ips.insert(make_pair(ip2, &dev2));    
  256. 252.    
  257. 253.    // 获取设备信息    
  258. 254.    GetHostInfo(ips, 2000);    
  259. 255.    std::map<unsigned long, CDevice*>::iterator itr;    
  260. 256.    for(itr = ips.begin(); itr != ips.end(); itr++)    
  261. 257.    {    
  262. 258.        printf("\nIP: %s;  \nName: %s;  \nMac: %s;  \nWorkgroup:  %s\n\n",    
  263. 259.            itr->second->IP.c_str(), itr->second->Name.c_str(), itr->second->Mac.c_str(), itr->second->Workgroup.c_str());    
  264. 260.    }    
  265. 261.    system("pause");    
  266. 262.    return 0;    
  267. 263.}    
基于netbios探测对方主机信息的编程
空傅的脑袋
07-13 1547
作者注：空傅的早期作品，换编程方式实现获取网络信息，不尽完善 一般学习过网络的朋友都知道netbios协议，因为它的简便，所以在Windows局域网中被广泛使用，而且一般初级的攻击技术都是基于netbios协议，如看到的，使用net命令连接远程主机后的攻击，基于SMB漏洞的攻击等等，都是这个netbios惹得祸，所以使用的简单就是技术的不安全，要避免这些攻击简单的方法就是都是禁掉135，139等端
实验5：基于NetBIOS的网络通信程序设计
11-29
掌握NetBIOS方式的网络编程模式。 能运用NetBIOS提供的命令进行网络程序的编写。 理解并能应用NetBIOS提供的命令实现C/S通信。
基于NetBios的编程
12-30
基于Netbios的函数实现获取主机名及各种系统信息，主要函数与相关数据结构分析，代码实现
NetBios网络基础及编程
weixin_33894992的博客
08-02 249
　　开始学习（算是复习）网络编程了，第一个就是局域网的netbios协议编程。 　　首先了解一下什么是netbios:IBM公司为PC－Network开发的一套网络标准。,NetBIOS最广泛的应用之一就是对NetBIOS用户扩展接口(NetBEUI，NetBIOS Extend User Interface)协议的使用。处在表示层与会话层之间，处于参考模型的高层。 　　优点：短小精练; 良好...
NetBIOS网络编程设计参考手册要点解析
NetBIOS（Network Basic Input/Output System）是微软开发的一套网络编程接口，用于在局域网内进行计算机通信。NetBIOS提供了三个基本功能：名称服务、会话服务和数据报服务。名称服务允许计算机在网络上注册和解析...
NetBIOS网络编程常用函数解析
在Windows网络编程中，NetBIOS是实现网络服务的基础。由于标题和描述中提到了《Windows网络编程》这本书，并提到了与NetBIOS相关的函数，我们可以推断，该书籍可能会涉及到如何在Windows环境下使用NetBIOS进行编程的...
C++入门：NetBIOS网络编程与Windows接口详解
"C++ 网络编程"是一本关于C++语言在网络编程方面的专业书籍，主要关注Windows平台上的网络编程技术。书中首先讲解的是传统的网络接口，如NetBIOS（网络基本输入/输出系统），这是一种由Sytek公司为IBM开发的标准化...
基于NetBIOS的网络编程.pptx
01-05
在进行NetBIOS网络编程时，开发者需要考虑以下几个设计要素： 1. 选择合适的通信模式：根据应用需求，决定使用数据报还是会话通信。 2. 名字管理：确保名字的唯一性和正确注册，避免冲突。 3. 错误处理：处理可能...
NetBios网络编程;NetBios理解
CooIsir的专栏
11-20 891
这两天接触NetBios,总算拨开了一层弄弄的雾 . //
Netbios编程（一）：服务器端（事件模型）
snail2006的专栏
09-22 797
说明：看Netbios程序过程中，总结的开发服务器程序的步骤，相关代码多来自windows网络编程Netbios主要应用域小型局域网，服务器端（事件模型）开发的步骤如下：（1）枚举出本机所有的LANA，然后重设每个LANA。//枚举所有的LANAint LanaEnum(LANA_ENUM *lenum){    NCB ncb;    ZeroMemory(&ncb,
1.1.3 NetBIOS编程基础（1）
dizhi5320的博客
08-27 312
1.1.3 NetBIOS编程基础（1） NetBIOS是用于网络的基本输入/输出系统，是一个应用程序接口，用于源与目的地之间的交换，即能够支持计算机应用程序与设备通信时要用到的各种具有明确而简单的通信协议，必须用特殊的命令序列来调用NetBIOS。 在参考层次模型中，NetBIOS处于表示层和会话层之间，是参考模型的高层。因此其接口程序的应用在很大程度上(并且从本质上)与较低层次...
netbios编程(对前面局域网编程的一个补充)
...........
03-08 1816
    关键词：windows，netbios协议,lan 　 1. 概述： netbios是pc机网络中用得最为广泛的网络协议之一，大多数的局域网（lan）产品，如micros
delphi技术专题---获取网卡物理地址之NetBios网络编程接口LANA介绍
web18484626332的博客
09-06 547
接下来我们要介绍一个Netbios网络编程接口中的极为重要的概念，那就是LANA编号(LANA适配器编号LAN adapter)，它是我们理解Netbios的关键，也是真正的传送协议与Net_bios如何对应起来这个问题的答案所在。“面向连接，，的通信可保证通信具有极高的可靠性，而且数据包的收发顺序也能确保正确无误。然而，它仍然是一种以消息为基础的服务，也就是说，假如已连接好的某个客户机执行一个读命令，那么服务器在流中仍然只会返回一个数据包(尽管客户机此时提供了一个足够大的缓冲区，可同时容下几一个包)。
NetBIOS特性与编程基础
cl007的专栏
07-03 941
       NetBIOS同时提供了“面向连接”服务以及“无连接”服务。面向连接的服务，是指它允许两个客户机相互间建立一个会话，或者说建立一个“虚拟回路”。这种会话实际是一种双向的通信数据流，通信的每一方都可向另一方发送消息。面向连接的服务可担保在两个端点之间，任何数据都能准确无误的传递。在这种服务中，服务器通常将自己注册到一个已知的名字下。客户机会搜寻这个名字，以便建立与服务器的通信。就拿Ne
netbios协议使用
12-17 1223
NetBIOS协议 　　说明：全称NetWork Basic Input/Output System（网络基本输入/输出系统），该协议是由IBM公司开发，主要用于数十台计算机的小型局域网。NetBIOS协议是一种在局域网上的程序可以使用的应用程序编程接口（API），为程序提供了请求低级服务的统一的命令集，作用是为了给局域网提供网络以及其他特殊功能，几乎所有的局域网都是在NetBIOS协议的基础上
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值