NetBios网络基础及编程

　　开始学习（算是复习）网络编程了，第一个就是局域网的netbios协议编程。

　　首先了解一下什么是netbios:IBM公司为PC－Network开发的一套网络标准。,NetBIOS最广泛的应用之一就是对NetBIOS用户扩展接口(NetBEUI，NetBIOS Extend User Interface)协议的使用。处在表示层与会话层之间，处于参考模型的高层。

　　优点：短小精练; 良好的网络通信性能; 适合于适时性较高的小型LAN网络环境;

　　缺点：是一种不可路由的协议；数据包无法跨网段传输。

NetBIOS程序的工作过程:

　　首先，网络通信程序通过名字的标识区别于其他程序，并将名字注册到LANA中，获得合法的网络身份。

　　之后，网络通信程序可以使用NetBIOS的数据报或会话服务与驻留在相同或不同主机中的其他应用程序进行通信。通信过程中，用户还可以使用一般命令服务对适配器进行管理和监测。

　　最后，在通信结束后，通信程序需要删除已注册的名字并释放所占用的网络资源。

编程讲解：

　　在Win32环境下，使用VS2012进行NetBIOS程序开发时，需要用到nb30.h文件和netapi32.lib静态链接库。前者定义了NetBIOS的所有函数声明和常数定义，后者定义了NetBIOS应用。Ncb的结构在nb30.h文件中定义。Ncb结构的定义：Ncb有64个字符，分为14个域(或称为字段)和一个10字节的保留域。各字段这里就不详细了，另外一个博客有讲解。

编写NetBios命令函数的步骤：

　　　　1. 定义函数原型。

　　　　2. 申明NCB结构变量。

　　　　3. 对该变量所有域清零。

　　　　4. 根据命令填写相关域。

　　　　5. 调用NetBios函数提交NCB结构。

　　　　6. 判断NetBios函数返回值，作出相应处理。

　　　　7. 从NCB中获取输出域。（根据具体命令）

简单的基于NetBios的对话编程，实现了建立会话过程，客户端向服务端发送数据，服务端接受数据并回复数据，客户端成功接受并无限递归（当然程序可以自己修改）。win32，vs2012，C++平台参考代码如下：

