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         ret = WN_NO_NETWORK;
 641     else
 642     {
 643         if (lpNet)
 644         {
 645             LPNETRESOURCEW lpNetWide = NULL;
 646             BYTE buf[1024];
 647             DWORD size = sizeof(buf), count = 1;
 648             BOOL allocated = FALSE;
 649
 650             ret = _thunkNetResourceArrayAToW(lpNet, &count, buf, &size);
 651             if (ret == WN_MORE_DATA)
 652             {
 653                 lpNetWide = HeapAlloc(GetProcessHeap(), 0,
 654                  size);
 655                 if (lpNetWide)
 656                 {
 657                     ret = _thunkNetResourceArrayAToW(lpNet, &count, lpNetWide,
 658                      &size);
 659                     allocated = TRUE;
 660                 }
 661                 else
 662                     ret = WN_OUT_OF_MEMORY;
 663             }
 664             else if (ret == WN_SUCCESS)
 665                 lpNetWide = (LPNETRESOURCEW)buf;
 666             if (ret == WN_SUCCESS)
 667                 ret = WNetOpenEnumW(dwScope, dwType, dwUsage, lpNetWide,
 668                  lphEnum);
 669             if (allocated)
 670                 HeapFree(GetProcessHeap(), 0, lpNetWide);
 671         }
 672         else
 673             ret = WNetOpenEnumW(dwScope, dwType, dwUsage, NULL, lphEnum);
 674     }
 675     if (ret)
 676         SetLastError(ret);
 677     TRACE("Returning %d\n", ret);
 678     return ret;
 679 }
 680
 681 /*********************************************************************
 682  * WNetOpenEnumW [MPR.@]
 683  *
 684  * Network enumeration has way too many parameters, so I'm not positive I got
 685  * them right.  What I've got so far:
 686  *
 687  * - If the scope is RESOURCE_GLOBALNET, and no LPNETRESOURCE is passed,
 688  *   all the network providers should be enumerated.
 689  *
 690  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and
 691  *   and neither the LPNETRESOURCE's lpRemoteName nor the LPNETRESOURCE's
 692  *   lpProvider is set, all the network providers should be enumerated.
 693  *   (This means the enumeration is a list of network providers, not that the
 694  *   enumeration is passed on to the providers.)
 695  *
 696  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and the
 697  *   resource matches the "Entire Network" resource (no remote name, no
 698  *   provider, comment is the "Entire Network" string), a RESOURCE_GLOBALNET
 699  *   enumeration is done on every network provider.
 700  *
 701  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and
 702  *   the LPNETRESOURCE's lpProvider is set, enumeration will be passed through
 703  *   only to the given network provider.
 704  *
 705  * - If the scope is RESOURCE_GLOBALNET, and LPNETRESOURCE is passed, and
 706  *   no lpProvider is set, enumeration will be tried on every network provider,
 707  *   in the order in which they're loaded.
 708  *
 709  * - The LPNETRESOURCE should be disregarded for scopes besides
 710  *   RESOURCE_GLOBALNET.  MSDN states that lpNet must be NULL if dwScope is not
 711  *   RESOURCE_GLOBALNET, but Windows doesn't return an error if it isn't NULL.
 712  *
 713  * - If the scope is RESOURCE_CONTEXT, MS includes an "Entire Network" net
 714  *   resource in the enumerated list, as well as any machines in your
 715  *   workgroup.  The machines in your workgroup come from doing a
 716  *   RESOURCE_CONTEXT enumeration of every Network Provider.
 717  */
 718 DWORD WINAPI WNetOpenEnumW( DWORD dwScope, DWORD dwType, DWORD dwUsage,
 719                             LPNETRESOURCEW lpNet, LPHANDLE lphEnum )
 720 {
 721     DWORD ret;
 722
 723     TRACE( "(%08X, %08X, %08X, %p, %p)\n",
 724           dwScope, dwType, dwUsage, lpNet, lphEnum );
 725
 726     if (!lphEnum)
 727         ret = WN_BAD_POINTER;
 728     else if (!providerTable || providerTable->numProviders == 0)
 729         ret = WN_NO_NETWORK;
 730     else
 731     {
 732         switch (dwScope)
 733         {
 734             case RESOURCE_GLOBALNET:
 735                 if (lpNet)
 736                 {
 737                     if (lpNet->lpProvider)
 738                     {
 739                         DWORD index = _findProviderIndexW(lpNet->lpProvider);
 740
 741                         if (index != BAD_PROVIDER_INDEX)
 742                         {
 743                             if (providerTable->table[index].openEnum &&
 744                              providerTable->table[index].dwEnumScopes & WNNC_ENUM_GLOBAL)
 745                             {
 746                                 HANDLE handle;
 747
 748                                 ret = providerTable->table[index].openEnum(
 749                                  dwScope, dwType, dwUsage, lpNet, &handle);
 750                                 if (ret == WN_SUCCESS)
 751                                 {
 752                                     *lphEnum =
 753                                      (HANDLE)_createProviderEnumerator(
 754                                      dwScope, dwType, dwUsage, index, handle);
 755                                     ret = *lphEnum ? WN_SUCCESS :
 756                                      WN_OUT_OF_MEMORY;
 757                                 }
 758                             }
 759                             else
 760                                 ret = WN_NOT_SUPPORTED;
 761                         }
 762                         else
 763                             ret = WN_BAD_PROVIDER;
 764                     }
 765                     else if (lpNet->lpRemoteName)
 766                     {
 767                         *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope,
 768                          dwType, dwUsage, lpNet);
 769                         ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 770                     }
 771                     else
 772                     {
 773                         if (lpNet->lpComment && !strcmpW(lpNet->lpComment,
 774                          providerTable->entireNetwork))
 775                         {
 776                             /* comment matches the "Entire Network", enumerate
 777                              * global scope of every provider
 778                              */
 779                             *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope,
 780                              dwType, dwUsage, lpNet);
 781                         }
 782                         else
 783                         {
 784                             /* this is the same as not having passed lpNet */
 785                             *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope,
 786                              dwType, dwUsage, NULL);
 787                         }
 788                         ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 789                     }
 790                 }
 791                 else
 792                 {
 793                     *lphEnum = (HANDLE)_createGlobalEnumeratorW(dwScope, dwType,
 794                      dwUsage, lpNet);
 795                     ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 796                 }
 797                 break;
 798             case RESOURCE_CONTEXT:
 799                 *lphEnum = (HANDLE)_createContextEnumerator(dwScope, dwType,
 800                  dwUsage);
 801                 ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 802                 break;
 803             case RESOURCE_REMEMBERED:
 804             case RESOURCE_CONNECTED:
 805                 *lphEnum = (HANDLE)_createNullEnumerator();
 806                 ret = *lphEnum ? WN_SUCCESS : WN_OUT_OF_MEMORY;
 807                 break;
 808             default:
 809                 WARN("unknown scope 0x%08x\n", dwScope);
 810                 ret = WN_BAD_VALUE;
 811         }
 812     }
 813     if (ret)
 814         SetLastError(ret);
 815     TRACE("Returning %d\n", ret);
 816     return ret;
 817 }
 818
 819 /*********************************************************************
 820  * WNetEnumResourceA [MPR.@]
 821  */
 822 DWORD WINAPI WNetEnumResourceA( HANDLE hEnum, LPDWORD lpcCount,
 823                                 LPVOID lpBuffer, LPDWORD lpBufferSize )
 824 {
 825     DWORD ret;
 826
 827     TRACE( "(%p, %p, %p, %p)\n", hEnum, lpcCount, lpBuffer, lpBufferSize );
 828
 829     if (!hEnum)
 830         ret = WN_BAD_POINTER;
 831     else if (!lpcCount)
 832         ret = WN_BAD_POINTER;
 833     else if (!lpBuffer)
 834         ret = WN_BAD_POINTER;
 835     else if (!lpBufferSize)
 836         ret = WN_BAD_POINTER;
 837     else if (*lpBufferSize < sizeof(NETRESOURCEA))
 838     {
 839         *lpBufferSize = sizeof(NETRESOURCEA);
 840         ret = WN_MORE_DATA;
 841     }
 842     else
 843     {
 844         DWORD localCount = *lpcCount, localSize = *lpBufferSize;
 845         LPVOID localBuffer = HeapAlloc(GetProcessHeap(), 0, localSize);
 846
 847         if (localBuffer)
 848         {
 849             ret = WNetEnumResourceW(hEnum, &localCount, localBuffer,
 850              &localSize);
 851             if (ret == WN_SUCCESS || (ret == WN_MORE_DATA && localCount != -1))
 852             {
 853                 /* FIXME: this isn't necessarily going to work in the case of
 854                  * WN_MORE_DATA, because our enumerator may have moved on to
 855                  * the next provider.  MSDN states that a large (16KB) buffer
 856                  * size is the appropriate usage of this function, so
 857                  * hopefully it won't be an issue.
 858                  */
 859                 ret = _thunkNetResourceArrayWToA((LPNETRESOURCEW)localBuffer,
 860                  &localCount, lpBuffer, lpBufferSize);
 861                 *lpcCount = localCount;
 862             }
 863             HeapFree(GetProcessHeap(), 0, localBuffer);
 864         }
 865         else
 866             ret = WN_OUT_OF_MEMORY;
 867     }
 868     if (ret)
 869         SetLastError(ret);
 870     TRACE("Returning %d\n", ret);
 871     return ret;
 872 }
 873
 874 static DWORD _countProviderBytesW(PWNetProvider provider)
 875 {
 876     DWORD ret;
 877
 878     if (provider)
 879     {
 880         ret = sizeof(NETRESOURCEW);
 881         ret += 2 * (strlenW(provider->name) + 1) * sizeof(WCHAR);
 882     }
 883     else
 884         ret = 0;
 885     return ret;
 886 }
 887
 888 static DWORD _enumerateProvidersW(PWNetEnumerator enumerator, LPDWORD lpcCount,
 889  LPVOID lpBuffer, const DWORD *lpBufferSize)
 890 {
 891     DWORD ret;
 892
 893     if (!enumerator)
 894         return WN_BAD_POINTER;
 895     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
 896         return WN_BAD_VALUE;
 897     if (!lpcCount)
 898         return WN_BAD_POINTER;
 899     if (!lpBuffer)
 900         return WN_BAD_POINTER;
 901     if (!lpBufferSize)
 902         return WN_BAD_POINTER;
 903     if (*lpBufferSize < sizeof(NETRESOURCEA))
 904         return WN_MORE_DATA;
 905
 906     if (!providerTable || enumerator->providerIndex >=
 907      providerTable->numProviders)
 908         ret = WN_NO_MORE_ENTRIES;
 909     else
 910     {
 911         DWORD bytes = 0, count = 0, countLimit, i;
 912         LPNETRESOURCEW resource;
 913         LPWSTR strNext;
 914
 915         countLimit = *lpcCount == -1 ?
 916          providerTable->numProviders - enumerator->providerIndex : *lpcCount;
 917         while (count < countLimit && bytes < *lpBufferSize)
 918         {
 919             DWORD bytesNext = _countProviderBytesW(
 920              &providerTable->table[count + enumerator->providerIndex]);
 921
 922             if (bytes + bytesNext < *lpBufferSize)
 923             {
 924                 bytes += bytesNext;
 925                 count++;
 926             }
 927         }
 928         strNext = (LPWSTR)((LPBYTE)lpBuffer + count * sizeof(NETRESOURCEW));
 929         for (i = 0, resource = (LPNETRESOURCEW)lpBuffer; i < count;
 930          i++, resource++)
 931         {
 932             resource->dwScope = RESOURCE_GLOBALNET;
 933             resource->dwType = RESOURCETYPE_ANY;
 934             resource->dwDisplayType = RESOURCEDISPLAYTYPE_NETWORK;
 935             resource->dwUsage = RESOURCEUSAGE_CONTAINER |
 936              RESOURCEUSAGE_RESERVED;
 937             resource->lpLocalName = NULL;
 938             resource->lpRemoteName = strNext;
 939             strcpyW(resource->lpRemoteName,
 940              providerTable->table[i + enumerator->providerIndex].name);
 941             strNext += strlenW(resource->lpRemoteName) + 1;
 942             resource->lpComment = NULL;
 943             resource->lpProvider = strNext;
 944             strcpyW(resource->lpProvider,
 945              providerTable->table[i + enumerator->providerIndex].name);
 946             strNext += strlenW(resource->lpProvider) + 1;
 947         }
 948         enumerator->providerIndex += count;
 949         *lpcCount = count;
 950         ret = count > 0 ? WN_SUCCESS : WN_MORE_DATA;
 951     }
 952     TRACE("Returning %d\n", ret);
 953     return ret;
 954 }
 955
 956 /* Advances the enumerator (assumed to be a global enumerator) to the next
 957  * provider that supports the enumeration scope passed to WNetOpenEnum.  Does
 958  * not open a handle with the next provider.
 959  * If the existing handle is NULL, may leave the enumerator unchanged, since
 960  * the current provider may support the desired scope.
 961  * If the existing handle is not NULL, closes it before moving on.
 962  * Returns WN_SUCCESS on success, WN_NO_MORE_ENTRIES if there is no available
 963  * provider, and another error on failure.
 964  */
 965 static DWORD _globalEnumeratorAdvance(PWNetEnumerator enumerator)
 966 {
 967     if (!enumerator)
 968         return WN_BAD_POINTER;
 969     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
 970         return WN_BAD_VALUE;
 971     if (!providerTable || enumerator->providerIndex >=
 972      providerTable->numProviders)
 973         return WN_NO_MORE_ENTRIES;
 974
 975     if (enumerator->providerDone)
 976     {
 977         DWORD dwEnum = 0;
 978         enumerator->providerDone = FALSE;
 979         if (enumerator->handle)
 980         {
 981             providerTable->table[enumerator->providerIndex].closeEnum(
 982              enumerator->handle);
 983             enumerator->handle = NULL;
 984             enumerator->providerIndex++;
 985         }
 986         if (enumerator->dwScope == RESOURCE_CONNECTED)
 987             dwEnum = WNNC_ENUM_LOCAL;
 988         else if (enumerator->dwScope == RESOURCE_GLOBALNET)
 989             dwEnum = WNNC_ENUM_GLOBAL;
 990         else if (enumerator->dwScope == RESOURCE_CONTEXT)
 991             dwEnum = WNNC_ENUM_CONTEXT;
 992         for (; enumerator->providerIndex < providerTable->numProviders &&
 993          !(providerTable->table[enumerator->providerIndex].dwEnumScopes
 994          & dwEnum); enumerator->providerIndex++)
 995             ;
 996     }
 997     return enumerator->providerIndex < providerTable->numProviders ?
 998      WN_SUCCESS : WN_NO_MORE_ENTRIES;
 999 }
