You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
278 lines
9.2 KiB
278 lines
9.2 KiB
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
mprbase.hxx
|
|
|
|
Abstract:
|
|
|
|
Contains class definitions for base classes that implement common code
|
|
for Multi-Provider Router operations, namely:
|
|
CMprOperation
|
|
CRoutedOperation
|
|
|
|
Author:
|
|
|
|
Anirudh Sahni (anirudhs) 11-Oct-1995
|
|
|
|
Environment:
|
|
|
|
User Mode -Win32
|
|
|
|
Revision History:
|
|
|
|
11-Oct-1995 AnirudhS
|
|
Created.
|
|
|
|
--*/
|
|
|
|
#ifndef _MPRBASE_HXX_
|
|
#define _MPRBASE_HXX_
|
|
|
|
//=======================
|
|
// MACROS
|
|
//=======================
|
|
|
|
// Macro used to access PROVIDER class member functions in a generic
|
|
// fashion without creating an array of functions
|
|
#define PROVIDERFUNC(x) ((FARPROC PROVIDER::*) (&PROVIDER::x))
|
|
|
|
// Macro for use in declaring subclasses of CRoutedOperation
|
|
#define DECLARE_CROUTED \
|
|
\
|
|
protected: \
|
|
\
|
|
DWORD ValidateRoutedParameters( \
|
|
LPCWSTR * ppProviderName, \
|
|
LPCWSTR * ppRemoteName, \
|
|
LPCWSTR * ppLocalName \
|
|
); \
|
|
\
|
|
DWORD TestProvider( \
|
|
const PROVIDER *pProvider \
|
|
);
|
|
|
|
// "Debug-only parameter" macro
|
|
#if DBG == 1
|
|
#define DBGPARM(x) x,
|
|
#else
|
|
#define DBGPARM(x)
|
|
#endif
|
|
|
|
|
|
//=======================
|
|
// CONSTANTS
|
|
//=======================
|
|
|
|
// Number of recently used net paths for CPathCache to remember
|
|
#define PATH_CACHE_SIZE 4
|
|
|
|
// Possible algorithms for routing among providers
|
|
enum ROUTING_ALGORITHM
|
|
{
|
|
ROUTE_LAZY,
|
|
ROUTE_AGGRESSIVE
|
|
};
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CMprOperation
|
|
//
|
|
// Purpose: An MPR operation is an API in which the MPR needs to be
|
|
// initialized, parameters need to be validated, operation-
|
|
// specific processing needs to be performed, and the result
|
|
// needs to be saved by SetLastError.
|
|
//
|
|
// CMprOperation::Perform provides this common outline.
|
|
// Each MPR API can be implemented by providing a derived class.
|
|
// The derived class must fill in the API-specific processing
|
|
// by supplying the ValidateParameters and GetResult methods.
|
|
//
|
|
// Interface: Constructor - API can only construct an instance of a derived
|
|
// class, passing it the API parameters.
|
|
// Perform - API calls this to make the operation happen.
|
|
// ValidateParameters - In this method, the derived class does
|
|
// any parameter validation that could cause an exception.
|
|
// GetResult - In this method, the derived class does operation-
|
|
// specific processing.
|
|
//
|
|
// History: 11-Oct-95 AnirudhS Created.
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CMprOperation
|
|
{
|
|
public:
|
|
|
|
virtual DWORD Perform();
|
|
|
|
#if DBG == 1
|
|
LPCSTR OpName()
|
|
{ return _OpName; }
|
|
#endif
|
|
|
|
protected:
|
|
|
|
#if DBG == 1
|
|
CMprOperation(LPCSTR OpName) :
|
|
_OpName(OpName)
|
|
{ }
|
|
#else
|
|
CMprOperation()
|
|
{ }
|
|
#endif
|
|
|
|
virtual DWORD ValidateParameters() = 0;
|
|
virtual DWORD GetResult() = 0;
|
|
|
|
#if DBG == 1
|
|
private:
|
|
LPCSTR _OpName; // API name to print in debug messages
|
|
#endif
|
|
};
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Class: CRoutedOperation
|
|
//
|
|
// Purpose: A Routed Operation is an MPR operation which needs to be
|
|
// routed to the provider responsible, usually by either
|
|
// calling a provider that is named by the API caller, or
|
|
// polling all the providers and determining the right one
|
|
// based on the errors returned.
|
|
// This is a common type of MPR operation, so this subclass of
|
|
// CMprOperation, CRoutedOperation, is defined to hold the
|
|
// common code. A derived class is required for each routed
|
|
// operation.
|
|
//
|
|
// Parameter validation for a routed operation usually includes
|
|
// validating the name of a specific NP that may have been
|
|
// passed in by the caller of the WNet API, so CRoutedOperation
|
|
// ::ValidateParameters does this.
|
|
// CRoutedOperation::GetResult provides the logic for polling
|
|
// the providers and picking the best error. This may still be
|
|
// overridden if it does not exactly meet a particular
|
|
// operation's needs.
|
|
//
|
|
// Derived classes need to provide the methods
|
|
// ValidateRoutedParameters and TestProvider.
|
|
//
|
|
// Interface:
|
|
//
|
|
// History: 11-Oct-95 AnirudhS Created.
|
|
//
|
|
// Notes:
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
class CRoutedOperation : public CMprOperation
|
|
{
|
|
public:
|
|
|
|
DWORD Perform(BOOL fCheckProviders);
|
|
|
|
// CODEWORK: This should become private once all APIs use CRoutedOperation
|
|
static DWORD FindCallOrder(
|
|
const UNICODE_STRING *NameInfo,
|
|
LPPROVIDER ProviderArray[],
|
|
LPDWORD ProviderArrayCount,
|
|
DWORD InitClass
|
|
);
|
|
|
|
static void ConstructCache()
|
|
{ _PathCache.Construct(); }
|
|
|
|
static void DestroyCache()
|
|
{ _PathCache.Destroy(); }
|
|
|
|
protected:
|
|
CRoutedOperation(
|
|
DBGPARM(LPCSTR OpName)
|
|
FARPROC PROVIDER::* pProviderFunction = NULL,
|
|
ROUTING_ALGORITHM Routing = ROUTE_LAZY
|
|
) :
|
|
DBGPARM(CMprOperation(OpName))
|
|
_pProviderFunction (pProviderFunction),
|
|
_AggressiveRouting (Routing == ROUTE_AGGRESSIVE),
|
|
_pSpecifiedProvider(NULL),
|
|
_LastProvider (NULL),
|
|
_uDriveType (DRIVE_REMOTE)
|
|
{ }
|
|
|
|
//
|
|
// Helper functions for child classes
|
|
//
|
|
PROVIDER * LastProvider() const
|
|
{ return _LastProvider; }
|
|
|
|
//
|
|
// Implementations of CMprOperation functions
|
|
//
|
|
DWORD ValidateParameters();
|
|
DWORD GetResult();
|
|
|
|
//
|
|
// Virtual functions that child classes should supply
|
|
//
|
|
virtual DWORD ValidateRoutedParameters(
|
|
LPCWSTR *ppProviderName,
|
|
LPCWSTR *ppRemoteName,
|
|
LPCWSTR *ppLocalName
|
|
) = 0;
|
|
virtual DWORD TestProvider(
|
|
const PROVIDER * pProvider
|
|
) = 0;
|
|
|
|
private:
|
|
|
|
FARPROC PROVIDER::*
|
|
_pProviderFunction; // Required provider function, if any
|
|
BOOL _AggressiveRouting; // Whether to continue on "other" errors
|
|
PROVIDER * _pSpecifiedProvider; // Provider specified in API parameters
|
|
UNICODE_STRING _RemoteName; // Remote name specified in API parameters
|
|
PROVIDER * _LastProvider; // On a success return from GetResult,
|
|
// is the provider that responded
|
|
UINT _uDriveType; // Optimization -- if the localname is
|
|
// not a remote drive, some APIs can
|
|
// fail w/o loading the provider DLLs
|
|
|
|
//
|
|
// Cache of providers for the last few net paths accessed through WNet APIs
|
|
//
|
|
class CPathCache
|
|
{
|
|
public:
|
|
void Construct();
|
|
void Destroy();
|
|
void AddEntry(const UNICODE_STRING * Path, LPPROVIDER Provider);
|
|
LPPROVIDER FindEntry(const UNICODE_STRING * Path);
|
|
|
|
private:
|
|
|
|
// The cache is a doubly linked list of UNICODE_STRINGs and LPPROVIDERs.
|
|
// The string buffers are allocated on the heap but the the list
|
|
// entries are allocated statically.
|
|
struct CacheEntry
|
|
{
|
|
LIST_ENTRY Links;
|
|
UNICODE_STRING Path;
|
|
LPPROVIDER Provider;
|
|
};
|
|
|
|
CRITICAL_SECTION _Lock;
|
|
CacheEntry _RecentPaths[PATH_CACHE_SIZE];
|
|
LIST_ENTRY _ListHead;
|
|
DWORD _NumFree; // _RecentPaths[0] thru [_NumFree-1] are unused
|
|
};
|
|
|
|
static CPathCache _PathCache;
|
|
};
|
|
|
|
#endif // _MPRBASE_HXX_
|
|
|