服务端代码参考：

  1 //服务端参考代码：
  2 #include <windows.h>
  3 #include <stdio.h>
  4 #include <nb30.h>
  5 #include "NetBioscmd.h"
  6 #define MAX_SESSIONS 254
  7 #define MAX_NAMES 254
  8 #define MAX_BUFFER 1024
  9 #define SERVER_NAME "server"
 10 //
 11 //Thread to give a simple service to client
 12 //
 13 DWORD WINAPI ServerThread(PVOID lpParam)
 14 {
 15     PNCB pncb =(PNCB)lpParam;
 16     NCB ncb;
 17     char buff[MAX_BUFFER],
 18         Clientname[NCBNAMSZ+1];
 19     DWORD Bufferlen,retval =NRC_GOODRET;
 20     FormatNetbiosName((char *)&pncb->ncb_callname,Clientname);
 21     printf("a connect come\n");
 22     ZeroMemory(buff,MAX_BUFFER);
 23     Bufferlen =MAX_BUFFER;
 24
 25     while (true)
 26     {
 27         retval =Recv(pncb->ncb_lana_num,pncb->ncb_lsn,buff,Bufferlen);
 28         if(retval!=NRC_GOODRET)
 29             return pncb->ncb_retcode;
 30         printf("Massage from[%s]:%s\n",Clientname,buff);
 31         ZeroMemory(buff,MAX_BUFFER);
 32         Bufferlen =MAX_BUFFER;
 33         strcpy(buff,"welcome you join the NetBIOS club.");
 34         retval =Send(pncb->ncb_lana_num,pncb->ncb_lsn,buff,Bufferlen);
 35         if(retval!=NRC_GOODRET)
 36             return pncb->ncb_retcode;
 37     }
 38
 39     if(retval!=NRC_SCLOSED)
 40     {
 41         ZeroMemory(&ncb,sizeof(NCB));
 42         ncb.ncb_command =NCBHANGUP;
 43         ncb.ncb_lsn =pncb->ncb_lsn;
 44         ncb.ncb_lana_num =pncb->ncb_lana_num;
 45         if(Netbios(&ncb)!=NRC_GOODRET)
 46         {
 47             GlobalFree(pncb);
 48             retval =ncb.ncb_retcode;
 49         }
 50     }
 51     GlobalFree(pncb);
 52     return NRC_GOODRET;
 53 }
 54 //
 55 //Callback function to give a simple service to client, you can use it as another sever model
 56 //
 57 void CALLBACK listencallback(PNCB pncb)
 58 {
 59     //
 60     //you also can write down code here to communicate to a client
 61     //
 62 }
 63 //main function
 64 int main(int argc, char* argv[])
 65 {
 66     HANDLE hEvent[64],hThread;
 67     NCB *pncb,
 68         *workpncb;
 69     DWORD ThreadId,
 70         dwIndex;
 71     UCHAR dwNum = ' ';
 72     LANA_ENUM lenum;
 73     int i;
 74     if(LanaEnum(&lenum)!=NRC_GOODRET)
 75     {
 76         return 1;
 77     }
 78     if(ResetAll(&lenum,(UCHAR)MAX_SESSIONS,(UCHAR)MAX_NAMES,false)!=NRC_GOODRET)
 79         return 1;
 80     pncb = (NCB*)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,sizeof(NCB)*lenum.length);
 81     for(i=0;i<lenum.length;i++)
 82         if((AddName((int)lenum.lana[i],SERVER_NAME,&dwNum))==NRC_GOODRET)
 83         {printf("add name(%s) to lana[%d]\n",SERVER_NAME,lenum.lana[i]);
 84     //printf("name(%s) have the name_num (%d)\n",SERVER_NAME,dwNum);
 85     }
 86     for(i=0;i<lenum.length;i++)
 87     {
 88         hEvent[i]=CreateEvent(0,TRUE,FALSE,0);
 89         if(Listen(&pncb[i],lenum.lana[i],SERVER_NAME,hEvent[i])==NRC_GOODRET)
 90             printf("attempt to listen to lana[%d] succeed!\n",lenum.lana[i]);
 91     }
 92     printf("Server setup has been finished,now server begin to listen.\n");
 93     while(true)
 94     {
 95         dwIndex=WaitForMultipleObjects(lenum.length,hEvent,FALSE,INFINITE);
 96         if(dwIndex==WAIT_FAILED)
 97         {
 98             printf("WaitForMultipleObjects ERROR:%0xh\n",GetLastError());
 99             break;
100         }
101         else
102         {
103             for(int i=0;i<lenum.length;i++)
104             {
105                 if(pncb[i].ncb_cmd_cplt!=NRC_PENDING)
106                 {
107                     workpncb = (NCB *)GlobalAlloc(GMEM_FIXED,sizeof(NCB));
108                     memcpy(workpncb,&pncb[i],sizeof(NCB));
109                     workpncb->ncb_event = 0;
110                     hThread=CreateThread(NULL,0,ServerThread,(LPVOID)workpncb,0,&ThreadId);
111                     CloseHandle(hThread);
112                     ResetEvent(hEvent[i]);
113                     Listen(&pncb[i],lenum.lana[i],SERVER_NAME,hEvent[i]);
114                 }
115                 else
116                     continue;
117             }
118         }
119     }
120     for(i=0;i<lenum.lana[i];i++)
121     {
122         DelName(lenum.lana[i],SERVER_NAME);
123         CloseHandle(hEvent[i]);
124     }
125     GlobalFree(hEvent);
126     GlobalFree(pncb);
127     return 0;
128 }

View Code

客户端代码参考：

 1 //客户端参考代码：
 2 // client.cpp : Defines the entry point for the console application.
 3 //
 4
 5 #include <windows.h>
 6 #include <stdio.h>
 7 #include <nb30.h>
 8 #include <winbase.h>
 9 #include "NetBioscmd.h"
