src/WINNT/afsd/lanahelper.cpp

   1 /*
   2
   3 Copyright 2004 by the Massachusetts Institute of Technology
   4
   5 All rights reserved.
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the name of the Massachusetts
  12 Institute of Technology (M.I.T.) not be used in advertising or publicity
  13 pertaining to distribution of the software without specific, written
  14 prior permission.
  15
  16 M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  17 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  18 M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  19 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  22 SOFTWARE.
  23
  24 */
  25
  26 #include <windows.h>
  27 #include <winreg.h>
  28 #include <nb30.h>
  29 #include <tchar.h>
  30 #include <shellapi.h>
  31 #include <objbase.h>
  32 #include <shlobj.h>
  33 #include <wtypes.h>
  34 #include <string.h>
  35 #include <malloc.h>
  36 #include <stdio.h>
  37 #include <lanahelper.h>
  38
  39 #define NOLOGGING
  40 #ifndef NOLOGGING
  41 extern "C" {
  42 #include <stdarg.h>
  43
  44     void afsi_log(TCHAR *p, ...) {
  45         va_list marker;
  46         TCHAR buffer[200];
  47
  48         va_start(marker,p);
  49         _vstprintf(buffer,p,marker);
  50         va_end(marker);
  51         _tcscat(buffer,_T("\n"));
  52
  53         OutputDebugString(buffer);
  54     }
  55 }
  56 #endif
  57
  58 static const char *szAFSConfigKeyName = "SYSTEM\\CurrentControlSet\\Services\\TransarcAFSDaemon\\Parameters";
  59 static const char *szNetbiosNameValue = "NetbiosName";
  60 static const char *szIsGatewayValue = "IsGateway";
  61 static const char *szLanAdapterValue = "LanAdapter";
  62 static const char *szNoFindLanaByName = "NoFindLanaByName";
  63
  64 // Use the IShellFolder API to get the connection name for the given Guid.
  65 static HRESULT lana_ShellGetNameFromGuidW(WCHAR *wGuid, WCHAR *wName, int NameSize)
  66 {
  67     // This is the GUID for the network connections folder. It is constant.
  68     // {7007ACC7-3202-11D1-AAD2-00805FC1270E}
  69     const GUID CLSID_NetworkConnections = {
  70         0x7007ACC7, 0x3202, 0x11D1, {
  71             0xAA, 0xD2, 0x00, 0x80, 0x5F, 0xC1, 0x27, 0x0E
  72         }
  73     };
  74     LPITEMIDLIST pidl;
  75     IShellFolder *pShellFolder;
  76     IMalloc *pShellMalloc;
  77
  78     // Build the display name in the form "::{GUID}".
  79     if (wcslen(wGuid) >= MAX_PATH)
  80         return E_INVALIDARG;
  81     WCHAR szAdapterGuid[MAX_PATH + 2];
  82     swprintf(szAdapterGuid, L"::%ls", wGuid);
  83
  84     // Initialize COM.
  85     CoInitialize(NULL);
  86
  87     // Get the shell allocator.
  88     HRESULT hr = SHGetMalloc(&pShellMalloc);
  89     if (SUCCEEDED(hr))
  90     {
  91         // Create an instance of the network connections folder.
  92         hr = CoCreateInstance(CLSID_NetworkConnections, NULL,
  93                               CLSCTX_INPROC_SERVER, IID_IShellFolder,
  94                               reinterpret_cast<LPVOID *>(&pShellFolder));
  95     }
  96     if (SUCCEEDED(hr))
  97     {
  98         hr = pShellFolder->ParseDisplayName(NULL, NULL, szAdapterGuid, NULL,
  99                                             &pidl, NULL);
 100     }
 101     if (SUCCEEDED(hr)) {
 102         // Get the display name; this returns the friendly name.
 103         STRRET sName;
 104         hr = pShellFolder->GetDisplayNameOf(pidl, SHGDN_NORMAL, &sName);
 105         if (SUCCEEDED(hr))
 106             wcsncpy(wName, sName.pOleStr, NameSize);
 107         pShellMalloc->Free(pidl);
 108     }
 109
 110     CoUninitialize();
 111     return hr;
 112 }
 113
 114 // Get the Connection Name for the given GUID.
 115 extern "C" int lana_GetNameFromGuid(char *Guid, char **Name)
 116 {
 117     typedef HRESULT (WINAPI *HrLanProcAddr)(GUID *, PCWSTR, PWSTR, LPDWORD);
 118     HrLanProcAddr HrLanProc = NULL;
 119     HMODULE hNetMan;
 120     int size;
 121     WCHAR *wGuid = NULL;
 122     WCHAR wName[MAX_PATH];
 123     DWORD NameSize = MAX_PATH;
 124     char *name = NULL;
 125     HRESULT status;
 126
 127     // Convert the Guid string to Unicode.  First we ask only for the size
 128     // of the converted string.  Then we allocate a buffer of sufficient
 129     // size to hold the result of the conversion.
 130     size = MultiByteToWideChar(CP_ACP, 0, Guid, -1, NULL, 0);
 131     wGuid = (WCHAR *) malloc(size * sizeof(WCHAR));
 132     MultiByteToWideChar(CP_ACP, 0, Guid, -1, wGuid, size);
 133
 134     // First try the IShellFolder interface, which was unimplemented
 135     // for the network connections folder before XP.
 136
 137     /* XXX pbh 9/11/03 - revert to using the undocumented APIs on XP while
 138      *   waiting to hear back from PSS about the slow reboot issue.
 139      *   This is an ugly, misleading hack, but is minimally invasive
 140      *   and will be easy to rollback.
 141      */
 142
 143     //status = getname_shellfolder(wGuid, wName, NameSize);
 144     status = E_NOTIMPL;
 145
 146     /* XXX end of pbh 9/11/03 temporary hack*/
 147
 148     if (status == E_NOTIMPL) {
 149         // The IShellFolder interface is not implemented on this platform.
 150         // Try the (undocumented) HrLanConnectionNameFromGuidOrPath API
 151         // from the netman DLL.
 152 #ifndef NOLOGGING
 153         afsi_log("IShellFolder API not implemented, trying HrLanConnectionNameFromGuidOrPath");
 154 #endif
 155         hNetMan = LoadLibrary("netman.dll");
 156         if (hNetMan == NULL) {
 157             free(wGuid);
 158             return -1;
 159         }
 160         /* Super Secret Microsoft Call */
 161         HrLanProc = (HrLanProcAddr) GetProcAddress(hNetMan,
 162                                                    "HrLanConnectionNameFromGuidOrPath");
 163         if (HrLanProc == NULL) {
 164             FreeLibrary(hNetMan);
 165             free(wGuid);
 166             return -1;
 167         }
 168         status = HrLanProc(NULL, wGuid, wName, &NameSize);
 169         FreeLibrary(hNetMan);
 170     }
 171     free(wGuid);
 172     if (FAILED(status)) {
 173 #ifndef NOLOGGING
 174         afsi_log("lana_GetNameFromGuid: failed to get connection name (status %ld)",
 175                  status);
 176 #endif
 177         return -1;
 178     }
 179
 180     // Get the required buffer size, and then convert the string.
 181     size = WideCharToMultiByte(CP_ACP, 0, wName, -1, NULL, 0, NULL, NULL);
 182     name = (char *) malloc(size);
 183     if (name == NULL)
 184         return -1;
 185     WideCharToMultiByte(CP_ACP, 0, wName, -1, name, size, NULL, NULL);
 186 #ifndef NOLOGGING
 187     afsi_log("Connection name for %s is '%s'", Guid, name);
 188 #endif
 189     if (*Name)
 190         *Name = name;
 191     else
 192         free(name);
 193     return 0;
 194 }
 195
 196 // Return an array of LANAINFOs corresponding to a connection named LanaName
 197 // (NULL LanaName matches all connections), and has an IPv4 binding. Returns
 198 // NULL if something goes wrong.
 199 // NOTE: caller must free the returned block if non NULL.
 200 extern "C" LANAINFO * lana_FindLanaByName(const char *LanaName)
 201 {
 202     const char RegNetBiosLinkageKeyName[] =
 203         "System\\CurrentControlSet\\Services\\NetBios\\Linkage";
 204     HKEY hkey;
 205     LONG status;
 206     struct {
 207         BYTE flags;
 208         BYTE number;
 209     } lanamap[MAX_LANA+1];
 210     DWORD lanamapsize = sizeof(lanamap);
 211     DWORD type;
 212     char *bindpaths = NULL;
 213     DWORD bindpathsize;
 214     int nlana;
 215     int i;
 216     char *guid;
 217     char *name;
 218     char *pBind;
 219     char *p;
 220
 221     LANAINFO * lanainfo;
 222
 223     // Open the NetBios Linkage key.
 224     status = RegOpenKeyEx(HKEY_LOCAL_MACHINE, RegNetBiosLinkageKeyName, 0,
 225                           KEY_QUERY_VALUE, &hkey);
 226
 227     if (status != ERROR_SUCCESS) {
 228 #ifndef NOLOGGING
 229         afsi_log("Failed to open NetBios Linkage key (status %ld)", status);
 230 #endif
 231         return NULL;
 232     }
 233
 234     // Read the lana map.
 235     status = RegQueryValueEx(hkey, "LanaMap", 0, &type,
 236                          (BYTE *) &lanamap, &lanamapsize);
 237     if (status != ERROR_SUCCESS) {
 238 #ifndef NOLOGGING
 239         afsi_log("Failed to read LanaMap (status %ld)", status);
 240 #endif
 241         RegCloseKey(hkey);
 242         return NULL;
 243     }
 244     if (lanamapsize == 0) {
 245 #ifndef NOLOGGING
 246         afsi_log("No data in LanaMap");
 247 #endif
 248         return NULL;
 249     }
 250     nlana = lanamapsize / sizeof(lanamap[0]);
 251
 252     // Get the bind paths for NetBios so we can match them up
 253     // with the lana map.  First we query for the size, so we
 254     // can allocate an appropriate buffer.
 255     status = RegQueryValueEx(hkey, "Bind", 0, &type, NULL, &bindpathsize);
 256     if (status == ERROR_SUCCESS && bindpathsize != 0) {
 257         bindpaths = (char *) malloc(bindpathsize * sizeof(char));
 258         if (bindpaths == NULL) {
 259 #ifndef NOLOGGING
 260             afsi_log("Cannot allocate %ld bytes for bindpaths", bindpathsize);
 261 #endif
 262             RegCloseKey(hkey);
 263             return NULL;
 264         }
 265         status = RegQueryValueEx(hkey, "Bind", 0, &type,
 266                                  (BYTE *) bindpaths, &bindpathsize);
 267     }
 268     RegCloseKey(hkey);
 269     if (status != ERROR_SUCCESS) {
 270 #ifndef NOLOGGING
 271         afsi_log("Failed to read bind paths (status %ld)", status);
 272 #endif
 273         if (bindpaths != NULL)
 274             free(bindpaths);
 275         return NULL;
 276       }
 277     if (bindpathsize == 0) {
 278 #ifndef NOLOGGING
 279         afsi_log("No bindpath data");
 280 #endif
 281         if (bindpaths != NULL)
 282             free(bindpaths);
 283         return NULL;
 284     }
 285
 286     if (LanaName)
 287     {
 288         lanainfo = (LANAINFO *) malloc(sizeof(LANAINFO)*2);
 289         if(lanainfo == NULL) {
 290             free(bindpaths);
 291             return NULL;
 292         }
 293         memset(lanainfo, 0, sizeof(LANAINFO) * 2);
 294         lanainfo[0].lana_number = LANA_INVALID;
 295     }
 296     else
 297     {
 298         lanainfo = (LANAINFO *) malloc(sizeof(LANAINFO)*(nlana+1));
 299         if(lanainfo == NULL) {
 300             free(bindpaths);
 301             return NULL;
 302         }
 303         memset(lanainfo, 0, sizeof(LANAINFO) * (nlana+1));
 304     }
 305
 306     int index = 0;
 307
 308     // Iterate over the lana map entries and bind paths.
 309     for (i = 0, pBind = bindpaths; i < nlana;
 310          i++, pBind += strlen(pBind) + 1) {
 311         // Ignore an invalid map entry.
 312         if ((lanamap[i].flags & 1) == 0)
 313             continue;
 314
 315                 // check for an IPv4 binding
 316                 if(!strstr(pBind,"_Tcpip_"))
 317                         continue;
 318
 319         // Find the beginning of the GUID.
 320         guid = strchr(pBind, '{');
 321         if (guid == NULL)
 322             continue;                   // Malformed path entry?
 323         guid = strdup(guid);
 324         if (guid == NULL)
 325             continue;
 326         // Find the end of the GUID.
 327         p = strchr(guid, '}');
 328         if (p == NULL) {
 329             free(guid);                 // Malformed GUID?
 330             continue;
 331         }
 332         *++p = '\0';                    // Ignore anything after the GUID.
 333         status = lana_GetNameFromGuid(guid, &name);
 334         free(guid);
 335
 336         if (status == 0 && name != 0)
 337         {
 338             if (LanaName)
 339             {
 340                 if (strcmp(name, LanaName) ==0)
 341                 {
 342                     lanainfo[index].lana_number = lanamap[i].number;
 343                     _tcscpy(lanainfo[index].lana_name, name);
 344                     free(name);
 345                     index++;
 346                     break;
 347                 }
 348             }
 349             else
 350             {
 351                 lanainfo[index].lana_number = lanamap[i].number;
 352                 _tcscpy(lanainfo[index].lana_name, name);
 353                 free(name);
 354                 index++;
 355             }
 356         }
 357     }
 358
 359     lanainfo[index].lana_number = LANA_INVALID;
 360
 361     free(bindpaths);
 362     return lanainfo;
 363 }
 364
 365 extern "C" lana_number_t lana_FindLoopback(void)
 366 {
 367     NCB ncb;
 368     LANA_ENUM lana_list;
 369     int status;
 370     int i;
 371
 372     memset(&ncb, 0, sizeof(ncb));
 373     ncb.ncb_command = NCBENUM;
 374     ncb.ncb_buffer = (UCHAR *) &lana_list;
 375     ncb.ncb_length = sizeof(lana_list);
 376     status = Netbios(&ncb);
 377     if (status != 0) {
 378 #ifndef NOLOGGING
 379         afsi_log("Netbios NCBENUM failed: status %ld", status);
 380 #endif
 381         return LANA_INVALID;
 382     }
 383     for (i = 0; i < lana_list.length; i++) {
 384         if (lana_IsLoopback(lana_list.lana[i])) {
 385             // Found one, return it.
 386 #ifndef NOLOGGING
 387             afsi_log("lana_FindLoopback: Found LAN adapter %d",
 388                      lana_list.lana[i]);
 389 #endif
 390             return lana_list.lana[i];
 391         }
 392     }
 393     // Could not find a loopback adapter.
 394     return LANA_INVALID;
 395 }
 396
 397 /* Returns TRUE if all adapters are loopback adapters */
 398 extern "C" BOOL lana_OnlyLoopback(void)
 399 {
 400     NCB ncb;
 401     LANA_ENUM lana_list;
 402     int status;
 403     int i;
 404
 405     memset(&ncb, 0, sizeof(ncb));
 406     ncb.ncb_command = NCBENUM;
 407     ncb.ncb_buffer = (UCHAR *) &lana_list;
 408     ncb.ncb_length = sizeof(lana_list);
 409     status = Netbios(&ncb);
 410     if (status != 0) {
 411 #ifndef NOLOGGING
 412         afsi_log("Netbios NCBENUM failed: status %ld", status);
 413 #endif
 414         return FALSE;
 415     }
 416     for (i = 0; i < lana_list.length; i++) {
 417         if (!lana_IsLoopback(lana_list.lana[i])) {
 418             // Found one non-Loopback adapter
 419             return FALSE;
 420         }
 421     }
 422     // All adapters are loopback
 423     return TRUE;
 424 }
 425
 426 // Is the given lana a Windows Loopback Adapter?
 427 // TODO: implement a better check for loopback
 428 // TODO: also check for proper bindings (IPv4)
 429 extern "C" BOOL lana_IsLoopback(lana_number_t lana)
 430 {
 431     NCB ncb;
 432     struct {
 433         ADAPTER_STATUS status;
 434         NAME_BUFFER names[MAX_LANA+1];
 435     } astat;
 436     unsigned char kWLA_MAC[6] = { 0x02, 0x00, 0x4c, 0x4f, 0x4f, 0x50 };
 437     int status;
 438
 439     // Reset the adapter: in Win32, this is required for every process, and
 440     // acts as an init call, not as a real hardware reset.
 441     memset(&ncb, 0, sizeof(ncb));
 442     ncb.ncb_command = NCBRESET;
 443     ncb.ncb_callname[0] = 100;
 444     ncb.ncb_callname[2] = 100;
 445     ncb.ncb_lana_num = lana;
 446     status = Netbios(&ncb);
 447     if (status == 0)
 448         status = ncb.ncb_retcode;
 449     if (status != 0) {
 450 #ifndef NOLOGGING
 451        afsi_log("NCBRESET failed: lana %u, status %ld", lana, status);
 452 #endif
 453         return FALSE;
 454     }
 455
 456     // Use the NCBASTAT command to get the adapter address.
 457     memset(&ncb, 0, sizeof(ncb));
 458     ncb.ncb_command = NCBASTAT;
 459     ncb.ncb_lana_num = lana;
 460     strcpy((char *) ncb.ncb_callname, "*               ");
 461     ncb.ncb_buffer = (UCHAR *) &astat;
 462     ncb.ncb_length = sizeof(astat);
 463     status = Netbios(&ncb);
 464     if (status == 0)
 465         status = ncb.ncb_retcode;
 466     if (ncb.ncb_retcode != 0) {
 467 #ifndef NOLOGGING
 468         afsi_log("NCBASTAT failed: lana %u, status %ld", lana, status);
 469 #endif
 470         return FALSE;
 471     }
 472     return (memcmp(astat.status.adapter_address, kWLA_MAC, 6) == 0);
 473 }
 474
 475 // Get the netbios named used/to-be-used by the AFS SMB server.
 476 // IF <lana specified> THEN
 477 //     Use specified lana
 478 // ELSE
 479 //         Look for an adapter named "AFS", failing which,
 480 //     look for a loopback adapter.
 481 // ENDIF
 482 // IF lana is for a loopback && !IsGateway THEN
 483 //    IF netbios name is specified THEN
 484 //       use specified netbios name
 485 //    ELSE
 486 //       use "AFS"
 487 //    ENDIF
 488 // ELSE
 489 //    use netbios name "<hostname>-AFS"
 490 // ENDIF
 491 // Return ERROR_SUCCESS if netbios name was successfully generated.
 492 // Returns the lana number to use in *pLana (if pLana is non-NULL) and also
 493 //         the IsGateway setting in *pIsGateway (if pIsGateway is non-NULL).
 494 //         the type of name returned.
 495 //
 496 // buffer is assumed to hold at least MAX_NB_NAME_LENGTH bytes.
 497 //
 498 // flags :
 499 //        LANA_NETBIOS_NAME_IN : Use the values of *pLana and *pIsGateway as [in] parameters.
 500 //        LANA_NETBIOS_NAME_SUFFIX : Only return the suffix of netbios name
 501 //                LANA_NETBIOS_NAME_FULL : Return full netbios name
 502 extern "C" long lana_GetUncServerNameEx(char *buffer, lana_number_t * pLana, int * pIsGateway, int flags) {
 503     HKEY hkConfig;
 504         DWORD dummyLen;
 505         LONG rv;
 506         int regLana;
 507         int regGateway, regNoFindLanaByName;
 508         TCHAR regNbName[MAX_NB_NAME_LENGTH];
 509         TCHAR nbName[MAX_NB_NAME_LENGTH];
 510         TCHAR hostname[MAX_COMPUTERNAME_LENGTH+1];
 511
 512         rv = RegOpenKeyEx(HKEY_LOCAL_MACHINE,szAFSConfigKeyName,0,KEY_READ,&hkConfig);
 513         if(rv == ERROR_SUCCESS) {
 514                 if(!(flags & LANA_NETBIOS_NAME_IN) || !pLana) {
 515                         dummyLen = sizeof(regLana);
 516                         rv = RegQueryValueEx(hkConfig, szLanAdapterValue, NULL, NULL, (LPBYTE) &regLana, &dummyLen);
 517                         if(rv != ERROR_SUCCESS) regLana = -1;
 518                 } else
 519                         regLana = *pLana;
 520
 521                 if(!(flags & LANA_NETBIOS_NAME_IN) || !pIsGateway) {
 522                         dummyLen = sizeof(regGateway);
 523                         rv = RegQueryValueEx(hkConfig, szIsGatewayValue, NULL, NULL, (LPBYTE) &regGateway, &dummyLen);
 524                         if(rv != ERROR_SUCCESS) regGateway = 0;
 525                 } else
 526                         regGateway = *pIsGateway;
 527
 528                 dummyLen = sizeof(regNoFindLanaByName);
 529                 rv = RegQueryValueEx(hkConfig, szNoFindLanaByName, NULL, NULL, (LPBYTE) &regNoFindLanaByName, &dummyLen);
 530                 if(rv != ERROR_SUCCESS) regNoFindLanaByName = 0;
 531
 532                 // Do not care if the call fails for insufficient buffer size.  We are not interested
 533                 // in netbios names over 15 chars.
 534                 dummyLen = sizeof(regNbName);
 535                 rv = RegQueryValueEx(hkConfig, szNetbiosNameValue, NULL, NULL, (LPBYTE) &regNbName, &dummyLen);
 536                 if(rv != ERROR_SUCCESS) regNbName[0] = 0;
 537                 else regNbName[15] = 0;
 538
 539                 RegCloseKey(hkConfig);
 540         } else {
 541                 if(flags & LANA_NETBIOS_NAME_IN) {
 542                         regLana = (pLana)? *pLana: -1;
 543                         regGateway = (pIsGateway)? *pIsGateway: 0;
 544                 } else {
 545                         regLana = -1;
 546                         regGateway = 0;
 547                 }
 548         regNoFindLanaByName = 0;
 549                 regNbName[0] = 0;
 550         }
 551
 552     if(regLana < 0 || regLana > MAX_LANA)
 553         regLana = -1;
 554
 555         if(regLana == -1) {
 556                 LANAINFO *lanaInfo = NULL;
 557         int nLana = LANA_INVALID;
 558
 559         if (!regNoFindLanaByName)
 560             lanaInfo = lana_FindLanaByName("AFS");
 561                 if(lanaInfo != NULL) {
 562             nLana = lanaInfo[0].lana_number;
 563                         free(lanaInfo);
 564                 } else
 565                         nLana = LANA_INVALID;
 566
 567                 if(nLana == LANA_INVALID && !regGateway) {
 568                         nLana = lana_FindLoopback();
 569                 }
 570                 if(nLana != LANA_INVALID)
 571             regLana = nLana;
 572         }
 573
 574         if(regNbName[0] &&
 575        (regLana >=0 && lana_IsLoopback((lana_number_t) regLana))) {
 576         strncpy(nbName,regNbName,15);
 577         nbName[16] = 0;
 578         strupr(nbName);
 579         } else {
 580                 char * dot;
 581
 582                 if(flags & LANA_NETBIOS_NAME_SUFFIX) {
 583                         strcpy(nbName,"-AFS");
 584                 } else {
 585                         dummyLen = sizeof(hostname);
 586                         // assume we are not a cluster.
 587                         rv = GetComputerName(hostname, &dummyLen);
 588                         if(!SUCCEEDED(rv)) { // should not happen, but...
 589                                 return rv;
 590                         }
 591                         strncpy(nbName, hostname, 11);
 592                         nbName[11] = 0;
 593                         if(dot = strchr(nbName,'.'))
 594                                 *dot = 0;
 595                         strcat(nbName,"-AFS");
 596                 }
 597         }
 598
 599         if(pLana) *pLana = regLana;
 600         if(pIsGateway) *pIsGateway = regGateway;
 601
 602         strcpy(buffer, nbName);
 603
 604         return ERROR_SUCCESS;
 605 }
 606
 607 extern "C" void lana_GetUncServerNameDynamic(int lanaNumber, BOOL isGateway, TCHAR *name, int type) {
 608         char szName[MAX_NB_NAME_LENGTH];
 609         lana_number_t lana = (lana_number_t) lanaNumber;
 610         int gateway = (int) isGateway;
 611
 612         if(SUCCEEDED(lana_GetUncServerNameEx(szName, &lana, &gateway, LANA_NETBIOS_NAME_IN | type))) {
 613 #ifdef _UNICODE
 614                 mbswcs(name,szName,MAX_NB_NAME_LENGTH);
 615 #else
 616                 strncpy(name,szName,MAX_NB_NAME_LENGTH);
 617 #endif
 618         } else
 619                 *name = _T('\0');
 620 }
 621
 622 extern "C" void lana_GetUncServerName(TCHAR *name, int type) {
 623         char szName[MAX_NB_NAME_LENGTH];
 624
 625         if(SUCCEEDED(lana_GetUncServerNameEx(szName,NULL,NULL,type))) {
 626 #ifdef _UNICODE
 627                 mbswcs(name,szName,MAX_NB_NAME_LENGTH);
 628 #else
 629                 strncpy(name,szName,MAX_NB_NAME_LENGTH);
 630 #endif
 631         } else {
 632         *name = _T('\0');
 633         }
 634 }
 635
 636 extern "C" void lana_GetAfsNameString(int lanaNumber, BOOL isGateway, TCHAR* name)
 637 {
 638     TCHAR netbiosName[32];
 639     lana_GetUncServerNameDynamic(lanaNumber, isGateway, netbiosName, LANA_NETBIOS_NAME_FULL);
 640     _stprintf(name, _T("Your UNC name to reach the root of AFS is \\\\%s\\all"), netbiosName);
 641 }
 642
 643 extern "C" void lana_GetNetbiosName(LPTSTR pszName, int type)
 644 {
 645         HKEY hkCfg;
 646     TCHAR name[MAX_NB_NAME_LENGTH];
 647         DWORD dummyLen;
 648
 649     memset(name, 0, sizeof(name));
 650     if (GetVersion() >= 0x80000000) // not WindowsNT
 651     {
 652         if (type == LANA_NETBIOS_NAME_SUFFIX)
 653         {
 654             _tcscpy(pszName, TEXT("-afs"));
 655             return;
 656         }
 657
 658                 if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,szAFSConfigKeyName,0,KEY_READ,&hkCfg) == ERROR_SUCCESS) {
 659                         dummyLen = sizeof(name);
 660                         if(RegQueryValueEx(hkCfg,TEXT("Gateway"),NULL,NULL,(LPBYTE) name,&dummyLen) == ERROR_SUCCESS)
 661                                 name[0] = _T('\0');
 662                         RegCloseKey(hkCfg);
 663                 }
 664
 665         if (_tcslen(name) == 0)
 666         {
 667             _tcscpy(pszName, TEXT("unknown"));
 668             return;
 669         }
 670
 671                 _tcscpy(pszName, name);
 672         _tcscat(pszName, TEXT("-afs"));
 673         return;
 674     }
 675
 676     lana_GetUncServerName(name,type);
 677         _tcslwr(name);
 678     _tcscpy(pszName, name);
 679     return;
 680 }
 681