windows-server-2003/com/rpc/runtime/mtrt/usvr.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1990 - 1999
//
//  File:       usvr.cxx
//
//--------------------------------------------------------------------------

/* --------------------------------------------------------------------

                      Microsoft OS/2 LAN Manager
                   Copyright(c) Microsoft Corp., 1990

-------------------------------------------------------------------- */
/* --------------------------------------------------------------------

File : usvr.cxx

Description :

Server test program for the RPC runtime.  This program functions as half
of the build verification test for the RPC runtime.  The other half is
the client test program.

This particular program is independent of the particular operating
system other than requiring threads support of some sort (including
mutexes).

RPC server runtime APIs:

RpcCreateServer
RpcDeleteServer
RpcAddAddress
RpcRemoveAddress
RpcAddInterface
RpcRemoveInterface
RpcMonitorAssociation
RpcQueryConfig
RpcGetCurrentCallHandle
RpcGetAssociationContext
RpcQueryCall
RpcQueryBinding
RpcQueryProtocolStack
I_RpcGetBuffer
I_RpcFreeBuffer
I_RpcSendReceive


-------------------------------------------------------------------- */
#include <precomp.hxx>
#include "pipe.h"
#include "astub.h"
#define _PNP_POWER_
#include <winsock2.h>
#include <Charconv.hxx>
#include <direct.h>

extern "C"
{
#include <iphlpapi.h>
}

/*
Transports:

    Update this to add a new transport.
*/

#define RPC_TRANSPORT_NAMEPIPE 1
#define RPC_LRPC 2
#define RPC_TRANSPORT_TCP 3
#define RPC_TRANSPORT_DNET 4
#define RPC_TRANSPORT_NETBIOS 5
#define RPC_TRANSPORT_SPX 6
#define RPC_TRANSPORT_UDP 7
#define RPC_TRANSPORT_IPX 8
#define RPC_TRANSPORT_DSP 9
#define RPC_TRANSPORT_VNS 10
#define RPC_WMSG          11
#define RPC_TRANSPORT_MSMQ 12

#define MAXLISTENTHREADS 12345
#define MAX_CALL_REQUESTS 500

#define EXTENDED_ERROR_EXCEPTION 77777

#define SIZEOUT_ASYNC_EXCEPTION (0xfffffff)

typedef DWORD
(RPCRTAPI RPC_ENTRY *SET_TEST_HOOK_FN)(
                    RPC_TEST_HOOK_ID id,
                    RPC_TEST_HOOK_FN fn
                    );

//
// Global variables.
//
BOOL fExtendedError        = FALSE;

unsigned int MinimumListenThreads  = 1;
unsigned int UseEndpointMapperFlag = 0;
unsigned int NoSecurityTests       = 0;
unsigned int DatagramFlag          = 0;
unsigned int AutoListenFlag        = 0;
unsigned int IFSecurity        = 0;
int Verbose = 0;

unsigned int WarnFlag = 0; // Flag for warning messages;
unsigned int ErrorFlag = 0; // Flag for error messages;
unsigned int TransportType;
int MaxRpcSize = 1000000;
unsigned long ulSecurityPackage = 10 ;
int FireWallFlag = 0;

char NetBiosProtocol[20] = "ncacn_nb_nb";  // NetBios transport protocol
char *TransportOption = "-namepipe";

int ServerType ;
#define SYNC_WMSG 1
#define ASYNC_WMSG 2
HWND hWnd ;
char szAppName[] = "usvr";
THREAD_IDENTIFIER CurrentTid ;

extern RPC_SERVER_INTERFACE IsabelleInterfaceInformation;


RPC_STATUS Status; // Contains the status of the last RPC API call.
I_RPC_MUTEX PrintMutex = 0; // Mutex used to serialize print operations.

#define CHUNK_SIZE   50
#define NUM_CHUNKS 100
#define BUFF_SIZE 100

typedef int pipe_element_t ;

typedef struct {
    void (*Pull) (
            PIPE_STATE *state,
            pipe_element_t *buffer,
            int max_buf,
            int *actual_transfer_count
            ) ;

    void (*Push) (
        PIPE_STATE *state,
        pipe_element_t *buffer,
        int max_buf
        ) ;

    PIPE_STATE *state ;
    } pipe_t ;

int ShutdownCalled ;
unsigned int IsabelleErrors = 0;
unsigned int HelgaErrors = 0;
unsigned int SylviaErrors = 0;

SET_TEST_HOOK_FN SetTestHookFn;

//
// forward declarations
//


extern void
Async (
    ) ;


extern void
SendAck (
    ) ;


void
DgTransport (
    );

void
SecurityErrorWrapper(
    int subtest
    );

DWORD
GenericServerListen(
    char * name,
    int endpoint
    );

DWORD
GenericServerUnlisten(
    char * name
    );

//
// function definitions
//

void
ApiError ( // An API error occured; we just print a message.
    IN char * Routine, // The routine which called the API.
    IN char * API,
    IN RPC_STATUS status
    )
{
    if (ErrorFlag)
        {
        I_RpcRequestMutex(&PrintMutex);
        PrintToConsole("    ApiError in %s (%s = %u)\n",Routine,API,status);
        I_RpcClearMutex(PrintMutex);
        }
}

void
PauseExecution (
    unsigned long milliseconds
    )
{

    Sleep(milliseconds);

}

void
CompleteReceive(
    PRPC_MESSAGE Callee
    )
{
    DWORD size = 0;

    Callee->RpcFlags |=  RPC_BUFFER_EXTRA;
    Callee->RpcFlags &= ~RPC_BUFFER_PARTIAL;

    if ((Callee->RpcFlags & RPC_BUFFER_COMPLETE) == 0)
        {
        Status =  I_RpcReceive(Callee, size) ;
        if (Status)
            {
            ApiError("CompleteReceive", "I_RpcReceive", Status) ;
            }
        }

    ASSERT(Callee->RpcFlags & RPC_BUFFER_COMPLETE);
}

RPC_STATUS
RpcServerUseProtseqEpWrapper (
    IN unsigned char PAPI * Protseq,
    IN unsigned int MaxCalls,
    IN unsigned char PAPI * Endpoint,
    IN void PAPI * SecurityDescriptor
    )
{
    RPC_POLICY Policy ;

    if (FireWallFlag)
        {
        Policy.Length = sizeof(RPC_POLICY) ;
        Policy.NICFlags = RPC_C_BIND_TO_ALL_NICS;
        Policy.EndpointFlags = RPC_C_DONT_FAIL;
        return RpcServerUseProtseqEpExA(Protseq, MaxCalls, Endpoint,
                        SecurityDescriptor,&Policy) ;
        }
    else
        {
        return RpcServerUseProtseqEpA(Protseq, MaxCalls, Endpoint, SecurityDescriptor) ;
        }
}

RPC_STATUS
RpcServerUseProtseqWrapper (
    IN unsigned char PAPI * Protseq,
    IN unsigned int MaxCalls,
    IN void PAPI * SecurityDescriptor OPTIONAL
    )
{
    RPC_POLICY Policy ;

    if (FireWallFlag)
        {
        Policy.Length = sizeof(RPC_POLICY) ;
        Policy.NICFlags = RPC_C_BIND_TO_ALL_NICS ;
        return RpcServerUseProtseqExA(Protseq, MaxCalls, SecurityDescriptor, &Policy) ;
        }
    else
        {
        return RpcServerUseProtseqA(Protseq, MaxCalls, SecurityDescriptor) ;
        }
}

RPC_STATUS
RpcServerUseAllProtseqsWrapper (
    IN unsigned int MaxCalls,
    IN void PAPI * SecurityDescriptor OPTIONAL
    )
{
    RPC_POLICY Policy ;

    if (FireWallFlag)
        {
        Policy.Length = sizeof(RPC_POLICY) ;
        Policy.NICFlags = RPC_C_BIND_TO_ALL_NICS ;
        return RpcServerUseAllProtseqsEx(MaxCalls, SecurityDescriptor, &Policy) ;
        }
    else
        {
        return RpcServerUseAllProtseqs(MaxCalls, SecurityDescriptor) ;
        }
}

RPC_STATUS
RpcServerUseProtseqIfWrapper (
    IN unsigned char PAPI * Protseq,
    IN unsigned int MaxCalls,
    IN RPC_IF_HANDLE IfSpec,
    IN void PAPI * SecurityDescriptor
    )
{
    RPC_POLICY Policy ;

    if (FireWallFlag)
        {
        Policy.Length = sizeof(RPC_POLICY) ;
        Policy.NICFlags = RPC_C_BIND_TO_ALL_NICS ;
        return RpcServerUseProtseqIfExA(Protseq, MaxCalls, IfSpec,
                    SecurityDescriptor, &Policy) ;
        }
    else
        {
        return RpcServerUseProtseqIfA(Protseq, MaxCalls, IfSpec, SecurityDescriptor) ;
        }
}

RPC_STATUS
RpcServerUseAllProtseqsIfWrapper (
    IN unsigned int MaxCalls,
    IN RPC_IF_HANDLE IfSpec,
    IN void PAPI * SecurityDescriptor OPTIONAL
    )
{
    RPC_POLICY Policy ;

    if (FireWallFlag)
        {
        Policy.Length = sizeof(RPC_POLICY) ;
        Policy.NICFlags = RPC_C_BIND_TO_ALL_NICS ;
        return RpcServerUseAllProtseqsIfEx(MaxCalls, IfSpec, SecurityDescriptor, &Policy) ;
        }
    else
        {
        return RpcServerUseAllProtseqsIf(MaxCalls, IfSpec, SecurityDescriptor) ;
        }
}

#if 0
void
GlobalMutexRequest (
    void
    )
{
    I_RpcRequestMutex(&PrintMutex);
}

void
GlobalMutexClear (
    void
    )
{
    I_RpcClearMutex(PrintMutex);
}
#endif

void
OtherError ( // Some other error occured; again, we just print a message.
    IN char * Routine, // The routine where the error occured.
    IN char * Message
    )
{
    if (ErrorFlag)
        {
        I_RpcRequestMutex(&PrintMutex);
        PrintToConsole("    Error in %s (%s)\n",Routine,Message);
        I_RpcClearMutex(PrintMutex);
        }
}

void
Shutdown ( // Awaken the thread waiting on WaitForShutdown.
    )
{
    Status = RpcMgmtStopServerListening(0);
    if (Status)
        {
        ApiError("Shutdown","RpcMgmtStopServerListening",Status);
        }
    ShutdownCalled = 1 ;
}

RPC_STATUS
IfCallbackFunction(
    IN RPC_IF_HANDLE  InterfaceUuid,
    IN void *Context
    )
{
    return (RPC_S_OK) ;
}

RPC_STATUS
stub_RegisterIf (
    IN RPC_IF_HANDLE IfSpec,
    IN UUID PAPI * MgrTypeUuid OPTIONAL,
    IN RPC_MGR_EPV PAPI * MgrEpv OPTIONAL
    )
{
    unsigned int Flags = 0;

    if (AutoListenFlag)
        {
        Flags |= RPC_IF_AUTOLISTEN ;
        ShutdownCalled = 0 ;
        }

    if (IFSecurity)
        {
        Flags |= RPC_IF_ALLOW_SECURE_ONLY;
        }

    return RpcServerRegisterIf2(IfSpec, MgrTypeUuid, MgrEpv,
                                               Flags, 1000, MaxRpcSize, 0);
}

RPC_STATUS
stub_ServerListen (
    IN unsigned int MinimumCallThreads,
    IN unsigned int MaxCalls,
    IN unsigned int DontWait
    )
{
    if (AutoListenFlag)
        {
        while (ShutdownCalled == 0)
            {
            PauseExecution(500) ;
            }
        return (RPC_S_OK) ;
        }
    else
        {
        return RpcServerListen(MinimumCallThreads, MaxCalls, DontWait) ;
        }
}

void IsabelleError (
    )
{
    IsabelleErrors += 1 ;
}

void HelgaError (
    )
{
    HelgaErrors += 1 ;
}

void SylviaError (
    )
{
    SylviaErrors += 1 ;
}

#define SIGFRIED 0
#define ELLIOTMINIMIZE 1
#define ELLIOTMAXIMIZE 2
#define ELLIOTNORMAL 3
#define ANDROMIDA 4
#define FREDRICK 7
#define ISABELLENORMAL 10
#define ISABELLEMINIMIZE 11
#define ISABELLEMAXIMIZE 12
#define CHRISTOPHER 13
#define CHRISTOPHERHELGA 14
#define CHRISTOPHERISABELLE 15
#define TYLER 17
#define CHRISTOPHERMUSTFAILONE 18
#define CHRISTOPHERMUSTFAILTWO 19
#define RICHARD 20
#define RICHARDHELPER 21
#define DAVIDFIRST 22
#define DAVIDSECOND 23
#define BARTHOLOMEW 24
#define GRANT 25
#define HERMAN 26
#define IVAN 27
#define JASON 28
#define KENNETH 29
#define TESTYIELD 30
#define SPIPE TESTYIELD
#define SECURITY_ERROR TESTYIELD


/*
Transports:

    Update this to add a new transport.
*/

char * NamepipeAddresses [] =
{
    "\\pipe\\sigfried",
    "\\pipe\\elliotmi",
    "\\pipe\\elliotma",
    "\\pipe\\elliotno",
    "\\pipe\\andromno",
    0,
    0,
    "\\pipe\\fredrick",
    0,
    0,
    "\\pipe\\isabelno",
    "\\pipe\\isabelmi",
    "\\pipe\\isabelma",
    "\\pipe\\christ",
    "\\pipe\\zippyhe",
    "\\pipe\\zippyis",
    0,
    "\\pipe\\tyler",
    "\\\blippo",
    "\\\\\\chrismft",
    "\\pipe\\richard",
    "\\pipe\\richardh",
    "\\pipe\\david1",
    "\\pipe\\david2",
    "\\pipe\\bart",
    "\\pipe\\grant",
    "\\pipe\\herman",
    "\\pipe\\ivan",
    "\\pipe\\jason",
    "\\pipe\\kenneth",
    "\\pipe\\testyield"
};

char * DspAddresses [] =
{
    "\\pipe\\sigfried",
    "\\pipe\\elliotmi",
    "\\pipe\\elliotma",
    "\\pipe\\elliotno",
    "\\pipe\\andromno",
    0,
    0,
    "\\pipe\\fredrick",
    0,
    0,
    "\\pipe\\isabelno",
    "\\pipe\\isabelmi",
    "\\pipe\\isabelma",
    "\\pipe\\christ",
    "\\pipe\\zippyhe",
    "\\pipe\\zippyis",
    0,
    "\\pipe\\tyler",
    "",
    "",
    "\\pipe\\richard",
    "\\pipe\\richardh",
    "\\pipe\\david1",
    "\\pipe\\david2",
    "\\pipe\\bart",
    "\\pipe\\grant",
    "\\pipe\\herman",
    "\\pipe\\ivan",
    "\\pipe\\jason",
    "\\pipe\\kenneth",
    "\\pipe\\testyield"
};

char * NetBiosAddresses [] =
{
    "201",    // sigfried
    "202",    // elliotmi
    "203",    // elliotma
    "204",    // elliotno
    "205",    // andromno
    0,
    0,
    "206",    // fredrick
    0,
    0,
    "207",    // isabelno
    "208",    // isabelmi
    "209",    // isabelma
    "210",    // christ
    "211",    // zippyhe
    "212",    // zippyis
    0,
    "214",    // tyler
    "300",    // christ fail 1
    "BadName",// christ fail 2
    "215",    // richard
    "216",    // richardh
    "217",    // david1
    "218",    // david2
    "219",    // bart
    "220",    // grant
    "221",    // herman
    "222",    // ivan
    "223",    // jason
    "224",     // kenneth
    "225"     //testyield
};

char * TCPAddresses [] =
{
    "2025", // SIGFRIED
    "2026", // ELLIOTMINIMIZE
    "2027", // ELLIOTMAXIMIZE
    "2028", // ELLIOTNORMAL
    "2029", // ANDROMIDA
    0,
    0,
    "2032", // FREDRICK
    0,
    0,
    "2035", // ISABELLENORMAL
    "2036", // ISABELLEMINIMIZE
    "2037", // ISABELLEMAXIMIZE
    "2038", // CHRISTOPHER
    "2039", // CHRISTOPHERHELGA
    "2040", // CHRISTOPHERISABELLE
    0,
    "2042", // TYLER
    "chrismfo",
    "chrismft",
    "2043", // RICHARD
    "2044", // RICHARDHELPER
    "2045", // D1
    "2046", // D2
    "2047", // BARTHOLOMEW
    "2048", // GRANT
    "2049", // HERMAN
    "2050", // IVAN
    "2051", // JASON
    "2052",  // KENNETH
    "2053"  // TESTYIELD
};

char * UDPAddresses [] =
{
    "2025", // SIGFRIED
    "2026", // ELLIOTMINIMIZE
    "2027", // ELLIOTMAXIMIZE
    "2028", // ELLIOTNORMAL
    "2029", // ANDROMIDA
    0,
    0,
    "2032", // FREDRICK
    0,
    0,
    "2035", // ISABELLENORMAL
    "2036", // ISABELLEMINIMIZE
    "2037", // ISABELLEMAXIMIZE
    "2038", // CHRISTOPHER
    "2039", // CHRISTOPHERHELGA
    "2040", // CHRISTOPHERISABELLE
    0,
    "2042", // TYLER
    "chrismfo",
    "chrismft",
    "2043", // RICHARD
    "2044", // RICHARDHELPER
    "2045", // D1
    "2046", // D2
    "2047", // BARTHOLOMEW
    "2048", // GRANT
    "2049", // HERMAN
    "2050", // IVAN
    "2051", // JASON
    "2052",  // KENNETH
    "2053"  // TESTYIELD
};

char * SPCAddresses [] =
{
    "sigfried",
    "elliotminimize",
    "elliotmaximize",
    "elliotnormal",
    "andromida",
    0,
    0,
    "fredrick",
    0,
    0,
    "isabellenormal",
    "isabelleminimize",
    "isabellemaximize",
    "christopher",
    "christopherhelga",
    "christopherisabelle",
    0,
    "tyler",
    "\\christophermustfailone",
    "christopher\\mustfailtwo",
    "richard",
    "richardhelper",
    "davidfirst",
    "davidsecond",
    "bartholomew",
    "grant",
    "herman",
    "ivan",
    "jason",
    "kenneth",
    "testyield"
};

char * SPXAddresses [] =
{
    "5000",    // sigfried
    "5001",    // elliotmi
    "5002",    // elliotma
    "5003",    // elliotno
    "5004",    // andromno
    "5005",
    "5006",
    "5007",    // fredrick
    "5008",
    "5009",
    "5010",    // isabelno
    "5011",    // isabelmi
    "5012",    // isabelma
    "5013",    // christ
    "5014",    // zippyhe
    "5015",    // zippyis
    "5016",
    "5017",    // tyler
    "hello",    // christ fail 1
    "50195019",    // christ fail 2
    "5020",    // richard
    "5021",    // richardh
    "5022",    // david1
    "5023",    // david2
    "5024",    // bart
    "5025",    // grant
    "5026",    // herman
    "5027",    // ivan
    "5028",    // jason
    "5029",     // kenneth
    "5030"     // testyield
};

char * IPXAddresses [] =
{
    "5000",    // sigfried
    "5001",    // elliotmi
    "5002",    // elliotma
    "5003",    // elliotno
    "5004",    // andromno
    "5005",
    "5006",
    "5007",    // fredrick
    "5008",
    "5009",
    "5010",    // isabelno
    "5011",    // isabelmi
    "5012",    // isabelma
    "5013",    // christ
    "5014",    // zippyhe
    "5015",    // zippyis
    "5016",
    "5017",    // tyler
    "hello",    // christ fail 1
    "50195019",    // christ fail 2
    "5020",    // richard
    "5021",    // richardh
    "5022",    // david1
    "5023",    // david2
    "5024",    // bart
    "5025",    // grant
    "5026",    // herman
    "5027",    // ivan
    "5028",    // jason
    "5029",     // kenneth
    "5030"     // testyield
};


char * VNSAddresses [] =
{
    "250",    // sigfried
    "251",    // elliotmi
    "252",    // elliotma
    "253",    // elliotno
    "254",    // andromno
    "255",
    "256",
    "257",    // fredrick
    "258",
    "259",
    "260",    // isabelno
    "261",    // isabelmi
    "262",    // isabelma
    "263",    // christ
    "264",    // zippyhe
    "265",    // zippyis
    "266",
    "267",    // tyler
    "hello",    // christ fail 1
    "50195019",    // christ fail 2
    "270",    // richard
    "271",    // richardh
    "272",    // david1
    "273",    // david2
    "274",    // bart
    "275",    // grant
    "276",    // herman
    "277",    // ivan
    "278",    // jason
    "279",     // kenneth
    "280"     // testyield
};

char * MSMQAddresses [] =
{
    "SIGFRIED",
    "ELLIOTMINIMIZE",
    "ELLIOTMAXIMIZE",
    "ELLIOTNORMAL",
    "ANDROMIDA",
    0,
    0,
    "FREDRICK",
    0,
    0,
    "ISABELLENORMAL",
    "ISABELLEMINIMIZE",
    "ISABELLEMAXIMIZE",
    "CHRISTOPHER",
    "CHRISTOPHERHELGA",
    "CHRISTOPHERISABELLE",
    0,
    "TYLER",
    " \\  \\  \\chrismfo",
    "chr\\\\\\\\  $$$$ismft",
    "RICHARD",
    "RICHARDHELPER",
    "D1",
    "D2",
    "BARTHOLOMEW",
    "GRANT",
    "HERMAN",
    "IVAN",
    "JASON",
    "KENNETH",
    "TESTYIELD"
};



unsigned char *
GetProtocolSequence (
    )
/*++

Routine Description:

    This routine is used to obtain an rpc protocol sequence.

Return Value:

    A pointer to an rpc protocol sequence is returned.  This pointer
    should not be freed.

Transports:

    Update this to add a new transport.

--*/
{
    if (TransportType == RPC_TRANSPORT_NAMEPIPE)
        return((unsigned char *) "ncacn_np");

    if (TransportType == RPC_LRPC)
        {
        return((unsigned char *) "ncalrpc");
        }

    if (TransportType == RPC_TRANSPORT_NETBIOS)
        return((unsigned char *) NetBiosProtocol);

    if (TransportType == RPC_TRANSPORT_SPX)
        return((unsigned char *) "ncacn_spx");

    if (TransportType == RPC_TRANSPORT_TCP)
        return((unsigned char *) "ncacn_ip_tcp");

    if (TransportType == RPC_TRANSPORT_UDP)
        return((unsigned char *) "ncadg_ip_udp");

    if (TransportType == RPC_TRANSPORT_IPX)
        return((unsigned char *) "ncadg_ipx");

    if (TransportType == RPC_TRANSPORT_DSP)
            return((unsigned char *) "ncacn_at_dsp") ;

    if (TransportType == RPC_TRANSPORT_VNS)
                return((unsigned char *) "ncacn_vns_spp") ;

    if (TransportType == RPC_TRANSPORT_MSMQ)
                return((unsigned char *) "ncadg_mq") ;

    return(0);
}


unsigned char *
GetEndpoint (
    IN unsigned int Endpoint
    )
/*++

Routine Description:

    This routine is used to obtain the endpoint corresponding to a
    give endpoint index.

Arguments:

    Endpoint - Supplies an index into a table of endpoints.

Return Value:

    A pointer to an endpoint from the table of endpoints will be returned.

Transports:

    Update this to add a new transport.

--*/
{
    if (TransportType == RPC_TRANSPORT_NAMEPIPE)
        return((unsigned char *) NamepipeAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_NETBIOS)
        return((unsigned char *) NetBiosAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_TCP)
        return((unsigned char *) TCPAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_UDP)
        return((unsigned char *) UDPAddresses[Endpoint]);

    else if ((TransportType == RPC_LRPC) || (TransportType == RPC_WMSG))
        return((unsigned char *) SPCAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_SPX)
        return((unsigned char *) SPXAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_IPX)
        return((unsigned char *) IPXAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_VNS)
        return((unsigned char *) VNSAddresses[Endpoint]);

    else if (TransportType == RPC_TRANSPORT_DSP)
                return ((unsigned char *) DspAddresses[Endpoint]) ;

    else if (TransportType == RPC_TRANSPORT_MSMQ)
                return ((unsigned char *) MSMQAddresses[Endpoint]) ;

    return(0);
}


/* --------------------------------------------------------------------

Helga Interface

-------------------------------------------------------------------- */

unsigned int HelgaCheckManagerEpv = 0;
RPC_MGR_EPV PAPI * HelgaManagerEpv;
unsigned int HelgaCheckObject = 0;
unsigned short HelgaMagicNumber;


int
CheckUuidValue (
    IN unsigned short MagicNumber,
    OUT UUID PAPI * Uuid
    )
/*++

Routine Description:

    This routine is used to check that a generated uuid value is correct.

Arguments:

    MagicNumber - Supplies a magic number which will be used to
        check a generated uuid.

    Uuid - Supplies a generated uuid to check.

Return Value:

    Zero will be returned if the uuid value is correct; otherwise, non-zero
    will be returned.

--*/
{
    if ( Uuid->Data1 != ((unsigned long) MagicNumber)
                * ((unsigned long) MagicNumber))
        return(1);
    if ( Uuid->Data2 != MagicNumber )
        return(1);
    if ( Uuid->Data3 != MagicNumber / 2 )
        return(1);
    if ( Uuid->Data4[0] != MagicNumber % 256 )
        return(1);
    if ( Uuid->Data4[1] != MagicNumber % 257 )
        return(1);
    if ( Uuid->Data4[2] != MagicNumber % 258 )
        return(1);
    if ( Uuid->Data4[3] != MagicNumber % 259 )
        return(1);
    if ( Uuid->Data4[4] != MagicNumber % 260 )
        return(1);
    if ( Uuid->Data4[5] != MagicNumber % 261 )
        return(1);
    if ( Uuid->Data4[6] != MagicNumber % 262 )
        return(1);
    if ( Uuid->Data4[7] != MagicNumber % 263 )
        return(1);
    return(0);
}


void
InitializeBuffer (
    IN OUT void PAPI * Buffer,
    IN unsigned int BufferLength
    )
/*++

Routine Description:

    This routine is used to initialize the buffer; the first long in the
    buffer is set to be the length of the buffer.  The rest of the buffer
    is initialized with a pattern which will be checked by the receiver.

Arguments:

    Buffer - Supplies the buffer to be initialized.

    BufferLength - Supplies the length of the buffer.

--*/
{
    unsigned long PAPI * Length;
    unsigned char PAPI * BufferScan;
    static unsigned char InitialValue = 69;
    unsigned char Value;

    Length = (unsigned long PAPI *) Buffer;
    *Length = BufferLength;
    Value = InitialValue;
    InitialValue += 1;

    for (BufferScan = (unsigned char PAPI *) (Length + 1), BufferLength -= 4;
        BufferLength > 0; BufferLength--, BufferScan++, Value++)
        *BufferScan = Value;
}


int
CheckBuffer (
    IN void PAPI * Buffer,
    IN unsigned long BufferLength
    )
/*++

Routine Description:

    We need to check that the correct bytes were sent.  We do not check
    the length of the buffer.

Arguments:

    Buffer - Supplies the buffer to be checked.

    BufferLength - Supplies the length of the buffer to be checked.

Return Value:

    A value of zero will be returned if the buffer contains the correct
    bytes; otherwise, non-zero will be returned.

--*/
{
    unsigned long PAPI * Length;
    unsigned char PAPI * BufferScan;
    unsigned char Value;

    Length = (unsigned long PAPI *) Buffer;

    for (BufferScan = (unsigned char PAPI *) (Length + 1),
                Value = *BufferScan, BufferLength -= 4;
                BufferLength > 0; BufferLength--, BufferScan++, Value++)
        {
        if (*BufferScan != Value)
            {
            return(1);
            }
        }

    return(0);
}



