/*++

Copyright (c) 1995-1996 Microsoft Corporation

Module Name:

    OrSvr.cxx

Abstract:

    Object resolver server side class implementations.  CServerOxid, CServerOid,
    CServerSet and CServerSetTable classes are implemented here.

Author:

    Mario Goertzel    [MarioGo]

Revision History:

    MarioGo     04-03-95    Combined many smaller .cxx files
    MarioGo     01-12-96    Locally unique IDs

--*/

#include<or.hxx>

//
// ScanForOrphanedPinnedOids
//
// This function is called from CServerOxid::ProcessRelease when
// the soxid is deregistered or the server dies.  
//
void 
ScanForOrphanedPinnedOids(CServerOxid* pDeadOxid)
{
    CListElement* pLE;
    CServerOid* pOid;
    CServerOid* pNextOid;

    ASSERT(gpServerLock->HeldExclusive());

    // Walk the list, unpinning oids which were owned by the 
    // dead soxid.
    pLE = gpServerPinnedOidList->First();
    pOid = pLE ? CServerOid::ContainingRecord2(pLE) : NULL;
    while (pOid)
    {
        pLE = pLE->Next();
        pNextOid = pLE ? CServerOid::ContainingRecord2(pLE) : NULL;

        if (pOid->GetOxid() == pDeadOxid)
        {
            // This will remove it from the pinned list
            pOid->SetPinned(FALSE);
        }

        pOid = pNextOid;
    }

    ASSERT(gpServerLock->HeldExclusive());

    return;
}


//
// CServerOid methods
//

void
CServerOid::Reference()
{
    ASSERT(gpServerLock->HeldExclusive());

    BOOL fRemove = (this->References() == 0);

    // We may remove something from a PList more then once; this won't
    // hurt anything.  fRemove is used to avoid trying to remove it more
    // often then necessary without taking lock.

    this->CIdTableElement::Reference();

    if (fRemove)
        {
        CPListElement * t = Remove();
        ASSERT(t == &this->_plist || t == 0);
        }
}

DWORD
CServerOid::Release()
{
    ASSERT(gpServerLock->HeldExclusive());

    DWORD c = this->CReferencedObject::Dereference();

    if (0 == c)
        {
        // If another thread is already running this down it
        // means we got referenced and released during the rundown
        // callback.  That thread will figure out what to do.

        if (IsRunningDown())
            {
            KdPrintEx((DPFLTR_DCOMSS_ID,
                       DPFLTR_WARNING_LEVEL,
                       "OR: Oid running down in release: %p\n",
                       this));
            }
        else if (IsFreed() || this->_pOxid->IsRunning() == FALSE)
            {
            // Server freed this OID already; no need to run it down
            KdPrintEx((DPFLTR_DCOMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "OR: OID %p freed by server so not rundown\n",
                       this));

            SetRundown(TRUE);
            delete this;
            }
        else
            {
            // All serverset (or pinned) references have been released. Put 
            // ourselves into the oid plist so we can be rundown.
            ASSERT(!IsPinned());       
            Insert();
            }
        }

    // this pointer maybe invalid.
    return(c);
}

CServerOid::~CServerOid()
{
    ASSERT(gpServerLock->HeldExclusive());
    ASSERT(_pOxid);
    ASSERT(_fRunningDown);
    ASSERT(!IsPinned());

    _pOxid->Release();

    gpServerOidTable->Remove(this);
}

void
CServerOid::KeepAlive()
// A client has removed this oid from its set.  This keeps
// the oid alive for another timeout period.
{
    ASSERT(gpServerLock->HeldExclusive());

    if (IsRunningDown() == FALSE && References() == 0)
        {
        // It's in the rundown list, move it to the end.
        CPListElement *pT = Remove();
        ASSERT(pT == &this->_plist);
        Insert();
        }
}

void 
CServerOid::SetPinned(BOOL fPinned)
{
    ASSERT(gpServerLock->HeldExclusive());
    
    // Assert that this is a state switch.
    ASSERT(_fPinned ? !fPinned : fPinned);

    // Set new state
    _fPinned = fPinned;

    // When we are pinned, we take an extra reference to avoid further 
    // rundown attempts.  When unpinned, we remove the reference.
    if (_fPinned)
    {        
        this->Reference();

        // Now we should not be in any list
        ASSERT(_list.NotInList()); 
        ASSERT(_plist.NotInList());
        gpServerPinnedOidList->Insert(&_list);
    }
    else
    {
        // We should be in the gpServerPinnedOidList list, but not the plist
        ASSERT(_list.InList());
        ASSERT(_plist.NotInList());
        gpServerPinnedOidList->Remove(&_list);

        // This Release call may put us in the oidplist
        this->Release();
    }

    ASSERT(gpServerLock->HeldExclusive());

    return;
}


