/*++

Copyright (C) Microsoft Corporation, 1991 - 1999

Module Name:

    epmapper.cxx

Abstract:

    This routine implements the server side DCE runtime APIs.  The
    routines in this file are used by server applications only.

Author:

    Bharat Shah (barats) 3-5-92

Revision History:

    06-03-96    gopalp      Added code to cleanup stale EP Mapper entries.

--*/

#include <precomp.hxx>
#include <rpcobj.hxx>
#include <epmap.h>
#include <epmp.h>
#include <twrproto.h>
#include <startsvc.h>
#include <hndlsvr.hxx>
#include <CharConv.hxx>


//
// Global EP cleanup context handle. Initially NULL, this will
// be allocated by Endpoint Mapper. As of now, it points to the
// EP entries registered by this process. This way, the Endpoint
// Mapper can cleanup entries of this process as soon as process
// goes away.
//

void * hEpContext = NULL;
MUTEX *EpContextMutex = NULL;


RPC_STATUS
InitializeEPMapperClient(
    void
    )
{
    RPC_STATUS Status = RPC_S_OK;

    EpContextMutex = new MUTEX(&Status,
                               TRUE     // pre-allocate semaphore
                               );

    if (EpContextMutex == NULL)
        {
        return RPC_S_OUT_OF_MEMORY;
        }

    if (Status != RPC_S_OK)
        {
        delete EpContextMutex;
        EpContextMutex = NULL;
        }

    return Status;
}

inline void RequestEPClientMutex(void)
{
    EpContextMutex->Request();
}

inline void ClearEPClientMutex(void)
{
    EpContextMutex->Clear();
}


RPC_STATUS
BindingAndIfToTower(
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_HANDLE BindingHandle,
    OUT twr_t PAPI * PAPI * Tower
)
/*+

Routine Description:
    Helper routine that returns a Tower from the Interface Spec
    and a bindinh handle

Arguments:

    IfSpec - Client or Server IfSpec structure.

    BindingHandle - A partially bound binding handle

    Tower - Returns a Tower if the Binding Handle had a
        dynamic endpoint, else Tower=NULL. The caller needs
        to free this memory.

Return Value:

    RPC_S_OK - The ansi string was successfully converted into a unicode
        string.

    RPC_S_OUT_OF_MEMORY - Insufficient memory is available for the unicode
        string.

    EP_S_CANT_PERFORM_OP - The Binding Handle or IfSpec were in valid.

--*/
{
    RPC_STATUS err          = 0;
    unsigned char *Protseq  = 0;
    unsigned char *NWAddress= 0;
    unsigned char *Binding  = 0;
    unsigned char *Endpoint = 0;
    RPC_CHAR * String       = 0;
    RPC_IF_ID Ifid;
    RPC_TRANSFER_SYNTAX Xferid;
    unsigned int Size;

    *Tower = NULL;
    err = RpcIfInqId(IfSpec, &Ifid);
    if (!err)
        {
        err = I_RpcIfInqTransferSyntaxes(
                    IfSpec,
                    &Xferid,
                    sizeof(Xferid),
                    &Size
                    );
        }

    if (!err)
        {
        err = I_RpcBindingInqDynamicEndpoint(BindingHandle, &String);
        }

    if (err)
        {
        return (err);
        }


    if (!err)
        {
        err = RpcBindingToStringBindingA(BindingHandle, &Binding);
        }

    if (!err)
        {
        if (String != 0)
            {
            // It is a dynamic endpoint
            Endpoint = UnicodeToAnsiString(String, &err);
            if (!err)
                {
                err = RpcStringBindingParseA(
                            Binding,
                            NULL,
                            &Protseq,
                            &NWAddress,
                            NULL,
                            NULL
                            );
                }
            }
        else
            {
            err = RpcStringBindingParseA(
                        Binding,
                        NULL,
                        &Protseq,
                        &NWAddress,
                        &Endpoint,
                        NULL
                        );
            }
        }

    if (!err)
        {
        err = TowerConstruct(
                    &Ifid,
                    &Xferid,
                    (char PAPI*)Protseq,
                    (char PAPI *)Endpoint,
                    (char PAPI *)NWAddress,
                    Tower
                    );
        }

    if (Endpoint)
        RpcStringFreeA(&Endpoint);

    if (String)
        RpcStringFreeA((unsigned char PAPI * PAPI *)&String);

    if (Protseq)
        RpcStringFreeA(&Protseq);

    if (NWAddress)
        RpcStringFreeA(&NWAddress);

    if (Binding)
        RpcStringFreeA(&Binding);

    return(err);
}