10 #define MAX_SESSIONS 254
11 #define MAX_NAMES 254
12 #define MAX_BUFFER 1024
13 #define MAX_DATAGRAM_SIZE 512
14 #define CLIENT_NAME "client"
15 #define SERVER_NAME "server"
16 //main fuction
17 int main(int argc, char* argv[])
18 {
19     HANDLE *hEvent;
20     NCB *pncb;
21     DWORD dwRet,
22         Bufferlen,dwIndex;
23     UCHAR *dwNum = NULL;
24     char Buff[MAX_BUFFER],
25         Servername[NCBNAMSZ+1];
26     LANA_ENUM lenum;
27     int i;
28     if(LanaEnum(&lenum)!=NRC_GOODRET)
29         return 1;
30     if(ResetAll(&lenum,(UCHAR)MAX_SESSIONS,(UCHAR)MAX_NAMES,false)!=NRC_GOODRET)
31         return 1;
32     hEvent = (HANDLE*)GlobalAlloc(GMEM_FIXED,sizeof(HANDLE)*lenum.length);  //分配内存
33     pncb = (NCB*)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,sizeof(NCB)*lenum.length);
34     dwNum = (UCHAR*)GlobalAlloc(GMEM_FIXED|GMEM_ZEROINIT,sizeof(UCHAR)*lenum.length);
35     for(i=0;i<lenum.length;i++)    //增加名字
36         if((AddName((int)lenum.lana[i],CLIENT_NAME,(UCHAR*)&dwNum[i]))==NRC_GOODRET)
37         {    printf("add name(%s) to lana[%d]\n",CLIENT_NAME,lenum.lana[i]);
38     //printf("name(%s) have the name_num (%d)\n",CLIENT_NAME,dwNum[i]);
39     }
40     for(i=0;i<lenum.length;i++)//  连接
41     {
42         hEvent[i]=CreateEvent(0,TRUE,FALSE,0);
43         if((Connect(&pncb[i],lenum.lana[i],SERVER_NAME,CLIENT_NAME,hEvent[i]))==NRC_GOODRET)
44             printf("attempt to connect to lana[%d] succeed!\n",lenum.lana[i]);
45     }
46
47         dwIndex = WaitForMultipleObjects(lenum.length,hEvent,FALSE,INFINITE);
48
49         if(dwIndex == WAIT_FAILED)
50             printf("ERROR:WaitForMultipleObjects:%0xh\n",GetLastError());
51         else
52         {
53             for(int i=0;i<lenum.length;i++)
54             {
55                 if(i!=(int)dwIndex)
56                 {
57                     if(pncb[i].ncb_cmd_cplt==NRC_PENDING)   //异步
58                         Cancel(&pncb[i]);
59                     else
60                         Hangup(pncb[i].ncb_lana_num,pncb[i].ncb_lsn);
61                 }
62             }
63             //printf("%i",(int)pncb[dwIndex].ncb_lana_num);
64             printf("a connect on[LANA %i] has been built!\n",(int)pncb[dwIndex].ncb_lana_num);
65             ZeroMemory(Buff,MAX_BUFFER);
66             Bufferlen = MAX_BUFFER;
67             while (TRUE)
68             {
69                 strcpy(Buff,"I want to register to you.");
70                 dwRet = Send(pncb[dwIndex].ncb_lana_num,pncb[dwIndex].ncb_lsn,Buff,Bufferlen);
71                 if(dwRet!=NRC_GOODRET)
72                     return pncb[dwIndex].ncb_retcode;
73                 ZeroMemory(Buff,MAX_BUFFER);
74                 dwRet=Recv(pncb[dwIndex].ncb_lana_num,pncb[dwIndex].ncb_lsn,Buff,Bufferlen);
75                 if(dwRet!=NRC_GOODRET)
76                     return pncb[dwIndex].ncb_retcode;
77                 FormatNetbiosName((char *)&pncb->ncb_callname,Servername);
78                 printf("Massage from[%s]:%s\n",Servername,Buff);
79             }
80
81             Hangup(pncb[dwIndex].ncb_lana_num,pncb[dwIndex].ncb_lsn);
82         }
83
84
85     for(i=0;i<lenum.length;i++)
86     {
87         DelName(lenum.lana[i],CLIENT_NAME);
88         CloseHandle(hEvent[i]);
89     }
90     GlobalFree(hEvent);
91     GlobalFree(pncb);
92     return 0;
93 }

View Code