//
// CServerOidPList method
//
CServerOid *
CServerOidPList::MaybeRemoveMatchingOxid(
    IN CTime &when,
    IN CServerOid *pOid
    )
{
    CPListElement *ple;
    CServerOid *poid;

    CMutexLock lock(&this->_lock);

    ple = (CPListElement *)CPList::First();

    while(   ple != 0
          && *ple->GetTimeout() < when)
        {

        poid = CServerOid::ContainingRecord(ple);

        if (poid->Match(pOid))
            {
            Remove(ple);
            return(poid);
            }

        ple = ple->Next();
        }
    return(0);
}



//
// CServerOxid methods
//

void
CServerOxid::ProcessRelease()
/*++

Routine Desciption

    The server process owning this OXID has either died
    or deregistered this oxid.  Releases the oxid and
    nulls the pProcess pointer.

Arguments:

    n/a

Return Value:

    n/a

--*/
{
    ASSERT(gpServerLock->HeldExclusive());
    ASSERT(_pProcess);
    _fRunning = FALSE;

    ScanForOrphanedPinnedOids(this);

    Release();
    // This pointer may now be invalid, _pProcess pointer maybe invalid.
}

CServerOxid::~CServerOxid(void)
{
    ASSERT(gpServerLock->HeldExclusive());
    ASSERT(_pProcess);
    ASSERT(!IsRunning()); // implies that the oxid has been removed from the table
    ASSERT(!_fRundownInProgress);
    _pProcess->Release();
}

ORSTATUS
CServerOxid::GetInfo(
    OUT OXID_INFO *poxidInfo,
    IN  BOOL    fLocal
    )
// Server lock held shared.
{
    ORSTATUS status;
    DUALSTRINGARRAY *psa;

    if (!IsRunning())
        {
        // Server crashed, info is not needed.
        return(OR_NOSERVER);
        }

    if (fLocal)
        {
        psa = _pProcess->GetLocalBindings();
        }
    else
        {
        psa = _pProcess->GetRemoteBindings();
        }

    if (!psa)
        {
        return(OR_NOMEM);
        }

    // copy the data
    memcpy(poxidInfo, &_info, sizeof(_info));
    poxidInfo->psa = psa;

    return(OR_OK);
}

void
CServerOxid::RundownOids(ULONG cOids,
                         CServerOid* aOids[])
// Note: Returns without the server lock held.
{
    RPC_STATUS status = RPC_S_OK;

    ASSERT(cOids > 0);
    ASSERT(cOids <= MAX_OID_RUNDOWNS_PER_CALL);

    ASSERT(gpServerLock->HeldExclusive());

    // We only issue the rundown call if a) we're still running
    // and b) there isn't another rundown call to this oxid 
    // already in progress.
    if (IsRunning() && !_fRundownInProgress)
    {
        // Note: The server lock is released during the callback.
        // Since the OID hasn't rundown yet, it will keep a reference
        // to this OXID which in turn keeps the process object alive.
        
        // Ask our process object to issue an async call to try
        // to rundown the specified oids.  If call was sent ok,
        // return.   Otherwise fall thru and cleanup below.
        _fRundownInProgress = TRUE;

        status = _pProcess->RundownOids(this,
                                        cOids,
                                        aOids);

        ASSERT(!gpServerLock->HeldExclusive());

        if (status == RPC_S_OK)
        {            
            return;
        }
        else
        {
            // Re-take the lock
            gpServerLock->LockExclusive();

            // No rundown in progress now
            _fRundownInProgress = FALSE;
        }
    }

    BYTE aRundownStatus[MAX_OID_RUNDOWNS_PER_CALL];
    
    // If server died or apartment was unregistered, okay to run all 
    // oids down.  Otherwise don't run any down (this is also the 
    // case for when we are still running but another rundown is already
    // in progress).
    for (ULONG i = 0; i < cOids; i++)
    {
        aRundownStatus[i] = IsRunning() ? ORS_DONTRUNDOWN : ORS_OK_TO_RUNDOWN;
    }
	
    // Call the notify function whih will do appropriate 
    // cleanup on the oids
    ProcessRundownResultsInternal(FALSE, cOids, aOids, aRundownStatus);

    gpServerLock->UnlockExclusive();
}


void 
CServerOxid::ProcessRundownResults(ULONG cOids, 
                                   CServerOid* aOids[], 
                                   BYTE aRundownStatus[])