int
CheckInitialBuffer (
    IN void PAPI * Buffer,
    IN unsigned long BufferLength,
    OUT unsigned char * pNextValue
    )
/*++

Routine Description:

    We need to check that the correct bytes were sent.  We do not check
    the length of the buffer.

Arguments:

    Buffer - Supplies the buffer to be checked.

    BufferLength - Supplies the length of the buffer to be checked.

Return Value:

    A value of zero will be returned if the buffer contains the correct
    bytes; otherwise, non-zero will be returned.

--*/
{
    unsigned long PAPI * Length;
    unsigned char PAPI * BufferScan;
    unsigned char Value;

    Length = (unsigned long PAPI *) Buffer;

    for (BufferScan = (unsigned char PAPI *) (Length + 1),
                Value = *BufferScan, BufferLength -= 4;
                BufferLength > 0; BufferLength--, BufferScan++, Value++)
        {
        if (*BufferScan != Value)
            {
            return(1);
            }
        }

    *pNextValue = Value;

    return(0);
}



int
CheckContinuedBuffer (
    IN void PAPI * Buffer,
    IN unsigned long BufferLength,
    IN  unsigned char BeginningValue,
    OUT unsigned char * pNextValue
    )
/*++

Routine Description:

    We need to check that the correct bytes were sent.  We do not check
    the length of the buffer.

Arguments:

    Buffer - Supplies the buffer to be checked.

    BufferLength - Supplies the length of the buffer to be checked.

Return Value:

    A value of zero will be returned if the buffer contains the correct
    bytes; otherwise, non-zero will be returned.

    *pValue

--*/
{
    unsigned long PAPI * Length;
    unsigned char PAPI * BufferScan;
    unsigned char Value;

    for (BufferScan = (unsigned char PAPI *) Buffer, Value = BeginningValue;
         BufferLength > 0;
         BufferLength--, BufferScan++, Value++)
        {
        if (*BufferScan != Value)
            {
            return(1);
            }
        }

    *pNextValue = Value;

    return(0);
}


extern RPC_DISPATCH_TABLE HelgaDispatchTable;

RPC_PROTSEQ_ENDPOINT HelgaRpcProtseqEndpoint[] =
{
    {(unsigned char *) "ncacn_np",
#ifdef WIN32RPC
     (unsigned char *) "\\pipe\\zippyhe"},
#else // WIN32RPC
     (unsigned char *) "\\device\\namedpipe\\christopherhelga"},
#endif // WIN32RPC
    {(unsigned char *) "ncacn_ip_tcp", (unsigned char *) "2039"},
    {(unsigned char *) "ncadg_ip_udp", (unsigned char *) "2039"},
    {(unsigned char *) "ncalrpc", (unsigned char *) "christopherhelga"},
    {(unsigned char *) "ncacn_nb_nb", (unsigned char *) "211"},
    {(unsigned char *) "ncacn_spx", (unsigned char *) "5014"},
    {(unsigned char *) "ncadg_ipx", (unsigned char *) "5014"},
    {(unsigned char *) "ncacn_vns_spp", (unsigned char *) "264"},
    {(unsigned char *) "ncacn_at_dsp",(unsigned char *) "\\pipe\\zippyhe"},
    {(unsigned char *) "ncadg_mq",(unsigned char *) "christopherhelga"}
};

RPC_SERVER_INTERFACE HelgaInterfaceInformation =
{
    sizeof(RPC_SERVER_INTERFACE),
    {{1,2,2,{3,3,3,3,3,3,3,3}},
     {1,1}},
    {{0x8A885D04, 0x1CEB, 0x11C9, {0x9F, 0xE8, 0x08, 0x00, 0x2B, 0x10, 0x48, 0x60}},
     {2, 0}},
    &HelgaDispatchTable,
    sizeof(HelgaRpcProtseqEndpoint) / sizeof(RPC_PROTSEQ_ENDPOINT),
    HelgaRpcProtseqEndpoint,
    NULL,
    NULL,
    RPC_INTERFACE_HAS_PIPES
};

void __RPC_STUB
HelgaStub (
    PRPC_MESSAGE Callee
    )
{
    UUID ObjectUuid;

    CompleteReceive(Callee) ;

    if ( HelgaCheckObject != 0 )
        {
        Status = RpcBindingInqObject(Callee->Handle, &ObjectUuid);
        if (Status)
            {
            ApiError("HelgaStub", "RpcBindingInqObject", Status);
            HelgaError();
            }
        else if ( CheckUuidValue(HelgaMagicNumber, &ObjectUuid) != 0 )
            {
            OtherError("HelgaStub", "CheckUuidValue() != 0");
            HelgaError();
            }

        Status = RpcBindingInqObject(0, &ObjectUuid);  // zero handle
        if (Status)
            {
            ApiError("HelgaStub", "RpcBindingInqObject", Status);
            HelgaError();
            }
        else if ( CheckUuidValue(HelgaMagicNumber, &ObjectUuid) != 0 )
            {
            OtherError("HelgaStub", "CheckUuidValue() != 0");
            HelgaError();
            }
        }
    HelgaMagicNumber += 1;

    if ( Callee->ProcNum != 0 )
        {
        OtherError("HelgaStub", "Callee->ProcNum != 0");
        HelgaError();
        }

    if ( memcmp(Callee->RpcInterfaceInformation, &HelgaInterfaceInformation,
                sizeof(HelgaInterfaceInformation)) != 0 )
        {
        OtherError("HelgaStub",
                "Callee->RpcInteraceInformation != &HelgaInterfaceInformation");
        HelgaError();
        }

    if ( HelgaCheckManagerEpv != 0 )
        {
        if ( Callee->ManagerEpv != HelgaManagerEpv )
            {
            OtherError("HelgaStub", "Callee->ManagerEpv != HelgaManagerEpv");
            HelgaError();
            }
        }

    if (Callee->BufferLength != 0)
        {
        OtherError("HelgaStub","*BufferLength != 0");
        HelgaError();
        }

    Callee->BufferLength = 0;

    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("HelgaStub","I_RpcGetBuffer",Status);
        HelgaError();
        }
}

void __RPC_STUB
HelgaINStub (
    PRPC_MESSAGE Callee
    )
{
    unsigned long Length;
    UUID ObjectUuid;

    if ( HelgaCheckObject != 0 )
        {
        Status = RpcBindingInqObject(Callee->Handle, &ObjectUuid);
        if (Status)
            {
            ApiError("HelgaINStub", "RpcBindingInqObject", Status);
            HelgaError();
            }
        else if ( CheckUuidValue(HelgaMagicNumber, &ObjectUuid) != 0 )
            {
            OtherError("HelgaINStub", "CheckUuidValue() != 0");
            HelgaError();
            }
        }
    HelgaMagicNumber += 1;

    if ( Callee->ProcNum != 1 )
        {
        OtherError("HelgaINStub", "Callee->ProcNum != 0");
        HelgaError();
        }

    if ( memcmp(Callee->RpcInterfaceInformation, &HelgaInterfaceInformation,
                sizeof(HelgaInterfaceInformation)) != 0 )
        {
        OtherError("HelgaINStub",
                "Callee->RpcInteraceInformation != &HelgaInterfaceInformation");
        HelgaError();
        }

    if ( HelgaCheckManagerEpv != 0 )
        {
        if ( Callee->ManagerEpv != HelgaManagerEpv )
            {
            OtherError("HelgaINStub", "Callee->ManagerEpv != HelgaManagerEpv");
            HelgaError();
            }
        }

    //
    // Check the data we have so far.
    //
    Length = *(unsigned long *) Callee->Buffer;
    if (Length < Callee->BufferLength)
        {
        OtherError("HelgaINStub","*Length < *BufferLength");
        HelgaError();
        }

    if (0 == (Callee->RpcFlags & RPC_BUFFER_COMPLETE))
        {
        CompleteReceive(Callee) ;
        }

    if (Length != Callee->BufferLength)
        {
        OtherError("HelgaINStub","incomplete buffer marked as complete");
        HelgaError();
        }

    unsigned char InitialValue;
    if (CheckInitialBuffer(Callee->Buffer, Callee->BufferLength, &InitialValue) != 0)
        {
        OtherError("HelgaINStub","CheckBuffer Failed");
        HelgaError();
        }

    //
    // The [out] buffer.
    //
    Callee->BufferLength = 0;

    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("HelgaINStub","I_RpcGetBuffer",Status);
        HelgaError();
        }
}

void __RPC_STUB
HelgaOUTStub (
    PRPC_MESSAGE Callee
    )
{
    unsigned long * Length;
    unsigned int Size;
    UUID ObjectUuid;

    CompleteReceive(Callee) ;

    if ( HelgaCheckObject != 0 )
        {
        Status = RpcBindingInqObject(Callee->Handle, &ObjectUuid);
        if (Status)
            {
            ApiError("HelgaOUTStub", "RpcBindingInqObject", Status);
            HelgaError();
            }
        else if ( CheckUuidValue(HelgaMagicNumber, &ObjectUuid) != 0 )
            {
            OtherError("HelgaOUTStub", "CheckUuidValue() != 0");
            HelgaError();
            }
        }
    HelgaMagicNumber += 1;

    if ( Callee->ProcNum != 2 )
        {
        OtherError("HelgaOUTStub", "Callee->ProcNum != 0");
        HelgaError();
        }

    if ( memcmp(Callee->RpcInterfaceInformation, &HelgaInterfaceInformation,
                sizeof(HelgaInterfaceInformation)) != 0 )
        {
        OtherError("HelgaOUTStub",
                "Callee->RpcInteraceInformation != &HelgaInterfaceInformation");
        HelgaError();
        }

    if ( HelgaCheckManagerEpv != 0 )
        {
        if ( Callee->ManagerEpv != HelgaManagerEpv )
            {
            OtherError("HelgaOUTStub", "Callee->ManagerEpv != HelgaManagerEpv");
            HelgaError();
            }
        }

    if (Callee->BufferLength != sizeof(unsigned long))
        {
        //
        // secure datagram calls round the stub data length to a multiple
        // of eight.
        //
        if (!DatagramFlag || Callee->BufferLength != 8)
            {
            OtherError("HelgaOUTStub","*BufferLength != sizeof(unsigned int)");
            HelgaError();
            }
        }

    Length = (unsigned long *) Callee->Buffer;
    Size = (unsigned int) *Length;
    Callee->BufferLength = Size;

    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("HelgaOUTStub","I_RpcGetBuffer",Status);
        HelgaError();
        }
    else
        {
        InitializeBuffer(Callee->Buffer, Size);
        }
}

void __RPC_STUB
HelgaINOUTStub (
    PRPC_MESSAGE Callee
    )
{
    unsigned long Length;
    UUID ObjectUuid;

    if ( HelgaCheckObject != 0 )
        {
        Status = RpcBindingInqObject(Callee->Handle, &ObjectUuid);
        if (Status)
            {
            ApiError("HelgaINOUTStub", "RpcBindingInqObject", Status);
            HelgaError();
            }
        else if ( CheckUuidValue(HelgaMagicNumber, &ObjectUuid) != 0 )
            {
            OtherError("HelgaINOUTStub", "CheckUuidValue() != 0");
            HelgaError();
            }
        }
    HelgaMagicNumber += 1;

    if ( Callee->ProcNum != 3 )
        {
        OtherError("HelgaINOUTStub", "Callee->ProcNum != 0");
        HelgaError();
        }

    if ( memcmp(Callee->RpcInterfaceInformation, &HelgaInterfaceInformation,
                sizeof(HelgaInterfaceInformation)) != 0 )
        {
        OtherError("HelgaINOUTStub",
                "Callee->RpcInteraceInformation != &HelgaInterfaceInformation");
        HelgaError();
        }

    if ( HelgaCheckManagerEpv != 0 )
        {
        if ( Callee->ManagerEpv != HelgaManagerEpv )
            {
            OtherError("HelgaINOUTStub",
                    "Callee->ManagerEpv != HelgaManagerEpv");
            HelgaError();
            }
        }

    //
    // Check the data we have so far.
    //
    Length = *(unsigned long *) Callee->Buffer;
    if (Length < Callee->BufferLength)
        {
        OtherError("HelgaINOUTStub","*Length < *BufferLength");
        HelgaError();
        }

    unsigned char InitialValue;
    if (CheckInitialBuffer(Callee->Buffer, Callee->BufferLength, &InitialValue) != 0)
        {
        OtherError("HelgaINOUTStub","initial CheckBuffer Failed");
        HelgaError();
        }

    if (Length > Callee->BufferLength)
        {
        if (Callee->RpcFlags & RPC_BUFFER_COMPLETE)
            {
            OtherError("HelgaINOUTStub","incomplete buffer marked as complete");
            HelgaError();
            }
        }

    if (0 == (Callee->RpcFlags & RPC_BUFFER_COMPLETE))
        {
        //
        // Get the rest of the data and check it.
        //
        CompleteReceive(Callee) ;

        if (0 != CheckInitialBuffer(Callee->Buffer, Callee->BufferLength, &InitialValue))
            {
            OtherError("HelgaINOUTStub","second CheckBuffer Failed");
            HelgaError();
            }
        }

    Callee->BufferLength = Length;

    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("HelgaINOUTStub","I_RpcGetBuffer",Status);
        HelgaError();
        }
    else
        {
        InitializeBuffer(Callee->Buffer, Length);
        }
}

void Synchro(
    PRPC_MESSAGE Callee
    )
{
    PrintToConsole("Sychro called\n") ;
    RpcServerYield();
}

void SvrLazyFunc(
    PRPC_MESSAGE Callee
    )
{
    PrintToConsole("About to sleep\n") ;
    PauseExecution(100000) ;
    PrintToConsole("Waking up\n") ;

    Shutdown() ;
}

void HelgaLpcSecurity(
    PRPC_MESSAGE Callee
    )
{
    RPC_STATUS RpcStatus ;
    RPC_CHAR *UserName ;

    PrintToConsole("HelgaLpcSecurity\n") ;

    RpcStatus = RpcBindingInqAuthClient(Callee->Handle, (void **) &UserName,
                                        NULL, NULL, NULL, NULL) ;
    if ((RpcStatus != RPC_S_OK) && (RpcStatus != RPC_S_BINDING_HAS_NO_AUTH))
        {
        HelgaError() ;


        PrintToConsole("HelgaLpcSecurity: (1) UserName: %S\n", UserName) ;
        }

    UserName = NULL ;

    RpcStatus = RpcBindingInqAuthClient(Callee->Handle, (void **) &UserName,
                                        NULL, NULL, NULL, NULL) ;
    if ((RpcStatus != RPC_S_OK) && (RpcStatus != RPC_S_BINDING_HAS_NO_AUTH))
        {
        HelgaError() ;
        PrintToConsole("HelgaLpcSecurity: (2) UserName: %S\n", UserName) ;
        }
}

void
HelgaObjectUuids (
    PRPC_MESSAGE Callee
    )
{
    PrintToConsole("HelgaObjectUuids\n") ;

    char *Ptr = (char *) Callee->Buffer;
    BOOL fObjectUuid = *((BOOL *) Ptr);
    UUID MyObjectUuid;

    Status = RpcBindingInqObject(Callee->Handle, &MyObjectUuid);
    if (Status)
        {
        ApiError("HelgaStub", "RpcBindingInqObject", Status);
        HelgaError();
        RpcRaiseException(Status);
        }

    UUID Uuid;
    Ptr += sizeof(BOOL);

    if (fObjectUuid)
        {
        RpcpMemoryCopy(&Uuid, Ptr, sizeof(UUID));
        }
    else
        {
        RpcpMemorySet(&Uuid, 0, sizeof(UUID));
        }

    if (RpcpMemoryCompare(&Uuid, &MyObjectUuid, sizeof(UUID)))
        {
        HelgaError();
        RpcRaiseException(-1);
        }

    Callee->BufferLength = 0;

    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("HelgaStub","I_RpcGetBuffer",Status);
        HelgaError();
        RpcRaiseException(Status);
        }
}

void
HelgaConnId (
    PRPC_MESSAGE Callee
    )
{
    PrintToConsole("HelgaConnId\n") ;
    static void *OldId = 0;
    void *ConnId;
    BOOL fFirstTime;

    Status = I_RpcBindingInqConnId(
                                   Callee->Handle,
                                   &ConnId,
                                   &fFirstTime);
    if (Status)
        {
        HelgaError();
        ApiError("HelgaStub","I_RpcBindingInqConnId",Status);
        RpcRaiseException(Status);
        }

    PrintToConsole("HelgaConnId: ConnId: %p, fFirstTime: %d\n", ConnId, fFirstTime);

    char *Ptr = (char *) Callee->Buffer;
    BOOL fNewConnExpected = *((BOOL *) Ptr);


    if (fNewConnExpected != fFirstTime)
        {
        HelgaError();
        RpcRaiseException(-1);
        }

    if (fFirstTime)
        {
        OldId = ConnId;
        }
    else
        {
        if (ConnId != OldId)
            {
            HelgaError();
            RpcRaiseException(-1);
            }
        }

    Callee->BufferLength = 0;

    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("HelgaStub","I_RpcGetBuffer",Status);
        HelgaError();
        RpcRaiseException(Status);
        }
}

typedef struct _WIRE_CONTEXT
{
    unsigned long ContextType;
    UUID ContextUuid;
} WIRE_CONTEXT;

void UsvrRundown (
    void *Context
    )
{
    PrintToConsole("UsvrRundown called");
}

// partial replica of SCONTEXTItem in scontext.cxx
typedef struct tagUserContext
{
    void *R1;
    void *R2;
    void * userContext;       /* context for the user */
} UserContext;


// the buffer should be of type and size WIRE_CONTEXT
void OpenContextHandle (
    RPC_MESSAGE *Callee
    )
{
    void *pGuard;
    RPC_SERVER_INTERFACE *ServerIf;
    RPC_STATUS RpcStatus;
    void *Context;
    WIRE_CONTEXT WireContext;

    ASSERT(Callee->BufferLength == sizeof(WIRE_CONTEXT));

    if (Callee->ProcNum == 21)
        {
        ServerIf = &IsabelleInterfaceInformation;
        }
    else if (Callee->ProcNum == 10)
        {
        ServerIf = &HelgaInterfaceInformation;
        }
    else
        {
        ASSERT(0);
        }

    pGuard = &ServerIf->InterfaceId;

    Context = NDRSContextUnmarshall2(Callee->Handle,
        Callee->Buffer,
        10,
        pGuard,
        0);

    ((UserContext *)Context)->userContext = pGuard;

    Callee->BufferLength = 0;

    RpcStatus = I_RpcGetBuffer(Callee);
    if (RpcStatus != RPC_S_OK)
        {
        ApiError("Get Buffer", "I_RpcGetBuffer", Status) ;
        return ;
        }

    NDRSContextMarshall2(Callee->Handle,
        (NDR_SCONTEXT)Context,
        &WireContext,
        UsvrRundown,
        pGuard,
        0);
}

extern void
Foo_s (
    PRPC_MESSAGE Message
    ) ;

extern void
FooPipe_s (
    PRPC_MESSAGE Message
    )  ;

extern void
FooBar_s (
    PRPC_MESSAGE Message
    ) ;

void
FooCH_s (
    PRPC_MESSAGE Message
    ) ;



RPC_DISPATCH_FUNCTION HelgaDispatchFunctions[] =
{
        HelgaStub,
        HelgaINStub,
        HelgaOUTStub,
        HelgaINOUTStub,
        Synchro,
        SvrLazyFunc,
        HelgaLpcSecurity,
        Foo_s,
        HelgaObjectUuids,
        HelgaConnId,
        OpenContextHandle
};

RPC_DISPATCH_TABLE HelgaDispatchTable =
{
    11, HelgaDispatchFunctions
};

/* --------------------------------------------------------------------

Sylvia Interface

-------------------------------------------------------------------- */

extern RPC_DISPATCH_TABLE SylviaDispatchTable;

RPC_SERVER_INTERFACE SylviaInterfaceInformation =
{
    sizeof(RPC_SERVER_INTERFACE),
    {{3,2,2,{1,1,1,1,1,1,1,1}},
     {1,1}},
    {{0x8A885D04, 0x1CEB, 0x11C9, {0x9F, 0xE8, 0x08, 0x00, 0x2B, 0x10, 0x48, 0x60}},
     {2, 0}},
    &SylviaDispatchTable,
    0,
    0,
    0,
    0,
    RPC_INTERFACE_HAS_PIPES
};


unsigned int SylviaQueryBinding = 0;
unsigned int SylviaQueryProtocolStack = 0;
unsigned int SylviaQueryCall = 0;
char * SylviaTransportInfo = 0;

unsigned /*int*/ char // Specifies the new count of calls.
SylviaCallback (
    unsigned /*long*/ char Depth, // Specifies the depth of recursion desired.
    unsigned /*long*/ char Breadth, // Specifies the breadth desired.
    unsigned /*long*/ char Count // Specifies the count of calls up to this point.
    )
{
    RPC_MESSAGE Caller;
    unsigned /*long*/ char * plScan, ReturnValue;

    Caller.ProcNum = 0;
    Caller.Handle = I_RpcGetCurrentCallHandle();

    if (Caller.Handle == (RPC_BINDING_HANDLE) 0)
        {
        OtherError("SylviaCallback","Call == (RPC_BINDING_HANDLE) 0");
        SylviaError();
        return(0);
        }

    Caller.BufferLength = sizeof(unsigned /*long*/ char)*4+10240;
    Status = I_RpcGetBuffer(&Caller);
    if (Status)
        {
        ApiError("SylviaCallback","I_RpcGetBuffer",Status);
        SylviaError();
        return(0);
        }
    plScan = (unsigned /*long*/ char *) Caller.Buffer;
    plScan[0] = (unsigned char) Depth;
    plScan[1] = (unsigned char) Breadth;
    plScan[2] = (unsigned char) Count;

    Status = I_RpcSendReceive(&Caller);
    if (Status)
        {
        ApiError("SylviaCallback","I_RpcSendReceive",Status);
        SylviaError();
        return(0);
        }

    plScan = (unsigned /*long*/ char *) Caller.Buffer;
    ReturnValue = *plScan;
    Status = I_RpcFreeBuffer(&Caller);
    if (Status)
        {
        ApiError("SylviaCallback","I_RpcFreeBuffer",Status);
        SylviaError();
        return(0);
        }
    return(ReturnValue);
}

unsigned /*long*/ char
SylviaCallUserCode ( // The user code for SylviaCall.
    unsigned /*long*/ char Depth,
    unsigned /*long*/ char Breadth,
    unsigned /*long*/ char Count
    )
{
    if (Depth > 0)
        {
        if (Depth == Breadth)
            {
            Count = SylviaCallUserCode(Depth-1,Breadth,Count);
            }
        else
            Count = SylviaCallback(Depth-1,Breadth,Count);
        }
    return(Count+1);
}

void __RPC_STUB
SylviaCall (
    PRPC_MESSAGE Callee
    )
{
    unsigned /*long*/ char ReturnValue, *plScan;

    if ( Callee->ProcNum != 0 )
        {
        OtherError("SylviaCall", "Callee->ProcNum != 0");
        SylviaError();
        }

    if ( memcmp(Callee->RpcInterfaceInformation, &SylviaInterfaceInformation,
                sizeof(SylviaInterfaceInformation)) != 0 )
        {
        OtherError("SylviaCall",
                "Callee->RpcInteraceInformation != &SylviaInterfaceInformation");
        SylviaError();
        }

    if (Callee->BufferLength != sizeof(unsigned /*long*/ char)*4+10240)
        {
        OtherError("SylviaCall","*BufferLength != sizeof(unsigned  char)*4");
        SylviaError();
        }

    plScan = (unsigned /*long*/ char *) Callee->Buffer;

//    if (   SylviaQueryCall
//        && VerifyQueryCall(Callee->Handle,&SylviaProtocolStack))
//        {
//        OtherError("SylviaCallback","VerifyQueryCall");
//        SylviaError();
//        }

//    if (   SylviaQueryBinding
//        && VerifyQueryBinding(Callee->Handle,SylviaServer))
//        {
//        OtherError("SylviaCallback","VerifyQueryBinding");
//        SylviaError();
//        }

//    if (   SylviaQueryProtocolStack
//        && VerifyQueryProtocolStack(Callee->Handle,&SylviaProtocolStack,
//                        SylviaTransportInfo))
//        {
//        OtherError("SylviaCallback","VerifyQueryProtocolStack");
//        SylviaError();
//        }

    ReturnValue = (unsigned char) SylviaCallUserCode(plScan[0],plScan[1],plScan[2]);

//    if (   SylviaQueryCall
//        && VerifyQueryCall(Callee->Handle,&SylviaProtocolStack))
//        {
//        OtherError("SylviaCallback","VerifyQueryCall");
//        SylviaError();
//        }

//    if (   SylviaQueryBinding
//        && VerifyQueryBinding(Callee->Handle,SylviaServer))
//        {
//        OtherError("SylviaCallback","VerifyQueryBinding");
//        SylviaError();
//        }

//    if (   SylviaQueryProtocolStack
//        && VerifyQueryProtocolStack(Callee->Handle,&SylviaProtocolStack,
//                        SylviaTransportInfo))
//        {
//        OtherError("SylviaCallback","VerifyQueryProtocolStack");
//        SylviaError();
//        }

    Callee->BufferLength = sizeof(unsigned /*long*/ char);
    Status = I_RpcGetBuffer((PRPC_MESSAGE) Callee);
    if (Status)
        {
        ApiError("SylviaCall","I_RpcGetBuffer",Status);
        SylviaError();
        }
    plScan = (unsigned /*long*/ char *) Callee->Buffer;
    *plScan = ReturnValue;
}

RPC_DISPATCH_FUNCTION SylviaDispatchFunction[] = {SylviaCall};
RPC_DISPATCH_TABLE SylviaDispatchTable =
{
    1, SylviaDispatchFunction
};

/* --------------------------------------------------------------------

Isabelle Interface

-------------------------------------------------------------------- */


extern RPC_DISPATCH_TABLE IsabelleDispatchTable;

RPC_PROTSEQ_ENDPOINT IsabelleRpcProtseqEndpoint[] =
{
    {(unsigned char *) "ncacn_np",
#ifdef WIN32RPC
     (unsigned char *) "\\pipe\\zippyis"},
#else // WIN32RPC
     (unsigned char *) "\\device\\namedpipe\\christopherisabelle"},
#endif // WIN32RPC
    {(unsigned char *) "ncacn_ip_tcp",(unsigned char *) "2040"},
    {(unsigned char *) "ncadg_ip_udp",(unsigned char *) "2040"},
    {(unsigned char *) "ncalrpc",(unsigned char *) "christopherisabelle"},
    {(unsigned char *) "ncacn_nb_nb",(unsigned char *) "212"},
    {(unsigned char *) "ncacn_nb_tcp",(unsigned char *) "213"},
    {(unsigned char *) "ncacn_nb_ipx",(unsigned char *) "214"},
    {(unsigned char *) "ncacn_spx",(unsigned char *) "5015"},
    {(unsigned char *) "ncadg_ipx",(unsigned char *) "5015"},
    {(unsigned char *) "ncacn_vns_spp",(unsigned char *) "265"},
    {(unsigned char *) "ncacn_at_dsp", (unsigned char *) "\\pipe\\zippyis"},
    {(unsigned char *) "ncadg_mq", (unsigned char *) "christopherisabelle"}
};

RPC_SERVER_INTERFACE IsabelleInterfaceInformation =
{
    sizeof(RPC_SERVER_INTERFACE),
    {{9,8,8,{7,7,7,7,7,7,7,7}},
     {1,1}},
    {{0x8A885D04, 0x1CEB, 0x11C9, {0x9F, 0xE8, 0x08, 0x00, 0x2B, 0x10, 0x48, 0x60}},
     {2, 0}},
    &IsabelleDispatchTable,
    sizeof(IsabelleRpcProtseqEndpoint) / sizeof(RPC_PROTSEQ_ENDPOINT),
    IsabelleRpcProtseqEndpoint,
    0,
    0,
    RPC_INTERFACE_HAS_PIPES
};

