ntdsapi.pas

详细Windows API大全有关知识以及相关问题

//              UPDATE_ADDRESS
//                  Update the MTX_ADDR associated with the referenced server.
//              UPDATE_SCHEDULE
//                  Update the periodic replication schedule associated with
//                  the replica.
//              UPDATE_FLAGS
//                  Update the flags associated with the replica.
//              UPDATE_TRANSPORT
//                  Update the transport associated with the replica.
//      ulOptions (ULONG)
//          Bitwise OR of zero or more of the following:
//              DS_REPMOD_ASYNCHRONOUS_OPERATION
//                  Perform this operation asynchronously.
//   RETURNS: WIN32 STATUS

function DsReplicaModifyA(hDS: HANDLE; NameContext: LPCSTR; pUuidSourceDsa: LPUUID;
  TransportDn: LPCSTR; SourceDsaAddress: LPCSTR; pSchedule: PSCHEDULE;
  ReplicaFlags: DWORD; ModifyFields: DWORD; Options: DWORD): DWORD; stdcall;
{$EXTERNALSYM DsReplicaModifyA}
function DsReplicaModifyW(hDS: HANDLE; NameContext: LPCWSTR; pUuidSourceDsa: LPUUID;
  TransportDn: LPCWSTR; SourceDsaAddress: LPCWSTR; pSchedule: PSCHEDULE;
  ReplicaFlags: DWORD; ModifyFields: DWORD; Options: DWORD): DWORD; stdcall;
{$EXTERNALSYM DsReplicaModifyW}

{$IFDEF UNICODE}
function DsReplicaModify(hDS: HANDLE; NameContext: LPCWSTR; pUuidSourceDsa: LPUUID;
  TransportDn: LPCWSTR; SourceDsaAddress: LPCWSTR; pSchedule: PSCHEDULE;
  ReplicaFlags: DWORD; ModifyFields: DWORD; Options: DWORD): DWORD; stdcall;
{$EXTERNALSYM DsReplicaModify}
{$ELSE}
function DsReplicaModify(hDS: HANDLE; NameContext: LPCSTR; pUuidSourceDsa: LPUUID;
  TransportDn: LPCSTR; SourceDsaAddress: LPCSTR; pSchedule: PSCHEDULE;
  ReplicaFlags: DWORD; ModifyFields: DWORD; Options: DWORD): DWORD; stdcall;
{$EXTERNALSYM DsReplicaModify}
{$ENDIF}

// DsReplicaUpdateRefs
//
// In this case, the RPC is being executed on the "source" of destination-sourc
// replication relationship.  This function tells the source that it no longer
// supplies replication information to the indicated destination system.
// Add or remove a target server from the Reps-To property on the given NC.
// Add/remove a reference given the DSNAME of the corresponding NTDS-DSA
// object.
//
//  PARAMETERS:
//      pNC (DSNAME *)
//          Name of the NC for which the Reps-To should be modified.
//      DsaDest (SZ)
//          Network address of DSA for which the reference should be added
//          or deleted.
//      pUuidDsaDest (UUID *)
//          Invocation-ID of DSA for which the reference should be added
//          or deleted.
//      ulOptions (ULONG)
//          Bitwise OR of zero or more of the following:
//              DS_REPUPD_ASYNC_OP
//                  Perform this operation asynchronously.
//              DS_REPUPD_ADD_REFERENCE
//                  Add the given server to the Reps-To property.
//              DS_REPUPD_DEL_REFERENCE
//                  Remove the given server from the Reps-To property.
//          Note that ADD_REF and DEL_REF may be paired to perform
//          "add or update".
//
//   RETURNS: WIN32 STATUS

function DsReplicaUpdateRefsA(hDS: HANDLE; NameContext: LPCSTR; DsaDest: LPCSTR;
  pUuidDsaDest: LPUUID; Options: ULONG): DWORD; stdcall;
{$EXTERNALSYM DsReplicaUpdateRefsA}
function DsReplicaUpdateRefsW(hDS: HANDLE; NameContext: LPCWSTR; DsaDest: LPCWSTR;
  pUuidDsaDest: LPUUID; Options: ULONG): DWORD; stdcall;
{$EXTERNALSYM DsReplicaUpdateRefsW}

