mirror of https://github.com/lianthony/NT4.0
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.
411 lines
11 KiB
411 lines
11 KiB
/* --------------------------------------------------------------------
|
|
|
|
Microsoft OS/2 LAN Manager
|
|
Copyright(c) Microsoft Corp., 1990
|
|
|
|
RPC locator - Written by Steven Zeck
|
|
|
|
|
|
This file contains a client side worker functions for
|
|
the locator BVTs.
|
|
-------------------------------------------------------------------- */
|
|
|
|
#include "test.hxx"
|
|
#include "malloc.h"
|
|
|
|
RPC_SERVER_INTERFACE SInterface1 = {
|
|
sizeof(RPC_SERVER_INTERFACE),
|
|
{{0x11111111,0x2222,0x3333,{0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0x00}},
|
|
{1,1}},
|
|
{{0x00000000,0x1111,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff}},
|
|
{1,0}}
|
|
};
|
|
|
|
RPC_SERVER_INTERFACE SInterface2 = {
|
|
sizeof(RPC_SERVER_INTERFACE),
|
|
{{0x22222222,0x2222,0x3333,{0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0x00}},
|
|
{1,0}},
|
|
{{0x00000000,0x1111,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff}},
|
|
{1,0}}
|
|
};
|
|
|
|
UUID Object1 = {
|
|
0x00aaaaaa,0x2222,0x3333,{0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0x00}
|
|
};
|
|
|
|
UUID Object2= {
|
|
0xffffffff,0x2222,0x3333,{0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0x00}
|
|
};
|
|
|
|
UUID Object3= {
|
|
0x77777777,0x2222,0x3333,{0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0x00}
|
|
};
|
|
|
|
|
|
unsigned char EntryName1[] = "/.:/test1";
|
|
unsigned char EntryName2[] = "/.:/test2";
|
|
|
|
unsigned char GroupName1[] = "/.:/Group1";
|
|
unsigned char GroupName2[] = "/.:/Group.2";
|
|
|
|
|
|
RPC_BINDING_VECTOR *BindingVectorIn, *BindingVectorOut;
|
|
RPC_BINDING_HANDLE BindingHandle1, BindingHandle2, BindingHandle3;
|
|
UUID_VECTOR *ObjectVector;
|
|
unsigned char *StringBinding1, *StringBinding2, *StringBinding3;
|
|
|
|
RPC_STATUS Status;
|
|
|
|
void CreateBindingHandles(
|
|
|
|
//
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
BindingHandle1 = MakeBindingHandle( "ncacn_np", "\\pipe\\one",
|
|
&StringBinding1);
|
|
|
|
BindingHandle2 = MakeBindingHandle( "ncacn_np", "\\pipe\\two",
|
|
&StringBinding2);
|
|
|
|
BindingHandle3 = MakeBindingHandle( "ncacn_np", "\\pipe\\three",
|
|
&StringBinding3);
|
|
|
|
BindingVectorIn = (RPC_BINDING_VECTOR *) malloc(
|
|
sizeof(RPC_BINDING_VECTOR) +
|
|
(BindingVectorMax-1) * sizeof(RPC_BINDING_HANDLE));
|
|
|
|
BindingVectorIn->BindingH[0] = BindingHandle1;
|
|
BindingVectorIn->BindingH[1] = BindingHandle2;
|
|
BindingVectorIn->BindingH[2] = BindingHandle3;
|
|
|
|
|
|
ObjectVector = (UUID_VECTOR *) malloc(
|
|
sizeof(UUID_VECTOR) +
|
|
(BindingVectorMax-1) * sizeof(UUID *));
|
|
|
|
ObjectVector->Uuid[0] = &Object1;
|
|
ObjectVector->Uuid[1] = &Object2;
|
|
}
|
|
|
|
|
|
RPC_BINDING_HANDLE MakeBindingHandle ( // Make a binding handle from a string
|
|
SZ ProtocolName, // Protocol name
|
|
SZ Endpoint, // and endpoint to create
|
|
unsigned char **StringOut // place to put stringbinding
|
|
|
|
//
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
RPC_BINDING_HANDLE Handle;
|
|
|
|
Status = RpcStringBindingCompose(0, (unsigned char *) ProtocolName,
|
|
0, (unsigned char *) Endpoint, 0,
|
|
StringOut);
|
|
|
|
if (Status) {
|
|
printf("RpcStringBindingCompose -> %x\n", Status);
|
|
exit(1);
|
|
}
|
|
|
|
Status = RpcBindingFromStringBinding(*StringOut, &Handle);
|
|
|
|
if (Status) {
|
|
printf("RpcBindingFromStringBinding -> %x\n", Status);
|
|
exit(1);
|
|
}
|
|
|
|
return(Handle);
|
|
}
|
|
|
|
|
|
int CompareBinding( // see if two bindings are equal
|
|
|
|
RPC_BINDING_HANDLE Handle, // binding handle
|
|
unsigned char * String, // and string to compare
|
|
int fMustSucceed // exit if not equal
|
|
|
|
//
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
unsigned char *StringBinding;
|
|
int fReturn;
|
|
|
|
if (Status = RpcBindingToStringBinding(Handle, &StringBinding)) {
|
|
|
|
printf("RpcBindingToStringBinding -> %x\n", Status);
|
|
exit(1);
|
|
}
|
|
|
|
fReturn = (strcmp((CONST_CHAR *)StringBinding, (CONST_CHAR *)String) == 0);
|
|
|
|
if (!fReturn && fMustSucceed) {
|
|
|
|
printf("String binding didn't compare\n");
|
|
printf("Binding1: %s\n", StringBinding);
|
|
printf("Found: %s\n", String);
|
|
exit(1);
|
|
}
|
|
|
|
if (Status = RpcStringFree(&StringBinding)) {
|
|
printf ("RpcStringFree -> %x\n", Status);
|
|
exit(1);
|
|
}
|
|
|
|
return(fReturn);
|
|
}
|
|
|
|
void MatchBinding( // Search for a binding in a vector
|
|
|
|
RPC_BINDING_HANDLE Handle, // binding handle
|
|
RPC_BINDING_VECTOR *Vector, // vector handles to match agains
|
|
int *MatchArray // place to mark results
|
|
|
|
//
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
unsigned char *StringBinding;
|
|
|
|
if (Status = RpcBindingToStringBinding(Handle, &StringBinding)) {
|
|
|
|
printf("RpcBindingToStringBinding -> %x\n", Status);
|
|
exit(1);
|
|
}
|
|
|
|
for (unsigned int Index = 0; Index < Vector->Count; Index++) {
|
|
if (CompareBinding(Vector->BindingH[Index], StringBinding, 0))
|
|
MatchArray[Index]++;
|
|
}
|
|
|
|
if (Status = RpcStringFree(&StringBinding)) {
|
|
printf ("RpcStringFree -> %x\n", Status);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
|
|
int ClientImport(
|
|
|
|
unsigned char *EntryName,
|
|
RPC_SERVER_INTERFACE * SInterface,
|
|
UUID *Object,
|
|
unsigned char *StringBinding,
|
|
int ExpectedStatus
|
|
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
RPC_NS_HANDLE ImportContext;
|
|
RPC_BINDING_HANDLE RpcBinding;
|
|
UUID RpcObject;
|
|
|
|
ImportContext = (RPC_NS_HANDLE) -1;
|
|
|
|
Status = RpcNsBindingImportBegin(RPC_C_NS_SYNTAX_DEFAULT,
|
|
EntryName, (RPC_IF_HANDLE) SInterface, Object, &ImportContext);
|
|
|
|
if (ExpectedStatus == IMPORT_FAIL_BEGIN) {
|
|
|
|
if (Status != RPC_S_ENTRY_NOT_FOUND && Status != RPC_S_INTERFACE_NOT_FOUND) {
|
|
printf("RpcNsBindingImportBegin didn't return <not found> -> %x\n",
|
|
Status);
|
|
return (2);
|
|
}
|
|
|
|
if (Status = RpcNsBindingImportDone(&ImportContext)) {
|
|
|
|
printf("RpcNsBindingImportDone -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
if (Status) {
|
|
printf("RpcNsBindingImportBegin -> %x\n", Status);
|
|
return(3);
|
|
}
|
|
|
|
Status = RpcNsBindingImportNext(ImportContext, &RpcBinding);
|
|
|
|
if (ExpectedStatus == IMPORT_FAIL_NEXT) {
|
|
|
|
if (Status != RPC_S_NO_MORE_BINDINGS) {
|
|
printf("RpcNsBindingImportNext didn't return <not found> -> %x\n",
|
|
Status);
|
|
return (2);
|
|
}
|
|
|
|
if (Status = RpcNsBindingImportDone(&ImportContext)) {
|
|
|
|
printf("RpcNsBindingImportDone -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
if (Status) {
|
|
|
|
printf("RpcNsBindingImportNext -> %x\n", Status);
|
|
return(3);
|
|
}
|
|
|
|
if (Object) {
|
|
|
|
if (Status = RpcBindingInqObject(RpcBinding, &RpcObject)) {
|
|
|
|
printf("RpcBindingInqObject -> %x\n", Status);
|
|
return(3);
|
|
}
|
|
|
|
if (memcmp(&RpcObject, Object, sizeof(UUID)) != 0) {
|
|
printf("Objects don't match\n");
|
|
return(3);
|
|
}
|
|
|
|
// Remove the object so we can check to string binding.
|
|
|
|
memset(&RpcObject, 0, sizeof(UUID));
|
|
|
|
if (Status = RpcBindingSetObject(RpcBinding, &RpcObject)) {
|
|
|
|
printf("RpcBindingSetObject -> %x\n", Status);
|
|
return(3);
|
|
}
|
|
|
|
}
|
|
|
|
CompareBinding(RpcBinding, StringBinding, 1);
|
|
|
|
if (Status = RpcNsBindingImportDone(&ImportContext)) {
|
|
|
|
printf("RpcNsBindingImportDone -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
int ClientLookup(
|
|
|
|
RPC_SERVER_INTERFACE * SInterface,
|
|
unsigned char *StringBinding,
|
|
int fLocal
|
|
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
RPC_NS_HANDLE LookupContext;
|
|
|
|
// Start the lookup on a inteface.
|
|
|
|
if (Status = RpcNsBindingLookupBegin(RPC_C_NS_SYNTAX_DEFAULT, EntryName1,
|
|
(RPC_IF_HANDLE) SInterface, 0, BindingVectorMax, &LookupContext)) {
|
|
|
|
printf("RpcNsBindingLookupBegin -> %x\n", Status);
|
|
return (2);
|
|
}
|
|
|
|
if (Status = RpcNsBindingLookupNext(LookupContext, &BindingVectorOut)) {
|
|
|
|
printf("RpcNsBindingLookupNext -> %x\n", Status);
|
|
return(3);
|
|
}
|
|
|
|
if (BindingVectorOut->Count != 1) {
|
|
printf("binding vector count != 1 : %d\n", BindingVectorOut->Count);
|
|
return(4);
|
|
}
|
|
|
|
// Verify if that we got the right binding back.
|
|
|
|
CompareBinding(BindingVectorOut->BindingH[0], StringBinding, 1);
|
|
|
|
if (Status = RpcNsBindingLookupDone(&LookupContext)) {
|
|
|
|
printf("RpcNsBindingLookupDone -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
if (Status = RpcBindingVectorFree(&BindingVectorOut)) {
|
|
|
|
printf("RpcVectorFree -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
int MatchMultiple(
|
|
|
|
RPC_SERVER_INTERFACE * SInterface,
|
|
RPC_BINDING_VECTOR *VectorExpected
|
|
|
|
) //-----------------------------------------------------------------------//
|
|
{
|
|
RPC_NS_HANDLE LookupContext;
|
|
RPC_BINDING_HANDLE RpcBinding;
|
|
int MatchVector[BindingVectorMax];
|
|
unsigned int Index;
|
|
|
|
if (Status = RpcNsBindingLookupBegin(RPC_C_NS_SYNTAX_DEFAULT, 0, (RPC_IF_HANDLE) SInterface,
|
|
0, BindingVectorMax, &LookupContext)) {
|
|
|
|
printf("RpcNsBindingLookupBegin -> %x\n", Status);
|
|
return (2);
|
|
}
|
|
|
|
if (Status = RpcNsBindingLookupNext(LookupContext, &BindingVectorOut)) {
|
|
|
|
printf("RpcNsBindingLookupNext -> %x\n", Status);
|
|
return(3);
|
|
}
|
|
|
|
if (BindingVectorOut->Count != VectorExpected->Count) {
|
|
printf("binding vector count != 1 : %d\n", BindingVectorOut->Count);
|
|
return(4);
|
|
}
|
|
|
|
if (Status = RpcNsBindingLookupDone(&LookupContext)) {
|
|
|
|
printf("RpcNsBindingLookupDone -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
// verify the all the returned bindings are in the original exported.
|
|
|
|
memset(MatchVector, 0, sizeof(MatchVector));
|
|
|
|
for (Index = 0; Index < BindingVectorOut->Count; Index++)
|
|
MatchBinding(BindingVectorOut->BindingH[Index], VectorExpected,
|
|
MatchVector);
|
|
|
|
for (Index = 0; Index < VectorExpected->Count; Index++)
|
|
if (MatchVector[Index] != 1) {
|
|
printf("Multiple vector match error on index: %d\n", Index);
|
|
exit(4);
|
|
}
|
|
|
|
// New use the same binding vector with select.
|
|
|
|
memset(MatchVector, 0, sizeof(MatchVector));
|
|
|
|
for (Index = 0; Index < BindingVectorOut->Count; Index++) {
|
|
|
|
if (Status = RpcNsBindingSelect(BindingVectorOut, &RpcBinding)) {
|
|
|
|
printf("RpcNsBindingSelect -> %x\n", Status);
|
|
return (7);
|
|
}
|
|
|
|
MatchBinding(RpcBinding, VectorExpected, MatchVector);
|
|
}
|
|
|
|
for (Index = 0; Index < VectorExpected->Count; Index++)
|
|
if (MatchVector[Index] != 1) {
|
|
printf("Multiple vector match error on index: %d\n", Index);
|
|
exit(4);
|
|
}
|
|
|
|
return(0);
|
|
}
|