/*++

Routine Desciption

    Takes the appropriate action based on the result of trying
    to rundown one or more oids.

Arguments:

    cOids -- # of oids in aOids

    aOids -- array of CServerOid*'s that we tried to rundown

    aRundownStatus -- array of status values from the 
        OID_RUNDOWN_STATUS enumeration.

Return Value:

    void

--*/
{
    ProcessRundownResultsInternal(TRUE,
                                  cOids,
                                  aOids,
                                  aRundownStatus);

    return;
}

void 
CServerOxid::ProcessRundownResultsInternal(BOOL fAsyncReturn,
                                       ULONG cOids, 
                                       CServerOid* aOids[], 
                                       BYTE aRundownStatus[])
/*++

Routine Desciption

    Takes the appropriate action based on the result of trying
    to rundown one or more oids.

Arguments:
	
    fAsyncReturn -- TRUE if we are processing these results in response
        to a async rundown call returning, FALSE otherwise.

    cOids -- # of oids in aOids

    aOids -- array of CServerOid*'s that we tried to rundown

    aRundownStatus -- array of status values from the 
        OID_RUNDOWN_STATUS enumeration.

Return Value:

    void

--*/
{
    ULONG i;

    ASSERT(gpServerLock->HeldExclusive());

    // Flip the "rundown in progress" flag as necessary.
    if (fAsyncReturn)
    {
        ASSERT(_fRundownInProgress);
        _fRundownInProgress = FALSE;
    }

    for(i = 0; i < cOids; i++)
    {
        CServerOid* pOid;

        pOid = aOids[i];
        ASSERT(pOid);
        ASSERT(this == pOid->GetOxid());

        if (aRundownStatus[i] == ORS_OID_PINNED)
        {
            KdPrintEx((DPFLTR_DCOMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "OR: Randown OID %p but the client says it's pinned\n",
                       pOid));

            // Server says that particular oid is "pinned", ie cannot
            // be rundown until we are told otherwise.  Note that we
            // check for this before we check # of references -- the
            // ORS_OID_PINNED status takes precedence.
            pOid->SetPinned(TRUE);                            
            pOid->SetRundown(FALSE);
        }
        else if (pOid->References() != 0)
        {
            // Added to a set while running down and still referenced.
            pOid->SetRundown(FALSE);
        }
        else if (aRundownStatus[i] == ORS_OK_TO_RUNDOWN)
        {
            delete pOid;
        }
        else
        {
            ASSERT(aRundownStatus[i] == ORS_DONTRUNDOWN);

            KdPrintEx((DPFLTR_DCOMSS_ID,
                       DPFLTR_INFO_LEVEL,
                       "OR: Randown OID %p but the client kept it alive\n",
                       pOid));

            // Client want us to keep it alive and is still running.
            pOid->SetRundown(FALSE);
            pOid->Insert();
        }
    }
}


ORSTATUS
CServerOxid::GetRemoteInfo(
    OUT OXID_INFO *pInfo,
    IN  USHORT    cClientProtseqs,
    IN  USHORT    aClientProtseqs[]
    )
// Server lock held shared.
{
    ORSTATUS status;
    USHORT   protseq;

    status = GetInfo(pInfo, FALSE);

    if (OR_OK == status)
        {
        protseq = FindMatchingProtseq(cClientProtseqs,
                                      aClientProtseqs,
                                      pInfo->psa->aStringArray
                                      );
        if (0 == protseq)
            {
            MIDL_user_free(pInfo->psa);
            pInfo->psa = 0;
            status = OR_I_NOPROTSEQ;
            }
        }

    return(status);

}

ORSTATUS
CServerOxid::LazyUseProtseq(
    IN  USHORT    cClientProtseqs,
    IN  USHORT    *aClientProtseqs
    )
// Server lock held shared, returns with the server lock exclusive.
// Note: It is possible, that after this call the OXID has been deleted.
{
    ORSTATUS status;

    if (IsRunning())
        {
        // Keep this OXID process alive while making the callback. If the process
        // crashes and this OXID has no OIDs it could be released by everybody
        // else.  This keeps the OXID and process alive until we finish.

        this->Reference();

        gpServerLock->UnlockShared();

        status = _pProcess->UseProtseqIfNeeded(cClientProtseqs, aClientProtseqs);

        gpServerLock->LockExclusive();

        this->Release();
        }
    else
        {
        gpServerLock->ConvertToExclusive();
        status = OR_NOSERVER;
        }

    // Note: The this poiner maybe BAD now.

    return(status);
}


//
// CServerSet methods.
//