RPC_STATUS
RegisterEntries(
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * ObjUuidVector,
    IN unsigned char * Annotation,
    IN unsigned long ReplaceNoReplace
    )
/*++


Routine Description:

    This helper function is called by RpcEpRegister or RpcEpRegisterNoReplace
    Depending on the TypeOp, it tries to Add or replace endpoint entries
    in the EP-database.

Arguments:

    IfSpec - Interface Spec Handle for which the entries are to be registered.

    BindingVector - A Vector of Binding Handles which need to be registered

    ObjUUIDVector - A Vector of Objects

    Annotation - A String representing the Annotation

    TypeOp - A Flag : REGISTER_REPLACE or REGISTER_NO_REPLACE

Return Value:

    RPC_S_OK - Some of the entries specified were successfully registered.

    RPC_S_OUT_OF_MEMORY - Insufficient memory is available,

    EP_S_CANT_PERFORM_OP - Misc. local error occured; e.g. could not bind to
        the EpMapper.

--*/
{
    RPC_STATUS err;
    unsigned int i, j, k, Entries, CountBH, CountObj;
    RPC_BINDING_HANDLE EpMapperHandle;
    unsigned char * PStringBinding = NULL;
    twr_p_t Twr;
    ept_entry_t * EpEntries = NULL, *p;
    unsigned long ArgC = 0;
    char *ArgV[1] = { NULL };

    if (BindingVector->Count == 0)
        {
        //
        // PNP
        //
        err = GlobalRpcServer->InterfaceExported(
                                                 (PRPC_SERVER_INTERFACE) IfSpec,
                                                 ObjUuidVector,
                                                 Annotation,
                                                 ReplaceNoReplace);
        return RPC_S_OK;
        }

    if (err = BindToEpMapper(&EpMapperHandle,
        NULL,       // NetworkAddress
        NULL,       // Protseq
        0,          // Options
        RPC_C_BINDING_DEFAULT_TIMEOUT,
        INFINITE,    // CallTimeout
        NULL        // AuthInfo
        ))
        {
        return err;
        }

    CountObj =  (unsigned int)ObjUuidVector->Count;
    CountBH = (unsigned int) BindingVector->Count;

    if ((p = (EpEntries =  (ept_entry_t *)
        I_RpcAllocate(CountBH * sizeof(ept_entry_t)))) == NULL)
        {
        return(RPC_S_OUT_OF_MEMORY);
        }

    for (i = 0, Entries = 0;  (!err) && (i < CountBH); i++)
        {
        if (BindingVector->BindingH[i] == 0)
            {
            continue;
            }

        if (err = BindingAndIfToTower(IfSpec, BindingVector->BindingH[i], &Twr))
            {
            err = 0;
            continue;
            }

        if (Twr == NULL)
            {
            continue;
            }

        Entries ++;
        p->tower = Twr;
        lstrcpyA((char PAPI *)p->annotation, (char PAPI *)Annotation);
        p++;
        }

    for (j = 0; j < CountObj; j++)
        {
        for (k = 0, p = EpEntries; k < Entries; k++, p++)
            {
            RpcpMemoryCopy(
                (char PAPI *)&p->object,
                (char PAPI *)ObjUuidVector->Uuid[j],
                sizeof(UUID)
                );
            }

        RequestEPClientMutex();
        RpcTryExcept
            {
            ept_insert_ex(
                EpMapperHandle,
                &hEpContext,
                Entries,
                EpEntries,
                ReplaceNoReplace,
                (error_status PAPI *)&err
                );
            }
        RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
            {
            err = RpcExceptionCode();
            }
        RpcEndExcept
        ClearEPClientMutex();

        if (err == RPC_S_SERVER_UNAVAILABLE)
            {
            //
            //Try to start the epmapper and retry
            //

            err = StartServiceIfNecessary();

            if (err == RPC_S_OK)
                {
                RequestEPClientMutex();
                RpcTryExcept
                    {
                    ept_insert_ex(
                        EpMapperHandle,
                        &hEpContext,
                        Entries,
                        EpEntries,
                        ReplaceNoReplace,
                        (error_status PAPI *)&err
                        );
                    }
                RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
                    {
                    RpcpErrorAddRecord(EEInfoGCRuntime,
                        EPT_S_CANT_CREATE,
                        EEInfoDLRegisterEntries10,
                        RpcExceptionCode());
                    err = EPT_S_CANT_CREATE;
                    }
                RpcEndExcept
                ClearEPClientMutex();
                }
            }

        if (err != RPC_S_OK)
            {
            RpcpErrorAddRecord(EEInfoGCRuntime,
                EPT_S_CANT_CREATE,
                EEInfoDLRegisterEntries20,
                err);
            err = EPT_S_CANT_CREATE;
            break;
            }

         // Subsequent Inserts should be (ALWAYS) NOREPLACE
         // ReplaceNoReplace = REGISTER_NOREPLACE;

        }  // for loop over UUID Vectors


    for (i = 0, p = EpEntries; i < Entries; i++,p++)
        I_RpcFree(p->tower);

    if (EpEntries)
        {
        I_RpcFree(EpEntries);
        }

    RpcBindingFree(&EpMapperHandle);

    if (err == RPC_S_OK)
        {
        //
        // We successfully registered our bindings,
        // reflect that in the interface so that if we get a
        // PNP notification, we can update the bindings
        //
        err = GlobalRpcServer->InterfaceExported(
                                                 (PRPC_SERVER_INTERFACE) IfSpec,
                                                 ObjUuidVector,
                                                 Annotation,
                                                 ReplaceNoReplace);
        }

    return(err);
}




