git.oblomov.eu Git - wine/blob - dlls/mpr/wnet.c

   1 /*
   2  * MPR WNet functions
   3  *
   4  * Copyright 1999 Ulrich Weigand
   5  * Copyright 2004 Juan Lang
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winnls.h"
  26 #include "winnetwk.h"
  27 #include "npapi.h"
  28 #include "winreg.h"
  29 #include "winuser.h"
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32 #include "mprres.h"
  33 #include "wnetpriv.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mpr);
  36
  37 /* Data structures representing network service providers.  Assumes only one
  38  * thread creates them, and that they are constant for the life of the process
  39  * (and therefore doesn't synchronize access).
  40  * FIXME: only basic provider data and enumeration-related data are implemented
  41  * so far, need to implement the rest too.
  42  */
  43 typedef struct _WNetProvider
  44 {
  45     HMODULE           hLib;
  46     PWSTR             name;
  47     PF_NPGetCaps      getCaps;
  48     DWORD             dwSpecVersion;
  49     DWORD             dwNetType;
  50     DWORD             dwEnumScopes;
  51     PF_NPOpenEnum     openEnum;
  52     PF_NPEnumResource enumResource;
  53     PF_NPCloseEnum    closeEnum;
  54 } WNetProvider, *PWNetProvider;
  55
  56 typedef struct _WNetProviderTable
  57 {
  58     LPWSTR           entireNetwork;
  59     DWORD            numAllocated;
  60     DWORD            numProviders;
  61     WNetProvider     table[1];
  62 } WNetProviderTable, *PWNetProviderTable;
  63
  64 #define WNET_ENUMERATOR_TYPE_NULL     0
  65 #define WNET_ENUMERATOR_TYPE_GLOBAL   1
  66 #define WNET_ENUMERATOR_TYPE_PROVIDER 2
  67 #define WNET_ENUMERATOR_TYPE_CONTEXT  3
  68
  69 /* An WNet enumerator.  Note that the type doesn't correspond to the scope of
  70  * the enumeration; it represents one of the following types:
  71  * - a 'null' enumeration, one that contains no members
  72  * - a global enumeration, one that's executed across all providers
  73  * - a provider-specific enumeration, one that's only executed by a single
  74  *   provider
  75  * - a context enumeration.  I know this contradicts what I just said about
  76  *   there being no correspondence between the scope and the type, but it's
  77  *   necessary for the special case that a "Entire Network" entry needs to
  78  *   be enumerated in an enumeration of the context scope.  Thus an enumeration
  79  *   of the context scope results in a context type enumerator, which morphs
  80  *   into a global enumeration (so the enumeration continues across all
  81  *   providers).
  82  */
  83 typedef struct _WNetEnumerator
  84 {
  85     DWORD          enumType;
  86     DWORD          providerIndex;
  87     HANDLE         handle;
  88     BOOL           providerDone;
  89     DWORD          dwScope;
  90     DWORD          dwType;
  91     DWORD          dwUsage;
  92     LPNETRESOURCEW lpNet;
  93 } WNetEnumerator, *PWNetEnumerator;
  94
  95 #define BAD_PROVIDER_INDEX (DWORD)0xffffffff
  96
  97 /* Returns an index (into the global WNetProviderTable) of the provider with
  98  * the given name, or BAD_PROVIDER_INDEX if not found.
  99  */
 100 static DWORD _findProviderIndexW(LPCWSTR lpProvider);
 101
 102 PWNetProviderTable providerTable;
 103
 104 /*
 105  * Global provider table functions
 106  */
 107
 108 static void _tryLoadProvider(PCWSTR provider)
 109 {
 110     static const WCHAR servicePrefix[] = { 'S','y','s','t','e','m','\\',
 111      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 112      'S','e','r','v','i','c','e','s','\\',0 };
 113     static const WCHAR serviceFmt[] = { '%','s','%','s','\\',
 114      'N','e','t','w','o','r','k','P','r','o','v','i','d','e','r',0 };
 115     WCHAR serviceName[MAX_PATH];
 116     HKEY hKey;
 117
 118     TRACE("%s\n", debugstr_w(provider));
 119     snprintfW(serviceName, sizeof(serviceName) / sizeof(WCHAR), serviceFmt,
 120      servicePrefix, provider);
 121     serviceName[sizeof(serviceName) / sizeof(WCHAR) - 1] = '\0';
 122     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, serviceName, 0, KEY_READ, &hKey) ==
 123      ERROR_SUCCESS)
 124     {
 125         static const WCHAR szProviderPath[] = { 'P','r','o','v','i','d','e','r',
 126          'P','a','t','h',0 };
 127         WCHAR providerPath[MAX_PATH];
 128         DWORD type, size = sizeof(providerPath);
 129
 130         if (RegQueryValueExW(hKey, szProviderPath, NULL, &type,
 131          (LPBYTE)providerPath, &size) == ERROR_SUCCESS && type == REG_SZ)
 132         {
 133             static const WCHAR szProviderName[] = { 'N','a','m','e',0 };
 134             PWSTR name = NULL;
 135
 136             size = 0;
 137             RegQueryValueExW(hKey, szProviderName, NULL, NULL, NULL, &size);
 138             if (size)
 139             {
 140                 name = HeapAlloc(GetProcessHeap(), 0, size);
 141                 if (RegQueryValueExW(hKey, szProviderName, NULL, &type,
 142                  (LPBYTE)name, &size) != ERROR_SUCCESS || type != REG_SZ)
 143                 {
 144                     HeapFree(GetProcessHeap(), 0, name);
 145                     name = NULL;
 146                 }
 147             }
 148             if (name)
 149             {
 150                 HMODULE hLib = LoadLibraryW(providerPath);
 151
 152                 if (hLib)
 153                 {
 154                     PF_NPGetCaps getCaps = (PF_NPGetCaps)GetProcAddress(hLib,
 155                      "NPGetCaps");
 156
 157                     TRACE("loaded lib %p\n", hLib);
 158                     if (getCaps)
 159                     {
 160                         PWNetProvider provider =
 161                          &providerTable->table[providerTable->numProviders];
 162
 163                         provider->hLib = hLib;
 164                         provider->name = name;
 165                         TRACE("name is %s\n", debugstr_w(name));
 166                         provider->getCaps = getCaps;
 167                         provider->dwSpecVersion = getCaps(WNNC_SPEC_VERSION);
 168                         provider->dwNetType = getCaps(WNNC_NET_TYPE);
 169                         TRACE("net type is 0x%08lx\n", provider->dwNetType);
 170                         provider->dwEnumScopes = getCaps(WNNC_ENUMERATION);
 171                         if (provider->dwEnumScopes)
 172                         {
 173                             TRACE("supports enumeration\n");
 174                             provider->openEnum = (PF_NPOpenEnum)
 175                              GetProcAddress(hLib, "NPOpenEnum");
 176                             TRACE("openEnum is %p\n", provider->openEnum);
 177                             provider->enumResource = (PF_NPEnumResource)
 178                              GetProcAddress(hLib, "NPEnumResource");
 179                             TRACE("enumResource is %p\n",
 180                              provider->enumResource);
 181                             provider->closeEnum = (PF_NPCloseEnum)
 182                              GetProcAddress(hLib, "NPCloseEnum");
 183                             TRACE("closeEnum is %p\n", provider->closeEnum);
 184                             if (!provider->openEnum || !provider->enumResource
 185                              || !provider->closeEnum)
 186                             {
 187                                 provider->openEnum = NULL;
 188                                 provider->enumResource = NULL;
 189                                 provider->closeEnum = NULL;
 190                                 provider->dwEnumScopes = 0;
 191                                 WARN("Couldn't load enumeration functions\n");
 192                             }
 193                         }
 194                         providerTable->numProviders++;
 195                     }
 196                     else
 197                     {
 198                         WARN("Provider %s didn't export NPGetCaps\n",
 199                          debugstr_w(provider));
 200                         HeapFree(GetProcessHeap(), 0, name);
 201                         FreeLibrary(hLib);
 202                     }
 203                 }
 204                 else
 205                 {
 206                     WARN("Couldn't load library %s for provider %s\n",
 207                      debugstr_w(providerPath), debugstr_w(provider));
 208                     HeapFree(GetProcessHeap(), 0, name);
 209                 }
 210             }
 211             else
 212             {
 213                 WARN("Couldn't get provider name for provider %s\n",
 214                  debugstr_w(provider));
 215             }
 216         }
 217         else
 218             WARN("Couldn't open value %s\n", debugstr_w(szProviderPath));
 219         RegCloseKey(hKey);
 220     }
 221     else
 222         WARN("Couldn't open service key for provider %s\n",
 223          debugstr_w(provider));
 224 }
 225
 226 void wnetInit(HINSTANCE hInstDll)
 227 {
 228     static const WCHAR providerOrderKey[] = { 'S','y','s','t','e','m','\\',
 229      'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
 230      'C','o','n','t','r','o','l','\\',
 231      'N','e','t','w','o','r','k','P','r','o','v','i','d','e','r','\\',
 232      'O','r','d','e','r',0 };
 233      static const WCHAR providerOrder[] = { 'P','r','o','v','i','d','e','r',
 234       'O','r','d','e','r',0 };
 235     HKEY hKey;
 236
 237     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, providerOrderKey, 0, KEY_READ, &hKey)
 238      == ERROR_SUCCESS)
 239     {
 240         DWORD size = 0;
 241
 242         RegQueryValueExW(hKey, providerOrder, NULL, NULL, NULL, &size);
 243         if (size)
 244         {
 245             PWSTR providers = HeapAlloc(GetProcessHeap(), 0, size);
 246
 247             if (providers)
 248             {
 249                 DWORD type;
 250
 251                 if (RegQueryValueExW(hKey, providerOrder, NULL, &type,
 252                  (LPBYTE)providers, &size) == ERROR_SUCCESS && type == REG_SZ)
 253                 {
 254                     PWSTR ptr;
 255                     DWORD numToAllocate;
 256
 257                     TRACE("provider order is %s\n", debugstr_w(providers));
 258                     /* first count commas as a heuristic for how many to
 259                      * allocate space for */
 260                     for (ptr = providers, numToAllocate = 1; ptr; )
 261                     {
 262                         ptr = strchrW(ptr, ',');
 263                         if (ptr)
 264                             numToAllocate++;
 265                     }
 266                     providerTable =
 267                      HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 268                      sizeof(WNetProviderTable)
 269                      + (numToAllocate - 1) * sizeof(WNetProvider));
 270                     if (providerTable)
 271                     {
 272                         PWSTR ptrPrev;
 273                         int entireNetworkLen;
 274
 275                         entireNetworkLen = LoadStringW(hInstDll,
 276                          IDS_ENTIRENETWORK, NULL, 0);
 277                         providerTable->entireNetwork = HeapAlloc(
 278                          GetProcessHeap(), 0, (entireNetworkLen + 1) *
 279                          sizeof(WCHAR));
 280                         if (providerTable->entireNetwork)
 281                             LoadStringW(hInstDll, IDS_ENTIRENETWORK,
 282                              providerTable->entireNetwork,
 283                              entireNetworkLen + 1);
 284                         providerTable->numAllocated = numToAllocate;
 285                         for (ptr = providers; ptr; )
 286                         {
 287                             ptrPrev = ptr;
 288                             ptr = strchrW(ptr, ',');
 289                             if (ptr)
 290                                 *ptr = '\0';
 291                             _tryLoadProvider(ptrPrev);
 292                         }
 293                     }
 294                 }
 295                 HeapFree(GetProcessHeap(), 0, providers);
 296             }
 297         }
 298         RegCloseKey(hKey);
 299     }
 300 }
 301
 302 void wnetFree(void)
 303 {
 304     if (providerTable)
 305     {
 306         DWORD i;
 307
 308         for (i = 0; i < providerTable->numProviders; i++)
 309         {
 310             HeapFree(GetProcessHeap(), 0, providerTable->table[i].name);
 311             FreeModule(providerTable->table[i].hLib);
 312         }
 313         HeapFree(GetProcessHeap(), 0, providerTable->entireNetwork);
 314         HeapFree(GetProcessHeap(), 0, providerTable);
 315         providerTable = NULL;
 316     }
 317 }
 318
 319 static DWORD _findProviderIndexW(LPCWSTR lpProvider)
 320 {
 321     DWORD ret = BAD_PROVIDER_INDEX;
 322
 323     if (providerTable && providerTable->numProviders)
 324     {
 325         DWORD i;
 326
 327         for (i = 0; i < providerTable->numProviders &&
 328          ret == BAD_PROVIDER_INDEX; i++)
 329             if (!strcmpW(lpProvider, providerTable->table[i].name))
 330                 ret = i;
 331     }
 332     return ret;
 333 }
 334
 335 /*
 336  * Browsing Functions
 337  */
 338
 339 static LPNETRESOURCEW _copyNetResourceForEnumW(LPNETRESOURCEW lpNet)
 340 {
 341     LPNETRESOURCEW ret;
 342
 343     if (lpNet)
 344     {
 345         ret = HeapAlloc(GetProcessHeap(), 0, sizeof(NETRESOURCEW));
 346         if (ret)
 347         {
 348             size_t len;
 349
 350             memcpy(ret, lpNet, sizeof(ret));
 351             ret->lpLocalName = ret->lpComment = ret->lpProvider = NULL;
 352             if (lpNet->lpRemoteName)
 353             {
 354                 len = strlenW(lpNet->lpRemoteName) + 1;
 355                 ret->lpRemoteName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 356                 if (ret->lpRemoteName)
 357                     strcpyW(ret->lpRemoteName, lpNet->lpRemoteName);
 358             }
 359         }
 360     }
 361     else
 362         ret = NULL;
 363     return ret;
 364 }
 365
 366 static void _freeEnumNetResource(LPNETRESOURCEW lpNet)
 367 {
 368     if (lpNet)
 369     {
 370         HeapFree(GetProcessHeap(), 0, lpNet->lpRemoteName);
 371         HeapFree(GetProcessHeap(), 0, lpNet);
 372     }
 373 }
 374
 375 static PWNetEnumerator _createNullEnumerator(void)
 376 {
 377     PWNetEnumerator ret = HeapAlloc(GetProcessHeap(),
 378      HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
 379
 380     if (ret)
 381         ret->enumType = WNET_ENUMERATOR_TYPE_NULL;
 382     return ret;
 383 }
 384
 385 static PWNetEnumerator _createGlobalEnumeratorW(DWORD dwScope, DWORD dwType,
 386  DWORD dwUsage, LPNETRESOURCEW lpNet)
 387 {
 388     PWNetEnumerator ret = HeapAlloc(GetProcessHeap(),
 389      HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
 390
 391     if (ret)
 392     {
 393         ret->enumType = WNET_ENUMERATOR_TYPE_GLOBAL;
 394         ret->dwScope = dwScope;
 395         ret->dwType  = dwType;
 396         ret->dwUsage = dwUsage;
 397         ret->lpNet   = _copyNetResourceForEnumW(lpNet);
 398     }
 399     return ret;
 400 }
 401
 402 static PWNetEnumerator _createProviderEnumerator(DWORD dwScope, DWORD dwType,
 403  DWORD dwUsage, DWORD index, HANDLE handle)
 404 {
 405     PWNetEnumerator ret;
 406
 407     if (!providerTable || index >= providerTable->numProviders)
 408         ret = NULL;
 409     else
 410     {
 411         ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
 412         if (ret)
 413         {
 414             ret->enumType      = WNET_ENUMERATOR_TYPE_PROVIDER;
 415             ret->providerIndex = index;
 416             ret->dwScope       = dwScope;
 417             ret->dwType        = dwType;
 418             ret->dwUsage       = dwUsage;
 419             ret->handle        = handle;
 420         }
 421     }
 422     return ret;
 423 }
 424
 425 static PWNetEnumerator _createContextEnumerator(DWORD dwScope, DWORD dwType,
 426  DWORD dwUsage)
 427 {
 428     PWNetEnumerator ret = HeapAlloc(GetProcessHeap(),
 429      HEAP_ZERO_MEMORY, sizeof(WNetEnumerator));
 430
 431     if (ret)
 432     {
 433         ret->enumType = WNET_ENUMERATOR_TYPE_CONTEXT;
 434         ret->dwScope = dwScope;
 435         ret->dwType  = dwType;
 436         ret->dwUsage = dwUsage;
 437     }
 438     return ret;
 439 }
 440
 441 /* Thunks the array of wide-string LPNETRESOURCEs lpNetArrayIn into buffer
 442  * lpBuffer, with size *lpBufferSize.  lpNetArrayIn contains *lpcCount entries
 443  * to start.  On return, *lpcCount reflects the number thunked into lpBuffer.
 444  * Returns WN_SUCCESS on success (all of lpNetArrayIn thunked), WN_MORE_DATA
 445  * if not all members of the array could be thunked, and something else on
 446  * failure.
 447  */
 448 static DWORD _thunkNetResourceArrayWToA(const LPNETRESOURCEW lpNetArrayIn,
 449  LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
 450 {
 451     DWORD i, numToThunk, totalBytes, ret;
 452     LPSTR strNext;
 453
 454     if (!lpNetArrayIn)
 455         return WN_BAD_POINTER;
 456     if (!lpcCount)
 457         return WN_BAD_POINTER;
 458     if (*lpcCount == -1)
 459         return WN_BAD_VALUE;
 460     if (!lpBuffer)
 461         return WN_BAD_POINTER;
 462     if (!lpBufferSize)
 463         return WN_BAD_POINTER;
 464
 465     for (i = 0, numToThunk = 0, totalBytes = 0; i < *lpcCount; i++)
 466     {
 467         LPNETRESOURCEW lpNet = lpNetArrayIn + i;
 468
 469         totalBytes += sizeof(NETRESOURCEA);
 470         if (lpNet->lpLocalName)
 471             totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpLocalName,
 472              -1, NULL, 0, NULL, NULL);
 473         if (lpNet->lpRemoteName)
 474             totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpRemoteName,
 475              -1, NULL, 0, NULL, NULL);
 476         if (lpNet->lpComment)
 477             totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpComment,
 478              -1, NULL, 0, NULL, NULL);
 479         if (lpNet->lpProvider)
 480             totalBytes += WideCharToMultiByte(CP_ACP, 0, lpNet->lpProvider,
 481              -1, NULL, 0, NULL, NULL);
 482         if (totalBytes < *lpBufferSize)
 483             numToThunk = i + 1;
 484     }
 485     strNext = (LPSTR)((LPBYTE)lpBuffer + numToThunk * sizeof(NETRESOURCEA));
 486     for (i = 0; i < numToThunk; i++)
 487     {
 488         LPNETRESOURCEA lpNetOut = (LPNETRESOURCEA)lpBuffer + i;
 489         LPNETRESOURCEW lpNetIn = lpNetArrayIn + i;
 490
 491         memcpy(lpNetOut, lpNetIn, sizeof(NETRESOURCEA));
 492         /* lie about string lengths, we already verified how many
 493          * we have space for above
 494          */
 495         if (lpNetIn->lpLocalName)
 496         {
 497             lpNetOut->lpLocalName = strNext;
 498             strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpLocalName, -1,
 499              lpNetOut->lpLocalName, *lpBufferSize, NULL, NULL);
 500         }
 501         if (lpNetIn->lpRemoteName)
 502         {
 503             lpNetOut->lpRemoteName = strNext;
 504             strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpRemoteName, -1,
 505              lpNetOut->lpRemoteName, *lpBufferSize, NULL, NULL);
 506         }
 507         if (lpNetIn->lpComment)
 508         {
 509             lpNetOut->lpComment = strNext;
 510             strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpComment, -1,
 511              lpNetOut->lpComment, *lpBufferSize, NULL, NULL);
 512         }
 513         if (lpNetIn->lpProvider)
 514         {
 515             lpNetOut->lpProvider = strNext;
 516             strNext += WideCharToMultiByte(CP_ACP, 0, lpNetIn->lpProvider, -1,
 517              lpNetOut->lpProvider, *lpBufferSize, NULL, NULL);
 518         }
 519     }
 520     ret = numToThunk < *lpcCount ? WN_MORE_DATA : WN_SUCCESS;
 521     TRACE("numToThunk is %ld, *lpcCount is %ld, returning %ld\n", numToThunk,
 522      *lpcCount, ret);
 523     return ret;
 524 }
 525
 526 /* Thunks the array of multibyte-string LPNETRESOURCEs lpNetArrayIn into buffer
 527  * lpBuffer, with size *lpBufferSize.  lpNetArrayIn contains *lpcCount entries
 528  * to start.  On return, *lpcCount reflects the number thunked into lpBuffer.
 529  * Returns WN_SUCCESS on success (all of lpNetArrayIn thunked), WN_MORE_DATA
 530  * if not all members of the array could be thunked, and something else on
 531  * failure.
 532  */
 533 static DWORD _thunkNetResourceArrayAToW(const LPNETRESOURCEA lpNetArrayIn,
 534  LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
 535 {
 536     DWORD i, numToThunk, totalBytes, ret;
 537     LPWSTR strNext;
 538
 539     if (!lpNetArrayIn)
 540         return WN_BAD_POINTER;
 541     if (!lpcCount)
 542         return WN_BAD_POINTER;
 543     if (*lpcCount == -1)
 544         return WN_BAD_VALUE;
 545     if (!lpBuffer)
 546         return WN_BAD_POINTER;
 547     if (!lpBufferSize)
 548         return WN_BAD_POINTER;
 549
 550     for (i = 0, numToThunk = 0, totalBytes = 0; i < *lpcCount; i++)
 551     {
 552         LPNETRESOURCEA lpNet = lpNetArrayIn + i;
 553
 554         totalBytes += sizeof(NETRESOURCEW);
 555         if (lpNet->lpLocalName)
 556             totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpLocalName,
 557              -1, NULL, 0) * sizeof(WCHAR);
 558         if (lpNet->lpRemoteName)
 559             totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpRemoteName,
 560              -1, NULL, 0) * sizeof(WCHAR);
 561         if (lpNet->lpComment)
 562             totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpComment,
 563              -1, NULL, 0) * sizeof(WCHAR);
 564         if (lpNet->lpProvider)
 565             totalBytes += MultiByteToWideChar(CP_ACP, 0, lpNet->lpProvider,
 566              -1, NULL, 0) * sizeof(WCHAR);
 567         if (totalBytes < *lpBufferSize)
 568             numToThunk = i + 1;
 569     }
 570     strNext = (LPWSTR)((LPBYTE)lpBuffer + numToThunk * sizeof(NETRESOURCEW));
 571     for (i = 0; i < numToThunk; i++)
 572     {
 573         LPNETRESOURCEW lpNetOut = (LPNETRESOURCEW)lpBuffer + i;
 574         LPNETRESOURCEA lpNetIn = lpNetArrayIn + i;
 575
 576         memcpy(lpNetOut, lpNetIn, sizeof(NETRESOURCEW));
 577         /* lie about string lengths, we already verified how many
 578          * we have space for above
 579          */
 580         if (lpNetIn->lpLocalName)
 581         {
 582             lpNetOut->lpLocalName = strNext;
 583             strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpLocalName,
 584              -1, lpNetOut->lpLocalName, *lpBufferSize);
 585         }
 586         if (lpNetIn->lpRemoteName)
 587         {
 588             lpNetOut->lpRemoteName = strNext;
 589             strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpRemoteName,
 590              -1, lpNetOut->lpRemoteName, *lpBufferSize);
 591         }
 592         if (lpNetIn->lpComment)
 593         {
 594             lpNetOut->lpComment = strNext;
 595             strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpComment,
 596              -1, lpNetOut->lpComment, *lpBufferSize);
 597         }
 598         if (lpNetIn->lpProvider)
 599         {
 600             lpNetOut->lpProvider = strNext;
 601             strNext += MultiByteToWideChar(CP_ACP, 0, lpNetIn->lpProvider,
 602              -1, lpNetOut->lpProvider, *lpBufferSize);
 603         }
 604     }
 605     ret = numToThunk < *lpcCount ? WN_MORE_DATA : WN_SUCCESS;
 606     TRACE("numToThunk is %ld, *lpcCount is %ld, returning %ld\n", numToThunk,
 607      *lpcCount, ret);
 608     return ret;
 609 }
 610
 611 /*********************************************************************
 612  * WNetOpenEnumA [MPR.@]
 613  *
 614  * See comments for WNetOpenEnumW.
 615  */
 616 DWORD WINAPI WNetOpenEnumA( DWORD dwScope, DWORD dwType, DWORD dwUsage,
 617                             LPNETRESOURCEA lpNet, LPHANDLE lphEnum )
 618 {
 619     DWORD ret;
 620
 621     TRACE( "(%08lX, %08lX, %08lX, %p, %p)\n",
 622             dwScope, dwType, dwUsage, lpNet, lphEnum );
 623
 624     if (!lphEnum)
 625         ret = WN_BAD_POINTER;
 626     else if (!providerTable || providerTable->numProviders == 0)
 627         ret = WN_NO_NETWORK;
 628     else
 629     {
 630         if (lpNet)
 631         {
 632             LPNETRESOURCEW lpNetWide = NULL;
 633             BYTE buf[1024];
 634             DWORD size = sizeof(buf), count = 1;
 635             BOOL allocated = FALSE;
 636
 637             ret = _thunkNetResourceArrayAToW(lpNet, &count, buf, &size);
 638             if (ret == WN_MORE_DATA)
 639             {
 640                 lpNetWide = HeapAlloc(GetProcessHeap(), 0,
 641                  size);
 642                 if (lpNetWide)
 643                 {
 644                     ret = _thunkNetResourceArrayAToW(lpNet, &count, lpNetWide,
 645                      &size);
 646                     allocated = TRUE;
 647                 }
 648                 else
 649                     ret = WN_OUT_OF_MEMORY;
 650             }
 651             else if (ret == WN_SUCCESS)
 652                 lpNetWide = (LPNETRESOURCEW)buf;
 653             if (ret == WN_SUCCESS)
 654                 ret = WNetOpenEnumW(dwScope, dwType, dwUsage, lpNetWide,
 655                  lphEnum);
 656             if (allocated && lpNetWide)
 657                 HeapFree(GetProcessHeap(), 0, lpNetWide);
 658         }
 659         else
 660             ret = WNetOpenEnumW(dwScope, dwType, dwUsage, NULL, lphEnum);
 661     }
 662     if (ret)
 663         SetLastError(ret);
 664     TRACE("Returning %ld\n", ret);
 665     return ret;
 666 }
 667
 668 /*********************************************************************
 669  * WNetOpenEnumW [MPR.@]
 670  *
 671  * Network enumeration has way too many parameters, so I'm not positive I got
 672  * them right.  What I've got so far:
 673  *
 674  * - If the scope is RESOURCE_GLOBALNET, and no LPNETRESOURCE is passed,
 675  *   all the network providers should be enumerated.
 676  *
 677  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and
 678  *   and neither the LPNETRESOURCE's lpRemoteName nor the LPNETRESOURCE's
 679  *   lpProvider is set, all the network providers should be enumerated.
 680  *   (This means the enumeration is a list of network providers, not that the
 681  *   enumeration is passed on to the providers.)
 682  *
 683  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and the
 684  *   resource matches the "Entire Network" resource (no remote name, no
 685  *   provider, comment is the "Entire Network" string), a RESOURCE_GLOBALNET
 686  *   enumeration is done on every network provider.
 687  *
 688  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and
 689  *   the LPNETRESOURCE's lpProvider is set, enumeration will be passed through
 690  *   only to the given network provider.
 691  *
 692  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and
 693  *   no lpProvider is set, enumeration will be tried on every network provider,
 694  *   in the order in which they're loaded.
 695  *
 696  * - The LPNETRESOURCE should be disregarded for scopes besides
 697  *   RESOURCE_GLOBALNET.  MSDN states that lpNet must be NULL if dwScope is not
 698  *   RESOURCE_GLOBALNET, but Windows doesn't return an error if it isn't NULL.
 699  *
 700  * - If the scope is RESOURCE_CONTEXT, MS includes an "Entire Network" net
 701  *   resource in the enumerated list, as well as any machines in your
 702  *   workgroup.  The machines in your workgroup come from doing a
 703  *   RESOURCE_CONTEXT enumeration of every Network Provider.
 704  */
 705 DWORD WINAPI WNetOpenEnumW( DWORD dwScope, DWORD dwType, DWORD dwUsage,
 706                             LPNETRESOURCEW lpNet, LPHANDLE lphEnum )
 707 {
 708     DWORD ret;
 709
 710     TRACE( "(%08lX, %08lX, %08lX, %p, %p)\n",
 711           dwScope, dwType, dwUsage, lpNet, lphEnum );
 712
 713     if (!lphEnum)
 714         ret = WN_BAD_POINTER;
 715     else if (!providerTable || providerTable->numProviders == 0)
 716         ret = WN_NO_NETWORK;
 717     else
 718     {
 719         switch (dwScope)
 720         {
 721             case RESOURCE_GLOBALNET:
 722                 if (lpNet)
 723                 {
 724                     if (lpNet->lpProvider)
 725                     {
 726                         DWORD index = _findProviderIndexW(lpNet->lpProvider);
 727
 728                         if (index != BAD_PROVIDER_INDEX)
 729                         {
 730                             if (providerTable->table[index].openEnum &&
 731                              providerTable->table[index].dwEnumScopes & dwScope)
 732                             {
 733                                 HANDLE handle;
 734
 735                                 ret = providerTable->table[index].openEnum(
 736                                  dwScope, dwType, dwUsage, lpNet, &handle);
 737                                 if (ret == WN_SUCCESS)
 738                                 {
 739                                     *lphEnum =
 740                                      (HANDLE)_createProviderEnumerator(
 741                                      dwScope, dwType, dwUsage, index, handle);
 742                                     ret = *lphEnum ? WN_SUCCESS :
 743                                      WN_OUT_OF_MEMORY;
 744                                 }
 745                             }
 746                             else
 747                                 ret = WN_NOT_SUPPORTED;
 748                         }
 749                         else
 750                             ret = WN_BAD_PROVIDER;
 751                     }
 752                     else if (lpNet->lpRemoteName)
 753                     {
 754                         *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope,
 755                          dwType, dwUsage, lpNet);
 756                         ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 757                     }
 758                     else
 759                     {
 760                         if (lpNet->lpComment && !strcmpW(lpNet->lpComment,
 761                          providerTable->entireNetwork))
 762                         {
 763                             /* comment matches the "Entire Network", enumerate
 764                              * global scope of every provider
 765                              */
 766                             *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope,
 767                              dwType, dwUsage, lpNet);
 768                         }
 769                         else
 770                         {
 771                             /* this is the same as not having passed lpNet */
 772                             *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope,
 773                              dwType, dwUsage, NULL);
 774                         }
 775                         ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 776                     }
 777                 }
 778                 else
 779                 {
 780                     *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope, dwType,
 781                      dwUsage, lpNet);
 782                     ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 783                 }
 784                 break;
 785             case RESOURCE_CONTEXT:
 786                 *lphEnum = (HANDLE)_createContextEnumerator(dwScope, dwType,
 787                  dwUsage);
 788                 ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 789                 break;
 790             case RESOURCE_REMEMBERED:
 791             case RESOURCE_CONNECTED:
 792                 *lphEnum = (HANDLE)_createNullEnumerator();
 793                 ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 794                 break;
 795             default:
 796                 WARN("unknown scope 0x%08lx\n", dwScope);
 797                 ret = WN_BAD_VALUE;
 798         }
 799     }
 800     if (ret)
 801         SetLastError(ret);
 802     TRACE("Returning %ld\n", ret);
 803     return ret;
 804 }
 805
 806 /*********************************************************************
 807  * WNetEnumResourceA [MPR.@]
 808  */
 809 DWORD WINAPI WNetEnumResourceA( HANDLE hEnum, LPDWORD lpcCount,
 810                                 LPVOID lpBuffer, LPDWORD lpBufferSize )
 811 {
 812     DWORD ret;
 813
 814     TRACE( "(%p, %p, %p, %p)\n", hEnum, lpcCount, lpBuffer, lpBufferSize );
 815
 816     if (!hEnum)
 817         ret = WN_BAD_POINTER;
 818     else if (!lpcCount)
 819         ret = WN_BAD_POINTER;
 820     if (!lpBuffer)
 821         ret = WN_BAD_POINTER;
 822     else if (!lpBufferSize)
 823         ret = WN_BAD_POINTER;
 824     else if (*lpBufferSize < sizeof(NETRESOURCEA))
 825     {
 826         *lpBufferSize = sizeof(NETRESOURCEA);
 827         ret = WN_MORE_DATA;
 828     }
 829     else
 830     {
 831         DWORD localCount = *lpcCount, localSize = *lpBufferSize;
 832         LPVOID localBuffer = HeapAlloc(GetProcessHeap(), 0, localSize);
 833
 834         if (localBuffer)
 835         {
 836             ret = WNetEnumResourceW(hEnum, &localCount, localBuffer,
 837              &localSize);
 838             if (ret == WN_SUCCESS || (ret == WN_MORE_DATA && localCount != -1))
 839             {
 840                 /* FIXME: this isn't necessarily going to work in the case of
 841                  * WN_MORE_DATA, because our enumerator may have moved on to
 842                  * the next provider.  MSDN states that a large (16KB) buffer
 843                  * size is the appropriate usage of this function, so
 844                  * hopefully it won't be an issue.
 845                  */
 846                 ret = _thunkNetResourceArrayWToA((LPNETRESOURCEW)localBuffer,
 847                  &localCount, lpBuffer, lpBufferSize);
 848                 *lpcCount = localCount;
 849             }
 850             HeapFree(GetProcessHeap(), 0, localBuffer);
 851         }
 852         else
 853             ret = WN_OUT_OF_MEMORY;
 854     }
 855     if (ret)
 856         SetLastError(ret);
 857     TRACE("Returning %ld\n", ret);
 858     return ret;
 859 }
 860
 861 static DWORD _countProviderBytesW(PWNetProvider provider)
 862 {
 863     DWORD ret;
 864
 865     if (provider)
 866     {
 867         ret = sizeof(NETRESOURCEW);
 868         ret += 2 * (strlenW(provider->name) + 1) * sizeof(WCHAR);
 869     }
 870     else
 871         ret = 0;
 872     return ret;
 873 }
 874
 875 static DWORD _enumerateProvidersW(PWNetEnumerator enumerator, LPDWORD lpcCount,
 876  LPVOID lpBuffer, LPDWORD lpBufferSize)
 877 {
 878     DWORD ret;
 879
 880     if (!enumerator)
 881         return WN_BAD_POINTER;
 882     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
 883         return WN_BAD_VALUE;
 884     if (!lpcCount)
 885         return WN_BAD_POINTER;
 886     if (!lpBuffer)
 887         return WN_BAD_POINTER;
 888     if (!lpBufferSize)
 889         return WN_BAD_POINTER;
 890     if (*lpBufferSize < sizeof(NETRESOURCEA))
 891         return WN_MORE_DATA;
 892
 893     if (!providerTable || enumerator->providerIndex >=
 894      providerTable->numProviders)
 895         ret = WN_NO_MORE_ENTRIES;
 896     else
 897     {
 898         DWORD bytes = 0, count = 0, countLimit, i;
 899         LPNETRESOURCEW resource;
 900         LPWSTR strNext;
 901
 902         countLimit = *lpcCount == -1 ?
 903          providerTable->numProviders - enumerator->providerIndex : *lpcCount;
 904         while (count < countLimit && bytes < *lpBufferSize)
 905         {
 906             DWORD bytesNext = _countProviderBytesW(
 907              &providerTable->table[count + enumerator->providerIndex]);
 908
 909             if (bytes + bytesNext < *lpBufferSize)
 910             {
 911                 bytes += bytesNext;
 912                 count++;
 913             }
 914         }
 915         strNext = (LPWSTR)((LPBYTE)lpBuffer + count * sizeof(NETRESOURCEW));
 916         for (i = 0, resource = (LPNETRESOURCEW)lpBuffer; i < count;
 917          i++, resource++)
 918         {
 919             resource->dwScope = RESOURCE_GLOBALNET;
 920             resource->dwType = RESOURCETYPE_ANY;
 921             resource->dwDisplayType = RESOURCEDISPLAYTYPE_NETWORK;
 922             resource->dwUsage = RESOURCEUSAGE_CONTAINER |
 923              RESOURCEUSAGE_RESERVED;
 924             resource->lpLocalName = NULL;
 925             resource->lpRemoteName = strNext;
 926             strcpyW(resource->lpRemoteName,
 927              providerTable->table[i + enumerator->providerIndex].name);
 928             strNext += strlenW(resource->lpRemoteName) + 1;
 929             resource->lpComment = NULL;
 930             resource->lpProvider = strNext;
 931             strcpyW(resource->lpProvider,
 932              providerTable->table[i + enumerator->providerIndex].name);
 933             strNext += strlenW(resource->lpProvider) + 1;
 934         }
 935         enumerator->providerIndex += count;
 936         *lpcCount = count;
 937         ret = count > 0 ? WN_SUCCESS : WN_MORE_DATA;
 938     }
 939     TRACE("Returning %ld\n", ret);
 940     return ret;
 941 }
 942
 943 /* Advances the enumerator (assumed to be a global enumerator) to the next
 944  * provider that supports the enumeration scope passed to WNetOpenEnum.  Does
 945  * not open a handle with the next provider.
 946  * If the existing handle is NULL, may leave the enumerator unchanged, since
 947  * the current provider may support the desired scope.
 948  * If the existing handle is not NULL, closes it before moving on.
 949  * Returns WN_SUCCESS on success, WN_NO_MORE_ENTRIES if there is no available
 950  * provider, and another error on failure.
 951  */
 952 static DWORD _globalEnumeratorAdvance(PWNetEnumerator enumerator)
 953 {
 954     if (!enumerator)
 955         return WN_BAD_POINTER;
 956     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
 957         return WN_BAD_VALUE;
 958     if (!providerTable || enumerator->providerIndex >=
 959      providerTable->numProviders)
 960         return WN_NO_MORE_ENTRIES;
 961
 962     if (enumerator->providerDone)
 963     {
 964         enumerator->providerDone = FALSE;
 965         if (enumerator->handle)
 966         {
 967             providerTable->table[enumerator->providerIndex].closeEnum(
 968              enumerator->handle);
 969             enumerator->handle = NULL;
 970             enumerator->providerIndex++;
 971         }
 972         for (; enumerator->providerIndex < providerTable->numProviders &&
 973          !(enumerator->dwScope & providerTable->table
 974          [enumerator->providerIndex].dwEnumScopes);
 975          enumerator->providerIndex++)
 976             ;
 977     }
 978     return enumerator->providerIndex < providerTable->numProviders ?
 979      WN_SUCCESS : WN_NO_MORE_ENTRIES;
 980 }
 981
 982 /* "Passes through" call to the next provider that supports the enumeration
 983  * type.
 984  * FIXME: if one call to a provider's enumerator succeeds while there's still
 985  * space in lpBuffer, I don't call to the next provider.  The caller may not
 986  * expect that it should call EnumResourceW again with a return value of
 987  * WN_SUCCESS (depending what *lpcCount was to begin with).  That means strings
 988  * may have to be moved around a bit, ick.
 989  */
 990 static DWORD _enumerateGlobalPassthroughW(PWNetEnumerator enumerator,
 991  LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
 992 {
 993     DWORD ret;
 994
 995     if (!enumerator)
 996         return WN_BAD_POINTER;
 997     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
 998         return WN_BAD_VALUE;
 999     if (!lpcCount)
1000         return WN_BAD_POINTER;
1001     if (!lpBuffer)
1002         return WN_BAD_POINTER;
1003     if (!lpBufferSize)
1004         return WN_BAD_POINTER;
1005     if (*lpBufferSize < sizeof(NETRESOURCEW))
1006         return WN_MORE_DATA;
1007
1008     ret = _globalEnumeratorAdvance(enumerator);
1009     if (ret == WN_SUCCESS)
1010     {
1011         ret = providerTable->table[enumerator->providerIndex].
1012          openEnum(enumerator->dwScope, enumerator->dwType,
1013          enumerator->dwUsage, enumerator->lpNet,
1014          &enumerator->handle);
1015         if (ret == WN_SUCCESS)
1016         {
1017             ret = providerTable->table[enumerator->providerIndex].
1018              enumResource(enumerator->handle, lpcCount, lpBuffer,
1019              lpBufferSize);
1020             if (ret != WN_MORE_DATA)
1021                 enumerator->providerDone = TRUE;
1022         }
1023     }
1024     TRACE("Returning %ld\n", ret);
1025     return ret;
1026 }
1027
1028 static DWORD _enumerateGlobalW(PWNetEnumerator enumerator, LPDWORD lpcCount,
1029  LPVOID lpBuffer, LPDWORD lpBufferSize)
1030 {
1031     DWORD ret;
1032
1033     if (!enumerator)
1034         return WN_BAD_POINTER;
1035     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
1036         return WN_BAD_VALUE;
1037     if (!lpcCount)
1038         return WN_BAD_POINTER;
1039     if (!lpBuffer)
1040         return WN_BAD_POINTER;
1041     if (!lpBufferSize)
1042         return WN_BAD_POINTER;
1043     if (*lpBufferSize < sizeof(NETRESOURCEW))
1044         return WN_MORE_DATA;
1045     if (!providerTable)
1046         return WN_NO_NETWORK;
1047
1048     switch (enumerator->dwScope)
1049     {
1050         case RESOURCE_GLOBALNET:
1051             if (enumerator->lpNet)
1052                 ret = _enumerateGlobalPassthroughW(enumerator, lpcCount,
1053                  lpBuffer, lpBufferSize);
1054             else
1055                 ret = _enumerateProvidersW(enumerator, lpcCount, lpBuffer,
1056                  lpBufferSize);
1057             break;
1058         case RESOURCE_CONTEXT:
1059             ret = _enumerateGlobalPassthroughW(enumerator, lpcCount, lpBuffer,
1060              lpBufferSize);
1061             break;
1062         default:
1063             WARN("unexpected scope 0x%08lx\n", enumerator->dwScope);
1064             ret = WN_NO_MORE_ENTRIES;
1065     }
1066     TRACE("Returning %ld\n", ret);
1067     return ret;
1068 }
1069
1070 static DWORD _enumerateProviderW(PWNetEnumerator enumerator, LPDWORD lpcCount,
1071  LPVOID lpBuffer, LPDWORD lpBufferSize)
1072 {
1073     if (!enumerator)
1074         return WN_BAD_POINTER;
1075     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_PROVIDER)
1076         return WN_BAD_VALUE;
1077     if (!enumerator->handle)
1078         return WN_BAD_VALUE;
1079     if (!lpcCount)
1080         return WN_BAD_POINTER;
1081     if (!lpBuffer)
1082         return WN_BAD_POINTER;
1083     if (!lpBufferSize)
1084         return WN_BAD_POINTER;
1085     if (!providerTable)
1086         return WN_NO_NETWORK;
1087     if (enumerator->providerIndex >= providerTable->numProviders)
1088         return WN_NO_MORE_ENTRIES;
1089     if (!providerTable->table[enumerator->providerIndex].enumResource)
1090         return WN_BAD_VALUE;
1091     return providerTable->table[enumerator->providerIndex].enumResource(
1092      enumerator->handle, lpcCount, lpBuffer, lpBufferSize);
1093 }
1094
1095 static DWORD _enumerateContextW(PWNetEnumerator enumerator, LPDWORD lpcCount,
1096  LPVOID lpBuffer, LPDWORD lpBufferSize)
1097 {
1098     DWORD ret;
1099     size_t cchEntireNetworkLen, bytesNeeded;
1100
1101     if (!enumerator)
1102         return WN_BAD_POINTER;
1103     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_CONTEXT)
1104         return WN_BAD_VALUE;
1105     if (!lpcCount)
1106         return WN_BAD_POINTER;
1107     if (!lpBuffer)
1108         return WN_BAD_POINTER;
1109     if (!lpBufferSize)
1110         return WN_BAD_POINTER;
1111     if (!providerTable)
1112         return WN_NO_NETWORK;
1113
1114     cchEntireNetworkLen = strlenW(providerTable->entireNetwork) + 1;
1115     bytesNeeded = sizeof(NETRESOURCEW) + cchEntireNetworkLen * sizeof(WCHAR);
1116     if (*lpBufferSize < bytesNeeded)
1117     {
1118         *lpBufferSize = bytesNeeded;
1119         ret = WN_MORE_DATA;
1120     }
1121     else
1122     {
1123         LPNETRESOURCEW lpNet = (LPNETRESOURCEW)lpBuffer;
1124
1125         lpNet->dwScope = RESOURCE_GLOBALNET;
1126         lpNet->dwType = enumerator->dwType;
1127         lpNet->dwDisplayType = RESOURCEDISPLAYTYPE_ROOT;
1128         lpNet->dwUsage = RESOURCEUSAGE_CONTAINER;
1129         lpNet->lpLocalName = NULL;
1130         lpNet->lpRemoteName = NULL;
1131         lpNet->lpProvider = NULL;
1132         /* odd, but correct: put comment at end of buffer, so it won't get
1133          * overwritten by subsequent calls to a provider's enumResource
1134          */
1135         lpNet->lpComment = (LPWSTR)((LPBYTE)lpBuffer + *lpBufferSize -
1136          (cchEntireNetworkLen * sizeof(WCHAR)));
1137         strcpyW(lpNet->lpComment, providerTable->entireNetwork);
1138         ret = WN_SUCCESS;
1139     }
1140     if (ret == WN_SUCCESS)
1141     {
1142         DWORD bufferSize = *lpBufferSize - bytesNeeded;
1143
1144         /* "Entire Network" entry enumerated--morph this into a global
1145          * enumerator.  enumerator->lpNet continues to be NULL, since it has
1146          * no meaning when the scope isn't RESOURCE_GLOBALNET.
1147          */
1148         enumerator->enumType = WNET_ENUMERATOR_TYPE_GLOBAL;
1149         ret = _enumerateGlobalW(enumerator, lpcCount,
1150          (LPBYTE)lpBuffer + bytesNeeded, &bufferSize);
1151         if (ret == WN_SUCCESS)
1152         {
1153             /* reflect the fact that we already enumerated "Entire Network" */
1154             lpcCount++;
1155             *lpBufferSize = bufferSize + bytesNeeded;
1156         }
1157         else
1158         {
1159             /* the provider enumeration failed, but we already succeeded in
1160              * enumerating "Entire Network"--leave type as global to allow a
1161              * retry, but indicate success with a count of one.
1162              */
1163             ret = WN_SUCCESS;
1164             *lpcCount = 1;
1165             *lpBufferSize = bytesNeeded;
1166         }
1167     }
1168     TRACE("Returning %ld\n", ret);
1169     return ret;
1170 }
1171
1172 /*********************************************************************
1173  * WNetEnumResourceW [MPR.@]
1174  */
1175 DWORD WINAPI WNetEnumResourceW( HANDLE hEnum, LPDWORD lpcCount,
1176                                 LPVOID lpBuffer, LPDWORD lpBufferSize )
1177 {
1178     DWORD ret;
1179
1180     TRACE( "(%p, %p, %p, %p)\n", hEnum, lpcCount, lpBuffer, lpBufferSize );
1181
1182     if (!hEnum)
1183         ret = WN_BAD_POINTER;
1184     else if (!lpcCount)
1185         ret = WN_BAD_POINTER;
1186     else if (!lpBuffer)
1187         ret = WN_BAD_POINTER;
1188     else if (!lpBufferSize)
1189         ret = WN_BAD_POINTER;
1190     else if (*lpBufferSize < sizeof(NETRESOURCEW))
1191     {
1192         *lpBufferSize = sizeof(NETRESOURCEW);
1193         ret = WN_MORE_DATA;
1194     }
1195     else
1196     {
1197         PWNetEnumerator enumerator = (PWNetEnumerator)hEnum;
1198
1199         switch (enumerator->enumType)
1200         {
1201             case WNET_ENUMERATOR_TYPE_NULL:
1202                 ret = WN_NO_MORE_ENTRIES;
1203                 break;
1204             case WNET_ENUMERATOR_TYPE_GLOBAL:
1205                 ret = _enumerateGlobalW(enumerator, lpcCount, lpBuffer,
1206                  lpBufferSize);
1207                 break;
1208             case WNET_ENUMERATOR_TYPE_PROVIDER:
1209                 ret = _enumerateProviderW(enumerator, lpcCount, lpBuffer,
1210                  lpBufferSize);
1211                 break;
1212             case WNET_ENUMERATOR_TYPE_CONTEXT:
1213                 ret = _enumerateContextW(enumerator, lpcCount, lpBuffer,
1214                  lpBufferSize);
1215                 break;
1216             default:
1217                 WARN("bogus enumerator type!\n");
1218                 ret = WN_NO_NETWORK;
1219         }
1220     }
1221     if (ret)
1222         SetLastError(ret);
1223     TRACE("Returning %ld\n", ret);
1224     return ret;
1225 }
1226
1227 /*********************************************************************
1228  * WNetCloseEnum [MPR.@]
1229  */
1230 DWORD WINAPI WNetCloseEnum( HANDLE hEnum )
1231 {
1232     DWORD ret;
1233
1234     TRACE( "(%p)\n", hEnum );
1235
1236     if (hEnum)
1237     {
1238         PWNetEnumerator enumerator = (PWNetEnumerator)hEnum;
1239
1240         switch (enumerator->enumType)
1241         {
1242             case WNET_ENUMERATOR_TYPE_NULL:
1243                 ret = WN_SUCCESS;
1244                 break;
1245             case WNET_ENUMERATOR_TYPE_GLOBAL:
1246                 if (enumerator->lpNet)
1247                     _freeEnumNetResource(enumerator->lpNet);
1248                 if (enumerator->handle)
1249                     providerTable->table[enumerator->providerIndex].
1250                      closeEnum(enumerator->handle);
1251                 ret = WN_SUCCESS;
1252                 break;
1253             case WNET_ENUMERATOR_TYPE_PROVIDER:
1254                 if (enumerator->handle)
1255                     providerTable->table[enumerator->providerIndex].
1256                      closeEnum(enumerator->handle);
1257                 ret = WN_SUCCESS;
1258                 break;
1259             default:
1260                 WARN("bogus enumerator type!\n");
1261                 ret = WN_BAD_HANDLE;
1262         }
1263         HeapFree(GetProcessHeap(), 0, hEnum);
1264     }
1265     else
1266         ret = WN_BAD_HANDLE;
1267     if (ret)
1268         SetLastError(ret);
1269     TRACE("Returning %ld\n", ret);
1270     return ret;
1271 }
1272
1273 /*********************************************************************
1274  * WNetGetResourceInformationA [MPR.@]
1275  */
1276 DWORD WINAPI WNetGetResourceInformationA( LPNETRESOURCEA lpNetResource,
1277                                           LPVOID lpBuffer, LPDWORD cbBuffer,
1278                                           LPSTR *lplpSystem )
1279 {
1280     FIXME( "(%p, %p, %p, %p): stub\n",
1281            lpNetResource, lpBuffer, cbBuffer, lplpSystem );
1282
1283     SetLastError(WN_NO_NETWORK);
1284     return WN_NO_NETWORK;
1285 }
1286
1287 /*********************************************************************
1288  * WNetGetResourceInformationW [MPR.@]
1289  */
1290 DWORD WINAPI WNetGetResourceInformationW( LPNETRESOURCEW lpNetResource,
1291                                           LPVOID lpBuffer, LPDWORD cbBuffer,
1292                                           LPWSTR *lplpSystem )
1293 {
1294     FIXME( "(%p, %p, %p, %p): stub\n",
1295            lpNetResource, lpBuffer, cbBuffer, lplpSystem );
1296
1297     SetLastError(WN_NO_NETWORK);
1298     return WN_NO_NETWORK;
1299 }
1300
1301 /*********************************************************************
1302  * WNetGetResourceParentA [MPR.@]
1303  */
1304 DWORD WINAPI WNetGetResourceParentA( LPNETRESOURCEA lpNetResource,
1305                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1306 {
1307     FIXME( "(%p, %p, %p): stub\n",
1308            lpNetResource, lpBuffer, lpBufferSize );
1309
1310     SetLastError(WN_NO_NETWORK);
1311     return WN_NO_NETWORK;
1312 }
1313
1314 /*********************************************************************
1315  * WNetGetResourceParentW [MPR.@]
1316  */
1317 DWORD WINAPI WNetGetResourceParentW( LPNETRESOURCEW lpNetResource,
1318                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1319 {
1320     FIXME( "(%p, %p, %p): stub\n",
1321            lpNetResource, lpBuffer, lpBufferSize );
1322
1323     SetLastError(WN_NO_NETWORK);
1324     return WN_NO_NETWORK;
1325 }
1326
1327
1328
1329 /*
1330  * Connection Functions
1331  */
1332
1333 /*********************************************************************
1334  *  WNetAddConnectionA [MPR.@]
1335  */
1336 DWORD WINAPI WNetAddConnectionA( LPCSTR lpRemoteName, LPCSTR lpPassword,
1337                                  LPCSTR lpLocalName )
1338 {
1339     FIXME( "(%s, %p, %s): stub\n",
1340            debugstr_a(lpRemoteName), lpPassword, debugstr_a(lpLocalName) );
1341
1342     SetLastError(WN_NO_NETWORK);
1343     return WN_NO_NETWORK;
1344 }
1345
1346 /*********************************************************************
1347  *  WNetAddConnectionW [MPR.@]
1348  */
1349 DWORD WINAPI WNetAddConnectionW( LPCWSTR lpRemoteName, LPCWSTR lpPassword,
1350                                  LPCWSTR lpLocalName )
1351 {
1352     FIXME( "(%s, %p, %s): stub\n",
1353            debugstr_w(lpRemoteName), lpPassword, debugstr_w(lpLocalName) );
1354
1355     SetLastError(WN_NO_NETWORK);
1356     return WN_NO_NETWORK;
1357 }
1358
1359 /*********************************************************************
1360  *  WNetAddConnection2A [MPR.@]
1361  */
1362 DWORD WINAPI WNetAddConnection2A( LPNETRESOURCEA lpNetResource,
1363                                   LPCSTR lpPassword, LPCSTR lpUserID,
1364                                   DWORD dwFlags )
1365 {
1366     FIXME( "(%p, %p, %s, 0x%08lX): stub\n",
1367            lpNetResource, lpPassword, debugstr_a(lpUserID), dwFlags );
1368
1369     SetLastError(WN_NO_NETWORK);
1370     return WN_NO_NETWORK;
1371 }
1372
1373 /*********************************************************************
1374  * WNetAddConnection2W [MPR.@]
1375  */
1376 DWORD WINAPI WNetAddConnection2W( LPNETRESOURCEW lpNetResource,
1377                                   LPCWSTR lpPassword, LPCWSTR lpUserID,
1378                                   DWORD dwFlags )
1379 {
1380     FIXME( "(%p, %p, %s, 0x%08lX): stub\n",
1381            lpNetResource, lpPassword, debugstr_w(lpUserID), dwFlags );
1382
1383     SetLastError(WN_NO_NETWORK);
1384     return WN_NO_NETWORK;
1385 }
1386
1387 /*********************************************************************
1388  * WNetAddConnection3A [MPR.@]
1389  */
1390 DWORD WINAPI WNetAddConnection3A( HWND hwndOwner, LPNETRESOURCEA lpNetResource,
1391                                   LPCSTR lpPassword, LPCSTR lpUserID,
1392                                   DWORD dwFlags )
1393 {
1394     FIXME( "(%p, %p, %p, %s, 0x%08lX), stub\n",
1395            hwndOwner, lpNetResource, lpPassword, debugstr_a(lpUserID), dwFlags );
1396
1397     SetLastError(WN_NO_NETWORK);
1398     return WN_NO_NETWORK;
1399 }
1400
1401 /*********************************************************************
1402  * WNetAddConnection3W [MPR.@]
1403  */
1404 DWORD WINAPI WNetAddConnection3W( HWND hwndOwner, LPNETRESOURCEW lpNetResource,
1405                                   LPCWSTR lpPassword, LPCWSTR lpUserID,
1406                                   DWORD dwFlags )
1407 {
1408     FIXME( "(%p, %p, %p, %s, 0x%08lX), stub\n",
1409            hwndOwner, lpNetResource, lpPassword, debugstr_w(lpUserID), dwFlags );
1410
1411     SetLastError(WN_NO_NETWORK);
1412     return WN_NO_NETWORK;
1413 }
1414
1415 /*****************************************************************
1416  *  WNetUseConnectionA [MPR.@]
1417  */
1418 DWORD WINAPI WNetUseConnectionA( HWND hwndOwner, LPNETRESOURCEA lpNetResource,
1419                                  LPCSTR lpPassword, LPCSTR lpUserID, DWORD dwFlags,
1420                                  LPSTR lpAccessName, LPDWORD lpBufferSize,
1421                                  LPDWORD lpResult )
1422 {
1423     FIXME( "(%p, %p, %p, %s, 0x%08lX, %s, %p, %p), stub\n",
1424            hwndOwner, lpNetResource, lpPassword, debugstr_a(lpUserID), dwFlags,
1425            debugstr_a(lpAccessName), lpBufferSize, lpResult );
1426
1427     SetLastError(WN_NO_NETWORK);
1428     return WN_NO_NETWORK;
1429 }
1430
1431 /*****************************************************************
1432  *  WNetUseConnectionW [MPR.@]
1433  */
1434 DWORD WINAPI WNetUseConnectionW( HWND hwndOwner, LPNETRESOURCEW lpNetResource,
1435                                  LPCWSTR lpPassword, LPCWSTR lpUserID, DWORD dwFlags,
1436                                  LPWSTR lpAccessName, LPDWORD lpBufferSize,
1437                                  LPDWORD lpResult )
1438 {
1439     FIXME( "(%p, %p, %p, %s, 0x%08lX, %s, %p, %p), stub\n",
1440            hwndOwner, lpNetResource, lpPassword, debugstr_w(lpUserID), dwFlags,
1441            debugstr_w(lpAccessName), lpBufferSize, lpResult );
1442
1443     SetLastError(WN_NO_NETWORK);
1444     return WN_NO_NETWORK;
1445 }
1446
1447 /*********************************************************************
1448  *  WNetCancelConnectionA [MPR.@]
1449  */
1450 DWORD WINAPI WNetCancelConnectionA( LPCSTR lpName, BOOL fForce )
1451 {
1452     FIXME( "(%s, %d), stub\n", debugstr_a(lpName), fForce );
1453
1454     return WN_SUCCESS;
1455 }
1456
1457 /*********************************************************************
1458  *  WNetCancelConnectionW [MPR.@]
1459  */
1460 DWORD WINAPI WNetCancelConnectionW( LPCWSTR lpName, BOOL fForce )
1461 {
1462     FIXME( "(%s, %d), stub\n", debugstr_w(lpName), fForce );
1463
1464     return WN_SUCCESS;
1465 }
1466
1467 /*********************************************************************
1468  *  WNetCancelConnection2A [MPR.@]
1469  */
1470 DWORD WINAPI WNetCancelConnection2A( LPCSTR lpName, DWORD dwFlags, BOOL fForce )
1471 {
1472     FIXME( "(%s, %08lX, %d), stub\n", debugstr_a(lpName), dwFlags, fForce );
1473
1474     return WN_SUCCESS;
1475 }
1476
1477 /*********************************************************************
1478  *  WNetCancelConnection2W [MPR.@]
1479  */
1480 DWORD WINAPI WNetCancelConnection2W( LPCWSTR lpName, DWORD dwFlags, BOOL fForce )
1481 {
1482     FIXME( "(%s, %08lX, %d), stub\n", debugstr_w(lpName), dwFlags, fForce );
1483
1484     return WN_SUCCESS;
1485 }
1486
1487 /*****************************************************************
1488  *  WNetRestoreConnectionA [MPR.@]
1489  */
1490 DWORD WINAPI WNetRestoreConnectionA( HWND hwndOwner, LPSTR lpszDevice )
1491 {
1492     FIXME( "(%p, %s), stub\n", hwndOwner, debugstr_a(lpszDevice) );
1493
1494     SetLastError(WN_NO_NETWORK);
1495     return WN_NO_NETWORK;
1496 }
1497
1498 /*****************************************************************
1499  *  WNetRestoreConnectionW [MPR.@]
1500  */
1501 DWORD WINAPI WNetRestoreConnectionW( HWND hwndOwner, LPWSTR lpszDevice )
1502 {
1503     FIXME( "(%p, %s), stub\n", hwndOwner, debugstr_w(lpszDevice) );
1504
1505     SetLastError(WN_NO_NETWORK);
1506     return WN_NO_NETWORK;
1507 }
1508
1509 /**************************************************************************
1510  * WNetGetConnectionA [MPR.@]
1511  *
1512  * RETURNS
1513  * - WN_BAD_LOCALNAME     lpLocalName makes no sense
1514  * - WN_NOT_CONNECTED     drive is a local drive
1515  * - WN_MORE_DATA         buffer isn't big enough
1516  * - WN_SUCCESS           success (net path in buffer)
1517  *
1518  * FIXME: need to test return values under different errors
1519  */
1520 DWORD WINAPI WNetGetConnectionA( LPCSTR lpLocalName,
1521                                  LPSTR lpRemoteName, LPDWORD lpBufferSize )
1522 {
1523     DWORD ret;
1524
1525     if (!lpLocalName)
1526         ret = WN_BAD_POINTER;
1527     else if (!lpRemoteName)
1528         ret = WN_BAD_POINTER;
1529     else if (!lpBufferSize)
1530         ret = WN_BAD_POINTER;
1531     else
1532     {
1533         int len = MultiByteToWideChar(CP_ACP, 0, lpLocalName, -1, NULL, 0);
1534
1535         if (len)
1536         {
1537             PWSTR wideLocalName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1538
1539             if (wideLocalName)
1540             {
1541                 WCHAR wideRemoteStatic[MAX_PATH];
1542                 DWORD wideRemoteSize = sizeof(wideRemoteStatic) / sizeof(WCHAR);
1543
1544                 MultiByteToWideChar(CP_ACP, 0, lpLocalName, -1, wideLocalName, len);
1545
1546                 /* try once without memory allocation */
1547                 ret = WNetGetConnectionW(wideLocalName, wideRemoteStatic,
1548                  &wideRemoteSize);
1549                 if (ret == WN_SUCCESS)
1550                 {
1551                     int len = WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic,
1552                      -1, NULL, 0, NULL, NULL);
1553
1554                     if (len <= *lpBufferSize)
1555                     {
1556                         WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic, -1,
1557                          lpRemoteName, *lpBufferSize, NULL, NULL);
1558                         ret = WN_SUCCESS;
1559                     }
1560                     else
1561                     {
1562                         *lpBufferSize = len;
1563                         ret = WN_MORE_DATA;
1564                     }
1565                 }
1566                 else if (ret == WN_MORE_DATA)
1567                 {
1568                     PWSTR wideRemote = HeapAlloc(GetProcessHeap(), 0,
1569                      wideRemoteSize * sizeof(WCHAR));
1570
1571                     if (wideRemote)
1572                     {
1573                         ret = WNetGetConnectionW(wideLocalName, wideRemote,
1574                          &wideRemoteSize);
1575                         if (ret == WN_SUCCESS)
1576                         {
1577                             if (len <= *lpBufferSize)
1578                             {
1579                                 WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic,
1580                                  -1, lpRemoteName, *lpBufferSize, NULL, NULL);
1581                                 ret = WN_SUCCESS;
1582                             }
1583                             else
1584                             {
1585                                 *lpBufferSize = len;
1586                                 ret = WN_MORE_DATA;
1587                             }
1588                         }
1589                         HeapFree(GetProcessHeap(), 0, wideRemote);
1590                     }
1591                     else
1592                         ret = WN_OUT_OF_MEMORY;
1593                 }
1594                 HeapFree(GetProcessHeap(), 0, wideLocalName);
1595             }
1596             else
1597                 ret = WN_OUT_OF_MEMORY;
1598         }
1599         else
1600             ret = WN_BAD_LOCALNAME;
1601     }
1602     if (ret)
1603         SetLastError(ret);
1604     TRACE("Returning %ld\n", ret);
1605     return ret;
1606 }
1607
1608 /**************************************************************************
1609  * WNetGetConnectionW [MPR.@]
1610  *
1611  * FIXME: need to test return values under different errors
1612  */
1613 DWORD WINAPI WNetGetConnectionW( LPCWSTR lpLocalName,
1614                                  LPWSTR lpRemoteName, LPDWORD lpBufferSize )
1615 {
1616     DWORD ret;
1617
1618     TRACE("(%s, %p, %p)\n", debugstr_w(lpLocalName), lpRemoteName,
1619      lpBufferSize);
1620
1621     if (!lpLocalName)
1622         ret = WN_BAD_POINTER;
1623     else if (!lpRemoteName)
1624         ret = WN_BAD_POINTER;
1625     else if (!lpBufferSize)
1626         ret = WN_BAD_POINTER;
1627     else if (!lpLocalName[0])
1628         ret = WN_BAD_LOCALNAME;
1629     else
1630     {
1631         if (lpLocalName[1] == ':')
1632         {
1633             switch(GetDriveTypeW(lpLocalName))
1634             {
1635             case DRIVE_REMOTE:
1636             {
1637                 WCHAR remote[MAX_PATH];
1638                 if (!QueryDosDeviceW( lpLocalName, remote, MAX_PATH )) remote[0] = 0;
1639                 if (strlenW(remote) + 1 > *lpBufferSize)
1640                 {
1641                     *lpBufferSize = strlenW(remote) + 1;
1642                     ret = WN_MORE_DATA;
1643                 }
1644                 else
1645                 {
1646                     strcpyW( lpRemoteName, remote );
1647                     *lpBufferSize = strlenW(lpRemoteName) + 1;
1648                     ret = WN_SUCCESS;
1649                 }
1650                 break;
1651             }
1652             case DRIVE_REMOVABLE:
1653             case DRIVE_FIXED:
1654             case DRIVE_CDROM:
1655                 TRACE("file is local\n");
1656                 ret = WN_NOT_CONNECTED;
1657                 break;
1658             default:
1659                 ret = WN_BAD_LOCALNAME;
1660             }
1661         }
1662         else
1663             ret = WN_BAD_LOCALNAME;
1664     }
1665     if (ret)
1666         SetLastError(ret);
1667     TRACE("Returning %ld\n", ret);
1668     return ret;
1669 }
1670
1671 /**************************************************************************
1672  * WNetSetConnectionA [MPR.@]
1673  */
1674 DWORD WINAPI WNetSetConnectionA( LPCSTR lpName, DWORD dwProperty,
1675                                  LPVOID pvValue )
1676 {
1677     FIXME( "(%s, %08lX, %p): stub\n", debugstr_a(lpName), dwProperty, pvValue );
1678
1679     SetLastError(WN_NO_NETWORK);
1680     return WN_NO_NETWORK;
1681 }
1682
1683 /**************************************************************************
1684  * WNetSetConnectionW [MPR.@]
1685  */
1686 DWORD WINAPI WNetSetConnectionW( LPCWSTR lpName, DWORD dwProperty,
1687                                  LPVOID pvValue )
1688 {
1689     FIXME( "(%s, %08lX, %p): stub\n", debugstr_w(lpName), dwProperty, pvValue );
1690
1691     SetLastError(WN_NO_NETWORK);
1692     return WN_NO_NETWORK;
1693 }
1694
1695 /*****************************************************************
1696  * WNetGetUniversalNameA [MPR.@]
1697  */
1698 DWORD WINAPI WNetGetUniversalNameA ( LPCSTR lpLocalPath, DWORD dwInfoLevel,
1699                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1700 {
1701     FIXME( "(%s, 0x%08lX, %p, %p): stub\n",
1702            debugstr_a(lpLocalPath), dwInfoLevel, lpBuffer, lpBufferSize);
1703
1704     SetLastError(WN_NO_NETWORK);
1705     return WN_NO_NETWORK;
1706 }
1707
1708 /*****************************************************************
1709  * WNetGetUniversalNameW [MPR.@]
1710  */
1711 DWORD WINAPI WNetGetUniversalNameW ( LPCWSTR lpLocalPath, DWORD dwInfoLevel,
1712                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1713 {
1714     LPUNIVERSAL_NAME_INFOW uniw;
1715     DWORD err, len;
1716
1717     FIXME( "(%s, 0x%08lX, %p, %p): stub\n",
1718            debugstr_w(lpLocalPath), dwInfoLevel, lpBuffer, lpBufferSize);
1719
1720     switch (dwInfoLevel)
1721     {
1722     case UNIVERSAL_NAME_INFO_LEVEL:
1723         err = WN_MORE_DATA;
1724         len = sizeof (*uniw) + lstrlenW(lpLocalPath);
1725         if (*lpBufferSize <= len)
1726             break;
1727         uniw = lpBuffer;
1728         uniw->lpUniversalName = (LPWSTR) &uniw[1];
1729         lstrcpyW(uniw->lpUniversalName, lpLocalPath);
1730         *lpBufferSize = len;
1731         err = WN_NO_ERROR;
1732         break;
1733
1734     case REMOTE_NAME_INFO_LEVEL:
1735         err = WN_NO_NETWORK;
1736         break;
1737
1738     default:
1739         err = WN_BAD_VALUE;
1740     }
1741
1742     SetLastError(err);
1743     return err;
1744 }
1745
1746
1747
1748 /*
1749  * Other Functions
1750  */
1751
1752 /**************************************************************************
1753  * WNetGetUserA [MPR.@]
1754  *
1755  * FIXME: we should not return ourselves, but the owner of the drive lpName
1756  */
1757 DWORD WINAPI WNetGetUserA( LPCSTR lpName, LPSTR lpUserID, LPDWORD lpBufferSize )
1758 {
1759     if (GetUserNameA( lpUserID, lpBufferSize )) return WN_SUCCESS;
1760     return GetLastError();
1761 }
1762
1763 /*****************************************************************
1764  * WNetGetUserW [MPR.@]
1765  *
1766  * FIXME: we should not return ourselves, but the owner of the drive lpName
1767  */
1768 DWORD WINAPI WNetGetUserW( LPCWSTR lpName, LPWSTR lpUserID, LPDWORD lpBufferSize )
1769 {
1770     if (GetUserNameW( lpUserID, lpBufferSize )) return WN_SUCCESS;
1771     return GetLastError();
1772 }
1773
1774 /*********************************************************************
1775  * WNetConnectionDialog [MPR.@]
1776  */
1777 DWORD WINAPI WNetConnectionDialog( HWND hwnd, DWORD dwType )
1778 {
1779     FIXME( "(%p, %08lX): stub\n", hwnd, dwType );
1780
1781     SetLastError(WN_NO_NETWORK);
1782     return WN_NO_NETWORK;
1783 }
1784
1785 /*********************************************************************
1786  * WNetConnectionDialog1A [MPR.@]
1787  */
1788 DWORD WINAPI WNetConnectionDialog1A( LPCONNECTDLGSTRUCTA lpConnDlgStruct )
1789 {
1790     FIXME( "(%p): stub\n", lpConnDlgStruct );
1791
1792     SetLastError(WN_NO_NETWORK);
1793     return WN_NO_NETWORK;
1794 }
1795
1796 /*********************************************************************
1797  * WNetConnectionDialog1W [MPR.@]
1798  */
1799 DWORD WINAPI WNetConnectionDialog1W( LPCONNECTDLGSTRUCTW lpConnDlgStruct )
1800 {
1801     FIXME( "(%p): stub\n", lpConnDlgStruct );
1802
1803     SetLastError(WN_NO_NETWORK);
1804     return WN_NO_NETWORK;
1805 }
1806
1807 /*********************************************************************
1808  * WNetDisconnectDialog [MPR.@]
1809  */
1810 DWORD WINAPI WNetDisconnectDialog( HWND hwnd, DWORD dwType )
1811 {
1812     FIXME( "(%p, %08lX): stub\n", hwnd, dwType );
1813
1814     SetLastError(WN_NO_NETWORK);
1815     return WN_NO_NETWORK;
1816 }
1817
1818 /*********************************************************************
1819  * WNetDisconnectDialog1A [MPR.@]
1820  */
1821 DWORD WINAPI WNetDisconnectDialog1A( LPDISCDLGSTRUCTA lpConnDlgStruct )
1822 {
1823     FIXME( "(%p): stub\n", lpConnDlgStruct );
1824
1825     SetLastError(WN_NO_NETWORK);
1826     return WN_NO_NETWORK;
1827 }
1828
1829 /*********************************************************************
1830  * WNetDisconnectDialog1W [MPR.@]
1831  */
1832 DWORD WINAPI WNetDisconnectDialog1W( LPDISCDLGSTRUCTW lpConnDlgStruct )
1833 {
1834     FIXME( "(%p): stub\n", lpConnDlgStruct );
1835
1836     SetLastError(WN_NO_NETWORK);
1837     return WN_NO_NETWORK;
1838 }
1839
1840 /*********************************************************************
1841  * WNetGetLastErrorA [MPR.@]
1842  */
1843 DWORD WINAPI WNetGetLastErrorA( LPDWORD lpError,
1844                                 LPSTR lpErrorBuf, DWORD nErrorBufSize,
1845                                 LPSTR lpNameBuf, DWORD nNameBufSize )
1846 {
1847     FIXME( "(%p, %p, %ld, %p, %ld): stub\n",
1848            lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize );
1849
1850     SetLastError(WN_NO_NETWORK);
1851     return WN_NO_NETWORK;
1852 }
1853
1854 /*********************************************************************
1855  * WNetGetLastErrorW [MPR.@]
1856  */
1857 DWORD WINAPI WNetGetLastErrorW( LPDWORD lpError,
1858                                 LPWSTR lpErrorBuf, DWORD nErrorBufSize,
1859                          LPWSTR lpNameBuf, DWORD nNameBufSize )
1860 {
1861     FIXME( "(%p, %p, %ld, %p, %ld): stub\n",
1862            lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize );
1863
1864     SetLastError(WN_NO_NETWORK);
1865     return WN_NO_NETWORK;
1866 }
1867
1868 /*********************************************************************
1869  * WNetGetNetworkInformationA [MPR.@]
1870  */
1871 DWORD WINAPI WNetGetNetworkInformationA( LPCSTR lpProvider,
1872                                          LPNETINFOSTRUCT lpNetInfoStruct )
1873 {
1874     DWORD ret;
1875
1876     TRACE( "(%s, %p)\n", debugstr_a(lpProvider), lpNetInfoStruct );
1877
1878     if (!lpProvider)
1879         ret = WN_BAD_POINTER;
1880     else
1881     {
1882         int len;
1883
1884         len = MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, NULL, 0);
1885         if (len)
1886         {
1887             LPWSTR wideProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1888
1889             if (wideProvider)
1890             {
1891                 MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, wideProvider,
1892                  len);
1893                 ret = WNetGetNetworkInformationW(wideProvider, lpNetInfoStruct);
1894                 HeapFree(GetProcessHeap(), 0, wideProvider);
1895             }
1896             else
1897                 ret = WN_OUT_OF_MEMORY;
1898         }
1899         else
1900             ret = GetLastError();
1901     }
1902     if (ret)
1903         SetLastError(ret);
1904     TRACE("Returning %ld\n", ret);
1905     return ret;
1906 }
1907
1908 /*********************************************************************
1909  * WNetGetNetworkInformationW [MPR.@]
1910  */
1911 DWORD WINAPI WNetGetNetworkInformationW( LPCWSTR lpProvider,
1912                                          LPNETINFOSTRUCT lpNetInfoStruct )
1913 {
1914     DWORD ret;
1915
1916     TRACE( "(%s, %p)\n", debugstr_w(lpProvider), lpNetInfoStruct );
1917
1918     if (!lpProvider)
1919         ret = WN_BAD_POINTER;
1920     else if (!lpNetInfoStruct)
1921         ret = WN_BAD_POINTER;
1922     else if (lpNetInfoStruct->cbStructure < sizeof(NETINFOSTRUCT))
1923         ret = WN_BAD_VALUE;
1924     else
1925     {
1926         if (providerTable && providerTable->numProviders)
1927         {
1928             DWORD providerIndex = _findProviderIndexW(lpProvider);
1929
1930             if (providerIndex != BAD_PROVIDER_INDEX)
1931             {
1932                 lpNetInfoStruct->cbStructure = sizeof(NETINFOSTRUCT);
1933                 lpNetInfoStruct->dwProviderVersion =
1934                  providerTable->table[providerIndex].dwSpecVersion;
1935                 lpNetInfoStruct->dwStatus = NO_ERROR;
1936                 lpNetInfoStruct->dwCharacteristics = 0;
1937                 lpNetInfoStruct->dwHandle = (ULONG_PTR)NULL;
1938                 lpNetInfoStruct->wNetType =
1939                  HIWORD(providerTable->table[providerIndex].dwNetType);
1940                 lpNetInfoStruct->dwPrinters = -1;
1941                 lpNetInfoStruct->dwDrives = -1;
1942                 ret = WN_SUCCESS;
1943             }
1944             else
1945                 ret = WN_BAD_PROVIDER;
1946         }
1947         else
1948             ret = WN_NO_NETWORK;
1949     }
1950     if (ret)
1951         SetLastError(ret);
1952     TRACE("Returning %ld\n", ret);
1953     return ret;
1954 }
1955
1956 /*****************************************************************
1957  *  WNetGetProviderNameA [MPR.@]
1958  */
1959 DWORD WINAPI WNetGetProviderNameA( DWORD dwNetType,
1960                                    LPSTR lpProvider, LPDWORD lpBufferSize )
1961 {
1962     DWORD ret;
1963
1964     TRACE("(0x%08lx, %s, %p)\n", dwNetType, debugstr_a(lpProvider),
1965      lpBufferSize);
1966
1967     if (!lpProvider)
1968         ret = WN_BAD_POINTER;
1969     else if (!lpBufferSize)
1970         ret = WN_BAD_POINTER;
1971     else
1972     {
1973         if (providerTable)
1974         {
1975             DWORD i;
1976
1977             ret = WN_NO_NETWORK;
1978             for (i = 0; i < providerTable->numProviders &&
1979              HIWORD(providerTable->table[i].dwNetType) != HIWORD(dwNetType);
1980              i++)
1981                 ;
1982             if (i < providerTable->numProviders)
1983             {
1984                 DWORD sizeNeeded = WideCharToMultiByte(CP_ACP, 0,
1985                  providerTable->table[i].name, -1, NULL, 0, NULL, NULL);
1986
1987                 if (*lpBufferSize < sizeNeeded)
1988                 {
1989                     *lpBufferSize = sizeNeeded;
1990                     ret = WN_MORE_DATA;
1991                 }
1992                 else
1993                 {
1994                     WideCharToMultiByte(CP_ACP, 0, providerTable->table[i].name,
1995                      -1, lpProvider, *lpBufferSize, NULL, NULL);
1996                     ret = WN_SUCCESS;
1997                     /* FIXME: is *lpBufferSize set to the number of characters
1998                      * copied? */
1999                 }
2000             }
2001         }
2002         else
2003             ret = WN_NO_NETWORK;
2004     }
2005     if (ret)
2006         SetLastError(ret);
2007     TRACE("Returning %ld\n", ret);
2008     return ret;
2009 }
2010
2011 /*****************************************************************
2012  *  WNetGetProviderNameW [MPR.@]
2013  */
2014 DWORD WINAPI WNetGetProviderNameW( DWORD dwNetType,
2015                                    LPWSTR lpProvider, LPDWORD lpBufferSize )
2016 {
2017     DWORD ret;
2018
2019     TRACE("(0x%08lx, %s, %p)\n", dwNetType, debugstr_w(lpProvider),
2020      lpBufferSize);
2021
2022     if (!lpProvider)
2023         ret = WN_BAD_POINTER;
2024     else if (!lpBufferSize)
2025         ret = WN_BAD_POINTER;
2026     else
2027     {
2028         if (providerTable)
2029         {
2030             DWORD i;
2031
2032             ret = WN_NO_NETWORK;
2033             for (i = 0; i < providerTable->numProviders &&
2034              HIWORD(providerTable->table[i].dwNetType) != HIWORD(dwNetType);
2035              i++)
2036                 ;
2037             if (i < providerTable->numProviders)
2038             {
2039                 DWORD sizeNeeded = strlenW(providerTable->table[i].name) + 1;
2040
2041                 if (*lpBufferSize < sizeNeeded)
2042                 {
2043                     *lpBufferSize = sizeNeeded;
2044                     ret = WN_MORE_DATA;
2045                 }
2046                 else
2047                 {
2048                     strcpyW(lpProvider, providerTable->table[i].name);
2049                     ret = WN_SUCCESS;
2050                     /* FIXME: is *lpBufferSize set to the number of characters
2051                      * copied? */
2052                 }
2053             }
2054         }
2055         else
2056             ret = WN_NO_NETWORK;
2057     }
2058     if (ret)
2059         SetLastError(ret);
2060     TRACE("Returning %ld\n", ret);
2061     return ret;
2062 }