Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Das folgende Beispiel veranschaulicht eine anwendungsdefinierte Funktion (EnumerateFunc), die alle Ressourcen in einem Netzwerk aufzählt. Das Beispiel gibt NULL für den Zeiger auf die NETRESOURCE-Struktur an, da WNetOpenEnum einen NULL-Zeiger empfängt, ein Handle zum Stamm des Netzwerks abgerufen wird.
Um mit der Enumeration einer Netzwerkcontainerressource zu beginnen, sollte Ihre Anwendung die folgenden Schritte ausführen:
- Übergeben Sie die Adresse einer NETRESOURCE-Struktur , die die Ressource darstellt, an die WNetOpenEnum-Funktion .
- Ordnen Sie einen Puffer zu, der groß genug ist, um das Array von NETRESOURCE-Strukturen aufzunehmen, das die WNetEnumResource-Funktion zurückgibt, sowie die Zeichenfolgen, auf die ihre Member verweisen.
- Übergeben Sie das von WNetOpenEnum zurückgegebene Ressourcenhandle an die WNetEnumResource-Funktion .
- Schließen Sie das Ressourcenhandle, wenn es nicht mehr benötigt wird, indem Sie die WNetCloseEnum-Funktion aufrufen.
Sie können weiterhin eine Containerressource aufzählen, die im Array von NETRESOURCE-Strukturen beschrieben wird, das von WNetEnumResource abgerufen wird. Wenn das dwUsage-Element der NETRESOURCE-Struktur gleich RESOURCEUSAGE_CONTAINER ist, übergeben Sie die Adresse der Struktur an die WNetOpenEnum-Funktion , um den Container zu öffnen und die Enumeration fortzusetzen. Wenn dwUsage gleich RESOURCEUSAGE_CONNECTABLE ist, kann die Anwendung die Adresse der Struktur an die WNetAddConnection2-Funktion oder die WNetAddConnection3-Funktion übergeben, um eine Verbindung mit der Ressource herzustellen.
Zunächst ruft das Beispiel die WNetOpenEnum-Funktion auf, um mit der Enumeration zu beginnen. Im Beispiel wird die GlobalAlloc-Funktion aufgerufen, um den erforderlichen Puffer zuzuordnen, und dann die ZeroMemory-Funktion aufgerufen, um den Pufferinhalt auf 0 festzulegen. Anschließend ruft das Beispiel die WNetEnumResource-Funktion auf, um die Enumeration fortzusetzen. Wenn das dwUsage-Element einer von WNetEnumResource abgerufenenNETRESOURCE-Struktur gleich RESOURCEUSAGE_CONTAINER ist, ruft sich die EnumerateFunc-Funktion rekursiv auf und verwendet einen Zeiger auf diese Struktur in ihrem Aufruf von WNetOpenEnum. Schließlich ruft das Beispiel die GlobalFree-Funktion auf, um den zugewiesenen Arbeitsspeicher freizugeben, und WNetCloseEnum , um die Enumeration zu beenden.
#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");
}
Weitere Informationen zur Verwendung eines anwendungsdefinierten Fehlerhandlers finden Sie unter Abrufen von Netzwerkfehlern.