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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
21 * Lack of understanding and bugs are my fault.
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
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
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.
73 WINE_DEFAULT_DEBUG_CHANNEL(netbios
);
80 #define INADDR_NONE ~0UL
83 #define NBR_ADDWORD(p,word) (*(WORD *)(p)) = htons(word)
84 #define NBR_GETWORD(p) ntohs(*(WORD *)(p))
87 #define MAX_QUERIES 0xffff
88 #define MIN_QUERY_TIMEOUT 100
89 #define MAX_QUERY_TIMEOUT 0xffffffff
90 #define BCAST_QUERIES 3
91 #define BCAST_QUERY_TIMEOUT 750
92 #define WINS_QUERIES 3
93 #define WINS_QUERY_TIMEOUT 750
94 #define MAX_WINS_SERVERS 2
95 #define MIN_CACHE_TIMEOUT 60000
96 #define CACHE_TIMEOUT 360000
98 #define MAX_NBT_NAME_SZ 255
99 #define SIMPLE_NAME_QUERY_PKT_SIZE 16 + MAX_NBT_NAME_SZ
101 #define NBNS_TYPE_NB 0x0020
102 #define NBNS_TYPE_NBSTAT 0x0021
103 #define NBNS_CLASS_INTERNET 0x00001
104 #define NBNS_HEADER_SIZE (sizeof(WORD) * 6)
105 #define NBNS_RESPONSE_AND_OPCODE 0xf800
106 #define NBNS_RESPONSE_AND_QUERY 0x8000
107 #define NBNS_REPLYCODE 0x0f
109 #define NBSS_HDRSIZE 4
111 #define NBSS_MSG 0x00
112 #define NBSS_REQ 0x81
113 #define NBSS_ACK 0x82
114 #define NBSS_NACK 0x83
115 #define NBSS_RETARGET 0x84
116 #define NBSS_KEEPALIVE 0x85
118 #define NBSS_ERR_NOT_LISTENING_ON_NAME 0x80
119 #define NBSS_ERR_NOT_LISTENING_FOR_CALLER 0x81
120 #define NBSS_ERR_BAD_NAME 0x82
121 #define NBSS_ERR_INSUFFICIENT_RESOURCES 0x83
123 #define NBSS_EXTENSION 0x01
125 typedef struct _NetBTSession
132 typedef struct _NetBTAdapter
136 struct NBNameCache
*nameCache
;
141 static ULONG gTransportID
;
142 static BOOL gEnableDNS
;
143 static DWORD gBCastQueries
;
144 static DWORD gBCastQueryTimeout
;
145 static DWORD gWINSQueries
;
146 static DWORD gWINSQueryTimeout
;
147 static DWORD gWINSServers
[MAX_WINS_SERVERS
];
148 static int gNumWINSServers
;
149 static char gScopeID
[MAX_SCOPE_ID_LEN
];
150 static DWORD gCacheTimeout
;
151 static struct NBNameCache
*gNameCache
;
153 /* Converts from a NetBIOS name into a Second Level Encoding-formatted name.
154 * Assumes p is not NULL and is either NULL terminated or has at most NCBNAMSZ
155 * bytes, and buffer has at least MAX_NBT_NAME_SZ bytes. Pads with space bytes
156 * if p is NULL-terminated. Returns the number of bytes stored in buffer.
158 static int NetBTNameEncode(const UCHAR
*p
, UCHAR
*buffer
)
163 if (!buffer
) return 0;
165 buffer
[len
++] = NCBNAMSZ
* 2;
166 for (i
= 0; p
[i
] && i
< NCBNAMSZ
; i
++)
168 buffer
[len
++] = ((p
[i
] & 0xf0) >> 4) + 'A';
169 buffer
[len
++] = (p
[i
] & 0x0f) + 'A';
171 while (len
< NCBNAMSZ
* 2)
178 int scopeIDLen
= strlen(gScopeID
);
180 memcpy(buffer
+ len
, gScopeID
, scopeIDLen
);
183 buffer
[len
++] = 0; /* add second terminator */
187 /* Creates a NBT name request packet for name in buffer. If broadcast is true,
188 * creates a broadcast request, otherwise creates a unicast request.
189 * Returns the number of bytes stored in buffer.
191 static DWORD
NetBTNameReq(const UCHAR name
[NCBNAMSZ
], WORD xid
, WORD qtype
,
192 BOOL broadcast
, UCHAR
*buffer
, int len
)
196 if (len
< SIMPLE_NAME_QUERY_PKT_SIZE
) return 0;
198 NBR_ADDWORD(&buffer
[i
],xid
); i
+=2; /* transaction */
201 NBR_ADDWORD(&buffer
[i
],0x0110); /* flags: r=req,op=query,rd=1,b=1 */
206 NBR_ADDWORD(&buffer
[i
],0x0100); /* flags: r=req,op=query,rd=1,b=0 */
209 NBR_ADDWORD(&buffer
[i
],0x0001); i
+=2; /* one name query */
210 NBR_ADDWORD(&buffer
[i
],0x0000); i
+=2; /* zero answers */
211 NBR_ADDWORD(&buffer
[i
],0x0000); i
+=2; /* zero authorities */
212 NBR_ADDWORD(&buffer
[i
],0x0000); i
+=2; /* zero additional */
214 i
+= NetBTNameEncode(name
, &buffer
[i
]);
216 NBR_ADDWORD(&buffer
[i
],qtype
); i
+=2;
217 NBR_ADDWORD(&buffer
[i
],NBNS_CLASS_INTERNET
); i
+=2;
222 /* Sends a name query request for name on fd to destAddr. Sets SO_BROADCAST on
223 * fd if broadcast is TRUE. Assumes fd is not INVALID_SOCKET, and name is not
225 * Returns 0 on success, -1 on failure.
227 static int NetBTSendNameQuery(SOCKET fd
, const UCHAR name
[NCBNAMSZ
], WORD xid
,
228 WORD qtype
, DWORD destAddr
, BOOL broadcast
)
233 addr
.s_addr
= destAddr
;
234 TRACE("name %s, dest addr %s\n", name
, inet_ntoa(addr
));
237 ret
= setsockopt(fd
, SOL_SOCKET
, SO_BROADCAST
, (const char*)&on
, sizeof(on
));
241 UCHAR buf
[SIMPLE_NAME_QUERY_PKT_SIZE
];
242 struct sockaddr_in sin
;
244 memset(&sin
, 0, sizeof(sin
));
245 sin
.sin_addr
.s_addr
= destAddr
;
246 sin
.sin_family
= AF_INET
;
247 sin
.sin_port
= htons(PORT_NBNS
);
249 wsaBuf
.buf
= (CHAR
*)buf
;
250 wsaBuf
.len
= NetBTNameReq(name
, xid
, qtype
, broadcast
, buf
,
256 ret
= WSASendTo(fd
, &wsaBuf
, 1, &bytesSent
, 0,
257 (struct sockaddr
*)&sin
, sizeof(sin
), NULL
, NULL
);
258 if (ret
< 0 || bytesSent
< wsaBuf
.len
)
269 typedef BOOL (*NetBTAnswerCallback
)(void *data
, WORD answerCount
,
270 WORD answerIndex
, PUCHAR rData
, WORD rdLength
);
272 /* Waits on fd until GetTickCount() returns a value greater than or equal to
273 * waitUntil for a name service response. If a name response matching xid
274 * is received, calls answerCallback once for each answer resource record in
275 * the response. (The callback's answerCount will be the total number of
276 * answers to expect, and answerIndex will be the 0-based index that's being
277 * sent this time.) Quits parsing if answerCallback returns FALSE.
278 * Returns NRC_GOODRET on timeout or a valid response received, something else
281 static UCHAR
NetBTWaitForNameResponse(const NetBTAdapter
*adapter
, SOCKET fd
,
282 DWORD waitUntil
, NetBTAnswerCallback answerCallback
, void *data
)
286 UCHAR ret
= NRC_GOODRET
;
288 if (!adapter
) return NRC_BADDR
;
289 if (fd
== INVALID_SOCKET
) return NRC_BADDR
;
290 if (!answerCallback
) return NRC_BADDR
;
292 while (!found
&& ret
== NRC_GOODRET
&& (now
= GetTickCount()) < waitUntil
)
294 DWORD msToWait
= waitUntil
- now
;
296 struct timeval timeout
= { msToWait
/ 1000, msToWait
% 1000 };
301 r
= select(fd
+ 1, &fds
, NULL
, NULL
, &timeout
);
306 /* FIXME: magic #, is this always enough? */
309 struct sockaddr_in fromaddr
;
310 WORD respXID
, flags
, queryCount
, answerCount
;
311 WSABUF wsaBuf
= { sizeof(buffer
), (CHAR
*)buffer
};
312 DWORD bytesReceived
, recvFlags
= 0;
314 fromsize
= sizeof(fromaddr
);
315 r
= WSARecvFrom(fd
, &wsaBuf
, 1, &bytesReceived
, &recvFlags
,
316 (struct sockaddr
*)&fromaddr
, &fromsize
, NULL
, NULL
);
323 if (bytesReceived
< NBNS_HEADER_SIZE
)
326 respXID
= NBR_GETWORD(buffer
);
327 if (adapter
->nameQueryXID
!= respXID
)
330 flags
= NBR_GETWORD(buffer
+ 2);
331 queryCount
= NBR_GETWORD(buffer
+ 4);
332 answerCount
= NBR_GETWORD(buffer
+ 6);
334 /* a reply shouldn't contain a query, ignore bad packet */
338 if ((flags
& NBNS_RESPONSE_AND_OPCODE
) == NBNS_RESPONSE_AND_QUERY
)
340 if ((flags
& NBNS_REPLYCODE
) != 0)
342 else if ((flags
& NBNS_REPLYCODE
) == 0 && answerCount
> 0)
344 PUCHAR ptr
= buffer
+ NBNS_HEADER_SIZE
;
345 BOOL shouldContinue
= TRUE
;
346 WORD answerIndex
= 0;
349 /* decode one answer at a time */
350 while (ret
== NRC_GOODRET
&& answerIndex
< answerCount
&&
351 ptr
- buffer
< bytesReceived
&& shouldContinue
)
356 for (; ptr
[0] && ptr
- buffer
< bytesReceived
; )
359 ptr
+= 2; /* scan past type */
360 if (ptr
- buffer
< bytesReceived
&& ret
== NRC_GOODRET
361 && NBR_GETWORD(ptr
) == NBNS_CLASS_INTERNET
)
364 ret
= NRC_SYSTEM
; /* parse error */
365 ptr
+= sizeof(DWORD
); /* TTL */
366 rLen
= NBR_GETWORD(ptr
);
367 rLen
= min(rLen
, bytesReceived
- (ptr
- buffer
));
369 shouldContinue
= answerCallback(data
, answerCount
,
370 answerIndex
, ptr
, rLen
);
378 TRACE("returning 0x%02x\n", ret
);
382 typedef struct _NetBTNameQueryData
{
383 NBNameCacheEntry
*cacheEntry
;
385 } NetBTNameQueryData
;
387 /* Name query callback function for NetBTWaitForNameResponse, creates a cache
388 * entry on the first answer, adds each address as it's called again (as long
389 * as there's space). If there's an error that should be propagated as the
390 * NetBIOS error, modifies queryData's ret member to the proper return code.
392 static BOOL
NetBTFindNameAnswerCallback(void *pVoid
, WORD answerCount
,
393 WORD answerIndex
, PUCHAR rData
, WORD rLen
)
395 NetBTNameQueryData
*queryData
= pVoid
;
400 if (queryData
->cacheEntry
== NULL
)
402 queryData
->cacheEntry
= HeapAlloc(
403 GetProcessHeap(), 0, sizeof(NBNameCacheEntry
) +
404 (answerCount
- 1) * sizeof(DWORD
));
405 if (queryData
->cacheEntry
)
406 queryData
->cacheEntry
->numAddresses
= 0;
408 queryData
->ret
= NRC_OSRESNOTAV
;
410 if (rLen
== 6 && queryData
->cacheEntry
&&
411 queryData
->cacheEntry
->numAddresses
< answerCount
)
413 queryData
->cacheEntry
->addresses
[queryData
->cacheEntry
->
414 numAddresses
++] = *(const DWORD
*)(rData
+ 2);
415 ret
= queryData
->cacheEntry
->numAddresses
< answerCount
;
425 /* Workhorse NetBT name lookup function. Sends a name lookup query for
426 * ncb->ncb_callname to sendTo, as a broadcast if broadcast is TRUE, using
427 * adapter->nameQueryXID as the transaction ID. Waits up to timeout
428 * milliseconds, and retries up to maxQueries times, waiting for a reply.
429 * If a valid response is received, stores the looked up addresses as a
430 * NBNameCacheEntry in *cacheEntry.
431 * Returns NRC_GOODRET on success, though this may not mean the name was
432 * resolved--check whether *cacheEntry is NULL.
434 static UCHAR
NetBTNameWaitLoop(const NetBTAdapter
*adapter
, SOCKET fd
, const NCB
*ncb
,
435 DWORD sendTo
, BOOL broadcast
, DWORD timeout
, DWORD maxQueries
,
436 NBNameCacheEntry
**cacheEntry
)
438 unsigned int queries
;
439 NetBTNameQueryData queryData
;
441 if (!adapter
) return NRC_BADDR
;
442 if (fd
== INVALID_SOCKET
) return NRC_BADDR
;
443 if (!ncb
) return NRC_BADDR
;
444 if (!cacheEntry
) return NRC_BADDR
;
446 queryData
.cacheEntry
= NULL
;
447 queryData
.ret
= NRC_GOODRET
;
448 for (queries
= 0; queryData
.cacheEntry
== NULL
&& queries
< maxQueries
;
451 if (!NCB_CANCELLED(ncb
))
453 int r
= NetBTSendNameQuery(fd
, ncb
->ncb_callname
,
454 adapter
->nameQueryXID
, NBNS_TYPE_NB
, sendTo
, broadcast
);
457 queryData
.ret
= NetBTWaitForNameResponse(adapter
, fd
,
458 GetTickCount() + timeout
, NetBTFindNameAnswerCallback
,
461 queryData
.ret
= NRC_SYSTEM
;
464 queryData
.ret
= NRC_CMDCAN
;
466 if (queryData
.cacheEntry
)
468 memcpy(queryData
.cacheEntry
->name
, ncb
->ncb_callname
, NCBNAMSZ
);
469 memcpy(queryData
.cacheEntry
->nbname
, ncb
->ncb_callname
, NCBNAMSZ
);
471 *cacheEntry
= queryData
.cacheEntry
;
472 return queryData
.ret
;
475 /* Attempts to add cacheEntry to the name cache in *nameCache; if *nameCache
476 * has not yet been created, creates it, using gCacheTimeout as the cache
477 * entry timeout. If memory allocation fails, or if NBNameCacheAddEntry fails,
479 * Returns NRC_GOODRET on success, and something else on failure.
481 static UCHAR
NetBTStoreCacheEntry(struct NBNameCache
**nameCache
,
482 NBNameCacheEntry
*cacheEntry
)
486 if (!nameCache
) return NRC_BADDR
;
487 if (!cacheEntry
) return NRC_BADDR
;
490 *nameCache
= NBNameCacheCreate(GetProcessHeap(), gCacheTimeout
);
492 ret
= NBNameCacheAddEntry(*nameCache
, cacheEntry
)
493 ? NRC_GOODRET
: NRC_OSRESNOTAV
;
496 HeapFree(GetProcessHeap(), 0, cacheEntry
);
497 ret
= NRC_OSRESNOTAV
;
502 /* Attempts to resolve name using inet_addr(), then gethostbyname() if
503 * gEnableDNS is TRUE, if the suffix byte is either <00> or <20>. If the name
504 * can be looked up, returns 0 and stores the looked up addresses as a
505 * NBNameCacheEntry in *cacheEntry.
506 * Returns NRC_GOODRET on success, though this may not mean the name was
507 * resolved--check whether *cacheEntry is NULL. Returns something else on
510 static UCHAR
NetBTinetResolve(const UCHAR name
[NCBNAMSZ
],
511 NBNameCacheEntry
**cacheEntry
)
513 UCHAR ret
= NRC_GOODRET
;
515 TRACE("name %s, cacheEntry %p\n", name
, cacheEntry
);
517 if (!name
) return NRC_BADDR
;
518 if (!cacheEntry
) return NRC_BADDR
;
520 if (isalnum(name
[0]) && (name
[NCBNAMSZ
- 1] == 0 ||
521 name
[NCBNAMSZ
- 1] == 0x20))
523 CHAR toLookup
[NCBNAMSZ
];
526 for (i
= 0; i
< NCBNAMSZ
- 1 && name
[i
] && name
[i
] != ' '; i
++)
527 toLookup
[i
] = name
[i
];
530 if (isdigit(toLookup
[0]))
532 unsigned long addr
= inet_addr(toLookup
);
534 if (addr
!= INADDR_NONE
)
536 *cacheEntry
= HeapAlloc(GetProcessHeap(),
537 0, sizeof(NBNameCacheEntry
));
540 memcpy((*cacheEntry
)->name
, name
, NCBNAMSZ
);
541 memset((*cacheEntry
)->nbname
, 0, NCBNAMSZ
);
542 (*cacheEntry
)->nbname
[0] = '*';
543 (*cacheEntry
)->numAddresses
= 1;
544 (*cacheEntry
)->addresses
[0] = addr
;
547 ret
= NRC_OSRESNOTAV
;
550 if (gEnableDNS
&& ret
== NRC_GOODRET
&& !*cacheEntry
)
552 struct hostent
*host
;
554 if ((host
= gethostbyname(toLookup
)) != NULL
)
556 for (i
= 0; ret
== NRC_GOODRET
&& host
->h_addr_list
&&
557 host
->h_addr_list
[i
]; i
++)
559 if (host
->h_addr_list
&& host
->h_addr_list
[0])
561 *cacheEntry
= HeapAlloc(
562 GetProcessHeap(), 0, sizeof(NBNameCacheEntry
) +
563 (i
- 1) * sizeof(DWORD
));
566 memcpy((*cacheEntry
)->name
, name
, NCBNAMSZ
);
567 memset((*cacheEntry
)->nbname
, 0, NCBNAMSZ
);
568 (*cacheEntry
)->nbname
[0] = '*';
569 (*cacheEntry
)->numAddresses
= i
;
570 for (i
= 0; i
< (*cacheEntry
)->numAddresses
; i
++)
571 (*cacheEntry
)->addresses
[i
] =
572 (DWORD
)host
->h_addr_list
[i
];
575 ret
= NRC_OSRESNOTAV
;
581 TRACE("returning 0x%02x\n", ret
);
585 /* Looks up the name in ncb->ncb_callname, first in the name caches (global
586 * and this adapter's), then using gethostbyname(), next by WINS if configured,
587 * and finally using broadcast NetBT name resolution. In NBT parlance, this
588 * makes this an "H-node". Stores an entry in the appropriate name cache for a
589 * found node, and returns it as *cacheEntry.
590 * Assumes data, ncb, and cacheEntry are not NULL.
591 * Returns NRC_GOODRET on success--which doesn't mean the name was resolved,
592 * just that all name lookup operations completed successfully--and something
593 * else on failure. *cacheEntry will be NULL if the name was not found.
595 static UCHAR
NetBTInternalFindName(NetBTAdapter
*adapter
, PNCB ncb
,
596 const NBNameCacheEntry
**cacheEntry
)
598 UCHAR ret
= NRC_GOODRET
;
600 TRACE("adapter %p, ncb %p, cacheEntry %p\n", adapter
, ncb
, cacheEntry
);
602 if (!cacheEntry
) return NRC_BADDR
;
605 if (!adapter
) return NRC_BADDR
;
606 if (!ncb
) return NRC_BADDR
;
608 if (ncb
->ncb_callname
[0] == '*')
612 *cacheEntry
= NBNameCacheFindEntry(gNameCache
, ncb
->ncb_callname
);
614 *cacheEntry
= NBNameCacheFindEntry(adapter
->nameCache
,
618 NBNameCacheEntry
*newEntry
= NULL
;
620 ret
= NetBTinetResolve(ncb
->ncb_callname
, &newEntry
);
621 if (ret
== NRC_GOODRET
&& newEntry
)
623 ret
= NetBTStoreCacheEntry(&gNameCache
, newEntry
);
624 if (ret
!= NRC_GOODRET
)
629 SOCKET fd
= WSASocketA(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
,
630 0, WSA_FLAG_OVERLAPPED
);
632 if(fd
== INVALID_SOCKET
)
633 ret
= NRC_OSRESNOTAV
;
638 adapter
->nameQueryXID
++;
639 for (winsNdx
= 0; ret
== NRC_GOODRET
&& *cacheEntry
== NULL
640 && winsNdx
< gNumWINSServers
; winsNdx
++)
641 ret
= NetBTNameWaitLoop(adapter
, fd
, ncb
,
642 gWINSServers
[winsNdx
], FALSE
, gWINSQueryTimeout
,
643 gWINSQueries
, &newEntry
);
644 if (ret
== NRC_GOODRET
&& newEntry
)
646 ret
= NetBTStoreCacheEntry(&gNameCache
, newEntry
);
647 if (ret
!= NRC_GOODRET
)
650 if (ret
== NRC_GOODRET
&& *cacheEntry
== NULL
)
653 adapter
->ipr
.dwAddr
& adapter
->ipr
.dwMask
;
655 if (adapter
->ipr
.dwBCastAddr
)
656 bcastAddr
|= ~adapter
->ipr
.dwMask
;
657 ret
= NetBTNameWaitLoop(adapter
, fd
, ncb
, bcastAddr
,
658 TRUE
, gBCastQueryTimeout
, gBCastQueries
, &newEntry
);
659 if (ret
== NRC_GOODRET
&& newEntry
)
661 ret
= NetBTStoreCacheEntry(&adapter
->nameCache
,
663 if (ret
!= NRC_GOODRET
)
670 *cacheEntry
= newEntry
;
673 TRACE("returning 0x%02x\n", ret
);
677 typedef struct _NetBTNodeQueryData
680 PADAPTER_STATUS astat
;
682 } NetBTNodeQueryData
;
684 /* Callback function for NetBTAstatRemote, parses the rData for the node
685 * status and name list of the remote node. Always returns FALSE, since
686 * there's never more than one answer we care about in a node status response.
688 static BOOL
NetBTNodeStatusAnswerCallback(void *pVoid
, WORD answerCount
,
689 WORD answerIndex
, PUCHAR rData
, WORD rLen
)
691 NetBTNodeQueryData
*data
= pVoid
;
693 if (data
&& !data
->gotResponse
&& rData
&& rLen
>= 1)
695 /* num names is first byte; each name is NCBNAMSZ + 2 bytes */
696 if (rLen
>= rData
[0] * (NCBNAMSZ
+ 2))
702 data
->gotResponse
= TRUE
;
703 data
->astat
->name_count
= rData
[0];
704 for (i
= 0, src
= rData
+ 1,
705 dst
= (PNAME_BUFFER
)((PUCHAR
)data
->astat
+
706 sizeof(ADAPTER_STATUS
));
707 i
< data
->astat
->name_count
&& src
- rData
< rLen
&&
708 (PUCHAR
)dst
- (PUCHAR
)data
->astat
< data
->astatLen
;
709 i
++, dst
++, src
+= NCBNAMSZ
+ 2)
711 UCHAR flags
= *(src
+ NCBNAMSZ
);
713 memcpy(dst
->name
, src
, NCBNAMSZ
);
714 /* we won't actually see a registering name in the returned
715 * response. It's useful to see if no other flags are set; if
716 * none are, then the name is registered. */
717 dst
->name_flags
= REGISTERING
;
719 dst
->name_flags
|= GROUP_NAME
;
721 dst
->name_flags
|= DEREGISTERED
;
723 dst
->name_flags
|= DUPLICATE
;
724 if (dst
->name_flags
== REGISTERING
)
725 dst
->name_flags
= REGISTERED
;
727 /* arbitrarily set HW type to Ethernet */
728 data
->astat
->adapter_type
= 0xfe;
729 if (src
- rData
< rLen
)
730 memcpy(data
->astat
->adapter_address
, src
,
731 min(rLen
- (src
- rData
), 6));
737 /* This uses the WINS timeout and query values, as they're the
738 * UCAST_REQ_RETRY_TIMEOUT and UCAST_REQ_RETRY_COUNT according to the RFCs.
740 static UCHAR
NetBTAstatRemote(NetBTAdapter
*adapter
, PNCB ncb
)
742 UCHAR ret
= NRC_GOODRET
;
743 const NBNameCacheEntry
*cacheEntry
= NULL
;
745 TRACE("adapter %p, NCB %p\n", adapter
, ncb
);
747 if (!adapter
) return NRC_BADDR
;
748 if (!ncb
) return NRC_INVADDRESS
;
750 ret
= NetBTInternalFindName(adapter
, ncb
, &cacheEntry
);
751 if (ret
== NRC_GOODRET
&& cacheEntry
)
753 if (cacheEntry
->numAddresses
> 0)
755 SOCKET fd
= WSASocketA(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
, NULL
, 0,
756 WSA_FLAG_OVERLAPPED
);
758 if(fd
== INVALID_SOCKET
)
759 ret
= NRC_OSRESNOTAV
;
762 NetBTNodeQueryData queryData
;
764 PADAPTER_STATUS astat
= (PADAPTER_STATUS
)ncb
->ncb_buffer
;
766 adapter
->nameQueryXID
++;
767 astat
->name_count
= 0;
768 queryData
.gotResponse
= FALSE
;
769 queryData
.astat
= astat
;
770 queryData
.astatLen
= ncb
->ncb_length
;
771 for (queries
= 0; !queryData
.gotResponse
&&
772 queries
< gWINSQueries
; queries
++)
774 if (!NCB_CANCELLED(ncb
))
776 int r
= NetBTSendNameQuery(fd
, ncb
->ncb_callname
,
777 adapter
->nameQueryXID
, NBNS_TYPE_NBSTAT
,
778 cacheEntry
->addresses
[0], FALSE
);
781 ret
= NetBTWaitForNameResponse(adapter
, fd
,
782 GetTickCount() + gWINSQueryTimeout
,
783 NetBTNodeStatusAnswerCallback
, &queryData
);
796 else if (ret
== NRC_CMDCAN
)
797 ; /* do nothing, we were cancelled */
800 TRACE("returning 0x%02x\n", ret
);
804 static UCHAR
NetBTAstat(void *adapt
, PNCB ncb
)
806 NetBTAdapter
*adapter
= adapt
;
809 TRACE("adapt %p, NCB %p\n", adapt
, ncb
);
811 if (!adapter
) return NRC_ENVNOTDEF
;
812 if (!ncb
) return NRC_INVADDRESS
;
813 if (!ncb
->ncb_buffer
) return NRC_BADDR
;
814 if (ncb
->ncb_length
< sizeof(ADAPTER_STATUS
)) return NRC_BUFLEN
;
816 if (ncb
->ncb_callname
[0] == '*')
820 PADAPTER_STATUS astat
= (PADAPTER_STATUS
)ncb
->ncb_buffer
;
822 memset(astat
, 0, sizeof(ADAPTER_STATUS
));
823 astat
->rev_major
= 3;
824 ifRow
.dwIndex
= adapter
->ipr
.dwIndex
;
825 if (GetIfEntry(&ifRow
) != NO_ERROR
)
829 physAddrLen
= min(ifRow
.dwPhysAddrLen
, 6);
831 memcpy(astat
->adapter_address
, ifRow
.bPhysAddr
, physAddrLen
);
832 /* doubt anyone cares, but why not.. */
833 if (ifRow
.dwType
== MIB_IF_TYPE_TOKENRING
)
834 astat
->adapter_type
= 0xff;
836 astat
->adapter_type
= 0xfe; /* for Ethernet */
837 astat
->max_sess_pkt_size
= 0xffff;
838 astat
->xmit_success
= adapter
->xmit_success
;
839 astat
->recv_success
= adapter
->recv_success
;
844 ret
= NetBTAstatRemote(adapter
, ncb
);
845 TRACE("returning 0x%02x\n", ret
);
849 static UCHAR
NetBTFindName(void *adapt
, PNCB ncb
)
851 NetBTAdapter
*adapter
= adapt
;
853 const NBNameCacheEntry
*cacheEntry
= NULL
;
854 PFIND_NAME_HEADER foundName
;
856 TRACE("adapt %p, NCB %p\n", adapt
, ncb
);
858 if (!adapter
) return NRC_ENVNOTDEF
;
859 if (!ncb
) return NRC_INVADDRESS
;
860 if (!ncb
->ncb_buffer
) return NRC_BADDR
;
861 if (ncb
->ncb_length
< sizeof(FIND_NAME_HEADER
)) return NRC_BUFLEN
;
863 foundName
= (PFIND_NAME_HEADER
)ncb
->ncb_buffer
;
864 memset(foundName
, 0, sizeof(FIND_NAME_HEADER
));
866 ret
= NetBTInternalFindName(adapter
, ncb
, &cacheEntry
);
867 if (ret
== NRC_GOODRET
)
871 DWORD spaceFor
= min((ncb
->ncb_length
- sizeof(FIND_NAME_HEADER
)) /
872 sizeof(FIND_NAME_BUFFER
), cacheEntry
->numAddresses
);
875 for (ndx
= 0; ndx
< spaceFor
; ndx
++)
877 PFIND_NAME_BUFFER findNameBuffer
;
880 (PFIND_NAME_BUFFER
)((PUCHAR
)foundName
+
881 sizeof(FIND_NAME_HEADER
) + foundName
->node_count
*
882 sizeof(FIND_NAME_BUFFER
));
883 memset(findNameBuffer
->destination_addr
, 0, 2);
884 memcpy(findNameBuffer
->destination_addr
+ 2,
885 &adapter
->ipr
.dwAddr
, sizeof(DWORD
));
886 memset(findNameBuffer
->source_addr
, 0, 2);
887 memcpy(findNameBuffer
->source_addr
+ 2,
888 &cacheEntry
->addresses
[ndx
], sizeof(DWORD
));
889 foundName
->node_count
++;
891 if (spaceFor
< cacheEntry
->numAddresses
)
897 TRACE("returning 0x%02x\n", ret
);
901 static UCHAR
NetBTSessionReq(SOCKET fd
, const UCHAR
*calledName
,
902 const UCHAR
*callingName
)
904 UCHAR buffer
[NBSS_HDRSIZE
+ MAX_DOMAIN_NAME_LEN
* 2], ret
;
906 unsigned int len
= 0;
907 DWORD bytesSent
, bytesReceived
, recvFlags
= 0;
910 buffer
[0] = NBSS_REQ
;
913 len
+= NetBTNameEncode(calledName
, &buffer
[NBSS_HDRSIZE
]);
914 len
+= NetBTNameEncode(callingName
, &buffer
[NBSS_HDRSIZE
+ len
]);
916 NBR_ADDWORD(&buffer
[2], len
);
918 wsaBuf
.len
= len
+ NBSS_HDRSIZE
;
919 wsaBuf
.buf
= (char*)buffer
;
921 r
= WSASend(fd
, &wsaBuf
, 1, &bytesSent
, 0, NULL
, NULL
);
922 if(r
< 0 || bytesSent
< len
+ NBSS_HDRSIZE
)
924 ERR("send failed\n");
928 /* I've already set the recv timeout on this socket (if it supports it), so
929 * just block. Hopefully we'll always receive the session acknowledgement
930 * within one timeout.
932 wsaBuf
.len
= NBSS_HDRSIZE
+ 1;
933 r
= WSARecv(fd
, &wsaBuf
, 1, &bytesReceived
, &recvFlags
, NULL
, NULL
);
934 if (r
< 0 || bytesReceived
< NBSS_HDRSIZE
)
936 else if (buffer
[0] == NBSS_NACK
)
938 if (r
== NBSS_HDRSIZE
+ 1)
940 switch (buffer
[NBSS_HDRSIZE
])
942 case NBSS_ERR_INSUFFICIENT_RESOURCES
:
952 else if (buffer
[0] == NBSS_RETARGET
)
954 FIXME("Got a session retarget, can't deal\n");
957 else if (buffer
[0] == NBSS_ACK
)
962 TRACE("returning 0x%02x\n", ret
);
966 static UCHAR
NetBTCall(void *adapt
, PNCB ncb
, void **sess
)
968 NetBTAdapter
*adapter
= adapt
;
970 const NBNameCacheEntry
*cacheEntry
= NULL
;
972 TRACE("adapt %p, ncb %p\n", adapt
, ncb
);
974 if (!adapter
) return NRC_ENVNOTDEF
;
975 if (!ncb
) return NRC_INVADDRESS
;
976 if (!sess
) return NRC_BADDR
;
978 ret
= NetBTInternalFindName(adapter
, ncb
, &cacheEntry
);
979 if (ret
== NRC_GOODRET
)
981 if (cacheEntry
&& cacheEntry
->numAddresses
> 0)
985 fd
= WSASocketA(PF_INET
, SOCK_STREAM
, IPPROTO_TCP
, NULL
, 0,
986 WSA_FLAG_OVERLAPPED
);
987 if (fd
!= INVALID_SOCKET
)
990 struct sockaddr_in sin
;
992 if (ncb
->ncb_rto
> 0)
994 timeout
= ncb
->ncb_rto
* 500;
995 setsockopt(fd
, SOL_SOCKET
, SO_RCVTIMEO
, (char*)&timeout
,
998 if (ncb
->ncb_rto
> 0)
1000 timeout
= ncb
->ncb_sto
* 500;
1001 setsockopt(fd
, SOL_SOCKET
, SO_SNDTIMEO
, (char*)&timeout
,
1005 memset(&sin
, 0, sizeof(sin
));
1006 memcpy(&sin
.sin_addr
, &cacheEntry
->addresses
[0],
1007 sizeof(sin
.sin_addr
));
1008 sin
.sin_family
= AF_INET
;
1009 sin
.sin_port
= htons(PORT_NBSS
);
1010 /* FIXME: use nonblocking mode for the socket, check the
1011 * cancel flag periodically
1013 if (connect(fd
, (struct sockaddr
*)&sin
, sizeof(sin
))
1018 static const UCHAR fakedCalledName
[] = "*SMBSERVER";
1019 const UCHAR
*calledParty
= cacheEntry
->nbname
[0] == '*'
1020 ? fakedCalledName
: cacheEntry
->nbname
;
1022 ret
= NetBTSessionReq(fd
, calledParty
, ncb
->ncb_name
);
1023 if (ret
!= NRC_GOODRET
&& calledParty
[0] == '*')
1025 FIXME("NBT session to \"*SMBSERVER\" refused,\n");
1026 FIXME("should try finding name using ASTAT\n");
1029 if (ret
!= NRC_GOODRET
)
1033 NetBTSession
*session
= HeapAlloc(
1034 GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(NetBTSession
));
1039 InitializeCriticalSection(&session
->cs
);
1040 session
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": NetBTSession.cs");
1045 ret
= NRC_OSRESNOTAV
;
1051 ret
= NRC_OSRESNOTAV
;
1056 TRACE("returning 0x%02x\n", ret
);
1060 /* Notice that I don't protect against multiple thread access to NetBTSend.
1061 * This is because I don't update any data in the adapter, and I only make a
1062 * single call to WSASend, which I assume to act atomically (not interleaving
1063 * data from other threads).
1064 * I don't lock, because I only depend on the fd being valid, and this won't be
1065 * true until a session setup is completed.
1067 static UCHAR
NetBTSend(void *adapt
, void *sess
, PNCB ncb
)
1069 NetBTAdapter
*adapter
= adapt
;
1070 NetBTSession
*session
= sess
;
1071 UCHAR buffer
[NBSS_HDRSIZE
], ret
;
1076 TRACE("adapt %p, session %p, NCB %p\n", adapt
, session
, ncb
);
1078 if (!adapter
) return NRC_ENVNOTDEF
;
1079 if (!ncb
) return NRC_INVADDRESS
;
1080 if (!ncb
->ncb_buffer
) return NRC_BADDR
;
1081 if (!session
) return NRC_SNUMOUT
;
1082 if (session
->fd
== INVALID_SOCKET
) return NRC_SNUMOUT
;
1084 buffer
[0] = NBSS_MSG
;
1086 NBR_ADDWORD(&buffer
[2], ncb
->ncb_length
);
1088 wsaBufs
[0].len
= NBSS_HDRSIZE
;
1089 wsaBufs
[0].buf
= (char*)buffer
;
1090 wsaBufs
[1].len
= ncb
->ncb_length
;
1091 wsaBufs
[1].buf
= (char*)ncb
->ncb_buffer
;
1093 r
= WSASend(session
->fd
, wsaBufs
, sizeof(wsaBufs
) / sizeof(wsaBufs
[0]),
1094 &bytesSent
, 0, NULL
, NULL
);
1095 if (r
== SOCKET_ERROR
)
1097 NetBIOSHangupSession(ncb
);
1100 else if (bytesSent
< NBSS_HDRSIZE
+ ncb
->ncb_length
)
1102 FIXME("Only sent %d bytes (of %d), hanging up session\n", bytesSent
,
1103 NBSS_HDRSIZE
+ ncb
->ncb_length
);
1104 NetBIOSHangupSession(ncb
);
1110 adapter
->xmit_success
++;
1112 TRACE("returning 0x%02x\n", ret
);
1116 static UCHAR
NetBTRecv(void *adapt
, void *sess
, PNCB ncb
)
1118 NetBTAdapter
*adapter
= adapt
;
1119 NetBTSession
*session
= sess
;
1120 UCHAR buffer
[NBSS_HDRSIZE
], ret
;
1123 DWORD bufferCount
, bytesReceived
, flags
;
1125 TRACE("adapt %p, session %p, NCB %p\n", adapt
, session
, ncb
);
1127 if (!adapter
) return NRC_ENVNOTDEF
;
1128 if (!ncb
) return NRC_BADDR
;
1129 if (!ncb
->ncb_buffer
) return NRC_BADDR
;
1130 if (!session
) return NRC_SNUMOUT
;
1131 if (session
->fd
== INVALID_SOCKET
) return NRC_SNUMOUT
;
1133 EnterCriticalSection(&session
->cs
);
1135 if (session
->bytesPending
== 0)
1138 wsaBufs
[0].len
= NBSS_HDRSIZE
;
1139 wsaBufs
[0].buf
= (char*)buffer
;
1141 wsaBufs
[bufferCount
].len
= ncb
->ncb_length
;
1142 wsaBufs
[bufferCount
].buf
= (char*)ncb
->ncb_buffer
;
1146 /* FIXME: should poll a bit so I can check the cancel flag */
1147 r
= WSARecv(session
->fd
, wsaBufs
, bufferCount
, &bytesReceived
, &flags
,
1149 if (r
== SOCKET_ERROR
&& WSAGetLastError() != WSAEWOULDBLOCK
)
1151 LeaveCriticalSection(&session
->cs
);
1152 ERR("Receive error, WSAGetLastError() returns %d\n", WSAGetLastError());
1153 NetBIOSHangupSession(ncb
);
1156 else if (NCB_CANCELLED(ncb
))
1158 LeaveCriticalSection(&session
->cs
);
1163 if (bufferCount
== 2)
1165 if (buffer
[0] == NBSS_KEEPALIVE
)
1167 LeaveCriticalSection(&session
->cs
);
1168 FIXME("Oops, received a session keepalive and lost my place\n");
1169 /* need to read another session header until we get a session
1170 * message header. */
1171 NetBIOSHangupSession(ncb
);
1175 else if (buffer
[0] != NBSS_MSG
)
1177 LeaveCriticalSection(&session
->cs
);
1178 FIXME("Received unexpected session msg type %d\n", buffer
[0]);
1179 NetBIOSHangupSession(ncb
);
1185 if (buffer
[1] & NBSS_EXTENSION
)
1187 LeaveCriticalSection(&session
->cs
);
1188 FIXME("Received a message that's too long for my taste\n");
1189 NetBIOSHangupSession(ncb
);
1195 session
->bytesPending
= NBSS_HDRSIZE
1196 + NBR_GETWORD(&buffer
[2]) - bytesReceived
;
1197 ncb
->ncb_length
= bytesReceived
- NBSS_HDRSIZE
;
1198 LeaveCriticalSection(&session
->cs
);
1204 if (bytesReceived
< session
->bytesPending
)
1205 session
->bytesPending
-= bytesReceived
;
1207 session
->bytesPending
= 0;
1208 LeaveCriticalSection(&session
->cs
);
1209 ncb
->ncb_length
= bytesReceived
;
1211 if (session
->bytesPending
> 0)
1216 adapter
->recv_success
++;
1220 TRACE("returning 0x%02x\n", ret
);
1224 static UCHAR
NetBTHangup(void *adapt
, void *sess
)
1226 NetBTSession
*session
= sess
;
1228 TRACE("adapt %p, session %p\n", adapt
, session
);
1230 if (!session
) return NRC_SNUMOUT
;
1232 /* I don't lock the session, because NetBTRecv knows not to decrement
1233 * past 0, so if a receive completes after this it should still deal.
1235 closesocket(session
->fd
);
1236 session
->fd
= INVALID_SOCKET
;
1237 session
->bytesPending
= 0;
1238 session
->cs
.DebugInfo
->Spare
[0] = 0;
1239 DeleteCriticalSection(&session
->cs
);
1240 HeapFree(GetProcessHeap(), 0, session
);
1245 static void NetBTCleanupAdapter(void *adapt
)
1247 TRACE("adapt %p\n", adapt
);
1250 NetBTAdapter
*adapter
= adapt
;
1252 if (adapter
->nameCache
)
1253 NBNameCacheDestroy(adapter
->nameCache
);
1254 HeapFree(GetProcessHeap(), 0, adapt
);
1258 static void NetBTCleanup(void)
1263 NBNameCacheDestroy(gNameCache
);
1268 static UCHAR
NetBTRegisterAdapter(const MIB_IPADDRROW
*ipRow
)
1271 NetBTAdapter
*adapter
;
1273 if (!ipRow
) return NRC_BADDR
;
1275 adapter
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(NetBTAdapter
));
1278 adapter
->ipr
= *ipRow
;
1279 if (!NetBIOSRegisterAdapter(gTransportID
, ipRow
->dwIndex
, adapter
))
1281 NetBTCleanupAdapter(adapter
);
1288 ret
= NRC_OSRESNOTAV
;
1292 /* Callback for NetBIOS adapter enumeration. Assumes closure is a pointer to
1293 * a MIB_IPADDRTABLE containing all the IP adapters needed to be added to the
1294 * NetBIOS adapter table. For each callback, checks if the passed-in adapt
1295 * has an entry in the table; if so, this adapter was enumerated previously,
1296 * and it's enabled. As a flag, the table's dwAddr entry is changed to
1297 * INADDR_LOOPBACK, since this is an invalid address for a NetBT adapter.
1298 * The NetBTEnum function will add any remaining adapters from the
1299 * MIB_IPADDRTABLE to the NetBIOS adapter table.
1301 static BOOL
NetBTEnumCallback(UCHAR totalLANAs
, UCHAR lanaIndex
,
1302 ULONG transport
, const NetBIOSAdapterImpl
*data
, void *closure
)
1305 PMIB_IPADDRTABLE table
= closure
;
1312 for (ndx
= 0; !ret
&& ndx
< table
->dwNumEntries
; ndx
++)
1314 const NetBTAdapter
*adapter
= data
->data
;
1316 if (table
->table
[ndx
].dwIndex
== adapter
->ipr
.dwIndex
)
1318 NetBIOSEnableAdapter(data
->lana
);
1319 table
->table
[ndx
].dwAddr
= INADDR_LOOPBACK
;
1329 /* Enumerates adapters by:
1330 * - retrieving the IP address table for the local machine
1331 * - eliminating loopback addresses from the table
1332 * - eliminating redundant addresses, that is, multiple addresses on the same
1334 * Calls NetBIOSEnumAdapters, passing the resulting table as the callback
1335 * data. The callback reenables each adapter that's already in the NetBIOS
1336 * table. After NetBIOSEnumAdapters returns, this function adds any remaining
1337 * adapters to the NetBIOS table.
1339 static UCHAR
NetBTEnum(void)
1346 if (GetIpAddrTable(NULL
, &size
, FALSE
) == ERROR_INSUFFICIENT_BUFFER
)
1348 PMIB_IPADDRTABLE ipAddrs
, coalesceTable
= NULL
;
1349 DWORD numIPAddrs
= (size
- sizeof(MIB_IPADDRTABLE
)) /
1350 sizeof(MIB_IPADDRROW
) + 1;
1352 ipAddrs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
1354 coalesceTable
= HeapAlloc(GetProcessHeap(),
1355 HEAP_ZERO_MEMORY
, sizeof(MIB_IPADDRTABLE
) +
1356 (min(numIPAddrs
, MAX_LANA
+ 1) - 1) * sizeof(MIB_IPADDRROW
));
1357 if (ipAddrs
&& coalesceTable
)
1359 if (GetIpAddrTable(ipAddrs
, &size
, FALSE
) == ERROR_SUCCESS
)
1363 for (ndx
= 0; ndx
< ipAddrs
->dwNumEntries
; ndx
++)
1365 if ((ipAddrs
->table
[ndx
].dwAddr
&
1366 ipAddrs
->table
[ndx
].dwMask
) !=
1367 htonl((INADDR_LOOPBACK
& IN_CLASSA_NET
)))
1369 BOOL newNetwork
= TRUE
;
1372 /* make sure we don't have more than one entry
1374 for (innerIndex
= 0; newNetwork
&&
1375 innerIndex
< coalesceTable
->dwNumEntries
; innerIndex
++)
1376 if ((ipAddrs
->table
[ndx
].dwAddr
&
1377 ipAddrs
->table
[ndx
].dwMask
) ==
1378 (coalesceTable
->table
[innerIndex
].dwAddr
1379 & coalesceTable
->table
[innerIndex
].dwMask
))
1383 memcpy(&coalesceTable
->table
[
1384 coalesceTable
->dwNumEntries
++],
1385 &ipAddrs
->table
[ndx
], sizeof(MIB_IPADDRROW
));
1389 NetBIOSEnumAdapters(gTransportID
, NetBTEnumCallback
,
1392 for (ndx
= 0; ret
== NRC_GOODRET
&&
1393 ndx
< coalesceTable
->dwNumEntries
; ndx
++)
1394 if (coalesceTable
->table
[ndx
].dwAddr
!= INADDR_LOOPBACK
)
1395 ret
= NetBTRegisterAdapter(&coalesceTable
->table
[ndx
]);
1399 HeapFree(GetProcessHeap(), 0, ipAddrs
);
1400 HeapFree(GetProcessHeap(), 0, coalesceTable
);
1403 ret
= NRC_OSRESNOTAV
;
1407 TRACE("returning 0x%02x\n", ret
);
1411 static const WCHAR VxD_MSTCPW
[] = { 'S','Y','S','T','E','M','\\','C','u','r',
1412 'r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','S','e','r','v',
1413 'i','c','e','s','\\','V','x','D','\\','M','S','T','C','P','\0' };
1414 static const WCHAR NetBT_ParametersW
[] = { 'S','Y','S','T','E','M','\\','C','u',
1415 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\','S','e','r',
1416 'v','i','c','e','s','\\','N','e','t','B','T','\\','P','a','r','a','m','e','t',
1418 static const WCHAR EnableDNSW
[] = { 'E','n','a','b','l','e','D','N','S','\0' };
1419 static const WCHAR BcastNameQueryCountW
[] = { 'B','c','a','s','t','N','a','m',
1420 'e','Q','u','e','r','y','C','o','u','n','t','\0' };
1421 static const WCHAR BcastNameQueryTimeoutW
[] = { 'B','c','a','s','t','N','a','m',
1422 'e','Q','u','e','r','y','T','i','m','e','o','u','t','\0' };
1423 static const WCHAR NameSrvQueryCountW
[] = { 'N','a','m','e','S','r','v',
1424 'Q','u','e','r','y','C','o','u','n','t','\0' };
1425 static const WCHAR NameSrvQueryTimeoutW
[] = { 'N','a','m','e','S','r','v',
1426 'Q','u','e','r','y','T','i','m','e','o','u','t','\0' };
1427 static const WCHAR ScopeIDW
[] = { 'S','c','o','p','e','I','D','\0' };
1428 static const WCHAR CacheTimeoutW
[] = { 'C','a','c','h','e','T','i','m','e','o',
1430 static const WCHAR Config_NetworkW
[] = { 'S','o','f','t','w','a','r','e','\\',
1431 'W','i','n','e','\\','N','e','t','w','o','r','k','\0' };
1433 /* Initializes global variables and registers the NetBT transport */
1434 void NetBTInit(void)
1437 NetBIOSTransport transport
;
1443 gBCastQueries
= BCAST_QUERIES
;
1444 gBCastQueryTimeout
= BCAST_QUERY_TIMEOUT
;
1445 gWINSQueries
= WINS_QUERIES
;
1446 gWINSQueryTimeout
= WINS_QUERY_TIMEOUT
;
1447 gNumWINSServers
= 0;
1448 memset(gWINSServers
, 0, sizeof(gWINSServers
));
1450 gCacheTimeout
= CACHE_TIMEOUT
;
1452 /* Try to open the Win9x NetBT configuration key */
1453 ret
= RegOpenKeyExW(HKEY_LOCAL_MACHINE
, VxD_MSTCPW
, 0, KEY_READ
, &hKey
);
1454 /* If that fails, try the WinNT NetBT configuration key */
1455 if (ret
!= ERROR_SUCCESS
)
1456 ret
= RegOpenKeyExW(HKEY_LOCAL_MACHINE
, NetBT_ParametersW
, 0, KEY_READ
,
1458 if (ret
== ERROR_SUCCESS
)
1462 size
= sizeof(dword
);
1463 if (RegQueryValueExW(hKey
, EnableDNSW
, NULL
, NULL
,
1464 (LPBYTE
)&dword
, &size
) == ERROR_SUCCESS
)
1466 size
= sizeof(dword
);
1467 if (RegQueryValueExW(hKey
, BcastNameQueryCountW
, NULL
, NULL
,
1468 (LPBYTE
)&dword
, &size
) == ERROR_SUCCESS
&& dword
>= MIN_QUERIES
1469 && dword
<= MAX_QUERIES
)
1470 gBCastQueries
= dword
;
1471 size
= sizeof(dword
);
1472 if (RegQueryValueExW(hKey
, BcastNameQueryTimeoutW
, NULL
, NULL
,
1473 (LPBYTE
)&dword
, &size
) == ERROR_SUCCESS
&& dword
>= MIN_QUERY_TIMEOUT
)
1474 gBCastQueryTimeout
= dword
;
1475 size
= sizeof(dword
);
1476 if (RegQueryValueExW(hKey
, NameSrvQueryCountW
, NULL
, NULL
,
1477 (LPBYTE
)&dword
, &size
) == ERROR_SUCCESS
&& dword
>= MIN_QUERIES
1478 && dword
<= MAX_QUERIES
)
1479 gWINSQueries
= dword
;
1480 size
= sizeof(dword
);
1481 if (RegQueryValueExW(hKey
, NameSrvQueryTimeoutW
, NULL
, NULL
,
1482 (LPBYTE
)&dword
, &size
) == ERROR_SUCCESS
&& dword
>= MIN_QUERY_TIMEOUT
)
1483 gWINSQueryTimeout
= dword
;
1484 size
= sizeof(gScopeID
) - 1;
1485 if (RegQueryValueExW(hKey
, ScopeIDW
, NULL
, NULL
, (LPBYTE
)gScopeID
+ 1, &size
)
1488 /* convert into L2-encoded version, suitable for use by
1492 for (ptr
= gScopeID
+ 1; ptr
- gScopeID
< sizeof(gScopeID
) && *ptr
; )
1494 for (lenPtr
= ptr
- 1, *lenPtr
= 0;
1495 ptr
- gScopeID
< sizeof(gScopeID
) && *ptr
&& *ptr
!= '.';
1501 if (RegQueryValueExW(hKey
, CacheTimeoutW
, NULL
, NULL
,
1502 (LPBYTE
)&dword
, &size
) == ERROR_SUCCESS
&& dword
>= MIN_CACHE_TIMEOUT
)
1503 gCacheTimeout
= dword
;
1506 /* WINE-specific NetBT registry settings. Because our adapter naming is
1507 * different than MS', we can't do per-adapter WINS configuration in the
1508 * same place. Just do a global WINS configuration instead.
1510 /* @@ Wine registry key: HKCU\Software\Wine\Network */
1511 if (RegOpenKeyW(HKEY_CURRENT_USER
, Config_NetworkW
, &hKey
) == ERROR_SUCCESS
)
1513 static const char *nsValueNames
[] = { "WinsServer", "BackupWinsServer" };
1517 for (ndx
= 0; ndx
< sizeof(nsValueNames
) / sizeof(nsValueNames
[0]);
1520 size
= sizeof(nsString
) / sizeof(char);
1521 if (RegQueryValueExA(hKey
, nsValueNames
[ndx
], NULL
, NULL
,
1522 (LPBYTE
)nsString
, &size
) == ERROR_SUCCESS
)
1524 unsigned long addr
= inet_addr(nsString
);
1526 if (addr
!= INADDR_NONE
&& gNumWINSServers
< MAX_WINS_SERVERS
)
1527 gWINSServers
[gNumWINSServers
++] = addr
;
1533 transport
.enumerate
= NetBTEnum
;
1534 transport
.astat
= NetBTAstat
;
1535 transport
.findName
= NetBTFindName
;
1536 transport
.call
= NetBTCall
;
1537 transport
.send
= NetBTSend
;
1538 transport
.recv
= NetBTRecv
;
1539 transport
.hangup
= NetBTHangup
;
1540 transport
.cleanupAdapter
= NetBTCleanupAdapter
;
1541 transport
.cleanup
= NetBTCleanup
;
1542 memcpy(&gTransportID
, TRANSPORT_NBT
, sizeof(ULONG
));
1543 NetBIOSRegisterTransport(gTransportID
, &transport
);