其中需要一个头文件NetBIOScmd.h部分参考代码：

  1 //NetBIOScmd.h 部分参考代码：
  2 //
  3 //Get the status of local or remote adapter
  4 //
  5 #define MAX_DATAGRAM_SIZE 512
  6 int Astatus(ADAPTER_STATUS *astat,int lana,char *name)
  7 {
  8 NCB ncb;
  9 ZeroMemory(&ncb,sizeof(NCB));
 10 ncb.ncb_command = NCBASTAT;
 11 ncb.ncb_buffer = (PUCHAR)astat;
 12 ncb.ncb_length = sizeof(ADAPTER_STATUS);
 13 memset(&ncb.ncb_callname,' ',NCBNAMSZ);
 14 strncpy((char *)&ncb.ncb_callname,name,strlen(name));
 15 ncb.ncb_lana_num = lana;
 16 if(Netbios(&ncb)!=NRC_GOODRET)
 17 {
 18 printf("Netbios NCBASTAT ERROR:%0xh\n",ncb.ncb_retcode);
 19 return ncb.ncb_retcode;
 20 }
 21 return NRC_GOODRET;
 22 }
 23 //
 24 //Get the machine's LANA NUM
 25 //
 26 int LanaEnum(LANA_ENUM *lenum)
 27 {
 28 NCB ncb;
 29 ZeroMemory(&ncb,sizeof(NCB));
 30 ncb.ncb_command = NCBENUM;
 31 ncb.ncb_buffer = (PUCHAR)lenum;
 32 ncb.ncb_length = sizeof(LANA_ENUM);
 33 if(Netbios(&ncb)!=NRC_GOODRET)
 34 {
 35 printf("Netbios NEBENUM ERROR:%0xh\n",ncb.ncb_retcode);
 36 return ncb.ncb_retcode;
 37 }
 38 return NRC_GOODRET;
 39 }
 40 //
 41 //Reset All LANA NUM
 42 //
 43 int ResetAll(LANA_ENUM *lenum,UCHAR ucMaxSession,UCHAR unMaxName,BOOL bFirstname)
 44 {
 45 NCB ncb;
 46 ZeroMemory(&ncb,sizeof(NCB));
 47 ncb.ncb_command = NCBRESET;
 48 ncb.ncb_callname[0] = ucMaxSession;
 49 ncb.ncb_callname[1] = unMaxName;
 50 ncb.ncb_callname[2] = (UCHAR)bFirstname;
 51 for(int i=0;i<lenum->length;i++)
 52 {
 53 ncb.ncb_lana_num = lenum->lana[i];
 54 if(Netbios(&ncb)!=NRC_GOODRET)
 55 {
 56 printf("Netbios NCBRESET[%d]ERROR:%0xh\n",ncb.ncb_lana_num,ncb.ncb_retcode);
 57 return ncb.ncb_retcode;
 58 }
 59 }
 60 return NRC_GOODRET;
 61 }
 62 //
 63 //Add name of program
 64 //
 65 int AddName(int lana,char *name,UCHAR *num)
 66 {
 67 NCB ncb;
 68 ZeroMemory(&ncb,sizeof(NCB));
 69 ncb.ncb_command = NCBADDNAME;
 70 ncb.ncb_lana_num = lana;
 71 memset(ncb.ncb_name,' ',NCBNAMSZ);//add by jinhua
 72 strncpy((char *)ncb.ncb_name,name,strlen(name));
 73 if(Netbios(&ncb)!=NRC_GOODRET)
 74 {
 75 printf("Netbios NCBADDNAME[lana=%d;name=%s]ERROR:%0xh\n",lana,name,ncb.ncb_retcode);
 76 return ncb.ncb_retcode;
 77 }
 78 *num = ncb.ncb_num;
 79 return NRC_GOODRET;
 80 }
 81 //
 82 //Cancel NetBios Command
 83 //
 84 int Cancel(PNCB pncb)
 85 {
 86 NCB ncb;
 87 ZeroMemory(&ncb,sizeof(NCB));
 88 ncb.ncb_command = NCBCANCEL;
 89 ncb.ncb_buffer = (PUCHAR)pncb;
 90 ncb.ncb_lana_num = pncb->ncb_lana_num;
 91 if(Netbios(&ncb)!=NRC_GOODRET)
 92 {
 93 printf("Netbios NCBCANCEL ERROR:%0xh\n",ncb.ncb_retcode);
 94 return ncb.ncb_retcode;
 95 }
 96 return NRC_GOODRET;
 97 }
 98 //
 99 //Hangup Command