void __RPC_STUB
IsabelleShutdown (
    PRPC_MESSAGE Callee
    )
{
    RPC_BINDING_HANDLE BindingHandle;
    unsigned char PAPI * StringBinding;
    unsigned int ClientLocalFlag = 0;
    RPC_STATUS IsClientLocalStatus;

    CompleteReceive(Callee) ;

    Status = I_RpcBindingIsClientLocal(0, &ClientLocalFlag);
    if ( (IsClientLocalStatus = Status) != RPC_S_CANNOT_SUPPORT )
        {
        if ( Status != RPC_S_OK )
            {
            ApiError("IsabelleShutdown", "I_RpcBindingIsClientLocal", Status);
            IsabelleError();
            }
        }

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleShutdown","*BufferLength != 0");
        IsabelleError();
        }

    if (AutoListenFlag == 0)
        {
        Status = RpcMgmtIsServerListening(0);
        if (Status)
            {
            ApiError("IsabelleShutdown", "RpcMgmtIsServerListening", Status);
            IsabelleError();
            }
        }

    Status = RpcBindingServerFromClient(Callee->Handle, &BindingHandle);
    if (Status)
        {
        if ( Status != RPC_S_CANNOT_SUPPORT && (DatagramFlag == 0) )
            {
            ApiError("IsabelleShutdown", "RpcBindingServerFromClient", Status);
            IsabelleError();
            }

        if(IsClientLocalStatus == RPC_S_OK)
           {
               if ( ClientLocalFlag != 0 )
                 PrintToConsole("Local Client\n");
               else
                 PrintToConsole("Remote Client\n");
           }
        }
    else
        {
        Status = RpcBindingToStringBindingA(BindingHandle, &StringBinding);
        if (Status)
            {
            ApiError("IsabelleShutdown", "RpcBindingToStringBinding", Status);
            IsabelleError();
            }
        else
            {
            if ( ClientLocalFlag != 0 )
                {
                PrintToConsole("Local Client [%s]\n", StringBinding);
                }
            else
                {
                PrintToConsole("Remote Client [%s]\n", StringBinding);
                }
            RpcStringFreeA(&StringBinding);
            RpcBindingFree(&BindingHandle);
            }
        }

    Shutdown();

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleShutdown","I_RpcGetBuffer",Status);
        IsabelleError();
        }
}


void __RPC_STUB
IsabelleNtSecurity (
    PRPC_MESSAGE CalleeMessage
    )
/*++

Routine Description:

    A client will call this routine with some quality of service
    specified.  The server will impersonate the client and check
    that the impersonation level is that specified.  The request
    buffer will contain the network options passed by the client
    to RpcBindingFromStringBinding.

Arguments:

    CalleeMessage - Supplies the request message and returns the
        response message for the remote procedure call.

--*/
{
    RPC_STATUS Status;

    Status = RpcImpersonateClient(0);
    if (Status != RPC_S_OK)
        {
        ApiError("IsabelleNtSecurity","RpcImpersonateClient",Status);
        IsabelleError();
        }
    else
        {
        Status = RpcRevertToSelf();
        if (Status != RPC_S_OK)
            {
            ApiError("IsabelleNtSecurity","RpcRevertToSelf",Status);
            IsabelleError();
            }
        else
            {
            Status = RpcImpersonateClient(CalleeMessage->Handle);
            if (Status != RPC_S_OK)
                {
                ApiError("IsabelleNtSecurity","RpcImpersonateClient",
                        Status);
                IsabelleError();
                }
            else
                {
                Status = RpcRevertToSelf();
                if (Status != RPC_S_OK)
                    {
                    ApiError("IsabelleNtSecurity","RpcRevertToSelf",Status);
                    IsabelleError();
                    }
                }
            }
        }

    CalleeMessage->BufferLength = 0;
    Status = I_RpcGetBuffer(CalleeMessage);

    if (Status)
        {
        ApiError("IsabelleNtSecurity","I_RpcGetBuffer",Status);
        IsabelleError();
        }

}

int ChristopherIsabelleError;

void __RPC_STUB
IsabelleToStringBinding (
    PRPC_MESSAGE Callee
    )
{
    unsigned char PAPI * StringBinding;

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleToStringBinding","*BufferLength != 0");
        IsabelleError();
        }

    Status = RpcBindingToStringBindingA(Callee->Handle, &StringBinding);
    if (Status)
        {
        ApiError("Christopher","RpcBindingToStringBinding",Status);
        PrintToConsole("Christopher : FAIL - RpcBindingToStringBinding\n");
        ChristopherIsabelleError = 1;
        }
    else
        {
        PrintToConsole("Christopher : (RpcBindingToStringBinding)\n    ");
        PrintToConsole((char *) StringBinding);
        PrintToConsole("\n");

        Status = RpcStringFreeA(&StringBinding);
        if (Status)
            {
            ApiError("Christopher","RpcStringFree",Status);
            PrintToConsole("Christopher : FAIl - RpcStringFree\n");
            ChristopherIsabelleError = 1;
            }
        else
            {
            if (StringBinding != 0)
                {
                PrintToConsole("Christopher : FAIL - ");
                PrintToConsole("StringBinding != 0\n");
                ChristopherIsabelleError = 1;
                }
            }
        }

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("Christopher","I_RpcGetBuffer",Status);
        HelgaError();
        }
}

#define RICHARDHELPER_EXIT 1
#define RICHARDHELPER_EXECUTE 2
#define RICHARDHELPER_IGNORE 3
#define RICHARDHELPER_DELAY_EXIT 4


void
RichardHelperExit (
    void * Ignore
    )
{
    PauseExecution(2000L);
    PrintToConsole("Richard : RichardHelper Exiting\n");

#ifdef WIN32RPC

    ExitProcess(0);

#endif // WIN32RPC
}


void __RPC_STUB
IsabelleRichardHelper (
    PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    This routine is the stub (and actually the manager code as well) for
    the IsabelleRichardHelper routine.  The client will call a stub and
    specify a command argument which will be passed in the buffer.  We
    need to extract the argument, and then execute the requested command.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    unsigned /*long*/ char Command;
    RPC_STATUS RpcStatus = RPC_S_OK;

    if (   Callee->BufferLength != sizeof(unsigned char)
        && Callee->BufferLength != sizeof(unsigned long) )
        {
        OtherError("IsabelleRichardHelper",
                "*BufferLength != sizeof(unsigned long)");
        IsabelleError();
        Callee->BufferLength = 0;

         Status = I_RpcGetBuffer(Callee);

        if (Status)
            {
            ApiError("IsabelleRichardHelper","I_RpcGetBuffer",Status);
            IsabelleError();
            }
        return;
        }

    Command = *((unsigned char *) Callee->Buffer);

    if (Command == RICHARDHELPER_EXIT)
        {
        PrintToConsole("Richard : RichardHelper Exiting\n");
#ifdef OS2_12
        DosExit(EXIT_PROCESS, 0);

#endif // OS2_12

#ifdef WIN32RPC

        ExitProcess(0);

#endif // WIN32RPC
        }
    else if (Command == RICHARDHELPER_EXECUTE)
        {
#ifdef OS2_12

        USHORT Os2Status;
        RESULTCODES ResultCodes;
        char CommandLine[200], *pT;

        pT = CommandLine;
        *pT = 0;

        pT += strlen(strcpy(pT, "usvr")) + 1;
        pT += strlen(strcpy(pT, TransportOption));
        pT += strlen(strcpy(pT, "-error -richardhelper")) + 1;
        *pT = 0;

        Os2Status = DosExecPgm(0,0,EXEC_ASYNC, (unsigned char *)CommandLine, 0,
                &ResultCodes,(unsigned char *)"usvr.exe");
        if (Os2Status != 0)
            {
            OtherError("IsabelleRichardHelper","DosExecPgm Failed");
            IsabelleError();
            }

#endif // OS2_12

#ifdef WIN32RPC

        PROCESS_INFORMATION ProcessInformation;
        STARTUPINFOA StartupInfo;

        StartupInfo.cb = sizeof(STARTUPINFOA);
        StartupInfo.lpReserved = 0;
        StartupInfo.lpDesktop = 0;
        StartupInfo.lpTitle = 0;
        StartupInfo.dwX = 0;
        StartupInfo.dwY = 0;
        StartupInfo.dwXSize = 0;
        StartupInfo.dwYSize = 0;
        StartupInfo.dwFlags = 0;
        StartupInfo.wShowWindow = 0;
        StartupInfo.cbReserved2 = 0;
        StartupInfo.lpReserved2 = 0;

        char CommandLine[200];

    PrintToConsole("Spawning richardhelper\n") ;
        strcpy(CommandLine, "usvr ");
        strcat(CommandLine, TransportOption);

        strcat(CommandLine, " -richardhelper");

        if (CreateProcessA(0, CommandLine, 0, 0, FALSE,
                0, 0, 0, &StartupInfo, &ProcessInformation) == FALSE)
            {
            OtherError("IsabelleRichardHelper","CreateProcessA Failed");
            IsabelleError();
            }

#endif // WIN32RPC
        }
    else if (Command == RICHARDHELPER_DELAY_EXIT)
        {
        HANDLE HandleToThread ;
        unsigned long ThreadIdentifier;

        HandleToThread = CreateThread(
                                    0,
                                    0,
                                    (LPTHREAD_START_ROUTINE) RichardHelperExit,
                                    0,
                                    0,
                                    &ThreadIdentifier);

        if (HandleToThread == 0)
            {
            OtherError("IsabelleRichardHelper","Can Not Create Thread");
            IsabelleError();
            }
        }
    else if (Command != RICHARDHELPER_IGNORE)
        {
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        OtherError("IsabelleRichardHelper","Unknown Command Requested");
        IsabelleError();
        }

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleRichardHelper","I_RpcGetBuffer",Status);
        }

}


void __RPC_STUB
IsabelleRaiseException (
    PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    This routine is the stub (and actually the manager code as well) for
    the IsabelleRaiseException routine.  The client will call a stub and
    specify an exception to be raised which will be passed in the buffer.  We
    need to extract the argument, and then raise the exception.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    unsigned /*long*/ char Exception;

    CompleteReceive(Callee) ;

    if (   Callee->BufferLength != sizeof(unsigned long)
        && Callee->BufferLength != sizeof(unsigned char) )
        {
        OtherError("IsabelleRaiseException",
                "*BufferLength != 1 or 4");
        IsabelleError();
        Callee->BufferLength = 0;

        Status = I_RpcGetBuffer(Callee);

        if (Status)
            {
            ApiError("IsabelleRaiseException","I_RpcGetBuffer",Status);
            IsabelleError();
            }
        return;
        }

    Exception = *((unsigned /*long*/ char *) Callee->Buffer);

    RpcRaiseException((RPC_STATUS) Exception);

    // This should never be reached.

    OtherError("IsabelleRaiseException", "RpcRaiseException Failed");
    IsabelleError();

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleRaiseException","I_RpcGetBuffer",Status);
        }

}

unsigned int IsabelleRundownFlag = 0;
void PAPI * IsabelleAssociationContext = 0;


void __RPC_STUB
IsabelleRundownRoutine (
    IN void PAPI * AssociationContext
    )
/*++

Routine Description:

    This routine will get called when the association closes.  We just
    need to check that the association context is correct, and then
    note that we got called.

Arguments:

    AssociationContext - Supplies the association context for the association
        which closed.

--*/
{
    if (AssociationContext == IsabelleAssociationContext)
        IsabelleRundownFlag += 1;
}


void __RPC_STUB
IsabelleSetRundown (
    IN PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    We want to set an association context in this routine, and a rundown
    routine.  The rundown will set a flag when it is called.  Later, the
    client, will call another routine to check to set the flag has been
    set.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    CompleteReceive(Callee) ;

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleSetException", "*BufferLength != 0");
        IsabelleError();
        }

    IsabelleRundownFlag = 0;
    IsabelleAssociationContext = Callee->Buffer;

    Status = I_RpcMonitorAssociation(Callee->Handle, IsabelleRundownRoutine,
            IsabelleAssociationContext);
    if (Status)
        {
        ApiError("IsabelleSetRundown","I_RpcMonitorAssociation",Status);
        IsabelleError();
        }

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleSetRundown","I_RpcGetBuffer",Status);
        }

}


void __RPC_STUB
IsabelleCheckRundown (
    PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    This routine will be called to check that context rundown did, in
    fact, occur.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    CompleteReceive(Callee) ;

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleCheckRundown", "*BufferLength != 0");
        IsabelleError();
        }

    if (0 == DatagramFlag)
        {
        if (IsabelleRundownFlag != 1)
            {
            OtherError("IsabelleCheckRundown", "IsabelleRundownFlag != 1");
            IsabelleError();
            }
        }

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleCheckRundown","I_RpcGetBuffer",Status);
        }

}


void __RPC_STUB
IsabelleCheckNoRundown (
    PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    This routine will be called to check that context rundown did not
    occur.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    CompleteReceive(Callee) ;

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleCheckNoRundown", "*BufferLength != 0");
        IsabelleError();
        }

    if (IsabelleRundownFlag == 1)
        {
        OtherError("IsabelleCheckNoRundown", "IsabelleRundownFlag == 1");
        IsabelleError();
        }

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleCheckNoRundown","I_RpcGetBuffer",Status);
        }

}


void __RPC_STUB
IsabelleCheckContext (
    PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    This routine will be called to check the context for an association,
    and then to set a new context.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    void PAPI * Context;

    CompleteReceive(Callee) ;

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleCheckContext", "*BufferLength != 0");
        IsabelleError();
        }

    Status = I_RpcGetAssociationContext(Callee->Handle, &Context);
    if (Status)
        {
        ApiError("IsabelleCheckContext", "I_RpcGetAssociationContext",
                Status);
        IsabelleError();

        Callee->BufferLength = 0;

        Status = I_RpcGetBuffer(Callee);

        if (Status)
            {
            ApiError("IsabelleCheckContext","I_RpcGetBuffer",Status);
            IsabelleError();
            }

        return;
        }

    if (Context != IsabelleAssociationContext)
        {
        OtherError("IsabelleCheckContext",
                "Context != IsabelleAssociationContext");
        IsabelleError();

        Callee->BufferLength = 0;

        Status = I_RpcGetBuffer(Callee);

        if (Status)
            {
            ApiError("IsabelleCheckContext","I_RpcGetBuffer",Status);
            IsabelleError();
            }
        return;
        }

    Callee->BufferLength = 0;
    Status = I_RpcGetBuffer(Callee);

    if (Status)
        {
        ApiError("IsabelleCheckContext","I_RpcGetBuffer",Status);
        }

}

RPC_BINDING_VECTOR * BartholomewRpcBindingVector;
unsigned int BartholomewIndex;


unsigned char *
UnicodeToAnsiString (
    IN RPC_CHAR * WideCharString,
    OUT RPC_STATUS * RpcStatus
    )
/*++

Routine Description:

    This routine will convert a unicode string into an ansi string,
    including allocating memory for the ansi string.

Arguments:

    WideCharString - Supplies the unicode string to be converted into
        an ansi string.

    RpcStatus - Returns the status of the operation; this will be one
        of the following values.

        RPC_S_OK - The unicode string has successfully been converted
            into an ansi string.

        RPC_S_OUT_OF_MEMORY - Insufficient memory is available to allocate
            the ansi string.

Return Value:

    A pointer to the ansi string will be returned.

--*/
{
    NTSTATUS NtStatus;
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;
    unsigned char * NewString;

    RtlInitUnicodeString(&UnicodeString,WideCharString);
    NtStatus = RtlUnicodeStringToAnsiString(&AnsiString,&UnicodeString,TRUE);
    if (!NT_SUCCESS(NtStatus))
        {
        *RpcStatus = RPC_S_OUT_OF_MEMORY;
        return(0);
        }

    NewString = new unsigned char[AnsiString.Length + 1];
    if (NewString == 0)
        {
        RtlFreeAnsiString(&AnsiString);
        *RpcStatus = RPC_S_OUT_OF_MEMORY;
        return(0);
        }

    memcpy(NewString,AnsiString.Buffer,AnsiString.Length + 1);
    RtlFreeAnsiString(&AnsiString);
    *RpcStatus = RPC_S_OK;
    return(NewString);
}


unsigned char PAPI *
StringBindingWithDynamicEndpoint (
    IN unsigned char PAPI * StringBinding,
    IN RPC_CHAR PAPI * DynamicEndpoint
    )
/*++

Routine Description:

    This routine adds the dynamic endpoint to the string binding.  A
    new string binding will be returned, and the supplied string binding
    and dynamic endpoint will be freed.

Arguments:

    StringBinding - Supplies the string binding to which the dynamic
        endpoint should be added.

    DynamicEndpoint - Supplies the dynamic endpoint.

Return Value:

    A new string binding will be returned which contains the dynamic
    endpoint if the operation is successful; otherwise, zero will be
    returned.

--*/
{
    unsigned char PAPI * ObjectUuid;
    unsigned char PAPI * RpcProtocolSequence;
    unsigned char PAPI * NetworkAddress;
    unsigned char PAPI * Endpoint;
    unsigned char PAPI * NetworkOptions;

    Status = RpcStringBindingParseA(StringBinding, &ObjectUuid,
            &RpcProtocolSequence, &NetworkAddress, &Endpoint,
            &NetworkOptions);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint",
                "RpcStringBindingParse", Status);
        return(0);
        }

    Status = RpcStringFreeA(&StringBinding);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFree", Status);
        return(0);
        }

    Status = RpcStringFreeA(&Endpoint);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFree", Status);
        return(0);
        }

    Endpoint = UnicodeToAnsiString(DynamicEndpoint, &Status);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "UnicodeToAnsiString",
                Status);
        return(0);
        }

    Status = RpcStringFreeW(&DynamicEndpoint);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFreeW",
                Status);
        return(0);
        }

    Status = RpcStringBindingComposeA(ObjectUuid, RpcProtocolSequence,
            NetworkAddress, Endpoint, NetworkOptions, &StringBinding);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint",
                "RpcStringBindingCompose", Status);
        return(0);
        }

    delete Endpoint;

    Status = RpcStringFreeA(&ObjectUuid);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFree", Status);
        return(0);
        }

    Status = RpcStringFreeA(&RpcProtocolSequence);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFree", Status);
        return(0);
        }

    Status = RpcStringFreeA(&NetworkAddress);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFree", Status);
        return(0);
        }

    Status = RpcStringFreeA(&NetworkOptions);
    if (Status)
        {
        ApiError("StringBindingWithDynamicEndpoint", "RpcStringFree", Status);
        return(0);
        }

    return(StringBinding);
}


void __RPC_STUB
IsabelleGetStringBinding (
    PRPC_MESSAGE Callee
    )
/*++

Routine Description:

    This routine will be called to obtain a string binding for one of
    the protocol sequences supported by this server.

Arguments:

    Callee - Supplies the input arguments and returns the output arguments
        and return value for the stub.

--*/
{
    unsigned char * StringBinding;
    WCHAR * DynamicEndpointW;
        RPC_CHAR *DynamicEndpoint;
    unsigned int TransportType ;
    unsigned int CurTransportType;

    CompleteReceive(Callee) ;

    while (BartholomewRpcBindingVector == 0)
        {
        Sleep(100);
        }

    if (Callee->BufferLength != 0)
        {
        OtherError("IsabelleGetStringBinding", "*BufferLength != 0");
        IsabelleError();
        }

    Status = I_RpcBindingInqTransportType(Callee->Handle, &TransportType);

    if (Status)
        {
        ApiError("IsabelleGetStringBinding", "I_RpcBindingInqTransportType", Status);
        IsabelleError();
        return;
        }

    if (TransportType != TRANSPORT_TYPE_LPC)
        {
        while (BartholomewIndex < BartholomewRpcBindingVector->Count)
            {
            Status = I_RpcBindingInqTransportType(
                            BartholomewRpcBindingVector->BindingH[BartholomewIndex],
                            &CurTransportType);

            if (Status)
                {
                ApiError("IsabelleGetStringBinding",
                         "I_RpcBindingInqTransportType", Status);
                IsabelleError();
                return;
                }

            if (CurTransportType == TRANSPORT_TYPE_LPC)
                {
                BartholomewIndex ++;
                continue;
                }
            break;
            }
        }

    if (BartholomewIndex < BartholomewRpcBindingVector->Count)
        {
        Status = RpcBindingToStringBindingA(
                BartholomewRpcBindingVector->BindingH[BartholomewIndex],
                &StringBinding);
        if (Status)
            {
            ApiError("IsabelleGetStringBinding", "RpcBindingToStringBinding",
                    Status);
            IsabelleError();
            Callee->BufferLength = 0;

            Status = I_RpcGetBuffer(Callee);

            if (Status)
                {
                ApiError("IsabelleGetStringBinding","I_RpcGetBuffer",Status);
                IsabelleError();
                }
            return;
            }

        Status = I_RpcBindingInqDynamicEndpointW(
                BartholomewRpcBindingVector->BindingH[BartholomewIndex],
                &DynamicEndpointW);
        if (Status)
            {
            ApiError("IsabelleGetStringBinding",
                    "I_RpcBindingInqDynamicEndpoint", Status);
            IsabelleError();
            Callee->BufferLength = 0;

            Status = I_RpcGetBuffer(Callee);

            if (Status)
                {
                ApiError("IsabelleGetStringBinding","I_RpcGetBuffer",Status);
                IsabelleError();
                }
            return;
            }

        DynamicEndpoint = DynamicEndpointW;

        if (DynamicEndpoint != 0)
            {

            StringBinding = StringBindingWithDynamicEndpoint(StringBinding,
                    DynamicEndpoint);
            if (StringBinding == 0)
                {
                OtherError("IsabelleGetStringBinding",
                        "StringBinding == 0");
                IsabelleError();
                Callee->BufferLength = 0;

                Status = I_RpcGetBuffer(Callee);

                if (Status)
                    {
                    ApiError("IsabelleGetStringBinding","I_RpcGetBuffer",Status);
                    IsabelleError();
                    }
                return;
                }
            }

        Callee->BufferLength = strlen((char PAPI *) StringBinding) + 1;

        Status = I_RpcGetBuffer(Callee);
        if (Status)
            {
            ApiError("IsabelleGetStringBinding", "I_RpcGetBuffer", Status);
            IsabelleError();
            return;
            }

        memcpy(Callee->Buffer, StringBinding,
                strlen((char PAPI *) StringBinding) + 1);

        Status = RpcStringFreeA(&StringBinding);
        if (Status)
            {
            ApiError("IsabelleGetStringBinding", "RpcStringFree", Status);
            IsabelleError();
            return;
            }

        BartholomewIndex += 1;
        }
    else
        {
        Callee->BufferLength = 0;

        Status = I_RpcGetBuffer(Callee);

        if (Status)
            {
            ApiError("IsabelleGetStringBinding","I_RpcGetBuffer",Status);
            IsabelleError();
            }
        return;
        }
}