ORSTATUS
CServerSet::AddObject(OID &oid)
{
    ORSTATUS status = OR_OK;
    CServerOid *pOid;

    ASSERT(gpServerLock->HeldExclusive());

    CIdKey key(oid);

    pOid = (CServerOid *)gpServerOidTable->Lookup(key);

    if (pOid)
    {
        ASSERT(_blistOids.Member(pOid) == FALSE);
        
        // Don't add duplicate IDs to the set
        if (_blistOids.Member(pOid) == FALSE) 
        {
           status = _blistOids.Insert(pOid);
           if (status == OR_OK)
           {
               pOid->Reference();
           }
        }
    }
    else
        status = OR_BADOID;

    VALIDATE((status, OR_BADOID, OR_NOMEM, 0));

    return(status);
}

void
CServerSet::RemoveObject(OID &oid)
{
    CServerOid *pOid;

    ASSERT(gpServerLock->HeldExclusive());

    CIdKey key(oid);

    pOid = (CServerOid *)gpServerOidTable->Lookup(key);

    if (pOid)
        {
        CServerOid *pOidTmp = (CServerOid *)_blistOids.Remove(pOid);

        if (pOid == pOidTmp)
            {
            pOid->Release();
            }
        else
            {
            // Set doesn't contain the specified oid, treat this as an
            // add and delete by keeping the oid alive for another timeout
            // period.

            ASSERT(pOidTmp == 0);

            pOid->KeepAlive();
            }
        }
}

BOOL
CServerSet::ValidateObjects(BOOL fShared)
// fShared - Indicates if the server lock is held
//           shared (TRUE) or exclusive (FALSE).
//
// Return  - TRUE the lock is still shared, false
//           the lock is held exclusive.
{
    CServerOid *pOid;
    CBListIterator oids(&_blistOids);

    // Since we own a reference on all the Oids they must still exist.
    // No need to lock exclusive until we find something to delete.

    while(pOid = (CServerOid *)oids.Next())
        {
        if (!pOid->IsRunning())
            {
            if (fShared)
                {
                KdPrintEx((DPFLTR_DCOMSS_ID,
                           DPFLTR_WARNING_LEVEL,
                           "OR: Cleanup in set (%p), removing dead oids.\n",
                           this,
                           pOid));

                gpServerLock->ConvertToExclusive();
                fShared = FALSE;
                oids.Reset(&_blistOids);
                continue;
                }

            CServerOid *pOidTmp = (CServerOid *)_blistOids.Remove(pOid);

            ASSERT(pOidTmp == pOid);
            ASSERT(pOid->IsRunning() == FALSE);

            pOid->Release();
            }
        }

    return(fShared);
}

BOOL
CServerSet::Rundown()
// Rundown the whole set.
{
    CServerOid *poid;
    CTime now;

    ASSERT(gpServerLock->HeldExclusive());

    if (_timeout > now)
        {
        // Don't rundown if we've recieved a late ping.
        return(FALSE);
        }

    if (_fLocal && _blistOids.Size() != 0)
        {
        KdPrintEx((DPFLTR_DCOMSS_ID,
                   DPFLTR_WARNING_LEVEL,
                   "OR: Premature rundown of local set ignored.\n"));

        return(FALSE);
        }

    KdPrintEx((DPFLTR_DCOMSS_ID,
               DPFLTR_WARNING_LEVEL,
               "OR: Set %p's client appears to have died\n",
               this));

    CBListIterator oids(&_blistOids);

    while(poid = (CServerOid *)oids.Next())
        {
        poid->Release();
        }

    return(TRUE);
}


//
// CServerSetTable implementation
//

CServerSet *
CServerSetTable::Allocate(
    IN USHORT sequence,
    IN PSID   psid,
    IN BOOL   fLocal,
    OUT ID   &setid
    )
