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.
1729 lines
42 KiB
1729 lines
42 KiB
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Global Definitions //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define DevPrint
|
|
//#define DevPrint DbgPrint
|
|
|
|
#define Error(N,S) { DbgPrint(#N); DbgPrint(" Error %08lx\n", S); }
|
|
|
|
#define Delay(SECONDS) { \
|
|
LARGE_INTEGER Time; \
|
|
Time.QuadPart = -10 * 1000 * 1000, ((LONGLONG)SECONDS); \
|
|
NtDelayExecution(TRUE,(PLARGE_INTEGER)&Time); \
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Global Variables //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
NTSTATUS Status;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
STRING EventName;
|
|
UNICODE_STRING UnicodeEventName;
|
|
HANDLE EventHandle;
|
|
STRING PortName;
|
|
UNICODE_STRING UnicodePortName;
|
|
STRING RelativePortName;
|
|
UNICODE_STRING UnicodeRelativePortName;
|
|
HANDLE EarPort;
|
|
HANDLE TalkPort;
|
|
SECURITY_QUALITY_OF_SERVICE SecurityQos;
|
|
ULONG RequestCount;
|
|
HANDLE ClientToken;
|
|
TOKEN_STATISTICS ClientTokenStatistics;
|
|
ULONG IgnoreLength;
|
|
|
|
HANDLE SepServerThread;
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Test Routine Definitions //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
BOOLEAN
|
|
SepClientTestStatic(VOID);
|
|
|
|
BOOLEAN
|
|
SepClientTestDynamic(VOID);
|
|
|
|
BOOLEAN
|
|
SepClientTestEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
);
|
|
|
|
BOOLEAN
|
|
SepClientTestNotEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
);
|
|
|
|
BOOLEAN
|
|
SepClientTestAnonymous(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
BOOLEAN
|
|
SepClientTestIdentification(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
BOOLEAN
|
|
SepClientTestImpersonation(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
VOID
|
|
SepClientConnect(
|
|
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
|
|
SECURITY_CONTEXT_TRACKING_MODE TrackingMode,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
VOID
|
|
SepClientMakeRemoteCall( VOID );
|
|
|
|
VOID
|
|
SepClientDropConnection( VOID );
|
|
|
|
BOOLEAN
|
|
SepClientTest(VOID);
|
|
|
|
NTSTATUS
|
|
SepClientInitialize(
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestStatic(VOID);
|
|
|
|
BOOLEAN
|
|
SepServerTestDynamic(VOID);
|
|
|
|
BOOLEAN
|
|
SepServerTestEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
);
|
|
|
|
BOOLEAN
|
|
SepServerTestNotEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
);
|
|
|
|
BOOLEAN
|
|
SepServerTestAnonymous(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
BOOLEAN
|
|
SepServerTestIdentification(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
BOOLEAN
|
|
SepServerTestImpersonation(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
);
|
|
|
|
VOID
|
|
SepServerWaitForNextConnect( VOID );
|
|
|
|
VOID
|
|
SepServerGetNextMessage( VOID );
|
|
|
|
VOID
|
|
SepServerCompleteMessage( VOID );
|
|
|
|
VOID
|
|
SepServerDropConnection( VOID );
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTest(VOID);
|
|
|
|
NTSTATUS
|
|
SepServerInitialize(
|
|
);
|
|
|
|
VOID
|
|
SepServerSpawnClientProcess(VOID);
|
|
|
|
|
|
|
|
|
|
VOID
|
|
SepWritePipe( PSZ String );
|
|
|
|
VOID
|
|
SepReadPipe(VOID);
|
|
|
|
VOID
|
|
SepTransceivePipe( PSZ String );
|
|
|
|
|
|
|
|
|
|
HANDLE
|
|
SepServerCreatePipe(VOID);
|
|
|
|
VOID
|
|
SepServerListenPipe(VOID);
|
|
|
|
VOID
|
|
SepServerImpersonatePipe(VOID);
|
|
|
|
VOID
|
|
SepServerDisconnectPipe(VOID);
|
|
|
|
|
|
|
|
|
|
HANDLE
|
|
SepClientOpenPipe( VOID );
|
|
|
|
|
|
|
|
|
|
BOOLEAN
|
|
CtLnpQos (VOID);
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Client-Side Test Routines //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VOID
|
|
SepClientConnect(
|
|
SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
|
|
SECURITY_CONTEXT_TRACKING_MODE TrackingMode,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
|
|
SecurityQos.ImpersonationLevel = ImpersonationLevel;
|
|
SecurityQos.ContextTrackingMode = TrackingMode;
|
|
SecurityQos.EffectiveOnly = EffectiveOnly;
|
|
|
|
DevPrint("\nClient: ");
|
|
TalkPort = SepClientOpenPipe();
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepClientMakeRemoteCall( VOID )
|
|
|
|
{
|
|
|
|
DevPrint("\nClient: ");
|
|
SepTransceivePipe( "Make Client Call\n" );
|
|
|
|
RequestCount += 1;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepClientDropConnection( VOID )
|
|
|
|
{
|
|
|
|
Status = NtClose( TalkPort ); SEASSERT_SUCCESS(Status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestStatic(VOID)
|
|
|
|
{
|
|
|
|
BOOLEAN CompletionStatus;
|
|
|
|
//
|
|
// Static Context Tracking ... Suite
|
|
//
|
|
|
|
CompletionStatus = SepClientTestEffectiveOnly( TRUE );
|
|
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
|
|
CompletionStatus = SepClientTestNotEffectiveOnly( TRUE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestDynamic(VOID)
|
|
|
|
{
|
|
BOOLEAN CompletionStatus;
|
|
|
|
//
|
|
// Dynamic Context Tracking ... Suite
|
|
//
|
|
|
|
CompletionStatus = SepClientTestEffectiveOnly( FALSE );
|
|
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
|
|
CompletionStatus = SepClientTestNotEffectiveOnly( FALSE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
)
|
|
|
|
|
|
{
|
|
|
|
BOOLEAN CompletionStatus;
|
|
|
|
//
|
|
// Effective Only ... Test
|
|
//
|
|
|
|
CompletionStatus = SepClientTestAnonymous( StaticTest, TRUE );
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepClientTestIdentification( StaticTest, TRUE );
|
|
}
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepClientTestImpersonation( StaticTest, TRUE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestNotEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
)
|
|
|
|
{
|
|
BOOLEAN CompletionStatus;
|
|
|
|
//
|
|
// Not Effective Only ... Test
|
|
//
|
|
|
|
CompletionStatus = SepClientTestAnonymous( StaticTest, FALSE );
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepClientTestIdentification( StaticTest, FALSE );
|
|
}
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepClientTestImpersonation( StaticTest, FALSE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestAnonymous(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Anonymous Use Test //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
SECURITY_CONTEXT_TRACKING_MODE TrackingMode;
|
|
|
|
if (StaticTest) {
|
|
TrackingMode = SECURITY_STATIC_TRACKING;
|
|
} else {
|
|
TrackingMode = SECURITY_DYNAMIC_TRACKING;
|
|
}
|
|
|
|
if (!StaticTest) {
|
|
//
|
|
// No action for dynamic test
|
|
//
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Anonymous Use ... Test
|
|
//
|
|
|
|
|
|
SepClientConnect(
|
|
SecurityAnonymous,
|
|
TrackingMode,
|
|
EffectiveOnly
|
|
);
|
|
|
|
SepClientMakeRemoteCall();
|
|
|
|
SepClientDropConnection();
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestIdentification(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Identification Use Test //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
SECURITY_CONTEXT_TRACKING_MODE TrackingMode;
|
|
|
|
if (StaticTest) {
|
|
TrackingMode = SECURITY_STATIC_TRACKING;
|
|
} else {
|
|
TrackingMode = SECURITY_DYNAMIC_TRACKING;
|
|
}
|
|
|
|
//
|
|
// Identification Use ... Test
|
|
//
|
|
|
|
|
|
SepClientConnect(
|
|
SecurityIdentification,
|
|
TrackingMode,
|
|
EffectiveOnly
|
|
);
|
|
|
|
SepClientMakeRemoteCall();
|
|
|
|
SepClientDropConnection();
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTestImpersonation(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Impersonation Use Test //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
SECURITY_CONTEXT_TRACKING_MODE TrackingMode;
|
|
|
|
if (StaticTest) {
|
|
TrackingMode = SECURITY_STATIC_TRACKING;
|
|
} else {
|
|
TrackingMode = SECURITY_DYNAMIC_TRACKING;
|
|
}
|
|
|
|
|
|
//
|
|
// Impersonation Use ... Test
|
|
//
|
|
|
|
|
|
SepClientConnect(
|
|
SecurityImpersonation,
|
|
TrackingMode,
|
|
EffectiveOnly
|
|
);
|
|
|
|
SepClientMakeRemoteCall();
|
|
|
|
SepClientDropConnection();
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOLEAN
|
|
SepClientTest(VOID)
|
|
//
|
|
// Tests:
|
|
//
|
|
// Static Context Tracking Tests
|
|
// Effective Only
|
|
// Anonymous
|
|
// Identification
|
|
// Impersonation
|
|
// Not Effective Only
|
|
// Anonymous
|
|
// Identification
|
|
// Impersonation
|
|
//
|
|
// Dynamic Context Tracking Tests
|
|
// Effective Only
|
|
// Identification
|
|
// Impersonation
|
|
// Not Effective Only
|
|
// Identification
|
|
// Impersonation
|
|
//
|
|
{
|
|
|
|
BOOLEAN CompletionStatus;
|
|
|
|
|
|
|
|
|
|
//
|
|
// Run the static test suite...
|
|
//
|
|
|
|
CompletionStatus = SepClientTestStatic();
|
|
|
|
//
|
|
// Run the dynamic test suite...
|
|
//
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepClientTestDynamic();
|
|
}
|
|
|
|
DbgPrint("Se: Client Test Complete.\n");
|
|
|
|
|
|
return CompletionStatus;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
SepClientInitialize(
|
|
)
|
|
|
|
{
|
|
|
|
|
|
|
|
DbgPrint("Se: Client Initializing ...\n");
|
|
|
|
|
|
RequestCount = 0;
|
|
|
|
|
|
//
|
|
// Signal the named event to start the test
|
|
//
|
|
|
|
DbgPrint("Se: Client Starting Test ...\n");
|
|
Status = NtSetEvent( EventHandle, NULL ); SEASSERT_SUCCESS(Status);
|
|
|
|
Status = NtClose( EventHandle ); SEASSERT_SUCCESS(Status);
|
|
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Server-Side Test Routines //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VOID
|
|
SepServerWaitForNextConnect( VOID )
|
|
{
|
|
|
|
DevPrint("\nServer: ");
|
|
SepServerListenPipe();
|
|
|
|
Status = NtDuplicateObject(
|
|
NtCurrentProcess(), // SourceProcessHandle
|
|
EarPort, // SourceHandle
|
|
NtCurrentProcess(), // TargetProcessHandle
|
|
&TalkPort, // TargetHandle
|
|
0, // DesiredAccess (over-ridden by option)
|
|
0, // HandleAttributes
|
|
DUPLICATE_SAME_ACCESS // Options
|
|
);
|
|
ASSERT(NT_SUCCESS(Status));
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
VOID
|
|
SepServerGetNextMessage( VOID )
|
|
|
|
{
|
|
|
|
|
|
|
|
DevPrint("\nServer: ");
|
|
SepReadPipe();
|
|
|
|
RequestCount += 1;
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
SepServerCompleteMessage( VOID )
|
|
|
|
{
|
|
|
|
DevPrint("\nServer: ");
|
|
SepWritePipe("Return From Server\n");
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
SepServerImpersonateClient( VOID )
|
|
|
|
{
|
|
|
|
DevPrint("\nServer: ");
|
|
SepServerImpersonatePipe( );
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
SepServerRevertToSelf( VOID )
|
|
|
|
{
|
|
NTSTATUS TmpStatus;
|
|
HANDLE NullHandle;
|
|
|
|
NullHandle = NULL;
|
|
TmpStatus = NtSetInformationThread(
|
|
SepServerThread,
|
|
ThreadImpersonationToken,
|
|
(PVOID)&NullHandle,
|
|
(ULONG)sizeof(HANDLE)
|
|
); SEASSERT_SUCCESS(TmpStatus);
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
SepServerDropConnection( VOID )
|
|
|
|
{
|
|
DevPrint("\nServer: ");
|
|
SepServerDisconnectPipe();
|
|
|
|
return;
|
|
}
|
|
|
|
BOOLEAN
|
|
SepServerTestStatic(VOID)
|
|
|
|
{
|
|
BOOLEAN CompletionStatus;
|
|
|
|
DbgPrint("Se: Static Context Tracking ... Suite\n");
|
|
|
|
CompletionStatus = SepServerTestEffectiveOnly( TRUE );
|
|
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
|
|
CompletionStatus = SepServerTestNotEffectiveOnly( TRUE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestDynamic(VOID)
|
|
|
|
{
|
|
BOOLEAN CompletionStatus;
|
|
|
|
DbgPrint("Se: Dynamic Context Tracking ... Suite\n");
|
|
|
|
CompletionStatus = SepServerTestEffectiveOnly( FALSE );
|
|
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
|
|
CompletionStatus = SepServerTestNotEffectiveOnly( FALSE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
)
|
|
|
|
{
|
|
|
|
BOOLEAN CompletionStatus;
|
|
|
|
DbgPrint("Se: Effective Only ... Test\n");
|
|
|
|
CompletionStatus = SepServerTestAnonymous( StaticTest, TRUE );
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepServerTestIdentification( StaticTest, TRUE );
|
|
}
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepServerTestImpersonation( StaticTest, TRUE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestNotEffectiveOnly(
|
|
BOOLEAN StaticTest
|
|
)
|
|
|
|
{
|
|
|
|
BOOLEAN CompletionStatus;
|
|
|
|
DbgPrint("Se: Not Effective Only ... Test\n");
|
|
|
|
CompletionStatus = SepServerTestAnonymous( StaticTest, FALSE );
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepServerTestIdentification( StaticTest, FALSE );
|
|
}
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepServerTestImpersonation( StaticTest, FALSE );
|
|
}
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestAnonymous(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
BOOLEAN CompletionStatus = TRUE;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Anonymous Use Test //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
if (!StaticTest) {
|
|
//
|
|
// No action for dynamic test
|
|
//
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
DbgPrint("Se: Anonymous Use ... ");
|
|
|
|
SepServerWaitForNextConnect();
|
|
|
|
SepServerGetNextMessage();
|
|
|
|
|
|
SepServerImpersonateClient();
|
|
Status = NtOpenThreadToken(
|
|
SepServerThread,
|
|
TOKEN_ALL_ACCESS,
|
|
TRUE,
|
|
&ClientToken
|
|
);
|
|
SepServerRevertToSelf();
|
|
if (Status == STATUS_CANT_OPEN_ANONYMOUS) {
|
|
|
|
DbgPrint(" Succeeded\n");
|
|
|
|
} else {
|
|
DbgPrint("* ! FAILED (srvr) ! *\n");
|
|
DbgPrint("Status is: 0x%lx \n", Status );
|
|
CompletionStatus = FALSE;
|
|
}
|
|
|
|
|
|
SepServerCompleteMessage();
|
|
|
|
SepServerDropConnection();
|
|
|
|
//
|
|
// Appease the compiler Gods..
|
|
//
|
|
|
|
if (EffectiveOnly) {;}
|
|
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestIdentification(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
|
|
BOOLEAN CompletionStatus = TRUE;
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Identification Use Test //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
DbgPrint("Se: Identification Use ... ");
|
|
|
|
SepServerWaitForNextConnect();
|
|
|
|
SepServerGetNextMessage();
|
|
|
|
SepServerImpersonateClient();
|
|
Status = NtOpenThreadToken(
|
|
SepServerThread,
|
|
TOKEN_ALL_ACCESS,
|
|
TRUE,
|
|
&ClientToken
|
|
); SEASSERT_SUCCESS(Status);
|
|
SepServerRevertToSelf();
|
|
Status = NtQueryInformationToken(
|
|
ClientToken,
|
|
TokenStatistics,
|
|
&ClientTokenStatistics,
|
|
(ULONG)sizeof(TOKEN_STATISTICS),
|
|
&IgnoreLength
|
|
); SEASSERT_SUCCESS(Status);
|
|
|
|
if ( (ClientTokenStatistics.TokenType == TokenImpersonation) &&
|
|
(ClientTokenStatistics.ImpersonationLevel == SecurityIdentification)
|
|
) {
|
|
DbgPrint(" Succeeded\n");
|
|
|
|
} else {
|
|
DbgPrint("* ! FAILED (srvr) ! *\n");
|
|
CompletionStatus = FALSE;
|
|
}
|
|
|
|
|
|
SepServerCompleteMessage();
|
|
|
|
SepServerDropConnection();
|
|
|
|
//
|
|
// Appease the compiler Gods..
|
|
//
|
|
if (StaticTest) {;}
|
|
if (EffectiveOnly) {;}
|
|
|
|
return CompletionStatus;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTestImpersonation(
|
|
BOOLEAN StaticTest,
|
|
BOOLEAN EffectiveOnly
|
|
)
|
|
|
|
{
|
|
BOOLEAN CompletionStatus = TRUE;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Impersonation Use Test //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
DbgPrint("Se: Impersonation Use ... ");
|
|
|
|
|
|
SepServerWaitForNextConnect();
|
|
|
|
SepServerGetNextMessage();
|
|
|
|
|
|
|
|
SepServerImpersonateClient();
|
|
Status = NtOpenThreadToken(
|
|
SepServerThread,
|
|
TOKEN_ALL_ACCESS,
|
|
TRUE,
|
|
&ClientToken
|
|
); SEASSERT_SUCCESS(Status);
|
|
SepServerRevertToSelf();
|
|
Status = NtQueryInformationToken(
|
|
ClientToken,
|
|
TokenStatistics,
|
|
&ClientTokenStatistics,
|
|
(ULONG)sizeof(TOKEN_STATISTICS),
|
|
&IgnoreLength
|
|
); SEASSERT_SUCCESS(Status);
|
|
|
|
if ( (ClientTokenStatistics.TokenType == TokenImpersonation) &&
|
|
(ClientTokenStatistics.ImpersonationLevel == SecurityImpersonation)
|
|
) {
|
|
DbgPrint(" Succeeded\n");
|
|
|
|
} else {
|
|
DbgPrint("* ! FAILED (srvr) ! *\n");
|
|
CompletionStatus = FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
SepServerCompleteMessage();
|
|
|
|
SepServerDropConnection();
|
|
|
|
//
|
|
// Appease the compiler gods
|
|
//
|
|
if (StaticTest) {;}
|
|
if (EffectiveOnly) {;}
|
|
|
|
return CompletionStatus;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
SepServerTest(VOID)
|
|
//
|
|
// Tests:
|
|
//
|
|
// Static Context Tracking Tests
|
|
// Effective Only
|
|
// Anonymous
|
|
// Identification
|
|
// Impersonation
|
|
// Not Effective Only
|
|
// Anonymous
|
|
// Identification
|
|
// Impersonation
|
|
//
|
|
// Dynamic Context Tracking Tests
|
|
// Effective Only
|
|
// Identification
|
|
// Impersonation
|
|
// Not Effective Only
|
|
// Identification
|
|
// Impersonation
|
|
//
|
|
{
|
|
|
|
BOOLEAN CompletionStatus;
|
|
|
|
|
|
DbgPrint("Se: Server Starting Test ...\n");
|
|
|
|
//
|
|
// Run the static test suite...
|
|
//
|
|
|
|
CompletionStatus = SepServerTestStatic();
|
|
|
|
//
|
|
// Run the dynamic test suite...
|
|
//
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
CompletionStatus = SepServerTestDynamic();
|
|
}
|
|
|
|
DbgPrint("Se: Server Test Complete.\n");
|
|
|
|
//
|
|
// Print test results
|
|
//
|
|
|
|
DbgPrint("\n");
|
|
DbgPrint("\n");
|
|
DbgPrint("**********************\n");
|
|
DbgPrint("** **\n");
|
|
|
|
if (CompletionStatus == TRUE) {
|
|
DbgPrint("** Test Succeeded **\n");
|
|
} else {
|
|
DbgPrint("** Test Failed !! **\n");
|
|
}
|
|
|
|
DbgPrint("** **\n");
|
|
DbgPrint("**********************\n");
|
|
|
|
return CompletionStatus;
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
SepServerInitialize(
|
|
)
|
|
|
|
{
|
|
|
|
OBJECT_ATTRIBUTES ThreadAttributes;
|
|
PTEB CurrentTeb;
|
|
|
|
|
|
DbgPrint("Se: Server Initializing ...\n");
|
|
|
|
//
|
|
// Initialize global variables
|
|
//
|
|
|
|
RequestCount = 0;
|
|
|
|
//
|
|
// Get a handle to our thread to so that we can access our thread
|
|
// even when impersonating an anonymous client (which we can't do
|
|
// using NtCurrentThread()).
|
|
//
|
|
|
|
CurrentTeb = NtCurrentTeb();
|
|
InitializeObjectAttributes(&ThreadAttributes, NULL, 0, NULL, NULL);
|
|
Status = NtOpenThread(
|
|
&SepServerThread, // TargetHandle
|
|
THREAD_ALL_ACCESS, // DesiredAccess
|
|
&ThreadAttributes, // ObjectAttributes
|
|
&CurrentTeb->ClientId // ClientId
|
|
);
|
|
ASSERT( NT_SUCCESS(Status) );
|
|
|
|
|
|
//
|
|
// Create the server's port
|
|
//
|
|
|
|
EarPort = SepServerCreatePipe();
|
|
|
|
|
|
|
|
//
|
|
// Spawn a copy of ourselves...
|
|
//
|
|
|
|
DbgPrint("Se: Server Spawning client process ...\n");
|
|
SepServerSpawnClientProcess();
|
|
|
|
|
|
DbgPrint("Se: Server waiting for start of test signal ...\n");
|
|
|
|
Status = NtWaitForSingleObject(
|
|
EventHandle,
|
|
TRUE,
|
|
NULL
|
|
); SEASSERT_SUCCESS(Status);
|
|
|
|
Status = NtClose( EventHandle ); SEASSERT_SUCCESS(Status);
|
|
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
VOID
|
|
SepServerSpawnClientProcess(VOID)
|
|
|
|
{
|
|
|
|
RTL_USER_PROCESS_INFORMATION ProcessInformation;
|
|
STRING ProgramName;
|
|
UNICODE_STRING UnicodeProgramName;
|
|
STRING ImagePathName;
|
|
UNICODE_STRING UnicodeImagePathName;
|
|
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
|
|
|
|
RtlInitString( &ProgramName, "\\SystemRoot\\Bin\\utlnpqos.exe" );
|
|
Status = RtlAnsiStringToUnicodeString(
|
|
&UnicodeProgramName,
|
|
&ProgramName,
|
|
TRUE ); SEASSERT_SUCCESS( NT_SUCCESS(Status) );
|
|
RtlInitString( &ImagePathName, "utlnpqos.exe");
|
|
Status = RtlAnsiStringToUnicodeString(
|
|
&UnicodeImagePathName,
|
|
&ImagePathName,
|
|
TRUE ); SEASSERT_SUCCESS( NT_SUCCESS(Status) );
|
|
|
|
|
|
Status = RtlCreateProcessParameters(
|
|
&ProcessParameters,
|
|
&ImagePathName, // FIX, FIX &UnicodeImagePathName, (when converted to unicode)
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
SEASSERT_SUCCESS(Status);
|
|
RtlFreeUnicodeString( &UnicodeImagePathName );
|
|
|
|
|
|
Status = RtlCreateUserProcess(
|
|
&ProgramName, // FIX, FIX &UnicodeProgramName (when converted to unicode)
|
|
ProcessParameters, // ProcessParameters
|
|
NULL, // ProcessSecurityDescriptor
|
|
NULL, // ThreadSecurityDescriptor
|
|
NtCurrentProcess(), // ParentProcess
|
|
FALSE, // InheritHandles
|
|
NULL, // DebugPort
|
|
NULL, // ExceptionPort
|
|
&ProcessInformation // ProcessInformation
|
|
); SEASSERT_SUCCESS(Status);
|
|
RtlFreeUnicodeString( &UnicodeProgramName );
|
|
|
|
Status = NtResumeThread(
|
|
ProcessInformation.Thread,
|
|
NULL
|
|
); SEASSERT_SUCCESS(Status);
|
|
|
|
RtlDestroyProcessParameters( ProcessParameters );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Main Program Entry Routine //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOLEAN
|
|
CtLnpQos (VOID)
|
|
{
|
|
|
|
BOOLEAN Result = TRUE;
|
|
|
|
RtlInitString( &PortName, "\\Device\\NamedPipe\\TestLnpQosServerPort" );
|
|
Status = RtlAnsiStringToUnicodeString(
|
|
&UnicodePortName,
|
|
&PortName,
|
|
TRUE ); SEASSERT_SUCCESS( NT_SUCCESS(Status) );
|
|
|
|
RtlInitString( &RelativePortName, "TestLnpQosServerPort" );
|
|
Status = RtlAnsiStringToUnicodeString(
|
|
&UnicodeRelativePortName,
|
|
&RelativePortName,
|
|
TRUE ); SEASSERT_SUCCESS( NT_SUCCESS(Status) );
|
|
|
|
|
|
//
|
|
// Determine whether we are the client or server side of the test.
|
|
// This is done by creating or opening a named event object. If the
|
|
// event does not yet exist, then we are the client, and must create
|
|
// the server process. Otherwise, we are the server and the client
|
|
// is waiting for us to signal the event.
|
|
//
|
|
|
|
RtlInitString( &EventName, "\\TestLnpQosEvent" );
|
|
Status = RtlAnsiStringToUnicodeString(
|
|
&UnicodeEventName,
|
|
&EventName,
|
|
TRUE ); SEASSERT_SUCCESS( NT_SUCCESS(Status) );
|
|
|
|
InitializeObjectAttributes(
|
|
&ObjectAttributes,
|
|
&UnicodeEventName,
|
|
OBJ_OPENIF,
|
|
NULL,
|
|
NULL
|
|
);
|
|
Status = NtCreateEvent(
|
|
&EventHandle,
|
|
EVENT_ALL_ACCESS,
|
|
&ObjectAttributes,
|
|
SynchronizationEvent,
|
|
FALSE
|
|
);
|
|
RtlFreeUnicodeString( &UnicodeEventName );
|
|
|
|
if (Status == STATUS_OBJECT_NAME_EXISTS) {
|
|
|
|
//
|
|
// Server is already running, therefore, this process gets to be
|
|
// the client.
|
|
//
|
|
|
|
Status = SepClientInitialize(); SEASSERT_SUCCESS(Status);
|
|
Result = SepClientTest();
|
|
|
|
} else {
|
|
|
|
SEASSERT_SUCCESS(Status);
|
|
|
|
//
|
|
// Event wasn't yet there, so we must be the server.
|
|
//
|
|
|
|
DbgPrint("Se: Starting Local Named Pipe Impersonation Test.\n");
|
|
|
|
Status = SepServerInitialize(); SEASSERT_SUCCESS(Status);
|
|
Result = SepServerTest();
|
|
|
|
DbgPrint("Se: End Test.\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
Status = NtTerminateThread( NtCurrentThread(), STATUS_SUCCESS);
|
|
SEASSERT_SUCCESS(Status);
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Named Pipe Common Operations //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
VOID
|
|
SepReadPipe(
|
|
)
|
|
{
|
|
IO_STATUS_BLOCK Iosb;
|
|
UCHAR Buffer[512];
|
|
|
|
DevPrint("ReadPipe...\n", 0);
|
|
|
|
if (!NT_SUCCESS(Status = NtReadFile( TalkPort,
|
|
(HANDLE)NULL,
|
|
(PIO_APC_ROUTINE)NULL,
|
|
(PVOID)NULL,
|
|
&Iosb,
|
|
Buffer,
|
|
512,
|
|
(PLARGE_INTEGER)NULL,
|
|
(PULONG) NULL ))) {
|
|
Error( NtReadFile, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( TalkPort, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( NtReadFileFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepWritePipe(
|
|
PSZ String
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
|
|
|
|
DevPrint("WritePipe...\n", 0);
|
|
|
|
if (!NT_SUCCESS(Status = NtWriteFile( TalkPort,
|
|
(HANDLE)NULL,
|
|
(PIO_APC_ROUTINE)NULL,
|
|
(PVOID)NULL,
|
|
&Iosb,
|
|
String,
|
|
strlen( String ),
|
|
(PLARGE_INTEGER)NULL,
|
|
(PULONG)NULL ))) {
|
|
Error( NtWriteFile, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( TalkPort, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( NtWriteFileFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepTransceivePipe(
|
|
PSZ String
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
UCHAR Buffer[512];
|
|
|
|
|
|
DevPrint("TransceivePipe...\n", 0);
|
|
|
|
if (!NT_SUCCESS(Status = NtFsControlFile(
|
|
TalkPort,
|
|
NULL, // Event
|
|
NULL, // ApcRoutine
|
|
NULL, // ApcContext
|
|
&Iosb,
|
|
FSCTL_PIPE_TRANSCEIVE,
|
|
String,
|
|
strlen( String ),
|
|
Buffer,
|
|
511
|
|
))) {
|
|
Error( NtTransceiveFile, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( TalkPort, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( NtTransceiveFileFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Named Pipe Server Operations //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
HANDLE
|
|
SepServerCreatePipe(
|
|
VOID
|
|
)
|
|
{
|
|
HANDLE PipeHandle;
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
LARGE_INTEGER Timeout;
|
|
READ_MODE Mode;
|
|
ULONG Share;
|
|
NAMED_PIPE_CONFIGURATION Config = FILE_PIPE_FULL_DUPLEX;
|
|
NAMED_PIPE_TYPE PipeType = FILE_PIPE_MESSAGE_TYPE;
|
|
COMPLETION_MODE CompletionMode = FILE_PIPE_QUEUE_OPERATION;
|
|
ULONG MaximumInstances = 4;
|
|
|
|
|
|
//
|
|
// Set the default timeout to 60 seconds, and initalize the attributes
|
|
//
|
|
|
|
Timeout.QuadPart = -10 * 1000 * 1000 * 60;
|
|
|
|
InitializeObjectAttributes(
|
|
&ObjectAttributes,
|
|
&UnicodePortName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
//
|
|
// Calculate the readmode and share access
|
|
//
|
|
|
|
Mode = (PipeType == FILE_PIPE_MESSAGE_TYPE ? FILE_PIPE_MESSAGE_MODE :
|
|
FILE_PIPE_BYTE_STREAM_MODE);
|
|
|
|
Share = (Config == FILE_PIPE_INBOUND ? FILE_SHARE_WRITE :
|
|
(Config == FILE_PIPE_OUTBOUND ? FILE_SHARE_READ :
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE));
|
|
|
|
if (!NT_SUCCESS(Status = NtCreateNamedPipeFile(
|
|
&PipeHandle,
|
|
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&Iosb,
|
|
Share,
|
|
FILE_CREATE,
|
|
0,
|
|
PipeType,
|
|
Mode,
|
|
CompletionMode,
|
|
MaximumInstances,
|
|
1024,
|
|
1024,
|
|
(PLARGE_INTEGER)&Timeout ))) {
|
|
|
|
Error( CreatePipe, Status );
|
|
}
|
|
RtlFreeUnicodeString( &UnicodePortName );
|
|
|
|
return PipeHandle;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepServerListenPipe(
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
|
|
DevPrint("ListenPipe...\n", 0);
|
|
|
|
if (!NT_SUCCESS(Status = NtFsControlFile(
|
|
EarPort,
|
|
NULL, // Event
|
|
NULL, // ApcRoutine
|
|
NULL, // ApcContext
|
|
&Iosb,
|
|
FSCTL_PIPE_LISTEN,
|
|
NULL, // InputBuffer
|
|
0, // InputBufferLength,
|
|
NULL, // OutputBuffer
|
|
0 // OutputBufferLength
|
|
))) {
|
|
|
|
Error( ListenPipe, Status );
|
|
}
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( EarPort, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( ListenPipeFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepServerImpersonatePipe(
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
|
|
DevPrint("ImpersonatePipe...\n", 0);
|
|
|
|
if (!NT_SUCCESS(Status = NtFsControlFile(
|
|
TalkPort,
|
|
NULL, // Event
|
|
NULL, // ApcRoutine
|
|
NULL, // ApcContext
|
|
&Iosb,
|
|
FSCTL_PIPE_IMPERSONATE,
|
|
NULL, // InputBuffer
|
|
0, // InputBufferLength,
|
|
NULL, // OutputBuffer
|
|
0 // OutputBufferLength
|
|
))) {
|
|
|
|
Error( ImpersonatePipe, Status );
|
|
}
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( TalkPort, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( ImpersonatePipeFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
SepServerDisconnectPipe(
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
|
|
DevPrint("DisconnectPipe...\n", 0);
|
|
DevPrint(" (Flush)...\n", 0);
|
|
|
|
if (!NT_SUCCESS(Status = NtFlushBuffersFile(
|
|
TalkPort,
|
|
&Iosb
|
|
))) {
|
|
Error( DisconnectPipe, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( FlushPipeFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
|
|
DevPrint(" (Close Talk Port)...\n", 0);
|
|
Status = NtClose( TalkPort ); SEASSERT_SUCCESS(Status);
|
|
|
|
DevPrint(" (Disconnect)...\n", 0);
|
|
if (!NT_SUCCESS(Status = NtFsControlFile(
|
|
EarPort,
|
|
NULL, // Event
|
|
NULL, // ApcRoutine
|
|
NULL, // ApcContext
|
|
&Iosb,
|
|
FSCTL_PIPE_DISCONNECT,
|
|
NULL, // InputBuffer
|
|
0, // InputBufferLength,
|
|
NULL, // OutputBuffer
|
|
0 // OutputBufferLength
|
|
))) {
|
|
|
|
Error( DisconnectPipe, Status );
|
|
}
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( EarPort, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( DisconnectPipeFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Named Pipe Client Operations //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
HANDLE
|
|
SepClientOpenPipe(
|
|
VOID
|
|
)
|
|
{
|
|
HANDLE PipeHandle, NpfsHandle;
|
|
NTSTATUS Status;
|
|
IO_STATUS_BLOCK Iosb;
|
|
ULONG Share;
|
|
STRING Npfs;
|
|
UNICODE_STRING UnicodeNpfs;
|
|
PFILE_PIPE_WAIT_FOR_BUFFER WaitPipe;
|
|
ULONG WaitPipeLength;
|
|
NAMED_PIPE_CONFIGURATION Config = FILE_PIPE_FULL_DUPLEX;
|
|
READ_MODE ReadMode = FILE_PIPE_MESSAGE_MODE;
|
|
COMPLETION_MODE CompletionMode = FILE_PIPE_QUEUE_OPERATION;
|
|
|
|
|
|
//#ifdef NOT_YET_WORKING
|
|
//
|
|
// Wait for the server's pipe to reach a listen state...
|
|
//
|
|
|
|
RtlInitString( &Npfs, "\\Device\\NamedPipe\\");
|
|
Status = RtlAnsiStringToUnicodeString(
|
|
&UnicodeNpfs,
|
|
&Npfs,
|
|
TRUE ); SEASSERT_SUCCESS( NT_SUCCESS(Status) );
|
|
|
|
InitializeObjectAttributes(
|
|
&ObjectAttributes,
|
|
&UnicodeNpfs,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(Status = NtOpenFile(
|
|
&NpfsHandle,
|
|
GENERIC_READ | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&Iosb,
|
|
FILE_SHARE_READ,
|
|
0 ))) {
|
|
|
|
Error( OpenNpfs, Status );
|
|
}
|
|
RtlFreeUnicodeString( &UnicodeNpfs );
|
|
|
|
WaitPipeLength =
|
|
FIELD_OFFSET(FILE_PIPE_WAIT_FOR_BUFFER, Name[0]) +
|
|
RelativePortName.MaximumLength; //UNICODEFIX UnicodeRelativePortName.MaximumLength;
|
|
WaitPipe = RtlAllocateHeap(RtlProcessHeap(), 0, WaitPipeLength);
|
|
WaitPipe->TimeoutSpecified = FALSE;
|
|
|
|
WaitPipe->NameLength = RelativePortName.Length; //UNICODEFIX UnicodeRelativePortName.Length;
|
|
strcpy(WaitPipe->Name, RelativePortName.Buffer); //UNICODEFIX UnicodePortName.Buffer;
|
|
|
|
if (!NT_SUCCESS(Status = NtFsControlFile(
|
|
NpfsHandle,
|
|
NULL, // Event
|
|
NULL, // ApcRoutine
|
|
NULL, // ApcContext
|
|
&Iosb,
|
|
FSCTL_PIPE_WAIT,
|
|
WaitPipe, // Buffer for data to the FS
|
|
WaitPipeLength,
|
|
NULL, // OutputBuffer
|
|
0 // OutputBufferLength
|
|
))) {
|
|
|
|
Error( ClientWaitPipe, Status );
|
|
}
|
|
if (Status == STATUS_PENDING) {
|
|
if (!NT_SUCCESS(Status = NtWaitForSingleObject( NpfsHandle, TRUE, NULL ))) {
|
|
|
|
Error( NtWaitForSingleObject, Status );
|
|
}
|
|
}
|
|
|
|
if (!NT_SUCCESS(Iosb.Status)) {
|
|
|
|
Error( ClientWaitPipeFinalStatus, Iosb.Status );
|
|
}
|
|
|
|
Status = NtClose( NpfsHandle );
|
|
ASSERT(NT_SUCCESS(Status));
|
|
//#endif // NOT_YET_WORKING
|
|
// Delay(1);
|
|
|
|
|
|
//
|
|
// Initialize the attributes
|
|
//
|
|
|
|
InitializeObjectAttributes(
|
|
&ObjectAttributes,
|
|
&UnicodePortName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL
|
|
);
|
|
ObjectAttributes.SecurityQualityOfService = (PVOID)(&SecurityQos);
|
|
|
|
//
|
|
// Calculate the share access
|
|
//
|
|
|
|
Share = (Config == FILE_PIPE_INBOUND ? FILE_SHARE_WRITE :
|
|
(Config == FILE_PIPE_OUTBOUND ? FILE_SHARE_READ :
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE));
|
|
|
|
|
|
|
|
//
|
|
// And now open it...
|
|
//
|
|
|
|
if (!NT_SUCCESS(Status = NtOpenFile(
|
|
&PipeHandle,
|
|
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&Iosb,
|
|
Share,
|
|
0 ))) {
|
|
|
|
Error( OpenPipe, Status );
|
|
}
|
|
|
|
if ((ReadMode != FILE_PIPE_BYTE_STREAM_MODE) ||
|
|
(CompletionMode != FILE_PIPE_QUEUE_OPERATION)) {
|
|
|
|
FILE_PIPE_INFORMATION Buffer;
|
|
|
|
Buffer.ReadMode = ReadMode;
|
|
Buffer.CompletionMode = CompletionMode;
|
|
|
|
if (!NT_SUCCESS(Status = NtSetInformationFile(
|
|
PipeHandle,
|
|
&Iosb,
|
|
&Buffer,
|
|
sizeof(FILE_PIPE_INFORMATION),
|
|
FilePipeInformation ))) {
|
|
|
|
Error( NtSetInformationFile, Status );
|
|
}
|
|
}
|
|
|
|
return PipeHandle;
|
|
}
|