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