- call CertFreeCertificateContext from CertDeleteCertificateFromStore
[wine/multimedia.git] / dlls / netapi32 / nbt.c
blob3125df0c59250e548d9b60f2f813cf138cc79cc3
1 /* Copyright (c) 2003 Juan Lang
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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.
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.
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).
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.
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.)
65 * See also other FIXMEs in the code.
68 #include "config.h"
69 #include <stdarg.h>
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"
78 #include "netbios.h"
79 #include "nbnamecache.h"
81 WINE_DEFAULT_DEBUG_CHANNEL(netbios);
83 #define PORT_NBNS 137
84 #define PORT_NBDG 138
85 #define PORT_NBSS 139
87 #ifndef INADDR_NONE
88 #define INADDR_NONE ~0UL
89 #endif
91 #define NBR_ADDWORD(p,word) (*(WORD *)(p)) = htons(word)
92 #define NBR_GETWORD(p) ntohs(*(WORD *)(p))
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
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
109 #define DEFAULT_NBT_SESSIONS 16
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
119 #define NBSS_HDRSIZE 4
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
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
133 #define NBSS_EXTENSION 0x01
135 typedef struct _NetBTSession
137 CRITICAL_SECTION cs;
138 SOCKET fd;
139 DWORD bytesPending;
140 } NetBTSession;
142 typedef struct _NetBTAdapter
144 MIB_IPADDRROW ipr;
145 WORD nameQueryXID;
146 struct NBNameCache *nameCache;
147 DWORD xmit_success;
148 DWORD recv_success;
149 } NetBTAdapter;
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;
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.
168 static int NetBTNameEncode(const UCHAR *p, UCHAR *buffer)
170 int i,len=0;
172 if (!p) return 0;
173 if (!buffer) return 0;
175 buffer[len++] = NCBNAMSZ * 2;
176 for (i = 0; p[i] && i < NCBNAMSZ; i++)
178 buffer[len++] = ((p[i] & 0xf0) >> 4) + 'A';
179 buffer[len++] = (p[i] & 0x0f) + 'A';
181 while (len < NCBNAMSZ * 2)
183 buffer[len++] = 'C';
184 buffer[len++] = 'A';
186 if (*gScopeID)
188 int scopeIDLen = strlen(gScopeID);
190 memcpy(buffer + len, gScopeID, scopeIDLen);
191 len += scopeIDLen;
193 buffer[len++] = 0; /* add second terminator */
194 return len;
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.
201 static DWORD NetBTNameReq(const UCHAR name[NCBNAMSZ], WORD xid, WORD qtype,
202 BOOL broadcast, UCHAR *buffer, int len)
204 int i = 0;
206 if (len < SIMPLE_NAME_QUERY_PKT_SIZE) return 0;
208 NBR_ADDWORD(&buffer[i],xid); i+=2; /* transaction */
209 if (broadcast)
211 NBR_ADDWORD(&buffer[i],0x0110); /* flags: r=req,op=query,rd=1,b=1 */
212 i+=2;
214 else
216 NBR_ADDWORD(&buffer[i],0x0100); /* flags: r=req,op=query,rd=1,b=0 */
217 i+=2;
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 */
224 i += NetBTNameEncode(name, &buffer[i]);
226 NBR_ADDWORD(&buffer[i],qtype); i+=2;
227 NBR_ADDWORD(&buffer[i],NBNS_CLASS_INTERNET); i+=2;
229 return i;
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.
237 static int NetBTSendNameQuery(SOCKET fd, const UCHAR name[NCBNAMSZ], WORD xid,
238 WORD qtype, DWORD destAddr, BOOL broadcast)
240 int ret = 0, on = 1;
241 struct in_addr addr;
243 addr.s_addr = destAddr;
244 TRACE("name %s, dest addr %s\n", name, inet_ntoa(addr));
246 if (broadcast)
247 ret = setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (const char*)&on, sizeof(on));
248 if(ret == 0)
250 WSABUF wsaBuf;
251 UCHAR buf[SIMPLE_NAME_QUERY_PKT_SIZE];
252 struct sockaddr_in sin;
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);
259 wsaBuf.buf = (CHAR*)buf;
260 wsaBuf.len = NetBTNameReq(name, xid, qtype, broadcast, buf,
261 sizeof(buf));
262 if (wsaBuf.len > 0)
264 DWORD bytesSent;
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;
273 else
274 ret = -1;
276 return ret;
279 typedef BOOL (*NetBTAnswerCallback)(void *data, WORD answerCount,
280 WORD answerIndex, PUCHAR rData, WORD rdLength);
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.
291 static UCHAR NetBTWaitForNameResponse(NetBTAdapter *adapter, SOCKET fd,
292 DWORD waitUntil, NetBTAnswerCallback answerCallback, void *data)
294 BOOL found = FALSE;
295 DWORD now;
296 UCHAR ret = NRC_GOODRET;
298 if (!adapter) return NRC_BADDR;
299 if (fd == INVALID_SOCKET) return NRC_BADDR;
300 if (!answerCallback) return NRC_BADDR;
302 while (!found && ret == NRC_GOODRET && (now = GetTickCount()) < waitUntil)
304 DWORD msToWait = waitUntil - now;
305 struct fd_set fds;
306 struct timeval timeout = { msToWait / 1000, msToWait % 1000 };
307 int r;
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)
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;
324 fromsize = sizeof(fromaddr);
325 r = WSARecvFrom(fd, &wsaBuf, 1, &bytesReceived, &recvFlags,
326 (struct sockaddr*)&fromaddr, &fromsize, NULL, NULL);
327 if(r < 0)
329 ret = NRC_SYSTEM;
330 break;
333 if (bytesReceived < NBNS_HEADER_SIZE)
334 continue;
336 respXID = NBR_GETWORD(buffer);
337 if (adapter->nameQueryXID != respXID)
338 continue;
340 flags = NBR_GETWORD(buffer + 2);
341 queryCount = NBR_GETWORD(buffer + 4);
342 answerCount = NBR_GETWORD(buffer + 6);
344 /* a reply shouldn't contain a query, ignore bad packet */
345 if (queryCount > 0)
346 continue;
348 if ((flags & NBNS_RESPONSE_AND_OPCODE) == NBNS_RESPONSE_AND_QUERY)
350 if ((flags & NBNS_REPLYCODE) != 0)
351 ret = NRC_NAMERR;
352 else if ((flags & NBNS_REPLYCODE) == 0 && answerCount > 0)
354 PUCHAR ptr = buffer + NBNS_HEADER_SIZE;
355 BOOL shouldContinue = TRUE;
356 WORD answerIndex = 0;
358 found = TRUE;
359 /* decode one answer at a time */
360 while (ret == NRC_GOODRET && answerIndex < answerCount &&
361 ptr - buffer < bytesReceived && shouldContinue)
363 WORD rLen;
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++;
388 TRACE("returning 0x%02x\n", ret);
389 return ret;
392 typedef struct _NetBTNameQueryData {
393 NBNameCacheEntry *cacheEntry;
394 UCHAR ret;
395 } NetBTNameQueryData;
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.
402 static BOOL NetBTFindNameAnswerCallback(void *pVoid, WORD answerCount,
403 WORD answerIndex, PUCHAR rData, WORD rLen)
405 NetBTNameQueryData *queryData = (NetBTNameQueryData *)pVoid;
406 BOOL ret;
408 if (queryData)
410 if (queryData->cacheEntry == NULL)
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
419 ret = FALSE;
420 queryData->ret = NRC_OSRESNOTAV;
423 if (rLen == 6 && queryData->cacheEntry &&
424 queryData->cacheEntry->numAddresses < answerCount)
426 queryData->cacheEntry->addresses[queryData->cacheEntry->
427 numAddresses++] = *(PDWORD)(rData + 2);
428 ret = queryData->cacheEntry->numAddresses < answerCount;
430 else
431 ret = FALSE;
433 else
434 ret = FALSE;
435 return ret;
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.
447 static UCHAR NetBTNameWaitLoop(NetBTAdapter *adapter, SOCKET fd, PNCB ncb,
448 DWORD sendTo, BOOL broadcast, DWORD timeout, DWORD maxQueries,
449 NBNameCacheEntry **cacheEntry)
451 unsigned int queries;
452 NetBTNameQueryData queryData;
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;
459 queryData.cacheEntry = NULL;
460 queryData.ret = NRC_GOODRET;
461 for (queries = 0; queryData.cacheEntry == NULL && queries < maxQueries;
462 queries++)
464 if (!NCB_CANCELLED(ncb))
466 int r = NetBTSendNameQuery(fd, ncb->ncb_callname,
467 adapter->nameQueryXID, NBNS_TYPE_NB, sendTo, broadcast);
469 if (r == 0)
470 queryData.ret = NetBTWaitForNameResponse(adapter, fd,
471 GetTickCount() + timeout, NetBTFindNameAnswerCallback,
472 &queryData);
473 else
474 queryData.ret = NRC_SYSTEM;
476 else
477 queryData.ret = NRC_CMDCAN;
479 if (queryData.cacheEntry)
481 memcpy(queryData.cacheEntry->name, ncb->ncb_callname, NCBNAMSZ);
482 memcpy(queryData.cacheEntry->nbname, ncb->ncb_callname, NCBNAMSZ);
484 *cacheEntry = queryData.cacheEntry;
485 return queryData.ret;
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.
494 static UCHAR NetBTStoreCacheEntry(struct NBNameCache **nameCache,
495 NBNameCacheEntry *cacheEntry)
497 UCHAR ret;
499 if (!nameCache) return NRC_BADDR;
500 if (!cacheEntry) return NRC_BADDR;
502 if (!*nameCache)
503 *nameCache = NBNameCacheCreate(GetProcessHeap(), gCacheTimeout);
504 if (*nameCache)
505 ret = NBNameCacheAddEntry(*nameCache, cacheEntry)
506 ? NRC_GOODRET : NRC_OSRESNOTAV;
507 else
509 HeapFree(GetProcessHeap(), 0, cacheEntry);
510 ret = NRC_OSRESNOTAV;
512 return ret;
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.
523 static UCHAR NetBTinetResolve(const UCHAR name[NCBNAMSZ],
524 NBNameCacheEntry **cacheEntry)
526 UCHAR ret = NRC_GOODRET;
528 TRACE("name %s, cacheEntry %p\n", name, cacheEntry);
530 if (!name) return NRC_BADDR;
531 if (!cacheEntry) return NRC_BADDR;
533 if (isalnum(name[0]) && (name[NCBNAMSZ - 1] == 0 ||
534 name[NCBNAMSZ - 1] == 0x20))
536 CHAR toLookup[NCBNAMSZ];
537 unsigned int i;
539 for (i = 0; i < NCBNAMSZ - 1 && name[i] && name[i] != ' '; i++)
540 toLookup[i] = name[i];
541 toLookup[i] = '\0';
543 if (isdigit(toLookup[0]))
545 unsigned long addr = inet_addr(toLookup);
547 if (addr != INADDR_NONE)
549 *cacheEntry = HeapAlloc(GetProcessHeap(),
550 0, sizeof(NBNameCacheEntry));
551 if (*cacheEntry)
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;
559 else
560 ret = NRC_OSRESNOTAV;
563 if (gEnableDNS && ret == NRC_GOODRET && !*cacheEntry)
565 struct hostent *host;
567 if ((host = gethostbyname(toLookup)) != NULL)
569 for (i = 0; ret == NRC_GOODRET && host->h_addr_list &&
570 host->h_addr_list[i]; i++)
572 if (host->h_addr_list && host->h_addr_list[0])
574 *cacheEntry = HeapAlloc(
575 GetProcessHeap(), 0, sizeof(NBNameCacheEntry) +
576 (i - 1) * sizeof(DWORD));
577 if (*cacheEntry)
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];
587 else
588 ret = NRC_OSRESNOTAV;
594 TRACE("returning 0x%02x\n", ret);
595 return ret;
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.
608 static UCHAR NetBTInternalFindName(NetBTAdapter *adapter, PNCB ncb,
609 const NBNameCacheEntry **cacheEntry)
611 UCHAR ret = NRC_GOODRET;
613 TRACE("adapter %p, ncb %p, cacheEntry %p\n", adapter, ncb, cacheEntry);
615 if (!cacheEntry) return NRC_BADDR;
616 *cacheEntry = NULL;
618 if (!adapter) return NRC_BADDR;
619 if (!ncb) return NRC_BADDR;
621 if (ncb->ncb_callname[0] == '*')
622 ret = NRC_NOWILD;
623 else
625 *cacheEntry = NBNameCacheFindEntry(gNameCache, ncb->ncb_callname);
626 if (!*cacheEntry)
627 *cacheEntry = NBNameCacheFindEntry(adapter->nameCache,
628 ncb->ncb_callname);
629 if (!*cacheEntry)
631 NBNameCacheEntry *newEntry = NULL;
633 ret = NetBTinetResolve(ncb->ncb_callname, &newEntry);
634 if (ret == NRC_GOODRET && newEntry)
636 ret = NetBTStoreCacheEntry(&gNameCache, newEntry);
637 if (ret != NRC_GOODRET)
638 newEntry = NULL;
640 else
642 SOCKET fd = WSASocketA(PF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL,
643 0, WSA_FLAG_OVERLAPPED);
645 if(fd == INVALID_SOCKET)
646 ret = NRC_OSRESNOTAV;
647 else
649 int winsNdx;
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)
659 ret = NetBTStoreCacheEntry(&gNameCache, newEntry);
660 if (ret != NRC_GOODRET)
661 newEntry = NULL;
663 if (ret == NRC_GOODRET && *cacheEntry == NULL)
665 DWORD bcastAddr =
666 adapter->ipr.dwAddr & adapter->ipr.dwMask;
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)
674 ret = NetBTStoreCacheEntry(&adapter->nameCache,
675 newEntry);
676 if (ret != NRC_GOODRET)
677 newEntry = NULL;
680 closesocket(fd);
683 *cacheEntry = newEntry;
686 TRACE("returning 0x%02x\n", ret);
687 return ret;
690 typedef struct _NetBTNodeQueryData
692 BOOL gotResponse;
693 PADAPTER_STATUS astat;
694 WORD astatLen;
695 } NetBTNodeQueryData;
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.
701 static BOOL NetBTNodeStatusAnswerCallback(void *pVoid, WORD answerCount,
702 WORD answerIndex, PUCHAR rData, WORD rLen)
704 NetBTNodeQueryData *data = (NetBTNodeQueryData *)pVoid;
706 if (data && !data->gotResponse && rData && rLen >= 1)
708 /* num names is first byte; each name is NCBNAMSZ + 2 bytes */
709 if (rLen >= rData[0] * (NCBNAMSZ + 2))
711 WORD i;
712 PUCHAR src;
713 PNAME_BUFFER dst;
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)
724 UCHAR flags = *(src + NCBNAMSZ);
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;
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));
747 return FALSE;
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.
753 static UCHAR NetBTAstatRemote(NetBTAdapter *adapter, PNCB ncb)
755 UCHAR ret = NRC_GOODRET;
756 const NBNameCacheEntry *cacheEntry = NULL;
758 TRACE("adapter %p, NCB %p\n", adapter, ncb);
760 if (!adapter) return NRC_BADDR;
761 if (!ncb) return NRC_INVADDRESS;
763 ret = NetBTInternalFindName(adapter, ncb, &cacheEntry);
764 if (ret == NRC_GOODRET && cacheEntry)
766 if (cacheEntry->numAddresses > 0)
768 SOCKET fd = WSASocketA(PF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0,
769 WSA_FLAG_OVERLAPPED);
771 if(fd == INVALID_SOCKET)
772 ret = NRC_OSRESNOTAV;
773 else
775 NetBTNodeQueryData queryData;
776 DWORD queries;
777 PADAPTER_STATUS astat = (PADAPTER_STATUS)ncb->ncb_buffer;
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++)
787 if (!NCB_CANCELLED(ncb))
789 int r = NetBTSendNameQuery(fd, ncb->ncb_callname,
790 adapter->nameQueryXID, NBNS_TYPE_NBSTAT,
791 cacheEntry->addresses[0], FALSE);
793 if (r == 0)
794 ret = NetBTWaitForNameResponse(adapter, fd,
795 GetTickCount() + gWINSQueryTimeout,
796 NetBTNodeStatusAnswerCallback, &queryData);
797 else
798 ret = NRC_SYSTEM;
800 else
801 ret = NRC_CMDCAN;
803 closesocket(fd);
806 else
807 ret = NRC_CMDTMO;
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;
817 static UCHAR NetBTAstat(void *adapt, PNCB ncb)
819 NetBTAdapter *adapter = (NetBTAdapter *)adapt;
820 UCHAR ret;
822 TRACE("adapt %p, NCB %p\n", adapt, ncb);
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;
829 if (ncb->ncb_callname[0] == '*')
831 DWORD physAddrLen;
832 MIB_IFROW ifRow;
833 PADAPTER_STATUS astat = (PADAPTER_STATUS)ncb->ncb_buffer;
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
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;
854 ret = NRC_GOODRET;
856 else
857 ret = NetBTAstatRemote(adapter, ncb);
858 TRACE("returning 0x%02x\n", ret);
859 return ret;
862 static UCHAR NetBTFindName(void *adapt, PNCB ncb)
864 NetBTAdapter *adapter = (NetBTAdapter *)adapt;
865 UCHAR ret;
866 const NBNameCacheEntry *cacheEntry = NULL;
867 PFIND_NAME_HEADER foundName;
869 TRACE("adapt %p, NCB %p\n", adapt, ncb);
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;
876 foundName = (PFIND_NAME_HEADER)ncb->ncb_buffer;
877 memset(foundName, 0, sizeof(FIND_NAME_HEADER));
879 ret = NetBTInternalFindName(adapter, ncb, &cacheEntry);
880 if (ret == NRC_GOODRET)
882 if (cacheEntry)
884 DWORD spaceFor = min((ncb->ncb_length - sizeof(FIND_NAME_HEADER)) /
885 sizeof(FIND_NAME_BUFFER), cacheEntry->numAddresses);
886 DWORD ndx;
888 for (ndx = 0; ndx < spaceFor; ndx++)
890 PFIND_NAME_BUFFER findNameBuffer;
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++;
904 if (spaceFor < cacheEntry->numAddresses)
905 ret = NRC_BUFLEN;
907 else
908 ret = NRC_CMDTMO;
910 TRACE("returning 0x%02x\n", ret);
911 return ret;
914 static UCHAR NetBTSessionReq(SOCKET fd, const UCHAR *calledName,
915 const UCHAR *callingName)
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;
923 buffer[0] = NBSS_REQ;
924 buffer[1] = 0;
926 len += NetBTNameEncode(calledName, &buffer[NBSS_HDRSIZE]);
927 len += NetBTNameEncode(callingName, &buffer[NBSS_HDRSIZE + len]);
929 NBR_ADDWORD(&buffer[2], len);
931 wsaBuf.len = len + NBSS_HDRSIZE;
932 wsaBuf.buf = (char*)buffer;
934 r = WSASend(fd, &wsaBuf, 1, &bytesSent, 0, NULL, NULL);
935 if(r < 0 || bytesSent < len + NBSS_HDRSIZE)
937 ERR("send failed\n");
938 return NRC_SABORT;
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.
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)
951 if (r == NBSS_HDRSIZE + 1)
953 switch (buffer[NBSS_HDRSIZE])
955 case NBSS_ERR_INSUFFICIENT_RESOURCES:
956 ret = NRC_REMTFUL;
957 break;
958 default:
959 ret = NRC_NOCALL;
962 else
963 ret = NRC_NOCALL;
965 else if (buffer[0] == NBSS_RETARGET)
967 FIXME("Got a session retarget, can't deal\n");
968 ret = NRC_NOCALL;
970 else if (buffer[0] == NBSS_ACK)
971 ret = NRC_GOODRET;
972 else
973 ret = NRC_SYSTEM;
975 TRACE("returning 0x%02x\n", ret);
976 return ret;
979 static UCHAR NetBTCall(void *adapt, PNCB ncb, void **sess)
981 NetBTAdapter *adapter = (NetBTAdapter *)adapt;
982 UCHAR ret;
983 const NBNameCacheEntry *cacheEntry = NULL;
985 TRACE("adapt %p, ncb %p\n", adapt, ncb);
987 if (!adapter) return NRC_ENVNOTDEF;
988 if (!ncb) return NRC_INVADDRESS;
989 if (!sess) return NRC_BADDR;
991 ret = NetBTInternalFindName(adapter, ncb, &cacheEntry);
992 if (ret == NRC_GOODRET)
994 if (cacheEntry && cacheEntry->numAddresses > 0)
996 SOCKET fd;
998 fd = WSASocketA(PF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
999 WSA_FLAG_OVERLAPPED);
1000 if (fd != INVALID_SOCKET)
1002 DWORD timeout;
1003 struct sockaddr_in sin;
1005 if (ncb->ncb_rto > 0)
1007 timeout = ncb->ncb_rto * 500;
1008 setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout,
1009 sizeof(timeout));
1011 if (ncb->ncb_rto > 0)
1013 timeout = ncb->ncb_sto * 500;
1014 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout,
1015 sizeof(timeout));
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
1026 if (connect(fd, (struct sockaddr *)&sin, sizeof(sin))
1027 == SOCKET_ERROR)
1028 ret = NRC_CMDTMO;
1029 else
1031 static UCHAR fakedCalledName[] = "*SMBSERVER";
1032 const UCHAR *calledParty = cacheEntry->nbname[0] == '*'
1033 ? fakedCalledName : cacheEntry->nbname;
1035 ret = NetBTSessionReq(fd, calledParty, ncb->ncb_name);
1036 if (ret != NRC_GOODRET && calledParty[0] == '*')
1038 FIXME("NBT session to \"*SMBSERVER\" refused,\n");
1039 FIXME("should try finding name using ASTAT\n");
1042 if (ret != NRC_GOODRET)
1043 closesocket(fd);
1044 else
1046 NetBTSession *session = HeapAlloc(
1047 GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NetBTSession));
1049 if (session)
1051 session->fd = fd;
1052 InitializeCriticalSection(&session->cs);
1053 *sess = session;
1055 else
1057 ret = NRC_OSRESNOTAV;
1058 closesocket(fd);
1062 else
1063 ret = NRC_OSRESNOTAV;
1065 else
1066 ret = NRC_NAMERR;
1068 TRACE("returning 0x%02x\n", ret);
1069 return ret;
1072 /* Notice that I don't protect against multiple thread access to NetBTSend.
1073 * This is because I don't update any data in the adapter, and I only make a
1074 * single call to WSASend, which I assume to act atomically (not interleaving
1075 * data from other threads).
1076 * I don't lock, because I only depend on the fd being valid, and this won't be
1077 * true until a session setup is completed.
1079 static UCHAR NetBTSend(void *adapt, void *sess, PNCB ncb)
1081 NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1082 NetBTSession *session = (NetBTSession *)sess;
1083 UCHAR buffer[NBSS_HDRSIZE], ret;
1084 int r;
1085 WSABUF wsaBufs[2];
1086 DWORD bytesSent;
1088 TRACE("adapt %p, session %p, NCB %p\n", adapt, session, ncb);
1090 if (!adapter) return NRC_ENVNOTDEF;
1091 if (!ncb) return NRC_INVADDRESS;
1092 if (!ncb->ncb_buffer) return NRC_BADDR;
1093 if (!session) return NRC_SNUMOUT;
1094 if (session->fd == INVALID_SOCKET) return NRC_SNUMOUT;
1096 buffer[0] = NBSS_MSG;
1097 buffer[1] = 0;
1098 NBR_ADDWORD(&buffer[2], ncb->ncb_length);
1100 wsaBufs[0].len = NBSS_HDRSIZE;
1101 wsaBufs[0].buf = (char*)buffer;
1102 wsaBufs[1].len = ncb->ncb_length;
1103 wsaBufs[1].buf = (char*)ncb->ncb_buffer;
1105 r = WSASend(session->fd, wsaBufs, sizeof(wsaBufs) / sizeof(wsaBufs[0]),
1106 &bytesSent, 0, NULL, NULL);
1107 if (r == SOCKET_ERROR)
1109 NetBIOSHangupSession(ncb);
1110 ret = NRC_SABORT;
1112 else if (bytesSent < NBSS_HDRSIZE + ncb->ncb_length)
1114 FIXME("Only sent %ld bytes (of %d), hanging up session\n", bytesSent,
1115 NBSS_HDRSIZE + ncb->ncb_length);
1116 NetBIOSHangupSession(ncb);
1117 ret = NRC_SABORT;
1119 else
1121 ret = NRC_GOODRET;
1122 adapter->xmit_success++;
1124 TRACE("returning 0x%02x\n", ret);
1125 return ret;
1128 static UCHAR NetBTRecv(void *adapt, void *sess, PNCB ncb)
1130 NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1131 NetBTSession *session = (NetBTSession *)sess;
1132 UCHAR buffer[NBSS_HDRSIZE], ret;
1133 int r;
1134 WSABUF wsaBufs[2];
1135 DWORD bufferCount, bytesReceived, flags;
1137 TRACE("adapt %p, session %p, NCB %p\n", adapt, session, ncb);
1139 if (!adapter) return NRC_ENVNOTDEF;
1140 if (!ncb) return NRC_BADDR;
1141 if (!ncb->ncb_buffer) return NRC_BADDR;
1142 if (!session) return NRC_SNUMOUT;
1143 if (session->fd == INVALID_SOCKET) return NRC_SNUMOUT;
1145 EnterCriticalSection(&session->cs);
1146 bufferCount = 0;
1147 if (session->bytesPending == 0)
1149 bufferCount++;
1150 wsaBufs[0].len = NBSS_HDRSIZE;
1151 wsaBufs[0].buf = (char*)buffer;
1153 wsaBufs[bufferCount].len = ncb->ncb_length;
1154 wsaBufs[bufferCount].buf = (char*)ncb->ncb_buffer;
1155 bufferCount++;
1157 flags = 0;
1158 /* FIXME: should poll a bit so I can check the cancel flag */
1159 r = WSARecv(session->fd, wsaBufs, bufferCount, &bytesReceived, &flags,
1160 NULL, NULL);
1161 if (r == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
1163 LeaveCriticalSection(&session->cs);
1164 ERR("Receive error, WSAGetLastError() returns %d\n", WSAGetLastError());
1165 NetBIOSHangupSession(ncb);
1166 ret = NRC_SABORT;
1168 else if (NCB_CANCELLED(ncb))
1170 LeaveCriticalSection(&session->cs);
1171 ret = NRC_CMDCAN;
1173 else
1175 if (bufferCount == 2)
1177 if (buffer[0] == NBSS_KEEPALIVE)
1179 LeaveCriticalSection(&session->cs);
1180 FIXME("Oops, received a session keepalive and lost my place\n");
1181 /* need to read another session header until we get a session
1182 * message header. */
1183 NetBIOSHangupSession(ncb);
1184 ret = NRC_SABORT;
1186 else if (buffer[0] != NBSS_MSG)
1188 LeaveCriticalSection(&session->cs);
1189 FIXME("Received unexpected session msg type %d\n", buffer[0]);
1190 NetBIOSHangupSession(ncb);
1191 ret = NRC_SABORT;
1193 else
1195 if (buffer[1] & NBSS_EXTENSION)
1197 LeaveCriticalSection(&session->cs);
1198 FIXME("Received a message that's too long for my taste\n");
1199 NetBIOSHangupSession(ncb);
1200 ret = NRC_SABORT;
1202 else
1204 session->bytesPending = NBSS_HDRSIZE
1205 + NBR_GETWORD(&buffer[2]) - bytesReceived;
1206 ncb->ncb_length = bytesReceived - NBSS_HDRSIZE;
1207 LeaveCriticalSection(&session->cs);
1211 else
1213 if (bytesReceived < session->bytesPending)
1214 session->bytesPending -= bytesReceived;
1215 else
1216 session->bytesPending = 0;
1217 LeaveCriticalSection(&session->cs);
1218 ncb->ncb_length = bytesReceived;
1220 if (session->bytesPending > 0)
1221 ret = NRC_INCOMP;
1222 else
1224 ret = NRC_GOODRET;
1225 adapter->recv_success++;
1228 TRACE("returning 0x%02x\n", ret);
1229 return ret;
1232 static UCHAR NetBTHangup(void *adapt, void *sess)
1234 NetBTSession *session = (NetBTSession *)sess;
1236 TRACE("adapt %p, session %p\n", adapt, session);
1238 if (!session) return NRC_SNUMOUT;
1240 /* I don't lock the session, because NetBTRecv knows not to decrement
1241 * past 0, so if a receive completes after this it should still deal.
1243 closesocket(session->fd);
1244 session->fd = INVALID_SOCKET;
1245 session->bytesPending = 0;
1246 DeleteCriticalSection(&session->cs);
1247 HeapFree(GetProcessHeap(), 0, session);
1249 return NRC_GOODRET;
1252 static void NetBTCleanupAdapter(void *adapt)
1254 TRACE("adapt %p\n", adapt);
1255 if (adapt)
1257 NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1259 if (adapter->nameCache)
1260 NBNameCacheDestroy(adapter->nameCache);
1261 HeapFree(GetProcessHeap(), 0, adapt);
1265 static void NetBTCleanup(void)
1267 TRACE("\n");
1268 if (gNameCache)
1270 NBNameCacheDestroy(gNameCache);
1271 gNameCache = NULL;
1275 static UCHAR NetBTRegisterAdapter(PMIB_IPADDRROW ipRow)
1277 UCHAR ret;
1278 NetBTAdapter *adapter;
1280 if (!ipRow) return NRC_BADDR;
1282 adapter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NetBTAdapter));
1283 if (adapter)
1285 memcpy(&adapter->ipr, ipRow, sizeof(MIB_IPADDRROW));
1286 if (!NetBIOSRegisterAdapter(gTransportID, ipRow->dwIndex, adapter))
1288 NetBTCleanupAdapter(adapter);
1289 ret = NRC_SYSTEM;
1291 else
1292 ret = NRC_GOODRET;
1294 else
1295 ret = NRC_OSRESNOTAV;
1296 return ret;
1299 /* Callback for NetBIOS adapter enumeration. Assumes closure is a pointer to
1300 * a MIB_IPADDRTABLE containing all the IP adapters needed to be added to the
1301 * NetBIOS adapter table. For each callback, checks if the passed-in adapt
1302 * has an entry in the table; if so, this adapter was enumerated previously,
1303 * and it's enabled. As a flag, the table's dwAddr entry is changed to
1304 * INADDR_LOOPBACK, since this is an invalid address for a NetBT adapter.
1305 * The NetBTEnum function will add any remaining adapters from the
1306 * MIB_IPADDRTABLE to the NetBIOS adapter table.
1308 static BOOL NetBTEnumCallback(UCHAR totalLANAs, UCHAR lanaIndex,
1309 ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
1311 BOOL ret;
1312 PMIB_IPADDRTABLE table = (PMIB_IPADDRTABLE)closure;
1314 if (table && data)
1316 DWORD ndx;
1318 ret = FALSE;
1319 for (ndx = 0; !ret && ndx < table->dwNumEntries; ndx++)
1321 const NetBTAdapter *adapter = (const NetBTAdapter *)data->data;
1323 if (table->table[ndx].dwIndex == adapter->ipr.dwIndex)
1325 NetBIOSEnableAdapter(data->lana);
1326 table->table[ndx].dwAddr = INADDR_LOOPBACK;
1327 ret = TRUE;
1331 else
1332 ret = FALSE;
1333 return ret;
1336 /* Enumerates adapters by:
1337 * - retrieving the IP address table for the local machine
1338 * - eliminating loopback addresses from the table
1339 * - eliminating redundant addresses, that is, multiple addresses on the same
1340 * subnet
1341 * Calls NetBIOSEnumAdapters, passing the resulting table as the callback
1342 * data. The callback reenables each adapter that's already in the NetBIOS
1343 * table. After NetBIOSEnumAdapters returns, this function adds any remaining
1344 * adapters to the NetBIOS table.
1346 static UCHAR NetBTEnum(void)
1348 UCHAR ret;
1349 DWORD size = 0;
1351 TRACE("\n");
1353 if (GetIpAddrTable(NULL, &size, FALSE) == ERROR_INSUFFICIENT_BUFFER)
1355 PMIB_IPADDRTABLE ipAddrs, coalesceTable = NULL;
1356 DWORD numIPAddrs = (size - sizeof(MIB_IPADDRTABLE)) /
1357 sizeof(MIB_IPADDRROW) + 1;
1359 ipAddrs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1360 if (ipAddrs)
1361 coalesceTable = HeapAlloc(GetProcessHeap(),
1362 HEAP_ZERO_MEMORY, sizeof(MIB_IPADDRTABLE) +
1363 (min(numIPAddrs, MAX_LANA + 1) - 1) * sizeof(MIB_IPADDRROW));
1364 if (ipAddrs && coalesceTable)
1366 if (GetIpAddrTable(ipAddrs, &size, FALSE) == ERROR_SUCCESS)
1368 DWORD ndx;
1370 for (ndx = 0; ndx < ipAddrs->dwNumEntries; ndx++)
1372 if ((ipAddrs->table[ndx].dwAddr &
1373 ipAddrs->table[ndx].dwMask) !=
1374 htonl((INADDR_LOOPBACK & IN_CLASSA_NET)))
1376 BOOL newNetwork = TRUE;
1377 DWORD innerIndex;
1379 /* make sure we don't have more than one entry
1380 * for a subnet */
1381 for (innerIndex = 0; newNetwork &&
1382 innerIndex < coalesceTable->dwNumEntries; innerIndex++)
1383 if ((ipAddrs->table[ndx].dwAddr &
1384 ipAddrs->table[ndx].dwMask) ==
1385 (coalesceTable->table[innerIndex].dwAddr
1386 & coalesceTable->table[innerIndex].dwMask))
1387 newNetwork = FALSE;
1389 if (newNetwork)
1390 memcpy(&coalesceTable->table[
1391 coalesceTable->dwNumEntries++],
1392 &ipAddrs->table[ndx], sizeof(MIB_IPADDRROW));
1396 NetBIOSEnumAdapters(gTransportID, NetBTEnumCallback,
1397 coalesceTable);
1398 ret = NRC_GOODRET;
1399 for (ndx = 0; ret == NRC_GOODRET &&
1400 ndx < coalesceTable->dwNumEntries; ndx++)
1401 if (coalesceTable->table[ndx].dwAddr != INADDR_LOOPBACK)
1402 ret = NetBTRegisterAdapter(&coalesceTable->table[ndx]);
1404 else
1405 ret = NRC_SYSTEM;
1406 HeapFree(GetProcessHeap(), 0, ipAddrs);
1407 HeapFree(GetProcessHeap(), 0, coalesceTable);
1409 else
1410 ret = NRC_OSRESNOTAV;
1412 else
1413 ret = NRC_SYSTEM;
1414 TRACE("returning 0x%02x\n", ret);
1415 return ret;
1418 static const WCHAR VxD_MSTCPW[] = { 'S','Y','S','T','E','M','\\','C','u','r',
1419 'r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','S','e','r','v',
1420 'i','c','e','s','\\','V','x','D','\\','M','S','T','C','P','\0' };
1421 static const WCHAR NetBT_ParametersW[] = { 'S','Y','S','T','E','M','\\','C','u',
1422 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','S','e','r',
1423 'v','i','c','e','s','\\','N','e','t','B','T','\\','P','a','r','a','m','e','t',
1424 'e','r','s','\0' };
1425 static const WCHAR EnableDNSW[] = { 'E','n','a','b','l','e','D','N','S','\0' };
1426 static const WCHAR BcastNameQueryCountW[] = { 'B','c','a','s','t','N','a','m',
1427 'e','Q','u','e','r','y','C','o','u','n','t','\0' };
1428 static const WCHAR BcastNameQueryTimeoutW[] = { 'B','c','a','s','t','N','a','m',
1429 'e','Q','u','e','r','y','T','i','m','e','o','u','t','\0' };
1430 static const WCHAR NameSrvQueryCountW[] = { 'N','a','m','e','S','r','v',
1431 'Q','u','e','r','y','C','o','u','n','t','\0' };
1432 static const WCHAR NameSrvQueryTimeoutW[] = { 'N','a','m','e','S','r','v',
1433 'Q','u','e','r','y','T','i','m','e','o','u','t','\0' };
1434 static const WCHAR ScopeIDW[] = { 'S','c','o','p','e','I','D','\0' };
1435 static const WCHAR CacheTimeoutW[] = { 'C','a','c','h','e','T','i','m','e','o',
1436 'u','t','\0' };
1437 static const WCHAR Config_NetworkW[] = { 'S','o','f','t','w','a','r','e','\\',
1438 'W','i','n','e','\\','N','e','t','w','o','r','k','\0' };
1440 /* Initializes global variables and registers the NetBT transport */
1441 void NetBTInit(void)
1443 HKEY hKey;
1444 NetBIOSTransport transport;
1445 LONG ret;
1447 TRACE("\n");
1449 gEnableDNS = TRUE;
1450 gBCastQueries = BCAST_QUERIES;
1451 gBCastQueryTimeout = BCAST_QUERY_TIMEOUT;
1452 gWINSQueries = WINS_QUERIES;
1453 gWINSQueryTimeout = WINS_QUERY_TIMEOUT;
1454 gNumWINSServers = 0;
1455 memset(gWINSServers, 0, sizeof(gWINSServers));
1456 gScopeID[0] = '\0';
1457 gCacheTimeout = CACHE_TIMEOUT;
1459 /* Try to open the Win9x NetBT configuration key */
1460 ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, VxD_MSTCPW, 0, KEY_READ, &hKey);
1461 /* If that fails, try the WinNT NetBT configuration key */
1462 if (ret != ERROR_SUCCESS)
1463 ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, NetBT_ParametersW, 0, KEY_READ,
1464 &hKey);
1465 if (ret == ERROR_SUCCESS)
1467 DWORD dword, size;
1469 size = sizeof(dword);
1470 if (RegQueryValueExW(hKey, EnableDNSW, NULL, NULL,
1471 (LPBYTE)&dword, &size) == ERROR_SUCCESS)
1472 gEnableDNS = dword;
1473 size = sizeof(dword);
1474 if (RegQueryValueExW(hKey, BcastNameQueryCountW, NULL, NULL,
1475 (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERIES
1476 && dword <= MAX_QUERIES)
1477 gBCastQueries = dword;
1478 size = sizeof(dword);
1479 if (RegQueryValueExW(hKey, BcastNameQueryTimeoutW, NULL, NULL,
1480 (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERY_TIMEOUT
1481 && dword <= MAX_QUERY_TIMEOUT)
1482 gBCastQueryTimeout = dword;
1483 size = sizeof(dword);
1484 if (RegQueryValueExW(hKey, NameSrvQueryCountW, NULL, NULL,
1485 (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERIES
1486 && dword <= MAX_QUERIES)
1487 gWINSQueries = dword;
1488 size = sizeof(dword);
1489 if (RegQueryValueExW(hKey, NameSrvQueryTimeoutW, NULL, NULL,
1490 (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERY_TIMEOUT
1491 && dword <= MAX_QUERY_TIMEOUT)
1492 gWINSQueryTimeout = dword;
1493 size = MAX_DOMAIN_NAME_LEN - 1;
1494 if (RegQueryValueExW(hKey, ScopeIDW, NULL, NULL, (LPBYTE)gScopeID + 1, &size)
1495 == ERROR_SUCCESS)
1497 /* convert into L2-encoded version, suitable for use by
1498 NetBTNameEncode */
1499 char *ptr, *lenPtr;
1501 for (ptr = gScopeID + 1; *ptr &&
1502 ptr - gScopeID < MAX_DOMAIN_NAME_LEN; )
1504 for (lenPtr = ptr - 1, *lenPtr = 0; *ptr && *ptr != '.' &&
1505 ptr - gScopeID < MAX_DOMAIN_NAME_LEN; ptr++)
1506 *lenPtr += 1;
1507 ptr++;
1510 if (RegQueryValueExW(hKey, CacheTimeoutW, NULL, NULL,
1511 (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_CACHE_TIMEOUT)
1512 gCacheTimeout = dword;
1513 RegCloseKey(hKey);
1515 /* WINE-specific NetBT registry settings. Because our adapter naming is
1516 * different than MS', we can't do per-adapter WINS configuration in the
1517 * same place. Just do a global WINS configuration instead.
1519 /* @@ Wine registry key: HKCU\Software\Wine\Network */
1520 if (RegOpenKeyW(HKEY_CURRENT_USER, Config_NetworkW, &hKey) == ERROR_SUCCESS)
1522 static const char *nsValueNames[] = { "WinsServer", "BackupWinsServer" };
1523 char nsString[16];
1524 DWORD size, ndx;
1526 for (ndx = 0; ndx < sizeof(nsValueNames) / sizeof(nsValueNames[0]);
1527 ndx++)
1529 size = sizeof(nsString) / sizeof(char);
1530 if (RegQueryValueExA(hKey, nsValueNames[ndx], NULL, NULL,
1531 (LPBYTE)nsString, &size) == ERROR_SUCCESS)
1533 unsigned long addr = inet_addr(nsString);
1535 if (addr != INADDR_NONE && gNumWINSServers < MAX_WINS_SERVERS)
1536 gWINSServers[gNumWINSServers++] = addr;
1539 RegCloseKey(hKey);
1542 transport.enumerate = NetBTEnum;
1543 transport.astat = NetBTAstat;
1544 transport.findName = NetBTFindName;
1545 transport.call = NetBTCall;
1546 transport.send = NetBTSend;
1547 transport.recv = NetBTRecv;
1548 transport.hangup = NetBTHangup;
1549 transport.cleanupAdapter = NetBTCleanupAdapter;
1550 transport.cleanup = NetBTCleanup;
1551 memcpy(&gTransportID, TRANSPORT_NBT, sizeof(ULONG));
1552 NetBIOSRegisterTransport(gTransportID, &transport);