src/WINNT/afsd/lanahelper.cpp

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