enumnetresources.cpp

关于文件夹共享的一个程序

//
// file:	EnumNetResources.h
// project:	net
// create:	19.11.2001
// purpose:	Testing of enumeration available resources & check they status
// creator:	CWiC
//

#include "stdafx.h"



// WNetOpenEnum
//	The WNetOpenEnum function starts an enumeration of network resources or 
//	existing connections. 
//
//DWORD WNetOpenEnum(
//  DWORD dwScope,     // scope of enumeration
//  DWORD dwType,      // resource types to list
//  DWORD dwUsage,     // resource usage to list
//  LPNETRESOURCE lpNetResource,  // pointer to resource structure
//  LPHANDLE lphEnum   // pointer to enumeration handle buffer
//);
// 
//	Parameters
//
////	dwScope 
//
//	Specifies the scope of the enumeration. This parameter can be one of the 
//	following values: 
//
//	Value				Meaning 
//
//	RESOURCE_CONNECTED	All currently connected resources (the dwUsage parameter
//						is ignored). 
//
//	RESOURCE_CONTEXT	Only resources in the network context of the caller (used 
//						for a Network Neighborhood view). The dwUsage parameter 
//						is ignored. 
//
//	RESOURCE_GLOBALNET	All resources on the network. 
//
//	RESOURCE_REMEMBERED	All remembered (persistent) connections (the dwUsage 
//						parameter is ignored). 
//
////	dwType 
//
//	Specifies the resource types to enumerate. This parameter can be a combination 
//	of the following values: 
//
//	Value				Meaning 
//
//	RESOURCETYPE_ANY	All resources (this value cannot be combined with 
//						RESOURCETYPE_DISK or RESOURCETYPE_PRINT). 
//
//	RESOURCETYPE_DISK	All disk resources. 
//
//	RESOURCETYPE_PRINT	All print resources. 
//
//	If a network provider cannot distinguish between print and disk resources, 
//	it may enumerate all resources. 
//
////	dwUsage 
//
//	Specifies the resource usage to be enumerated. This parameter can be a 
//	combination of the following values: 
//	Value						Meaning 
//
//	0							All resources 
//
//	RESOURCEUSAGE_CONNECTABLE	All connectable resources 
//
//	RESOURCEUSAGE_CONTAINER		All container resources 
//
//	This parameter is ignored if the dwScope parameter is not RESOURCE_GLOBALNET. 
//
////	lpNetResource 
//
//	Points to a NETRESOURCE structure specifying the container to enumerate. 
//	If this parameter is NULL, the root of the network is assumed. Windows 
//	organizes a network as a hierarchy; the root is the topmost container 
//	in the network. 
//	If this parameter is not NULL, it must point to a NETRESOURCE structure. 
//	This structure can be filled in by the application or be returned by a call 
//	to the WNetEnumResource function. The NETRESOURCE structure must specify a
//	container resource; that is, the RESOURCEUSAGE_CONTAINER value must be 
//	specified in the dwUsage member. 
//
//	To enumerate all network resources, an application can begin the enumeration 
//	by calling WNetOpenEnum with lpNetResource set to NULL and then use the 
//	returned handle with WNetEnumResource to enumerate resources. If one of the 
//	resources in the NETRESOURCE array returned by the WNetEnumResource function 
//	is a container resource, WNetOpenEnum can be used to open the resource for 
//	further enumeration. 
//	If the dwScope parameter is not RESOURCE_GLOBALNET, this parameter must be NULL.
//
////	lphEnum 
//
//	Points to a variable filled with an enumeration handle that can be used in 
//	a subsequent call to WNetEnumResource. 
//
//
//	Return Values
//
//	If the function succeeds, the return value is NO_ERROR. 
//
//	If the function fails, the return value is an error code. To get extended
//	error information, callGetLastError. GetLastError may return one of the 
//	following error codes: 
//
//	Value					Meaning 
//	ERROR_NOT_CONTAINER		The lpNetResource parameter does not point to a container. 
//
//	ERROR_INVALID_PARAMETER Either the dwScope or dwType parameter is invalid, or 
//							there is a bad combination of parameters. 
//
//	ERROR_NO_NETWORK		No network is present. 
//
//	ERROR_EXTENDED_ERROR	A network-specific error occurred. To get a description of the error, use the WNetGetLastError function. 
//
//
//	The function returns error codes for compatibility with Windows version 3.1. 
//	For compatibility with Windows NT, the function also sets the error code 
//	value returned by GetLastError. 
//
//Remarks
//
//	The exact interpretation of RESOURCE_CONTEXT in the dwScope parameter depends
//	on the networks installed on the machine.
//
//	The WNetOpenEnum function is used to begin enumeration of the resources in a 
//	single container. The following examples show the hierarchical structure of 
//	a Microsoft LAN Manager network and a Novell Netware network: 
//
//	LanMan (container, in this case the provider) 
//	 ACCOUNTING (container, in this case the domain) 
//	    \\ACCTSPAY (container, in this case the server) 
//	      PAYFILES (disk) 
//	      LASERJET (print) 
// 
//	Netware (container, in this case the provider) 
//	  MARKETING (container, in this case the server) 
//	    SYS (disk, first one on any Netware server) 
//	    ANOTHERVOLUME (disk) 
//	    LASERJET (print) 
 