100 //
101 int Hangup(int lana,int lsn)
102 {
103 NCB ncb;
104 int retcode;
105 ZeroMemory(&ncb,sizeof(NCB));
106 ncb.ncb_command = NCBHANGUP;
107 ncb.ncb_lsn = lsn;
108 ncb.ncb_lana_num = lana;
109 retcode = Netbios(&ncb);
110 return retcode;
111 }
112 //
113 //Delete Name Command
114 //
115 int DelName(int lana,char *name)
116 {
117 NCB ncb;
118 ZeroMemory(&ncb,sizeof(NCB));
119 ncb.ncb_command = NCBDELNAME;
120 ncb.ncb_lana_num = lana;
121 //memset(ncb.ncb_name,' ',strlen(name));
122 memset(ncb.ncb_name,' ',NCBNAMSZ);//add by jinhua
123 strncpy((char *)ncb.ncb_name,name,strlen(name));
124 if(Netbios(&ncb) != NRC_GOODRET)
125 {
126 printf("Netbios NCBDELNAME [lana=%d;name=%s] ERROR:%0xh\n",lana,name,ncb.ncb_retcode);
127 return ncb.ncb_retcode;
128 }
129 return NRC_GOODRET;
130 }
131 //
132 //Add the group name to LANA number
133 //Retrun the name number for the registered name.
134 //
135 int AddGroupName(int lana,char *name,UCHAR *num)
136 {
137 NCB ncb;
138 ZeroMemory(&ncb,sizeof(NCB));
139 ncb.ncb_command = NCBADDGRNAME;
140 ncb.ncb_lana_num = lana;
141 memset(ncb.ncb_name,' ',NCBNAMSZ);
142 strncpy((char *)ncb.ncb_name,name,strlen(name));
143 if(Netbios(&ncb)!=NRC_GOODRET)
144 {
145 printf("Netbios NCBADDGRPNAME[lana=%d;name=%s] ERROR:%0xh\n",lana,name,ncb.ncb_retcode);
146 return ncb.ncb_retcode;
147 }
148 *num = ncb.ncb_num;
149 return NRC_GOODRET;
150 }
151 //
152 //function to realize NCBRECV
153 //
154 int Recv(int lana,int lsn,char *buffer,DWORD bufferlen)
155 {
156 NCB ncb;
157 ZeroMemory(&ncb,sizeof(NCB));
158 ncb.ncb_command =NCBRECV;
159 ncb.ncb_buffer =(PUCHAR)buffer;
160 ncb.ncb_length =(unsigned short)bufferlen;
161 ncb.ncb_lana_num =lana;
162 ncb.ncb_lsn =lsn;
163 if(Netbios(&ncb)!=NRC_GOODRET)
164 {
165 bufferlen = -1;
166 printf("Netbios NCBRECV ERROR:%0xh.\n",ncb.ncb_retcode);
167 return ncb.ncb_retcode;
168 }
169 bufferlen = ncb.ncb_length;
170 return NRC_GOODRET;
171 }
172 //
173 //function to realize NCBSEND
174 //
175 int Send(int lana,int lsn,char *data,DWORD len)
176 {
177 NCB ncb;
178 int retcode;
179 ZeroMemory(&ncb,sizeof(NCB));
180 ncb.ncb_command =NCBSEND;
181 ncb.ncb_buffer =(PUCHAR)data;
182 ncb.ncb_length =(unsigned short)len;
183 ncb.ncb_lsn =lsn;
184 ncb.ncb_lana_num =lana;
185 retcode =Netbios(&ncb);
186 return retcode;
187 }
188 //
189 //covert the NetBIOS name from unprintable to printable
190 //
191 int FormatNetbiosName(char *nbname,char *outname)
192 {
193 int i;
194 strncpy(outname,nbname,NCBNAMSZ);
195 outname[NCBNAMSZ-1] = '\0';
196 for(i=0;i<NCBNAMSZ-1;i++)
197 {
198 if(!((outname[i]>=32)&&(outname[i]<=126)))
199 outname[i] = '.';
200 }
201 return NRC_GOODRET;
202 }
203 //
204 //Send a broadcast datagram on the specified LANA number
205 //
206 int DatagramSendBC(int lana,int num,char *buffer,int buflen)
207 {
208 NCB ncb;
209 ZeroMemory(&ncb,sizeof(NCB));
210 ncb.ncb_command = NCBDGSENDBC;
211 ncb.ncb_lana_num = lana;
212 ncb.ncb_num = (UCHAR)num;
213 ncb.ncb_buffer = (PUCHAR)(buffer);
214 ncb.ncb_length = buflen;
215 if(Netbios(&ncb)!=NRC_GOODRET)
216 {
217 printf("Netbios NCBDGSENDBC ERROR:%0xh\n",ncb.ncb_retcode);
218 return ncb.ncb_retcode;
219 }
220 return NRC_GOODRET;
221 }
222 //
223 //receive a broadcast datagram on the specified LANA number from the registered name
224 //
225 int DatagramRecvBC(PNCB pncb,int lana,int num,char *buffer,int buflen,HANDLE hEvent)
226 {
227 ZeroMemory(pncb,sizeof(NCB));
228 ZeroMemory(buffer,sizeof(MAX_DATAGRAM_SIZE));
229 pncb->ncb_command = NCBDGRECVBC|ASYNCH;
230 pncb->ncb_lana_num = lana;
231 pncb->ncb_buffer = (PUCHAR)(buffer);
232 pncb->ncb_length = buflen;
233 pncb->ncb_event = hEvent;
234 if(Netbios(pncb)!=NRC_GOODRET)
235 {
236 printf("Netbios NCBDGRECVBC ERROR:%0xh\n",pncb->ncb_retcode);
237 return pncb->ncb_retcode;
238 }
239 return NRC_GOODRET;
240 }
241 //
242 //Send a directed datagram on the specified LANA number
243 //
244 int DatagramSend(int lana,int num,char *buffer,int buflen,char *Destname)
245 {
246 NCB ncb;
247 ZeroMemory(&ncb,sizeof(NCB));
248 ncb.ncb_command =NCBDGSEND;
249 ncb.ncb_lana_num =lana;
250 ncb.ncb_num =(UCHAR)num;
251 ncb.ncb_buffer =(PUCHAR)buffer;
252 ncb.ncb_length =buflen;
253 memset(ncb.ncb_name,' ',NCBNAMSZ);
254 strncpy((char *)ncb.ncb_callname,Destname,strlen(Destname));
255 if(Netbios(&ncb)!=NRC_GOODRET)
256 {
257 printf("Netbios NCBDGSEND ERROR:%0xh\n",ncb.ncb_retcode);
258 return ncb.ncb_retcode;
259 }
260 return NRC_GOODRET;
261 }
262 //
263 //Recieve a directed datagram on the specified LANA number from registered name
264 //
265 int DatagramRecv(PNCB pncb,int lana,int num,char *buffer,int buflen,HANDLE hEvent)
266 {
267 ZeroMemory(pncb,sizeof(NCB));
268 ZeroMemory(buffer,sizeof(MAX_DATAGRAM_SIZE));
269 pncb->ncb_command =NCBDGRECV|ASYNCH;
270 pncb->ncb_lana_num =lana;
271 pncb->ncb_num =(UCHAR)num;
272 pncb->ncb_buffer =(PUCHAR)buffer;
273 pncb->ncb_length =buflen;
274 pncb->ncb_event =hEvent;
275 if(Netbios(pncb)!=NRC_GOODRET)
276 {
277 printf("Netbios NCBDGRECV ERROR:%0xh\n",pncb->ncb_retcode);
278 return pncb->ncb_retcode;
279 }
280 return NRC_GOODRET;
281 }
282 //
283 //function to realize NCBLISTEN
284 //
285 int Listen(PNCB pncb,int lana,char *server,HANDLE hEvent)
286 {
287 pncb->ncb_command = NCBLISTEN|ASYNCH;
288 pncb->ncb_lana_num = lana;
289 memset(&pncb->ncb_name,' ',NCBNAMSZ);
290 strncpy((char *)&pncb->ncb_name,server,strlen(server));
291 memset(&pncb->ncb_callname,' ',NCBNAMSZ);
292 pncb->ncb_callname[0] = '*';
293 pncb->ncb_event = hEvent;
294 //you also can use callback function to providw service to client
295 //pncb->ncb_post =listencallback;
296 if(Netbios(pncb)!=NRC_GOODRET)
297 {
298 printf("Netbios NCBLISTEN ERROR:%0xh.\n",pncb->ncb_retcode);
299 return pncb->ncb_retcode;
300 }
301 return NRC_GOODRET;
302 }
303 //
304 //fuction to realize NCBCALL
305 //
306 int Connect(PNCB pncb,int lana,char *server,char *client,HANDLE hEvent)
307 {
308 pncb->ncb_command =NCBCALL|ASYNCH;
309 pncb->ncb_lana_num =lana;
310 memset(&pncb->ncb_name,' ',NCBNAMSZ);
311 strncpy((char *)&pncb->ncb_name,client,strlen(client));
312 memset(&pncb->ncb_callname,' ',NCBNAMSZ);
313 strncpy((char *)&pncb->ncb_callname,server,strlen(server));
314 pncb->ncb_event =hEvent;
315 if(Netbios(pncb)!=NRC_GOODRET)
316 {
317 printf("ERROR:Netbios:NCBCONNECT.%0xh\n",pncb->ncb_retcode);
318 return pncb->ncb_retcode;
319 }
320 return NRC_GOODRET;
321 }