/*++

Routine Description:

    Allocates a new CServerSet and returns the setid for the new set.

Arguments:

    sequence - initial sequence number for the new set.

    psid - pointer to an NT SID structure for the new set.

    fLocal - TRUE : set is for the local client,
             FALSE : set is for a remote client

    setid - the setid of the set returned.  Unchanged if return value 0.

Return Value:

    0 - Unable to allocate a resource

    non-zero - A pointer to the newly created set.

--*/
{
    ASSERT(gpServerLock->HeldExclusive());
    UINT i;
    LARGE_INTEGER li;

    ASSERT(_cAllocated <= _cMax);

    if (_cAllocated == _cMax)
        {
        // Table is full, realloc

        // Do this first, if it succeeds great even if
        // a later allocation fails. If not, fail now.

        IndexElement *pNew = new IndexElement[_cMax * 2];

        if (!pNew)
            {
            return(0);
            }

        for (i = 0; i < _cMax; i++)
            {
            pNew[i] = _pElements[i];
            }

        for(i = _cMax; i < _cMax*2; i++)
            {
            pNew[i]._sequence = GetTickCount();
            pNew[i]._pSet = 0;
            }

        delete _pElements;
        _pElements = pNew;
        _cMax *= 2;
        }

    CServerSet *pSet = new CServerSet(sequence, psid, fLocal);

    if (0 == pSet)
        {
        return(0);
        }

    ASSERT(_pElements);
    ASSERT(_cMax > _cAllocated);

    for(i = _iFirstFree; i < _cMax; i++)
        {
        if (0 == _pElements[i]._pSet)
            {
            _pElements[i]._sequence++;
            _pElements[i]._pSet = pSet;
            li.HighPart = i + 1;
            li.LowPart = _pElements[i]._sequence;
            setid = li.QuadPart;
            _iFirstFree = i + 1;
            _cAllocated++;
            return pSet;
            }
        }

    ASSERT(0);
    return(0);
}


CServerSet *
CServerSetTable::Lookup(
    IN ID setid
    )
/*++

Routine Description:

    Looks up an a set given the sets ID.

    Server lock held shared.

Arguments:

    setid - the ID of the set to lookup

Return Value:

    0 - set doesn't exist

    non-zero - the set.

--*/
{
    LARGE_INTEGER li;
    li.QuadPart = setid;
    LONG i = li.HighPart - 1;
    DWORD sequence = (DWORD)(setid & ~((ID)0));

    if (i >= 0 && (DWORD) i < _cMax)
        {
        if (_pElements[i]._sequence == sequence)
            {
            // May still be null if it is free and has not yet be reused.
            return(_pElements[i]._pSet);
            }
        }
    return(0);
}


ID
CServerSetTable::CheckForRundowns(
    )
/*++

Routine Description:

    Used by ping and worker threads to monitor for sets that should
    be rundown.  It is called with the server lock held shared.

Arguments:

    None

Return Value:

    0 - Didn't find a set to rundown

    non-zero - ID of a set which may need to be rundown.

--*/
{
    UINT i, end;
    LARGE_INTEGER id;
    id.QuadPart = 0;
    ASSERT(_iRundown < _cMax);

    if (_cAllocated == 0)
        {
        return(0);
        }

    i = _iRundown;
    do
        {
        ASSERT(_cAllocated);  // loop assumes one or more allocated elements.
        i = (i + 1) % _cMax;
        }
    while(0 == _pElements[i]._pSet);

    ASSERT(_pElements[i]._pSet);

    if (_pElements[i]._pSet->ShouldRundown())
        {
        id.HighPart = i + 1;
        id.LowPart = _pElements[i]._sequence;
        }

    _iRundown = i;

    return(id.QuadPart);
}


BOOL
CServerSetTable::RundownSetIfNeeded(
    IN ID setid
    )
/*++

Routine Description:

    Rundowns down a set (or sets) if needed. Called by
    ping and worker threads.  Server lock held exclusive.

Arguments:

    setid - An ID previously returned from CheckForRundowns.

Return Value:

    TRUE - A set was actually rundown

    FALSE - No sets actually rundown

--*/
{
    ASSERT(gpServerLock->HeldExclusive());

    CServerSet *pSet = Lookup(setid);

    if (0 == pSet || FALSE == pSet->ShouldRundown())
        {
        // Set already randown or has been pinged in the meantime.
        return(FALSE);
        }

    // PERF REVIEW this function has the option of running multiple sets,
    // saving the worker thread from taking and leaving the lock many times
    // when a bunch of sets all rundown.  This feature is not used.

    LARGE_INTEGER li;
    li.QuadPart = setid;

    UINT i = li.HighPart - 1;

     if (pSet->Rundown())
        {
        delete pSet;
        _cAllocated--;
        if (i < _iFirstFree) _iFirstFree = i;
        _pElements[i]._pSet = 0;
        return(TRUE);
        }

    return(FALSE);
}


void 
CServerSetTable::PingAllSets()
/*++

Routine Description:

    Performs a ping of all sets currently in the table.

Arguments:

    none

Return Value:

    void

--*/
{
    ASSERT(gpServerLock->HeldExclusive());

    ULONG i;
    for(i = 0; i < _cMax; i++)
    {
        if (_pElements[i]._pSet)
        {
            _pElements[i]._pSet->Ping(FALSE);
        }
    }	
}