BOOL WINAPI EnumerateFunc(HWND hwnd, 
                          HDC hdc, 
                          LPNETRESOURCE lpnr,
						  void* pPointer,	// Pointer to CTreeCtrl
						  void(*DisplayInfo)(LPNETRESOURCE,void* ) ) 
{ 
    DWORD dwResult, dwResultEnum; 
    HANDLE hEnum; 
    DWORD cbBuffer = 16384;      // 16K is a good size 
    DWORD cEntries = 0xFFFFFFFF; // enumerate all possible entries 
    LPNETRESOURCE lpnrLocal;     // pointer to enumerated structures 
    DWORD i; 
 
    dwResult = WNetOpenEnum(RESOURCE_GLOBALNET, 
        RESOURCETYPE_ANY, 
        0,                 // enumerate all resources 
        lpnr,              // NULL first time this function is called 
        &hEnum);           // handle to resource 
 
    if (dwResult != NO_ERROR) { 
 
        // An application-defined error handler is demonstrated in the 
        // section titled "Retrieving Network Errors." 

//        NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetOpenEnum"); 
        return FALSE; 
    } 
 
    do { 
 
        // Allocate memory for NETRESOURCE structures.
 
        lpnrLocal = (LPNETRESOURCE) GlobalAlloc(GPTR, cbBuffer); 
 
        dwResultEnum = WNetEnumResource(hEnum, // resource handle 
            &cEntries,               // defined locally as 0xFFFFFFFF 
            lpnrLocal,               // LPNETRESOURCE 
            &cbBuffer);              // buffer size 
 
        if (dwResultEnum == NO_ERROR) 
		{ 
            for(i = 0; i < cEntries; i++) 
            { 
                // Following is an application-defined function for 
                // displaying contents of NETRESOURCE structures. 
 
                DisplayInfo( &lpnrLocal[i], pPointer );
 
                // 
                // If this NETRESOURCE is a container, call the function 
                // recursively. 

                if(RESOURCEUSAGE_CONTAINER == 
                        (lpnrLocal[i].dwUsage & RESOURCEUSAGE_CONTAINER)) 
                    if(!EnumerateFunc(hwnd, hdc, &lpnrLocal[i], pPointer, DisplayInfo )) 
                        TextOut(hdc, 10, 10, 
                            "EnumerateFunc returned FALSE.", 29); 
 
            } 
        } 
 
        else if (dwResultEnum != ERROR_NO_MORE_ITEMS) { 
//            NetErrorHandler(hwnd, dwResultEnum, (LPSTR)"WNetEnumResource"); 
            break; 
        } 
    } 
    while(dwResultEnum != ERROR_NO_MORE_ITEMS); 
 
    GlobalFree((HGLOBAL) lpnrLocal); 
 
    dwResult = WNetCloseEnum(hEnum); 
 
    if(dwResult != NO_ERROR) { 
//        NetErrorHandler(hwnd, dwResult, (LPSTR)"WNetCloseEnum"); 
        return FALSE; 
    } 
 
    return TRUE; 
}