{$IFDEF UNICODE}
function DsReplicaUpdateRefs(hDS: HANDLE; NameContext: LPCWSTR; DsaDest: LPCWSTR;
  pUuidDsaDest: LPUUID; Options: ULONG): DWORD; stdcall;
{$EXTERNALSYM DsReplicaUpdateRefs}
{$ELSE}
function DsReplicaUpdateRefs(hDS: HANDLE; NameContext: LPCSTR; DsaDest: LPCSTR;
  pUuidDsaDest: LPUUID; Options: ULONG): DWORD; stdcall;
{$EXTERNALSYM DsReplicaUpdateRefs}
{$ENDIF}

// Friends of DsReplicaSyncAll

type
  DS_REPSYNCALL_ERROR = (
    DS_REPSYNCALL_WIN32_ERROR_CONTACTING_SERVER,
    DS_REPSYNCALL_WIN32_ERROR_REPLICATING,
    DS_REPSYNCALL_SERVER_UNREACHABLE);
  {$EXTERNALSYM DS_REPSYNCALL_ERROR}
  TDsReSynCallError = DS_REPSYNCALL_ERROR;

  DS_REPSYNCALL_EVENT = (
    DS_REPSYNCALL_EVENT_ERROR,
    DS_REPSYNCALL_EVENT_SYNC_STARTED,
    DS_REPSYNCALL_EVENT_SYNC_COMPLETED,
    DS_REPSYNCALL_EVENT_FINISHED);
  {$EXTERNALSYM DS_REPSYNCALL_EVENT}
  TDsReSynCallEvent = DS_REPSYNCALL_EVENT;

