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