View Code

这两天看的netbios,简单整理了一下，分享给园友，有问题请指正，谢谢。

转载于:https://www.cnblogs.com/zCoderJoy/p/3887018.html

NetBios网络基础及编程相关推荐

网络基础+Socket编程+高并发服务器
网络编程 P1 复习 Linux 网络编程 P2 信号量生产者复习 P3 协议 P4 七层模型和四层模型及代表协议 P5 网络传输数据封装流程 P6 以太网帧和ARP请求 P7 IP 协议 P8 TC ...
Python3 与 C# 网络编程之～网络基础篇
最新版本查看:https://www.cnblogs.com/dotnetcrazy/p/9919202.html 入门篇官方文档:https://docs.python.org/3/library ...
Linux应用程序设计之网络基础编程
1.TCP/IP协议概述 1.1.OSI参考模型及TCP/IP参考模型 OSI协议参考模型是基于国际标准化组织(ISO)的建议发展起来的,从上到下工分为7层:应用层,表示层,会话层,传输层,网络层,数 ...
网络编程—网络基础概览、socket，TCP/UDP协议
网络基础概览 socket概览 socket模块-TCP/UDP的实现 TCP/UDP总结网络基础概览 osi七层协议各层主要的协议 # 物理层传输电信号1010101010 # 数据链路层,以太网 ...
菜鸟学习笔记：Java提升篇9（网络1——网络基础、Java网络编程）
菜鸟学习笔记:Java提升篇9(网络1--网络基础.Java网络编程) 网络基础什么是计算机网络 OS七层模型 Java网络编程 InetAddress InetSocketAddress URL类 ...
网络基础：NetBIOS
网络基础小补. 利用 NetBIOS 名称与其他计算机通信网络中的计算机之间必须知道IP地址后才能相互通信.但对人来说IP难以记忆,NetBIOS计算机名称比较容易记忆.当计算机使用 NetBIOS ...
计算机智能编程任务赛,网络基础赛 | 智能编程任务赛比赛规则
原标题:网络基础赛 | 智能编程任务赛比赛规则一. 比赛目标 <新一代人工智能发展规划>中指出,"要支持开展形式多样的人工智能科普活动,全面提高全社会对人工智能的整体认知和应用 ...
python 复习——网络编程(三)——网络基础、多线程、ftp任务铺垫
一.网络基础学习网络编程,了解一些网络基础的知识是必不可少的,下面学习一些基础的网络知识: 1.我们的电脑里有网卡,网卡里有mac地址: 2.我到某个地方插上网线,路由器或交换机中的DHCP服务为我 ...
网络编程_1(网络基础+跨主机传输)
一.网络基础知识点回顾: 同一主机间的进程通讯方式: 1.无名管道(亲缘关系间的通讯,固定的读端和写端) 2.有名管道(半双工(因为文件可见,可再次打开交换读端写端),非亲缘关系) 3.信号 4.共 ...

NetBios网络基础及编程

NetBios网络基础及编程相关推荐

最新文章

热门文章