// Friends of DsReplicaSyncAll

  PDS_REPSYNCALL_SYNCA = ^DS_REPSYNCALL_SYNCA;
  {$EXTERNALSYM PDS_REPSYNCALL_SYNCA}
  DS_REPSYNCALL_SYNCA = record
    pszSrcId: LPSTR;
    pszDstId: LPSTR;
    pszNC: LPSTR;
    pguidSrc: LPGUID;
    pguidDst: LPGUID;
  end;
  {$EXTERNALSYM DS_REPSYNCALL_SYNCA}
  TDsRepsyncallSyncA = DS_REPSYNCALL_SYNCA;
  PDsRepsyncallSyncA = PDS_REPSYNCALL_SYNCA;

  PDS_REPSYNCALL_SYNCW = ^DS_REPSYNCALL_SYNCW;
  {$EXTERNALSYM PDS_REPSYNCALL_SYNCW}
  DS_REPSYNCALL_SYNCW = record
    pszSrcId: LPWSTR;
    pszDstId: LPWSTR;
    pszNC: LPWSTR;
    pguidSrc: LPGUID;
    pguidDst: LPGUID;
  end;
  {$EXTERNALSYM DS_REPSYNCALL_SYNCW}
  TDsRepsyncallSyncW = DS_REPSYNCALL_SYNCW;
  PDsRepsyncallSyncW = PDS_REPSYNCALL_SYNCW;

  PDS_REPSYNCALL_ERRINFOA = ^DS_REPSYNCALL_ERRINFOA;
  {$EXTERNALSYM PDS_REPSYNCALL_ERRINFOA}
  DS_REPSYNCALL_ERRINFOA = record
    pszSvrId: LPSTR;
    error: DS_REPSYNCALL_ERROR;
    dwWin32Err: DWORD;
    pszSrcId: LPSTR;
  end;
  {$EXTERNALSYM DS_REPSYNCALL_ERRINFOA}
  PPDS_REPSYNCALL_ERRINFOA = ^PDS_REPSYNCALL_ERRINFOA;
  {$NODEFINE PPDS_REPSYNCALL_ERRINFOA}
  TDsRepSynCallErrInfoA = DS_REPSYNCALL_ERRINFOA;
  PDsRepSynCallErrInfoA = PDS_REPSYNCALL_ERRINFOA;

  PDS_REPSYNCALL_ERRINFOW = ^DS_REPSYNCALL_ERRINFOW;
  {$EXTERNALSYM PDS_REPSYNCALL_ERRINFOW}
  DS_REPSYNCALL_ERRINFOW = record
    pszSvrId: LPWSTR;
    error: DS_REPSYNCALL_ERROR;
    dwWin32Err: DWORD;
    pszSrcId: LPWSTR;
  end;
  {$EXTERNALSYM DS_REPSYNCALL_ERRINFOW}
  PPDS_REPSYNCALL_ERRINFOW = ^PDS_REPSYNCALL_ERRINFOW;
  {$NODEFINE PPDS_REPSYNCALL_ERRINFOW}
  TDsRepSynCallErrInfoW = DS_REPSYNCALL_ERRINFOW;
  PDsRepSynCallErrInfoW = PDS_REPSYNCALL_ERRINFOW;

  PDS_REPSYNCALL_UPDATEA = ^DS_REPSYNCALL_UPDATEA;
  {$EXTERNALSYM PDS_REPSYNCALL_UPDATEA}
  DS_REPSYNCALL_UPDATEA = record
    event: DS_REPSYNCALL_EVENT;
    pErrInfo: PDS_REPSYNCALL_ERRINFOA;
    pSync: PDS_REPSYNCALL_SYNCA;
  end;
  {$EXTERNALSYM DS_REPSYNCALL_UPDATEA}
  TDsRepSynCallUpdateA = DS_REPSYNCALL_UPDATEA;
  PDsRepSynCallUpdateA = PDS_REPSYNCALL_UPDATEA;

  PDS_REPSYNCALL_UPDATEW = ^DS_REPSYNCALL_UPDATEW;
  {$EXTERNALSYM PDS_REPSYNCALL_UPDATEW}
  DS_REPSYNCALL_UPDATEW = record
    event: DS_REPSYNCALL_EVENT;
    pErrInfo: PDS_REPSYNCALL_ERRINFOW;
    pSync: PDS_REPSYNCALL_SYNCW;
  end;
  {$EXTERNALSYM DS_REPSYNCALL_UPDATEW}
  TDsRepSynCallUpdateW = DS_REPSYNCALL_UPDATEW;
  PDsRepSynCallUpdateW = PDS_REPSYNCALL_UPDATEW;