RPC_STATUS RPC_ENTRY
RpcEpRegisterNoReplaceA (
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * UuidVector OPTIONAL,
    IN unsigned char * Annotation
    )
/*++


Routine Description:

    A server application will call this routine to register
    a series of end points with the local endpoint mapper.

Arguments:


Return Value:


--*/
{
    UUID_VECTOR UuidVectorNull;
    UUID_VECTOR PAPI *PObjUuidVector = &UuidVectorNull;
    UUID NilUuid;
    unsigned char AnnotStr[] = {'\0'};
    THREAD *Thread;

    if (!ARGUMENT_PRESENT(Annotation))
        Annotation = AnnotStr;

    if (strlen((char PAPI *)Annotation) >= ep_max_annotation_size)
        return(EPT_S_INVALID_ENTRY);

    if (!ARGUMENT_PRESENT( BindingVector))
        {
        return(RPC_S_NO_BINDINGS);
        }

    if (ARGUMENT_PRESENT( UuidVector ))
        {
        PObjUuidVector = UuidVector;
        }
    else
        {
        UuidVectorNull.Count = 1;
        RpcpMemorySet(&NilUuid, 0, sizeof(UUID));
        UuidVectorNull.Uuid[0] = &NilUuid;
        }

    Thread = ThreadSelf();
    if (Thread)
        {
        RpcpPurgeEEInfoFromThreadIfNecessary(Thread);
        }

    return(RegisterEntries(
            IfSpec,
            BindingVector,
            PObjUuidVector,
            Annotation,
            EP_REGISTER_NOREPLACE
            ));
}





