|
|
/*++
Microsoft Windows
Copyright (C) Microsoft Corporation, 1998 - 2001
Module Name:
time.c
Abstract:
Handles the various functions for the time functionality of netdom
--*/#include "pch.h"
#pragma hdrstop
#include <netdom.h>
DWORDNetDompTimeGetDc( IN PWSTR Domain, IN PWSTR DestServer, IN PND5_AUTH_INFO AuthInfo, OUT PWSTR *Dc )/*++
Routine Description:
This function will find the DC to use as a time source for the given machine
Arguments:
Domain - Domain to get a time source from
DestServer - Server for which we need a time source
AuthInfo - Auth info to connect to the destination server for
Dc - Where the dc name is returned. Freed via NetApiBufferFree
Return Value:
ERROR_INVALID_PARAMETER - No object name was supplied
--*/{ DWORD Win32Err = ERROR_SUCCESS; PDOMAIN_CONTROLLER_INFO DcInfo = NULL; BOOL Retry = FALSE; WCHAR FlatName[ CNLEN + 1 ]; ULONG Len = CNLEN + 1;
//
// Get a server name
//
Win32Err = DsGetDcName( NULL, Domain, NULL, NULL, DS_GOOD_TIMESERV_PREFERRED, &DcInfo );
//
// If we have a destination server specified, make sure that we
// aren't talking to ourselves... That would kind of defeat the purpose
//
if ( Win32Err == ERROR_SUCCESS && DestServer ) {
if ( !_wcsicmp( DcInfo->DomainControllerName + 2, DestServer ) ) {
Retry = TRUE;
} else {
//
// Handle the case where we have a Dns dc name and a netbios server name
//
if ( wcslen( DestServer ) <= CNLEN && FLAG_ON( DcInfo->Flags, DS_IS_DNS_NAME ) ) {
if ( !DnsHostnameToComputerName( DcInfo->DomainControllerName + 2, FlatName, &Len ) ) {
Win32Err = GetLastError();
} else {
if ( !_wcsicmp( FlatName, DestServer ) ) {
Retry = TRUE; } } } } }
//
// We have a dc name specified, so connect to that machine, and try it again, with
// the AvoidSelf flag. If we can't (like this is an NT4 PDC) then return that we
// can't find a dc
//
if ( Win32Err == ERROR_SUCCESS && Retry ) {
NetApiBufferFree( DcInfo ); DcInfo = NULL;
Win32Err = NetpManageIPCConnect( DestServer, AuthInfo->User, AuthInfo->Password, NETSETUPP_CONNECT_IPC );
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = DsGetDcName( DestServer, Domain, NULL, NULL, DS_GOOD_TIMESERV_PREFERRED | DS_AVOID_SELF, &DcInfo );
NetpManageIPCConnect( DestServer, AuthInfo->User, AuthInfo->Password, NETSETUPP_DISCONNECT_IPC ); }
}
//
// Copy the name if everything worked
//
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = NetApiBufferAllocate( ( wcslen( DcInfo->DomainControllerName + 2 ) + 1 ) * sizeof( WCHAR ), (PVOID*)Dc ); if ( Win32Err == ERROR_SUCCESS ) {
wcscpy( *Dc, DcInfo->DomainControllerName + 2 ); } }
NetApiBufferFree( DcInfo );
return( Win32Err );}
DWORDNetDompEnableSystimePriv( VOID )/*++
Routine Description:
This function will enable the systemtime privilege for the current thread
Arguments:
VOID
Return Value:
ERROR_INVALID_PARAMETER - No object name was supplied
--*/{ NTSTATUS Status; HANDLE ThreadToken; TOKEN_PRIVILEGES Enabled, Previous; DWORD PreviousSize;
Status = NtOpenThreadToken( NtCurrentThread(), TOKEN_READ | TOKEN_WRITE, TRUE, &ThreadToken );
if ( Status == STATUS_NO_TOKEN ) {
Status = NtOpenProcessToken( NtCurrentProcess(), TOKEN_WRITE | TOKEN_READ, &ThreadToken ); }
if ( NT_SUCCESS( Status ) ) {
Enabled.PrivilegeCount = 1; Enabled.Privileges[0].Luid.LowPart = SE_SYSTEMTIME_PRIVILEGE; Enabled.Privileges[0].Luid.HighPart = 0; Enabled.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; PreviousSize = sizeof( Previous );
Status = NtAdjustPrivilegesToken( ThreadToken, FALSE, &Enabled, sizeof( Enabled ), &Previous, &PreviousSize ); }
return( RtlNtStatusToDosError( Status ) );}
DWORDNetDompGetTimeTripLength( IN PWSTR Server, IN OUT PDWORD TripLength )/*++
Routine Description:
This function will get an approximate elapsed time for getting the time from a domain controller
Arguments:
Server - Server to get the elapsed trip time for
TripLength - Number of ticks it takes to get the time
Return Value:
ERROR_SUCCESS - The function succeeded
--*/{ DWORD Win32Err = ERROR_SUCCESS; ULONG StartTime, EndTime, ElapsedTime = 0, i; PTIME_OF_DAY_INFO TOD;#define NETDOMP_NUM_TRIPS 2
//
// Get the average from several time trips
//
for ( i = 0; i < NETDOMP_NUM_TRIPS && Win32Err == ERROR_SUCCESS; i++ ) {
StartTime = GetTickCount(); Win32Err = NetRemoteTOD( Server, ( LPBYTE * )&TOD ); EndTime = GetTickCount(); ElapsedTime += ( EndTime - StartTime );
NetApiBufferFree( TOD ); }
if ( Win32Err == ERROR_SUCCESS ) {
*TripLength = ElapsedTime / NETDOMP_NUM_TRIPS; }
return( Win32Err );}
DWORDNetDompResetSingleClient( IN PWSTR Server, IN PWSTR Dc, IN PND5_AUTH_INFO ObjectAuthInfo, IN DWORD DcDelay )/*++
Routine Description:
This function sync the time between and NT5 client and the specified domain controller
Arguments:
Server - Server to reset the time for
Dc - Domain controller to sync the time against
ObjectAuthInfo - User info to connect to the server as
DcDelay - The amount of time it takes to talk to the dc
Return Value:
ERROR_SUCCESS - The function succeeded
--*/{ DWORD Win32Err = ERROR_SUCCESS; BOOL Connected = FALSE; //PSTR ServerA = NULL;
//
// Set up a connection to the client machine
//
Win32Err = NetpManageIPCConnect( Server, ObjectAuthInfo->User, ObjectAuthInfo->Password, NETSETUPP_CONNECT_IPC ); if ( Win32Err == ERROR_SUCCESS ) {
Connected = TRUE;
} else {
goto ResetSingleError; }
//if ( Server ) {
//
// Win32Err = NetApiBufferAllocate( wcstombs( NULL, Server, wcslen( Server ) + 1 ) + 3,
// &ServerA );
// if ( Win32Err != ERROR_SUCCESS ) {
//
// goto ResetSingleError;
// }
//
// if ( *Server == L'\\' ) {
//
// strcpy( ServerA, "\\\\" );
// wcstombs( ServerA + 2, Server, wcslen( Server ) + 1 );
//
// } else {
//
// wcstombs( ServerA, Server, wcslen( Server ) + 1 );
// }
//}
Win32Err = W32TimeSyncNow( Server, FALSE, // no wait
TimeSyncFlag_HardResync );
ResetSingleError:
if ( Connected ) {
NetpManageIPCConnect( Server, ObjectAuthInfo->User, ObjectAuthInfo->Password, NETSETUPP_DISCONNECT_IPC ); }
//NetApiBufferFree( ServerA );
return( Win32Err );}
DWORDNetDompVerifySingleClient( IN PWSTR Server, IN PWSTR Dc, IN PND5_AUTH_INFO ObjectAuthInfo, IN DWORD DcDelay, IN BOOL * InSync )/*++
Routine Description:
This function will verify that the time between the specified server and domain controller is within the acceptable skew
Arguments:
Server - Server to verify the time for
Dc - Domain controller to verify the time against
ObjectAuthInfo - User and password to connect to the client as
DcDelay - How long does it take to get the time from the domain controller
InSync - Where the results are returned.
Return Value:
ERROR_SUCCESS - The function succeeded
--*/{ DWORD Win32Err = ERROR_SUCCESS; SYSTEMTIME StartTime, EndTime; PTIME_OF_DAY_INFO DcTOD = NULL, ClientTOD = NULL; BOOL Connected = FALSE; FILETIME StartFile, EndFile; LARGE_INTEGER ElapsedTime, TimeDifference, DcTime, ClientTime, UpdatedDcTime, TimeSkew, AllowedSkew; TIME_FIELDS TimeFields; LARGE_INTEGER SystemTime;
//
// Set the allowable time skew. 600,000,000L is the number of 100 nanoseconds in a minute
//
#define NETDOMP_VERIFY_SKEW 0xB2D05E00
//
// Assume the clocks are fine
//
*InSync = TRUE;
//
// Set up a connection to the client machine
//
Win32Err = NetpManageIPCConnect( Server, ObjectAuthInfo->User, ObjectAuthInfo->Password, NETSETUPP_CONNECT_IPC ); if ( Win32Err == ERROR_SUCCESS ) {
Connected = TRUE;
} else {
goto VerifySingleError; }
//
// Ok, first, we get the time on the dc, then we get the time on the client, keeping in mind
// how long that takes,
//
Win32Err = NetRemoteTOD( Dc, ( LPBYTE * )&DcTOD );
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = NetRemoteTOD( Server, ( LPBYTE * )&ClientTOD );
}
if ( Win32Err != ERROR_SUCCESS ) {
goto VerifySingleError; }
//
// Ok, now we've gotten all the info we need, assemble it... Note that we are only computing
// the difference in time here...
//
SystemTimeToFileTime( &StartTime, &StartFile ); SystemTimeToFileTime( &EndTime, &EndFile );
ElapsedTime = RtlLargeIntegerSubtract( *( PLARGE_INTEGER )&EndFile, *( PLARGE_INTEGER )&StartFile );
TimeFields.Hour = ( WORD )DcTOD->tod_hours; TimeFields.Minute = ( WORD )DcTOD->tod_mins; TimeFields.Second = ( WORD )DcTOD->tod_secs; TimeFields.Milliseconds = ( WORD )DcTOD->tod_hunds * 10; TimeFields.Day = ( WORD )DcTOD->tod_day; TimeFields.Month = ( WORD )DcTOD->tod_month; TimeFields.Year = ( WORD )DcTOD->tod_year;
if ( !RtlTimeFieldsToTime( &TimeFields, &DcTime ) ) {
Win32Err = ERROR_INVALID_PARAMETER; }
TimeFields.Hour = ( WORD )ClientTOD->tod_hours; TimeFields.Minute = ( WORD )ClientTOD->tod_mins; TimeFields.Second = ( WORD )ClientTOD->tod_secs; TimeFields.Milliseconds = ( WORD )ClientTOD->tod_hunds * 10; TimeFields.Day = ( WORD )ClientTOD->tod_day; TimeFields.Month = ( WORD )ClientTOD->tod_month; TimeFields.Year = ( WORD )ClientTOD->tod_year;
if ( !RtlTimeFieldsToTime( &TimeFields, &ClientTime ) ) {
Win32Err = ERROR_INVALID_PARAMETER; }
//
// Add the time it takes to get the time from the dc.
//
UpdatedDcTime = RtlLargeIntegerAdd( DcTime, ElapsedTime );
//
// Compute the difference in time
//
if ( RtlLargeIntegerGreaterThan( UpdatedDcTime, ClientTime ) ) {
TimeSkew = RtlLargeIntegerSubtract( UpdatedDcTime, ClientTime ); } else {
TimeSkew = RtlLargeIntegerSubtract( ClientTime, UpdatedDcTime ); }
//
// Now, see if there is a time difference greater than the allowable skew
//
AllowedSkew = RtlConvertUlongToLargeInteger( NETDOMP_VERIFY_SKEW );
if ( RtlLargeIntegerGreaterThan( TimeSkew, AllowedSkew ) ) {
*InSync = FALSE; }
VerifySingleError:
if ( Connected ) {
NetpManageIPCConnect( Server, ObjectAuthInfo->User, ObjectAuthInfo->Password, NETSETUPP_DISCONNECT_IPC ); }
NetApiBufferFree( ClientTOD ); NetApiBufferFree( DcTOD ); return( Win32Err );}
VOIDNetDompDisplayTimeVerify( IN PWSTR Server, IN DWORD Results, IN BOOL InSync )/*++
Routine Description:
This function will display the results of the time verification
Arguments:
Server - Server which had the time verified
Results - The error code of the verification attempt
InSync - Whether the clocks are within the skew. Only valid if Results is ERROR_SUCCESS
Return Value:
VOID
--*/{ NetDompDisplayMessage( MSG_TIME_COMPUTER, Server ); if ( Results != ERROR_SUCCESS ) {
NetDompDisplayErrorMessage( Results );
} else {
NetDompDisplayMessage( InSync ? MSG_TIME_SUCCESS : MSG_TIME_FAILURE ); }}
DWORDNetDompVerifyTime( IN PWSTR Domain, IN PWSTR Server, OPTIONAL IN PND5_AUTH_INFO DomainAuthInfo, IN PND5_AUTH_INFO ObjectAuthInfo, IN PWSTR Dc, IN BOOL AllWorkstation, IN BOOL AllServer )/*++
Routine Description:
This function will verify the time between some or all of the servers/workstations in a domain against the specified domain controller
Arguments:
Domain - Domain containing the servers/workstations
Server - Name of a specific machine to verify the time for
DomainAuthInfo - User and password for the domain controller
ObjectAuthInfo - User and password for the servers/workstations
Dc - Name of a domain controller in the domain to use as a time source
AllWorkstation - If TRUE, verify the time for all the workstations
AllServer - If TRUE, verify the time for all the servers
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_INVALID_PARAMETER - No server, workstation or machine was specified
--*/{ DWORD Win32Err = ERROR_SUCCESS, Err2; BOOL DcSession = FALSE, InSync; DWORD DcDelay; LPUSER_INFO_0 UserList = NULL; PWSTR FullDc = NULL, Lop; ULONG ResumeHandle = 0, Count = 0, TotalCount = 0, i, j; ULONG Types[] = { FILTER_WORKSTATION_TRUST_ACCOUNT, FILTER_SERVER_TRUST_ACCOUNT }; BOOL ProcessType[ sizeof( Types ) / sizeof( ULONG ) ];
ProcessType[ 0 ] = AllWorkstation; ProcessType[ 1 ] = AllServer;
//
// Make sure that there is something to do
//
if ( !Server && !AllWorkstation && !AllServer ) {
return( ERROR_INVALID_PARAMETER ); }
//
// Build a full machine name
//
if ( Dc && *Dc != L'\\' ) {
Win32Err = NetApiBufferAllocate( ( wcslen( Dc ) + 3 ) * sizeof( WCHAR ), ( PVOID * )&FullDc );
if ( Win32Err == ERROR_SUCCESS ) {
swprintf( FullDc, L"\\\\%ws", Dc ); }
} else {
FullDc = Dc; }
//
// Set up a session
//
Win32Err = NetpManageIPCConnect( FullDc, DomainAuthInfo->User, DomainAuthInfo->Password, NETSETUPP_CONNECT_IPC ); if ( Win32Err == ERROR_SUCCESS ) {
DcSession = FALSE; }
//
// See how long it takes to get to the dc
//
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = NetDompGetTimeTripLength( Dc, &DcDelay ); }
if ( Win32Err != ERROR_SUCCESS ) {
goto VerifyTimeError; }
NetDompDisplayMessage( MSG_TIME_VERIFY );
//
// Verify a single machine
//
if ( Server ) {
Win32Err = NetDompVerifySingleClient( Server, Dc, ObjectAuthInfo, DcDelay, &InSync ); NetDompDisplayTimeVerify( Server, Win32Err, InSync ); }
//
// Verify all the workstations/servers, if requested.
//
for ( i = 0; i < sizeof( Types ) / sizeof( ULONG ); i++ ) {
if ( !ProcessType[ i ] ) {
continue; }
do {
Win32Err = NetUserEnum( FullDc, 0, Types[ i ], ( LPBYTE * )&UserList, MAX_PREFERRED_LENGTH, &Count, &TotalCount, &ResumeHandle );
if ( Win32Err == ERROR_SUCCESS || Win32Err == ERROR_MORE_DATA ) {
for ( j = 0; j < Count; j++ ) {
Lop = wcsrchr( UserList[ j ].usri0_name, L'$' ); if ( Lop ) {
*Lop = UNICODE_NULL; }
Err2 = NetDompVerifySingleClient( UserList[ j ].usri0_name, Dc, ObjectAuthInfo, DcDelay, &InSync ); NetDompDisplayTimeVerify( UserList[ j ].usri0_name, Err2, InSync );
} NetApiBufferFree( UserList ); }
} while ( Win32Err == ERROR_MORE_DATA );
}
VerifyTimeError:
if ( DcSession ) {
NetpManageIPCConnect( FullDc, DomainAuthInfo->User, DomainAuthInfo->Password, NETSETUPP_DISCONNECT_IPC ); }
if ( FullDc != Dc ) {
NetApiBufferFree( FullDc ); }
return( Win32Err );}
DWORDNetDompResetTime( IN PWSTR Domain, IN PWSTR Server, OPTIONAL IN PND5_AUTH_INFO DomainAuthInfo, IN PND5_AUTH_INFO ObjectAuthInfo, IN PWSTR Dc, IN BOOL AllWorkstation, IN BOOL AllServer )/*++
Routine Description:
This function will reset the time between some or all of the servers/workstations in a domain against the specified domain controller
Arguments:
Domain - Domain containing the servers/workstations
Server - Name of a specific machine to reset the time for
DomainAuthInfo - User and password for the domain controller
ObjectAuthInfo - User and password for the servers/workstations
Dc - Name of a domain controller in the domain to use as a time source
AllWorkstation - If TRUE, reset the time for all the workstations
AllServer - If TRUE, reset the time for all the servers
Return Value:
ERROR_SUCCESS - The function succeeded
ERROR_INVALID_PARAMETER - No server, workstation or machine was specified
--*/{ DWORD Win32Err = ERROR_SUCCESS, Err2; BOOL DcSession = FALSE, InSync; DWORD DcDelay; LPUSER_INFO_0 UserList = NULL; PWSTR FullDc = NULL, Lop; ULONG ResumeHandle = 0, Count = 0, TotalCount = 0, i, j; ULONG Types[] = { FILTER_WORKSTATION_TRUST_ACCOUNT, FILTER_SERVER_TRUST_ACCOUNT }; BOOL ProcessType[ sizeof( Types ) / sizeof( ULONG ) ];
ProcessType[ 0 ] = AllWorkstation; ProcessType[ 1 ] = AllServer;
//
// Make sure that there is something to do
//
if ( !Server && !AllWorkstation && !AllServer ) {
return( ERROR_INVALID_PARAMETER ); }
if ( Dc && *Dc != L'\\' ) {
Win32Err = NetApiBufferAllocate( ( wcslen( Dc ) + 3 ) * sizeof( WCHAR ), ( PVOID * )&FullDc );
if ( Win32Err == ERROR_SUCCESS ) {
swprintf( FullDc, L"\\\\%ws", Dc ); }
} else {
FullDc = Dc; }
Win32Err = NetpManageIPCConnect( FullDc, DomainAuthInfo->User, DomainAuthInfo->Password, NETSETUPP_CONNECT_IPC ); if ( Win32Err == ERROR_SUCCESS ) {
DcSession = FALSE; }
//
// Get the trip time to the dc
//
if ( Win32Err == ERROR_SUCCESS ) {
Win32Err = NetDompGetTimeTripLength( Dc, &DcDelay ); }
if ( Win32Err != ERROR_SUCCESS ) {
goto ResetTimeError; }
NetDompDisplayMessage( MSG_TIME_VERIFY );
//
// Reset the client, if needed
//
if ( Server ) {
Win32Err = NetDompVerifySingleClient( Server, Dc, ObjectAuthInfo, DcDelay, &InSync ); if ( Win32Err == ERROR_SUCCESS && !InSync ) {
Win32Err = NetDompResetSingleClient( Server, Dc, ObjectAuthInfo, DcDelay ); } }
//
// Do all the workstations/servers, if required
//
for ( i = 0; i < sizeof( Types ) / sizeof( ULONG ); i++ ) {
if ( !ProcessType[ i ] ) {
continue; }
do {
Win32Err = NetUserEnum( FullDc, 0, Types[ i ], ( LPBYTE * )&UserList, MAX_PREFERRED_LENGTH, &Count, &TotalCount, &ResumeHandle );
if ( Win32Err == ERROR_SUCCESS || Win32Err == ERROR_MORE_DATA ) {
for ( j = 0; j < Count; j++ ) {
Lop = wcsrchr( UserList[ j ].usri0_name, L'$' ); if ( Lop ) {
*Lop = UNICODE_NULL; }
Err2 = NetDompVerifySingleClient( UserList[ j ].usri0_name, Dc, ObjectAuthInfo, DcDelay, &InSync );
if ( Err2 == ERROR_SUCCESS && !InSync ) {
Err2 = NetDompResetSingleClient( UserList[ j ].usri0_name, Dc, ObjectAuthInfo, DcDelay ); } } NetApiBufferFree( UserList ); }
} while ( Win32Err == ERROR_MORE_DATA );
}
ResetTimeError:
if ( DcSession ) {
NetpManageIPCConnect( FullDc, DomainAuthInfo->User, DomainAuthInfo->Password, NETSETUPP_DISCONNECT_IPC ); }
if ( FullDc != Dc ) {
NetApiBufferFree( FullDc ); }
return( Win32Err );}
DWORDNetDompHandleTime(ARG_RECORD * rgNetDomArgs)/*++
Routine Description:
This function will handle the NETDOM TIME requirements
Arguments:
Args - List of command line arguments
Return Value:
ERROR_INVALID_PARAMETER - No object name was supplied
--*/{ DWORD Win32Err = ERROR_SUCCESS; PWSTR Domain = NULL, Dc = NULL; ND5_AUTH_INFO DomainUser, ObjectUser; ULONG i;
PWSTR Object = rgNetDomArgs[eObject].strValue;
if (!Object) { DisplayHelp(ePriTime); return( ERROR_INVALID_PARAMETER ); }
RtlZeroMemory( &DomainUser, sizeof( ND5_AUTH_INFO ) ); RtlZeroMemory( &ObjectUser, sizeof( ND5_AUTH_INFO ) );
//
// Validate the args
//
Win32Err = NetDompValidateSecondaryArguments(rgNetDomArgs, eObject, eCommDomain, eCommUserNameO, eCommPasswordO, eCommUserNameD, eCommPasswordD, eQueryServer, eQueryWksta, eCommVerify, eCommReset, eCommVerbose, eArgEnd); if ( Win32Err != ERROR_SUCCESS ) {
DisplayHelp(ePriTime); goto HandleTimeExit; }
//
// Verify that we don't have too many arguments
//
if ( CmdFlagOn(rgNetDomArgs, eCommVerify) && CmdFlagOn(rgNetDomArgs, eCommReset) ) {
NetDompDisplayUnexpectedParameter(rgNetDomArgs[eCommReset].strArg1);
Win32Err = ERROR_INVALID_PARAMETER; goto HandleTimeExit; }
//
// Ok, make sure that we have a specified domain...
//
Win32Err = NetDompGetDomainForOperation(rgNetDomArgs, Object, TRUE, &Domain);
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleTimeExit; }
//
// Get the password and user if it exists
//
if ( CmdFlagOn(rgNetDomArgs, eCommUserNameD) ) {
Win32Err = NetDompGetUserAndPasswordForOperation(rgNetDomArgs, eCommUserNameD, Domain, &DomainUser);
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleTimeExit; } }
if ( CmdFlagOn(rgNetDomArgs, eCommUserNameO) ) {
Win32Err = NetDompGetUserAndPasswordForOperation(rgNetDomArgs, eCommUserNameO, Object, &ObjectUser );
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleTimeExit; } }
//
// Get the name of a domain controller
//
Win32Err = NetDompTimeGetDc( Domain, Object, &ObjectUser, &Dc );
if ( Win32Err != ERROR_SUCCESS ) {
goto HandleTimeExit; }
//
// Now, see what we are supposed to do
//
if ( CmdFlagOn(rgNetDomArgs, eCommVerify) ) {
Win32Err = NetDompVerifyTime( Domain, Object, &DomainUser, &ObjectUser, Dc, CmdFlagOn(rgNetDomArgs, eQueryWksta), CmdFlagOn(rgNetDomArgs, eQueryServer) );
}
if ( CmdFlagOn(rgNetDomArgs, eCommReset) ) {
Win32Err = NetDompResetTime( Domain, Object, &DomainUser, &ObjectUser, Dc, CmdFlagOn(rgNetDomArgs, eQueryWksta), CmdFlagOn(rgNetDomArgs, eQueryServer) );
}
HandleTimeExit:
NetApiBufferFree( Domain ); NetApiBufferFree( Dc );
NetDompFreeAuthIdent( &DomainUser ); NetDompFreeAuthIdent( &ObjectUser );
if (NO_ERROR != Win32Err) { NetDompDisplayErrorMessage(Win32Err); }
return( Win32Err );}
|