{$IFDEF UNICODE}
  DS_REPSYNCALL_SYNC = DS_REPSYNCALL_SYNCW;
  {$EXTERNALSYM DS_REPSYNCALL_SYNC}
  DS_REPSYNCALL_ERRINFO = DS_REPSYNCALL_ERRINFOW;
  {$EXTERNALSYM DS_REPSYNCALL_ERRINFO}
  PPDS_REPSYNCALL_ERRINFO = PPDS_REPSYNCALL_ERRINFOW;
  {$NODEFINE PPDS_REPSYNCALL_ERRINFO}
  DS_REPSYNCALL_UPDATE = DS_REPSYNCALL_UPDATEW;
  {$EXTERNALSYM DS_REPSYNCALL_UPDATE}
  PDS_REPSYNCALL_SYNC = PDS_REPSYNCALL_SYNCW;
  {$EXTERNALSYM PDS_REPSYNCALL_SYNC}
  PDS_REPSYNCALL_ERRINFO = PDS_REPSYNCALL_ERRINFOW;
  {$EXTERNALSYM PDS_REPSYNCALL_ERRINFO}
  PDS_REPSYNCALL_UPDATE = PDS_REPSYNCALL_UPDATEW;
  {$EXTERNALSYM PDS_REPSYNCALL_UPDATE}
  TDsRepSynCallSync = TDsRepSynCallSyncW;
  PDsRepSynCallSync = PDsRepSynCallSyncW;
  TDsRepSynCallErrInfo = TDsRepSynCallErrInfoW;
  PDsRepSynCallErrInfo = PDsRepSynCallErrInfoW;
  TDsRepSynCallUpdate = TDsRepSynCallUpdateW;
  PDsRepSynCallUpdate = PDsRepSynCallUpdateW;
{$ELSE}
  DS_REPSYNCALL_SYNC = DS_REPSYNCALL_SYNCA;
  {$EXTERNALSYM DS_REPSYNCALL_SYNC}
  DS_REPSYNCALL_ERRINFO = DS_REPSYNCALL_ERRINFOA;
  {$EXTERNALSYM DS_REPSYNCALL_ERRINFO}
  PPDS_REPSYNCALL_ERRINFO = PPDS_REPSYNCALL_ERRINFOA;
  {$NODEFINE PPDS_REPSYNCALL_ERRINFO}
  DS_REPSYNCALL_UPDATE = DS_REPSYNCALL_UPDATEA;
  {$EXTERNALSYM DS_REPSYNCALL_UPDATE}
  PDS_REPSYNCALL_SYNC = PDS_REPSYNCALL_SYNCA;
  {$EXTERNALSYM PDS_REPSYNCALL_SYNC}
  PDS_REPSYNCALL_ERRINFO = PDS_REPSYNCALL_ERRINFOA;
  {$EXTERNALSYM PDS_REPSYNCALL_ERRINFO}
  PDS_REPSYNCALL_UPDATE = PDS_REPSYNCALL_UPDATEA;
  {$EXTERNALSYM PDS_REPSYNCALL_UPDATE}
  TDsRepSynCallSync = TDsRepSynCallSyncA;
  PDsRepSynCallSync = PDsRepSynCallSyncA;
  TDsRepSynCallErrInfo = TDsRepSynCallErrInfoA;
  PDsRepSynCallErrInfo = PDsRepSynCallErrInfoA;
  TDsRepSynCallUpdate = TDsRepSynCallUpdateA;
  PDsRepSynCallUpdate = PDsRepSynCallUpdateA;
{$ENDIF}

// **********************
// Replica SyncAll flags
// **********************

const

// This option has no effect.

  DS_REPSYNCALL_NO_OPTIONS = $00000000;
  {$EXTERNALSYM DS_REPSYNCALL_NO_OPTIONS}

// Ordinarily, if a server cannot be contacted, DsReplicaSyncAll tries to
// route around it and replicate from as many servers as possible.  Enabling
// this option will cause DsReplicaSyncAll to generate a fatal error if any
// server cannot be contacted, or if any server is unreachable (due to a
// disconnected or broken topology.)

  DS_REPSYNCALL_ABORT_IF_SERVER_UNAVAILABLE = $00000001;
  {$EXTERNALSYM DS_REPSYNCALL_ABORT_IF_SERVER_UNAVAILABLE}

// This option disables transitive replication; syncs will only be performed
// with adjacent servers and no DsBind calls will be made.

  DS_REPSYNCALL_SYNC_ADJACENT_SERVERS_ONLY = $00000002;
  {$EXTERNALSYM DS_REPSYNCALL_SYNC_ADJACENT_SERVERS_ONLY}

// Ordinarily, when DsReplicaSyncAll encounters a non-fatal error, it returns
// the GUID DNS of the relevant server(s).  Enabling this option causes
// DsReplicaSyncAll to return the servers' DNs instead.

  DS_REPSYNCALL_ID_SERVERS_BY_DN = $00000004;
  {$EXTERNALSYM DS_REPSYNCALL_ID_SERVERS_BY_DN}

// This option disables all syncing.  The topology will still be analyzed and
// unavailable / unreachable servers will still be identified.

  DS_REPSYNCALL_DO_NOT_SYNC = $00000008;
  {$EXTERNALSYM DS_REPSYNCALL_DO_NOT_SYNC}