RPC_STATUS RPC_ENTRY
RpcEpRegisterNoReplaceW (
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * UuidVector OPTIONAL,
    IN unsigned short * Annotation
    )
/*++


Routine Description:

    A server application will call this routine to register [Add]
    a series of end points with the local endpoint mapper
    This is the Unicode version of the API.

Arguments:

    IfSpec  - Server side Interface specification structure generated
        by MIDL, that describes Interface UUId and version

   Binding Vector - A vector of binding handles that the server has registered
        with the runtime.

   UuidVector- A vector of Uuids of objects that the server is supporting

   Annotation - Annotation String

Return Value:


--*/
{
        CHeapAnsi AnsiString;
        USES_CONVERSION;
    RPC_STATUS err;

    if (ARGUMENT_PRESENT(Annotation))
        {
        ATTEMPT_HEAP_W2A(AnsiString, Annotation);
        }

    err = RpcEpRegisterNoReplaceA(
                IfSpec,
                BindingVector,
                UuidVector,
                AnsiString
                );

    return(err);
}





RPC_STATUS RPC_ENTRY
RpcEpRegisterA (
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * UuidVector OPTIONAL,
    IN unsigned char * Annotation
    )
/*++


Routine Description:

    A server application will call this routine to register
    a series of end points with the local endpoint mapper, replacing
    existing database entries in the process.

    This is the Ansi version of the API.

Arguments:

    IfSpec  - Server side Interface specification structure generated
        by MIDL, that describes Interface UUId and version

    Binding Vector- A vector of binding handles that the server has registered
        with the runtime.

    UuidVector- A vector of Uuids of objects that the server is supporting

    Annotation - Annotation String

Return Value:


--*/
{
    UUID_VECTOR UuidVectorNull;
    UUID_VECTOR PAPI *PObjUuidVector = &UuidVectorNull;
    UUID NilUuid;
    unsigned char AnnotStr[] = {'\0'};
    THREAD *Thread;

    if (!ARGUMENT_PRESENT(Annotation))
        Annotation = AnnotStr;

    if (strlen((char PAPI *)Annotation) >= ep_max_annotation_size)
        return(EPT_S_INVALID_ENTRY);

    if (!ARGUMENT_PRESENT( BindingVector))
        {
        return(RPC_S_NO_BINDINGS);
        }

    if (ARGUMENT_PRESENT( UuidVector ))
        {
        PObjUuidVector = UuidVector;
        }
    else
        {
        UuidVectorNull.Count = 1;
        RpcpMemorySet(&NilUuid, 0, sizeof(UUID));
        UuidVectorNull.Uuid[0] = &NilUuid;
        }

    Thread = ThreadSelf();
    if (Thread)
        {
        RpcpPurgeEEInfoFromThreadIfNecessary(Thread);
        }

    return(RegisterEntries(
                IfSpec,
                BindingVector,
                PObjUuidVector,
                Annotation,
                EP_REGISTER_REPLACE
                ));
}



RPC_STATUS RPC_ENTRY
RpcEpRegisterW (
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * UuidVector,
    IN unsigned short * Annotation
    )
/*++


Routine Description:

    A server application will call this routine to register
    a series of end points with the local endpoint mapper, replcaing
    existing entries in the process.
    This is the Unicode version of the API.

Arguments:

    IfSpec  - Server side Interface specification structure generated
        by MIDL, that describes Interface UUId and version

    Binding Vector- A vector of binding handles that the server has registered
        with the runtime.

    UuidVector- A vector of Uuids of objects that the server is supporting

    Annotation - Annotation String

Return Value:


--*/
{
    USES_CONVERSION;
    CHeapAnsi AnsiString;
    RPC_STATUS err;

    if (ARGUMENT_PRESENT(Annotation))
        {
        ATTEMPT_HEAP_W2A(AnsiString, Annotation);
        }

    err = RpcEpRegisterA(
                IfSpec,
                BindingVector,
                UuidVector,
                AnsiString
                );

    return(err);
}





