871 lines
32 KiB
C
871 lines
32 KiB
C
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Copyright (C) 1992, Microsoft Corporation
|
|||
|
//
|
|||
|
// File: dfsapi.h
|
|||
|
//
|
|||
|
// Contents: C Callable DFS API.
|
|||
|
//
|
|||
|
// Classes:
|
|||
|
//
|
|||
|
// Functions:
|
|||
|
//
|
|||
|
// History: 29 Sep 92 Milans created.
|
|||
|
// 04-Aug-93 randyd Converted/moved to common\types
|
|||
|
// 05-Aug-93 alanw Added administration APIs
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
#ifndef _DFS_API_
|
|||
|
#define _DFS_API_
|
|||
|
|
|||
|
#include <windows.h>
|
|||
|
#include <dsys.h>
|
|||
|
#include <ntdddfs.h>
|
|||
|
|
|||
|
#ifdef __cplusplus
|
|||
|
extern "C" {
|
|||
|
#endif
|
|||
|
|
|||
|
#if !defined(_DFSSYSTEM_)
|
|||
|
#define DFSAPI DECLSPEC_IMPORT
|
|||
|
#else
|
|||
|
#define DFSAPI
|
|||
|
#endif
|
|||
|
|
|||
|
//
|
|||
|
// These are the names of Win32 events that get toggled when the Dfs PKT
|
|||
|
// changes. They are a handy way to figure out when to call the
|
|||
|
// DfsGetActiveVolumes API.
|
|||
|
//
|
|||
|
|
|||
|
#define DFS_PKT_CHANGE_EVENT_A L"DfsPktChangeA"
|
|||
|
#define DFS_PKT_CHANGE_EVENT_B L"DfsPktChangeB"
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsSetDomainInfo
|
|||
|
//
|
|||
|
// Synopsis: Seeds the Dfs driver with information about the domain
|
|||
|
// name and DC addressing info to bootstrap the name resolution
|
|||
|
// process.
|
|||
|
//
|
|||
|
// Arguments: [pglDomain] -- pointer to gluon describing domain/DCs
|
|||
|
// [iConnectedDC] -- index into gluon for the DC that should
|
|||
|
// be preferred for referrals etc.
|
|||
|
//
|
|||
|
// Returns: S_OK
|
|||
|
// DFS_E_NO_MEMORY
|
|||
|
// DFS_E_INVALID_PARAM
|
|||
|
// DFS_E_NO_DRIVER -- if NOCAIRO or STANDALONE machine
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsSetDomainInfo(
|
|||
|
IN PDS_GLUON pglDomain,
|
|||
|
IN USHORT iConnectedDC);
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsRegisterSCM
|
|||
|
//
|
|||
|
// Synopsis: To be called by the SCM to register BindingStrings with Dfs.
|
|||
|
//
|
|||
|
// Arguments: None
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsRegisterSCM(void);
|
|||
|
|
|||
|
|
|||
|
//+-------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsRegisterFileService
|
|||
|
//
|
|||
|
// Synopsis: This function is called by a file service which is
|
|||
|
// supporting DFS via a DFS$ share targeted at the WinDfs device.
|
|||
|
// It registers the principal name for the file service and
|
|||
|
// its transport addresses.
|
|||
|
//
|
|||
|
// Arguments: [usFsp] -- file level protocol supported by the server
|
|||
|
// (see FSP_xxx definitions in gluon.h)
|
|||
|
// [pwszPrincipalName] -- security principal name under which
|
|||
|
// the server operates.
|
|||
|
// [cTransports] -- number of transports on which the server
|
|||
|
// is listening
|
|||
|
// [prgTrans] -- pointer to an array of TA_ADDRESS pointers,
|
|||
|
// giving the TDI addresses for the server.
|
|||
|
//
|
|||
|
// Notes: A service which supports multiple file protocols should
|
|||
|
// issue this call once for each protocol.
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsRegisterFileService (
|
|||
|
IN USHORT usFsp,
|
|||
|
IN LPCWSTR pwszPrincipalName,
|
|||
|
IN ULONG cTransports,
|
|||
|
IN TA_ADDRESS **prgTrans );
|
|||
|
|
|||
|
//+-------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetLocalAddress
|
|||
|
//
|
|||
|
// Synopsis: Returns the addressing descriptor (DS_MACHINE) for the
|
|||
|
// local machine. This is a composite resulting from calls
|
|||
|
// to DfsRegisterSCM and DfsRegisterFileService.
|
|||
|
//
|
|||
|
// Arguments: [ppdsm] -- output pointer
|
|||
|
//
|
|||
|
// Notes: The DS_MACHINE returned is callee-allocated. The caller must
|
|||
|
// free it by walking the structure, freeing each sub-piece
|
|||
|
// using CoTaskMemFree.
|
|||
|
//
|
|||
|
// BUGBUG: it isn't really intended that this function should
|
|||
|
// be public. It is only for use internal to DSYS.
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetLocalAddress ( OUT DS_MACHINE **ppdsm );
|
|||
|
|
|||
|
//+-------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetMachineVolumeId
|
|||
|
//
|
|||
|
// Synopsis: Returns the volume id for the local DS volume for the
|
|||
|
// machine on which the call is issued. This id is also
|
|||
|
// the globally unique "DFS machine id" which appears in
|
|||
|
// the guidMachine field of the DS_MACHINE for the machine.
|
|||
|
//
|
|||
|
// Arguments: [pguidMachine] -- output pointer for returned GUID
|
|||
|
//
|
|||
|
// Notes:
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetMachineVolumeId ( GUID * pguidMachine );
|
|||
|
|
|||
|
//+-------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsUpdateMachineVolume
|
|||
|
//
|
|||
|
// Synopsis: Allows DFS to transmit updated addressing information
|
|||
|
// for the local volume to the DC.
|
|||
|
//
|
|||
|
// Notes: BUGBUG: this is function is intended only for the use of
|
|||
|
// SpMgr and is not supposed to be public.
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsUpdateMachineVolume ( void );
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsUpdateDomainKnowledge
|
|||
|
//
|
|||
|
// Synopsis: Takes a gluon for a new domain's DS volume. This should be
|
|||
|
// called only on a DC else call will fail.
|
|||
|
//
|
|||
|
// Arguments: [pglDomain] -- gluon for the new domain's DS volume.
|
|||
|
// [dwFlags] -- if DFS_UDK_DELETE bit is set, the domain's
|
|||
|
// knowledge will be deleted from Dfs data structures
|
|||
|
//
|
|||
|
// Returns: S_OK
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
#define DFS_UDK_DELETE 0x1
|
|||
|
|
|||
|
DFSAPI STDAPI DfsUpdateDomainKnowledge(
|
|||
|
IN PDS_GLUON pglDomain,
|
|||
|
IN const USHORT iConnectedDC,
|
|||
|
IN const DWORD dwFlags);
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsUpdateSiteCosts
|
|||
|
//
|
|||
|
// Synopsis: Updates the site costs. This should be called only on a DC
|
|||
|
// else the call will fail. Note that only sites whose
|
|||
|
// communication costs have changed need be included in the
|
|||
|
// list - sites whose costs have not changed since the last
|
|||
|
// call to this API need not be included, and their costs will
|
|||
|
// not be disturbed. Cost vectors are *not* persistent across
|
|||
|
// boots.
|
|||
|
//
|
|||
|
// Arguments: [cSiteCosts] -- The number of site costs listed below.
|
|||
|
// [rgpSiteCosts] -- The actual array of DFS_SITE_COST structs.
|
|||
|
//
|
|||
|
// Returns: S_OK
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
HRESULT
|
|||
|
DfsUpdateSiteCosts(
|
|||
|
IN ULONG cSiteCost,
|
|||
|
IN DFS_SITE_COST *prgSiteCost);
|
|||
|
|
|||
|
|
|||
|
//------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetReplicaSpecificPath, public
|
|||
|
//
|
|||
|
// Synopsis: This function returns a replica specific name, given a Win32
|
|||
|
// path. The user has to mention the full DN of the specific
|
|||
|
// replica which he/she wants to access.
|
|||
|
//
|
|||
|
// Arguments: [pwszPath] -- The Win32 path to be converted to repl specific
|
|||
|
// eg. x:\volumes\domainrt
|
|||
|
// \\thebese\dfs$\cairo\ds\dsdomain\volumes\domainrt
|
|||
|
// [pwszReplName] -- The full DN of the server
|
|||
|
// eg. \msft\redmond\bsd\test\thebes
|
|||
|
// [ppwszReplSpecificPath] -- The Replica specific name is
|
|||
|
// returned here.
|
|||
|
// eg. \\thebese\org$\cairo\ds\dsdomain\volumes\domainrt
|
|||
|
//
|
|||
|
// Notes: The ppwszReplSpecificName is freed using CoTaskMemFree.
|
|||
|
// One can convert a ReplSpecificPath back to a Win32 path by
|
|||
|
// using the dual of this api, DfsPathFromReplSpecificPath,
|
|||
|
// provided that the repl specific path does not refer to a
|
|||
|
// downlevel replica.
|
|||
|
//
|
|||
|
// History: Sudk Created 3/25/94
|
|||
|
// Milans Updated comments 5/15/95
|
|||
|
//
|
|||
|
//------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetReplicaSpecificPath(
|
|||
|
PWSTR pwszDfsPath,
|
|||
|
PWSTR pwszReplName,
|
|||
|
PWSTR *ppwszReplSpecificPath
|
|||
|
);
|
|||
|
|
|||
|
|
|||
|
//------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsPathFromReplSpecificPath, public
|
|||
|
//
|
|||
|
// Synopsis: This function retrieves a Win32 Path given a replica
|
|||
|
// specific path. The Replica specific path should refer to a
|
|||
|
// DFS aware machine (not to a downlevel machine). Usually,
|
|||
|
// the repl specific path is generated by the dual of this API,
|
|||
|
// DfsGetReplicaSpecificPath.
|
|||
|
//
|
|||
|
// Arguments: [pwszReplSpecificPath] -- The Repl Specific path here.
|
|||
|
// eg. \\thebes\org$\msft\volumes\domainrt
|
|||
|
// [ppwszPath] -- The Win32 Path is returned here.
|
|||
|
// eg. x:\volumes\domainrt
|
|||
|
//
|
|||
|
// Notes: Free ppwszDfsPath using CoTaskMemFree.
|
|||
|
//
|
|||
|
// History: Sudk Created 3/25/94
|
|||
|
// Milans Updated comments 5/15/95
|
|||
|
//
|
|||
|
//------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsPathFromReplSpecificPath(
|
|||
|
PWSTR pwszReplSpecificPath,
|
|||
|
PWSTR *ppwszPath
|
|||
|
);
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetActiveVolumeList, public
|
|||
|
//
|
|||
|
// Synopsis: The DFS design is centered around a cache which stores a map
|
|||
|
// for the most recently accessed DFS volumes. This API will
|
|||
|
// return the Entry Paths (as DFS_PATHs) of the volumes.
|
|||
|
//
|
|||
|
// Arguments: [pcVolumes] -- On successful return, number of volume entry
|
|||
|
// paths returned.
|
|||
|
// [pawszVolumes] -- On successful return, pointer to array of
|
|||
|
// Volume Entry Paths.
|
|||
|
//
|
|||
|
// Returns: SUCCESS_SUCCESS, DFS_E_NO_MEMORY
|
|||
|
//
|
|||
|
// Notes: pawszVolumes must be freed by the caller via MemFree.
|
|||
|
// The volume names will also be deleted at the same time.
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetActiveVolumeList(
|
|||
|
OUT UINT *pcVolumes,
|
|||
|
OUT PWSTR *pawszVolumes[]
|
|||
|
);
|
|||
|
|
|||
|
|
|||
|
//
|
|||
|
// BUGBUG: This Function to be removed once transition to new model is complete.
|
|||
|
//
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsEnumVolumeChildren, public
|
|||
|
//
|
|||
|
// Synopsis: The single logical volume rooted at DFS_ROOT_ORG presented by
|
|||
|
// DFS is actually composed of many Dfs volumes arranged in a
|
|||
|
// hierarchy. Given the Entry Path of a volume, this API will
|
|||
|
// return the volume entry paths of its child volumes.
|
|||
|
//
|
|||
|
// The names of the volume children are given as relative
|
|||
|
// path names from the input parent volume entry path.
|
|||
|
//
|
|||
|
// Arguments: [wszParent] -- Entry path of parent volume.
|
|||
|
// [pcChildren] -- On successful return, number of children.
|
|||
|
// [pawszChildren] -- On successful return, pointer to array of
|
|||
|
// volume entry paths of child volumes.
|
|||
|
//
|
|||
|
// Returns: SUCCESS_SUCCESS, DFS_E_NO_MEMORY
|
|||
|
//
|
|||
|
// Notes: pawszChildren must be freed by the caller via MemFree. The
|
|||
|
// names of the child volumes will be freed at the same time.
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsEnumVolumeChildren(
|
|||
|
IN PWSTR wszParent,
|
|||
|
OUT UINT *pcChildren,
|
|||
|
OUT PWSTR *pawszChildren[]
|
|||
|
);
|
|||
|
|
|||
|
|
|||
|
//+-----------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsAddLocalMachShare
|
|||
|
//
|
|||
|
// Synopsis: This function adds a new LocalMachShare and inits it in PKT.
|
|||
|
//
|
|||
|
// Arguments: [pwszPrefix] -- Prefix relative to Mach:\ for new Share.
|
|||
|
// [pwszStorageId] -- Storage for new MachShare.
|
|||
|
//
|
|||
|
//------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsAddLocalMachShare(
|
|||
|
PWSTR pwszPrefix,
|
|||
|
PWSTR pwszStorageId
|
|||
|
);
|
|||
|
|
|||
|
//+-----------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsDeleteLocalMachShare
|
|||
|
//
|
|||
|
// Synopsis: This function deletes a LocalMachShare.
|
|||
|
//
|
|||
|
// Arguments: [pwszPrefix] -- Prefix relative to Mach:\ for Share to delete.
|
|||
|
//
|
|||
|
//------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsDeleteLocalMachShare(
|
|||
|
PWSTR pwszPrefix
|
|||
|
);
|
|||
|
|
|||
|
//+-------------------------------------------------------------------
|
|||
|
//
|
|||
|
// DFS Administration API - For use with the IDfsVolume interface
|
|||
|
//
|
|||
|
//--------------------------------------------------------------------
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetEnumDfsVolumes, public
|
|||
|
//
|
|||
|
// Synopsis: This method takes an entryPath and then returns an IEnumDfsVol
|
|||
|
// interface using which the caller can enumerate all the DFS
|
|||
|
// volumes underneath that entryPath.
|
|||
|
//
|
|||
|
// Arguments: [pwszPrefix] -- Prefix to enumerate volumes underneath.
|
|||
|
// [ppEnum] -- The Enumeration interface is returned here.
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetEnumDfsVolumes(
|
|||
|
LPWSTR pwszPrefix,
|
|||
|
IEnumDfsVolumes **ppEnum
|
|||
|
);
|
|||
|
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsCreateVolume, public
|
|||
|
//
|
|||
|
// Synopsis: This API creates a DFS volume in the namespace based on the
|
|||
|
// parameters passed in.
|
|||
|
//
|
|||
|
// Arguments: [pwszPrefix] -- The Prefix for the new volume.
|
|||
|
// [ulVolType] -- The Volume Type for volume to be created.
|
|||
|
// [pReplicaInfo]--The ReplicaInfo for the first replica of volume.
|
|||
|
// [fCreateOptions] -- The Create Options (CreateStgId etc.)
|
|||
|
// [pwszComment] --Any comment that needs to be set on volume.
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsCreateVolume(
|
|||
|
LPWSTR pwszPrefix,
|
|||
|
ULONG ulVolumeType,
|
|||
|
PDFS_REPLICA_INFO pReplicaInfo,
|
|||
|
ULONG fCreateOptions,
|
|||
|
PWCHAR pwszComment
|
|||
|
);
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetVolumeFromPrefix, public
|
|||
|
//
|
|||
|
// Synopsis: This API returns an IDfsVolume interface given an EntryPath
|
|||
|
// that identifies a volume. The IDfsVolume can then be used to
|
|||
|
// do further operations on the volume.
|
|||
|
//
|
|||
|
// Arguments: [pwszPrefix] -- The Entry path that identifies volume.
|
|||
|
// This has to be an org-based prefix
|
|||
|
// [ppIDfsVol] -- The IDfsVOlume interface is returned here.
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetVolumeFromPrefix(
|
|||
|
LPWSTR pwszPrefix,
|
|||
|
IDfsVolume **ppIDfsVol);
|
|||
|
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsRenamePath, public
|
|||
|
//
|
|||
|
// Synopsis: This is the function to be used to rename a directory which
|
|||
|
// falls along on exit point on some volume. The old and new paths
|
|||
|
// can differ only in component of their entryPaths and that is the
|
|||
|
// last component. They should be identical otherwise.
|
|||
|
//
|
|||
|
// Arguments: [oldPath] -- The old path that has to be renamed.
|
|||
|
// [newPath] -- The new name and only the last component is
|
|||
|
// different here.
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsRenamePath(
|
|||
|
LPWSTR oldPath,
|
|||
|
LPWSTR newPath);
|
|||
|
|
|||
|
|
|||
|
DFSAPI STDAPI_(VOID) DfsFreeVolInfo(
|
|||
|
PDFS_VOLUME_INFO pInfo);
|
|||
|
|
|||
|
//
|
|||
|
// FOLLOWING ARE THE COMMON PUBLIC DFS APIS
|
|||
|
//
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetPathForPrefix, public
|
|||
|
//
|
|||
|
// Synopsis: This API returns a Win32 path for an object in the Dfs namespace
|
|||
|
// given the ORG relative prefix of that object in the Dfs
|
|||
|
// namespace.
|
|||
|
//
|
|||
|
// Arguments: [lpPrefix] -- The Prefix for which a Win32 path is desired.
|
|||
|
// [lpPath] -- The Win32 Path is returned here.
|
|||
|
// [lpBufferSize] -- On entry, contains the size of lpPath in
|
|||
|
// bytes. If DFS_E_BUFFER_TOO_SMALL is returned, this
|
|||
|
// will be set to indicate the required buffer size, in
|
|||
|
// bytes.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- If all went well.
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- If the buffer passed in small.
|
|||
|
// Required size will be in lpBufSize.
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsGetPathForPrefix(
|
|||
|
LPCWSTR lpPrefix,
|
|||
|
LPWSTR lpPath,
|
|||
|
LPDWORD lpBufferSize);
|
|||
|
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetPrefixForPath, public
|
|||
|
//
|
|||
|
// Synopsis: This API returns the org relative prefix given a Win32 path
|
|||
|
// which points into the Dfs namespace. Note that the Win32 path
|
|||
|
// can either be a drive based path or a UNC path (\\..\dfs$\..)
|
|||
|
//
|
|||
|
// Arguments: [lpPath] -- The Win32 Path.
|
|||
|
// [lpPrefix] -- The org relative Prefix is returned here.
|
|||
|
// [lpBufferSize] -- On entry, contains the size of lpPrefix in
|
|||
|
// bytes. If DFS_E_BUFFER_TOO_SMALL is returned, this
|
|||
|
// will be set to indicate the required buffer size, in
|
|||
|
// bytes.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- If all went well.
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- If the buffer passed in small.
|
|||
|
// Required size will be in lpBufSize.
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsGetPrefixForPath(
|
|||
|
LPCWSTR lpPath,
|
|||
|
LPWSTR lpPrefix,
|
|||
|
LPDWORD lpBufferSize);
|
|||
|
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetDriveBasedPath, public
|
|||
|
//
|
|||
|
// Synopsis: This function takes a universal name (UNC form) and returns
|
|||
|
// a drive based path for it - If that path is in Dfs namespace.
|
|||
|
//
|
|||
|
// Arguments: [lpUniversalPath] -- The universal name.
|
|||
|
// [lpDriveBasedPath] -- The drive based path is returned here.
|
|||
|
// [lpBufferSize] -- On entry, contains the size of
|
|||
|
// lpDriveBasedPath in bytes. If DFS_E_BUFFER_TOO_SMALL
|
|||
|
// is returned, this will be set to indicate the
|
|||
|
// required buffer size, in bytes.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- If all went well.
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- If the buffer passed in small.
|
|||
|
// Required size will be in lpBufSize.
|
|||
|
// [DFS_E_NOT_DFS_NAMESPACE] --If the universal path does not
|
|||
|
// refer to Dfs namespace at all.
|
|||
|
// [DFS_E_NO_DRIVE_MAPPING] -- In the event that there is no drive
|
|||
|
// mapping available for this path.
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsGetDriveBasedPath(
|
|||
|
LPCWSTR lpUniversalPath,
|
|||
|
LPWSTR lpDriveBasedPath,
|
|||
|
LPDWORD lpBufferSize);
|
|||
|
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsPathsEqual, public
|
|||
|
//
|
|||
|
// Synopsis: This function compares two Win32 paths which point into the
|
|||
|
// Dfs namespace. It returns TRUE if the two paths refer to the
|
|||
|
// same ORG based prefix in the Dfs namespace and false if not.
|
|||
|
//
|
|||
|
// Arguments: [lpPath1] -- First Path
|
|||
|
// [lpPath2] -- Second Path
|
|||
|
//
|
|||
|
// Returns: TRUE If paths are equal else FALSE.
|
|||
|
//
|
|||
|
// Note: If the two paths differ in even a L'\' character at the end
|
|||
|
// a FALSE will be returned.
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
DFSAPI BOOLEAN
|
|||
|
DfsPathsEqual(
|
|||
|
LPCWSTR lpPath1,
|
|||
|
LPCWSTR lpPath2);
|
|||
|
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsFindVolumePrefix, public
|
|||
|
//
|
|||
|
// Synopsis: Given a Win32 path this function will return the entrypath of
|
|||
|
// the volume on which this path lies.
|
|||
|
//
|
|||
|
// Arguments: [lpPath] -- The path is passed in here.
|
|||
|
// [lpPrefix] -- The org based prefix form of the above path.
|
|||
|
// [lpBufferSize] -- On entry, contains the size of lpPrefix in
|
|||
|
// bytes. If DFS_E_BUFFER_TOO_SMALL is returned, this
|
|||
|
// will be set to indicate the required buffer size, in
|
|||
|
// bytes.
|
|||
|
// [lpVolPrefixLen] -- The portion of the lpPrefix which forms the
|
|||
|
// prefix of volume where the object lies. This
|
|||
|
// is in WCHARs.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- If all went well.
|
|||
|
// [DFS_E_NOT_DFS_NAMESPACE] --If the universal path does not
|
|||
|
// refer to Dfs namespace at all.
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- If the buffer passed in small.
|
|||
|
// Required size will be in lpBufSize.
|
|||
|
//
|
|||
|
// Notes: Memory is allocated for returned args here. Use MemFree.
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsFindVolumePrefix(
|
|||
|
LPCWSTR lpPath,
|
|||
|
LPWSTR lpPrefix,
|
|||
|
LPDWORD lpBufferSize,
|
|||
|
LPDWORD lpVolPrefixLen);
|
|||
|
|
|||
|
//+--------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsFindLocalPath, public
|
|||
|
//
|
|||
|
// Synopsis: This function returns the local path to an object (if such
|
|||
|
// a path exists) given the name of that object in the Dfs
|
|||
|
// namespace.
|
|||
|
//
|
|||
|
// Arguments: [lpPath] -- The path is passed in here.
|
|||
|
// [lpLocalPath] -- The local path to the same object.
|
|||
|
// [lpBufferSize] -- On entry, contains the size of lpLocalPath
|
|||
|
// in bytes. If DFS_E_BUFFER_TOO_SMALL is returned, this
|
|||
|
// will be set to indicate the required buffer size, in
|
|||
|
// bytes.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- If all went well.
|
|||
|
// [DFS_E_NOT_DFS_NAMESPACE] --If the universal path does not
|
|||
|
// refer to Dfs namespace at all.
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- If the buffer passed in small.
|
|||
|
// Required size will be in lpBufSize.
|
|||
|
//
|
|||
|
//---------------------------------------------------------------------------
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsFindLocalPath(
|
|||
|
LPCWSTR lpPath,
|
|||
|
LPWSTR lpLocalPath,
|
|||
|
LPDWORD lpBufferSize);
|
|||
|
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetHandleServerInfo, public
|
|||
|
//
|
|||
|
// Synopsis: Given a NT or Win32 handle to an Open file, this function
|
|||
|
// will return the name of the server that opened the file.
|
|||
|
//
|
|||
|
// Arguments: [hFile] -- Handle to open file.
|
|||
|
// [lpServerName] -- Pointer to buffer that will contain the
|
|||
|
// server name. If the file was opened on the local
|
|||
|
// machine, lpServerName[0] will be UNICODE_NULL (ie,
|
|||
|
// lpServerName == L"".
|
|||
|
// [lpcbServerName] -- On entry, size in bytes of lpServerName.
|
|||
|
// On return, if DFS_E_BUFFER_TOO_SMALL is returned,
|
|||
|
// this contains the size required.
|
|||
|
// [lpReplSpecificPath] -- Pointer to buffer that will contain
|
|||
|
// the replica specific path to the file that was
|
|||
|
// opened.
|
|||
|
// [lpcbReplSpecificPath] -- On entry, size in bytes of
|
|||
|
// lpdwReplSpecificPath. On return, if
|
|||
|
// DFS_E_BUFFER_TOO_SMALL is returned, this contains the
|
|||
|
// size required.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- lpServerName has the server's name, and
|
|||
|
// lpReplSpecifcPath has the replica specific path.
|
|||
|
//
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- Either lpServerName or
|
|||
|
// lpReplSpecificPath is too small.
|
|||
|
//
|
|||
|
// [DFS_E_NOT_DFS_NAMESPACE] -- Handle is not a Dfs handle.
|
|||
|
//
|
|||
|
// [E_HANDLE] -- Handle is invalid, the server that opened the
|
|||
|
// handle can no longer be reached, or some other network
|
|||
|
// error happened.
|
|||
|
//
|
|||
|
// [E_OUTOFMEMORY] -- Unable to allocate enough memory for
|
|||
|
// internal functioning.
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsGetHandleServerInfo(
|
|||
|
IN HANDLE hFile,
|
|||
|
IN OUT LPWSTR lpServerName,
|
|||
|
IN OUT LPDWORD lpcbServerName,
|
|||
|
IN OUT LPWSTR lpReplSpecificPath,
|
|||
|
IN OUT LPDWORD lpcbReplSpecificPath);
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetHandleIDs, public
|
|||
|
//
|
|||
|
// Synopsis: Given a Win32 or NT Handle (to a file/dir/obj), this function
|
|||
|
// will return the domain, volume, and object ids of the
|
|||
|
// object opened via the handle.
|
|||
|
//
|
|||
|
//
|
|||
|
// Arguments: [hFile] -- [NT or Win32] Handle to the file/directory/object.
|
|||
|
// [pDomainId] -- On successful return, these three fields
|
|||
|
// [pVolumeId] -- contain the domain, volume and object id.
|
|||
|
// [pObjectId]
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- IDs returned successfully
|
|||
|
//
|
|||
|
// [E_HANDLE] -- Handle is invalid, is not a Dfs handle,
|
|||
|
// the server that opened the handle can no longer be
|
|||
|
// reached, or the underlying file system does not
|
|||
|
// support object ids.
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsGetHandleIDs(
|
|||
|
IN HANDLE hFile,
|
|||
|
OUT GUID *pDomainId,
|
|||
|
OUT GUID *pVolumeId,
|
|||
|
OUT OBJECTID *pObjectId);
|
|||
|
|
|||
|
//+----------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetVolumeFromID, public
|
|||
|
//
|
|||
|
// Synopsis: Given a domain and volume id (probably returned by
|
|||
|
// DfsGetHandleIDs), this routine will return a Win32 name
|
|||
|
// corresponding to the given ids.
|
|||
|
//
|
|||
|
// Arguments: [pDomainId] -- The domain and volume ids to "resolve".
|
|||
|
// [pVolumeId]
|
|||
|
// [pwszPath] -- The path is returned here. This must point to a
|
|||
|
// valid buffer.
|
|||
|
// [lpdwSize] -- The size, in bytes, of pwszPath. If the buffer
|
|||
|
// is too small, then on return, this variable will
|
|||
|
// contain the required number of bytes.
|
|||
|
//
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- Everything went ok, and the path is in pszPath.
|
|||
|
//
|
|||
|
// [DFS_E_BUFFER_TOO_SMALL] -- The provided buffer was too small;
|
|||
|
// the required buffer size, in bytes, is returned in
|
|||
|
// lpdwSize.
|
|||
|
//
|
|||
|
// [E_INVALIDARG] -- pwszPath does not point to a valid buffer.
|
|||
|
//
|
|||
|
// [DFS_E_NO_MAPPING] -- Either the domain id could not be
|
|||
|
// resolved to a domain name, or the volume id did not
|
|||
|
// correspond to an existing volume.
|
|||
|
//
|
|||
|
//-----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI
|
|||
|
DfsGetVolumeFromID(
|
|||
|
IN GUID *pDomainId,
|
|||
|
IN GUID *pVolumeId,
|
|||
|
OUT LPWSTR pwszPath,
|
|||
|
IN OUT LPDWORD lpdwSize);
|
|||
|
|
|||
|
|
|||
|
//
|
|||
|
// FOLLOWING ARE APIS FOR ACQUIRING BINDING STRINGS VIA DFS
|
|||
|
//
|
|||
|
|
|||
|
//
|
|||
|
// Following are the values for the grfFlags argument in DfsGetBindingsFirst
|
|||
|
//
|
|||
|
#define DFS_ALLOW_DATAGRAM 0x01
|
|||
|
|
|||
|
//
|
|||
|
// Following are the values for the ulReason argument in DfsGetBindingsNext
|
|||
|
//
|
|||
|
#define REASON_UNAVAILABLE 0x01
|
|||
|
#define REASON_TOOBUSY 0x02
|
|||
|
#define REASON_OTHER 0x04
|
|||
|
|
|||
|
//+---------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetBindingsFirst
|
|||
|
//
|
|||
|
// Synopsis: Given the name of an object, this function figures out the
|
|||
|
// machine on which the object lies and returns an RPC binding
|
|||
|
// handle to that machine. This will be a partial binding handle.
|
|||
|
// If the path resolves to a replicated volume, a binding to the
|
|||
|
// preferred replica is returned, along with a cookie which
|
|||
|
// can be passed back into DfsGetBindingsNext (see below) to
|
|||
|
// iterate through the other replicas.
|
|||
|
//
|
|||
|
// Arguments: [grfFlags] -- Flags. Currently only one value:
|
|||
|
//
|
|||
|
// DFS_ALLOW_DATAGRAM - indicates that the binding
|
|||
|
// returned may be for a datagram
|
|||
|
// transport. Otherwise, only
|
|||
|
// connection-oriented transports
|
|||
|
// will be considered.
|
|||
|
//
|
|||
|
// [pwszObjectName] -- Win32 path to the object for which
|
|||
|
// a binding is requested.
|
|||
|
//
|
|||
|
// [pbh] -- The Binding Handle is returned here. See notes below.
|
|||
|
//
|
|||
|
// [pdwContinuation] -- Returns the continuation cookie for
|
|||
|
// accessing alternative replicas.
|
|||
|
//
|
|||
|
// Returns: S_OK -- If there are other replicas and caller can call
|
|||
|
// Close/Next APIs to get more binding handles using the
|
|||
|
// continuation cookie.
|
|||
|
//
|
|||
|
// S_FALSE -- If there are no other replicas.
|
|||
|
//
|
|||
|
//
|
|||
|
// Notes: If the path specified resolves to the local machine, the function
|
|||
|
// will return S_FALSE and *pbh will be set to NULL. If the path
|
|||
|
// resolves into DFS, the binding handle returned will be for the
|
|||
|
// optimal compatible transport. If the path resolves to a non-DFS
|
|||
|
// network path, a named pipe binding will be returned (along with
|
|||
|
// S_FALSE).
|
|||
|
//
|
|||
|
//----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetBindingsFirst(
|
|||
|
DWORD grfFlags,
|
|||
|
LPWSTR pwszObjectName,
|
|||
|
RPC_BINDING_HANDLE *pbh,
|
|||
|
LPDWORD pdwContinuation);
|
|||
|
|
|||
|
|
|||
|
//+---------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetBindingsNext
|
|||
|
//
|
|||
|
// Synopsis: This function should be called only after DfsGetBindingsFirst
|
|||
|
// has been called. If the first binding handle returned
|
|||
|
// does not work then this function is called to see if there
|
|||
|
// are other replicas for which a binding handle can be obtained
|
|||
|
//
|
|||
|
// Arguments: [dwContinuation] -- The continuation handle returned in
|
|||
|
// DfsGetBindingsFirst API.
|
|||
|
// [ulReason] -- The reason additional bindings are being
|
|||
|
// requested. This is only informational to Dfs.
|
|||
|
// [pbh] -- The binding handle for the next replica.
|
|||
|
//
|
|||
|
// Returns: [S_OK] -- If there are other replicas still available.
|
|||
|
// [S_FALSE] -- If the vector returned is for last replica.
|
|||
|
//
|
|||
|
//----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetBindingsNext(
|
|||
|
DWORD dwContinuation,
|
|||
|
ULONG ulReason,
|
|||
|
RPC_BINDING_HANDLE *pbh);
|
|||
|
|
|||
|
|
|||
|
//+---------------------------------------------------------------------------
|
|||
|
//
|
|||
|
// Function: DfsGetBindingsClose
|
|||
|
//
|
|||
|
// Synopsis: This function releases the continuation pseudo-handle. This
|
|||
|
// call should not be issued if DfsGetBindingsFirst/Next returns
|
|||
|
// S_FALSE or an error.
|
|||
|
//
|
|||
|
// Arguments: [dwContinuation] -- Continuation handle returned from
|
|||
|
// DfsGetBindingsFirst
|
|||
|
//
|
|||
|
// Returns:
|
|||
|
//
|
|||
|
//----------------------------------------------------------------------------
|
|||
|
|
|||
|
DFSAPI STDAPI DfsGetBindingsClose(
|
|||
|
DWORD dwContinuation);
|
|||
|
|
|||
|
#ifdef __cplusplus
|
|||
|
}
|
|||
|
#endif
|
|||
|
|
|||
|
#endif
|