// Ordinarily, DsReplicaSyncAll attempts to bind to all servers before
// generating the topology.  If a server cannot be contacted, DsReplicaSyncAll
// excludes that server from the topology and tries to route around it.  If
// this option is enabled, checking will be bypassed and DsReplicaSyncAll will
// assume all servers are responding.  This will speed operation of
// DsReplicaSyncAll, but if some servers are not responding, some transitive
// replications may be blocked.

  DS_REPSYNCALL_SKIP_INITIAL_CHECK = $00000010;
  {$EXTERNALSYM DS_REPSYNCALL_SKIP_INITIAL_CHECK}

// Push mode. Push changes from the home server out to all partners using
// transitive replication.  This reverses the direction of replication, and
// the order of execution of the replication sets from the usual "pulling"
// mode of execution.

  DS_REPSYNCALL_PUSH_CHANGES_OUTWARD = $00000020;
  {$EXTERNALSYM DS_REPSYNCALL_PUSH_CHANGES_OUTWARD}

// Cross site boundaries.  By default, the only servers that are considered are
// those in the same site as the home system.  With this option, all servers in
// the enterprise, across all sites, are eligible.  They must be connected by
// a synchronous (RPC) transport, however.

  DS_REPSYNCALL_CROSS_SITE_BOUNDARIES = $00000040;
  {$EXTERNALSYM DS_REPSYNCALL_CROSS_SITE_BOUNDARIES}

// DsReplicaSyncAll.  Syncs the destination server with all other servers
// in the site.
//
//  PARAMETERS:
//	hDS		(IN) - A DS connection bound to the destination server.
//	pszNameContext	(IN) - The naming context to synchronize
//	ulFlags		(IN) - Bitwise OR of zero or more flags
//	pFnCallBack	(IN, OPTIONAL) - Callback function for message-passing.
//	pCallbackData	(IN, OPTIONAL) - A pointer that will be passed to the
//				first argument of the callback function.
//	pErrors		(OUT, OPTIONAL) - Pointer to a (PDS_REPSYNCALL_ERRINFO *)
//				object that will hold an array of error structures.

type
  TSynchUpdateProcA = function (pData: LPVOID; pUpdate: PDS_REPSYNCALL_UPDATEA): BOOL; stdcall;
  TSynchUpdateProcW = function (pData: LPVOID; pUpdate: PDS_REPSYNCALL_UPDATEW): BOOL; stdcall;

function DsReplicaSyncAllA(hDS: HANDLE; pszNameContext: LPCSTR; ulFlags: ULONG;
  pfnCallBack: TSynchUpdateProcA; pCallbackData: LPVOID;
  pErrors: PPDS_REPSYNCALL_ERRINFOA): DWORD; stdcall;
{$EXTERNALSYM DsReplicaSyncAllA}
function DsReplicaSyncAllW(hDS: HANDLE; pszNameContext: LPCWSTR; ulFlags: ULONG;
  pfnCallBackW: TSynchUpdateProcW; pCallbackData: LPVOID;
  pErrors: PPDS_REPSYNCALL_ERRINFOW): DWORD; stdcall;
{$EXTERNALSYM DsReplicaSyncAllW}

{$IFDEF UNICODE}
function DsReplicaSyncAll(hDS: HANDLE; pszNameContext: LPCWSTR; ulFlags: ULONG;
  pfnCallBackW: TSynchUpdateProcW; pCallbackData: LPVOID;
  pErrors: PPDS_REPSYNCALL_ERRINFOW): DWORD; stdcall;
{$EXTERNALSYM DsReplicaSyncAll}
{$ELSE}
function DsReplicaSyncAll(hDS: HANDLE; pszNameContext: LPCSTR; ulFlags: ULONG;
  pfnCallBack: TSynchUpdateProcA; pCallbackData: LPVOID;
  pErrors: PPDS_REPSYNCALL_ERRINFOA): DWORD; stdcall;
{$EXTERNALSYM DsReplicaSyncAll}
{$ENDIF}

function DsRemoveDsServerA(hDs: HANDLE; ServerDN: LPSTR; DomainDN: LPSTR;
  fLastDcInDomain: PBOOL; fCommit: BOOL):