RPC_STATUS RPC_ENTRY
RpcEpUnregister(
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * UuidVector
    )
/*++


Routine Description:

    A server application will call this routine to unregister
    a series of end points.

Arguments:

    IfSpec - Pointer to Interface Specification generated by MIDL

    BindingVector - A Vector of Binding handles maintained by runtime
        for the server.

    UuidVector - A Vector of UUIDs for objects supported by the the server

Return Value:

    RPC_S_OK -

    RPC_S_OUT_OF_MEMORY - There is no memory available to construct
                          towers

--*/
{
    UUID_VECTOR UuidVectorNull;
    UUID_VECTOR PAPI *PObjUuidVector = &UuidVectorNull;
    UUID NilUuid;
    RPC_STATUS err;
    unsigned int i, j, CountBH, CountObj;
    RPC_BINDING_HANDLE EpMapperHandle;
    ept_entry_t PAPI * EpEntries, * p;
    twr_t PAPI *Twr;

    if (!ARGUMENT_PRESENT( BindingVector))
        {
        return(RPC_S_NO_BINDINGS);
        }

    if (ARGUMENT_PRESENT( UuidVector ))
        {
        PObjUuidVector = UuidVector;
        }
    else
        {
        UuidVectorNull.Count = 1;
        RpcpMemorySet(&NilUuid, 0, sizeof(UUID));
        UuidVectorNull.Uuid[0] = &NilUuid;
        }

    if (err = BindToEpMapper(
        &EpMapperHandle,
        NULL,           // NetworkAddress
        NULL,           // Protseq
        0,              // Options
        RPC_C_BINDING_DEFAULT_TIMEOUT,
        INFINITE,        // CallTimeout
        NULL        // AuthInfo
        ))
        {
        return(err);
        }

    CountObj = (unsigned int)PObjUuidVector->Count;

    if ((EpEntries = (ept_entry_t *)
        I_RpcAllocate(sizeof(ept_entry_t)*CountObj)) == NULL)
        {
        RpcBindingFree(&EpMapperHandle);
        return(RPC_S_OUT_OF_MEMORY);
        }

    RPC_STATUS FinalStatus = EPT_S_CANT_PERFORM_OP;
    CountBH = (unsigned int) BindingVector->Count;

    for (i = 0; i < CountBH; i++)
        {
        if (BindingVector->BindingH[i] == 0)
            {
            continue;
            }

        if (err = BindingAndIfToTower(IfSpec, BindingVector->BindingH[i], &Twr))
            {
            FinalStatus = err;
            break;
            }

        if (Twr == NULL)
            {
            continue;
            }

        for (p=EpEntries,j = 0; j < CountObj; j++,p++)
            {
            RpcpMemoryCopy(
                (char PAPI *)&p->object,
                (char PAPI *)PObjUuidVector->Uuid[j],
                sizeof(UUID)
                );
            p->tower = Twr;
            p->annotation[0] = '\0';
            }

        RequestEPClientMutex();
        RpcTryExcept
            {
            ept_delete_ex(
                EpMapperHandle,
                &hEpContext,
                CountObj,
                EpEntries,
                (error_status PAPI *)&err
                );
            }
        RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
            {
            err = EPT_S_CANT_PERFORM_OP;
            }
        RpcEndExcept
        ClearEPClientMutex();

        I_RpcFree(Twr);

        } // For loop over Binding Handle Vector

    if (FinalStatus != RPC_S_OK)
        {
        FinalStatus = err;
        }

    I_RpcFree(EpEntries);

    RpcBindingFree(&EpMapperHandle);

    return(FinalStatus);
}