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