dbghelp: Prevent debug overflow of internal buffer while tracing.
[wine] / dlls / netapi32 / nbt.c
1 /* Copyright (c) 2003 Juan Lang
2  *
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  *
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * Lesser General Public License for more details.
12  *
13  * You should have received a copy of the GNU Lesser General Public
14  * License along with this library; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
16  *
17  * I am heavily indebted to Chris Hertel's excellent Implementing CIFS,
18  * http://ubiqx.org/cifs/ , for whatever understanding I have of NBT.
19  * I also stole from Mike McCormack's smb.c and netapi32.c, although little of
20  * that code remains.
21  * Lack of understanding and bugs are my fault.
22  *
23  * FIXME:
24  * - Of the NetBIOS session functions, only client functions are supported, and
25  *   it's likely they'll be the only functions supported.  NBT requires session
26  *   servers to listen on TCP/139.  This requires root privilege, and Samba is
27  *   likely to be listening here already.  This further restricts NetBIOS
28  *   applications, both explicit users and implicit ones:  CreateNamedPipe
29  *   won't actually create a listening pipe, for example, so applications can't
30  *   act as RPC servers using a named pipe protocol binding, DCOM won't be able
31  *   to support callbacks or servers over the named pipe protocol, etc.
32  *
33  * - Datagram support is omitted for the same reason.  To send a NetBIOS
34  *   datagram, you must include the NetBIOS name by which your application is
35  *   known.  This requires you to have registered the name previously, and be
36  *   able to act as a NetBIOS datagram server (listening on UDP/138).
37  *
38  * - Name registration functions are omitted for the same reason--registering a
39  *   name requires you to be able to defend it, and this means listening on
40  *   UDP/137.
41  *   Win98 requires you either use your computer's NetBIOS name (with the NULL
42  *   suffix byte) as the calling name when creating a session, or to register
43  *   a new name before creating one:  it disallows '*' as the calling name.
44  *   Win2K initially starts with an empty name table, and doesn't allow you to
45  *   use the machine's NetBIOS name (with the NULL suffix byte) as the calling
46  *   name.  Although it allows sessions to be created with '*' as the calling
47  *   name, doing so results in timeouts for all receives, because the
48  *   application never gets them.
49  *   So, a well-behaved NetBIOS application will typically want to register a
50  *   name.  I should probably support a do-nothing name list that allows
51  *   NCBADDNAME to add to it, but doesn't actually register the name, or does
52  *   attempt to register it without being able to defend it.
53  *
54  * - Name lookups may not behave quite as you'd expect/like if you have
55  *   multiple LANAs.  If a name is resolvable through DNS, or if you're using
56  *   WINS, it'll resolve on _any_ LANA.  So, a Call will succeed on any LANA as
57  *   well.
58  *   I'm not sure how Windows behaves in this case.  I could try to force
59  *   lookups to the correct adapter by using one of the GetPreferred*
60  *   functions, but with the possibility of multiple adapters in the same
61  *   same subnet, there's no guarantee that what IpHlpApi thinks is the
62  *   preferred adapter will actually be a LANA.  (It's highly probable because
63  *   this is an unusual configuration, but not guaranteed.)
64  *
65  * See also other FIXMEs in the code.
66  */
67
68 #include "config.h"
69 #include <stdarg.h>
70
71 #include "winsock2.h"
72 #include "windef.h"
73 #include "winbase.h"
74 #include "wine/debug.h"
75 #include "winreg.h"
76 #include "iphlpapi.h"
77
78 #include "netbios.h"
79 #include "nbnamecache.h"
80
81 WINE_DEFAULT_DEBUG_CHANNEL(netbios);
82
83 #define PORT_NBNS 137
84 #define PORT_NBDG 138
85 #define PORT_NBSS 139
86
87 #ifndef INADDR_NONE
88 #define INADDR_NONE ~0UL
89 #endif
90
91 #define NBR_ADDWORD(p,word) (*(WORD *)(p)) = htons(word)
92 #define NBR_GETWORD(p) ntohs(*(WORD *)(p))
93
94 #define MIN_QUERIES         1
95 #define MAX_QUERIES         0xffff
96 #define MIN_QUERY_TIMEOUT   100
97 #define MAX_QUERY_TIMEOUT   0xffffffff
98 #define BCAST_QUERIES       3
99 #define BCAST_QUERY_TIMEOUT 750
100 #define WINS_QUERIES        3
101 #define WINS_QUERY_TIMEOUT  750
102 #define MAX_WINS_SERVERS    2
103 #define MIN_CACHE_TIMEOUT   60000
104 #define CACHE_TIMEOUT       360000
105
106 #define MAX_NBT_NAME_SZ (NCBNAMSZ * 2 + MAX_DOMAIN_NAME_LEN + 2)
107 #define SIMPLE_NAME_QUERY_PKT_SIZE 26 + MAX_NBT_NAME_SZ
108
109 #define DEFAULT_NBT_SESSIONS 16
110
111 #define NBNS_TYPE_NB             0x0020
112 #define NBNS_TYPE_NBSTAT         0x0021
113 #define NBNS_CLASS_INTERNET      0x00001
114 #define NBNS_HEADER_SIZE         (sizeof(WORD) * 6)
115 #define NBNS_RESPONSE_AND_OPCODE 0xf800
116 #define NBNS_RESPONSE_AND_QUERY  0x8000
117 #define NBNS_REPLYCODE           0x0f
118
119 #define NBSS_HDRSIZE 4
120
121 #define NBSS_MSG       0x00
122 #define NBSS_REQ       0x81
123 #define NBSS_ACK       0x82
124 #define NBSS_NACK      0x83
125 #define NBSS_RETARGET  0x84
126 #define NBSS_KEEPALIVE 0x85
127
128 #define NBSS_ERR_NOT_LISTENING_ON_NAME    0x80
129 #define NBSS_ERR_NOT_LISTENING_FOR_CALLER 0x81
130 #define NBSS_ERR_BAD_NAME                 0x82
131 #define NBSS_ERR_INSUFFICIENT_RESOURCES   0x83
132
133 #define NBSS_EXTENSION 0x01
134
135 typedef struct _NetBTSession
136 {
137     CRITICAL_SECTION cs;
138     SOCKET           fd;
139     DWORD            bytesPending;
140 } NetBTSession;
141
142 typedef struct _NetBTAdapter
143 {
144     MIB_IPADDRROW       ipr;
145     WORD                nameQueryXID;
146     struct NBNameCache *nameCache;
147     DWORD               xmit_success;
148     DWORD               recv_success;
149 } NetBTAdapter;
150
151 static ULONG gTransportID;
152 static BOOL  gEnableDNS;
153 static DWORD gBCastQueries;
154 static DWORD gBCastQueryTimeout;
155 static DWORD gWINSQueries;
156 static DWORD gWINSQueryTimeout;
157 static DWORD gWINSServers[MAX_WINS_SERVERS];
158 static int   gNumWINSServers;
159 static char  gScopeID[MAX_DOMAIN_NAME_LEN];
160 static DWORD gCacheTimeout;
161 static struct NBNameCache *gNameCache;
162
163 /* Converts from a NetBIOS name into a Second Level Encoding-formatted name.
164  * Assumes p is not NULL and is either NULL terminated or has at most NCBNAMSZ
165  * bytes, and buffer has at least MAX_NBT_NAME_SZ bytes.  Pads with space bytes
166  * if p is NULL-terminated.  Returns the number of bytes stored in buffer.
167  */
168 static int NetBTNameEncode(const UCHAR *p, UCHAR *buffer)
169 {
170     int i,len=0;
171
172     if (!p) return 0;
173     if (!buffer) return 0;
174
175     buffer[len++] = NCBNAMSZ * 2;
176     for (i = 0; p[i] && i < NCBNAMSZ; i++)
177     {
178         buffer[len++] = ((p[i] & 0xf0) >> 4) + 'A';
179         buffer[len++] =  (p[i] & 0x0f) + 'A';
180     }
181     while (len < NCBNAMSZ * 2)
182     {
183         buffer[len++] = 'C';
184         buffer[len++] = 'A';
185     }
186     if (*gScopeID)
187     {
188         int scopeIDLen = strlen(gScopeID);
189
190         memcpy(buffer + len, gScopeID, scopeIDLen);
191         len += scopeIDLen;
192     }
193     buffer[len++] = 0;     /* add second terminator */
194     return len;
195 }
196
197 /* Creates a NBT name request packet for name in buffer.  If broadcast is true,
198  * creates a broadcast request, otherwise creates a unicast request.
199  * Returns the number of bytes stored in buffer.
200  */
201 static DWORD NetBTNameReq(const UCHAR name[NCBNAMSZ], WORD xid, WORD qtype,
202  BOOL broadcast, UCHAR *buffer, int len)
203 {
204     int i = 0;
205
206     if (len < SIMPLE_NAME_QUERY_PKT_SIZE) return 0;
207
208     NBR_ADDWORD(&buffer[i],xid);    i+=2; /* transaction */
209     if (broadcast)
210     {
211         NBR_ADDWORD(&buffer[i],0x0110); /* flags: r=req,op=query,rd=1,b=1 */
212         i+=2;
213     }
214     else
215     {
216         NBR_ADDWORD(&buffer[i],0x0100); /* flags: r=req,op=query,rd=1,b=0 */
217         i+=2;
218     }
219     NBR_ADDWORD(&buffer[i],0x0001); i+=2; /* one name query */
220     NBR_ADDWORD(&buffer[i],0x0000); i+=2; /* zero answers */
221     NBR_ADDWORD(&buffer[i],0x0000); i+=2; /* zero authorities */
222     NBR_ADDWORD(&buffer[i],0x0000); i+=2; /* zero additional */
223
224     i += NetBTNameEncode(name, &buffer[i]);
225
226     NBR_ADDWORD(&buffer[i],qtype); i+=2;
227     NBR_ADDWORD(&buffer[i],NBNS_CLASS_INTERNET); i+=2;
228
229     return i;
230 }
231
232 /* Sends a name query request for name on fd to destAddr.  Sets SO_BROADCAST on
233  * fd if broadcast is TRUE.  Assumes fd is not INVALID_SOCKET, and name is not
234  * NULL.
235  * Returns 0 on success, -1 on failure.
236  */
237 static int NetBTSendNameQuery(SOCKET fd, const UCHAR name[NCBNAMSZ], WORD xid,
238  WORD qtype, DWORD destAddr, BOOL broadcast)
239 {
240     int ret = 0, on = 1;
241     struct in_addr addr;
242
243     addr.s_addr = destAddr;
244     TRACE("name %s, dest addr %s\n", name, inet_ntoa(addr));
245
246     if (broadcast)
247         ret = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (const char*)&on, sizeof(on));
248     if(ret == 0)
249     {
250         WSABUF wsaBuf;
251         UCHAR buf[SIMPLE_NAME_QUERY_PKT_SIZE];
252         struct sockaddr_in sin;
253
254         memset(&sin, 0, sizeof(sin));
255         sin.sin_addr.s_addr = destAddr;
256         sin.sin_family      = AF_INET;
257         sin.sin_port        = htons(PORT_NBNS);
258
259         wsaBuf.buf = (CHAR*)buf;
260         wsaBuf.len = NetBTNameReq(name, xid, qtype, broadcast, buf,
261          sizeof(buf));
262         if (wsaBuf.len > 0)
263         {
264             DWORD bytesSent;
265
266             ret = WSASendTo(fd, &wsaBuf, 1, &bytesSent, 0,
267              (struct sockaddr*)&sin, sizeof(sin), NULL, NULL);
268             if (ret < 0 || bytesSent < wsaBuf.len)
269                 ret = -1;
270             else
271                 ret = 0;
272         }
273         else
274             ret = -1;
275     }
276     return ret;
277 }
278
279 typedef BOOL (*NetBTAnswerCallback)(void *data, WORD answerCount,
280  WORD answerIndex, PUCHAR rData, WORD rdLength);
281
282 /* Waits on fd until GetTickCount() returns a value greater than or equal to
283  * waitUntil for a name service response.  If a name response matching xid
284  * is received, calls answerCallback once for each answer resource record in
285  * the response.  (The callback's answerCount will be the total number of
286  * answers to expect, and answerIndex will be the 0-based index that's being
287  * sent this time.)  Quits parsing if answerCallback returns FALSE.
288  * Returns NRC_GOODRET on timeout or a valid response received, something else
289  * on error.
290  */
291 static UCHAR NetBTWaitForNameResponse(const NetBTAdapter *adapter, SOCKET fd,
292  DWORD waitUntil, NetBTAnswerCallback answerCallback, void *data)
293 {
294     BOOL found = FALSE;
295     DWORD now;
296     UCHAR ret = NRC_GOODRET;
297
298     if (!adapter) return NRC_BADDR;
299     if (fd == INVALID_SOCKET) return NRC_BADDR;
300     if (!answerCallback) return NRC_BADDR;
301
302     while (!found && ret == NRC_GOODRET && (now = GetTickCount()) < waitUntil)
303     {
304         DWORD msToWait = waitUntil - now;
305         struct fd_set fds;
306         struct timeval timeout = { msToWait / 1000, msToWait % 1000 };
307         int r;
308
309         FD_ZERO(&fds);
310         FD_SET(fd, &fds);
311         r = select(fd + 1, &fds, NULL, NULL, &timeout);
312         if (r < 0)
313             ret = NRC_SYSTEM;
314         else if (r == 1)
315         {
316             /* FIXME: magic #, is this always enough? */
317             UCHAR buffer[256];
318             int fromsize;
319             struct sockaddr_in fromaddr;
320             WORD respXID, flags, queryCount, answerCount;
321             WSABUF wsaBuf = { sizeof(buffer), (CHAR*)buffer };
322             DWORD bytesReceived, recvFlags = 0;
323
324             fromsize = sizeof(fromaddr);
325             r = WSARecvFrom(fd, &wsaBuf, 1, &bytesReceived, &recvFlags,
326              (struct sockaddr*)&fromaddr, &fromsize, NULL, NULL);
327             if(r < 0)
328             {
329                 ret = NRC_SYSTEM;
330                 break;
331             }
332
333             if (bytesReceived < NBNS_HEADER_SIZE)
334                 continue;
335
336             respXID = NBR_GETWORD(buffer);
337             if (adapter->nameQueryXID != respXID)
338                 continue;
339
340             flags = NBR_GETWORD(buffer + 2);
341             queryCount = NBR_GETWORD(buffer + 4);
342             answerCount = NBR_GETWORD(buffer + 6);
343
344             /* a reply shouldn't contain a query, ignore bad packet */
345             if (queryCount > 0)
346                 continue;
347
348             if ((flags & NBNS_RESPONSE_AND_OPCODE) == NBNS_RESPONSE_AND_QUERY)
349             {
350                 if ((flags & NBNS_REPLYCODE) != 0)
351                     ret = NRC_NAMERR;
352                 else if ((flags & NBNS_REPLYCODE) == 0 && answerCount > 0)
353                 {
354                     PUCHAR ptr = buffer + NBNS_HEADER_SIZE;
355                     BOOL shouldContinue = TRUE;
356                     WORD answerIndex = 0;
357
358                     found = TRUE;
359                     /* decode one answer at a time */
360                     while (ret == NRC_GOODRET && answerIndex < answerCount &&
361                      ptr - buffer < bytesReceived && shouldContinue)
362                     {
363                         WORD rLen;
364
365                         /* scan past name */
366                         for (; ptr[0] && ptr - buffer < bytesReceived; )
367                             ptr += ptr[0] + 1;
368                         ptr++;
369                         ptr += 2; /* scan past type */
370                         if (ptr - buffer < bytesReceived && ret == NRC_GOODRET
371                          && NBR_GETWORD(ptr) == NBNS_CLASS_INTERNET)
372                             ptr += sizeof(WORD);
373                         else
374                             ret = NRC_SYSTEM; /* parse error */
375                         ptr += sizeof(DWORD); /* TTL */
376                         rLen = NBR_GETWORD(ptr);
377                         rLen = min(rLen, bytesReceived - (ptr - buffer));
378                         ptr += sizeof(WORD);
379                         shouldContinue = answerCallback(data, answerCount,
380                          answerIndex, ptr, rLen);
381                         ptr += rLen;
382                         answerIndex++;
383                     }
384                 }
385             }
386         }
387     }
388     TRACE("returning 0x%02x\n", ret);
389     return ret;
390 }
391
392 typedef struct _NetBTNameQueryData {
393     NBNameCacheEntry *cacheEntry;
394     UCHAR ret;
395 } NetBTNameQueryData;
396
397 /* Name query callback function for NetBTWaitForNameResponse, creates a cache
398  * entry on the first answer, adds each address as it's called again (as long
399  * as there's space).  If there's an error that should be propagated as the
400  * NetBIOS error, modifies queryData's ret member to the proper return code.
401  */
402 static BOOL NetBTFindNameAnswerCallback(void *pVoid, WORD answerCount,
403  WORD answerIndex, PUCHAR rData, WORD rLen)
404 {
405     NetBTNameQueryData *queryData = (NetBTNameQueryData *)pVoid;
406     BOOL ret;
407
408     if (queryData)
409     {
410         if (queryData->cacheEntry == NULL)
411         {
412             queryData->cacheEntry = HeapAlloc(
413              GetProcessHeap(), 0, sizeof(NBNameCacheEntry) +
414              (answerCount - 1) * sizeof(DWORD));
415             if (queryData->cacheEntry)
416                 queryData->cacheEntry->numAddresses = 0;
417             else
418             {
419                 ret = FALSE;
420                 queryData->ret = NRC_OSRESNOTAV;
421             }
422         }
423         if (rLen == 6 && queryData->cacheEntry &&
424          queryData->cacheEntry->numAddresses < answerCount)
425         {
426             queryData->cacheEntry->addresses[queryData->cacheEntry->
427              numAddresses++] = *(const DWORD *)(rData + 2);
428             ret = queryData->cacheEntry->numAddresses < answerCount;
429         }
430         else
431             ret = FALSE;
432     }
433     else
434         ret = FALSE;
435     return ret;
436 }
437
438 /* Workhorse NetBT name lookup function.  Sends a name lookup query for
439  * ncb->ncb_callname to sendTo, as a broadcast if broadcast is TRUE, using
440  * adapter->nameQueryXID as the transaction ID.  Waits up to timeout
441  * milliseconds, and retries up to maxQueries times, waiting for a reply.
442  * If a valid response is received, stores the looked up addresses as a
443  * NBNameCacheEntry in *cacheEntry.
444  * Returns NRC_GOODRET on success, though this may not mean the name was
445  * resolved--check whether *cacheEntry is NULL.
446  */
447 static UCHAR NetBTNameWaitLoop(const NetBTAdapter *adapter, SOCKET fd, const NCB *ncb,
448  DWORD sendTo, BOOL broadcast, DWORD timeout, DWORD maxQueries,
449  NBNameCacheEntry **cacheEntry)
450 {
451     unsigned int queries;
452     NetBTNameQueryData queryData;
453
454     if (!adapter) return NRC_BADDR;
455     if (fd == INVALID_SOCKET) return NRC_BADDR;
456     if (!ncb) return NRC_BADDR;
457     if (!cacheEntry) return NRC_BADDR;
458
459     queryData.cacheEntry = NULL;
460     queryData.ret = NRC_GOODRET;
461     for (queries = 0; queryData.cacheEntry == NULL && queries < maxQueries;
462      queries++)
463     {
464         if (!NCB_CANCELLED(ncb))
465         {
466             int r = NetBTSendNameQuery(fd, ncb->ncb_callname,
467              adapter->nameQueryXID, NBNS_TYPE_NB, sendTo, broadcast);
468
469             if (r == 0)
470                 queryData.ret = NetBTWaitForNameResponse(adapter, fd,
471                  GetTickCount() + timeout, NetBTFindNameAnswerCallback,
472                  &queryData);
473             else
474                 queryData.ret = NRC_SYSTEM;
475         }
476         else
477             queryData.ret = NRC_CMDCAN;
478     }
479     if (queryData.cacheEntry)
480     {
481         memcpy(queryData.cacheEntry->name, ncb->ncb_callname, NCBNAMSZ);
482         memcpy(queryData.cacheEntry->nbname, ncb->ncb_callname, NCBNAMSZ);
483     }
484     *cacheEntry = queryData.cacheEntry;
485     return queryData.ret;
486 }
487
488 /* Attempts to add cacheEntry to the name cache in *nameCache; if *nameCache
489  * has not yet been created, creates it, using gCacheTimeout as the cache
490  * entry timeout.  If memory allocation fails, or if NBNameCacheAddEntry fails,
491  * frees cacheEntry.
492  * Returns NRC_GOODRET on success, and something else on failure.
493  */
494 static UCHAR NetBTStoreCacheEntry(struct NBNameCache **nameCache,
495  NBNameCacheEntry *cacheEntry)
496 {
497     UCHAR ret;
498
499     if (!nameCache) return NRC_BADDR;
500     if (!cacheEntry) return NRC_BADDR;
501
502     if (!*nameCache)
503         *nameCache = NBNameCacheCreate(GetProcessHeap(), gCacheTimeout);
504     if (*nameCache)
505         ret = NBNameCacheAddEntry(*nameCache, cacheEntry)
506          ?  NRC_GOODRET : NRC_OSRESNOTAV;
507     else
508     {
509         HeapFree(GetProcessHeap(), 0, cacheEntry);
510         ret = NRC_OSRESNOTAV;
511     }
512     return ret;
513 }
514
515 /* Attempts to resolve name using inet_addr(), then gethostbyname() if
516  * gEnableDNS is TRUE, if the suffix byte is either <00> or <20>.  If the name
517  * can be looked up, returns 0 and stores the looked up addresses as a
518  * NBNameCacheEntry in *cacheEntry.
519  * Returns NRC_GOODRET on success, though this may not mean the name was
520  * resolved--check whether *cacheEntry is NULL.  Returns something else on
521  * error.
522  */
523 static UCHAR NetBTinetResolve(const UCHAR name[NCBNAMSZ],
524  NBNameCacheEntry **cacheEntry)
525 {
526     UCHAR ret = NRC_GOODRET;
527
528     TRACE("name %s, cacheEntry %p\n", name, cacheEntry);
529
530     if (!name) return NRC_BADDR;
531     if (!cacheEntry) return NRC_BADDR;
532
533     if (isalnum(name[0]) && (name[NCBNAMSZ - 1] == 0 ||
534      name[NCBNAMSZ - 1] == 0x20))
535     {
536         CHAR toLookup[NCBNAMSZ];
537         unsigned int i;
538
539         for (i = 0; i < NCBNAMSZ - 1 && name[i] && name[i] != ' '; i++)
540             toLookup[i] = name[i];
541         toLookup[i] = '\0';
542
543         if (isdigit(toLookup[0]))
544         {
545             unsigned long addr = inet_addr(toLookup);
546
547             if (addr != INADDR_NONE)
548             {
549                 *cacheEntry = HeapAlloc(GetProcessHeap(),
550                  0, sizeof(NBNameCacheEntry));
551                 if (*cacheEntry)
552                 {
553                     memcpy((*cacheEntry)->name, name, NCBNAMSZ);
554                     memset((*cacheEntry)->nbname, 0, NCBNAMSZ);
555                     (*cacheEntry)->nbname[0] = '*';
556                     (*cacheEntry)->numAddresses = 1;
557                     (*cacheEntry)->addresses[0] = addr;
558                 }
559                 else
560                     ret = NRC_OSRESNOTAV;
561             }
562         }
563         if (gEnableDNS && ret == NRC_GOODRET && !*cacheEntry)
564         {
565             struct hostent *host;
566
567             if ((host = gethostbyname(toLookup)) != NULL)
568             {
569                 for (i = 0; ret == NRC_GOODRET && host->h_addr_list &&
570                  host->h_addr_list[i]; i++)
571                     ;
572                 if (host->h_addr_list && host->h_addr_list[0])
573                 {
574                     *cacheEntry = HeapAlloc(
575                      GetProcessHeap(), 0, sizeof(NBNameCacheEntry) +
576                      (i - 1) * sizeof(DWORD));
577                     if (*cacheEntry)
578                     {
579                         memcpy((*cacheEntry)->name, name, NCBNAMSZ);
580                         memset((*cacheEntry)->nbname, 0, NCBNAMSZ);
581                         (*cacheEntry)->nbname[0] = '*';
582                         (*cacheEntry)->numAddresses = i;
583                         for (i = 0; i < (*cacheEntry)->numAddresses; i++)
584                             (*cacheEntry)->addresses[i] =
585                              (DWORD)host->h_addr_list[i];
586                     }
587                     else
588                         ret = NRC_OSRESNOTAV;
589                 }
590             }
591         }
592     }
593
594     TRACE("returning 0x%02x\n", ret);
595     return ret;
596 }
597
598 /* Looks up the name in ncb->ncb_callname, first in the name caches (global
599  * and this adapter's), then using gethostbyname(), next by WINS if configured,
600  * and finally using broadcast NetBT name resolution.  In NBT parlance, this
601  * makes this an "H-node".  Stores an entry in the appropriate name cache for a
602  * found node, and returns it as *cacheEntry.
603  * Assumes data, ncb, and cacheEntry are not NULL.
604  * Returns NRC_GOODRET on success--which doesn't mean the name was resolved,
605  * just that all name lookup operations completed successfully--and something
606  * else on failure.  *cacheEntry will be NULL if the name was not found.
607  */
608 static UCHAR NetBTInternalFindName(NetBTAdapter *adapter, PNCB ncb,
609  const NBNameCacheEntry **cacheEntry)
610 {
611     UCHAR ret = NRC_GOODRET;
612
613     TRACE("adapter %p, ncb %p, cacheEntry %p\n", adapter, ncb, cacheEntry);
614
615     if (!cacheEntry) return NRC_BADDR;
616     *cacheEntry = NULL;
617
618     if (!adapter) return NRC_BADDR;
619     if (!ncb) return NRC_BADDR;
620
621     if (ncb->ncb_callname[0] == '*')
622         ret = NRC_NOWILD;
623     else
624     {
625         *cacheEntry = NBNameCacheFindEntry(gNameCache, ncb->ncb_callname);
626         if (!*cacheEntry)
627             *cacheEntry = NBNameCacheFindEntry(adapter->nameCache,
628              ncb->ncb_callname);
629         if (!*cacheEntry)
630         {
631             NBNameCacheEntry *newEntry = NULL;
632
633             ret = NetBTinetResolve(ncb->ncb_callname, &newEntry);
634             if (ret == NRC_GOODRET && newEntry)
635             {
636                 ret = NetBTStoreCacheEntry(&gNameCache, newEntry);
637                 if (ret != NRC_GOODRET)
638                     newEntry = NULL;
639             }
640             else
641             {
642                 SOCKET fd = WSASocketA(PF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL,
643                  0, WSA_FLAG_OVERLAPPED);
644
645                 if(fd == INVALID_SOCKET)
646                     ret = NRC_OSRESNOTAV;
647                 else
648                 {
649                     int winsNdx;
650
651                     adapter->nameQueryXID++;
652                     for (winsNdx = 0; ret == NRC_GOODRET && *cacheEntry == NULL
653                      && winsNdx < gNumWINSServers; winsNdx++)
654                         ret = NetBTNameWaitLoop(adapter, fd, ncb,
655                          gWINSServers[winsNdx], FALSE, gWINSQueryTimeout,
656                          gWINSQueries, &newEntry);
657                     if (ret == NRC_GOODRET && newEntry)
658                     {
659                         ret = NetBTStoreCacheEntry(&gNameCache, newEntry);
660                         if (ret != NRC_GOODRET)
661                             newEntry = NULL;
662                     }
663                     if (ret == NRC_GOODRET && *cacheEntry == NULL)
664                     {
665                         DWORD bcastAddr =
666                          adapter->ipr.dwAddr & adapter->ipr.dwMask;
667
668                         if (adapter->ipr.dwBCastAddr)
669                             bcastAddr |= ~adapter->ipr.dwMask;
670                         ret = NetBTNameWaitLoop(adapter, fd, ncb, bcastAddr,
671                          TRUE, gBCastQueryTimeout, gBCastQueries, &newEntry);
672                         if (ret == NRC_GOODRET && newEntry)
673                         {
674                             ret = NetBTStoreCacheEntry(&adapter->nameCache,
675                              newEntry);
676                             if (ret != NRC_GOODRET)
677                                 newEntry = NULL;
678                         }
679                     }
680                     closesocket(fd);
681                 }
682             }
683             *cacheEntry = newEntry;
684         }
685     }
686     TRACE("returning 0x%02x\n", ret);
687     return ret;
688 }
689
690 typedef struct _NetBTNodeQueryData
691 {
692     BOOL gotResponse;
693     PADAPTER_STATUS astat;
694     WORD astatLen;
695 } NetBTNodeQueryData;
696
697 /* Callback function for NetBTAstatRemote, parses the rData for the node
698  * status and name list of the remote node.  Always returns FALSE, since
699  * there's never more than one answer we care about in a node status response.
700  */
701 static BOOL NetBTNodeStatusAnswerCallback(void *pVoid, WORD answerCount,
702  WORD answerIndex, PUCHAR rData, WORD rLen)
703 {
704     NetBTNodeQueryData *data = (NetBTNodeQueryData *)pVoid;
705
706     if (data && !data->gotResponse && rData && rLen >= 1)
707     {
708         /* num names is first byte; each name is NCBNAMSZ + 2 bytes */
709         if (rLen >= rData[0] * (NCBNAMSZ + 2))
710         {
711             WORD i;
712             PUCHAR src;
713             PNAME_BUFFER dst;
714
715             data->gotResponse = TRUE;
716             data->astat->name_count = rData[0];
717             for (i = 0, src = rData + 1,
718              dst = (PNAME_BUFFER)((PUCHAR)data->astat +
719               sizeof(ADAPTER_STATUS));
720              i < data->astat->name_count && src - rData < rLen &&
721              (PUCHAR)dst - (PUCHAR)data->astat < data->astatLen;
722              i++, dst++, src += NCBNAMSZ + 2)
723             {
724                 UCHAR flags = *(src + NCBNAMSZ);
725
726                 memcpy(dst->name, src, NCBNAMSZ);
727                 /* we won't actually see a registering name in the returned
728                  * response.  It's useful to see if no other flags are set; if
729                  * none are, then the name is registered. */
730                 dst->name_flags = REGISTERING;
731                 if (flags & 0x80)
732                     dst->name_flags |= GROUP_NAME;
733                 if (flags & 0x10)
734                     dst->name_flags |= DEREGISTERED;
735                 if (flags & 0x08)
736                     dst->name_flags |= DUPLICATE;
737                 if (dst->name_flags == REGISTERING)
738                     dst->name_flags = REGISTERED;
739             }
740             /* arbitrarily set HW type to Ethernet */
741             data->astat->adapter_type = 0xfe;
742             if (src - rData < rLen)
743                 memcpy(data->astat->adapter_address, src,
744                  min(rLen - (src - rData), 6));
745         }
746     }
747     return FALSE;
748 }
749
750 /* This uses the WINS timeout and query values, as they're the
751  * UCAST_REQ_RETRY_TIMEOUT and UCAST_REQ_RETRY_COUNT according to the RFCs.
752  */
753 static UCHAR NetBTAstatRemote(NetBTAdapter *adapter, PNCB ncb)
754 {
755     UCHAR ret = NRC_GOODRET;
756     const NBNameCacheEntry *cacheEntry = NULL;
757
758     TRACE("adapter %p, NCB %p\n", adapter, ncb);
759
760     if (!adapter) return NRC_BADDR;
761     if (!ncb) return NRC_INVADDRESS;
762
763     ret = NetBTInternalFindName(adapter, ncb, &cacheEntry);
764     if (ret == NRC_GOODRET && cacheEntry)
765     {
766         if (cacheEntry->numAddresses > 0)
767         {
768             SOCKET fd = WSASocketA(PF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0,
769              WSA_FLAG_OVERLAPPED);
770
771             if(fd == INVALID_SOCKET)
772                 ret = NRC_OSRESNOTAV;
773             else
774             {
775                 NetBTNodeQueryData queryData;
776                 DWORD queries;
777                 PADAPTER_STATUS astat = (PADAPTER_STATUS)ncb->ncb_buffer;
778
779                 adapter->nameQueryXID++;
780                 astat->name_count = 0;
781                 queryData.gotResponse = FALSE;
782                 queryData.astat = astat;
783                 queryData.astatLen = ncb->ncb_length;
784                 for (queries = 0; !queryData.gotResponse &&
785                  queries < gWINSQueries; queries++)
786                 {
787                     if (!NCB_CANCELLED(ncb))
788                     {
789                         int r = NetBTSendNameQuery(fd, ncb->ncb_callname,
790                          adapter->nameQueryXID, NBNS_TYPE_NBSTAT,
791                          cacheEntry->addresses[0], FALSE);
792
793                         if (r == 0)
794                             ret = NetBTWaitForNameResponse(adapter, fd,
795                              GetTickCount() + gWINSQueryTimeout,
796                              NetBTNodeStatusAnswerCallback, &queryData);
797                         else
798                             ret = NRC_SYSTEM;
799                     }
800                     else
801                         ret = NRC_CMDCAN;
802                 }
803                 closesocket(fd);
804             }
805         }
806         else
807             ret = NRC_CMDTMO;
808     }
809     else if (ret == NRC_CMDCAN)
810         ; /* do nothing, we were cancelled */
811     else
812         ret = NRC_CMDTMO;
813     TRACE("returning 0x%02x\n", ret);
814     return ret;
815 }
816
817 static UCHAR NetBTAstat(void *adapt, PNCB ncb)
818 {
819     NetBTAdapter *adapter = (NetBTAdapter *)adapt;
820     UCHAR ret;
821
822     TRACE("adapt %p, NCB %p\n", adapt, ncb);
823
824     if (!adapter) return NRC_ENVNOTDEF;
825     if (!ncb) return NRC_INVADDRESS;
826     if (!ncb->ncb_buffer) return NRC_BADDR;
827     if (ncb->ncb_length < sizeof(ADAPTER_STATUS)) return NRC_BUFLEN;
828
829     if (ncb->ncb_callname[0] == '*')
830     {
831         DWORD physAddrLen;
832         MIB_IFROW ifRow;
833         PADAPTER_STATUS astat = (PADAPTER_STATUS)ncb->ncb_buffer;
834   
835         memset(astat, 0, sizeof(ADAPTER_STATUS));
836         astat->rev_major = 3;
837         ifRow.dwIndex = adapter->ipr.dwIndex;
838         if (GetIfEntry(&ifRow) != NO_ERROR)
839             ret = NRC_BRIDGE;
840         else
841         {
842             physAddrLen = min(ifRow.dwPhysAddrLen, 6);
843             if (physAddrLen > 0)
844                 memcpy(astat->adapter_address, ifRow.bPhysAddr, physAddrLen);
845             /* doubt anyone cares, but why not.. */
846             if (ifRow.dwType == MIB_IF_TYPE_TOKENRING)
847                 astat->adapter_type = 0xff;
848             else
849                 astat->adapter_type = 0xfe; /* for Ethernet */
850             astat->max_sess_pkt_size = 0xffff;
851             astat->xmit_success = adapter->xmit_success;
852             astat->recv_success = adapter->recv_success;
853         }
854         ret = NRC_GOODRET;
855     }
856     else
857         ret = NetBTAstatRemote(adapter, ncb);
858     TRACE("returning 0x%02x\n", ret);
859     return ret;
860 }
861
862 static UCHAR NetBTFindName(void *adapt, PNCB ncb)
863 {
864     NetBTAdapter *adapter = (NetBTAdapter *)adapt;
865     UCHAR ret;
866     const NBNameCacheEntry *cacheEntry = NULL;
867     PFIND_NAME_HEADER foundName;
868
869     TRACE("adapt %p, NCB %p\n", adapt, ncb);
870
871     if (!adapter) return NRC_ENVNOTDEF;
872     if (!ncb) return NRC_INVADDRESS;
873     if (!ncb->ncb_buffer) return NRC_BADDR;
874     if (ncb->ncb_length < sizeof(FIND_NAME_HEADER)) return NRC_BUFLEN;
875
876     foundName = (PFIND_NAME_HEADER)ncb->ncb_buffer;
877     memset(foundName, 0, sizeof(FIND_NAME_HEADER));
878
879     ret = NetBTInternalFindName(adapter, ncb, &cacheEntry);
880     if (ret == NRC_GOODRET)
881     {
882         if (cacheEntry)
883         {
884             DWORD spaceFor = min((ncb->ncb_length - sizeof(FIND_NAME_HEADER)) /
885              sizeof(FIND_NAME_BUFFER), cacheEntry->numAddresses);
886             DWORD ndx;
887
888             for (ndx = 0; ndx < spaceFor; ndx++)
889             {
890                 PFIND_NAME_BUFFER findNameBuffer;
891
892                 findNameBuffer =
893                  (PFIND_NAME_BUFFER)((PUCHAR)foundName +
894                  sizeof(FIND_NAME_HEADER) + foundName->node_count *
895                  sizeof(FIND_NAME_BUFFER));
896                 memset(findNameBuffer->destination_addr, 0, 2);
897                 memcpy(findNameBuffer->destination_addr + 2,
898                  &adapter->ipr.dwAddr, sizeof(DWORD));
899                 memset(findNameBuffer->source_addr, 0, 2);
900                 memcpy(findNameBuffer->source_addr + 2,
901                  &cacheEntry->addresses[ndx], sizeof(DWORD));
902                 foundName->node_count++;
903             }
904             if (spaceFor < cacheEntry->numAddresses)
905                 ret = NRC_BUFLEN;
906         }
907         else
908             ret = NRC_CMDTMO;
909     }
910     TRACE("returning 0x%02x\n", ret);
911     return ret;
912 }
913
914 static UCHAR NetBTSessionReq(SOCKET fd, const UCHAR *calledName,
915  const UCHAR *callingName)
916 {
917     UCHAR buffer[NBSS_HDRSIZE + MAX_DOMAIN_NAME_LEN * 2], ret;
918     int r;
919     unsigned int len = 0;
920     DWORD bytesSent, bytesReceived, recvFlags = 0;
921     WSABUF wsaBuf;
922
923     buffer[0] = NBSS_REQ;
924     buffer[1] = 0;
925
926     len += NetBTNameEncode(calledName, &buffer[NBSS_HDRSIZE]);
927     len += NetBTNameEncode(callingName, &buffer[NBSS_HDRSIZE + len]);
928
929     NBR_ADDWORD(&buffer[2], len);
930
931     wsaBuf.len = len + NBSS_HDRSIZE;
932     wsaBuf.buf = (char*)buffer;
933
934     r = WSASend(fd, &wsaBuf, 1, &bytesSent, 0, NULL, NULL);
935     if(r < 0 || bytesSent < len + NBSS_HDRSIZE)
936     {
937         ERR("send failed\n");
938         return NRC_SABORT;
939     }
940
941     /* I've already set the recv timeout on this socket (if it supports it), so
942      * just block.  Hopefully we'll always receive the session acknowledgement
943      * within one timeout.
944      */
945     wsaBuf.len = NBSS_HDRSIZE + 1;
946     r = WSARecv(fd, &wsaBuf, 1, &bytesReceived, &recvFlags, NULL, NULL);
947     if (r < 0 || bytesReceived < NBSS_HDRSIZE)
948         ret = NRC_SABORT;
949     else if (buffer[0] == NBSS_NACK)
950     {
951         if (r == NBSS_HDRSIZE + 1)
952         {
953             switch (buffer[NBSS_HDRSIZE])
954             {
955                 case NBSS_ERR_INSUFFICIENT_RESOURCES:
956                     ret = NRC_REMTFUL;
957                     break;
958                 default:
959                     ret = NRC_NOCALL;
960             }
961         }
962         else
963             ret = NRC_NOCALL;
964     }
965     else if (buffer[0] == NBSS_RETARGET)
966     {
967         FIXME("Got a session retarget, can't deal\n");
968         ret = NRC_NOCALL;
969     }
970     else if (buffer[0] == NBSS_ACK)
971         ret = NRC_GOODRET;
972     else
973         ret = NRC_SYSTEM;
974
975     TRACE("returning 0x%02x\n", ret);
976     return ret;
977 }
978
979 static UCHAR NetBTCall(void *adapt, PNCB ncb, void **sess)
980 {
981     NetBTAdapter *adapter = (NetBTAdapter *)adapt;
982     UCHAR ret;
983     const NBNameCacheEntry *cacheEntry = NULL;
984
985     TRACE("adapt %p, ncb %p\n", adapt, ncb);
986
987     if (!adapter) return NRC_ENVNOTDEF;
988     if (!ncb) return NRC_INVADDRESS;
989     if (!sess) return NRC_BADDR;
990
991     ret = NetBTInternalFindName(adapter, ncb, &cacheEntry);
992     if (ret == NRC_GOODRET)
993     {
994         if (cacheEntry && cacheEntry->numAddresses > 0)
995         {
996             SOCKET fd;
997
998             fd = WSASocketA(PF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
999              WSA_FLAG_OVERLAPPED);
1000             if (fd != INVALID_SOCKET)
1001             {
1002                 DWORD timeout;
1003                 struct sockaddr_in sin;
1004
1005                 if (ncb->ncb_rto > 0)
1006                 {
1007                     timeout = ncb->ncb_rto * 500;
1008                     setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout,
1009                      sizeof(timeout));
1010                 }
1011                 if (ncb->ncb_rto > 0)
1012                 {
1013                     timeout = ncb->ncb_sto * 500;
1014                     setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout,
1015                      sizeof(timeout));
1016                 }
1017
1018                 memset(&sin, 0, sizeof(sin));
1019                 memcpy(&sin.sin_addr, &cacheEntry->addresses[0],
1020                  sizeof(sin.sin_addr));
1021                 sin.sin_family = AF_INET;
1022                 sin.sin_port   = htons(PORT_NBSS);
1023                 /* FIXME: use nonblocking mode for the socket, check the
1024                  * cancel flag periodically
1025                  */
1026                 if (connect(fd, (struct sockaddr *)&sin, sizeof(sin))
1027                  == SOCKET_ERROR)
1028                     ret = NRC_CMDTMO;
1029                 else
1030                 {
1031                     static const UCHAR fakedCalledName[] = "*SMBSERVER";
1032                     const UCHAR *calledParty = cacheEntry->nbname[0] == '*'
1033                      ? fakedCalledName : cacheEntry->nbname;
1034
1035                     ret = NetBTSessionReq(fd, calledParty, ncb->ncb_name);
1036                     if (ret != NRC_GOODRET && calledParty[0] == '*')
1037                     {
1038                         FIXME("NBT session to \"*SMBSERVER\" refused,\n");
1039                         FIXME("should try finding name using ASTAT\n");
1040                     }
1041                 }
1042                 if (ret != NRC_GOODRET)
1043                     closesocket(fd);
1044                 else
1045                 {
1046                     NetBTSession *session = HeapAlloc(
1047                      GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NetBTSession));
1048
1049                     if (session)
1050                     {
1051                         session->fd = fd;
1052                         InitializeCriticalSection(&session->cs);
1053                         session->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": NetBTSession.cs");
1054                         *sess = session;
1055                     }
1056                     else
1057                     {
1058                         ret = NRC_OSRESNOTAV;
1059                         closesocket(fd);
1060                     }
1061                 }
1062             }
1063             else
1064                 ret = NRC_OSRESNOTAV;
1065         }
1066         else
1067             ret = NRC_NAMERR;
1068     }
1069     TRACE("returning 0x%02x\n", ret);
1070     return ret;
1071 }
1072
1073 /* Notice that I don't protect against multiple thread access to NetBTSend.
1074  * This is because I don't update any data in the adapter, and I only make a
1075  * single call to WSASend, which I assume to act atomically (not interleaving
1076  * data from other threads).
1077  * I don't lock, because I only depend on the fd being valid, and this won't be
1078  * true until a session setup is completed.
1079  */
1080 static UCHAR NetBTSend(void *adapt, void *sess, PNCB ncb)
1081 {
1082     NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1083     NetBTSession *session = (NetBTSession *)sess;
1084     UCHAR buffer[NBSS_HDRSIZE], ret;
1085     int r;
1086     WSABUF wsaBufs[2];
1087     DWORD bytesSent;
1088
1089     TRACE("adapt %p, session %p, NCB %p\n", adapt, session, ncb);
1090
1091     if (!adapter) return NRC_ENVNOTDEF;
1092     if (!ncb) return NRC_INVADDRESS;
1093     if (!ncb->ncb_buffer) return NRC_BADDR;
1094     if (!session) return NRC_SNUMOUT;
1095     if (session->fd == INVALID_SOCKET) return NRC_SNUMOUT;
1096
1097     buffer[0] = NBSS_MSG;
1098     buffer[1] = 0;
1099     NBR_ADDWORD(&buffer[2], ncb->ncb_length);
1100
1101     wsaBufs[0].len = NBSS_HDRSIZE;
1102     wsaBufs[0].buf = (char*)buffer;
1103     wsaBufs[1].len = ncb->ncb_length;
1104     wsaBufs[1].buf = (char*)ncb->ncb_buffer;
1105
1106     r = WSASend(session->fd, wsaBufs, sizeof(wsaBufs) / sizeof(wsaBufs[0]),
1107      &bytesSent, 0, NULL, NULL);
1108     if (r == SOCKET_ERROR)
1109     {
1110         NetBIOSHangupSession(ncb);
1111         ret = NRC_SABORT;
1112     }
1113     else if (bytesSent < NBSS_HDRSIZE + ncb->ncb_length)
1114     {
1115         FIXME("Only sent %d bytes (of %d), hanging up session\n", bytesSent,
1116          NBSS_HDRSIZE + ncb->ncb_length);
1117         NetBIOSHangupSession(ncb);
1118         ret = NRC_SABORT;
1119     }
1120     else
1121     {
1122         ret = NRC_GOODRET;
1123         adapter->xmit_success++;
1124     }
1125     TRACE("returning 0x%02x\n", ret);
1126     return ret;
1127 }
1128
1129 static UCHAR NetBTRecv(void *adapt, void *sess, PNCB ncb)
1130 {
1131     NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1132     NetBTSession *session = (NetBTSession *)sess;
1133     UCHAR buffer[NBSS_HDRSIZE], ret;
1134     int r;
1135     WSABUF wsaBufs[2];
1136     DWORD bufferCount, bytesReceived, flags;
1137
1138     TRACE("adapt %p, session %p, NCB %p\n", adapt, session, ncb);
1139
1140     if (!adapter) return NRC_ENVNOTDEF;
1141     if (!ncb) return NRC_BADDR;
1142     if (!ncb->ncb_buffer) return NRC_BADDR;
1143     if (!session) return NRC_SNUMOUT;
1144     if (session->fd == INVALID_SOCKET) return NRC_SNUMOUT;
1145
1146     EnterCriticalSection(&session->cs);
1147     bufferCount = 0;
1148     if (session->bytesPending == 0)
1149     {
1150         bufferCount++;
1151         wsaBufs[0].len = NBSS_HDRSIZE;
1152         wsaBufs[0].buf = (char*)buffer;
1153     }
1154     wsaBufs[bufferCount].len = ncb->ncb_length;
1155     wsaBufs[bufferCount].buf = (char*)ncb->ncb_buffer;
1156     bufferCount++;
1157
1158     flags = 0;
1159     /* FIXME: should poll a bit so I can check the cancel flag */
1160     r = WSARecv(session->fd, wsaBufs, bufferCount, &bytesReceived, &flags,
1161      NULL, NULL);
1162     if (r == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
1163     {
1164         LeaveCriticalSection(&session->cs);
1165         ERR("Receive error, WSAGetLastError() returns %d\n", WSAGetLastError());
1166         NetBIOSHangupSession(ncb);
1167         ret = NRC_SABORT;
1168     }
1169     else if (NCB_CANCELLED(ncb))
1170     {
1171         LeaveCriticalSection(&session->cs);
1172         ret = NRC_CMDCAN;
1173     }
1174     else
1175     {
1176         if (bufferCount == 2)
1177         {
1178             if (buffer[0] == NBSS_KEEPALIVE)
1179             {
1180                 LeaveCriticalSection(&session->cs);
1181                 FIXME("Oops, received a session keepalive and lost my place\n");
1182                 /* need to read another session header until we get a session
1183                  * message header. */
1184                 NetBIOSHangupSession(ncb);
1185                 ret = NRC_SABORT;
1186             }
1187             else if (buffer[0] != NBSS_MSG)
1188             {
1189                 LeaveCriticalSection(&session->cs);
1190                 FIXME("Received unexpected session msg type %d\n", buffer[0]);
1191                 NetBIOSHangupSession(ncb);
1192                 ret = NRC_SABORT;
1193             }
1194             else
1195             {
1196                 if (buffer[1] & NBSS_EXTENSION)
1197                 {
1198                     LeaveCriticalSection(&session->cs);
1199                     FIXME("Received a message that's too long for my taste\n");
1200                     NetBIOSHangupSession(ncb);
1201                     ret = NRC_SABORT;
1202                 }
1203                 else
1204                 {
1205                     session->bytesPending = NBSS_HDRSIZE
1206                      + NBR_GETWORD(&buffer[2]) - bytesReceived;
1207                     ncb->ncb_length = bytesReceived - NBSS_HDRSIZE;
1208                     LeaveCriticalSection(&session->cs);
1209                 }
1210             }
1211         }
1212         else
1213         {
1214             if (bytesReceived < session->bytesPending)
1215                 session->bytesPending -= bytesReceived;
1216             else
1217                 session->bytesPending = 0;
1218             LeaveCriticalSection(&session->cs);
1219             ncb->ncb_length = bytesReceived;
1220         }
1221         if (session->bytesPending > 0)
1222             ret = NRC_INCOMP;
1223         else
1224         {
1225             ret = NRC_GOODRET;
1226             adapter->recv_success++;
1227         }
1228     }
1229     TRACE("returning 0x%02x\n", ret);
1230     return ret;
1231 }
1232
1233 static UCHAR NetBTHangup(void *adapt, void *sess)
1234 {
1235     NetBTSession *session = (NetBTSession *)sess;
1236
1237     TRACE("adapt %p, session %p\n", adapt, session);
1238
1239     if (!session) return NRC_SNUMOUT;
1240
1241     /* I don't lock the session, because NetBTRecv knows not to decrement
1242      * past 0, so if a receive completes after this it should still deal.
1243      */
1244     closesocket(session->fd);
1245     session->fd = INVALID_SOCKET;
1246     session->bytesPending = 0;
1247     session->cs.DebugInfo->Spare[0] = 0;
1248     DeleteCriticalSection(&session->cs);
1249     HeapFree(GetProcessHeap(), 0, session);
1250
1251     return NRC_GOODRET;
1252 }
1253
1254 static void NetBTCleanupAdapter(void *adapt)
1255 {
1256     TRACE("adapt %p\n", adapt);
1257     if (adapt)
1258     {
1259         NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1260
1261         if (adapter->nameCache)
1262             NBNameCacheDestroy(adapter->nameCache);
1263         HeapFree(GetProcessHeap(), 0, adapt);
1264     }
1265 }
1266
1267 static void NetBTCleanup(void)
1268 {
1269     TRACE("\n");
1270     if (gNameCache)
1271     {
1272         NBNameCacheDestroy(gNameCache);
1273         gNameCache = NULL;
1274     }
1275 }
1276
1277 static UCHAR NetBTRegisterAdapter(const MIB_IPADDRROW *ipRow)
1278 {
1279     UCHAR ret;
1280     NetBTAdapter *adapter;
1281
1282     if (!ipRow) return NRC_BADDR;
1283
1284     adapter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NetBTAdapter));
1285     if (adapter)
1286     {
1287         adapter->ipr = *ipRow;
1288         if (!NetBIOSRegisterAdapter(gTransportID, ipRow->dwIndex, adapter))
1289         {
1290             NetBTCleanupAdapter(adapter);
1291             ret = NRC_SYSTEM;
1292         }
1293         else
1294             ret = NRC_GOODRET;
1295     }
1296     else
1297         ret = NRC_OSRESNOTAV;
1298     return ret;
1299 }
1300
1301 /* Callback for NetBIOS adapter enumeration.  Assumes closure is a pointer to
1302  * a MIB_IPADDRTABLE containing all the IP adapters needed to be added to the
1303  * NetBIOS adapter table.  For each callback, checks if the passed-in adapt
1304  * has an entry in the table; if so, this adapter was enumerated previously,
1305  * and it's enabled.  As a flag, the table's dwAddr entry is changed to
1306  * INADDR_LOOPBACK, since this is an invalid address for a NetBT adapter.
1307  * The NetBTEnum function will add any remaining adapters from the
1308  * MIB_IPADDRTABLE to the NetBIOS adapter table.
1309  */
1310 static BOOL NetBTEnumCallback(UCHAR totalLANAs, UCHAR lanaIndex,
1311  ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
1312 {
1313     BOOL ret;
1314     PMIB_IPADDRTABLE table = (PMIB_IPADDRTABLE)closure;
1315
1316     if (table && data)
1317     {
1318         DWORD ndx;
1319
1320         ret = FALSE;
1321         for (ndx = 0; !ret && ndx < table->dwNumEntries; ndx++)
1322         {
1323             const NetBTAdapter *adapter = (const NetBTAdapter *)data->data;
1324
1325             if (table->table[ndx].dwIndex == adapter->ipr.dwIndex)
1326             {
1327                 NetBIOSEnableAdapter(data->lana);
1328                 table->table[ndx].dwAddr = INADDR_LOOPBACK;
1329                 ret = TRUE;
1330             }
1331         }
1332     }
1333     else
1334         ret = FALSE;
1335     return ret;
1336 }
1337
1338 /* Enumerates adapters by:
1339  * - retrieving the IP address table for the local machine
1340  * - eliminating loopback addresses from the table
1341  * - eliminating redundant addresses, that is, multiple addresses on the same
1342  *   subnet
1343  * Calls NetBIOSEnumAdapters, passing the resulting table as the callback
1344  * data.  The callback reenables each adapter that's already in the NetBIOS
1345  * table.  After NetBIOSEnumAdapters returns, this function adds any remaining
1346  * adapters to the NetBIOS table.
1347  */
1348 static UCHAR NetBTEnum(void)
1349 {
1350     UCHAR ret;
1351     DWORD size = 0;
1352
1353     TRACE("\n");
1354
1355     if (GetIpAddrTable(NULL, &size, FALSE) == ERROR_INSUFFICIENT_BUFFER)
1356     {
1357         PMIB_IPADDRTABLE ipAddrs, coalesceTable = NULL;
1358         DWORD numIPAddrs = (size - sizeof(MIB_IPADDRTABLE)) /
1359          sizeof(MIB_IPADDRROW) + 1;
1360
1361         ipAddrs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1362         if (ipAddrs)
1363             coalesceTable = HeapAlloc(GetProcessHeap(),
1364              HEAP_ZERO_MEMORY, sizeof(MIB_IPADDRTABLE) +
1365              (min(numIPAddrs, MAX_LANA + 1) - 1) * sizeof(MIB_IPADDRROW));
1366         if (ipAddrs && coalesceTable)
1367         {
1368             if (GetIpAddrTable(ipAddrs, &size, FALSE) == ERROR_SUCCESS)
1369             {
1370                 DWORD ndx;
1371
1372                 for (ndx = 0; ndx < ipAddrs->dwNumEntries; ndx++)
1373                 {
1374                     if ((ipAddrs->table[ndx].dwAddr &
1375                      ipAddrs->table[ndx].dwMask) !=
1376                      htonl((INADDR_LOOPBACK & IN_CLASSA_NET)))
1377                     {
1378                         BOOL newNetwork = TRUE;
1379                         DWORD innerIndex;
1380
1381                         /* make sure we don't have more than one entry
1382                          * for a subnet */
1383                         for (innerIndex = 0; newNetwork &&
1384                          innerIndex < coalesceTable->dwNumEntries; innerIndex++)
1385                             if ((ipAddrs->table[ndx].dwAddr &
1386                              ipAddrs->table[ndx].dwMask) ==
1387                              (coalesceTable->table[innerIndex].dwAddr
1388                              & coalesceTable->table[innerIndex].dwMask))
1389                                 newNetwork = FALSE;
1390
1391                         if (newNetwork)
1392                             memcpy(&coalesceTable->table[
1393                              coalesceTable->dwNumEntries++],
1394                              &ipAddrs->table[ndx], sizeof(MIB_IPADDRROW));
1395                     }
1396                 }
1397
1398                 NetBIOSEnumAdapters(gTransportID, NetBTEnumCallback,
1399                  coalesceTable);
1400                 ret = NRC_GOODRET;
1401                 for (ndx = 0; ret == NRC_GOODRET &&
1402                  ndx < coalesceTable->dwNumEntries; ndx++)
1403                     if (coalesceTable->table[ndx].dwAddr != INADDR_LOOPBACK)
1404                         ret = NetBTRegisterAdapter(&coalesceTable->table[ndx]);
1405             }
1406             else
1407                 ret = NRC_SYSTEM;
1408             HeapFree(GetProcessHeap(), 0, ipAddrs);
1409             HeapFree(GetProcessHeap(), 0, coalesceTable);
1410         }
1411         else
1412             ret = NRC_OSRESNOTAV;
1413     }
1414     else
1415         ret = NRC_SYSTEM;
1416     TRACE("returning 0x%02x\n", ret);
1417     return ret;
1418 }
1419
1420 static const WCHAR VxD_MSTCPW[] = { 'S','Y','S','T','E','M','\\','C','u','r',
1421  'r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','S','e','r','v',
1422  'i','c','e','s','\\','V','x','D','\\','M','S','T','C','P','\0' };
1423 static const WCHAR NetBT_ParametersW[] = { 'S','Y','S','T','E','M','\\','C','u',
1424  'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','S','e','r',
1425  'v','i','c','e','s','\\','N','e','t','B','T','\\','P','a','r','a','m','e','t',
1426  'e','r','s','\0' };
1427 static const WCHAR EnableDNSW[] = { 'E','n','a','b','l','e','D','N','S','\0' };
1428 static const WCHAR BcastNameQueryCountW[] = { 'B','c','a','s','t','N','a','m',
1429  'e','Q','u','e','r','y','C','o','u','n','t','\0' };
1430 static const WCHAR BcastNameQueryTimeoutW[] = { 'B','c','a','s','t','N','a','m',
1431  'e','Q','u','e','r','y','T','i','m','e','o','u','t','\0' };
1432 static const WCHAR NameSrvQueryCountW[] = { 'N','a','m','e','S','r','v',
1433  'Q','u','e','r','y','C','o','u','n','t','\0' };
1434 static const WCHAR NameSrvQueryTimeoutW[] = { 'N','a','m','e','S','r','v',
1435  'Q','u','e','r','y','T','i','m','e','o','u','t','\0' };
1436 static const WCHAR ScopeIDW[] = { 'S','c','o','p','e','I','D','\0' };
1437 static const WCHAR CacheTimeoutW[] = { 'C','a','c','h','e','T','i','m','e','o',
1438  'u','t','\0' };
1439 static const WCHAR Config_NetworkW[] = { 'S','o','f','t','w','a','r','e','\\',
1440                                          'W','i','n','e','\\','N','e','t','w','o','r','k','\0' };
1441
1442 /* Initializes global variables and registers the NetBT transport */
1443 void NetBTInit(void)
1444 {
1445     HKEY hKey;
1446     NetBIOSTransport transport;
1447     LONG ret;
1448
1449     TRACE("\n");
1450
1451     gEnableDNS = TRUE;
1452     gBCastQueries = BCAST_QUERIES;
1453     gBCastQueryTimeout = BCAST_QUERY_TIMEOUT;
1454     gWINSQueries = WINS_QUERIES;
1455     gWINSQueryTimeout = WINS_QUERY_TIMEOUT;
1456     gNumWINSServers = 0;
1457     memset(gWINSServers, 0, sizeof(gWINSServers));
1458     gScopeID[0] = '\0';
1459     gCacheTimeout = CACHE_TIMEOUT;
1460
1461     /* Try to open the Win9x NetBT configuration key */
1462     ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, VxD_MSTCPW, 0, KEY_READ, &hKey);
1463     /* If that fails, try the WinNT NetBT configuration key */
1464     if (ret != ERROR_SUCCESS)
1465         ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, NetBT_ParametersW, 0, KEY_READ,
1466          &hKey);
1467     if (ret == ERROR_SUCCESS)
1468     {
1469         DWORD dword, size;
1470
1471         size = sizeof(dword);
1472         if (RegQueryValueExW(hKey, EnableDNSW, NULL, NULL,
1473          (LPBYTE)&dword, &size) == ERROR_SUCCESS)
1474             gEnableDNS = dword;
1475         size = sizeof(dword);
1476         if (RegQueryValueExW(hKey, BcastNameQueryCountW, NULL, NULL,
1477          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERIES
1478          && dword <= MAX_QUERIES)
1479             gBCastQueries = dword;
1480         size = sizeof(dword);
1481         if (RegQueryValueExW(hKey, BcastNameQueryTimeoutW, NULL, NULL,
1482          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERY_TIMEOUT
1483          && dword <= MAX_QUERY_TIMEOUT)
1484             gBCastQueryTimeout = dword;
1485         size = sizeof(dword);
1486         if (RegQueryValueExW(hKey, NameSrvQueryCountW, NULL, NULL,
1487          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERIES
1488          && dword <= MAX_QUERIES)
1489             gWINSQueries = dword;
1490         size = sizeof(dword);
1491         if (RegQueryValueExW(hKey, NameSrvQueryTimeoutW, NULL, NULL,
1492          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERY_TIMEOUT
1493          && dword <= MAX_QUERY_TIMEOUT)
1494             gWINSQueryTimeout = dword;
1495         size = MAX_DOMAIN_NAME_LEN - 1;
1496         if (RegQueryValueExW(hKey, ScopeIDW, NULL, NULL, (LPBYTE)gScopeID + 1, &size)
1497          == ERROR_SUCCESS)
1498         {
1499             /* convert into L2-encoded version, suitable for use by
1500                NetBTNameEncode */
1501             char *ptr, *lenPtr;
1502
1503             for (ptr = gScopeID + 1; *ptr &&
1504              ptr - gScopeID < MAX_DOMAIN_NAME_LEN; )
1505             {
1506                 for (lenPtr = ptr - 1, *lenPtr = 0; *ptr && *ptr != '.' &&
1507                  ptr - gScopeID < MAX_DOMAIN_NAME_LEN; ptr++)
1508                     *lenPtr += 1;
1509                 ptr++;
1510             }
1511         }
1512         if (RegQueryValueExW(hKey, CacheTimeoutW, NULL, NULL,
1513          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_CACHE_TIMEOUT)
1514             gCacheTimeout = dword;
1515         RegCloseKey(hKey);
1516     }
1517     /* WINE-specific NetBT registry settings.  Because our adapter naming is
1518      * different than MS', we can't do per-adapter WINS configuration in the
1519      * same place.  Just do a global WINS configuration instead.
1520      */
1521     /* @@ Wine registry key: HKCU\Software\Wine\Network */
1522     if (RegOpenKeyW(HKEY_CURRENT_USER, Config_NetworkW, &hKey) == ERROR_SUCCESS)
1523     {
1524         static const char *nsValueNames[] = { "WinsServer", "BackupWinsServer" };
1525         char nsString[16];
1526         DWORD size, ndx;
1527
1528         for (ndx = 0; ndx < sizeof(nsValueNames) / sizeof(nsValueNames[0]);
1529          ndx++)
1530         {
1531             size = sizeof(nsString) / sizeof(char);
1532             if (RegQueryValueExA(hKey, nsValueNames[ndx], NULL, NULL,
1533              (LPBYTE)nsString, &size) == ERROR_SUCCESS)
1534             {
1535                 unsigned long addr = inet_addr(nsString);
1536
1537                 if (addr != INADDR_NONE && gNumWINSServers < MAX_WINS_SERVERS)
1538                     gWINSServers[gNumWINSServers++] = addr;
1539             }
1540         }
1541         RegCloseKey(hKey);
1542     }
1543
1544     transport.enumerate      = NetBTEnum;
1545     transport.astat          = NetBTAstat;
1546     transport.findName       = NetBTFindName;
1547     transport.call           = NetBTCall;
1548     transport.send           = NetBTSend;
1549     transport.recv           = NetBTRecv;
1550     transport.hangup         = NetBTHangup;
1551     transport.cleanupAdapter = NetBTCleanupAdapter;
1552     transport.cleanup        = NetBTCleanup;
1553     memcpy(&gTransportID, TRANSPORT_NBT, sizeof(ULONG));
1554     NetBIOSRegisterTransport(gTransportID, &transport);
1555 }