1000
1001 /* "Passes through" call to the next provider that supports the enumeration
1002  * type.
1003  * FIXME: if one call to a provider's enumerator succeeds while there's still
1004  * space in lpBuffer, I don't call to the next provider.  The caller may not
1005  * expect that it should call EnumResourceW again with a return value of
1006  * WN_SUCCESS (depending what *lpcCount was to begin with).  That means strings
1007  * may have to be moved around a bit, ick.
1008  */
1009 static DWORD _enumerateGlobalPassthroughW(PWNetEnumerator enumerator,
1010  LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
1011 {
1012     DWORD ret;
1013
1014     if (!enumerator)
1015         return WN_BAD_POINTER;
1016     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
1017         return WN_BAD_VALUE;
1018     if (!lpcCount)
1019         return WN_BAD_POINTER;
1020     if (!lpBuffer)
1021         return WN_BAD_POINTER;
1022     if (!lpBufferSize)
1023         return WN_BAD_POINTER;
1024     if (*lpBufferSize < sizeof(NETRESOURCEW))
1025         return WN_MORE_DATA;
1026
1027     ret = _globalEnumeratorAdvance(enumerator);
1028     if (ret == WN_SUCCESS)
1029     {
1030         ret = providerTable->table[enumerator->providerIndex].
1031          openEnum(enumerator->dwScope, enumerator->dwType,
1032          enumerator->dwUsage, enumerator->lpNet,
1033          &enumerator->handle);
1034         if (ret == WN_SUCCESS)
1035         {
1036             ret = providerTable->table[enumerator->providerIndex].
1037              enumResource(enumerator->handle, lpcCount, lpBuffer,
1038              lpBufferSize);
1039             if (ret != WN_MORE_DATA)
1040                 enumerator->providerDone = TRUE;
1041         }
1042     }
1043     TRACE("Returning %d\n", ret);
1044     return ret;
1045 }
1046
1047 static DWORD _enumerateGlobalW(PWNetEnumerator enumerator, LPDWORD lpcCount,
1048  LPVOID lpBuffer, LPDWORD lpBufferSize)
1049 {
1050     DWORD ret;
1051
1052     if (!enumerator)
1053         return WN_BAD_POINTER;
1054     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_GLOBAL)
1055         return WN_BAD_VALUE;
1056     if (!lpcCount)
1057         return WN_BAD_POINTER;
1058     if (!lpBuffer)
1059         return WN_BAD_POINTER;
1060     if (!lpBufferSize)
1061         return WN_BAD_POINTER;
1062     if (*lpBufferSize < sizeof(NETRESOURCEW))
1063         return WN_MORE_DATA;
1064     if (!providerTable)
1065         return WN_NO_NETWORK;
1066
1067     switch (enumerator->dwScope)
1068     {
1069         case RESOURCE_GLOBALNET:
1070             if (enumerator->lpNet)
1071                 ret = _enumerateGlobalPassthroughW(enumerator, lpcCount,
1072                  lpBuffer, lpBufferSize);
1073             else
1074                 ret = _enumerateProvidersW(enumerator, lpcCount, lpBuffer,
1075                  lpBufferSize);
1076             break;
1077         case RESOURCE_CONTEXT:
1078             ret = _enumerateGlobalPassthroughW(enumerator, lpcCount, lpBuffer,
1079              lpBufferSize);
1080             break;
1081         default:
1082             WARN("unexpected scope 0x%08x\n", enumerator->dwScope);
1083             ret = WN_NO_MORE_ENTRIES;
1084     }
1085     TRACE("Returning %d\n", ret);
1086     return ret;
1087 }
1088
1089 static DWORD _enumerateProviderW(PWNetEnumerator enumerator, LPDWORD lpcCount,
1090  LPVOID lpBuffer, LPDWORD lpBufferSize)
1091 {
1092     if (!enumerator)
1093         return WN_BAD_POINTER;
1094     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_PROVIDER)
1095         return WN_BAD_VALUE;
1096     if (!enumerator->handle)
1097         return WN_BAD_VALUE;
1098     if (!lpcCount)
1099         return WN_BAD_POINTER;
1100     if (!lpBuffer)
1101         return WN_BAD_POINTER;
1102     if (!lpBufferSize)
1103         return WN_BAD_POINTER;
1104     if (!providerTable)
1105         return WN_NO_NETWORK;
1106     if (enumerator->providerIndex >= providerTable->numProviders)
1107         return WN_NO_MORE_ENTRIES;
1108     if (!providerTable->table[enumerator->providerIndex].enumResource)
1109         return WN_BAD_VALUE;
1110     return providerTable->table[enumerator->providerIndex].enumResource(
1111      enumerator->handle, lpcCount, lpBuffer, lpBufferSize);
1112 }
1113
1114 static DWORD _enumerateContextW(PWNetEnumerator enumerator, LPDWORD lpcCount,
1115  LPVOID lpBuffer, LPDWORD lpBufferSize)
1116 {
1117     DWORD ret;
1118     size_t cchEntireNetworkLen, bytesNeeded;
1119
1120     if (!enumerator)
1121         return WN_BAD_POINTER;
1122     if (enumerator->enumType != WNET_ENUMERATOR_TYPE_CONTEXT)
1123         return WN_BAD_VALUE;
1124     if (!lpcCount)
1125         return WN_BAD_POINTER;
1126     if (!lpBuffer)
1127         return WN_BAD_POINTER;
1128     if (!lpBufferSize)
1129         return WN_BAD_POINTER;
1130     if (!providerTable)
1131         return WN_NO_NETWORK;
1132
1133     cchEntireNetworkLen = strlenW(providerTable->entireNetwork) + 1;
1134     bytesNeeded = sizeof(NETRESOURCEW) + cchEntireNetworkLen * sizeof(WCHAR);
1135     if (*lpBufferSize < bytesNeeded)
1136     {
1137         *lpBufferSize = bytesNeeded;
1138         ret = WN_MORE_DATA;
1139     }
1140     else
1141     {
1142         LPNETRESOURCEW lpNet = (LPNETRESOURCEW)lpBuffer;
1143
1144         lpNet->dwScope = RESOURCE_GLOBALNET;
1145         lpNet->dwType = enumerator->dwType;
1146         lpNet->dwDisplayType = RESOURCEDISPLAYTYPE_ROOT;
1147         lpNet->dwUsage = RESOURCEUSAGE_CONTAINER;
1148         lpNet->lpLocalName = NULL;
1149         lpNet->lpRemoteName = NULL;
1150         lpNet->lpProvider = NULL;
1151         /* odd, but correct: put comment at end of buffer, so it won't get
1152          * overwritten by subsequent calls to a provider's enumResource
1153          */
1154         lpNet->lpComment = (LPWSTR)((LPBYTE)lpBuffer + *lpBufferSize -
1155          (cchEntireNetworkLen * sizeof(WCHAR)));
1156         strcpyW(lpNet->lpComment, providerTable->entireNetwork);
1157         ret = WN_SUCCESS;
1158     }
1159     if (ret == WN_SUCCESS)
1160     {
1161         DWORD bufferSize = *lpBufferSize - bytesNeeded;
1162
1163         /* "Entire Network" entry enumerated--morph this into a global
1164          * enumerator.  enumerator->lpNet continues to be NULL, since it has
1165          * no meaning when the scope isn't RESOURCE_GLOBALNET.
1166          */
1167         enumerator->enumType = WNET_ENUMERATOR_TYPE_GLOBAL;
1168         ret = _enumerateGlobalW(enumerator, lpcCount,
1169          (LPBYTE)lpBuffer + bytesNeeded, &bufferSize);
1170         if (ret == WN_SUCCESS)
1171         {
1172             /* reflect the fact that we already enumerated "Entire Network" */
1173             lpcCount++;
1174             *lpBufferSize = bufferSize + bytesNeeded;
1175         }
1176         else
1177         {
1178             /* the provider enumeration failed, but we already succeeded in
1179              * enumerating "Entire Network"--leave type as global to allow a
1180              * retry, but indicate success with a count of one.
1181              */
1182             ret = WN_SUCCESS;
1183             *lpcCount = 1;
1184             *lpBufferSize = bytesNeeded;
1185         }
1186     }
1187     TRACE("Returning %d\n", ret);
1188     return ret;
1189 }
1190
1191 /*********************************************************************
1192  * WNetEnumResourceW [MPR.@]
1193  */
1194 DWORD WINAPI WNetEnumResourceW( HANDLE hEnum, LPDWORD lpcCount,
1195                                 LPVOID lpBuffer, LPDWORD lpBufferSize )
1196 {
1197     DWORD ret;
1198
1199     TRACE( "(%p, %p, %p, %p)\n", hEnum, lpcCount, lpBuffer, lpBufferSize );
1200
1201     if (!hEnum)
1202         ret = WN_BAD_POINTER;
1203     else if (!lpcCount)
1204         ret = WN_BAD_POINTER;
1205     else if (!lpBuffer)
1206         ret = WN_BAD_POINTER;
1207     else if (!lpBufferSize)
1208         ret = WN_BAD_POINTER;
1209     else if (*lpBufferSize < sizeof(NETRESOURCEW))
1210     {
1211         *lpBufferSize = sizeof(NETRESOURCEW);
1212         ret = WN_MORE_DATA;
1213     }
1214     else
1215     {
1216         PWNetEnumerator enumerator = (PWNetEnumerator)hEnum;
1217
1218         switch (enumerator->enumType)
1219         {
1220             case WNET_ENUMERATOR_TYPE_NULL:
1221                 ret = WN_NO_MORE_ENTRIES;
1222                 break;
1223             case WNET_ENUMERATOR_TYPE_GLOBAL:
1224                 ret = _enumerateGlobalW(enumerator, lpcCount, lpBuffer,
1225                  lpBufferSize);
1226                 break;
1227             case WNET_ENUMERATOR_TYPE_PROVIDER:
1228                 ret = _enumerateProviderW(enumerator, lpcCount, lpBuffer,
1229                  lpBufferSize);
1230                 break;
1231             case WNET_ENUMERATOR_TYPE_CONTEXT:
1232                 ret = _enumerateContextW(enumerator, lpcCount, lpBuffer,
1233                  lpBufferSize);
1234                 break;
1235             default:
1236                 WARN("bogus enumerator type!\n");
1237                 ret = WN_NO_NETWORK;
1238         }
1239     }
1240     if (ret)
1241         SetLastError(ret);
1242     TRACE("Returning %d\n", ret);
1243     return ret;
1244 }
1245
1246 /*********************************************************************
1247  * WNetCloseEnum [MPR.@]
1248  */
1249 DWORD WINAPI WNetCloseEnum( HANDLE hEnum )
1250 {
1251     DWORD ret;
1252
1253     TRACE( "(%p)\n", hEnum );
1254
1255     if (hEnum)
1256     {
1257         PWNetEnumerator enumerator = (PWNetEnumerator)hEnum;
1258
1259         switch (enumerator->enumType)
1260         {
1261             case WNET_ENUMERATOR_TYPE_NULL:
1262                 ret = WN_SUCCESS;
1263                 break;
1264             case WNET_ENUMERATOR_TYPE_GLOBAL:
1265                 if (enumerator->lpNet)
1266                     _freeEnumNetResource(enumerator->lpNet);
1267                 if (enumerator->handle)
1268                     providerTable->table[enumerator->providerIndex].
1269                      closeEnum(enumerator->handle);
1270                 ret = WN_SUCCESS;
1271                 break;
1272             case WNET_ENUMERATOR_TYPE_PROVIDER:
1273                 if (enumerator->handle)
1274                     providerTable->table[enumerator->providerIndex].
1275                      closeEnum(enumerator->handle);
1276                 ret = WN_SUCCESS;
1277                 break;
1278             default:
1279                 WARN("bogus enumerator type!\n");
1280                 ret = WN_BAD_HANDLE;
1281         }
1282         HeapFree(GetProcessHeap(), 0, hEnum);
1283     }
1284     else
1285         ret = WN_BAD_HANDLE;
1286     if (ret)
1287         SetLastError(ret);
1288     TRACE("Returning %d\n", ret);
1289     return ret;
1290 }
1291
1292 /*********************************************************************
1293  * WNetGetResourceInformationA [MPR.@]
1294  *
1295  * See WNetGetResourceInformationW
1296  */
1297 DWORD WINAPI WNetGetResourceInformationA( LPNETRESOURCEA lpNetResource,
1298                                           LPVOID lpBuffer, LPDWORD cbBuffer,
1299                                           LPSTR *lplpSystem )
1300 {
1301     DWORD ret;
1302
1303     TRACE( "(%p, %p, %p, %p)\n",
1304            lpNetResource, lpBuffer, cbBuffer, lplpSystem );
1305
1306     if (!providerTable || providerTable->numProviders == 0)
1307         ret = WN_NO_NETWORK;
1308     else if (lpNetResource)
1309     {
1310         LPNETRESOURCEW lpNetResourceW = NULL;
1311         DWORD size = 1024, count = 1;
1312         DWORD len;
1313
1314         lpNetResourceW = HeapAlloc(GetProcessHeap(), 0, size);
1315         ret = _thunkNetResourceArrayAToW(lpNetResource, &count, lpNetResourceW, &size);
1316         if (ret == WN_MORE_DATA)
1317         {
1318             HeapFree(GetProcessHeap(), 0, lpNetResourceW);
1319             lpNetResourceW = HeapAlloc(GetProcessHeap(), 0, size);
1320             if (lpNetResourceW)
1321                 ret = _thunkNetResourceArrayAToW(lpNetResource,
1322                         &count, lpNetResourceW, &size);
1323             else
1324                 ret = WN_OUT_OF_MEMORY;
1325         }
1326         if (ret == WN_SUCCESS)
1327         {
1328             LPWSTR lpSystemW = NULL;
1329             LPVOID lpBufferW;
1330             size = 1024;
1331             lpBufferW = HeapAlloc(GetProcessHeap(), 0, size);
1332             if (lpBufferW)
1333             {
1334                 ret = WNetGetResourceInformationW(lpNetResourceW,
1335                         lpBufferW, &size, &lpSystemW);
1336                 if (ret == WN_MORE_DATA)
1337                 {
1338                     HeapFree(GetProcessHeap(), 0, lpBufferW);
1339                     lpBufferW = HeapAlloc(GetProcessHeap(), 0, size);
1340                     if (lpBufferW)
1341                         ret = WNetGetResourceInformationW(lpNetResourceW,
1342                             lpBufferW, &size, &lpSystemW);
1343                     else
1344                         ret = WN_OUT_OF_MEMORY;
1345                 }
1346                 if (ret == WN_SUCCESS)
1347                 {
1348                     ret = _thunkNetResourceArrayWToA(lpBufferW,
1349                             &count, lpBuffer, cbBuffer);
1350                     HeapFree(GetProcessHeap(), 0, lpNetResourceW);
1351                     lpNetResourceW = lpBufferW;
1352                     size = sizeof(NETRESOURCEA);
1353                     size += WideCharToMultiByte(CP_ACP, 0, lpNetResourceW->lpRemoteName,
1354                             -1, NULL, 0, NULL, NULL);
1355                     size += WideCharToMultiByte(CP_ACP, 0, lpNetResourceW->lpProvider,
1356                             -1, NULL, 0, NULL, NULL);
1357
1358                     len = WideCharToMultiByte(CP_ACP, 0, lpSystemW,
1359                                       -1, NULL, 0, NULL, NULL);
1360                     if ((len) && ( size + len < *cbBuffer))
1361                     {
1362                         *lplpSystem = (char*)lpBuffer + *cbBuffer - len;
1363                         WideCharToMultiByte(CP_ACP, 0, lpSystemW, -1,
1364                              *lplpSystem, len, NULL, NULL);
1365                          ret = WN_SUCCESS;
1366                     }
1367                     else
1368                         ret = WN_MORE_DATA;
1369                 }
1370                 else
1371                     ret = WN_OUT_OF_MEMORY;
1372                 HeapFree(GetProcessHeap(), 0, lpBufferW);
1373             }
1374             else
1375                 ret = WN_OUT_OF_MEMORY;
1376             HeapFree(GetProcessHeap(), 0, lpSystemW);
1377         }
1378         HeapFree(GetProcessHeap(), 0, lpNetResourceW);
1379     }
1380     else
1381         ret = WN_NO_NETWORK;
1382
1383     if (ret)
1384         SetLastError(ret);
1385     TRACE("Returning %d\n", ret);
1386     return ret;
1387 }
1388
1389 /*********************************************************************
1390  * WNetGetResourceInformationW [MPR.@]
1391  *
1392  * WNetGetResourceInformationW function identifies the network provider
1393  * that owns the resource and gets information about the type of the resource.
1394  *
1395  * PARAMS:
1396  *  lpNetResource    [ I]    the pointer to NETRESOURCEW structure, that
1397  *                          defines a network resource.
1398  *  lpBuffer         [ O]   the pointer to buffer, containing result. It
1399  *                          contains NETRESOURCEW structure and strings to
1400  *                          which the members of the NETRESOURCEW structure
1401  *                          point.
1402  *  cbBuffer         [I/O] the pointer to DWORD number - size of buffer
1403  *                          in bytes.
1404  *  lplpSystem       [ O]   the pointer to string in the output buffer,
1405  *                          containing the part of the resource name without
1406  *                          names of the server and share.
1407  *
1408  * RETURNS:
1409  *  NO_ERROR if the function succeeds. System error code if the function fails.
1410  */
1411
1412 DWORD WINAPI WNetGetResourceInformationW( LPNETRESOURCEW lpNetResource,
1413                                           LPVOID lpBuffer, LPDWORD cbBuffer,
1414                                           LPWSTR *lplpSystem )
1415 {
1416     DWORD ret = WN_NO_NETWORK;
1417     DWORD index;
1418
1419     TRACE( "(%p, %p, %p, %p)\n",
1420            lpNetResource, lpBuffer, cbBuffer, lplpSystem);
1421
1422     if (!(lpBuffer))
1423         ret = WN_OUT_OF_MEMORY;
1424     else if (providerTable != NULL)
1425     {
1426         /* FIXME: For function value of a variable is indifferent, it does
1427          * search of all providers in a network.
1428          */
1429         for (index = 0; index < providerTable->numProviders; index++)
1430         {
1431             if(providerTable->table[index].getCaps(WNNC_DIALOG) &
1432                 WNNC_DLG_GETRESOURCEINFORMATION)
1433             {
1434                 if (providerTable->table[index].getResourceInformation)
1435                     ret = providerTable->table[index].getResourceInformation(
1436                         lpNetResource, lpBuffer, cbBuffer, lplpSystem);
1437                 else
1438                     ret = WN_NO_NETWORK;
1439                 if (ret == WN_SUCCESS)
1440                     break;
1441             }
1442         }
1443     }
1444     if (ret)
1445         SetLastError(ret);
1446     return ret;
1447 }
1448
1449 /*********************************************************************
1450  * WNetGetResourceParentA [MPR.@]
1451  */
1452 DWORD WINAPI WNetGetResourceParentA( LPNETRESOURCEA lpNetResource,
1453                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1454 {
1455     FIXME( "(%p, %p, %p): stub\n",
1456            lpNetResource, lpBuffer, lpBufferSize );
1457
1458     SetLastError(WN_NO_NETWORK);
1459     return WN_NO_NETWORK;
1460 }
1461
1462 /*********************************************************************
1463  * WNetGetResourceParentW [MPR.@]
1464  */
1465 DWORD WINAPI WNetGetResourceParentW( LPNETRESOURCEW lpNetResource,
1466                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1467 {
1468     FIXME( "(%p, %p, %p): stub\n",
1469            lpNetResource, lpBuffer, lpBufferSize );
1470
1471     SetLastError(WN_NO_NETWORK);
1472     return WN_NO_NETWORK;
1473 }
1474
1475
1476
1477 /*
1478  * Connection Functions
1479  */
1480
1481 /*********************************************************************
1482  *  WNetAddConnectionA [MPR.@]
1483  */
1484 DWORD WINAPI WNetAddConnectionA( LPCSTR lpRemoteName, LPCSTR lpPassword,
1485                                  LPCSTR lpLocalName )
1486 {
1487     FIXME( "(%s, %p, %s): stub\n",
1488            debugstr_a(lpRemoteName), lpPassword, debugstr_a(lpLocalName) );
1489
1490     SetLastError(WN_NO_NETWORK);
1491     return WN_NO_NETWORK;
1492 }
1493
1494 /*********************************************************************
1495  *  WNetAddConnectionW [MPR.@]
1496  */
1497 DWORD WINAPI WNetAddConnectionW( LPCWSTR lpRemoteName, LPCWSTR lpPassword,
1498                                  LPCWSTR lpLocalName )
1499 {
1500     FIXME( "(%s, %p, %s): stub\n",
1501            debugstr_w(lpRemoteName), lpPassword, debugstr_w(lpLocalName) );
1502
1503     SetLastError(WN_NO_NETWORK);
1504     return WN_NO_NETWORK;
1505 }
1506
1507 /*********************************************************************
1508  *  WNetAddConnection2A [MPR.@]
1509  */
1510 DWORD WINAPI WNetAddConnection2A( LPNETRESOURCEA lpNetResource,
1511                                   LPCSTR lpPassword, LPCSTR lpUserID,
1512                                   DWORD dwFlags )
1513 {
1514     FIXME( "(%p, %p, %s, 0x%08X): stub\n",
1515            lpNetResource, lpPassword, debugstr_a(lpUserID), dwFlags );
1516
1517     SetLastError(WN_NO_NETWORK);
1518     return WN_NO_NETWORK;
1519 }
1520
1521 /*********************************************************************
1522  * WNetAddConnection2W [MPR.@]
1523  */
1524 DWORD WINAPI WNetAddConnection2W( LPNETRESOURCEW lpNetResource,
1525                                   LPCWSTR lpPassword, LPCWSTR lpUserID,
1526                                   DWORD dwFlags )
1527 {
1528     FIXME( "(%p, %p, %s, 0x%08X): stub\n",
1529            lpNetResource, lpPassword, debugstr_w(lpUserID), dwFlags );
1530
1531     SetLastError(WN_NO_NETWORK);
1532     return WN_NO_NETWORK;
1533 }
1534
1535 /*********************************************************************
1536  * WNetAddConnection3A [MPR.@]
1537  */
1538 DWORD WINAPI WNetAddConnection3A( HWND hwndOwner, LPNETRESOURCEA lpNetResource,
1539                                   LPCSTR lpPassword, LPCSTR lpUserID,
1540                                   DWORD dwFlags )
1541 {
1542     FIXME( "(%p, %p, %p, %s, 0x%08X), stub\n",
1543            hwndOwner, lpNetResource, lpPassword, debugstr_a(lpUserID), dwFlags );
1544
1545     SetLastError(WN_NO_NETWORK);
1546     return WN_NO_NETWORK;
1547 }
1548
1549 /*********************************************************************
1550  * WNetAddConnection3W [MPR.@]
1551  */
1552 DWORD WINAPI WNetAddConnection3W( HWND hwndOwner, LPNETRESOURCEW lpNetResource,
1553                                   LPCWSTR lpPassword, LPCWSTR lpUserID,
1554                                   DWORD dwFlags )
1555 {
1556     FIXME( "(%p, %p, %p, %s, 0x%08X), stub\n",
1557            hwndOwner, lpNetResource, lpPassword, debugstr_w(lpUserID), dwFlags );
1558
1559     SetLastError(WN_NO_NETWORK);
1560     return WN_NO_NETWORK;
1561 }
1562
1563 /*****************************************************************
1564  *  WNetUseConnectionA [MPR.@]
1565  */
1566 DWORD WINAPI WNetUseConnectionA( HWND hwndOwner, LPNETRESOURCEA lpNetResource,
1567                                  LPCSTR lpPassword, LPCSTR lpUserID, DWORD dwFlags,
1568                                  LPSTR lpAccessName, LPDWORD lpBufferSize,
1569                                  LPDWORD lpResult )
1570 {
1571     FIXME( "(%p, %p, %p, %s, 0x%08X, %s, %p, %p), stub\n",
1572            hwndOwner, lpNetResource, lpPassword, debugstr_a(lpUserID), dwFlags,
1573            debugstr_a(lpAccessName), lpBufferSize, lpResult );
1574
1575     SetLastError(WN_NO_NETWORK);
1576     return WN_NO_NETWORK;
1577 }
1578
1579 /*****************************************************************
1580  *  WNetUseConnectionW [MPR.@]
1581  */
1582 DWORD WINAPI WNetUseConnectionW( HWND hwndOwner, LPNETRESOURCEW lpNetResource,
1583                                  LPCWSTR lpPassword, LPCWSTR lpUserID, DWORD dwFlags,
1584                                  LPWSTR lpAccessName, LPDWORD lpBufferSize,
1585                                  LPDWORD lpResult )
1586 {
1587     FIXME( "(%p, %p, %p, %s, 0x%08X, %s, %p, %p), stub\n",
1588            hwndOwner, lpNetResource, lpPassword, debugstr_w(lpUserID), dwFlags,
1589            debugstr_w(lpAccessName), lpBufferSize, lpResult );
1590
1591     SetLastError(WN_NO_NETWORK);
1592     return WN_NO_NETWORK;
1593 }
1594
1595 /*********************************************************************
1596  *  WNetCancelConnectionA [MPR.@]
1597  */
1598 DWORD WINAPI WNetCancelConnectionA( LPCSTR lpName, BOOL fForce )
1599 {
1600     FIXME( "(%s, %d), stub\n", debugstr_a(lpName), fForce );
1601
1602     return WN_SUCCESS;
1603 }
1604
1605 /*********************************************************************
1606  *  WNetCancelConnectionW [MPR.@]
1607  */
1608 DWORD WINAPI WNetCancelConnectionW( LPCWSTR lpName, BOOL fForce )
1609 {
1610     FIXME( "(%s, %d), stub\n", debugstr_w(lpName), fForce );
1611
1612     return WN_SUCCESS;
1613 }
1614
1615 /*********************************************************************
1616  *  WNetCancelConnection2A [MPR.@]
1617  */
1618 DWORD WINAPI WNetCancelConnection2A( LPCSTR lpName, DWORD dwFlags, BOOL fForce )
1619 {
1620     FIXME( "(%s, %08X, %d), stub\n", debugstr_a(lpName), dwFlags, fForce );
1621
1622     return WN_SUCCESS;
1623 }
1624
1625 /*********************************************************************
1626  *  WNetCancelConnection2W [MPR.@]
1627  */
1628 DWORD WINAPI WNetCancelConnection2W( LPCWSTR lpName, DWORD dwFlags, BOOL fForce )
1629 {
1630     FIXME( "(%s, %08X, %d), stub\n", debugstr_w(lpName), dwFlags, fForce );
1631
1632     return WN_SUCCESS;
1633 }
1634
1635 /*****************************************************************
1636  *  WNetRestoreConnectionA [MPR.@]
1637  */
1638 DWORD WINAPI WNetRestoreConnectionA( HWND hwndOwner, LPCSTR lpszDevice )
1639 {
1640     FIXME( "(%p, %s), stub\n", hwndOwner, debugstr_a(lpszDevice) );
1641
1642     SetLastError(WN_NO_NETWORK);
1643     return WN_NO_NETWORK;
1644 }
1645
1646 /*****************************************************************
1647  *  WNetRestoreConnectionW [MPR.@]
1648  */
1649 DWORD WINAPI WNetRestoreConnectionW( HWND hwndOwner, LPCWSTR lpszDevice )
1650 {
1651     FIXME( "(%p, %s), stub\n", hwndOwner, debugstr_w(lpszDevice) );
1652
1653     SetLastError(WN_NO_NETWORK);
1654     return WN_NO_NETWORK;
1655 }
1656
1657 /**************************************************************************
1658  * WNetGetConnectionA [MPR.@]
1659  *
1660  * RETURNS
1661  * - WN_BAD_LOCALNAME     lpLocalName makes no sense
1662  * - WN_NOT_CONNECTED     drive is a local drive
1663  * - WN_MORE_DATA         buffer isn't big enough
1664  * - WN_SUCCESS           success (net path in buffer)
1665  *
1666  * FIXME: need to test return values under different errors
1667  */
1668 DWORD WINAPI WNetGetConnectionA( LPCSTR lpLocalName,
1669                                  LPSTR lpRemoteName, LPDWORD lpBufferSize )
1670 {
1671     DWORD ret;
1672
1673     if (!lpLocalName)
1674         ret = WN_BAD_POINTER;
1675     else if (!lpBufferSize)
1676         ret = WN_BAD_POINTER;
1677     else if (!lpRemoteName && *lpBufferSize)
1678         ret = WN_BAD_POINTER;
1679     else
1680     {
1681         int len = MultiByteToWideChar(CP_ACP, 0, lpLocalName, -1, NULL, 0);
1682
1683         if (len)
1684         {
1685             PWSTR wideLocalName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1686
1687             if (wideLocalName)
1688             {
1689                 WCHAR wideRemoteStatic[MAX_PATH];
1690                 DWORD wideRemoteSize = sizeof(wideRemoteStatic) / sizeof(WCHAR);
1691
1692                 MultiByteToWideChar(CP_ACP, 0, lpLocalName, -1, wideLocalName, len);
1693
1694                 /* try once without memory allocation */
1695                 ret = WNetGetConnectionW(wideLocalName, wideRemoteStatic,
1696                  &wideRemoteSize);
1697                 if (ret == WN_SUCCESS)
1698                 {
1699                     int len = WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic,
1700                      -1, NULL, 0, NULL, NULL);
1701
1702                     if (len <= *lpBufferSize)
1703                     {
1704                         WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic, -1,
1705                          lpRemoteName, *lpBufferSize, NULL, NULL);
1706                         ret = WN_SUCCESS;
1707                     }
1708                     else
1709                     {
1710                         *lpBufferSize = len;
1711                         ret = WN_MORE_DATA;
1712                     }
1713                 }
1714                 else if (ret == WN_MORE_DATA)
1715                 {
1716                     PWSTR wideRemote = HeapAlloc(GetProcessHeap(), 0,
1717                      wideRemoteSize * sizeof(WCHAR));
1718
1719                     if (wideRemote)
1720                     {
1721                         ret = WNetGetConnectionW(wideLocalName, wideRemote,
1722                          &wideRemoteSize);
1723                         if (ret == WN_SUCCESS)
1724                         {
1725                             if (len <= *lpBufferSize)
1726                             {
1727                                 WideCharToMultiByte(CP_ACP, 0, wideRemoteStatic,
1728                                  -1, lpRemoteName, *lpBufferSize, NULL, NULL);
1729                                 ret = WN_SUCCESS;
1730                             }
1731                             else
1732                             {
1733                                 *lpBufferSize = len;
1734                                 ret = WN_MORE_DATA;
1735                             }
1736                         }
1737                         HeapFree(GetProcessHeap(), 0, wideRemote);
1738                     }
1739                     else
1740                         ret = WN_OUT_OF_MEMORY;
1741                 }
1742                 HeapFree(GetProcessHeap(), 0, wideLocalName);
1743             }
1744             else
1745                 ret = WN_OUT_OF_MEMORY;
1746         }
1747         else
1748             ret = WN_BAD_LOCALNAME;
1749     }
1750     if (ret)
1751         SetLastError(ret);
1752     TRACE("Returning %d\n", ret);
1753     return ret;
1754 }
1755
1756 /* find the network connection for a given drive; helper for WNetGetConnection */
1757 static DWORD get_drive_connection( WCHAR letter, LPWSTR remote, LPDWORD size )
1758 {
1759     char buffer[1024];
1760     struct mountmgr_unix_drive *data = (struct mountmgr_unix_drive *)buffer;
1761     HANDLE mgr;
1762     DWORD ret = WN_NOT_CONNECTED;
1763
1764     if ((mgr = CreateFileW( MOUNTMGR_DOS_DEVICE_NAME, GENERIC_READ|GENERIC_WRITE,
1765                             FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1766                             0, 0 )) == INVALID_HANDLE_VALUE)
1767     {
1768         ERR( "failed to open mount manager err %u\n", GetLastError() );
1769         return ret;
1770     }
1771     memset( data, 0, sizeof(*data) );
1772     data->letter = letter;
1773     if (DeviceIoControl( mgr, IOCTL_MOUNTMGR_QUERY_UNIX_DRIVE, data, sizeof(*data),
1774                          data, sizeof(buffer), NULL, NULL ))
1775     {
1776         char *p, *mount_point = buffer + data->mount_point_offset;
1777         DWORD len;
1778
1779         if (data->mount_point_offset && !strncmp( mount_point, "unc/", 4 ))
1780         {
1781             mount_point += 2;
1782             mount_point[0] = '\\';
1783             for (p = mount_point; *p; p++) if (*p == '/') *p = '\\';
1784
1785             len = MultiByteToWideChar( CP_UNIXCP, 0, mount_point, -1, NULL, 0 );
1786             if (len > *size)
1787             {
1788                 *size = len;
1789                 ret = WN_MORE_DATA;
1790             }
1791             else
1792             {
1793                 *size = MultiByteToWideChar( CP_UNIXCP, 0, mount_point, -1, remote, *size);
1794                 ret = WN_SUCCESS;
1795             }
1796         }
1797     }
1798     CloseHandle( mgr );
1799     return ret;
1800 }
1801
1802 /**************************************************************************
1803  * WNetGetConnectionW [MPR.@]
1804  *
1805  * FIXME: need to test return values under different errors
1806  */
1807 DWORD WINAPI WNetGetConnectionW( LPCWSTR lpLocalName,
1808                                  LPWSTR lpRemoteName, LPDWORD lpBufferSize )
1809 {
1810     DWORD ret;
1811
1812     TRACE("(%s, %p, %p)\n", debugstr_w(lpLocalName), lpRemoteName,
1813      lpBufferSize);
1814
1815     if (!lpLocalName)
1816         ret = WN_BAD_POINTER;
1817     else if (!lpBufferSize)
1818         ret = WN_BAD_POINTER;
1819     else if (!lpRemoteName && *lpBufferSize)
1820         ret = WN_BAD_POINTER;
1821     else if (!lpLocalName[0])
1822         ret = WN_BAD_LOCALNAME;
1823     else
1824     {
1825         if (lpLocalName[1] == ':')
1826         {
1827             switch(GetDriveTypeW(lpLocalName))
1828             {
1829             case DRIVE_REMOTE:
1830                 ret = get_drive_connection( lpLocalName[0], lpRemoteName, lpBufferSize );
1831                 break;
1832             case DRIVE_REMOVABLE:
1833             case DRIVE_FIXED:
1834             case DRIVE_CDROM:
1835                 TRACE("file is local\n");
1836                 ret = WN_NOT_CONNECTED;
1837                 break;
1838             default:
1839                 ret = WN_BAD_LOCALNAME;
1840             }
1841         }
1842         else
1843             ret = WN_BAD_LOCALNAME;
1844     }
1845     if (ret)
1846         SetLastError(ret);
1847     TRACE("Returning %d\n", ret);
1848     return ret;
1849 }
1850
1851 /**************************************************************************
1852  * WNetSetConnectionA [MPR.@]
1853  */
1854 DWORD WINAPI WNetSetConnectionA( LPCSTR lpName, DWORD dwProperty,
1855                                  LPVOID pvValue )
1856 {
1857     FIXME( "(%s, %08X, %p): stub\n", debugstr_a(lpName), dwProperty, pvValue );
1858
1859     SetLastError(WN_NO_NETWORK);
1860     return WN_NO_NETWORK;
1861 }
1862
1863 /**************************************************************************
1864  * WNetSetConnectionW [MPR.@]
1865  */
1866 DWORD WINAPI WNetSetConnectionW( LPCWSTR lpName, DWORD dwProperty,
1867                                  LPVOID pvValue )
1868 {
1869     FIXME( "(%s, %08X, %p): stub\n", debugstr_w(lpName), dwProperty, pvValue );
1870
1871     SetLastError(WN_NO_NETWORK);
1872     return WN_NO_NETWORK;
1873 }
1874
1875 /*****************************************************************
1876  * WNetGetUniversalNameA [MPR.@]
1877  */
1878 DWORD WINAPI WNetGetUniversalNameA ( LPCSTR lpLocalPath, DWORD dwInfoLevel,
1879                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1880 {
1881     DWORD err, size;
1882
1883     FIXME( "(%s, 0x%08X, %p, %p): stub\n",
1884            debugstr_a(lpLocalPath), dwInfoLevel, lpBuffer, lpBufferSize);
1885
1886     switch (dwInfoLevel)
1887     {
1888     case UNIVERSAL_NAME_INFO_LEVEL:
1889     {
1890         LPUNIVERSAL_NAME_INFOA info = (LPUNIVERSAL_NAME_INFOA)lpBuffer;
1891
1892         size = sizeof(*info) + lstrlenA(lpLocalPath) + 1;
1893         if (*lpBufferSize < size)
1894         {
1895             err = WN_MORE_DATA;
1896             break;
1897         }
1898         info->lpUniversalName = (char *)info + sizeof(*info);
1899         lstrcpyA(info->lpUniversalName, lpLocalPath);
1900         *lpBufferSize = size;
1901         err = WN_NO_ERROR;
1902         break;
1903     }
1904     case REMOTE_NAME_INFO_LEVEL:
1905         err = WN_NO_NETWORK;
1906         break;
1907
1908     default:
1909         err = WN_BAD_VALUE;
1910         break;
1911     }
1912
1913     SetLastError(err);
1914     return err;
1915 }
1916
1917 /*****************************************************************
1918  * WNetGetUniversalNameW [MPR.@]
1919  */
1920 DWORD WINAPI WNetGetUniversalNameW ( LPCWSTR lpLocalPath, DWORD dwInfoLevel,
1921                                      LPVOID lpBuffer, LPDWORD lpBufferSize )
1922 {
1923     DWORD err, size;
1924
1925     FIXME( "(%s, 0x%08X, %p, %p): stub\n",
1926            debugstr_w(lpLocalPath), dwInfoLevel, lpBuffer, lpBufferSize);
1927
1928     switch (dwInfoLevel)
1929     {
1930     case UNIVERSAL_NAME_INFO_LEVEL:
1931     {
1932         LPUNIVERSAL_NAME_INFOW info = (LPUNIVERSAL_NAME_INFOW)lpBuffer;
1933
1934         size = sizeof(*info) + (lstrlenW(lpLocalPath) + 1) * sizeof(WCHAR);
1935         if (*lpBufferSize < size)
1936         {
1937             err = WN_MORE_DATA;
1938             break;
1939         }
1940         info->lpUniversalName = (LPWSTR)((char *)info + sizeof(*info));
1941         lstrcpyW(info->lpUniversalName, lpLocalPath);
1942         *lpBufferSize = size;
1943         err = WN_NO_ERROR;
1944         break;
1945     }
1946     case REMOTE_NAME_INFO_LEVEL:
1947         err = WN_NO_NETWORK;
1948         break;
1949
1950     default:
1951         err = WN_BAD_VALUE;
1952         break;
1953     }
1954
1955     SetLastError(err);
1956     return err;
1957 }
1958
1959
1960
1961 /*
1962  * Other Functions
1963  */
1964
1965 /**************************************************************************
1966  * WNetGetUserA [MPR.@]
1967  *
1968  * FIXME: we should not return ourselves, but the owner of the drive lpName
1969  */
1970 DWORD WINAPI WNetGetUserA( LPCSTR lpName, LPSTR lpUserID, LPDWORD lpBufferSize )
1971 {
1972     if (GetUserNameA( lpUserID, lpBufferSize )) return WN_SUCCESS;
1973     return GetLastError();
1974 }
1975
1976 /*****************************************************************
1977  * WNetGetUserW [MPR.@]
1978  *
1979  * FIXME: we should not return ourselves, but the owner of the drive lpName
1980  */
1981 DWORD WINAPI WNetGetUserW( LPCWSTR lpName, LPWSTR lpUserID, LPDWORD lpBufferSize )
1982 {
1983     if (GetUserNameW( lpUserID, lpBufferSize )) return WN_SUCCESS;
1984     return GetLastError();
1985 }
1986
1987 /*********************************************************************
1988  * WNetConnectionDialog [MPR.@]
1989  */
1990 DWORD WINAPI WNetConnectionDialog( HWND hwnd, DWORD dwType )
1991 {
1992     FIXME( "(%p, %08X): stub\n", hwnd, dwType );
1993
1994     SetLastError(WN_NO_NETWORK);
1995     return WN_NO_NETWORK;
1996 }
1997
1998 /*********************************************************************
1999  * WNetConnectionDialog1A [MPR.@]
2000  */
2001 DWORD WINAPI WNetConnectionDialog1A( LPCONNECTDLGSTRUCTA lpConnDlgStruct )
2002 {
2003     FIXME( "(%p): stub\n", lpConnDlgStruct );
2004
2005     SetLastError(WN_NO_NETWORK);
2006     return WN_NO_NETWORK;
2007 }
2008
2009 /*********************************************************************
2010  * WNetConnectionDialog1W [MPR.@]
2011  */
2012 DWORD WINAPI WNetConnectionDialog1W( LPCONNECTDLGSTRUCTW lpConnDlgStruct )
2013 {
2014     FIXME( "(%p): stub\n", lpConnDlgStruct );
2015
2016     SetLastError(WN_NO_NETWORK);
2017     return WN_NO_NETWORK;
2018 }
2019
2020 /*********************************************************************
2021  * WNetDisconnectDialog [MPR.@]
2022  */
2023 DWORD WINAPI WNetDisconnectDialog( HWND hwnd, DWORD dwType )
2024 {
2025     FIXME( "(%p, %08X): stub\n", hwnd, dwType );
2026
2027     SetLastError(WN_NO_NETWORK);
2028     return WN_NO_NETWORK;
2029 }
2030
2031 /*********************************************************************
2032  * WNetDisconnectDialog1A [MPR.@]
2033  */
2034 DWORD WINAPI WNetDisconnectDialog1A( LPDISCDLGSTRUCTA lpConnDlgStruct )
2035 {
2036     FIXME( "(%p): stub\n", lpConnDlgStruct );
2037
2038     SetLastError(WN_NO_NETWORK);
2039     return WN_NO_NETWORK;
2040 }
2041
2042 /*********************************************************************
2043  * WNetDisconnectDialog1W [MPR.@]
2044  */
2045 DWORD WINAPI WNetDisconnectDialog1W( LPDISCDLGSTRUCTW lpConnDlgStruct )
2046 {
2047     FIXME( "(%p): stub\n", lpConnDlgStruct );
2048
2049     SetLastError(WN_NO_NETWORK);
2050     return WN_NO_NETWORK;
2051 }
2052
2053 /*********************************************************************
2054  * WNetGetLastErrorA [MPR.@]
2055  */
2056 DWORD WINAPI WNetGetLastErrorA( LPDWORD lpError,
2057                                 LPSTR lpErrorBuf, DWORD nErrorBufSize,
2058                                 LPSTR lpNameBuf, DWORD nNameBufSize )
2059 {
2060     FIXME( "(%p, %p, %d, %p, %d): stub\n",
2061            lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize );
2062
2063     SetLastError(WN_NO_NETWORK);
2064     return WN_NO_NETWORK;
2065 }
2066
2067 /*********************************************************************
2068  * WNetGetLastErrorW [MPR.@]
2069  */
2070 DWORD WINAPI WNetGetLastErrorW( LPDWORD lpError,
2071                                 LPWSTR lpErrorBuf, DWORD nErrorBufSize,
2072                          LPWSTR lpNameBuf, DWORD nNameBufSize )
2073 {
2074     FIXME( "(%p, %p, %d, %p, %d): stub\n",
2075            lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize );
2076
2077     SetLastError(WN_NO_NETWORK);
2078     return WN_NO_NETWORK;
2079 }
2080
2081 /*********************************************************************
2082  * WNetGetNetworkInformationA [MPR.@]
2083  */
2084 DWORD WINAPI WNetGetNetworkInformationA( LPCSTR lpProvider,
2085                                          LPNETINFOSTRUCT lpNetInfoStruct )
2086 {
2087     DWORD ret;
2088
2089     TRACE( "(%s, %p)\n", debugstr_a(lpProvider), lpNetInfoStruct );
2090
2091     if (!lpProvider)
2092         ret = WN_BAD_POINTER;
2093     else
2094     {
2095         int len;
2096
2097         len = MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, NULL, 0);
2098         if (len)
2099         {
2100             LPWSTR wideProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2101
2102             if (wideProvider)
2103             {
2104                 MultiByteToWideChar(CP_ACP, 0, lpProvider, -1, wideProvider,
2105                  len);
2106                 ret = WNetGetNetworkInformationW(wideProvider, lpNetInfoStruct);
2107                 HeapFree(GetProcessHeap(), 0, wideProvider);
2108             }
2109             else
2110                 ret = WN_OUT_OF_MEMORY;
2111         }
2112         else
2113             ret = GetLastError();
2114     }
2115     if (ret)
2116         SetLastError(ret);
2117     TRACE("Returning %d\n", ret);
2118     return ret;
2119 }
2120
2121 /*********************************************************************
2122  * WNetGetNetworkInformationW [MPR.@]
2123  */
2124 DWORD WINAPI WNetGetNetworkInformationW( LPCWSTR lpProvider,
2125                                          LPNETINFOSTRUCT lpNetInfoStruct )
2126 {
2127     DWORD ret;
2128
2129     TRACE( "(%s, %p)\n", debugstr_w(lpProvider), lpNetInfoStruct );
2130
2131     if (!lpProvider)
2132         ret = WN_BAD_POINTER;
2133     else if (!lpNetInfoStruct)
2134         ret = WN_BAD_POINTER;
2135     else if (lpNetInfoStruct->cbStructure < sizeof(NETINFOSTRUCT))
2136         ret = WN_BAD_VALUE;
2137     else
2138     {
2139         if (providerTable && providerTable->numProviders)
2140         {
2141             DWORD providerIndex = _findProviderIndexW(lpProvider);
2142
2143             if (providerIndex != BAD_PROVIDER_INDEX)
2144             {
2145                 lpNetInfoStruct->cbStructure = sizeof(NETINFOSTRUCT);
2146                 lpNetInfoStruct->dwProviderVersion =
2147                  providerTable->table[providerIndex].dwSpecVersion;
2148                 lpNetInfoStruct->dwStatus = NO_ERROR;
2149                 lpNetInfoStruct->dwCharacteristics = 0;
2150                 lpNetInfoStruct->dwHandle = 0;
2151                 lpNetInfoStruct->wNetType =
2152                  HIWORD(providerTable->table[providerIndex].dwNetType);
2153                 lpNetInfoStruct->dwPrinters = -1;
2154                 lpNetInfoStruct->dwDrives = -1;
2155                 ret = WN_SUCCESS;
2156             }
2157             else
2158                 ret = WN_BAD_PROVIDER;
2159         }
2160         else
2161             ret = WN_NO_NETWORK;
2162     }
2163     if (ret)
2164         SetLastError(ret);
2165     TRACE("Returning %d\n", ret);
2166     return ret;
2167 }
2168
2169 /*****************************************************************
2170  *  WNetGetProviderNameA [MPR.@]
2171  */
2172 DWORD WINAPI WNetGetProviderNameA( DWORD dwNetType,
2173                                    LPSTR lpProvider, LPDWORD lpBufferSize )
2174 {
2175     DWORD ret;
2176
2177     TRACE("(0x%08x, %s, %p)\n", dwNetType, debugstr_a(lpProvider),
2178      lpBufferSize);
2179
2180     if (!lpProvider)
2181         ret = WN_BAD_POINTER;
2182     else if (!lpBufferSize)
2183         ret = WN_BAD_POINTER;
2184     else
2185     {
2186         if (providerTable)
2187         {
2188             DWORD i;
2189
2190             ret = WN_NO_NETWORK;
2191             for (i = 0; i < providerTable->numProviders &&
2192              HIWORD(providerTable->table[i].dwNetType) != HIWORD(dwNetType);
2193              i++)
2194                 ;
2195             if (i < providerTable->numProviders)
2196             {
2197                 DWORD sizeNeeded = WideCharToMultiByte(CP_ACP, 0,
2198                  providerTable->table[i].name, -1, NULL, 0, NULL, NULL);
2199
2200                 if (*lpBufferSize < sizeNeeded)
2201                 {
2202                     *lpBufferSize = sizeNeeded;
2203                     ret = WN_MORE_DATA;
2204                 }
2205                 else
2206                 {
2207                     WideCharToMultiByte(CP_ACP, 0, providerTable->table[i].name,
2208                      -1, lpProvider, *lpBufferSize, NULL, NULL);
2209                     ret = WN_SUCCESS;
2210                     /* FIXME: is *lpBufferSize set to the number of characters
2211                      * copied? */
2212                 }
2213             }
2214         }
2215         else
2216             ret = WN_NO_NETWORK;
2217     }
2218     if (ret)
2219         SetLastError(ret);
2220     TRACE("Returning %d\n", ret);
2221     return ret;
2222 }
2223
2224 /*****************************************************************
2225  *  WNetGetProviderNameW [MPR.@]
2226  */
2227 DWORD WINAPI WNetGetProviderNameW( DWORD dwNetType,
2228                                    LPWSTR lpProvider, LPDWORD lpBufferSize )
2229 {
2230     DWORD ret;
2231
2232     TRACE("(0x%08x, %s, %p)\n", dwNetType, debugstr_w(lpProvider),
2233      lpBufferSize);
2234
2235     if (!lpProvider)
2236         ret = WN_BAD_POINTER;
2237     else if (!lpBufferSize)
2238         ret = WN_BAD_POINTER;
2239     else
2240     {
2241         if (providerTable)
2242         {
2243             DWORD i;
2244
2245             ret = WN_NO_NETWORK;
2246             for (i = 0; i < providerTable->numProviders &&
2247              HIWORD(providerTable->table[i].dwNetType) != HIWORD(dwNetType);
2248              i++)
2249                 ;
2250             if (i < providerTable->numProviders)
2251             {
2252                 DWORD sizeNeeded = strlenW(providerTable->table[i].name) + 1;
2253
2254                 if (*lpBufferSize < sizeNeeded)
2255                 {
2256                     *lpBufferSize = sizeNeeded;
2257                     ret = WN_MORE_DATA;
2258                 }
2259                 else
2260                 {
2261                     strcpyW(lpProvider, providerTable->table[i].name);
2262                     ret = WN_SUCCESS;
2263                     /* FIXME: is *lpBufferSize set to the number of characters
2264                      * copied? */
2265                 }
2266             }
2267         }
2268         else
2269             ret = WN_NO_NETWORK;
2270     }
2271     if (ret)
2272         SetLastError(ret);
2273     TRACE("Returning %d\n", ret);
2274     return ret;
2275 }