git.oblomov.eu Git - wine/blob - 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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, (PUCHAR)&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 = 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(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), 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 = (NBNameCacheEntry *)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++] = *(PDWORD)(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(NetBTAdapter *adapter, SOCKET fd, PNCB 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         UCHAR 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 = (NBNameCacheEntry *)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 = (NBNameCacheEntry *)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 = 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, (PUCHAR)&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, (PUCHAR)&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 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 = (NetBTSession *)HeapAlloc(
1047                      GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(NetBTSession));
1048
1049                     if (session)
1050                     {
1051                         session->fd = fd;
1052                         InitializeCriticalSection(&session->cs);
1053                         *sess = session;
1054                     }
1055                     else
1056                     {
1057                         ret = NRC_OSRESNOTAV;
1058                         closesocket(fd);
1059                     }
1060                 }
1061             }
1062             else
1063                 ret = NRC_OSRESNOTAV;
1064         }
1065         else
1066             ret = NRC_NAMERR;
1067     }
1068     TRACE("returning 0x%02x\n", ret);
1069     return ret;
1070 }
1071
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.
1078  */
1079 static UCHAR NetBTSend(void *adapt, void *sess, PNCB ncb)
1080 {
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;
1087
1088     TRACE("adapt %p, session %p, NCB %p\n", adapt, session, ncb);
1089
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;
1095
1096     buffer[0] = NBSS_MSG;
1097     buffer[1] = 0;
1098     NBR_ADDWORD(&buffer[2], ncb->ncb_length);
1099
1100     wsaBufs[0].len = NBSS_HDRSIZE;
1101     wsaBufs[0].buf = buffer;
1102     wsaBufs[1].len = ncb->ncb_length;
1103     wsaBufs[1].buf = ncb->ncb_buffer;
1104
1105     r = WSASend(session->fd, wsaBufs, sizeof(wsaBufs) / sizeof(wsaBufs[0]),
1106      &bytesSent, 0, NULL, NULL);
1107     if (r == SOCKET_ERROR)
1108     {
1109         NetBIOSHangupSession(ncb);
1110         ret = NRC_SABORT;
1111     }
1112     else if (bytesSent < NBSS_HDRSIZE + ncb->ncb_length)
1113     {
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;
1118     }
1119     else
1120     {
1121         ret = NRC_GOODRET;
1122         adapter->xmit_success++;
1123     }
1124     TRACE("returning 0x%02x\n", ret);
1125     return ret;
1126 }
1127
1128 static UCHAR NetBTRecv(void *adapt, void *sess, PNCB ncb)
1129 {
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;
1136
1137     TRACE("adapt %p, session %p, NCB %p\n", adapt, session, ncb);
1138
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;
1144
1145     EnterCriticalSection(&session->cs);
1146     bufferCount = 0;
1147     if (session->bytesPending == 0)
1148     {
1149         bufferCount++;
1150         wsaBufs[0].len = NBSS_HDRSIZE;
1151         wsaBufs[0].buf = buffer;
1152     }
1153     wsaBufs[bufferCount].len = ncb->ncb_length;
1154     wsaBufs[bufferCount].buf = ncb->ncb_buffer;
1155     bufferCount++;
1156
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)
1162     {
1163         LeaveCriticalSection(&session->cs);
1164         ERR("Receive error, WSAGetLastError() returns %d\n", WSAGetLastError());
1165         NetBIOSHangupSession(ncb);
1166         ret = NRC_SABORT;
1167     }
1168     else if (NCB_CANCELLED(ncb))
1169     {
1170         LeaveCriticalSection(&session->cs);
1171         ret = NRC_CMDCAN;
1172     }
1173     else
1174     {
1175         if (bufferCount == 2)
1176         {
1177             if (buffer[0] == NBSS_KEEPALIVE)
1178             {
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;
1185             }
1186             else if (buffer[0] != NBSS_MSG)
1187             {
1188                 LeaveCriticalSection(&session->cs);
1189                 FIXME("Received unexpected session msg type %d\n", buffer[0]);
1190                 NetBIOSHangupSession(ncb);
1191                 ret = NRC_SABORT;
1192             }
1193             else
1194             {
1195                 if (buffer[1] & NBSS_EXTENSION)
1196                 {
1197                     LeaveCriticalSection(&session->cs);
1198                     FIXME("Received a message that's too long for my taste\n");
1199                     NetBIOSHangupSession(ncb);
1200                     ret = NRC_SABORT;
1201                 }
1202                 else
1203                 {
1204                     session->bytesPending = NBSS_HDRSIZE
1205                      + NBR_GETWORD(&buffer[2]) - bytesReceived;
1206                     ncb->ncb_length = bytesReceived - NBSS_HDRSIZE;
1207                     LeaveCriticalSection(&session->cs);
1208                 }
1209             }
1210         }
1211         else
1212         {
1213             if (bytesReceived < session->bytesPending)
1214                 session->bytesPending -= bytesReceived;
1215             else
1216                 session->bytesPending = 0;
1217             LeaveCriticalSection(&session->cs);
1218             ncb->ncb_length = bytesReceived;
1219         }
1220         if (session->bytesPending > 0)
1221             ret = NRC_INCOMP;
1222         else
1223         {
1224             ret = NRC_GOODRET;
1225             adapter->recv_success++;
1226         }
1227     }
1228     TRACE("returning 0x%02x\n", ret);
1229     return ret;
1230 }
1231
1232 static UCHAR NetBTHangup(void *adapt, void *sess)
1233 {
1234     NetBTSession *session = (NetBTSession *)sess;
1235
1236     TRACE("adapt %p, session %p\n", adapt, session);
1237
1238     if (!session) return NRC_SNUMOUT;
1239
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.
1242      */
1243     closesocket(session->fd);
1244     session->fd = INVALID_SOCKET;
1245     session->bytesPending = 0;
1246     DeleteCriticalSection(&session->cs);
1247     HeapFree(GetProcessHeap(), 0, session);
1248
1249     return NRC_GOODRET;
1250 }
1251
1252 static void NetBTCleanupAdapter(void *adapt)
1253 {
1254     TRACE("adapt %p\n", adapt);
1255     if (adapt)
1256     {
1257         NetBTAdapter *adapter = (NetBTAdapter *)adapt;
1258
1259         if (adapter->nameCache)
1260             NBNameCacheDestroy(adapter->nameCache);
1261         HeapFree(GetProcessHeap(), 0, adapt);
1262     }
1263 }
1264
1265 static void NetBTCleanup(void)
1266 {
1267     TRACE("\n");
1268     if (gNameCache)
1269     {
1270         NBNameCacheDestroy(gNameCache);
1271         gNameCache = NULL;
1272     }
1273 }
1274
1275 static UCHAR NetBTRegisterAdapter(PMIB_IPADDRROW ipRow)
1276 {
1277     UCHAR ret;
1278     NetBTAdapter *adapter;
1279
1280     if (!ipRow) return NRC_BADDR;
1281
1282     adapter = (NetBTAdapter *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1283      sizeof(NetBTAdapter));
1284     if (adapter)
1285     {
1286         memcpy(&adapter->ipr, ipRow, sizeof(MIB_IPADDRROW));
1287         if (!NetBIOSRegisterAdapter(gTransportID, ipRow->dwIndex, adapter))
1288         {
1289             NetBTCleanupAdapter(adapter);
1290             ret = NRC_SYSTEM;
1291         }
1292         else
1293             ret = NRC_GOODRET;
1294     }
1295     else
1296         ret = NRC_OSRESNOTAV;
1297     return ret;
1298 }
1299
1300 /* Callback for NetBIOS adapter enumeration.  Assumes closure is a pointer to
1301  * a MIB_IPADDRTABLE containing all the IP adapters needed to be added to the
1302  * NetBIOS adapter table.  For each callback, checks if the passed-in adapt
1303  * has an entry in the table; if so, this adapter was enumerated previously,
1304  * and it's enabled.  As a flag, the table's dwAddr entry is changed to
1305  * INADDR_LOOPBACK, since this is an invalid address for a NetBT adapter.
1306  * The NetBTEnum function will add any remaining adapters from the
1307  * MIB_IPADDRTABLE to the NetBIOS adapter table.
1308  */
1309 static BOOL NetBTEnumCallback(UCHAR totalLANAs, UCHAR lanaIndex,
1310  ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
1311 {
1312     BOOL ret;
1313     PMIB_IPADDRTABLE table = (PMIB_IPADDRTABLE)closure;
1314
1315     if (table && data)
1316     {
1317         DWORD ndx;
1318
1319         ret = FALSE;
1320         for (ndx = 0; !ret && ndx < table->dwNumEntries; ndx++)
1321         {
1322             const NetBTAdapter *adapter = (const NetBTAdapter *)data->data;
1323
1324             if (table->table[ndx].dwIndex == adapter->ipr.dwIndex)
1325             {
1326                 NetBIOSEnableAdapter(data->lana);
1327                 table->table[ndx].dwAddr = INADDR_LOOPBACK;
1328                 ret = TRUE;
1329             }
1330         }
1331     }
1332     else
1333         ret = FALSE;
1334     return ret;
1335 }
1336
1337 /* Enumerates adapters by:
1338  * - retrieving the IP address table for the local machine
1339  * - eliminating loopback addresses from the table
1340  * - eliminating redundant addresses, that is, multiple addresses on the same
1341  *   subnet
1342  * Calls NetBIOSEnumAdapters, passing the resulting table as the callback
1343  * data.  The callback reenables each adapter that's already in the NetBIOS
1344  * table.  After NetBIOSEnumAdapters returns, this function adds any remaining
1345  * adapters to the NetBIOS table.
1346  */
1347 static UCHAR NetBTEnum(void)
1348 {
1349     UCHAR ret;
1350     DWORD size = 0;
1351
1352     TRACE("\n");
1353
1354     if (GetIpAddrTable(NULL, &size, FALSE) == ERROR_INSUFFICIENT_BUFFER)
1355     {
1356         PMIB_IPADDRTABLE ipAddrs, coalesceTable = NULL;
1357         DWORD numIPAddrs = (size - sizeof(MIB_IPADDRTABLE)) /
1358          sizeof(MIB_IPADDRROW) + 1;
1359
1360         ipAddrs = (PMIB_IPADDRTABLE)HeapAlloc(GetProcessHeap(),
1361          HEAP_ZERO_MEMORY, size);
1362         if (ipAddrs)
1363             coalesceTable = (PMIB_IPADDRTABLE)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','\\','W','i','n','e','\\','C','o','n','f','i','g','\\','N','e',
1441  't','w','o','r','k','\0' };
1442
1443 /* Initializes global variables and registers the NetBT transport */
1444 void NetBTInit(void)
1445 {
1446     HKEY hKey;
1447     NetBIOSTransport transport;
1448     LONG ret;
1449
1450     TRACE("\n");
1451
1452     gEnableDNS = TRUE;
1453     gBCastQueries = BCAST_QUERIES;
1454     gBCastQueryTimeout = BCAST_QUERY_TIMEOUT;
1455     gWINSQueries = WINS_QUERIES;
1456     gWINSQueryTimeout = WINS_QUERY_TIMEOUT;
1457     gNumWINSServers = 0;
1458     memset(gWINSServers, 0, sizeof(gWINSServers));
1459     gScopeID[0] = '\0';
1460     gCacheTimeout = CACHE_TIMEOUT;
1461
1462     /* Try to open the Win9x NetBT configuration key */
1463     ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, VxD_MSTCPW, 0, KEY_READ, &hKey);
1464     /* If that fails, try the WinNT NetBT configuration key */
1465     if (ret != ERROR_SUCCESS)
1466         ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, NetBT_ParametersW, 0, KEY_READ,
1467          &hKey);
1468     if (ret == ERROR_SUCCESS)
1469     {
1470         DWORD dword, size;
1471
1472         size = sizeof(dword);
1473         if (RegQueryValueExW(hKey, EnableDNSW, NULL, NULL,
1474          (LPBYTE)&dword, &size) == ERROR_SUCCESS)
1475             gEnableDNS = dword;
1476         size = sizeof(dword);
1477         if (RegQueryValueExW(hKey, BcastNameQueryCountW, NULL, NULL,
1478          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERIES
1479          && dword <= MAX_QUERIES)
1480             gBCastQueries = dword;
1481         size = sizeof(dword);
1482         if (RegQueryValueExW(hKey, BcastNameQueryTimeoutW, NULL, NULL,
1483          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERY_TIMEOUT
1484          && dword <= MAX_QUERY_TIMEOUT)
1485             gBCastQueryTimeout = dword;
1486         size = sizeof(dword);
1487         if (RegQueryValueExW(hKey, NameSrvQueryCountW, NULL, NULL,
1488          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERIES
1489          && dword <= MAX_QUERIES)
1490             gWINSQueries = dword;
1491         size = sizeof(dword);
1492         if (RegQueryValueExW(hKey, NameSrvQueryTimeoutW, NULL, NULL,
1493          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_QUERY_TIMEOUT
1494          && dword <= MAX_QUERY_TIMEOUT)
1495             gWINSQueryTimeout = dword;
1496         size = MAX_DOMAIN_NAME_LEN - 1;
1497         if (RegQueryValueExW(hKey, ScopeIDW, NULL, NULL, gScopeID + 1, &size)
1498          == ERROR_SUCCESS)
1499         {
1500             /* convert into L2-encoded version, suitable for use by
1501                NetBTNameEncode */
1502             char *ptr, *lenPtr;
1503
1504             for (ptr = gScopeID + 1; *ptr &&
1505              ptr - gScopeID < MAX_DOMAIN_NAME_LEN; )
1506             {
1507                 for (lenPtr = ptr - 1, *lenPtr = 0; *ptr && *ptr != '.' &&
1508                  ptr - gScopeID < MAX_DOMAIN_NAME_LEN; ptr++)
1509                     *lenPtr += 1;
1510                 ptr++;
1511             }
1512         }
1513         if (RegQueryValueExW(hKey, CacheTimeoutW, NULL, NULL,
1514          (LPBYTE)&dword, &size) == ERROR_SUCCESS && dword >= MIN_CACHE_TIMEOUT)
1515             gCacheTimeout = dword;
1516         RegCloseKey(hKey);
1517     }
1518     /* WINE-specific NetBT registry settings.  Because our adapter naming is
1519      * different than MS', we can't do per-adapter WINS configuration in the
1520      * same place.  Just do a global WINS configuration instead.
1521      */
1522     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, Config_NetworkW, 0, KEY_READ, &hKey)
1523      == ERROR_SUCCESS)
1524     {
1525         static const char *nsValueNames[] = { "WinsServer", "BackupWinsServer" };
1526         char nsString[16];
1527         DWORD size, ndx;
1528
1529         for (ndx = 0; ndx < sizeof(nsValueNames) / sizeof(nsValueNames[0]);
1530          ndx++)
1531         {
1532             size = sizeof(nsString) / sizeof(char);
1533             if (RegQueryValueExA(hKey, nsValueNames[ndx], NULL, NULL,
1534              (LPBYTE)nsString, &size) == ERROR_SUCCESS)
1535             {
1536                 unsigned long addr = inet_addr(nsString);
1537
1538                 if (addr != INADDR_NONE && gNumWINSServers < MAX_WINS_SERVERS)
1539                     gWINSServers[gNumWINSServers++] = addr;
1540             }
1541         }
1542         RegCloseKey(hKey);
1543     }
1544
1545     transport.enumerate      = NetBTEnum;
1546     transport.astat          = NetBTAstat;
1547     transport.findName       = NetBTFindName;
1548     transport.call           = NetBTCall;
1549     transport.send           = NetBTSend;
1550     transport.recv           = NetBTRecv;
1551     transport.hangup         = NetBTHangup;
1552     transport.cleanupAdapter = NetBTCleanupAdapter;
1553     transport.cleanup        = NetBTCleanup;
1554     memcpy(&gTransportID, TRANSPORT_NBT, sizeof(ULONG));
1555     NetBIOSRegisterTransport(gTransportID, &transport);
1556 }