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