reactos/dll/win32/netapi32/wksta.c

   1 /* Copyright 2002 Andriy Palamarchuk
   2  * Copyright (c) 2003 Juan Lang
   3  *
   4  * netapi32 user functions
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "netapi32.h"
  22
  23 #include <lmwksta.h>
  24 #include <lmjoin.h>
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(netapi32);
  27
  28 /************************************************************
  29  *                NETAPI_IsLocalComputer
  30  *
  31  * Checks whether the server name indicates local machine.
  32  */
  33 DECLSPEC_HIDDEN BOOL NETAPI_IsLocalComputer( LMCSTR name )
  34 {
  35     WCHAR buf[MAX_COMPUTERNAME_LENGTH + 1];
  36     DWORD size = sizeof(buf) / sizeof(buf[0]);
  37     BOOL ret;
  38
  39     if (!name || !name[0]) return TRUE;
  40
  41     ret = GetComputerNameW( buf,  &size );
  42     if (ret && name[0] == '\\' && name[1] == '\\') name += 2;
  43     return ret && !strcmpiW( name, buf );
  44 }
  45
  46 static void wprint_mac(WCHAR* buffer, int len, const MIB_IFROW *ifRow)
  47 {
  48     int i;
  49     unsigned char val;
  50
  51     if (!buffer)
  52         return;
  53     if (len < 1)
  54         return;
  55     if (!ifRow)
  56     {
  57         *buffer = '\0';
  58         return;
  59     }
  60
  61     for (i = 0; i < ifRow->dwPhysAddrLen && 2 * i < len; i++)
  62     {
  63         val = ifRow->bPhysAddr[i];
  64         if ((val >>4) >9)
  65             buffer[2*i] = (WCHAR)((val >>4) + 'A' - 10);
  66         else
  67             buffer[2*i] = (WCHAR)((val >>4) + '0');
  68         if ((val & 0xf ) >9)
  69             buffer[2*i+1] = (WCHAR)((val & 0xf) + 'A' - 10);
  70         else
  71             buffer[2*i+1] = (WCHAR)((val & 0xf) + '0');
  72     }
  73     buffer[2*i]=0;
  74 }
  75
  76 /* Theoretically this could be too short, except that MS defines
  77  * MAX_ADAPTER_NAME as 128, and MAX_INTERFACE_NAME_LEN as 256, and both
  78  * represent a count of WCHARs, so even with an extraordinarily long header
  79  * this will be plenty
  80  */
  81 #define MAX_TRANSPORT_NAME MAX_INTERFACE_NAME_LEN
  82 #define MAX_TRANSPORT_ADDR 13
  83
  84 #define NBT_TRANSPORT_NAME_HEADER "\\Device\\NetBT_Tcpip_"
  85 #define UNKNOWN_TRANSPORT_NAME_HEADER "\\Device\\UnknownTransport_"
  86
  87 static void wprint_name(WCHAR *buffer, int len, ULONG transport,
  88  PMIB_IFROW ifRow)
  89 {
  90     WCHAR *ptr1, *ptr2;
  91     const char *name;
  92
  93     if (!buffer)
  94         return;
  95     if (!ifRow)
  96     {
  97         *buffer = '\0';
  98         return;
  99     }
 100
 101     if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
 102         name = NBT_TRANSPORT_NAME_HEADER;
 103     else
 104         name = UNKNOWN_TRANSPORT_NAME_HEADER;
 105
 106     for (ptr1 = buffer; *name && ptr1 < buffer + len; ptr1++, name++)
 107         *ptr1 = *name;
 108     for (ptr2 = ifRow->wszName; *ptr2 && ptr1 < buffer + len; ptr1++, ptr2++)
 109         *ptr1 = *ptr2;
 110     *ptr1 = '\0';
 111 }
 112
 113 /***********************************************************************
 114  *                NetWkstaTransportEnum  (NETAPI32.@)
 115  */
 116
 117 struct WkstaTransportEnumData
 118 {
 119     UCHAR          n_adapt;
 120     UCHAR          n_read;
 121     DWORD          prefmaxlen;
 122     LPBYTE        *pbuf;
 123     NET_API_STATUS ret;
 124 };
 125
 126 /**********************************************************************/
 127
 128 static BOOL WkstaEnumAdaptersCallback(UCHAR totalLANAs, UCHAR lanaIndex,
 129  ULONG transport, const NetBIOSAdapterImpl *data, void *closure)
 130 {
 131     BOOL ret;
 132     struct WkstaTransportEnumData *enumData = closure;
 133
 134     if (enumData && enumData->pbuf)
 135     {
 136         if (lanaIndex == 0)
 137         {
 138             DWORD toAllocate;
 139
 140             enumData->n_adapt = totalLANAs;
 141             enumData->n_read = 0;
 142
 143             toAllocate = totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0)
 144              + MAX_TRANSPORT_NAME * sizeof(WCHAR) +
 145              MAX_TRANSPORT_ADDR * sizeof(WCHAR));
 146             if (enumData->prefmaxlen != MAX_PREFERRED_LENGTH)
 147                 toAllocate = enumData->prefmaxlen;
 148             NetApiBufferAllocate(toAllocate, (LPVOID *)enumData->pbuf);
 149         }
 150         if (*(enumData->pbuf))
 151         {
 152             UCHAR spaceFor;
 153
 154             if (enumData->prefmaxlen == MAX_PREFERRED_LENGTH)
 155                 spaceFor = totalLANAs;
 156             else
 157                 spaceFor = enumData->prefmaxlen /
 158                  (sizeof(WKSTA_TRANSPORT_INFO_0) + (MAX_TRANSPORT_NAME +
 159                  MAX_TRANSPORT_ADDR) * sizeof(WCHAR));
 160             if (enumData->n_read < spaceFor)
 161             {
 162                 PWKSTA_TRANSPORT_INFO_0 ti;
 163                 LMSTR transport_name, transport_addr;
 164                 MIB_IFROW ifRow;
 165
 166                 ti = (PWKSTA_TRANSPORT_INFO_0)(*(enumData->pbuf) +
 167                  enumData->n_read * sizeof(WKSTA_TRANSPORT_INFO_0));
 168                 transport_name = (LMSTR)(*(enumData->pbuf) +
 169                  totalLANAs * sizeof(WKSTA_TRANSPORT_INFO_0) +
 170                  enumData->n_read * MAX_TRANSPORT_NAME * sizeof(WCHAR));
 171                 transport_addr = (LMSTR)(*(enumData->pbuf) +
 172                  totalLANAs * (sizeof(WKSTA_TRANSPORT_INFO_0) +
 173                  MAX_TRANSPORT_NAME * sizeof(WCHAR)) +
 174                  enumData->n_read * MAX_TRANSPORT_ADDR * sizeof(WCHAR));
 175
 176                 ifRow.dwIndex = data->ifIndex;
 177                 GetIfEntry(&ifRow);
 178                 ti->wkti0_quality_of_service = 0;
 179                 ti->wkti0_number_of_vcs = 0;
 180                 ti->wkti0_transport_name = transport_name;
 181                 wprint_name(ti->wkti0_transport_name, MAX_TRANSPORT_NAME,
 182                  transport, &ifRow);
 183                 ti->wkti0_transport_address = transport_addr;
 184                 wprint_mac(ti->wkti0_transport_address, MAX_TRANSPORT_ADDR,
 185                  &ifRow);
 186                 if (!memcmp(&transport, TRANSPORT_NBT, sizeof(ULONG)))
 187                     ti->wkti0_wan_ish = TRUE;
 188                 else
 189                     ti->wkti0_wan_ish = FALSE;
 190                 TRACE("%d of %d:ti at %p\n", lanaIndex, totalLANAs, ti);
 191                 TRACE("transport_name at %p %s\n",
 192                  ti->wkti0_transport_name,
 193                  debugstr_w(ti->wkti0_transport_name));
 194                 TRACE("transport_address at %p %s\n",
 195                  ti->wkti0_transport_address,
 196                  debugstr_w(ti->wkti0_transport_address));
 197                 enumData->n_read++;
 198                 enumData->ret = NERR_Success;
 199                 ret = TRUE;
 200             }
 201             else
 202             {
 203                 enumData->ret = ERROR_MORE_DATA;
 204                 ret = FALSE;
 205             }
 206         }
 207         else
 208         {
 209             enumData->ret = ERROR_OUTOFMEMORY;
 210             ret = FALSE;
 211         }
 212     }
 213     else
 214         ret = FALSE;
 215     return ret;
 216 }
 217
 218 /**********************************************************************/
 219
 220 NET_API_STATUS WINAPI
 221 NetWkstaTransportEnum(LMSTR ServerName, DWORD level, PBYTE* pbuf,
 222       DWORD prefmaxlen, LPDWORD read_entries,
 223       PDWORD total_entries, PDWORD hresume)
 224 {
 225     NET_API_STATUS ret;
 226
 227     TRACE(":%s, 0x%08x, %p, 0x%08x, %p, %p, %p\n", debugstr_w(ServerName),
 228      level, pbuf, prefmaxlen, read_entries, total_entries,hresume);
 229     if (!NETAPI_IsLocalComputer(ServerName))
 230     {
 231         FIXME(":not implemented for non-local computers\n");
 232         ret = ERROR_INVALID_LEVEL;
 233     }
 234     else
 235     {
 236         if (hresume && *hresume)
 237         {
 238           FIXME(":resume handle not implemented\n");
 239           return ERROR_INVALID_LEVEL;
 240         }
 241
 242         switch (level)
 243         {
 244             case 0: /* transport info */
 245             {
 246                 ULONG allTransports;
 247                 struct WkstaTransportEnumData enumData;
 248
 249                 if (NetBIOSNumAdapters() == 0)
 250                   return ERROR_NETWORK_UNREACHABLE;
 251                 if (!read_entries)
 252                   return STATUS_ACCESS_VIOLATION;
 253                 if (!total_entries || !pbuf)
 254                   return RPC_X_NULL_REF_POINTER;
 255
 256                 enumData.prefmaxlen = prefmaxlen;
 257                 enumData.pbuf = pbuf;
 258                 memcpy(&allTransports, ALL_TRANSPORTS, sizeof(ULONG));
 259                 NetBIOSEnumAdapters(allTransports, WkstaEnumAdaptersCallback,
 260                  &enumData);
 261                 *read_entries = enumData.n_read;
 262                 *total_entries = enumData.n_adapt;
 263                 if (hresume) *hresume= 0;
 264                 ret = enumData.ret;
 265                 break;
 266             }
 267             default:
 268                 TRACE("Invalid level %d is specified\n", level);
 269                 ret = ERROR_INVALID_LEVEL;
 270         }
 271     }
 272     return ret;
 273 }
 274
 275
 276 /************************************************************
 277  *                NetWkstaUserGetInfo  (NETAPI32.@)
 278  */
 279 NET_API_STATUS WINAPI NetWkstaUserGetInfo(LMSTR reserved, DWORD level,
 280                                           PBYTE* bufptr)
 281 {
 282     NET_API_STATUS nastatus;
 283
 284     TRACE("(%s, %d, %p)\n", debugstr_w(reserved), level, bufptr);
 285     switch (level)
 286     {
 287     case 0:
 288     {
 289         PWKSTA_USER_INFO_0 ui;
 290         DWORD dwSize = UNLEN + 1;
 291
 292         /* set up buffer */
 293         nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_0) + dwSize * sizeof(WCHAR),
 294                              (LPVOID *) bufptr);
 295         if (nastatus != NERR_Success)
 296             return ERROR_NOT_ENOUGH_MEMORY;
 297
 298         ui = (PWKSTA_USER_INFO_0) *bufptr;
 299         ui->wkui0_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_0));
 300
 301         /* get data */
 302         if (!GetUserNameW(ui->wkui0_username, &dwSize))
 303         {
 304             NetApiBufferFree(ui);
 305             return ERROR_NOT_ENOUGH_MEMORY;
 306         }
 307         else {
 308             nastatus = NetApiBufferReallocate(
 309                 *bufptr, sizeof(WKSTA_USER_INFO_0) +
 310                 (lstrlenW(ui->wkui0_username) + 1) * sizeof(WCHAR),
 311                 (LPVOID *) bufptr);
 312             if (nastatus != NERR_Success)
 313                 return nastatus;
 314         }
 315         break;
 316     }
 317
 318     case 1:
 319     {
 320         PWKSTA_USER_INFO_1 ui;
 321         PWKSTA_USER_INFO_0 ui0;
 322         LSA_OBJECT_ATTRIBUTES ObjectAttributes;
 323         LSA_HANDLE PolicyHandle;
 324         PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
 325         NTSTATUS NtStatus;
 326
 327         /* sizes of the field buffers in WCHARS */
 328         int username_sz, logon_domain_sz, oth_domains_sz, logon_server_sz;
 329
 330         FIXME("Level 1 processing is partially implemented\n");
 331         oth_domains_sz = 1;
 332         logon_server_sz = 1;
 333
 334         /* get some information first to estimate size of the buffer */
 335         ui0 = NULL;
 336         nastatus = NetWkstaUserGetInfo(NULL, 0, (PBYTE *) &ui0);
 337         if (nastatus != NERR_Success)
 338             return nastatus;
 339         username_sz = lstrlenW(ui0->wkui0_username) + 1;
 340
 341         ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
 342         NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
 343                                  POLICY_VIEW_LOCAL_INFORMATION,
 344                                  &PolicyHandle);
 345         if (NtStatus != STATUS_SUCCESS)
 346         {
 347             TRACE("LsaOpenPolicyFailed with NT status %x\n",
 348                 LsaNtStatusToWinError(NtStatus));
 349             NetApiBufferFree(ui0);
 350             return ERROR_NOT_ENOUGH_MEMORY;
 351         }
 352         LsaQueryInformationPolicy(PolicyHandle, PolicyAccountDomainInformation,
 353                                   (PVOID*) &DomainInfo);
 354         logon_domain_sz = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
 355         LsaClose(PolicyHandle);
 356
 357         /* set up buffer */
 358         nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1) +
 359                              (username_sz + logon_domain_sz +
 360                               oth_domains_sz + logon_server_sz) * sizeof(WCHAR),
 361                              (LPVOID *) bufptr);
 362         if (nastatus != NERR_Success) {
 363             NetApiBufferFree(ui0);
 364             return nastatus;
 365         }
 366         ui = (WKSTA_USER_INFO_1 *) *bufptr;
 367         ui->wkui1_username = (LMSTR) (*bufptr + sizeof(WKSTA_USER_INFO_1));
 368         ui->wkui1_logon_domain = (LMSTR) (
 369             ((PBYTE) ui->wkui1_username) + username_sz * sizeof(WCHAR));
 370         ui->wkui1_oth_domains = (LMSTR) (
 371             ((PBYTE) ui->wkui1_logon_domain) +
 372             logon_domain_sz * sizeof(WCHAR));
 373         ui->wkui1_logon_server = (LMSTR) (
 374             ((PBYTE) ui->wkui1_oth_domains) +
 375             oth_domains_sz * sizeof(WCHAR));
 376
 377         /* get data */
 378         lstrcpyW(ui->wkui1_username, ui0->wkui0_username);
 379         NetApiBufferFree(ui0);
 380
 381         lstrcpynW(ui->wkui1_logon_domain, DomainInfo->DomainName.Buffer,
 382                 logon_domain_sz);
 383         LsaFreeMemory(DomainInfo);
 384
 385         /* FIXME. Not implemented. Populated with empty strings */
 386         ui->wkui1_oth_domains[0] = 0;
 387         ui->wkui1_logon_server[0] = 0;
 388         break;
 389     }
 390     case 1101:
 391     {
 392         PWKSTA_USER_INFO_1101 ui;
 393         DWORD dwSize = 1;
 394
 395         FIXME("Stub. Level 1101 processing is not implemented\n");
 396         /* FIXME see also wkui1_oth_domains for level 1 */
 397
 398         /* set up buffer */
 399         nastatus = NetApiBufferAllocate(sizeof(WKSTA_USER_INFO_1101) + dwSize * sizeof(WCHAR),
 400                              (LPVOID *) bufptr);
 401         if (nastatus != NERR_Success)
 402             return nastatus;
 403         ui = (PWKSTA_USER_INFO_1101) *bufptr;
 404         ui->wkui1101_oth_domains = (LMSTR)(ui + 1);
 405
 406         /* get data */
 407         ui->wkui1101_oth_domains[0] = 0;
 408         break;
 409     }
 410     default:
 411         TRACE("Invalid level %d is specified\n", level);
 412         return ERROR_INVALID_LEVEL;
 413     }
 414     return NERR_Success;
 415 }
 416
 417 /************************************************************
 418  *                NetWkstaUserEnum  (NETAPI32.@)
 419  */
 420 NET_API_STATUS WINAPI
 421 NetWkstaUserEnum(LMSTR servername, DWORD level, LPBYTE* bufptr,
 422                  DWORD prefmaxlen, LPDWORD entriesread,
 423                  LPDWORD totalentries, LPDWORD resumehandle)
 424 {
 425     FIXME("(%s, %d, %p, %d, %p, %p, %p): stub!\n", debugstr_w(servername),
 426           level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
 427     return ERROR_INVALID_PARAMETER;
 428 }
 429
 430 /************************************************************
 431  *                NetpGetComputerName  (NETAPI32.@)
 432  */
 433 NET_API_STATUS WINAPI NetpGetComputerName(LPWSTR *Buffer)
 434 {
 435     DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
 436
 437     TRACE("(%p)\n", Buffer);
 438     NetApiBufferAllocate(dwSize * sizeof(WCHAR), (LPVOID *) Buffer);
 439     if (GetComputerNameW(*Buffer,  &dwSize))
 440     {
 441         return NetApiBufferReallocate(
 442             *Buffer, (dwSize + 1) * sizeof(WCHAR),
 443             (LPVOID *) Buffer);
 444     }
 445     else
 446     {
 447         NetApiBufferFree(*Buffer);
 448         return ERROR_NOT_ENOUGH_MEMORY;
 449     }
 450 }
 451
 452 NET_API_STATUS WINAPI I_NetNameCompare(LPVOID p1, LPWSTR wkgrp, LPWSTR comp,
 453  LPVOID p4, LPVOID p5)
 454 {
 455     FIXME("(%p %s %s %p %p): stub\n", p1, debugstr_w(wkgrp), debugstr_w(comp),
 456      p4, p5);
 457     return ERROR_INVALID_PARAMETER;
 458 }
 459
 460 NET_API_STATUS WINAPI I_NetNameValidate(LPVOID p1, LPWSTR wkgrp, LPVOID p3,
 461  LPVOID p4)
 462 {
 463     FIXME("(%p %s %p %p): stub\n", p1, debugstr_w(wkgrp), p3, p4);
 464     return ERROR_INVALID_PARAMETER;
 465 }
 466
 467 NET_API_STATUS WINAPI NetWkstaGetInfo( LMSTR servername, DWORD level,
 468                                        LPBYTE* bufptr)
 469 {
 470     NET_API_STATUS ret;
 471
 472     TRACE("%s %d %p\n", debugstr_w( servername ), level, bufptr );
 473     if (servername)
 474     {
 475         if (!NETAPI_IsLocalComputer(servername))
 476         {
 477             FIXME("remote computers not supported\n");
 478             return ERROR_INVALID_LEVEL;
 479         }
 480     }
 481     if (!bufptr) return ERROR_INVALID_PARAMETER;
 482
 483     switch (level)
 484     {
 485         case 100:
 486         case 101:
 487         case 102:
 488         {
 489             static const WCHAR lanroot[] = {'c',':','\\','l','a','n','m','a','n',0};  /* FIXME */
 490             DWORD computerNameLen, domainNameLen, size;
 491             WCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
 492             LSA_OBJECT_ATTRIBUTES ObjectAttributes;
 493             LSA_HANDLE PolicyHandle;
 494             NTSTATUS NtStatus;
 495
 496             computerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
 497             GetComputerNameW(computerName, &computerNameLen);
 498             computerNameLen++; /* include NULL terminator */
 499
 500             ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
 501             NtStatus = LsaOpenPolicy(NULL, &ObjectAttributes,
 502              POLICY_VIEW_LOCAL_INFORMATION, &PolicyHandle);
 503             if (NtStatus != STATUS_SUCCESS)
 504                 ret = LsaNtStatusToWinError(NtStatus);
 505             else
 506             {
 507                 PPOLICY_ACCOUNT_DOMAIN_INFO DomainInfo;
 508
 509                 LsaQueryInformationPolicy(PolicyHandle,
 510                  PolicyAccountDomainInformation, (PVOID*)&DomainInfo);
 511                 domainNameLen = lstrlenW(DomainInfo->DomainName.Buffer) + 1;
 512                 size = sizeof(WKSTA_INFO_102) + computerNameLen * sizeof(WCHAR)
 513                     + domainNameLen * sizeof(WCHAR) + sizeof(lanroot);
 514                 ret = NetApiBufferAllocate(size, (LPVOID *)bufptr);
 515                 if (ret == NERR_Success)
 516                 {
 517                     /* INFO_100 and INFO_101 structures are subsets of INFO_102 */
 518                     PWKSTA_INFO_102 info = (PWKSTA_INFO_102)*bufptr;
 519                     OSVERSIONINFOW verInfo;
 520
 521                     info->wki102_platform_id = PLATFORM_ID_NT;
 522                     info->wki102_computername = (LMSTR)(*bufptr +
 523                      sizeof(WKSTA_INFO_102));
 524                     memcpy(info->wki102_computername, computerName,
 525                      computerNameLen * sizeof(WCHAR));
 526                     info->wki102_langroup = info->wki102_computername + computerNameLen;
 527                     memcpy(info->wki102_langroup, DomainInfo->DomainName.Buffer,
 528                      domainNameLen * sizeof(WCHAR));
 529                     info->wki102_lanroot = info->wki102_langroup + domainNameLen;
 530                     memcpy(info->wki102_lanroot, lanroot, sizeof(lanroot));
 531                     memset(&verInfo, 0, sizeof(verInfo));
 532                     verInfo.dwOSVersionInfoSize = sizeof(verInfo);
 533                     GetVersionExW(&verInfo);
 534                     info->wki102_ver_major = verInfo.dwMajorVersion;
 535                     info->wki102_ver_minor = verInfo.dwMinorVersion;
 536                     info->wki102_logged_on_users = 1;
 537                 }
 538                 LsaFreeMemory(DomainInfo);
 539                 LsaClose(PolicyHandle);
 540             }
 541             break;
 542         }
 543
 544         default:
 545             FIXME("level %d unimplemented\n", level);
 546             ret = ERROR_INVALID_LEVEL;
 547     }
 548     return ret;
 549 }
 550
 551 /************************************************************
 552  *                NetGetJoinInformation (NETAPI32.@)
 553  */
 554 NET_API_STATUS NET_API_FUNCTION NetGetJoinInformation(
 555     LPCWSTR Server,
 556     LPWSTR *Name,
 557     PNETSETUP_JOIN_STATUS type)
 558 {
 559     FIXME("Stub %s %p %p\n", wine_dbgstr_w(Server), Name, type);
 560
 561     if (Name == NULL || type == NULL)
 562         return ERROR_INVALID_PARAMETER;
 563
 564     *Name = NULL;
 565     *type = NetSetupUnknownStatus;
 566
 567     return NERR_Success;
 568 }
 569