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