void IsabelleUnregisterInterfaces(
    PRPC_MESSAGE Callee
    )
{
    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("IsabelleUnregsterInterface","RpcServerUnregisterIf",Status);
        PrintToConsole("IsabelleUnregsterInterfaces : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }
}

void IsabelleRegisterInterfaces(
    PRPC_MESSAGE Callee
    )
{
    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0,0);
    if (Status)
        {
        ApiError("Hybrid","stub_RegisterIf",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("Hybrid","stub_RegisterIf",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }
}

void PipeAlloc(
    PIPE_STATE *state,
    int requested_size,
    pipe_element_t **allocated_buf,
    int *allocated_size)
{
    if (state->BufferSize < requested_size)
        {
        if (state->AllocatedBuffer)
            {
            I_RpcFree(state->AllocatedBuffer) ;
            }

        state->AllocatedBuffer =  I_RpcAllocate(requested_size) ;
        if (state->AllocatedBuffer == 0)
            {
            *allocated_size = 0 ;
            state->BufferSize = 0 ;
            }
        else
            {
            *allocated_size = requested_size ;
            state->BufferSize = requested_size ;
            }

        *allocated_buf = (pipe_element_t *) state->AllocatedBuffer ;
        }
    else
        {
        *allocated_buf = (pipe_element_t *) state->AllocatedBuffer ;
        *allocated_size = state->BufferSize ;
        }
}

void PipePull(
    PIPE_STATE *state,
    pipe_element_t *buffer,
    int ecount,
    int *actual_transfer_count
    )
{
    int num_elements = 0;
    DWORD size = (DWORD) ecount * state->PipeElementSize ;
    RPC_MESSAGE Callee ;

    *actual_transfer_count = 0 ;

    if (state->EndOfPipe)
        {
        return ;
        }

    I_RpcReadPipeElementsFromBuffer(state, (char *) buffer, size, &num_elements) ;
    *actual_transfer_count += num_elements ;
    size -= num_elements * state->PipeElementSize ;

    if (state->EndOfPipe == 0 &&
        num_elements < ecount)
        {
        Callee.RpcFlags = RPC_BUFFER_PARTIAL ;

        Callee.Buffer = state->Buffer ;
        Callee.BufferLength = state->BufferLength ;

        Status = I_RpcReceive(&Callee, size) ;
        if (Status)
            {
            ApiError("PipePull", "I_RpcReceive", Status) ;
            num_elements = 0 ;
            return ;
            }

        state->Buffer = Callee.Buffer ;
        state->BufferLength = Callee.BufferLength ;
        state->CurPointer = (char *) Callee.Buffer ;
        state->BytesRemaining = Callee.BufferLength ;

        buffer = (pipe_element_t *)
                    ((char *) buffer + num_elements * state->PipeElementSize) ;

        num_elements = 0 ;
        I_RpcReadPipeElementsFromBuffer(state,
                                (char *) buffer, size, &num_elements) ;
        *actual_transfer_count += num_elements ;
        }
}

void PipePush(
    PIPE_STATE *state,
    pipe_element_t *buffer,
    int count
    )
{
    RPC_MESSAGE TempBuf ;
    int size = count * state->PipeElementSize + sizeof(DWORD) ;
    char *temp ;
    RPC_MESSAGE Callee ;

    Callee.Buffer = state->Buffer ;
    Callee.BufferLength = state->BufferLength ;
    Callee.Handle = state->BindingHandle;

    Status = I_RpcReallocPipeBuffer(&Callee, size+state->SendBufferOffset) ;
    if (Status)
        {
        ApiError("PipePush", "I_RpcGetBuffer", Status) ;
        return ;
        }

    temp = (char *) Callee.Buffer+state->SendBufferOffset ;

    *((DWORD *) temp) = count ;
    RpcpMemoryCopy(temp+sizeof(DWORD),
                               buffer, count * state->PipeElementSize) ;

    Callee.RpcFlags = RPC_BUFFER_PARTIAL ;

    Status = I_RpcSend(&Callee) ;
    if (Status == RPC_S_SEND_INCOMPLETE)
        {
        state->SendBufferOffset = Callee.BufferLength ;
        }
    else if (Status)
        {
        ApiError("PipePush", "I_RpcSend", Status) ;
        state->SendBufferOffset = 0 ;
        return;
        }
    else
        {
        state->SendBufferOffset = 0 ;
        }
}

void IsabelleMgrIN(
    pipe_t *pipe,
    int chunksize,
    int numchunks,
    int checksum,
    int buffsize,
    char *buffer
    )
{
    static pipe_element_t local_buf[CHUNK_SIZE] ;
    int num_elements ;
    int i, j ;
    int localchecksum = 0;

    PrintToConsole("IsabelleMgrIN: client chunk size: %d\n", chunksize) ;
    PrintToConsole("IsabelleMgrIN: client number of chunks: %d\n", numchunks) ;
    PrintToConsole("IsabelleMgrIN: buffer size: %d\n", buffsize) ;
    PrintToConsole("IsabelleMgrIN: checksum: %d\n", checksum) ;

    do
         {
         pipe->Pull(pipe->state,
                        local_buf,
                        CHUNK_SIZE,
                        &num_elements
                        ) ;

         for (i = 0; i <num_elements; i++)
             {
             localchecksum += local_buf[i] ;
             }
         }
     while ( num_elements > 0  );

     if (localchecksum != checksum)
         {
         IsabelleError() ;
         PrintToConsole("IsabelleMgrIN: checksums don't match\n") ;
         }
}

void IsabellePipeIN(
    PRPC_MESSAGE Callee
    )
{
    pipe_t mypipe ;
    PIPE_STATE pipestate ;
    pipe_element_t pipe_element ;
    DWORD size = 3* sizeof(int)  ;
    int chunksize, numchunks, checksum, buffsize ;
    char *buffer, *temp ;
    void *savedbuffer ;

    PrintToConsole("IsabellePipeIN called\n") ;

    if (!(Callee->RpcFlags & RPC_BUFFER_COMPLETE) &&
        Callee->BufferLength < size)
        {
        Callee->RpcFlags |= (RPC_BUFFER_PARTIAL | RPC_BUFFER_EXTRA) ;
        size = size - Callee->BufferLength ;

        Status = I_RpcReceive(Callee, size) ;
        if (Status)
            {
            ApiError("PipePull", "I_RpcReceive", Status) ;
            return ;
            }
        }

    temp = (char *) Callee->Buffer ;

    chunksize = *((int *) temp) ;
    temp += sizeof(int) ;

    numchunks = *((int *) temp) ;
    temp += sizeof(int) ;

    checksum = *((int *) temp) ;
    temp += sizeof(int) ;

    buffsize = *((int *) temp) ;
    temp += sizeof(int) ;

    size = 4 * sizeof(int) + buffsize + sizeof(DWORD) ;

    if (!(Callee->RpcFlags & RPC_BUFFER_COMPLETE) &&
        Callee->BufferLength < size)
        {
        Callee->RpcFlags |= (RPC_BUFFER_PARTIAL | RPC_BUFFER_EXTRA) ;
        size = size - Callee->BufferLength ;

        Status = I_RpcReceive(Callee, size) ;
        if (Status)
            {
            ApiError("PipePull", "I_RpcReceive", Status) ;
            return ;
            }
        }

    buffer = (char *) Callee->Buffer + 3 * sizeof(int) ;

    savedbuffer = Callee->Buffer ;
    Callee->Buffer = 0;

    pipestate.Buffer = Callee->Buffer ;
    pipestate.BufferLength = Callee->BufferLength ;
    pipestate.CurrentState = start ;
    pipestate.CurPointer = (char *) buffer+buffsize ;
    pipestate.BytesRemaining = Callee->BufferLength - 3 * sizeof(int) - buffsize ;
    pipestate.EndOfPipe = 0 ;
    pipestate.PipeElementSize = sizeof(pipe_element_t) ;
    pipestate.PartialPipeElement = &pipe_element ;
    pipestate.AllocatedBuffer = 0 ;
    pipestate.BufferSize = 0 ;

    mypipe.Pull = PipePull ;
    mypipe.Push = PipePush ;
    mypipe.state = &pipestate ;

    IsabelleMgrIN(&mypipe, chunksize, numchunks, checksum, buffsize, buffer) ;

    Callee->Buffer = savedbuffer ;
 }

void IsabelleMgrOUT(
    pipe_t *pipe,
    int *chunksize,
    int *numchunks,
    int *checksum,
    int *buffsize,
    char **buffer
    )
{
    static pipe_element_t local_buf[CHUNK_SIZE] ;
    static int buf[BUFF_SIZE] ;
    int i ;
    char j = 0;
    int localchecksum = 0;

    PrintToConsole("IsabelleMgrOUT called\n") ;

    for (i = 0; i < CHUNK_SIZE; i++, j++)
        {
        RpcpMemorySet((char *) &(local_buf[i]), j, sizeof(pipe_element_t)) ;
        localchecksum += local_buf[i] ;
        }

    for (i = 0; i < NUM_CHUNKS; i++)
        {
        pipe->Push(pipe->state,
                        local_buf,
                        CHUNK_SIZE
                        ) ;
        }
    pipe->Push(pipe->state, local_buf, 0) ;

    for (i = 0; i < BUFF_SIZE; i++)
        {
        local_buf[i] = i ;
        }

    *chunksize = CHUNK_SIZE ;
    *numchunks = NUM_CHUNKS ;
    *checksum = localchecksum * NUM_CHUNKS;
    *buffsize = BUFF_SIZE ;
    *buffer = (char *) buf ;
}

void IsabellePipeOUT(
    PRPC_MESSAGE Callee
    )
{
    pipe_t mypipe ;
    char *Temp ;
    PIPE_STATE pipestate ;
    pipe_element_t pipe_element ;
    int size ;
    char *buffer ;
    int chunksize, numchunks, buffsize, checksum ;
    RPC_MESSAGE TempBuffer ;
    void *savedbuffer ;

    PrintToConsole("IsabellePipeOUT called\n") ;

    pipestate.Buffer = Callee->Buffer ;
    pipestate.BufferLength = Callee->BufferLength ;
    pipestate.CurrentState = start ;
    pipestate.CurPointer = (char *) Callee->Buffer ;
    pipestate.BytesRemaining = Callee->BufferLength ;
    pipestate.EndOfPipe = 0 ;
    pipestate.PipeElementSize = sizeof(pipe_element_t) ;
    pipestate.PartialPipeElement = &pipe_element ;
    pipestate.AllocatedBuffer = 0 ;
    pipestate.BufferSize = 0 ;
    pipestate.SendBufferOffset = 0 ;
    pipestate.BindingHandle = Callee->Handle;

    Callee->Buffer = 0;

    mypipe.Pull = PipePull ;
    mypipe.Push = PipePush ;
    mypipe.state = &pipestate ;

    IsabelleMgrOUT(&mypipe, &chunksize, &numchunks, &checksum, &buffsize, &buffer) ;

    size = 3 *sizeof(int) + buffsize ;

    Status = I_RpcReallocPipeBuffer(Callee, size+pipestate.SendBufferOffset) ;
    if (Status)
        {
        ApiError("PipePull", "I_RpcReceive", Status) ;
        return ;
        }

    Temp = (char *) Callee->Buffer+pipestate.SendBufferOffset ;

    *((int *) Temp) = chunksize ;
    Temp += sizeof(int) ;

    *((int *) Temp) = numchunks ;
    Temp += sizeof(int) ;

    *((int *) Temp) = checksum ;
    Temp += sizeof(int) ;

    *((int *) Temp) = buffsize ;
    Temp += sizeof(int) ;

    RpcpMemoryCopy(Temp, buffer, buffsize) ;
}

void IsabelleMgrINOUT(
    pipe_t *pipe
    )
{
    int num_elements ;
    int i;
    char j = 0;
    static pipe_element_t local_buf[CHUNK_SIZE] ;
    char *PipeData ;
    int localchecksum = 0;
    int outchecksum = 0;

    do
         {
         pipe->Pull(pipe->state,
                        local_buf,
                        CHUNK_SIZE,
                        &num_elements
                        ) ;

         for (i = 0; i <num_elements; i++)
             {
             localchecksum += local_buf[i] ;
             }
         }
     while ( num_elements > 0  );

     PrintToConsole("IsabelleMgrINOUT: checksum (IN) = %d\n", localchecksum) ;

     for (i = 0; i < CHUNK_SIZE; i++, j++)
        {
        RpcpMemorySet((char *) &(local_buf[i]), j, sizeof(pipe_element_t)) ;
        outchecksum += local_buf[i] ;
        }

    PrintToConsole("IsabelleMgrINOUT: checksum (OUT) = %d\n",
                            outchecksum * NUM_CHUNKS) ;

     for (i = 0; i <NUM_CHUNKS; i++)
         {
         pipe->Push(pipe->state, local_buf, CHUNK_SIZE) ;
         }

     pipe->Push(pipe->state, local_buf, 0) ;
}

void IsabellePipeINOUT(
    PRPC_MESSAGE Callee
    )
{
    pipe_t mypipe ;
    PIPE_STATE pipestate ;
    pipe_element_t pipe_element ;
    DWORD size = sizeof(pipe_element_t) + sizeof(DWORD) ;

    PrintToConsole("IsabellePipeINOUT called\n") ;

    if (!(Callee->RpcFlags & RPC_BUFFER_COMPLETE) &&
        Callee->BufferLength < size)
        {
        Callee->RpcFlags |= (RPC_BUFFER_PARTIAL | RPC_BUFFER_EXTRA) ;
        size = size - Callee->BufferLength ;

        Status = I_RpcReceive(Callee, size) ;
        if (Status)
            {
            ApiError("PipePull", "I_RpcReceive", Status) ;
            return ;
            }
        }


    pipestate.Buffer = Callee->Buffer ;
    pipestate.BufferLength = Callee->BufferLength ;
    pipestate.CurrentState = start ;
    pipestate.CurPointer = (char *) Callee->Buffer ;
    pipestate.BytesRemaining = Callee->BufferLength ;
    pipestate.EndOfPipe = 0 ;
    pipestate.PipeElementSize = sizeof(pipe_element_t) ;
    pipestate.PartialPipeElement = &pipe_element ;
    pipestate.AllocatedBuffer = 0 ;
    pipestate.BufferSize = 0 ;
    pipestate.SendBufferOffset = 0 ;

    Callee->Buffer = 0;

    mypipe.Pull = PipePull ;
    mypipe.Push = PipePush ;
    mypipe.state = &pipestate ;

    IsabelleMgrINOUT(&mypipe) ;
}

void GetServerType(
    PRPC_MESSAGE Callee
    )
{
    RPC_STATUS RpcStatus;
    OSVERSIONINFO *pOsVer;

    Callee->BufferLength = sizeof(OSVERSIONINFO);
    RpcStatus = I_RpcGetBuffer(Callee);
    if (RpcStatus != RPC_S_OK)
        {
        ApiError("Get Buffer", "I_RpcGetBuffer", Status) ;
        return ;
        }

    pOsVer = (OSVERSIONINFO *)Callee->Buffer;
    pOsVer->dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    GetVersionEx(pOsVer);
}

void UnregisterHelgaEx(
    PRPC_MESSAGE Callee
    )
{
    Status = RpcServerUnregisterIfEx(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, TRUE);
    if (Status)
        {
        ApiError("UnregisterHelgaEx","RpcServerUnregisterIfEx",Status);
        PrintToConsole("David : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }
}

RPC_DISPATCH_FUNCTION IsabelleDispatchFunction[] =
{
        IsabelleShutdown,
        IsabelleNtSecurity,
        IsabelleToStringBinding,
        IsabelleRichardHelper,
        IsabelleRaiseException,
        IsabelleSetRundown,
        IsabelleCheckRundown,
        IsabelleCheckContext,
        IsabelleGetStringBinding,
        IsabelleCheckNoRundown,
        Synchro,
        IsabelleUnregisterInterfaces,
        IsabelleRegisterInterfaces,
        IsabellePipeIN,
        IsabellePipeOUT,
        IsabellePipeINOUT,
        Foo_s,
        FooPipe_s,
        FooBar_s,
        FooCH_s,
        GetServerType,
        OpenContextHandle,
        UnregisterHelgaEx
};

RPC_DISPATCH_TABLE IsabelleDispatchTable =
{
    23, IsabelleDispatchFunction
};


int
InquireBindings (
    char * TestName
    )
/*++

Routine Description:

    This routine is used to test RpcServerInqBindings and
    RpcBindingVectorFree.  We call RpcServerInqBindings, and then
    use RpcBindingToStringBinding to get string bindings to print
    to the console.

Arguments:

    TestName - Supplies the name of the test, Christopher or Bartholomew
        which is invoking this routine.  This is necessary so that we
        can print out appropriate messages.

Return Value:

    Zero will be returned if this test completes successfully; otherwise,
    non-zero will be returned.

--*/
{
    RPC_BINDING_VECTOR * RpcBindingVector;
    unsigned int Index;
    unsigned char * StringBinding;

    Status = RpcServerInqBindings(&RpcBindingVector);
    if (Status)
        {
        ApiError(TestName,"RpcServerInqBindings",Status);
        PrintToConsole(TestName);
        PrintToConsole(" : FAIL - RpcServerInqBindings\n");
        return(1);
        }

    PrintToConsole("%s: (RpcServerInqBindings)\n", TestName);
    for (Index = 0; Index < RpcBindingVector->Count; Index++)
        {
        unsigned int   Transport;
        char *TransportName;

        Status = RpcBindingToStringBindingA(RpcBindingVector->BindingH[Index],
                &StringBinding);
        if (Status)
            {
            ApiError(TestName,"RpcBindingToStringBinding",Status);
            PrintToConsole(TestName);
            PrintToConsole(" : FAIL - RpcBindingToStringBinding\n");
            return(1);
            }

        Status =
        I_RpcBindingInqTransportType(RpcBindingVector->BindingH[Index],
                                     &Transport);

        if (Status)
            {
            ApiError(TestName,"I_RpcBindingInqTransportType",Status);
            PrintToConsole(TestName);
            PrintToConsole(" : FAIL - I_RpcBindingInqTransportType\n");
            return(1);
            }

        if (Transport == TRANSPORT_TYPE_CN)
            {
            TransportName = "cn";
            }
        else if (Transport == TRANSPORT_TYPE_DG)
            {
            TransportName = "dg";
            }
        else if (Transport == TRANSPORT_TYPE_LPC)
            {
            TransportName = "lpc";
            }
        else
            {
            PrintToConsole(TestName);
            PrintToConsole(" : FAIL - Unknown transport (I_RpcBindingInqTransportType)\n");
            return(1);
            }

        PrintToConsole("    %s - ( %s )\n",
                       (char *) StringBinding,
                       TransportName );

        Status = RpcStringFreeA(&StringBinding);
        if (Status)
            {
            ApiError(TestName,"RpcStringFree",Status);
            PrintToConsole(TestName);
            PrintToConsole(" : FAIL - RpcStringFree\n");
            return(1);
            }

        if (StringBinding != 0)
            {
            PrintToConsole(TestName);
            PrintToConsole(" : FAIL - StringBinding != 0\n");
            return(1);
            }
        }

    Status = RpcBindingVectorFree(&RpcBindingVector);
    if (Status)
        {
        ApiError(TestName,"RpcBindingVectorFree",Status);
        PrintToConsole(TestName);
        PrintToConsole(" : FAIL - RpcBindingVectorFree\n");
        return(1);
        }

    if (RpcBindingVector != 0)
        {
        PrintToConsole(TestName);
        PrintToConsole(" : FAIL - RpcBindingVector != 0\n");
        return(1);
        }

    return(0);
}


void
Sigfried (
    )
/*++

Routine Description:

    This routine is used to perform a build verification test of the
    rpc runtime.  This test checks for basic functionality of the
    runtime.  It works with Sebastian in uclnt.exe.

--*/
{
    PrintToConsole("Sigfried : Verify Basic Server Functionality\n");

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0,0);
    if (Status)
        {
        ApiError("Sigfried","stub_RegisterIf",Status);
        PrintToConsole("Sigfried : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("Sigfried","stub_RegisterIf",Status);
        PrintToConsole("Sigfried : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(SIGFRIED), 0);
    if (Status)
        {
        ApiError("Sigfried","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Sigfried : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

//    if ( InquireBindings("Sigfried") != 0 )
//        {
//        return;
//        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Sigfried","stub_ServerListen",Status);
        PrintToConsole("Sigfried : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Sigfried : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Sigfried : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Sigfried","RpcServerUnregisterIf",Status);
        PrintToConsole("Sigfried : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Sigfried","RpcServerUnregisterIf",Status);
        PrintToConsole("Sigfried : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Sigfried : PASS\n");
}


void
Hybrid (
    )
/*++

Routine Description:

    This routine is used to perform a build verification test of the
    rpc runtime.  This test checks for basic functionality of the
    runtime.  It works with Sebastian in uclnt.exe.

--*/
{
    PrintToConsole("Hybrid : Verify Basic Server Functionality\n");

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0,0);
    if (Status)
        {
        ApiError("Hybrid","stub_RegisterIf",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("Hybrid","stub_RegisterIf",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(SIGFRIED), 0);
    if (Status)
        {
        ApiError("Hybrid","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

//    if ( InquireBindings("Sigfried") != 0 )
//        {
//        return;
//        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Hybrid","stub_ServerListen",Status);
        PrintToConsole("Hybrid : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Hybrid : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Hybrid : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Hybrid","RpcServerUnregisterIf",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Hybrid","RpcServerUnregisterIf",Status);
        PrintToConsole("Hybrid : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Hybrid : PASS\n");
}


void
LpcSecurity (
    )
/*++

Routine Description:

    This routine is used to perform a build verification test of the
    rpc runtime.  This test checks for basic functionality of the
    runtime.  It works with Sebastian in uclnt.exe.

--*/
{
    PrintToConsole("LpcSecurity : Verify Basic Server Functionality\n");

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0,0);
    if (Status)
        {
        ApiError("LpcSecurity","stub_RegisterIf",Status);
        PrintToConsole("LpcSecurity : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("LpcSecurity","stub_RegisterIf",Status);
        PrintToConsole("LpcSecurity : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(SIGFRIED), 0);
    if (Status)
        {
        ApiError("LpcSecurity","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("LpcSecurity : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

//    if ( InquireBindings("Sigfried") != 0 )
//        {
//        return;
//        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("LpcSecurity","stub_ServerListen",Status);
        PrintToConsole("LpcSecurity : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("LpcSecurity : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("LpcSecurity : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("LpcSecurity","RpcServerUnregisterIf",Status);
        PrintToConsole("LpcSecurity : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("LpcSecurity","RpcServerUnregisterIf",Status);
        PrintToConsole("LpcSecurity : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("LpcSecurity : PASS\n");
}

void
TestObjectUuids (
    )
/*++

Routine Description:

    This routine is used to perform a build verification test of the
    rpc runtime.  This test checks for basic functionality of the
    runtime.  It works with Sebastian in uclnt.exe.

--*/
{
    PrintToConsole("TestObjectUuids : Verify Basic Server Functionality\n");

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0,0);
    if (Status)
        {
        ApiError("TestObjectUuids","stub_RegisterIf",Status);
        PrintToConsole("TestObjectUuids : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("TestObjectUuids","stub_RegisterIf",Status);
        PrintToConsole("TestObjectUuids : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(SIGFRIED), 0);
    if (Status)
        {
        ApiError("TestObjectUuids","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("TestObjectUuids : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

//    if ( InquireBindings("Sigfried") != 0 )
//        {
//        return;
//        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("TestObjectUuids","stub_ServerListen",Status);
        PrintToConsole("TestObjectUuids : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("TestObjectUuids : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("TestObjectUuids : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("TestObjectUuids","RpcServerUnregisterIf",Status);
        PrintToConsole("TestObjectUuids : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("TestObjectUuids","RpcServerUnregisterIf",Status);
        PrintToConsole("TestObjectUuids : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("TestObjectUuids : PASS\n");
}


void
SPipe (
    )
/*++

Routine Description:

    This routine is used to perform a build verification test of the
    rpc runtime.  This test checks for basic functionality of the
    runtime.  It works with Sebastian in uclnt.exe.

--*/
{
    PrintToConsole("SPipe : Test Pipes\n");

    Status = RpcServerRegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("SPipe","RpcServerRegisterIf",Status);
        PrintToConsole("SPipe : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerRegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,0,0);
    if (Status)
        {
        ApiError("SPipe","RpcServerRegisterIf",Status);
        PrintToConsole("SPipe : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(SPIPE), 0);
    if (Status)
        {
        ApiError("SPipe","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("SPipe : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = RpcServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("SPipe","RpcServerListen",Status);
        PrintToConsole("SPipe : FAIL - RpcServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("SPipe : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("SPipe","RpcServerUnregisterIf",Status);
        PrintToConsole("SPipe : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    PrintToConsole("SPipe : PASS\n");
}


void
Grant (
    )
/*++

Routine Description:

    This routine is used to perform a build verification test of the
    rpc runtime.  This test checks for basic functionality of the
    runtime.  It works with Graham in uclnt.exe.

--*/
{
    PrintToConsole("Grant : Verify Basic Server Functionality\n");

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, (RPC_MGR_EPV PAPI *) 722);
    if (Status)
        {
        ApiError("Grant","stub_RegisterIf",Status);
        PrintToConsole("Grant : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Grant","stub_RegisterIf",Status);
        PrintToConsole("Grant : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(GRANT), 0);
    if (Status)
        {
        ApiError("Grant","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Grant : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    HelgaCheckManagerEpv = 1;
    HelgaManagerEpv = (RPC_MGR_EPV PAPI *) 722;
    if (DatagramFlag == 0)
        {
        HelgaCheckObject = 1;
        }
    HelgaMagicNumber = 106;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    HelgaCheckObject = 0;
    HelgaCheckManagerEpv = 0;
    if (Status)
        {
        ApiError("Grant","stub_ServerListen",Status);
        PrintToConsole("Grant : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Grant : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Grant : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Grant","RpcServerUnregisterIf",Status);
        PrintToConsole("Grant : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Grant","RpcServerUnregisterIf",Status);
        PrintToConsole("Grant : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Grant : PASS\n");
}


void
Elliot (
    )
/*++

Routine Description:

    This routine tests callbacks, multiple address, and multiple
    interfaces. It works with Edward in uclnt.exe.  We also test
    client side binding as well.  This test is named after a famous
    (at least in his mind) cat.

--*/
{
    PrintToConsole("Elliot : Verify Multiple Addresses and Interfaces, ");
    PrintToConsole("and Callbacks\n");

    Status = RpcImpersonateClient(0);
    if ( Status != RPC_S_NO_CALL_ACTIVE )
        {
        ApiError("Elliot", "RpcImpersonateClient", Status);
        PrintToConsole("Elliot : FAIL - RpcImpersonateClient\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(ELLIOTMAXIMIZE), 0);
    if (Status)
        {
        ApiError("Elliot","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Elliot : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf((RPC_IF_HANDLE) &SylviaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Elliot","stub_RegisterIf",Status);
        PrintToConsole("Elliot : FAIL - Unable to Register Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(ELLIOTMINIMIZE), 0);
    if (Status)
        {
        ApiError("Elliot","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Elliot : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(ELLIOTNORMAL), 0);
    if (Status)
        {
        ApiError("Elliot","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Elliot : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Elliot","stub_RegisterIf",Status);
        PrintToConsole("Elliot : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Elliot","stub_RegisterIf",Status);
        PrintToConsole("Elliot : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    PrintToConsole("Elliot: Start listening\n") ;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 1);
    if (Status)
        {
        ApiError("Elliot","stub_ServerListen",Status);
        PrintToConsole("Elliot : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (AutoListenFlag == 0)
        {
        PrintToConsole("Elliot: RpcMgmtWaitServerListen\n") ;
        Status = RpcMgmtWaitServerListen();
        if (Status)
            {
            ApiError("Elliot","RpcMgmtWaitServerListen",Status);
            PrintToConsole("Elliot : FAIL - RpcMgmtWaitServerListen Failed\n");
            return;
            }
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Elliot : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (SylviaErrors != 0)
        {
        PrintToConsole("Elliot : FAIL - Error(s) in Sylvia Interface\n");
        SylviaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Elliot : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    if (AutoListenFlag)
        {
        // unregister the interfaces individually
        Status = RpcServerUnregisterIf(
         (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
        if (Status)
            {
            ApiError("Elliot","RpcServerUnregisterIf",Status);
            PrintToConsole("Elliot : FAIL - Unable to Unregister Interface ");
            PrintToConsole("(Isabelle)\n");
            return;
            }

        Status = RpcServerUnregisterIf(
         (RPC_IF_HANDLE) &SylviaInterfaceInformation, 0, 0);
        if (Status)
            {
            ApiError("Elliot","RpcServerUnregisterIf",Status);
            PrintToConsole("Elliot : FAIL - Unable to Unregister Interface ");
            PrintToConsole("(Sylvia)\n");
            return;
            }

        Status = RpcServerUnregisterIf(
         (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
        if (Status)
            {
            ApiError("Elliot","RpcServerUnregisterIf",Status);
            PrintToConsole("Elliot : FAIL - Unable to Unregister Interface ");
            PrintToConsole("(Helga)\n");
            return;
            }
        }
    else
        {
        Status = RpcServerUnregisterIf(0, 0, 0);
        if (Status)
            {
            ApiError("Elliot","RpcServerUnregisterIf",Status);
            PrintToConsole("Elliot : FAIL - Unable to Unregister All Interfaces\n");
            return;
            }
        }

    PrintToConsole("Elliot : PASS\n");
}


void
Andromida (
    )
/*++

Routine Description:

    This routine is used to perform multithreaded client tests.  This
    test works with the Astro test in uclnt.exe.

--*/
{
    PrintToConsole("Andromida : Multithreaded Clients\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(ANDROMIDA), 0);
    if (Status)
        {
        ApiError("Andromida","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Andromida : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf((RPC_IF_HANDLE) &SylviaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Andromida","stub_RegisterIf",Status);
        PrintToConsole("Andromida : FAIL - Unable to Register Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Andromida","stub_RegisterIf",Status);
        PrintToConsole("Andromida : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Andromida","stub_RegisterIf",Status);
        PrintToConsole("Andromida : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Andromida","stub_ServerListen",Status);
        PrintToConsole("Andromida : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Andromida : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (SylviaErrors != 0)
        {
        PrintToConsole("Andromida : FAIL - Error(s) in Sylvia Interface\n");
        SylviaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Andromida : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Andromida","RpcServerUnregisterIf",Status);
        PrintToConsole("Andromida : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Andromida","RpcServerUnregisterIf",Status);
        PrintToConsole("Andromida : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Andromida","RpcServerUnregisterIf",Status);
        PrintToConsole("Andromida : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    PrintToConsole("Andromida : PASS\n");
}


void
Fredrick (
    )
/*++

Routine Description:

    This routine is used to verify all client DCE rpc runtime APIs.  It
    works with Fitzgerald in uclnt.exe.

--*/
{
    PrintToConsole("Fredrick : Verify All Client APIs\n");

    if (TransportType == RPC_TRANSPORT_TCP)
        {
        struct hostent *he;
        WSADATA data;
        struct in_addr addr;
        u_long AddrAsLong;
        RPC_CHAR Buffer[50];
        RPC_POLICY Policy;

        if ( WSAStartup(2, &data) != NO_ERROR)
            {
            ApiError("Fredrick","WSAStartup",Status);
            PrintToConsole("Fredrick : FAIL - Unable to call WSAStartup\n");
            return;
            }

        // Get Dns hostname
        he = gethostbyname( "" );
        if (he == NULL)
            {
            ApiError("Fredrick","gethostbyname",Status);
            PrintToConsole("Fredrick : FAIL - Unable to call gethostbyname\n");
            return;
            }

//        AddrAsLong = ntohl(*(DWORD *)he->h_addr_list[0]);
        memcpy(&addr, (DWORD *)he->h_addr_list[0], sizeof(addr));
        swprintf(Buffer, L"%d.%d.%d.%d", addr.S_un.S_un_b.s_b1, addr.S_un.S_un_b.s_b2,
            addr.S_un.S_un_b.s_b3, addr.S_un.S_un_b.s_b4);

        Policy.Length = sizeof(RPC_POLICY);
        Policy.EndpointFlags = 0;
        Policy.NICFlags = 0;
        Status = I_RpcServerUseProtseqEp2(Buffer, L"ncacn_ip_tcp", 3, L"2500", NULL, &Policy);
        if (Status)
            {
            ApiError("Fredrick","I_RpcServerUseProtseqEp2",Status);
            PrintToConsole("Fredrick : FAIL - Unable to Use Protseq Endpoint\n");
            return;
            }
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(FREDRICK), 0);
    if (Status)
        {
        ApiError("Fredrick","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Fredrick : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Fredrick","stub_RegisterIf",Status);
        PrintToConsole("Fredrick : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Fredrick","stub_RegisterIf",Status);
        PrintToConsole("Fredrick : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Fredrick","stub_ServerListen",Status);
        PrintToConsole("Fredrick : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Fredrick : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Fredrick : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    PauseExecution(10000L);

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Fredrick","RpcServerUnregisterIf",Status);
        PrintToConsole("Fredrick : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Fredrick","RpcServerUnregisterIf",Status);
        PrintToConsole("Fredrick : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Fredrick : PASS\n");
}


void
GenerateUuidValue (
    IN unsigned short MagicNumber,
    OUT UUID PAPI * Uuid
    )
/*++

Routine Description:

    This routine is used to generate a value for a uuid.  The magic
    number argument is used in mysterious and wonderful ways to
    generate a uuid (which is not necessarily correct).

Arguments:

    MagicNumber - Supplies a magic number which will be used to
        generate a uuid.

    Uuid - Returns the generated uuid.

--*/
{
    Uuid->Data1 = ((unsigned long) MagicNumber)
        * ((unsigned long) MagicNumber);
    Uuid->Data2 = MagicNumber;
    Uuid->Data3 = MagicNumber / 2;
    Uuid->Data4[0] = MagicNumber % 256;
    Uuid->Data4[1] = MagicNumber % 257;
    Uuid->Data4[2] = MagicNumber % 258;
    Uuid->Data4[3] = MagicNumber % 259;
    Uuid->Data4[4] = MagicNumber % 260;
    Uuid->Data4[5] = MagicNumber % 261;
    Uuid->Data4[6] = MagicNumber % 262;
    Uuid->Data4[7] = MagicNumber % 263;
}


int
ChristopherObjectSetType (
    IN unsigned short ObjectMagicNumber,
    IN unsigned short TypeMagicNumber,
    IN unsigned int MustFailFlag
    )
/*++

Routine Description:

    This routine calls the RpcObjectSetType routine.  The object uuid
    is generated using the object magic number argument, and the type
    uuid uses the type magic number argument.

Arguments:

    ObjectMagicNumber - Supplies the magic number to be used to generate
        the object uuid to be passed to RpcObjectSetType.

    TypeMagicNumber - Supplies the magic number to use to generate the
        type uuid.

    MustFailFlag - Supplies a flag indicating whether or not the call
        to RpcObjectSetType must succeed or fail.  If this flag is
        zero, then RpcObjectSetType must return RPC_S_OK, otherwise,
        the test fails.  If the flag is non-zero, then RpcObjectSetType
        must return RPC_S_ALREADY_REGISTERED.

Return Value:

    Zero will be returned if the test completes successfully; otherise,
    non-zero will be returned.

--*/
{
    UUID ObjectUuid;
    UUID TypeUuid;

    GenerateUuidValue(ObjectMagicNumber,&ObjectUuid);
    GenerateUuidValue(TypeMagicNumber,&TypeUuid);

    Status = RpcObjectSetType(&ObjectUuid,&TypeUuid);
    if (MustFailFlag == 0)
        {
        if (Status)
            {
            ApiError("Christopher","RpcObjectSetType",Status);
            PrintToConsole("Christopher : FAIL - Can not Set Object Type\n");
            return(1);
            }
        }
    else
        {
        if (Status != RPC_S_ALREADY_REGISTERED)
            {
            PrintToConsole("Christopher : FAIL - RpcObjectSetType did not");
            PrintToConsole(" fail as expected\n");
            return(1);
            }
        }

    return(0);
}


int
ChristopherObjectSetNullType (
    IN unsigned short ObjectMagicNumber,
    IN unsigned int UseNullUuidFlag,
    IN unsigned int MustFailFlag
    )
/*++

Routine Description:

    This routine calls the RpcObjectSetType routine.  The object uuid
    is generated using the object magic number argument, and the type
    uuid is either not specified, or is the null uuid.

Arguments:

    ObjectMagicNumber - Supplies the magic number to be used to generate
        the object uuid to be passed to RpcObjectSetType.

    UseNullUuidFlag - Supplies a flag indicating whether to specify
        the null uuid for the type uuid or nothing.  If this flag is
        non-zero the null uuid will be specified as the type uuid;
        otherwise, the type uuid will not be specified.

    MustFailFlag - Supplies a flag indicating whether or not the call
        to RpcObjectSetType must succeed or fail.  If this flag is
        zero, then RpcObjectSetType must return RPC_S_OK, otherwise,
        the test fails.  If the flag is non-zero, then RpcObjectSetType
        must return RPC_S_OBJECT_NOT_FOUND.

Return Value:

    Zero will be returned if the test completes successfully; otherise,
    non-zero will be returned.

--*/
{
    UUID ObjectUuid;
    UUID TypeUuid;

    GenerateUuidValue(ObjectMagicNumber,&ObjectUuid);
    memset(&TypeUuid,0,sizeof(UUID));

    if (UseNullUuidFlag == 0)
        Status = RpcObjectSetType(&ObjectUuid,&TypeUuid);
    else
        Status = RpcObjectSetType(&ObjectUuid,0);
    if (MustFailFlag == 0)
        {
        if (Status)
            {
            ApiError("Christopher","RpcObjectSetType",Status);
            PrintToConsole("Christopher : FAIL - Can not Set Object Type\n");
            return(1);
            }
        }
    else
        {
        if (Status != RPC_S_OK)
            {
            PrintToConsole("Christopher : FAIL - RpcObjectSetType did not");
            PrintToConsole(" fail as expected\n");
            return(1);
            }
        }

    return(0);
}


int
ChristopherObjectInqType (
    IN unsigned short ObjectMagicNumber,
    IN unsigned short TypeMagicNumber,
    IN unsigned int MustFailFlag
    )
/*++

Routine Description:

    This routine calls the RpcObjectInqType routine.  The object uuid
    is generated using the object magic number argument, and the type
    uuid uses the type magic number argument.

Arguments:

    ObjectMagicNumber - Supplies the magic number to be used to generate
        the object uuid to be passed to RpcObjectInqType.

    TypeMagicNumber - Supplies the magic number to use to generate the
        expected type uuid.

    MustFailFlag - Supplies a flag indicating whether or not the call
        to RpcObjectInqType must fail or succeed.  If this flag is
        non-zero, RpcObjectInqType must return RPC_S_OBJECT_NOT_FOUND,
        otherwise the test fails.  If the flag is zero, then
        RpcObjectInqType must succeed.

Return Value:

    Zero will be returned if the test completes successfully; otherise,
    non-zero will be returned.

--*/
{
    UUID ObjectUuid;
    UUID TypeUuid;
    UUID ExpectedTypeUuid;

    GenerateUuidValue(ObjectMagicNumber,&ObjectUuid);
    GenerateUuidValue(TypeMagicNumber,&ExpectedTypeUuid);

    Status = RpcObjectInqType(&ObjectUuid,&TypeUuid);
    if (MustFailFlag == 0)
        {
        if (Status)
            {
            ApiError("Christopher","RpcObjectInqType",Status);
            PrintToConsole("Christopher : FAIL - Can not Inquire");
            PrintToConsole(" Object Type\n");
            return(1);
            }

        if (memcmp(&ExpectedTypeUuid,&TypeUuid,sizeof(UUID)) != 0)
            {
            PrintToConsole("Christopher : FAIL - TypeUuid != ");
            PrintToConsole("ExpectedTypeUuid\n");
            return(1);
            }
        }
    else
        {
        if (Status != RPC_S_OBJECT_NOT_FOUND)
            {
            PrintToConsole("Christopher : FAIL - RpcObjectInqType ");
            PrintToConsole("succeeded\n");
            return(1);
            }
        }

    return(0);
}

static UUID ChristopherObjectUuid;
static UUID ChristopherTypeUuid;


void
ChristopherRpcObjectInqFn (
    IN UUID PAPI * ObjectUuid,
    OUT UUID PAPI * TypeUuid,
    OUT RPC_STATUS PAPI * Status
    )
/*++

Routine Description:

    This routine is the object inquiry function we will pass to the
    runtime.  If the object uuid specified is equal to the global
    object uuid, we will return the global type uuid and RPC_S_OK;
    otherwise, we will return RPC_S_OBJECT_NOT_FOUND.

Arguments:

    ObjectUuid - Supplies the object uuid to compare with the global
        object uuid.

    TypeUuid - Returns the type uuid if the object uuid is found.

    Status - Returns the status of the operations.  This will be
        either RPC_S_OK or RPC_S_OBJECT_NOT_FOUND.

--*/
{
    if (memcmp(ObjectUuid,&ChristopherObjectUuid,sizeof(UUID)) != 0)
        {
        *Status = RPC_S_OBJECT_NOT_FOUND;
        return;
        }

    memcpy(TypeUuid,&ChristopherTypeUuid,sizeof(UUID));
    *Status = RPC_S_OK;
    return;
}


int
ChristopherTestObject (
    )
/*++

Routine Description:

    This routine is used by Christopher to test RpcObjectInqType,
    RpcObjectSetInqFn, and RpcObjectSetType.

Return Value:

    Zero will be returned if all of the tests complete successfully,
    otherwise, non-zero will be returned.

--*/
{
    if (ChristopherObjectSetType(12345,2987,0))
        return(1);

    if (ChristopherObjectInqType(12345,2987,0))
        return(1);

    if (ChristopherObjectInqType(5421,2987,1))
        return(1);

    if (ChristopherObjectSetType(12345,2987,1))
        return(1);

    if (ChristopherObjectSetType(12,2987,0))
        return(1);

    if (ChristopherObjectSetType(123,2987,0))
        return(1);

    if (ChristopherObjectSetType(1234,2987,0))
        return(1);

    if (ChristopherObjectInqType(12,2987,0))
        return(1);

    if (ChristopherObjectInqType(123,2987,0))
        return(1);

    if (ChristopherObjectInqType(1234,2987,0))
        return(1);

    if (ChristopherObjectInqType(12345,2987,0))
        return(1);

    if (ChristopherObjectSetNullType(123,0,0))
        return(1);

    if (ChristopherObjectSetNullType(1234,1,0))
        return(1);

    if (ChristopherObjectInqType(123,2987,1))
        return(1);

    if (ChristopherObjectInqType(1234,2987,1))
        return(1);

    if (ChristopherObjectSetNullType(5421,0,1))
        return(1);

    if (ChristopherObjectSetNullType(421,0,1))
        return(1);

    Status = RpcObjectSetInqFn(&ChristopherRpcObjectInqFn);
    if (Status)
        {
        ApiError("Christopher","RpcObjectSetInqFn",Status);
        PrintToConsole("Christopher : FAIL - RpcObjectSetInqFn ");
        PrintToConsole("(ChristopherRpcObjectInqFn)\n");
        return(1);
        }

    GenerateUuidValue(10666,&ChristopherObjectUuid);
    GenerateUuidValue(8466,&ChristopherTypeUuid);

    if (ChristopherObjectInqType(96,2987,1))
        return(1);

    if (ChristopherObjectInqType(10666,8466,0))
        return(1);

    Status = RpcObjectSetInqFn(0);
    if (Status)
        {
        ApiError("Christopher","RpcObjectSetInqFn",Status);
        PrintToConsole("Christopher : FAIL - RpcObjectSetInqFn (0)\n");
        return(1);
        }

    if (ChristopherObjectInqType(10666,8466,1))
        return(1);

    return(0);
}


int
ChristopherTestInquire (
    )
/*++

Routine Description:

    Christopher uses this routine to test RpcServerInqIf and RpcIfInqId.

Return Value:

    Zero will be returned if all of the test successfully pass.  Otherwise,
    non-zero will be returned.

--*/
{
    RPC_IF_ID RpcIfId;
    UUID TypeUuid;
    RPC_MGR_EPV PAPI * ManagerEpv;

    Status = RpcIfInqId((RPC_IF_HANDLE) &IsabelleInterfaceInformation,
        &RpcIfId);
    if (Status)
        {
        ApiError("Christopher","RpcIfInqId",Status);
        PrintToConsole("Christopher : FAIL - Error in RpcIfInqId\n");
        return(1);
        }

    if (   (RpcIfId.VersMajor != 1)
        || (RpcIfId.VersMinor != 1)
        || (RpcIfId.Uuid.Data1 != 9)
        || (RpcIfId.Uuid.Data2 != 8)
        || (RpcIfId.Uuid.Data3 != 8)
        || (RpcIfId.Uuid.Data4[0] != 7)
        || (RpcIfId.Uuid.Data4[1] != 7)
        || (RpcIfId.Uuid.Data4[2] != 7)
        || (RpcIfId.Uuid.Data4[3] != 7)
        || (RpcIfId.Uuid.Data4[4] != 7)
        || (RpcIfId.Uuid.Data4[5] != 7)
        || (RpcIfId.Uuid.Data4[6] != 7)
        || (RpcIfId.Uuid.Data4[7] != 7))
        {
        PrintToConsole("Christopher : FAIL - Wrong RpcIfId\n");
        return(1);
        }

    TypeUuid.Data1 = 0x12345678;
    TypeUuid.Data2 = 0x9ABC;
    TypeUuid.Data3 = 0xDEF0;
    TypeUuid.Data4[0] = 0x12;
    TypeUuid.Data4[1] = 0x34;
    TypeUuid.Data4[2] = 0x56;
    TypeUuid.Data4[3] = 0x78;
    TypeUuid.Data4[4] = 0x9A;
    TypeUuid.Data4[5] = 0xBC;
    TypeUuid.Data4[6] = 0xDE;
    TypeUuid.Data4[7] = 0xF0;

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            &TypeUuid, (RPC_MGR_EPV PAPI *) 38756);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return(1);
        }

    Status = RpcServerInqIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            &TypeUuid,&ManagerEpv);
    if (Status)
        {
        ApiError("Christopher","RpcServerInqIf",Status);
        PrintToConsole("Christopher : FAIL - RpcServerInqIf\n");
        return(1);
        }

    if (ManagerEpv != (RPC_MGR_EPV PAPI *) 38756)
        {
        PrintToConsole("Christopher : FAIL - ManagerEpv != 38756\n");
        return(1);
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Christopher","RpcServerUnregisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Unregister");
        PrintToConsole(" Interface (Isabelle)\n");
        return(1);
        }

    return(0);
}


void
Christopher (
    )
/*++

Routine Description:

    We verify all server side APIs in this routine.  The idea is to
    emphasize complete coverage, rather than indepth coverage.  Actually,
    by all server side APIs, I really mean all server side APIs except
    for security and name service.  The following list is the APIs
    which will be tested by this routine.

    RpcBindingInqObject [SCONNECTION]
    RpcBindingToStringBinding [SCONNECTION]
    RpcBindingToStringBinding [SVR_BINDING_HANDLE]
    RpcBindingVectorFree
    RpcIfInqId
    RpcNetworkInqProtseqs
    RpcObjectInqType
    RpcObjectSetInqFn
    RpcObjectSetType
    RpcProtseqVectorFree
    RpcServerInqBindings
    RpcServerInqIf
    RpcServerListen
    stub_RegisterIf
    RpcServerUnregisterIf
    RpcServerUseAllProtseqs
    RpcServerUseAllProtseqsIf
    RpcServerUseProtseq
    RpcServerUseProtseqEpWrapper
    RpcServerUseProtseqIf
    RpcMgmtStopServerListening
    RpcMgmtInqIfIds
    RpcIfIdVectorFree

--*/
{
    RPC_PROTSEQ_VECTORA * RpcProtseqVector;
    unsigned int Index;
    UUID TypeUuid;
    UUID ObjectUuid;
    RPC_IF_ID_VECTOR * InterfaceIdVector;
    unsigned char * String;

    PrintToConsole("Christopher : Verify All Server APIs\n");

    Status = RpcNetworkInqProtseqsA(&RpcProtseqVector);
    if (Status)
        {
        ApiError("Christopher","RpcNetworkInqProtseqs",Status);
        PrintToConsole("Christopher : FAIL - RpcNetworkInqProtseqs\n");
        return;
        }

    PrintToConsole("Christopher : (RpcNetworkInqProtseqs)\n");
    for (Index = 0; Index < RpcProtseqVector->Count; Index++)
        {
        PrintToConsole("    ");
        PrintToConsole((char *) RpcProtseqVector->Protseq[Index]);
        PrintToConsole("\n");
        }

    Status = RpcProtseqVectorFreeA(&RpcProtseqVector);
    if (Status)
        {
        ApiError("Christopher","RpcProtseqVectorFree",Status);
        PrintToConsole("Christopher : FAIL - RpcProtseqVectorFree\n");
        return;
        }

    Status = RpcProtseqVectorFreeA(&RpcProtseqVector);
    if (Status)
        {
        ApiError("Christopher","RpcProtseqVectorFree",Status);
        PrintToConsole("Christopher : FAIL - RpcProtseqVectorFree\n");
        return;
        }

    ChristopherIsabelleError = 0;

    // This routine will test RpcServerInqIf and RpcIfInqId for us.

    if (ChristopherTestInquire() != 0)
        return;

    // We test RpcObjectInqType, RpcObjectSetInqFn, and RpcObjectSetType
    // in this routine.

    if (ChristopherTestObject() != 0)
        return;

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(CHRISTOPHER), 0);
    if (Status)
        {
        ApiError("Christopher","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Christopher : FAIL - Unable to Use Protseq ");
        PrintToConsole("Endpoint\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(CHRISTOPHER), 0);
    if (Status != RPC_S_DUPLICATE_ENDPOINT)
        {
        ApiError("Christopher","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Christopher : FAIL - Able to Add Duplicate ");
        PrintToConsole("Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    // added for synchro support
    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    GenerateUuidValue(288, &ObjectUuid);
    GenerateUuidValue(3010, &TypeUuid);
    Status = RpcObjectSetType(&ObjectUuid, &TypeUuid);
    if (Status)
        {
        ApiError("Christopher","RpcObjectSetType",Status);
        PrintToConsole("Christopher : FAIL - Unable to Set Object Type\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            &TypeUuid, (RPC_MGR_EPV PAPI *) 9814);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            &TypeUuid, (RPC_MGR_EPV PAPI *) 9814);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUseAllProtseqsIfWrapper(1,
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0);
    if (Status)
        {
        ApiError("Christopher","RpcServerUseAllProtseqsIfWrapper",Status);
        PrintToConsole("Christopher : FAIL - Unable to Use All Protseqs ");
        PrintToConsole("from Interface\n");
        return;
        }

    Status = RpcServerUseProtseqIfWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0);
    if (Status)
        {
        ApiError("Christopher","RpcServerUseProtseqIfWrapper",Status);
        PrintToConsole("Christopher : FAIL - Unable to Use Protseq From ");
        PrintToConsole("Interface\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation,
            &TypeUuid, (RPC_MGR_EPV PAPI *) 9814);
    if (Status)
        {
        ApiError("Christopher","stub_RegisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Register Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    if (AutoListenFlag == 0)
        {
        Status = stub_ServerListen(123, 122, 0);
        if ( Status != RPC_S_MAX_CALLS_TOO_SMALL )
            {
            ApiError("Christopher", "stub_ServerListen", Status);
            PrintToConsole("Christopher : FAIL - stub_ServerListen\n");
            return;
            }
        }

    PrintToConsole("Christopher : Start Listening\n") ;
    HelgaManagerEpv = (RPC_MGR_EPV PAPI *) 9814;
    HelgaCheckManagerEpv = 1;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    HelgaCheckManagerEpv = 0;
    if (Status)
        {
        ApiError("Christopher","stub_ServerListen",Status);
        PrintToConsole("Christopher : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (ChristopherIsabelleError != 0)
        {
        ChristopherIsabelleError = 0;
        return;
        }

    Status = RpcMgmtInqIfIds(0, &InterfaceIdVector);
    if ( Status != RPC_S_OK )
        {
        ApiError("Christopher", "RpcMgmtInqIfIds", Status);
        PrintToConsole("Christopher : FAIL - Unable to Inquire Interface Ids\n");
        return;
        }

    for (Index = 0; Index < InterfaceIdVector->Count; Index++)
        {
        PrintToConsole("    ");
        UuidToStringA(&(InterfaceIdVector->IfId[Index]->Uuid), &String);
        PrintToConsole((char *) String);
        RpcStringFreeA(&String);
        PrintToConsole(" %d.%d\n", InterfaceIdVector->IfId[Index]->VersMajor,
                InterfaceIdVector->IfId[Index]->VersMinor);
        }

    Status = RpcIfIdVectorFree(&InterfaceIdVector);
    if (   ( Status != RPC_S_OK )
        || ( InterfaceIdVector != 0 ) )
        {
        ApiError("Christopher", "RpcIfIdVectorFree", Status);
        PrintToConsole("Christopher : FAIL - Unable to Free IfIdVector\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Christopher : FAIL - Error(s) in Helga");
        PrintToConsole(" Interface\n");
        HelgaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 1);
    if (Status)
        {
        ApiError("Christopher","RpcServerUnregisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Unregister");
        PrintToConsole(" Interface (Helga)\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Christopher : FAIL - Error(s) in Isabelle");
        PrintToConsole(" Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 1);
    if (Status)
        {
        ApiError("Christopher","RpcServerUnregisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Unregister");
        PrintToConsole(" Interface (Isabelle)\n");
        return;
        }

    if (SylviaErrors != 0)
        {
        PrintToConsole("Christopher : FAIL - Error(s) in Sylvia Interface\n");
        SylviaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation, 0, 1);
    if (Status)
        {
        ApiError("Christopher","RpcServerUnregisterIf",Status);
        PrintToConsole("Christopher : FAIL - Unable to Unregister");
        PrintToConsole(" Interface (Sylvia)\n");
        return;
        }

    Status = RpcServerUseProtseqWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS, 0);
    if (Status)
        {
        ApiError("Christopher","RpcServerUseProtseq",Status);
        PrintToConsole("Christopher : FAIL - Unable to Use Protseq\n");
        return;
        }

    Status = RpcServerUseAllProtseqsWrapper(1, 0);
    if (Status)
        {
        ApiError("Christopher","RpcServerUseAllProtseqsWrapper",Status);
        PrintToConsole("Christopher : FAIL - Unable to Use All Protseqs\n");
        return;
        }

    if (InquireBindings("Christopher") != 0)
        return;

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(CHRISTOPHERMUSTFAILONE), 0);
    if (Status != RPC_S_INVALID_ENDPOINT_FORMAT)
        {
        PrintToConsole("Christopher : FAIL - Status != ");
        PrintToConsole("RPC_S_INVALID_ENDPOINT_FORMAT");
        PrintToConsole(" (ChristopherMustFailOne)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(CHRISTOPHERMUSTFAILTWO), 0);
    if (Status != RPC_S_INVALID_ENDPOINT_FORMAT)
        {
        PrintToConsole("Christopher : FAIL - Status != ");
        PrintToConsole("RPC_S_INVALID_ENDPOINT_FORMAT");
        PrintToConsole(" (ChristopherMustFailTwo)\n");
        return;
        }

// SkipInvalidEndpointFormat:

    Status = RpcServerUseProtseqEpWrapper((unsigned char *) "ncacn_bad",
            MAX_CALL_REQUESTS, GetEndpoint(CHRISTOPHERMUSTFAILONE), 0);
    if (Status != RPC_S_PROTSEQ_NOT_SUPPORTED)
        {
        PrintToConsole("Christopher : FAIL - Status != ");
        PrintToConsole("RPC_S_PROTSEQ_NOT_SUPPORTED (ncacn_bad)\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper((unsigned char *) "mkm_np",
            MAX_CALL_REQUESTS, GetEndpoint(CHRISTOPHERMUSTFAILONE), 0);
    if (Status != RPC_S_PROTSEQ_NOT_SUPPORTED)
        {
        PrintToConsole("Christopher : FAIL - Status != ");
        PrintToConsole("RPC_S_PROTSEQ_NOT_SUPPORTED (bad_np)\n");
        return;
        }

    PrintToConsole("Christopher : PASS\n");
}


void
David (
    )
/*++

Routine Description:

    This routine is used to test association context rundown support;
    it works with Daniel in uclnt.exe.

--*/
{
    PrintToConsole("David : Association Context and Rundown\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(DAVIDFIRST), 0);
    if (Status)
        {
        ApiError("David","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("David : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(DAVIDSECOND), 0);
    if (Status)
        {
        ApiError("David","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("David : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("David","stub_RegisterIf",Status);
        PrintToConsole("David : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    // Synchro support
    Status = stub_RegisterIf((RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("David","stub_RegisterIf",Status);
        PrintToConsole("David : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("David: Start Listening\n") ;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("David","stub_ServerListen",Status);
        PrintToConsole("David : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("David : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("David","RpcServerUnregisterIf",Status);
        PrintToConsole("David : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    // we don't unregister helga, as a method of isabelle should have
    // been called to do that

    PrintToConsole("David : PASS\n");
}


void
Tyler ( // Perform security tests.  This particular test works with
        // Thomas which lives in uclnt.cxx.
    )
/*++

Routine Description:

    Tyler works with Thomas, which lives in uclnt.exe, to perform build
    verification tests of security.

--*/
{
    SECURITY_DESCRIPTOR sd, *psd;

    PrintToConsole("Tyler : Test Security\n");

    if (TransportType == RPC_LRPC)
        {
        // ncalrpc needs a security descriptor.

        psd = &sd;

        InitializeSecurityDescriptor(
                        psd,
                        SECURITY_DESCRIPTOR_REVISION
                        );

        if ( FALSE == SetSecurityDescriptorDacl (
                            psd,
                            TRUE,                 // Dacl present
                            NULL,                 // NULL Dacl
                            FALSE                 // Not defaulted
                            ) )
            {
            ApiError("Tyler","SetSecurityDescriptorDacl",0);
            return;
            }
        }
    else
        {
        psd = 0;
        }


    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(TYLER), psd);
    if (Status)
        {
        ApiError("Tyler","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Tyler : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Tyler","stub_RegisterIf",Status);
        PrintToConsole("Tyler : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Tyler","stub_RegisterIf",Status);
        PrintToConsole("Tyler : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = RpcServerRegisterAuthInfoA((unsigned char PAPI *)
            "ServerPrincipal", ulSecurityPackage, 0, 0); //hack
    if (Status)
        {
        ApiError("Tyler", "RpcServerRegisterAuthInfo", Status);
        PrintToConsole("Tyler : FAIL - Unable to Register AuthInfo\n");
        return;
        }

    PrintToConsole("Tyler : Listening\n") ;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Tyler","stub_ServerListen",Status);
        PrintToConsole("Tyler : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Tyler : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Tyler : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Tyler","RpcServerUnregisterIf",Status);
        PrintToConsole("Tyler : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Tyler","RpcServerUnregisterIf",Status);
        PrintToConsole("Tyler : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Tyler : PASS\n");
}


void
Terry ( // Perform security tests.  This particular test works with
        // Tim which lives in uclnt.cxx.
    )
/*++

Routine Description:

    Terry works with Tim, which lives in uclnt.exe, to perform build
    verification tests of NT security.

--*/
{
    PrintToConsole("Terry : Test Security\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(TYLER), 0);
    if (Status)
        {
        ApiError("Terry","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Terry : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Terry","stub_RegisterIf",Status);
        PrintToConsole("Terry : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Terry","stub_RegisterIf",Status);
        PrintToConsole("Terry : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = RpcServerRegisterAuthInfoA((unsigned char PAPI *)
            "ServerPrincipal", ulSecurityPackage, 0, 0);
    if (Status)
        {
        ApiError("Terry", "RpcServerRegisterAuthInfo", Status);
        PrintToConsole("Terry : FAIL - Unable to Register AuthInfo\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Terry","stub_ServerListen",Status);
        PrintToConsole("Terry : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Terry : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Terry : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Terry","RpcServerUnregisterIf",Status);
        PrintToConsole("Terry : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Terry","RpcServerUnregisterIf",Status);
        PrintToConsole("Terry : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Terry : PASS\n");
}


void
RichardHelper (
    )
/*++

Routine Description:

    This routine will be used as a helper by Richard.  The description
    of Richard will explain how it is used.

--*/
{

    PrintToConsole("Richard : RichardHelper Executed\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(RICHARDHELPER), 0);
    if (Status)
        {
        ApiError("RichardHelper", "RpcServerUseProtseqEpWrapper", Status);
        PrintToConsole("RichardHelper : FAIL - Unable to Use Protseq ");
        PrintToConsole("Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("RichardHelper","stub_RegisterIf",Status);
        PrintToConsole("RichardHelper : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("RichardHelper","stub_RegisterIf",Status);
        PrintToConsole("RichardHelper : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("RichardHelper","stub_ServerListen",Status);
        PrintToConsole("RichardHelper : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("RichardHelper : FAIL - Error(s) in Isabelle");
        PrintToConsole(" Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("RichardHelper","RpcServerUnregisterIf",Status);
        PrintToConsole("RichardHelper : FAIL - Unable to Unregister ");
        PrintToConsole("Interface (Isabelle)\n");
        return;
        }

   Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("RichardHelper","RpcServerUnregisterIf",Status);
        PrintToConsole("RichardHelper : FAIL - Unable to Unregister ");
        PrintToConsole("Interface (Helga)\n");
        return;
        }
}


void
Richard (
    )
/*++

Description:

    Richard works with Robert (in uclnt.cxx) to test call and callback
    failures.  In particular, we want to test that a call failing does
    not invalidate the binding handle.  We will do this using the
    RichardHelper routine.

--*/
{
    PrintToConsole("Richard : Test Call and Callback Failures\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(RICHARD), 0);
    if (Status)
        {
        ApiError("Richard","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Richard : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Richard","stub_RegisterIf",Status);
        PrintToConsole("Richard : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Richard","stub_RegisterIf",Status);
        PrintToConsole("Richard : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }


    PrintToConsole("Richard : Listening\n") ;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Richard","stub_ServerListen",Status);
        PrintToConsole("Richard : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Richard : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Richard","RpcServerUnregisterIf",Status);
        PrintToConsole("Richard : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Richard","RpcServerUnregisterIf",Status);
        PrintToConsole("Richard : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Richard : PASS\n");
}

void
Kenneth (
    )
/*++

Description:

    Kenneth works with Keith (in uclnt.cxx) to auto reconnect.

--*/
{
    PrintToConsole("Kenneth : Test Auto Reconnect\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(KENNETH), 0);
    if (Status)
        {
        ApiError("Kenneth","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Kenneth : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Kenneth","stub_RegisterIf",Status);
        PrintToConsole("Kenneth : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    // Synchro support
    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Kenneth","stub_RegisterIf",Status);
        PrintToConsole("Kenneth : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Kenneth : Listening\n") ;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Kenneth","stub_ServerListen",Status);
        PrintToConsole("Kenneth : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Kenneth : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Kenneth","RpcServerUnregisterIf",Status);
        PrintToConsole("Kenneth : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    // synchro support
    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Kenneth","RpcServerUnregisterIf",Status);
        PrintToConsole("Kenneth : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Kenneth : PASS\n");
}


void
BartholomewHelper (
    )
/*++

Routine Description:

    Bartholomew will use this routine to help with testing resolving
    endpoints.  We just need to use some protocol sequences and then
    register with the endpoint mapper before returning (and exiting).

--*/
{
    PrintToConsole("Bartholomew : BartholomewHelper Executed\n");

    Status = RpcServerUseAllProtseqsWrapper(1, 0);
    if (Status)
        {
        ApiError("BartholomewHelper","RpcServerUseAllProtseqsWrapper",Status);
        PrintToConsole("BartholomewHelper : FAIL - Unable to Use All Protseqs\n");
        return;
        }

    Status = RpcServerInqBindings(&BartholomewRpcBindingVector);
    if (Status)
        {
        ApiError("BartholomewHelper", "RpcServerInqBindings", Status);
        PrintToConsole("BartholomewHelper : FAIL - RpcServerInqBindings\n");
        return;
        }

    Status = RpcEpRegisterA((RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            BartholomewRpcBindingVector, 0,
            (unsigned char PAPI *) "usvr.exe");
    if (Status)
        {
        ApiError("BartholomewHelper", "RpcEpRegister", Status);
        PrintToConsole("BartholomewHelper : FAIL - RpcEpRegister Failed\n");
        return;
        }

    Status = RpcEpRegisterNoReplaceA(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation,
            BartholomewRpcBindingVector, 0,
            (unsigned char PAPI *) "usvr.exe");
    if (Status)
        {
        ApiError("BartholomewHelper", "RpcEpRegisterNoReplace", Status);
        PrintToConsole("BartholomewHelper : FAIL - RpcEpRegister Failed\n");
        return;
        }

    PrintToConsole("Bartholomew : BartholomewHelper Exiting\n");
}


void
Bartholomew (
    )
/*++

Routine Description:

    This routine works with Benjamin in uclnt.exe to test that dynamic
    endpoints work.  What we actually do is inquire all bindings supported
    by this server, and then have the client bind to each of them, and
    make a call.

--*/
{
    PrintToConsole("Bartholomew : Test Dynamic Endpoints\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(BARTHOLOMEW), 0);
    if (Status)
        {
        ApiError("Bartholomew", "RpcServerUseProtseqEpWrapper", Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Use Protseq ");
        PrintToConsole("Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Bartholomew","stub_RegisterIf",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    // Synchro support
    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Bartholomew","stub_RegisterIf",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Bartholomew","stub_RegisterIf",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Register Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    Status = RpcServerUseProtseqWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS, 0);
    if (Status)
        {
        ApiError("Bartholomew","RpcServerUseProtseq",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Use Protseq\n");
        return;
        }

    Status = RpcServerUseAllProtseqsWrapper(1, 0);
    if (Status)
        {
        ApiError("Bartholomew","RpcServerUseAllProtseqsWrapper",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Use All Protseqs\n");
        return;
        }

    if ( InquireBindings("Bartholomew") != 0 )
        {
        return;
        }

    Status = RpcServerInqBindings(&BartholomewRpcBindingVector);
    if (Status)
        {
        ApiError("Bartholomew", "RpcServerInqBindings", Status);
        PrintToConsole("Bartholomew : FAIL - RpcServerInqBindings\n");
        return;
        }

    BartholomewIndex = 0;

    if ( UseEndpointMapperFlag != 0 )
        {
        Status = RpcEpRegisterA((RPC_IF_HANDLE) &IsabelleInterfaceInformation,
                BartholomewRpcBindingVector, 0,
                (unsigned char PAPI *) "usvr.exe");
        if (Status)
            {
            ApiError("Bartholomew", "RpcEpRegister", Status);
            PrintToConsole("Bartholomew : FAIL - RpcEpRegister Failed\n");
            return;
            }

        Status = RpcEpRegisterNoReplaceA(
                (RPC_IF_HANDLE) &SylviaInterfaceInformation,
                BartholomewRpcBindingVector, 0,
                (unsigned char PAPI *) "usvr.exe");
        if (Status)
            {
            ApiError("Bartholomew", "RpcEpRegisterNoReplace", Status);
            PrintToConsole("Bartholomew : FAIL - RpcEpRegister Failed\n");
            return;
            }

#ifdef WIN32RPC

        PROCESS_INFORMATION ProcessInformation;
        STARTUPINFOA StartupInfo;

        StartupInfo.cb = sizeof(STARTUPINFOA);
        StartupInfo.lpReserved = 0;
        StartupInfo.lpDesktop = 0;
        StartupInfo.lpTitle = 0;
        StartupInfo.dwX = 0;
        StartupInfo.dwY = 0;
        StartupInfo.dwXSize = 0;
        StartupInfo.dwYSize = 0;
        StartupInfo.dwFlags = 0;
        StartupInfo.wShowWindow = 0;
        StartupInfo.cbReserved2 = 0;
        StartupInfo.lpReserved2 = 0;

        char CommandLine[200];

        strcpy(CommandLine, "usvr ");
        strcat(CommandLine, TransportOption);

        strcat(CommandLine, " -bartholomewhelper");

        if (CreateProcessA(0, CommandLine, 0, 0, FALSE,
                0, 0, 0, &StartupInfo, &ProcessInformation) == FALSE)
            {
            OtherError("Bartholomew","CreateProcessA Failed");
            PrintToConsole("Bartholomew : FAIL - CreateProcess Failed\n");
            return;
            }

#endif // WIN32RPC

        PauseExecution(2000L);
        }

    PrintToConsole("Bartholomew : Listening\n") ;
    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Bartholomew","stub_ServerListen",Status);
        PrintToConsole("Bartholomew : FAIL - stub_ServerListen Failed\n");
        return;
        }

    Status = RpcBindingVectorFree(&BartholomewRpcBindingVector);
    if (Status)
        {
        ApiError("Bartholomew", "RpcBindingVectorFree", Status);
        PrintToConsole("Bartholomew : FAIL - RpcBindingVectorFree\n");
        return;
        }

    if (BartholomewRpcBindingVector != 0)
        {
        PrintToConsole("Bartholomew : FAIL - ");
        PrintToConsole("BartholomewRpcBindingVector != 0\n");
        return;
        }

    // Synchro support
    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Bartholomew","RpcServerUnregisterIf",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Unregister ");
        PrintToConsole("Interface (Helga)\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Bartholomew : FAIL - Error(s) in Isabelle");
        PrintToConsole(" Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Bartholomew","RpcServerUnregisterIf",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Unregister ");
        PrintToConsole("Interface (Isabelle)\n");
        return;
        }

    if (SylviaErrors != 0)
        {
        PrintToConsole("Bartholomew : FAIL - Error(s) in Sylvia");
        PrintToConsole(" Interface\n");
        HelgaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Bartholomew","RpcServerUnregisterIf",Status);
        PrintToConsole("Bartholomew : FAIL - Unable to Unregister ");
        PrintToConsole("Interface (Sylvia)\n");
        return;
        }

    PrintToConsole("Bartholomew : PASS\n");
}

void
TestYield (
    )
/*++

Routine Description:

    This routine works with Harold in uclnt.exe to test that idle
    connections get cleaned up properly, and that context is maintained.

--*/
{
    PrintToConsole("TestYeild : Test Yielding\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(TESTYIELD), 0);
    if (Status)
        {
        ApiError("TestYield","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("TestYield: FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    // Synchro support
    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("TestYield","stub_RegisterIf",Status);
        PrintToConsole("TestYield: FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("TestYield","stub_ServerListen",Status);
        PrintToConsole("TestYield: FAIL - stub_ServerListen Failed\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Herman","RpcServerUnregisterIf",Status);
        PrintToConsole("Herman : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("TestYield: PASS\n");
}


void
Herman (
    )
/*++

Routine Description:

    This routine works with Harold in uclnt.exe to test that idle
    connections get cleaned up properly, and that context is maintained.

--*/
{
    PrintToConsole("Herman : Test Idle Connection Cleanup and Context\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(HERMAN), 0);
    if (Status)
        {
        ApiError("Herman","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Herman : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    // Synchro support
    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Herman","stub_RegisterIf",Status);
        PrintToConsole("Herman : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Herman","stub_RegisterIf",Status);
        PrintToConsole("Herman : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Herman","stub_ServerListen",Status);
        PrintToConsole("Herman : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Herman : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Herman","RpcServerUnregisterIf",Status);
        PrintToConsole("Herman : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Herman","RpcServerUnregisterIf",Status);
        PrintToConsole("Herman : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Herman : PASS\n");
}


void
Ivan (
    )
/*++

Routine Description:

    This routine stress tests the runtime.  It works with Isaac in uclnt.exe.

--*/
{
    PrintToConsole("Ivan : Stress Test\n");

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(IVAN), 0);
    if (Status)
        {
        ApiError("Ivan","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Ivan : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Ivan","stub_RegisterIf",Status);
        PrintToConsole("Ivan : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Ivan","stub_RegisterIf",Status);
        PrintToConsole("Ivan : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Ivan","stub_ServerListen",Status);
        PrintToConsole("Ivan : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Ivan : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Ivan","RpcServerUnregisterIf",Status);
        PrintToConsole("Ivan : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Ivan : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Ivan","RpcServerUnregisterIf",Status);
        PrintToConsole("Ivan : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Ivan : PASS\n");
}


void
Jason (
    )
/*++

Routine Description:

    This routine helps perform performance tests of the runtime.  It works
    with James in uclnt.exe.

--*/
{
    PrintToConsole("Jason : Timing Tests With %d Listen Threads\n",
            MinimumListenThreads);

    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(JASON), 0);
    if (Status)
        {
        ApiError("Jason","RpcServerUseProtseqEpWrapper",Status);
        PrintToConsole("Jason : FAIL - Unable to Use Protseq Endpoint\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Jason","stub_RegisterIf",Status);
        PrintToConsole("Jason : FAIL - Unable to Register Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Jason","stub_RegisterIf",Status);
        PrintToConsole("Jason : FAIL - Unable to Register Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError("Jason","stub_ServerListen",Status);
        PrintToConsole("Jason : FAIL - stub_ServerListen Failed\n");
        return;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("Jason : FAIL - Error(s) in Isabelle Interface\n");
        IsabelleErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Jason","RpcServerUnregisterIf",Status);
        PrintToConsole("Jason : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Isabelle)\n");
        return;
        }

    if (HelgaErrors != 0)
        {
        PrintToConsole("Jason : FAIL - Error(s) in Helga Interface\n");
        HelgaErrors = 0;
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Jason","RpcServerUnregisterIf",Status);
        PrintToConsole("Jason : FAIL - Unable to Unregister Interface ");
        PrintToConsole("(Helga)\n");
        return;
        }

    PrintToConsole("Jason : PASS\n");
}

void
WaitForAddressListChange (
    IN void *Ignore
    )
{
    OVERLAPPED ol;
    SOCKET sock;
    HANDLE hEvent;
    SOCKADDR_IN sockaddr;
    DWORD           byteRet;

    hEvent = CreateEvent(0, FALSE, FALSE, 0);
    if (hEvent == 0)
        {
        ApiError("WaitForAddressListChange", "CreateEventW", 0);
        return ;
        }

    sock = WSASocket(AF_INET,
                      SOCK_STREAM,
                      IPPROTO_TCP,
                      0,
                      0,
                      WSA_FLAG_OVERLAPPED);
    if (sock == INVALID_SOCKET)
        {
        ApiError("WaitForAddressListChange", "WSASocketW", GetLastError());
        return;
        }

    sockaddr.sin_addr.s_addr = INADDR_ANY;
    sockaddr.sin_family = AF_INET;
    sockaddr.sin_port = 0;

    if (bind(sock,(struct sockaddr *) &sockaddr, sizeof(SOCKADDR_IN)))
        {
        closesocket(sock);
        return;
        }

    if(listen(sock, 10) == SOCKET_ERROR)
        {
        closesocket(sock);
        return;
        }

    while (1)
        {
        ol.hEvent = hEvent;
        ol.Offset = 0;
        ol.OffsetHigh = 0;

        if (WSAIoctl(sock,
                     SIO_ADDRESS_LIST_CHANGE,
                     0, 0, 0, 0, &byteRet, &ol, 0) == SOCKET_ERROR)
            {
            if (WSAGetLastError() != ERROR_IO_PENDING)
                {
                ApiError("WaitForAddressListChange", "DeviceIoControl",
                         GetLastError());
                return;
                }

            //
            // Wait for the IO to complete
            //
            WaitForSingleObject(hEvent,INFINITE);
            }
        //
        // figure out the new address list
        //

        //
        // First find out how big a buffer do we need.
        //
        byteRet = 0;
        if (WSAIoctl(sock,
                    SIO_ADDRESS_LIST_QUERY,
                    0, 0, 0, 0, &byteRet, NULL, NULL) == 0)
            {
            I_RpcRequestMutex(&PrintMutex);
            PrintToConsole("The Address list has changed, it is now empty\n");
            I_RpcClearMutex(PrintMutex);
            continue;
            }
        else
            {
            if (WSAGetLastError() != WSAEFAULT || byteRet == 0 )
                {
                ApiError("WaitForAddressListChange", "SIO_ADDRESS_LIST_QUERY",
                         WSAGetLastError());
                return;
                }
            }

        LPSOCKET_ADDRESS_LIST  interfaceList =
            (LPSOCKET_ADDRESS_LIST) I_RpcAllocate(byteRet);
        if( interfaceList == NULL )
            {
            ApiError("WaitForAddressListChange", "I_RpcAllocate", 0);
            return;
            }


        if (WSAIoctl(sock,
                    SIO_ADDRESS_LIST_QUERY,
                    0, 0, interfaceList, byteRet,&byteRet,NULL, NULL) != ERROR_SUCCESS)
            {
            ApiError("WaitForAddressListChange", "SIO_ADDRESS_LIST_QUERY",
                     WSAGetLastError());
            return;
            }

        I_RpcRequestMutex(&PrintMutex);
        PrintToConsole("The Address list has changed:\n");
        int i;
        for (i = 0; i < interfaceList->iAddressCount; i++)
            {
            PrintToConsole("AF: %d, Address: ",
                           interfaceList->Address[i].lpSockaddr->sa_family);
            int j;
            for (j = 0; j<14; j++)
                {
                PrintToConsole("%u ",
                               (unsigned char) interfaceList->Address[i].lpSockaddr->sa_data[j]);
                }
            PrintToConsole("\n");
            }
        PrintToConsole("\n");
        I_RpcClearMutex(PrintMutex);
        }


}
static unsigned long DefaultThreadStackSize = 0;

int
TestPNP (
    )
{
    unsigned long ThreadIdentifier;
    HANDLE NotificationHandle = 0;
    WSAOVERLAPPED Overlapped;
    unsigned long bytes;
    HANDLE hEvent;
    WSADATA data;
    int retval ;

    if (WSAStartup(2, &data) != NO_ERROR)
        {
        return -1;
        }

    //
    // Create another thread to go off and wait on address list
    // changes
    //
    if (CreateThread(0,
                     DefaultThreadStackSize,
                     (LPTHREAD_START_ROUTINE) WaitForAddressListChange,
                     0,
                     0,
                     &ThreadIdentifier) == 0)
        {
        ApiError("TestPNP", "CreateThread", GetLastError());
        return -1;
        }

    hEvent = CreateEvent(0, FALSE, FALSE, 0);
    if (hEvent == 0)
        {
        ApiError("TestPNP", "CreateEventW", 0);
        return -1;
        }

    retval = WSAProviderConfigChange(
                    &NotificationHandle,
                    &Overlapped,
                    0
                    );

    if (retval != 0 || NotificationHandle == 0)
        {
        ApiError("TestPNP", "WSAProviderConfigChange", retval);
        return -1;
        }

    while (1)
        {
        Overlapped.hEvent = hEvent;
        Overlapped.Offset = 0;
        Overlapped.OffsetHigh = 0;

        retval = WSAProviderConfigChange(
                        &NotificationHandle,
                        &Overlapped,
                        0
                        );

        if (retval != 0)
            {
            if (GetLastError() == WSA_IO_PENDING)
                {
                WaitForSingleObject(hEvent,INFINITE);
                }
            else
                {
                ApiError("TestPNP", "WSAProviderConfigChange", retval);
                return -1;
                }
            }

        WSAPROTOCOL_INFO *lpProtocolBuffer;
        DWORD dwBufferLength = 1;
        int ProtocolCount;

        while (1)
            {
            lpProtocolBuffer = (WSAPROTOCOL_INFO *) I_RpcAllocate(dwBufferLength);
            if (lpProtocolBuffer == 0)
                {
                ApiError("TestPNP", "I_RpcAllocate", 0);
                return -1;
                }

            ProtocolCount = WSAEnumProtocols(
                                      0,
                                      lpProtocolBuffer,
                                      &dwBufferLength
                                      );
            if (ProtocolCount != SOCKET_ERROR)
                {
                break;
                }

            I_RpcFree(lpProtocolBuffer);

            if (GetLastError() != WSAENOBUFS)
                {
                return -1;
                }
            }

        int i;
        //
        // take the print mutex for the entire output, so we don't
        // garble it with the other thread
        //
        I_RpcRequestMutex(&PrintMutex);
        PrintToConsole("LoadedProtocols:\n");
        for (i = 0; i < ProtocolCount; i++)
            {
            PrintToConsole("SocketType: %d, Protocol:%d, Address Family: %d\n",
                           lpProtocolBuffer[i].iSocketType,
                           lpProtocolBuffer[i].iProtocol,
                           lpProtocolBuffer[i].iAddressFamily);

            }
        PrintToConsole("\n");
        I_RpcClearMutex(PrintMutex);
        }
}

void
RpcYield()
{
    RpcServerYield();
}

void FireWall (
    )
{
    PMIB_IFTABLE pMib;
    DWORD Size = 20*sizeof(MIB_IFROW)+sizeof(DWORD);
    UINT i, j;

    for (i = 0; i < 2; i++)
        {
        pMib = (PMIB_IFTABLE) I_RpcAllocate(Size);
        if (pMib == 0)
            {
            return;
            }

        RpcpMemorySet(pMib, 0, Size);

        Status = GetIfTable(pMib, &Size, 0);
        if (Status == 0)
            {
            break;
            }
        }

    if (Status != RPC_S_OK)
        {
        return;
        }

    for (i = 1; i < pMib->dwNumEntries+1; i++)
        {
        for (j = 0; j < pMib->dwNumEntries; j++)
            {
            if (pMib->table[j].dwIndex == i)
                {
                PrintToConsole("IF[%d]: Ethernet: %s\n", i,
                               (char *) pMib->table[j].bDescr);
                break;
                }
            }
        }
}


extern void
Async (
    ) ;

int __cdecl
main (
    int argc,
    char * argv[]
    )

/*
Transports:

    Update this to add a new transport.
*/

{
    int argscan, testflag = 0;
    RPC_STATS_VECTOR * Statistics;
    char *option ;

    TransportType = RPC_TRANSPORT_NAMEPIPE;

    for (argscan = 1; argscan < argc; argscan++)
        {
        if (strcmp(argv[argscan], "-p") == 0)
        {
            ulSecurityPackage = (unsigned long) atol(argv[argscan+1]);
            argscan++;
        }
        else if (strcmp(argv[argscan],"-warn") == 0)
            WarnFlag = 1;
        else if (strcmp(argv[argscan],"-error") == 0)
            ErrorFlag = 1;
        else if (strcmp(argv[argscan],"-v") == 0)
            Verbose = 1;
        else if (strcmp(argv[argscan],"-verbose") == 0)
            Verbose = 1;
        else if (strcmp(argv[argscan],"-rpcss") == 0)
            {
            UseEndpointMapperFlag = 1;
            }
        else if (strcmp(argv[argscan],"-nosecuritytests") == 0)
            {
            NoSecurityTests = 1;
            }
        else if (strcmp(argv[argscan],"-sigfried") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Sigfried();
           }
       else if (strcmp(argv[argscan],"-hybrid") == 0)
           {
           testflag = 1;
           PrintToConsole("RPC Runtime Hybrid Server Test\n");
           Hybrid();
           }
       else if (strcmp(argv[argscan],"-lpcsecurity") == 0)
           {
           testflag = 1;
           PrintToConsole("RPC Runtime Lpc Security Test\n");
           LpcSecurity();
           }
       else if (strcmp(argv[argscan],"-objuuid") == 0)
           {
           testflag = 1;
           PrintToConsole("RPC Obj Uuid test\n");
           TestObjectUuids();
           }
       else if (strcmp(argv[argscan],"-connid") == 0)
           {
           testflag = 1;
           PrintToConsole("RPC Conn Id test\n");
           TestObjectUuids();
           }
       else if (strcmp(argv[argscan],"-async") == 0)
           {
           testflag = 1;
           PrintToConsole("RPC Runtime Async RPC Tests\n");
           Async();
           }
       else if (strcmp(argv[argscan],"-ee") == 0)
           {
           PrintToConsole("enabling extended errors\n");
           fExtendedError = TRUE;
           }
       else if (strcmp(argv[argscan],"-dgtransport") == 0)
           {
           testflag = 1;
           PrintToConsole("datagram transport tests \n");
           DgTransport();
           }
       else if (strcmp(argv[argscan],"-sendack") == 0)
           {
           testflag = 1;
           PrintToConsole("RPC Runtime datagram delayed-ack Tests\n");
           SendAck();
           }
       else if (strcmp(argv[argscan],"-securityerror") == 0)
           {
           int testnum;

           testflag = 1;
           PrintToConsole("security provider error tests \n");

           argscan++ ;

           if (argscan == argc)
               {
               PrintToConsole("-securityerror: you must specify a test #, or zero for all, or '?' for help\n");
               return 1;
               }

           if (strcmp(argv[argscan], "?") == 0)
               {
               testnum = 100 ;
               }
           else
               {
               testnum = atoi(argv[argscan]) ;
               }
           SecurityErrorWrapper(testnum);
           }
        else if (strcmp(argv[argscan],"-grant") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Grant();
            }
        else if (strcmp(argv[argscan],"-elliot") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Elliot();
            }
        else if (strcmp(argv[argscan],"-andromida") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Andromida();
            }
        else if (strcmp(argv[argscan],"-fredrick") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Fredrick();
            }
        else if (strcmp(argv[argscan],"-christopher") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Christopher();
            }
        else if (strcmp(argv[argscan],"-david") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            David();
            }
        else if (strcmp(argv[argscan],"-tyler") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Tyler();
            }
        else if (strcmp(argv[argscan],"-terry") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Terry();
            }
        else if (strcmp(argv[argscan],"-richardhelper") == 0)
            {
            testflag = 1;
            RichardHelper();
            return(0);
            }
        else if (strcmp(argv[argscan],"-bartholomewhelper") == 0)
            {
            testflag = 1;
            BartholomewHelper();
            return(0);
            }
        else if (strcmp(argv[argscan],"-richard") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Richard();
            }
        else if (strcmp(argv[argscan],"-bartholomew") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Bartholomew();
            }
        else if (strcmp(argv[argscan],"-herman") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Herman();
            }
        else if (strcmp(argv[argscan],"-ivan") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Ivan();
            }
        else if (strcmp(argv[argscan],"-jason") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Jason();
            }
        else if (strcmp(argv[argscan],"-kenneth") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            Kenneth();
            }
        else if (strcmp(argv[argscan],"-pipe") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            SPipe();
            }
        else if (strcmp(argv[argscan],"-testyield") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            TestYield();
            }
        else if (strcmp(argv[argscan],"-yield") == 0)
            {
            testflag = 1;
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            RpcYield();
            }
        else if (strcmp(argv[argscan],"-pnp") == 0)
            {
            testflag = 1;
            PrintToConsole("Test PNP stuff\n");
            TestPNP();
            }
        else if (strcmp(argv[argscan],"-namepipe") == 0)
            {
            TransportType = RPC_TRANSPORT_NAMEPIPE;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-lrpc") == 0)
            {
            TransportType = RPC_LRPC;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-tcp") == 0)
            {
            TransportType = RPC_TRANSPORT_TCP;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-udp") == 0)
            {
            DatagramFlag = 1;
            TransportType = RPC_TRANSPORT_UDP;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-dnet") == 0)
            {
            TransportType = RPC_TRANSPORT_DNET;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-spx") == 0)
            {
            TransportType = RPC_TRANSPORT_SPX;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-ipx") == 0)
            {
            DatagramFlag = 1;
            TransportType = RPC_TRANSPORT_IPX;
            TransportOption = argv[argscan];
            }
        else if (strcmp(argv[argscan],"-vns") == 0)
            {
            TransportType = RPC_TRANSPORT_VNS;
            TransportOption = argv[argscan];
            }

        else if (strcmp(argv[argscan], "-dsp") == 0)
            {
            TransportType = RPC_TRANSPORT_DSP ;
            TransportOption = argv[argscan] ;
            }

        else if (strcmp(argv[argscan], "-msmq") == 0)
            {
            DatagramFlag = 1;
            TransportType = RPC_TRANSPORT_MSMQ ;
            TransportOption = argv[argscan] ;
            }

        else if (strcmp(argv[argscan], "-autolisten") == 0)
            {
            AutoListenFlag = 1 ;
            }
        else if (strcmp(argv[argscan], "-ifsecurity") == 0)
            {
            IFSecurity = 1;
            }
        else if (strcmp(argv[argscan], "-firewall") == 0)
            {
            testflag = 1;
            FireWallFlag = 1 ;
            FireWall();
            }

        else if (strcmp(argv[argscan],"-protocol") == 0)
            {
            strcpy(NetBiosProtocol+sizeof("ncacn_nb_")-1, argv[argscan+1]);
            argscan++;
            }
        else if (strcmp(argv[argscan],"-netbios") == 0)
            {
            TransportType = RPC_TRANSPORT_NETBIOS;
            TransportOption = argv[argscan];
            }
        else if (strncmp(argv[argscan], "-listen:", strlen("-listen:"))
                    == 0 )
            {
            MinimumListenThreads = atoi(argv[argscan] + strlen("-listen:"));
            if ( MinimumListenThreads == 0 )
                {
                MinimumListenThreads = 1;
                }
            }
        else if (strncmp(argv[argscan], "-rpcsize:", strlen("-rpcsize:"))
                    == 0 )
            {
            MaxRpcSize = atoi(argv[argscan] + strlen("-rpcsize:"));
            }
        else if (argv[argscan][0] == '-')
            {
            PrintToConsole("unknown option '%s'\n", argv[argscan]);
            return 1;
            }
        else
            {
            PrintToConsole("RPC Runtime Server Build Verification Test\n");
            PrintToConsole("Usage : usvr\n");
            PrintToConsole("        -warn : turn on warning messages\n");
            PrintToConsole("        -error : turn on error messages\n");
            PrintToConsole("        -sigfried\n");
            PrintToConsole("        -grant\n");
            PrintToConsole("        -elliot\n");
            PrintToConsole("        -andromida\n");
            PrintToConsole("        -fredrick\n");
            PrintToConsole("        -christopher\n");
            PrintToConsole("        -david\n");
            PrintToConsole("        -tyler\n");
            PrintToConsole("        -terry\n");
            PrintToConsole("        -richard\n");
            PrintToConsole("        -bartholomew\n");
            PrintToConsole("        -herman\n");
            PrintToConsole("        -ivan\n");
            PrintToConsole("        -jason\n");
            PrintToConsole("        -kenneth\n");
            PrintToConsole("        -namepipe\n");
            PrintToConsole("        -lrpc\n");
            PrintToConsole("        -tcp\n");
            PrintToConsole("        -udp\n");
            PrintToConsole("        -dnet\n");
            PrintToConsole("        -netbios\n");
            PrintToConsole("        -spx\n");
            PrintToConsole("        -dsp\n") ;
            PrintToConsole("        -vns\n") ;
            PrintToConsole("        -msmq\n") ;
            PrintToConsole("        -listen:<listen threads>\n");
            PrintToConsole("        -rpcss\n");
            PrintToConsole("        -p <security provider #>\n");
            PrintToConsole("        -nosecuritytests") ;
            return(1);
            }
        }


    if (!testflag)
        {
        PrintToConsole("RPC Runtime Server Build Verification Test\n");
    PrintToConsole("Sigfried\n") ;
        Sigfried();
    PrintToConsole("Grant\n") ;
        Grant();
    PrintToConsole("Elliot\n") ;
        Elliot();
    PrintToConsole("Andromida\n") ;
        Andromida();
    PrintToConsole("Fredrick\n") ;
        Fredrick();
    PrintToConsole("Christopher\n") ;
        Christopher();
    PrintToConsole("David\n") ;
        David();
        if ( NoSecurityTests == 0)
            {
        PrintToConsole("Tyler\n") ;
            Tyler();
            }
        if ( TransportType != RPC_LRPC )
            {
        PrintToConsole("Richard\n") ;
            Richard();
            }
    PrintToConsole("Kenneth\n") ;
        Kenneth();
    PrintToConsole("Bartholomew\n") ;
        Bartholomew();
    PrintToConsole("Async\n") ;
        Async();
        }

    Status = RpcMgmtInqStats(0,&Statistics);
    if (Status)
        {
        ApiError("main", "RpcMgmtInqStats", Status);
        return(0);
        }

    PrintToConsole("\nCalls (and Callbacks) Received : %lu",
            Statistics->Stats[RPC_C_STATS_CALLS_IN]);
    PrintToConsole("\nCallbacks Sent : %lu",
            Statistics->Stats[RPC_C_STATS_CALLS_OUT]);
    PrintToConsole("\nPackets Received : %lu\nPackets Sent : %lu\n",
            Statistics->Stats[RPC_C_STATS_PKTS_IN],
            Statistics->Stats[RPC_C_STATS_PKTS_OUT]);

    Status = RpcMgmtStatsVectorFree(&Statistics);
    if (Status)
        ApiError("main", "RpcMgmtStatsVectorFree", Status);

    return(0); // To keep the compiler happy.
}


//
// BVT for Async RPC
//

//
// Server side code
//

//
// the following routines outline the server side code for a simple async function.
//

#define TRACE(_x) { \
    if (Verbose) \
        {\
        PrintToConsole _x;\
        }\
    }

#if 0
//
// Begin, Approximate idl file
//
interface FooInterface {
    int Foo (handle_t hBinding, [in] int sizein, [in] int *bufferin,
                [in, out] int *sizeout, [out] int **bufferout) ;
    }
// End, idl file

//
// Begin, Corresponding ACF file
//
interface FooInterface {
    [async] Foo () ;
    }
// End, acf file

//
// look at asyncstub.h for the generated header
// file for function Foo
//
#endif

////////////////////////////////////////////////////////////
// Begin, stubs for Foo                                                      //
////////////////////////////////////////////////////////////

RPC_STATUS RPC_ENTRY
MyRpcAbortAsyncCall (
    IN PRPC_ASYNC_STATE pAsync,
    IN unsigned long ExceptionCode
    )
/*++

Routine Description:


Arguments:
 pAsync - the async handle being registered

Return Value:
    RPC_S_OK - the call succeeded.
    RPC_S_INVALID_HANDLE - the handle was bad.

--*/

{
    return I_RpcAsyncAbortCall(pAsync, ExceptionCode);
}


typedef struct {
    RPC_ASYNC_STUB_STATE StubState ;
    RPC_ASYNC_STATE AsyncState ;
    void *state ;
    int sizeout ;
    int *bufferout ;
    } FOO_ASYNC_SERVER_STATE;


RPC_STATUS
FooComplete (
    IN PRPC_ASYNC_STATE pAsync,
    IN void *Reply
    )
/*++

Routine Description:
    This is a generated stub. It is the completion routine for the function
    Foo. When the server app is done with processing a particular call to
    Foo, It calls Foo_complete to complete the call.

Arguments:

 pAsync - The async handle. This handle is always the first parameter of every
    Foo_complete routine.
--*/

{
    int *Ptr ;
    RPC_MESSAGE Message ;
    RPC_STATUS RpcStatus ;
    FOO_ASYNC_SERVER_STATE *StubInfo =
            (FOO_ASYNC_SERVER_STATE *) pAsync->StubInfo ;

    TRACE(("FooComplete called: %d\n", *((int *) Reply))) ;

    Message.ProcNum = RPC_FLAGS_VALID_BIT ;
    Message.RpcFlags = RPC_BUFFER_ASYNC;
    Message.BufferLength = 8 + StubInfo->sizeout  ;
    Message.Handle = StubInfo->StubState.CallHandle ;

    RpcStatus = I_RpcGetBuffer(&Message) ;
    if (RpcStatus)
        {
        return RpcStatus ;
        }

    Ptr = (int *) Message.Buffer ;
    *Ptr++ = *((int *) Reply) ;
    *Ptr++ = StubInfo->sizeout ;
    RpcpMemoryCopy(Ptr, StubInfo->bufferout, StubInfo->sizeout) ;

    I_RpcFree(StubInfo->bufferout) ;

    // send the async reply
    Message.RpcFlags = RPC_BUFFER_ASYNC;
    RpcStatus = I_RpcSend(&Message) ;
    if (RpcStatus)
        {
        return RpcStatus ;
        }

    I_RpcFree(pAsync->StubInfo) ;

    return RPC_S_OK ;
}


void
Foo_s (
    PRPC_MESSAGE Message
    )
/*++

Routine Description:

 Generated stub for Foo.

--*/

{
    int sizein ;
    int *bufferin ;
    int *Ptr ;
    FOO_ASYNC_SERVER_STATE *StubInfo;
    RPC_STATUS RpcStatus ;

    if ((Message->RpcFlags & RPC_BUFFER_COMPLETE) == 0)
        {
        Message->RpcFlags = RPC_BUFFER_EXTRA;
        RpcStatus = I_RpcReceive (Message, 0) ;
        if (RpcStatus)
            {
            RpcRaiseException(RpcStatus) ;
            }
        }

    StubInfo = (FOO_ASYNC_SERVER_STATE *)
               I_RpcAllocate(sizeof(FOO_ASYNC_SERVER_STATE)) ;

    if (StubInfo == 0)
        {
        RpcRaiseException(RPC_S_OUT_OF_MEMORY) ;
        }

    StubInfo->AsyncState.Size = sizeof(RPC_ASYNC_STATE) ;
    StubInfo->AsyncState.StubInfo = (void *) StubInfo ;
    StubInfo->AsyncState.Flags = 0;
    StubInfo->AsyncState.NotificationType = RpcNotificationTypeNone;

    StubInfo->StubState.CallHandle = Message->Handle ;
    StubInfo->StubState.Flags = 0;
    StubInfo->StubState.CompletionRoutine = FooComplete ;

    RpcStatus = I_RpcAsyncSetHandle(
                        Message,
                        (PRPC_ASYNC_STATE) &(StubInfo->AsyncState)) ;
    if (RpcStatus)
        {
        RpcRaiseException(RpcStatus) ;
        }

    // unmarshall the received data
    Ptr = (int *) Message->Buffer ;
    sizein = *Ptr++ ;
    bufferin = Ptr ;

    Ptr += (sizein+3)/sizeof(int) ;
    StubInfo->sizeout = *Ptr ;

    Foo ((PRPC_ASYNC_STATE) &(StubInfo->AsyncState),
            Message->Handle,
            sizein,
            bufferin,
            &(StubInfo->sizeout),
            &(StubInfo->bufferout)) ;

}

////////////////////////////////////////////////////////////
// End, stubs for Foo                                                         //
////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////
// Begin, Application                                                       //
//////////////////////////////////////////////////////////

typedef struct {
    PRPC_ASYNC_STATE pAsync ;
    RPC_BINDING_HANDLE hBinding ;
    int *sizeout ;
    int **bufferout ;
    } CALL_COOKIE ;


void
ThreadProc(
    CALL_COOKIE *Cookie
    )
/*++

Routine Description:

    The thread that calls Foo_complete. Foo_complete is being called
    in a separate thread to show that it infact can be.

Arguments:
    pAsync - the async handle on which Foo_complete needs to be called.

--*/

{
    int retval = 1;
    UUID ObjectUuid;

    TRACE(("Foo: Sending back async reply\n"));

    Status = RpcBindingInqObject(Cookie->hBinding, &ObjectUuid);
    if (Status)
        {
        goto Cleanup;
        }

    if (CheckUuidValue(UUID_ASYNC_EXCEPTION, &ObjectUuid) == 0)
        {
        MyRpcAbortAsyncCall(Cookie->pAsync, ASYNC_EXCEPT) ;
        return ;
        }

    *(Cookie->bufferout) = (int *) I_RpcAllocate(*(Cookie->sizeout)) ;
    if (*(Cookie->bufferout) == 0)
        {
        goto Cleanup;
        }

    if (CheckUuidValue(UUID_SLEEP_1000, &ObjectUuid) == 0)
        {
        Sleep(1000);
        }
    if (CheckUuidValue(UUID_SLEEP_2000, &ObjectUuid) == 0)
        {
        Sleep(2000);
        }
    else if (CheckUuidValue(UUID_TEST_CANCEL, &ObjectUuid) == 0)
        {
        if (RpcServerTestCancel(RpcAsyncGetCallHandle(Cookie->pAsync)) == RPC_S_OK)
            {
            PrintToConsole("Async: Call was cancelled\n");
            MyRpcAbortAsyncCall(Cookie->pAsync, ASYNC_EXCEPT) ;
            return;
            }
        }
    else if (CheckUuidValue(UUID_EXTENDED_ERROR, &ObjectUuid) == 0)
        {
        RPC_EXTENDED_ERROR_INFO ErrorInfo;

        ErrorInfo.Version = RPC_EEINFO_VERSION;
        ErrorInfo.ComputerName = NULL;
        ErrorInfo.Flags = 0;
        ErrorInfo.NumberOfParameters = 1;
        ErrorInfo.DetectionLocation = 0;
        ErrorInfo.GeneratingComponent = 0;
        ErrorInfo.ProcessID = 0;
        ErrorInfo.Status = EXTENDED_ERROR_EXCEPTION;
        ErrorInfo.Parameters[0].ParameterType = eeptAnsiString;

        ErrorInfo.Parameters[0].u.AnsiString = "first element of three generated by usvr in ThreadProc()";
        RpcErrorAddRecord(&ErrorInfo);

        ErrorInfo.Parameters[0].u.AnsiString = "second element of three generated by usvr in ThreadProc()";
        RpcErrorAddRecord(&ErrorInfo);

        ErrorInfo.Parameters[0].u.AnsiString = "third element of three generated by usvr in ThreadProc()";
        RpcErrorAddRecord(&ErrorInfo);
        MyRpcAbortAsyncCall(Cookie->pAsync, EXTENDED_ERROR_EXCEPTION);
        return;
        }

    Status = MyRpcCompleteAsyncCall(Cookie->pAsync, &retval) ;
    if (Status != RPC_S_OK)
        {
        PrintToConsole("Async: RpcCompleteAsyncCall return: %d\n",
                       Status);
        }

    Sleep(100);
    return;

Cleanup:

    PrintToConsole("ThreadProc: an unknown error occurred; returning out-of-memory\n");

    MyRpcAbortAsyncCall(Cookie->pAsync, RPC_S_OUT_OF_MEMORY) ;
    IsabelleError() ;
}

int Count = 0;


void
Foo (
    IN PRPC_ASYNC_STATE pAsync,
    IN RPC_BINDING_HANDLE hBinding,
    IN int sizein,
    IN int *bufferin,
    IN OUT int *sizeout,
    OUT int **bufferout
    )
/*++

Routine Description:

    This is a actual manager routine. It can spawn off an async operation
    (a thread in this case) to do the rest of the work, and send back the
    reply when it is done.

Arguments:
    pAsync - Async handle. This is always the first parameter of every async
    handle.
--*/

{
  unsigned long ThreadIdentifier;
  HANDLE HandleToThread ;
  CALL_COOKIE *CallCookie ;
  UUID ObjectUuid;

  Status = RpcBindingInqObject(hBinding, &ObjectUuid);
  if (Status)
      {
      PrintToConsole("Foo: can't inq object uuid, error = %d\n", Status);
      RpcRaiseException(Status);
      }

  if (CheckUuidValue(UUID_SYNC_EXCEPTION, &ObjectUuid) == 0)
      {
      RpcRaiseException(SYNC_EXCEPT) ;
      }

  Count++ ;
  TRACE(("Foo: Count %d\n", Count)) ;
  if ((Count % 7) == 0)
      {
      Sleep(100) ;
      }

  CallCookie = new CALL_COOKIE ;
  if (CallCookie == 0)
      {
      RpcRaiseException(APP_ERROR) ;
      }

  CallCookie->pAsync = pAsync ;
  CallCookie->sizeout = sizeout ;
  CallCookie->bufferout = bufferout ;
  CallCookie->hBinding = hBinding;

  if (*sizeout > 100000)
      {
      DebugBreak();
      }

  if (RpcServerTestCancel(RpcAsyncGetCallHandle(pAsync)) == RPC_S_OK)
      {
      PrintToConsole("Async: Call was cancelled\n");
      }

  if ((Count % 3) == 0)
      {
      ThreadProc(CallCookie);
      }
  else
      {
      HandleToThread = CreateThread(
                                0,
                                DefaultThreadStackSize,
                                (LPTHREAD_START_ROUTINE) ThreadProc,
                                CallCookie,
                                0,
                                &ThreadIdentifier);

      if (HandleToThread == 0)
        {
        PrintToConsole("Foo: Error, could not create thread\n") ;
        return ;
        }

       CloseHandle(HandleToThread);
      }

  // return to the server stub.
}

///////////////////////////////////////////////////////////
// End, Application                                                          //
//////////////////////////////////////////////////////////

//
// the following function outline the server side code for a simple async
// function using pipes.
//


////////////////////////////////////////////////////////////
// Begin, stubs for FooPipe                                                 //
////////////////////////////////////////////////////////////

typedef struct {
    RPC_ASYNC_STUB_STATE StubState ;
    RPC_ASYNC_STATE AsyncState ;
    void *state ;
    async_intpipe inpipe ;
    async_intpipe outpipe ;
    int checksum_out ;
    } FOOPIPE_ASYNC_SERVER_STATE;

#define ASYNC_CHUNK_SIZE 1000
#define ASYNC_NUM_CHUNKS 20



RPC_STATUS
PipeSendFunction (
    PRPC_ASYNC_STATE pAsync,
    void *context,
    int *buffer,
    int num_elements
    )
/*++

Routine Description:

 this function is always implemented by the stubs. This routine is called by
 the application, to send pipe data.

Arguments:

 pAsync - Async Handle. The async handle is always the first parameter of every
              async routine.

--*/
{
    unsigned int Flags = 0;
    RPC_STATUS RpcStatus ;
    RPC_MESSAGE Message ;
    FOOPIPE_ASYNC_SERVER_STATE *StubInfo =
        (FOOPIPE_ASYNC_SERVER_STATE *) pAsync->StubInfo ;
    int calculated_length = num_elements * sizeof(int) + sizeof(int) ;
    char *ptr ;

    Message.ProcNum = RPC_FLAGS_VALID_BIT ;
    Message.Handle = StubInfo->StubState.CallHandle ;

    if (StubInfo->StubState.State == SEND_INCOMPLETE)
        {
        calculated_length += StubInfo->StubState.BufferLength ;
        }

    if (StubInfo->StubState.Buffer == 0)
        {
        Message.RpcFlags = RPC_BUFFER_ASYNC | RPC_BUFFER_PARTIAL ;
        Message.BufferLength = calculated_length ;

        RpcStatus = I_RpcGetBuffer(&Message) ;
        if (RpcStatus != RPC_S_OK)
            {
            return RpcStatus;
            }
        }
    else
        {
        Message.RpcFlags = RPC_BUFFER_ASYNC ;
        Message.Buffer = StubInfo->StubState.Buffer ;
        Message.BufferLength = StubInfo->StubState.BufferLength;

        RpcStatus = I_RpcReallocPipeBuffer(&Message, calculated_length) ;
        if (RpcStatus != RPC_S_OK)
            {
            return RpcStatus;
            }
        }

    ptr = (char *) Message.Buffer ;

    if (StubInfo->StubState.State == SEND_INCOMPLETE)
        {
        ptr += StubInfo->StubState.BufferLength ;
        }

    *((int *) ptr) = num_elements ;
    RpcpMemoryCopy(ptr+sizeof(int), buffer, num_elements *sizeof(int)) ;

    Message.RpcFlags = RPC_BUFFER_PARTIAL | RPC_BUFFER_ASYNC;

    RpcStatus = I_RpcSend(&Message) ;
    if (RpcStatus == RPC_S_OK)
        {
        StubInfo->StubState.State = SEND_COMPLETE ;
        }
    else if (RpcStatus == RPC_S_SEND_INCOMPLETE)
        {
        StubInfo->StubState.State = SEND_INCOMPLETE ;
        }
    else
        {
        return RpcStatus;
        }

    StubInfo->StubState.Buffer = Message.Buffer ;
    StubInfo->StubState.BufferLength = Message.BufferLength ;

    return RPC_S_OK;
}


RPC_STATUS
PipeReceiveFunction (
    PRPC_ASYNC_STATE pAsync,
    int *buffer,
    int requested_count,
    int *actual_count
    )
/*++
Function Name:PipeReceiveFunction

Parameters:

Description:

Returns:

--*/
{
    int num_elements = 0;
    RPC_MESSAGE Callee ;
    FOOPIPE_ASYNC_SERVER_STATE *StubInfo =
        (FOOPIPE_ASYNC_SERVER_STATE *) pAsync->StubInfo ;
    PIPE_STATE *state = &(StubInfo->StubState.PipeState);
    DWORD size = (DWORD) requested_count * state->PipeElementSize ;

    *actual_count = 0 ;

    if (state->EndOfPipe)
        {
        return RPC_S_OK;
        }

    I_RpcReadPipeElementsFromBuffer(
                                    state,
                                    (char *) buffer,
                                    size,
                                    &num_elements) ;

    *actual_count += num_elements ;
    size -= num_elements * state->PipeElementSize ;

    if (state->EndOfPipe == 0 &&
        num_elements < requested_count)
        {
        Callee.ProcNum = RPC_FLAGS_VALID_BIT ;
        Callee.Handle = StubInfo->StubState.CallHandle ;

        Callee.RpcFlags = RPC_BUFFER_PARTIAL | RPC_BUFFER_ASYNC ;
        if (num_elements)
            {
            Callee.RpcFlags |= RPC_BUFFER_NONOTIFY;
            }

        Callee.Buffer = 0 ;
        Callee.BufferLength = 0 ;

        Status = I_RpcReceive(&Callee, size) ;
        if (Status)
            {
            ApiError("PipePull", "I_RpcReceive", Status) ;

            if (Status == RPC_S_ASYNC_CALL_PENDING)
                {
                if (num_elements)
                    {
                    Status = RPC_S_OK;
                    }
                }
            else
                {
                num_elements = 0 ;
                }

            return Status;
            }

        state->Buffer = Callee.Buffer ;
        state->BufferLength = Callee.BufferLength ;
        state->CurPointer = (char *) Callee.Buffer ;
        state->BytesRemaining = Callee.BufferLength ;

        buffer = (pipe_element_t *)
                    ((char *) buffer + num_elements * state->PipeElementSize) ;

        num_elements = 0 ;
        I_RpcReadPipeElementsFromBuffer(
                                        state,
                                        (char *) buffer,
                                        size,
                                        &num_elements) ;

        *actual_count += num_elements ;
        }

    return RPC_S_OK;
}



RPC_STATUS
FooPipeComplete (
    IN PRPC_ASYNC_STATE pAsync,
    IN void *Reply
    )
/*++

Routine Description:
    Stub for the completion routine of FooPipe.

Arguments:

 pAsync - async handle
--*/

{
    RPC_MESSAGE Message ;
    RPC_STATUS RpcStatus ;
    char *ptr ;
    int calculated_length = 8 ;
    FOOPIPE_ASYNC_SERVER_STATE *StubInfo =
        (FOOPIPE_ASYNC_SERVER_STATE *) pAsync->StubInfo ;

    TRACE(("FooPipeComplete called: %d\n", *((int *) Reply))) ;

    Message.ProcNum = RPC_FLAGS_VALID_BIT ;
    Message.Handle = StubInfo->StubState.CallHandle ;
    Message.Buffer = StubInfo->StubState.Buffer ;
    Message.BufferLength = StubInfo->StubState.BufferLength ;

    if (StubInfo->StubState.State == SEND_INCOMPLETE)
        {
        calculated_length += StubInfo->StubState.BufferLength ;
        }

    // if we had [out] pipes, I_RpcGetBuffer must have
    // been called
    Message.RpcFlags = RPC_BUFFER_ASYNC ;

    RpcStatus = I_RpcReallocPipeBuffer(&Message, calculated_length) ;
    if (RpcStatus != RPC_S_OK)
        {
        return RpcStatus ;
        }

    ptr = (char *) Message.Buffer ;

    if (StubInfo->StubState.State == SEND_INCOMPLETE)
        {
        ptr += StubInfo->StubState.BufferLength ;
        }

    *((int *) ptr) = *((int *) Reply);
    *(((int *) ptr)+1) = StubInfo->checksum_out ;

    // send the async reply
    Message.RpcFlags = RPC_BUFFER_ASYNC;
    RpcStatus = I_RpcSend(&Message) ;
    if (RpcStatus)
        {
        return RpcStatus ;
        }

    I_RpcFree(StubInfo) ;

    return RPC_S_OK ;
}

int tempint ;


void
FooPipe_s (
    PRPC_MESSAGE Message
    )
/*++

Routine Description:

    server stub for the FooPipe function.

--*/

{
    int checksum_in;
    FOOPIPE_ASYNC_SERVER_STATE *StubInfo ;
    RPC_STATUS RpcStatus ;
    unsigned long non_pipe_size = sizeof(int) ;

    if (Message->BufferLength < non_pipe_size)
        {
        Message->RpcFlags = RPC_BUFFER_PARTIAL
                                        | RPC_BUFFER_EXTRA;

              RpcStatus = I_RpcReceive(
                                 Message,
                                 non_pipe_size - Message->BufferLength) ;
        if (RpcStatus)
            {
            RpcRaiseException(RpcStatus) ;
            }
        }

    //
    // allocate a handle on the heap, initialize it
    // and register it with the RPC runtime.
    //

    StubInfo = (FOOPIPE_ASYNC_SERVER_STATE *)
                I_RpcAllocate(sizeof(FOOPIPE_ASYNC_SERVER_STATE)) ;

    StubInfo->AsyncState.Size = sizeof(RPC_ASYNC_STATE) ;
    StubInfo->AsyncState.Flags = 0;
    StubInfo->AsyncState.StubInfo = (void *) StubInfo ;
    StubInfo->AsyncState.NotificationType = RpcNotificationTypeNone;

    StubInfo->StubState.Length = sizeof(FOOPIPE_ASYNC_SERVER_STATE) ;
    StubInfo->StubState.CallHandle = Message->Handle ;

    StubInfo->StubState.PipeState.Buffer = 0;
    StubInfo->StubState.PipeState.CurrentState = start;
    StubInfo->StubState.PipeState.EndOfPipe = 0;
    StubInfo->StubState.PipeState.PipeElementSize = sizeof(int);
    StubInfo->StubState.PipeState.PartialPipeElement = &tempint;
    StubInfo->StubState.PipeState.PreviousBuffer = 0;
    StubInfo->StubState.Buffer = 0;

    if (Message->BufferLength > non_pipe_size)
        {
        StubInfo->StubState.PipeState.CurPointer = (char *) Message->Buffer + sizeof(int);
        StubInfo->StubState.PipeState.BytesRemaining =
                    Message->BufferLength - non_pipe_size;
        }
    else
        {
        StubInfo->StubState.PipeState.CurPointer = 0;
        StubInfo->StubState.PipeState.BytesRemaining = 0;
        }

    RpcStatus = I_RpcAsyncSetHandle(
                            Message,
                            (PRPC_ASYNC_STATE) &(StubInfo->AsyncState)) ;
    if (RpcStatus != RPC_S_OK)
        {
        RpcRaiseException(RpcStatus) ;
        }

    // unmarshall the received data
    checksum_in = *((int *) Message->Buffer) ;

    StubInfo->StubState.CompletionRoutine = FooPipeComplete ;
    StubInfo->inpipe.PipeReceive = PipeReceiveFunction;
    StubInfo->outpipe.PipeSend = PipeSendFunction ;

    FooPipe ((PRPC_ASYNC_STATE) &(StubInfo->AsyncState),
                Message->Handle,
                checksum_in,
                &(StubInfo->inpipe),
                &(StubInfo->outpipe),
                &(StubInfo->checksum_out)) ;
}

////////////////////////////////////////////////////////////
// End, stubs for FooPipe                                                   //
////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////
// Begin, Application                                                       //
//////////////////////////////////////////////////////////

typedef struct {
    PRPC_ASYNC_STATE pAsync ;
    int checksum_in ;
    async_intpipe *inpipe ;
    async_intpipe *outpipe ;
    int *checksum_out ;
    int i ;
    int PipeChecksum ;
    int ExpectedValue;
    int PipeBuffer[ASYNC_CHUNK_SIZE] ;
    } PIPE_CALL_COOKIE ;


int PipeCount = 0;

void
FooPipeAPCRoutine (
    IN PRPC_ASYNC_STATE pAsync,
    IN void *Context,
    IN RPC_ASYNC_EVENT Event
    )
/*++

Routine Description:

 description

Arguments:


--*/

{
    RPC_STATUS Status;
    PIPE_CALL_COOKIE *Cookie = (PIPE_CALL_COOKIE *) pAsync->UserInfo ;

    switch (Event)
        {
        case RpcSendComplete:
            if (Cookie->i <ASYNC_NUM_CHUNKS)
                {
                Cookie->i++ ;
                Status = Cookie->outpipe->PipeSend(
                             pAsync,
                             0,
                             (int *) Cookie->PipeBuffer,
                             ASYNC_CHUNK_SIZE) ;
                }
            else
                {
                ASSERT(Cookie->i == ASYNC_NUM_CHUNKS);

                Cookie->i++ ;
                pAsync->Flags = 0;
                Status = Cookie->outpipe->PipeSend(
                            pAsync,
                            0, 0, 0) ;
                }

            if (Status != RPC_S_OK)
                {
                PrintToConsole("PipeSend failed\n");
                }
            break;

        case RpcCallComplete:
#if DBG
            PrintToConsole("usvr: call complete APC !!\n");
#endif
            break;
        }
}


void
ThreadProcPipes(
    IN PIPE_CALL_COOKIE  *Cookie
    )
/*++

Routine Description:

    The thread that calls FooPipe_complete. FooPipe_complete is being called
    in a separate thread to show that it infact can be.

Arguments:
    pAsync - the async handle on which Foo_complete needs to be called.

--*/

{
    int *ptr ;
    int  i ;
    int retval ;
    int Checksum = 0;
    RPC_STATUS Status ;
    int num_elements;
    BOOL fDone = 0;

    RpcTryExcept
        {
        TRACE(("FooPipe: sending pipe data\n")) ;

        while (!fDone)
            {
            Status = Cookie->inpipe->PipeReceive(
                                                  Cookie->pAsync,
                                                  (int *) Cookie->PipeBuffer,
                                                  ASYNC_CHUNK_SIZE,
                                                  &num_elements);

            switch (Status)
                {
                case RPC_S_ASYNC_CALL_PENDING:
                    if (SleepEx(INFINITE, TRUE) != WAIT_IO_COMPLETION)
                        {
                        RpcRaiseException(APP_ERROR) ;
                        }
                    break;

                case RPC_S_OK:
                    if (num_elements == 0)
                        {
                        fDone = 1;
                        }
                    else
                        {
                        for (i = 0; i <num_elements; i++)
                            {
                            if (Cookie->PipeBuffer[i] != Cookie->ExpectedValue)
                                {
                                printf("pipe recv fn: elt %d contains %lx, expected %lx\n",
                                       i, Cookie->PipeBuffer[i], Cookie->ExpectedValue);
                                DebugBreak();
                                }

                            Cookie->ExpectedValue =
                                (Cookie->PipeBuffer[i]+1) % ASYNC_CHUNK_SIZE;
                            Cookie->PipeChecksum += Cookie->PipeBuffer[i] ;
                            }
                        }
                    break;

                default:
                    fDone = 1;
                    break;
                }

            //
            // This code is for testing flow control
            //
            PipeCount++;
            if ((PipeCount % 3) == 0)
                {
                Sleep(100);
                }
            }

        if (Status != RPC_S_OK)
            {
            RpcRaiseException(Status);
            }

        TRACE(("FooPipe: sending pipe data\n")) ;

        ptr = (int *) Cookie->PipeBuffer ;
        for (i = 0; i <ASYNC_CHUNK_SIZE; i++)
            {
            *ptr++ = i;
            Checksum += i ;
            }

        TRACE(("FooPipe: [out] Block checksum: %d\n", Checksum)) ;
        Checksum *= ASYNC_NUM_CHUNKS ;

        TRACE(("FooPipe: [out] Total checksum: %d\n", Checksum)) ;


        Cookie->i = 1;

        Status = Cookie->outpipe->PipeSend(
                     Cookie->pAsync,
                     0,
                     Cookie->PipeBuffer,
                     ASYNC_CHUNK_SIZE) ;

        if (Status != RPC_S_OK)
            {
            RpcRaiseException(Status);
            }

        while (Cookie->i < ASYNC_NUM_CHUNKS+1)
            {
            if (SleepEx(INFINITE, TRUE) != WAIT_IO_COMPLETION)
                {
                RpcRaiseException(APP_ERROR) ;
                }
            }

        TRACE(("FooPipe: sending non pipe reply\n")) ;

        *(Cookie->checksum_out) = Checksum ;

        if (Cookie->checksum_in != Cookie->PipeChecksum)
            {
            PrintToConsole("FooPipe: Checksum Error, expected: %d, checksum: %d\n",
                    Cookie->checksum_in, Cookie->PipeChecksum) ;
            IsabelleError() ;
            retval = 0;
            }
        else
            {
            retval = 1;
            }

        Status = MyRpcCompleteAsyncCall(Cookie->pAsync, &retval) ;
        }
    RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
        {
        IsabelleError() ;
        MyRpcCompleteAsyncCall(Cookie->pAsync, &retval) ;

        PrintToConsole("FooPipe: Exception : 0x%lX\n", GetExceptionCode()) ;
        }
    RpcEndExcept

    Sleep(100);
}


void
FooPipe (
    IN PRPC_ASYNC_STATE pAsync,
    IN RPC_BINDING_HANDLE hBinding,
    IN int checksum_in,
    IN async_intpipe *inpipe,
    OUT async_intpipe *outpipe,
    OUT int *checksum_out
    )
/*++

Routine Description:

    The manager routine that implements FooPipe. It sets up the receive
    and alloc function pointer for each of the pipes on which data is to
    be received, and call RpcRegisterAsycnHandle on the async handle.
    It then spawns off an async operation (creates a thread in this case),
    to process the async call.
Arguments:

 pAsync - Async Handle. The async handle is always the first parameter of every
              async routine.
--*/

{
    unsigned long ThreadIdentifier;
    HANDLE HandleToThread ;
    RPC_STATUS RpcStatus ;
    PIPE_CALL_COOKIE *PipeCallCookie ;

    PipeCallCookie = new PIPE_CALL_COOKIE ;
    if (PipeCallCookie == 0)
        {
        RpcRaiseException(APP_ERROR) ;
        }

    PipeCallCookie->pAsync = pAsync ;
    PipeCallCookie->inpipe = inpipe ;
    PipeCallCookie->outpipe = outpipe ;
    PipeCallCookie->checksum_in = checksum_in ;
    PipeCallCookie->checksum_out = checksum_out ;
    PipeCallCookie->PipeChecksum = 0;
    PipeCallCookie->ExpectedValue = 0;

    HandleToThread = CreateThread(0,
                                    DefaultThreadStackSize,
                                    (LPTHREAD_START_ROUTINE) ThreadProcPipes,
                                    PipeCallCookie,
                                    0,
                                    &ThreadIdentifier);

    if (HandleToThread == 0)
        {
        PrintToConsole("FooPipe: Can't create thread\n") ;
        RpcRaiseException(RPC_S_OUT_OF_MEMORY) ;
        }

    pAsync->Flags = RPC_C_NOTIFY_ON_SEND_COMPLETE ;
    pAsync->UserInfo = (void *) PipeCallCookie ;
    pAsync->NotificationType = RpcNotificationTypeApc ;
    pAsync->u.APC.NotificationRoutine = FooPipeAPCRoutine ;
    pAsync->u.APC.hThread = HandleToThread ;

    RpcStatus = RpcAsyncRegisterInfo(pAsync) ;
    if (RpcStatus != RPC_S_OK)
        {
        RpcRaiseException(RpcStatus) ;
        }
}

///////////////////
// misc stuff       ///
///////////////////

int
FooBar (
    IN RPC_BINDING_HANDLE hBinding,
    IN int sizein,
    IN int *bufferin,
    IN OUT int *sizeout,
    OUT int **bufferout
    )
{
    UUID ObjectUuid;

    Status = RpcBindingInqObject(hBinding, &ObjectUuid);
    if (Status)
        {
        PrintToConsole("FooBar: can't inq object uuid, error = %d\n", Status);
        RpcRaiseException(Status);
        }

    if (CheckUuidValue(UUID_SYNC_EXCEPTION, &ObjectUuid) == 0)
        {
        RpcRaiseException(SYNC_EXCEPT) ;
        }

    *bufferout = (int *) I_RpcAllocate(*sizeout) ;
    if (*bufferout == 0)
        {
        RpcRaiseException(APP_ERROR) ;
        }

    return 1;
}


void
FooBar_s (
    PRPC_MESSAGE Message
    )
/*++

Routine Description:

 Generated stub for FooBar.

--*/

{
    int *bufferin ;
    int *bufferout ;
    int sizein, sizeout ;
    int *Ptr ;
    int retval ;
    RPC_STATUS RpcStatus ;

    if ((Message->RpcFlags & RPC_BUFFER_COMPLETE) == 0)
        {
        Message->RpcFlags = RPC_BUFFER_EXTRA;
        RpcStatus = I_RpcReceive (Message, 0) ;
        if (RpcStatus)
            {
            RpcRaiseException(RpcStatus) ;
            }
        }

    // unmarshall the received data
    Ptr = (int *) Message->Buffer ;
    sizein = *Ptr++ ;
    bufferin = Ptr ;

    Ptr += (sizein+3)/sizeof(int) ;

    sizeout = *Ptr ;

    retval = FooBar (Message->Handle, sizein, bufferin, &sizeout, &bufferout) ;

    Message->BufferLength = sizeout+8;

    RpcStatus = I_RpcGetBuffer(Message) ;
    if (RpcStatus != RPC_S_OK)
        {
        RpcRaiseException(RpcStatus) ;
        }

    Ptr = (int *) Message->Buffer ;
    *Ptr++ = retval ;
    *Ptr++ = sizeout ;
    RpcpMemoryCopy(Ptr, bufferout, sizeout) ;

    I_RpcFree(bufferout) ;
}

////////////////////////////////////////////////////////////
// Begin, stubs for FooCH                                                      //
////////////////////////////////////////////////////////////
void
FooCH (
    IN PRPC_ASYNC_STATE pAsync,
    IN RPC_BINDING_HANDLE hBinding,
    IN int sizein,
    IN int *bufferin,
    IN OUT int *sizeout,
    OUT int **bufferout
    ) ;

typedef struct {
    RPC_ASYNC_STUB_STATE StubState ;
    RPC_ASYNC_STATE AsyncState ;
    void *state ;
    int sizeout ;
    int *bufferout ;
    } FOOCH_ASYNC_SERVER_STATE;


RPC_STATUS
FooCHComplete (
    IN PRPC_ASYNC_STATE pAsync,
    IN void *Reply
    )
/*++

Routine Description:
    This is a generated stub. It is the completion routine for the function
    FooCH. When the server app is done with processing a particular call to
    FooCH, It calls FooCH_complete to complete the call.

Arguments:

 pAsync - The async handle. This handle is always the first parameter of every
    FooCH_complete routine.
--*/

{
    int *Ptr ;
    RPC_MESSAGE Message ;
    RPC_STATUS RpcStatus ;
    FOOCH_ASYNC_SERVER_STATE *StubInfo =
            (FOOCH_ASYNC_SERVER_STATE *) pAsync->StubInfo ;

    TRACE(("FooCHComplete called: %d\n", *((int *) Reply))) ;

    Message.ProcNum = RPC_FLAGS_VALID_BIT ;
    Message.RpcFlags = RPC_BUFFER_ASYNC;
    Message.BufferLength = 8 + StubInfo->sizeout  ;
    Message.Handle = StubInfo->StubState.CallHandle ;

    RpcStatus = I_RpcGetBuffer(&Message) ;
    if (RpcStatus)
        {
        return RpcStatus ;
        }

    Ptr = (int *) Message.Buffer ;
    *Ptr++ = *((int *) Reply) ;
    *Ptr++ = StubInfo->sizeout ;
    RpcpMemoryCopy(Ptr, StubInfo->bufferout, StubInfo->sizeout) ;

    I_RpcFree(StubInfo->bufferout) ;

    // send the async reply
    Message.RpcFlags = RPC_BUFFER_ASYNC;
    RpcStatus = I_RpcSend(&Message) ;
    if (RpcStatus)
        {
        return RpcStatus ;
        }

    I_RpcFree(pAsync->StubInfo) ;

    return RPC_S_OK ;
}


void
FooCH_s (
    PRPC_MESSAGE Message
    )
/*++

Routine Description:

 Generated stub for FooCH.

--*/

{
    int sizein ;
    int *bufferin ;
    int *Ptr ;
    FOOCH_ASYNC_SERVER_STATE *StubInfo;
    RPC_STATUS RpcStatus ;
    NDR_SCONTEXT Context ;

    if ((Message->RpcFlags & RPC_BUFFER_COMPLETE) == 0)
        {
        Message->RpcFlags = RPC_BUFFER_EXTRA;
        RpcStatus = I_RpcReceive (Message, 0) ;
        if (RpcStatus)
            {
            RpcRaiseException(RpcStatus) ;
            }
        }

    // allocate a handle and tell the runtime about it
    StubInfo = (FOOCH_ASYNC_SERVER_STATE *)
                   I_RpcAllocate(sizeof(FOOCH_ASYNC_SERVER_STATE)) ;

    if (StubInfo == 0)
        {
        RpcRaiseException(RPC_S_OUT_OF_MEMORY) ;
        }

    StubInfo->AsyncState.Size = sizeof(RPC_ASYNC_STATE) ;
    StubInfo->AsyncState.StubInfo = (void *) StubInfo ;
    StubInfo->AsyncState.Flags = 0;
    StubInfo->AsyncState.NotificationType = RpcNotificationTypeNone;

    StubInfo->StubState.CompletionRoutine = FooCHComplete ;
    StubInfo->StubState.CallHandle = Message->Handle ;
    StubInfo->StubState.Flags = 0;

    RpcStatus = I_RpcAsyncSetHandle(
                            Message,
                            (PRPC_ASYNC_STATE) &(StubInfo->AsyncState)) ;

    if (RpcStatus != RPC_S_OK)
        {
        RpcRaiseException(RpcStatus) ;
        }


    // unmarshall the received data
    Ptr = (int *) Message->Buffer ;
    Context = NDRSContextUnmarshallEx (
                  Message->Handle,
                  0,
                  Message->DataRepresentation );
    if (Context == 0)
        {
        RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH) ;
        }

    Ptr += 20/sizeof(int) ;

    sizein = *Ptr++ ;
    bufferin = Ptr ;

    Ptr += (sizein+3)/sizeof(int) ;
    StubInfo->sizeout = *Ptr ;

    {
    RPC_STATUS Status = 0;
    UUID ObjectUuid;

    Status = RpcBindingInqObject(Message->Handle, &ObjectUuid);
    if (Status)
        {
        PrintToConsole("FooBar: can't inq object uuid, error = %d\n", Status);
        RpcRaiseException(Status);
        }

    if (CheckUuidValue(UUID_SYNC_EXCEPTION, &ObjectUuid) == 0)
        {
        RpcRaiseException(SYNC_EXCEPT) ;
        }

    if (CheckUuidValue(UUID_ASYNC_EXCEPTION, &ObjectUuid) == 0)
        {
        StubInfo->sizeout = SIZEOUT_ASYNC_EXCEPTION;
        }
    }

    FooCH ((PRPC_ASYNC_STATE) &(StubInfo->AsyncState),
            (void PAPI *) *NDRSContextValue(Context),
            sizein,
            bufferin,
            &(StubInfo->sizeout),
            &(StubInfo->bufferout)) ;

}

////////////////////////////////////////////////////////////
// End, stubs for FooCH                                                         //
////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////
// Begin, Application                                                       //
//////////////////////////////////////////////////////////

typedef struct {
    PRPC_ASYNC_STATE pAsync ;
    int *sizeout ;
    int **bufferout ;
    BOOL fException;
    } FOOCH_CALL_COOKIE ;


void
FooCHThreadProc(
    FOOCH_CALL_COOKIE *Cookie
    )
/*++

Routine Description:

    The thread that calls FooCH_complete. FooCH_complete is being called
    in a separate thread to show that it infact can be.

Arguments:
    pAsync - the async handle on which FooCH_complete needs to be called.

--*/

{
    int retval = 1;

    TRACE(("FOOCH: Sending back aync reply\n")) ;

    if (Cookie->fException)
        {
        MyRpcAbortAsyncCall(Cookie->pAsync, ASYNC_EXCEPT) ;
        return ;
        }

    *(Cookie->bufferout) = (int *) I_RpcAllocate(*(Cookie->sizeout)) ;
    if (*(Cookie->bufferout) == 0)
        {
        MyRpcAbortAsyncCall(Cookie->pAsync, RPC_S_OUT_OF_MEMORY) ;
        IsabelleError() ;
        return ;
        }

    Status = MyRpcCompleteAsyncCall(Cookie->pAsync, &retval) ;
    if (Status != RPC_S_OK)
        {
        IsabelleError() ;
        }
}


void
FooCH (
    IN PRPC_ASYNC_STATE pAsync,
    IN void PAPI *ContextHandle,
    IN int sizein,
    IN int *bufferin,
    IN OUT int *sizeout,
    OUT int **bufferout
    )
/*++

Routine Description:

    This is a actual manager routine. It can spawn off an async operation
    (a thread in this case) to do the rest of the work, and send back the
    reply when it is done.

Arguments:
    pAsync - Async handle. This is always the first parameter of every async
    handle.
--*/

{
  unsigned long ThreadIdentifier;
  HANDLE HandleToThread ;
  FOOCH_CALL_COOKIE *CallCookie ;

  CallCookie = new FOOCH_CALL_COOKIE ;
  if (CallCookie == 0)
      {
      RpcRaiseException(APP_ERROR) ;
      }

  CallCookie->pAsync = pAsync ;
  CallCookie->sizeout = sizeout ;
  CallCookie->bufferout = bufferout ;
  CallCookie->fException = FALSE;

  if (*sizeout == SIZEOUT_ASYNC_EXCEPTION)
      {
      CallCookie->fException = TRUE;
      }

  HandleToThread = CreateThread(
                                0,
                                DefaultThreadStackSize,
                                (LPTHREAD_START_ROUTINE) FooCHThreadProc,
                                CallCookie,
                                0,
                                &ThreadIdentifier);

  if (HandleToThread == 0)
      {
      PrintToConsole("FooCH: Error, could not create thread\n") ;
      return ;
      }

  // return to the server stub.
}

///////////////////////////////////////////////////////////
// End, Application                                                          //
//////////////////////////////////////////////////////////


void
Async (
    )
/*++
Routine Description:
     Register the interfaces and start listening

--*/
{
    PrintToConsole("Async : Test Async RPC\n");

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError("Async","stub_RegisterIf",Status);
        PrintToConsole("Async : FAIL - Unable to Register Interface ");
        PrintToConsole("(Sylvia)\n");
        return;
        }

    //
    // synchronous listen blocks inside GenericServerListen
    //
    Status = GenericServerListen( "Async", BARTHOLOMEW );
    if (Status)
        {
        return;
        }

    Status = GenericServerUnlisten( "Async" );
    if (Status)
        {
        return;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &SylviaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError("Async","RpcServerUnregisterIf",Status);
        PrintToConsole("Async : FAIL - Unable to Unregister ");
        PrintToConsole("Interface (Sylvia)\n");
        return;
        }

    PrintToConsole("Async : PASS\n");
}



void
SendAck (
    )
/*++
Routine Description:
     Register the interfaces and start listening

--*/
        {
    PrintToConsole("SendAck : Test datagram delayed ACK\n");

    Status = GenericServerListen( "SendAck", BARTHOLOMEW );
        if (Status)
            {
        return;
        }

    Status = GenericServerUnlisten( "SendAck" );
    if (Status)
        {
            return;
            }
        }


void
DgTransport (
    )
/*++
Routine Description:
     Register the interfaces and start listening

--*/
{
    PrintToConsole("DgTransport : Test datagram transport\n");

    Status = GenericServerListen( "DgTransport", BARTHOLOMEW );
    if (Status)
        {
        return;
        }

    Status = GenericServerUnlisten( "DgTransport" );
    if (Status)
        {
        return;
        }
        }

PVOID LastConnectionCreated = 0;

PVOID MySecurityContext = 0;

DWORD ChosenErrorCode = 0;

void
ShutdownHookFn(
    DWORD id,
    PVOID subject,
    PVOID object
    )
{
    switch (id)
        {
        case TH_RPC_LOG_EVENT:
            {
            RPC_EVENT * event = (RPC_EVENT *) subject;

//            TRACE(("  hook: %c %c %p %p\n", event->Subject, event->Verb, event->SubjectPointer, event->ObjectPointer));

            //
            // Record sconnection creation.
            //
            if (event->Subject == SU_SCONN &&
                event->Verb    == EV_CREATE)
                {
                TRACE(("  hook: created connection %p\n", event->SubjectPointer));
                LastConnectionCreated = event->SubjectPointer;
                }

            break;
            }

        case TH_RPC_SECURITY_SERVER_CONTEXT_CREATED:
            {
            if (object == LastConnectionCreated)
                {
                TRACE(("  hook: connection %p created security context %p\n", LastConnectionCreated, subject));
                MySecurityContext = subject;
                }

            break;
            }

        default:
            {
            break;
            }
        }
}

void
SecurityContextHook(
    DWORD id,
    PVOID subject,
    PVOID object
    )
{
    if (subject == MySecurityContext)
        {
        TRACE(("  hook executed: context %p, hook ID %x, error code is 0x%x\n", subject, id, ChosenErrorCode));

        DWORD * pStatus = (DWORD *) object;

        *pStatus = ChosenErrorCode;
        }
    else
        {
        TRACE(("  hook: ignoring notification, my cxt = %p, context %p, hook ID %x, error code is 0x%x\n",
               MySecurityContext, subject, id, ChosenErrorCode));
        }
}

void
TestSecurityError (
    RPC_TEST_HOOK_ID id,
    DWORD error
    );

void
SecurityErrorWrapper(
    int subtest
    )
{
    //
    // Set up the test hook.
    //
    {
    HMODULE hRpc = GetModuleHandle(L"RPCRT4.DLL");

    if (!hRpc)
        {
        ApiError("","GetModuleHandle",GetLastError());
        return;
        }

    SetTestHookFn = (SET_TEST_HOOK_FN) GetProcAddress( hRpc, "I_RpcSetTestHook" );

    if (!SetTestHookFn)
        {
        ApiError("", "GetProcAddress: I_RpcSetTestHook", GetLastError());
        }
    }

    switch (subtest)
        {
        default:
            {
            PrintToConsole("unknown security-error case!\n");

            // no break here

            }
        case 100:
            {
            //
            // wants a list
            //
            PrintToConsole("cases:\n"
                           "\n"
                           "    1 - AcceptFirstTime returns SEC_E_SHUTDOWN_IN_PROGRESS\n"
                           "    2 - AcceptThirdLeg  returns SEC_E_SHUTDOWN_IN_PROGRESS\n"
                           );
            return;
            }

        case 0:
            {
            PrintToConsole("running all sub tests\n");
            }

        case 1:
            {
            PrintToConsole("subtest 1: AcceptFirstTime returns SEC_E_SHUTDOWN_IN_PROGRESS\n");

            TestSecurityError( TH_SECURITY_FN_ACCEPT1, SEC_E_SHUTDOWN_IN_PROGRESS );

            if (subtest)
                {
                break;
                }
            }

        case 2:
            {
            PrintToConsole("subtest 1: AcceptThirdLeg returns SEC_E_SHUTDOWN_IN_PROGRESS\n");

            TestSecurityError( TH_SECURITY_FN_ACCEPT3, SEC_E_SHUTDOWN_IN_PROGRESS );

            if (subtest)
                {
                break;
                }
            }
        }
}


void
TestSecurityError (
    RPC_TEST_HOOK_ID id,
    DWORD error
    )
/*++
Routine Description:
     Register the interfaces and start listening

--*/
{

    //
    // Set test hooks.
    //
    (*SetTestHookFn)( TH_RPC_LOG_EVENT, ShutdownHookFn );
    (*SetTestHookFn)( TH_RPC_SECURITY_SERVER_CONTEXT_CREATED, ShutdownHookFn );

    ChosenErrorCode = error;

    (*SetTestHookFn)( id, SecurityContextHook );

    //
    // Wait for the client to make the call.
    //
    Status = GenericServerListen( "SecurityShutdown", SECURITY_ERROR );
    if (Status)
        {
        return;
        }

    //
    // Remove test hooks.
    //
    (*SetTestHookFn)( TH_RPC_LOG_EVENT, 0 );
    (*SetTestHookFn)( TH_RPC_SECURITY_SERVER_CONTEXT_CREATED, 0 );

    (*SetTestHookFn)( id, 0 );

    //
    // Clean up.
    //
    Status = GenericServerUnlisten( "SecurityShutdown" );
    if (Status)
        {
        return;
        }
}


DWORD
GenericServerUnlisten(
    char * name
    )
{
    // Synchro support
    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError(name,"RpcServerUnregisterIf",Status);
        PrintToConsole("%s : FAIL - Unable to Unregister ", name);
        PrintToConsole("Interface (Helga)\n");
        return Status;
        }

    if (IsabelleErrors != 0)
        {
        PrintToConsole("%s : FAIL - Error(s) in Isabelle", name);
        PrintToConsole(" Interface\n");
        IsabelleErrors = 0;
        return Status;
        }

    Status = RpcServerUnregisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation, 0, 0);
    if (Status)
        {
        ApiError(name,"RpcServerUnregisterIf",Status);
        PrintToConsole("%s : FAIL - Unable to Unregister ", name);
        PrintToConsole("Interface (Isabelle)\n");
        return Status;
        }

    if (SylviaErrors != 0)
        {
        PrintToConsole("%s : FAIL - Error(s) in Sylvia", name);
        PrintToConsole(" Interface\n");
        HelgaErrors = 0;
        return Status;
        }

    return 0;
}


DWORD
GenericServerListen(
    char * name,
    int endpoint
    )
{
    Status = RpcServerUseProtseqEpWrapper(GetProtocolSequence(), MAX_CALL_REQUESTS,
            GetEndpoint(endpoint), 0);
    if (Status)
        {
        ApiError(name, "RpcServerUseProtseqEpWrapper", Status);
        PrintToConsole("%s : FAIL - Unable to Use Protseq endpoint \n", name);
        return Status;
        }

    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &IsabelleInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError(name,"stub_RegisterIf",Status);
        PrintToConsole("%s : FAIL - Unable to Register Interface ", name);
        PrintToConsole("(Isabelle)\n");
        return Status;
        }

    // Synchro support
    Status = stub_RegisterIf(
            (RPC_IF_HANDLE) &HelgaInterfaceInformation,
            0, 0);
    if (Status)
        {
        ApiError(name,"stub_RegisterIf",Status);
        PrintToConsole("%s : FAIL - Unable to Register Interface ", name);
        PrintToConsole("(Helga)\n");
        return Status;
        }

    if (!NoSecurityTests)
        {
        Status = RpcServerRegisterAuthInfoA((unsigned char PAPI *) "ServerPrincipal", 10, 0, 0);
        if (Status)
            {
            ApiError(name, "RpcServerRegisterAuthInfo", Status);
            PrintToConsole("%s : FAIL - Unable to Register AuthInfo\n", name);
            return Status;
            }
        }

    Status = stub_ServerListen(MinimumListenThreads, MAXLISTENTHREADS, 0);
    if (Status)
        {
        ApiError(name,"stub_ServerListen",Status);
        PrintToConsole("%s : FAIL - stub_ServerListen Failed\n", name);
        return Status;
        }

    return 0;
}