Énumération des ressources réseau
L’exemple suivant illustre une fonction définie par l’application (EnumerateFunc) qui énumère toutes les ressources d’un réseau. L’exemple spécifie NULL pour le pointeur vers la structure NETRESOURCE , car lorsque WNetOpenEnum reçoit un pointeur NULL , il récupère un handle à la racine du réseau.
Pour commencer l’énumération d’une ressource de conteneur réseau, votre application doit effectuer les étapes suivantes :
- Transmettez l’adresse d’une structure NETRESOURCE qui représente la ressource à la fonction WNetOpenEnum .
- Allouez une mémoire tampon suffisamment grande pour contenir le tableau de structures NETRESOURCE que la fonction WNetEnumResource retourne, ainsi que les chaînes vers lesquelles leurs membres pointent.
- Transmettez le handle de ressource retourné par WNetOpenEnum à la fonction WNetEnumResource .
- Fermez le handle de ressource lorsqu’il n’est plus nécessaire en appelant la fonction WNetCloseEnum .
Vous pouvez continuer à énumérer une ressource de conteneur décrite dans le tableau de structures NETRESOURCE récupérées par WNetEnumResource. Si le membre dwUsage de la structure NETRESOURCE est égal à RESOURCEUSAGE_CONTAINER, transmettez l’adresse de la structure à la fonction WNetOpenEnum pour ouvrir le conteneur et poursuivre l’énumération. Si dwUsage est égal à RESOURCEUSAGE_CONNECTABLE, l’application peut passer l’adresse de la structure à la fonction WNetAddConnection2 ou à la fonction WNetAddConnection3 pour se connecter à la ressource.
Tout d’abord, l’exemple appelle la fonction WNetOpenEnum pour commencer l’énumération. L’exemple appelle la fonction GlobalAlloc pour allouer la mémoire tampon requise, puis appelle la fonction ZeroMemory pour définir le contenu de la mémoire tampon sur zéro. Ensuite, l’exemple appelle la fonction WNetEnumResource pour poursuivre l’énumération. Chaque fois que le membre dwUsage d’une structure NETRESOURCE récupérée par WNetEnumResource est égal à RESOURCEUSAGE_CONTAINER, la fonction EnumerateFunc s’appelle de manière récursive et utilise un pointeur vers cette structure dans son appel à WNetOpenEnum. Enfin, l’exemple appelle la fonction GlobalFree pour libérer la mémoire allouée, et WNetCloseEnum pour mettre fin à l’énumération.
#ifndef UNICODE
#define UNICODE
#endif
#pragma comment(lib, "mpr.lib")
#include <windows.h>
#include <stdio.h>
#include <winnetwk.h>
BOOL WINAPI EnumerateFunc(LPNETRESOURCE lpnr);
void DisplayStruct(int i, LPNETRESOURCE lpnrLocal);
int main()
{
LPNETRESOURCE lpnr = NULL;
if (EnumerateFunc(lpnr) == FALSE) {
printf("Call to EnumerateFunc failed\n");
return 1;
} else
return 0;
}
BOOL WINAPI EnumerateFunc(LPNETRESOURCE lpnr)
{
DWORD dwResult, dwResultEnum;
HANDLE hEnum;
DWORD cbBuffer = 16384; // 16K is a good size
DWORD cEntries = -1; // enumerate all possible entries
LPNETRESOURCE lpnrLocal; // pointer to enumerated structures
DWORD i;
//
// Call the WNetOpenEnum function to begin the enumeration.
//
dwResult = WNetOpenEnum(RESOURCE_GLOBALNET, // all network resources
RESOURCETYPE_ANY, // all resources
0, // enumerate all resources
lpnr, // NULL first time the function is called
&hEnum); // handle to the resource
if (dwResult != NO_ERROR) {
printf("WnetOpenEnum failed with error %d\n", dwResult);
return FALSE;
}
//
// Call the GlobalAlloc function to allocate resources.
//
lpnrLocal = (LPNETRESOURCE) GlobalAlloc(GPTR, cbBuffer);
if (lpnrLocal == NULL) {
printf("WnetOpenEnum failed with error %d\n", dwResult);
// NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetOpenEnum");
return FALSE;
}
do {
//
// Initialize the buffer.
//
ZeroMemory(lpnrLocal, cbBuffer);
//
// Call the WNetEnumResource function to continue
// the enumeration.
//
dwResultEnum = WNetEnumResource(hEnum, // resource handle
&cEntries, // defined locally as -1
lpnrLocal, // LPNETRESOURCE
&cbBuffer); // buffer size
//
// If the call succeeds, loop through the structures.
//
if (dwResultEnum == NO_ERROR) {
for (i = 0; i < cEntries; i++) {
// Call an application-defined function to
// display the contents of the NETRESOURCE structures.
//
DisplayStruct(i, &lpnrLocal[i]);
// If the NETRESOURCE structure represents a container resource,
// call the EnumerateFunc function recursively.
if (RESOURCEUSAGE_CONTAINER == (lpnrLocal[i].dwUsage
& RESOURCEUSAGE_CONTAINER))
// if(!EnumerateFunc(hwnd, hdc, &lpnrLocal[i]))
if (!EnumerateFunc(&lpnrLocal[i]))
printf("EnumerateFunc returned FALSE\n");
// TextOut(hdc, 10, 10, "EnumerateFunc returned FALSE.", 29);
}
}
// Process errors.
//
else if (dwResultEnum != ERROR_NO_MORE_ITEMS) {
printf("WNetEnumResource failed with error %d\n", dwResultEnum);
// NetErrorHandler(hwnd, dwResultEnum, (LPSTR)"WNetEnumResource");
break;
}
}
//
// End do.
//
while (dwResultEnum != ERROR_NO_MORE_ITEMS);
//
// Call the GlobalFree function to free the memory.
//
GlobalFree((HGLOBAL) lpnrLocal);
//
// Call WNetCloseEnum to end the enumeration.
//
dwResult = WNetCloseEnum(hEnum);
if (dwResult != NO_ERROR) {
//
// Process errors.
//
printf("WNetCloseEnum failed with error %d\n", dwResult);
// NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetCloseEnum");
return FALSE;
}
return TRUE;
}
void DisplayStruct(int i, LPNETRESOURCE lpnrLocal)
{
printf("NETRESOURCE[%d] Scope: ", i);
switch (lpnrLocal->dwScope) {
case (RESOURCE_CONNECTED):
printf("connected\n");
break;
case (RESOURCE_GLOBALNET):
printf("all resources\n");
break;
case (RESOURCE_REMEMBERED):
printf("remembered\n");
break;
default:
printf("unknown scope %d\n", lpnrLocal->dwScope);
break;
}
printf("NETRESOURCE[%d] Type: ", i);
switch (lpnrLocal->dwType) {
case (RESOURCETYPE_ANY):
printf("any\n");
break;
case (RESOURCETYPE_DISK):
printf("disk\n");
break;
case (RESOURCETYPE_PRINT):
printf("print\n");
break;
default:
printf("unknown type %d\n", lpnrLocal->dwType);
break;
}
printf("NETRESOURCE[%d] DisplayType: ", i);
switch (lpnrLocal->dwDisplayType) {
case (RESOURCEDISPLAYTYPE_GENERIC):
printf("generic\n");
break;
case (RESOURCEDISPLAYTYPE_DOMAIN):
printf("domain\n");
break;
case (RESOURCEDISPLAYTYPE_SERVER):
printf("server\n");
break;
case (RESOURCEDISPLAYTYPE_SHARE):
printf("share\n");
break;
case (RESOURCEDISPLAYTYPE_FILE):
printf("file\n");
break;
case (RESOURCEDISPLAYTYPE_GROUP):
printf("group\n");
break;
case (RESOURCEDISPLAYTYPE_NETWORK):
printf("network\n");
break;
default:
printf("unknown display type %d\n", lpnrLocal->dwDisplayType);
break;
}
printf("NETRESOURCE[%d] Usage: 0x%x = ", i, lpnrLocal->dwUsage);
if (lpnrLocal->dwUsage & RESOURCEUSAGE_CONNECTABLE)
printf("connectable ");
if (lpnrLocal->dwUsage & RESOURCEUSAGE_CONTAINER)
printf("container ");
printf("\n");
printf("NETRESOURCE[%d] Localname: %S\n", i, lpnrLocal->lpLocalName);
printf("NETRESOURCE[%d] Remotename: %S\n", i, lpnrLocal->lpRemoteName);
printf("NETRESOURCE[%d] Comment: %S\n", i, lpnrLocal->lpComment);
printf("NETRESOURCE[%d] Provider: %S\n", i, lpnrLocal->lpProvider);
printf("\n");
}
Pour plus d’informations sur l’utilisation d’un gestionnaire d’erreurs défini par l’application, consultez Récupération d’erreurs réseau.