DCATALOG.CPP

/*++ 
 
     Copyright (c) 1996 Intel Corporation 
     Copyright 1996 - 1998 Microsoft Corporation 
     All Rights Reserved 
 
     Permission is granted to use, copy and distribute this software and 
     its documentation for any purpose and without fee, provided, that 
     the above copyright notice and this statement appear in all copies. 
     Intel makes no representations about the suitability of this 
     software for any purpose.  This software is provided "AS IS." 
 
     Intel specifically disclaims all warranties, express or implied, 
     and all liability, including consequential and other indirect 
     damages, for the use of this software, including liability for 
     infringement of any proprietary rights, and including the 
     warranties of merchantability and fitness for a particular purpose. 
     Intel does not assume any responsibility for any errors which may 
     appear in this software nor any responsibility to update it. 
 
 
Module Name: 
 
    dcatalog.cpp 
 
Abstract: 
 
    This module contains the implementation of the dcatalog class. This class 
    maintains a catalog of installed WinSock2 service providers. 
 
--*/ 
 
#include "precomp.h" 
#include "install.h" 
 
  
DCATALOG::DCATALOG() 
/*++ 
 
Routine Description: 
 
    Constructor for the DCATALOG object. Set member variables to known 
    state. Initialization of the object is completed in Initialize(). 
 
Arguments: 
 
    NONE. 
 
Return Value: 
 
    NONE. 
 
--*/ 
{ 
 
    m_num_items = 0; 
    m_local_item = NULL; 
 
    // initialize the critical section object 
    InitializeCriticalSection( &m_catalog_lock ); 
    InitializeListHead( &m_protocol_list ); 
} 
 
INT 
DCATALOG::Initialize( 
    ) 
/*++ 
 
Routine Description: 
 
    Initialization routine for the DCATALOG object. Completes the 
    initialization of the DCATALOG object.  This MUST be the first member 
    fuction called after a DCATALOG object is created. 
 
Arguments: 
 
    NONE. 
 
Return Value: 
 
    NO_ERROR if the fuction succeeds else a winsock2 error code. 
 
--*/ 
{ 
    LPWSAPROTOCOL_INFOW   ProtocolInfoBuff = NULL; 
    DWORD                ProtocolInfoBuffSize = 0; 
    PPROTO_CATALOG_ITEM  CatalogItem; 
    INT                  ReturnCode; 
    INT                  ErrorCode; 
    INT                  EnumResult; 
    INT                  Index; 
 
    // Call WSCEnumProtocols with a zero length buffer so we know what size to 
    // send in to get all the installed PROTOCOL_INFO structs. 
    WSCEnumProtocols( 
        NULL,                     // lpiProtocols 
        ProtocolInfoBuff,         // lpProtocolBuffer 
        & ProtocolInfoBuffSize,   // lpdwBufferLength 
        & ErrorCode);             // lpErrno 
 
    ReturnCode = WSA_NOT_ENOUGH_MEMORY; 
    ProtocolInfoBuff = (LPWSAPROTOCOL_INFOW)new char[ProtocolInfoBuffSize]; 
    if (ProtocolInfoBuff){ 
        EnumResult = WSCEnumProtocols( 
            NULL,                     // lpiProtocols 
            ProtocolInfoBuff,         // lpProtocolBuffer 
            & ProtocolInfoBuffSize,   // lpdwBufferLength 
            & ErrorCode); 
 
        ReturnCode = WSASYSNOTREADY; 
        if (EnumResult != SOCKET_ERROR){ 
            for (Index=0; Index < EnumResult ; Index++){ 
 
                //Create a new catalog item for the PROTOCOL_INFO struct. 
                CatalogItem = new PROTO_CATALOG_ITEM; 
                if (CatalogItem){ 
 
                    ReturnCode = CatalogItem->Initialize( 
                        &ProtocolInfoBuff[Index]); 
                    if (NO_ERROR == ReturnCode){ 
 
                        //Add the new catalog item to the catalog 
                        AcquireCatalogLock(); 
                        AppendCatalogItem( 
                            CatalogItem); 
                        if (memcmp (&CatalogItem->GetProtocolInfo()->ProviderId, 
                                &LayeredProviderGuid, 
sizeof (GUID))==0) 
                            m_local_item = CatalogItem; 
                        ReleaseCatalogLock(); 
                    } //if 
                    else{ 
                        break; 
                    } //else 
                } //if 
            } //for 
 
            if ((NO_ERROR==ReturnCode) 
                    && (m_local_item==NULL)) 
                ReturnCode = WSASYSNOTREADY; 
        } //if 
        delete(ProtocolInfoBuff); 
    } //if 
    return(ReturnCode); 
} 
 
 
 
  
DCATALOG::~DCATALOG() 
/*++ 
 
Routine Description: 
 
    This  function  destroys the catalog object.  It takes care of removing and 
    destroying  all  of  the  catalog  entries  in  the catalog.  This includes 
    destroying  all  of the DPROVIDER objects referenced by the catalog.  It is 
    the  caller's responsibility to make sure that the DPROVIDER objects are no 
    longer referenced. 
 
Arguments: 
 
    None 
 
Return Value: 
 
    None 
 
Implementation Notes: 
 
    for each catalog entry 
        remove the entry 
        get its DPROVIDER reference 
        if reference is non-null 
            Set providers for all entries with matching IDs null 
            destroy the DPROVIDER 
        endif 
        destroy the entry 
    end for 
    deallocate the list head 
    close the catalog registry mutex 
--*/ 
{ 
    PLIST_ENTRY  this_linkage; 
    PPROTO_CATALOG_ITEM  this_item; 
    PDPROVIDER  this_provider; 
 
    DEBUGF( 
        DBG_TRACE, 
        ("Catalog destructor\n")); 
 
    AcquireCatalogLock(); 
 
    while ((this_linkage = m_protocol_list.Flink) != & m_protocol_list) { 
        this_item = CONTAINING_RECORD( 
            this_linkage,        // address 
            PROTO_CATALOG_ITEM,  // type 
            m_CatalogLinkage     // field 
            ); 
        RemoveCatalogItem( 
            this_item  // CatalogItem 
            ); 
        this_provider = this_item->GetProvider(); 
        if (this_provider) 
            delete this_provider; 
        delete this_item; 
    }  // while (get entry linkage) 
 
    assert( m_num_items == 0 ); 
 
    ReleaseCatalogLock(); 
    DeleteCriticalSection( &m_catalog_lock ); 
 
}  // ~DCATALOG 
 
 
 
  
VOID 
DCATALOG::EnumerateCatalogItems( 
    IN CATALOGITERATION  Iteration, 
    IN DWORD             PassBack 
    ) 
/*++ 
 
Routine Description: 
 
    This  procedure enumerates all of the DPROTO_CATALOG_ITEM structures in the 
    catalog  by  calling  the indicated iteration procedure once for each item. 
    The called procedure can stop the iteration early by returning FALSE. 
 
    Note  that  the DPROVIDER associated with an enumerated DPROTO_CATALOG_ITEM 
    may  be  NULL.   To retrieve DPROTO_CATALOG_ITEM structure that has had its 
    DPROVIDER      loaded      and      initialized,      you      can      use 
    GetCatalogItemFromCatalogEntryId. 
 
Arguments: 
 
    Iteration - Supplies   a  reference  to  the  catalog  iteration  procedure 
                supplied by the client. 
 
    PassBack  - Supplies  a  value uninterpreted by this procedure.  This value 
                is  passed  unmodified to the catalog iteration procedure.  The 
                client can use this value to carry context between the original 
                call site and the iteration procedure. 
 
Return Value: 
 
    None 
--*/ 
{ 
    PLIST_ENTRY         ListMember; 
    PPROTO_CATALOG_ITEM CatalogEntry; 
    BOOL                enumerate_more; 
 
    assert(Iteration != NULL); 
 
    enumerate_more = TRUE; 
 
    AcquireCatalogLock(); 
 
    ListMember = m_protocol_list.Flink; 
 
    while (enumerate_more && (ListMember != & m_protocol_list)) { 
        CatalogEntry = CONTAINING_RECORD( 
            ListMember, 
            PROTO_CATALOG_ITEM, 
            m_CatalogLinkage); 
        ListMember = ListMember->Flink; 
        enumerate_more = (* Iteration) ( 
            PassBack,     // PassBack 
            CatalogEntry  // CatalogEntry 
            ); 
    } //while 
 
    ReleaseCatalogLock(); 
 
}  // EnumerateCatalogItems 
 
 
  
INT 
DCATALOG::FindNextProviderInChain( 
        IN  LPWSAPROTOCOL_INFOW lpProtocolInfo, 
        OUT PDPROVIDER          *NextProvider, 
OUT PPROTO_CATALOG_ITEM*BaseProviderCatalogEntry 
    ) 
/*++ 
 
Routine Description: 
 
    This procedure finds and loads the provider below this 
    provider in the protocol chain. 
 
Arguments: 
    lpLocalProtocolInfo - A pointer to the WSAPROTOCOL_INFO struct for the 
                          current protocol chain. 
 
    NextProvider        - A pointer to DPROVIDER object pointer for the 
                          next provider in chain 
BaseProviderCatalogEntry - If next provider is a base provider, this 
  pointer will contain the next provider catalog 
  entry 
Return Value: 
 
    NO_ERROR if the next provider is located else a valid winsock2 error 
    code. 
--*/ 
{ 
 
    PLIST_ENTRY         ListMember; 
    PPROTO_CATALOG_ITEM CatalogEntry; 
    PPROTO_CATALOG_ITEM NextProviderCatalogEntry; 
DWORDLocalCatalogEntryId; 
    DWORD               NextProviderCatalogEntryId; 
    INT                 Index; 
    INT                 ReturnCode =WSASYSNOTREADY; 
 
assert (NextProvider!=NULL); 
 
if (m_local_item==NULL) 
return WSASYSNOTREADY; 
 
LocalCatalogEntryId = m_local_item->GetProtocolInfo()->dwCatalogEntryId; 
 
    AcquireCatalogLock(); 
 
// First try to see if we have processed this chain already and 
// thus loaded the provider that follows us in it 
    ListMember = m_protocol_list.Flink; 
 
    while (ListMember != & m_protocol_list) { 
 
        CatalogEntry = CONTAINING_RECORD( 
            ListMember, 
            PROTO_CATALOG_ITEM, 
            m_CatalogLinkage); 
        ListMember = ListMember->Flink; 
        if (CatalogEntry->GetProtocolInfo()->dwCatalogEntryId == 
lpProtocolInfo->dwCatalogEntryId) { 
*NextProvider = CatalogEntry->GetProvider (); 
if (*NextProvider!=NULL) { 
 ReturnCode = NO_ERROR; 
} 
else { 
// 
// Get the next providers CatalogEntryId from the protocol chain 
// 
for (Index=0; 
 Index < lpProtocolInfo->ProtocolChain.ChainLen; 
 Index++){ 
if ((LocalCatalogEntryId== 
lpProtocolInfo->ProtocolChain.ChainEntries[Index]) 
&& (lpProtocolInfo->ProtocolChain.ChainLen>Index+1)) { 
NextProviderCatalogEntryId = 
lpProtocolInfo->ProtocolChain.ChainEntries[Index+1]; 
break; 
} //if 
} // for 
// 
// If we found ourselves before reaching the end of the chain, 
// go load the next guy in the chain 
// 
if (Index<lpProtocolInfo->ProtocolChain.ChainLen) { 
ReturnCode = GetCatalogItemFromCatalogEntryId ( 
NextProviderCatalogEntryId, 
&NextProviderCatalogEntry); 
if (NO_ERROR==ReturnCode) { 
// Pass the chain protocol info if 
// the provider we are loading is not 
// the last in the chain (base provider) 
if (Index==lpProtocolInfo->ProtocolChain.ChainLen-1) 
ReturnCode = LoadProvider ( 
NextProviderCatalogEntry, 
NextProviderCatalogEntry->GetProtocolInfo(), 
NextProvider); 
else 
ReturnCode = LoadProvider ( 
NextProviderCatalogEntry, 
lpProtocolInfo, 
NextProvider); 
 
// Cache provider if we succeded 
if (NO_ERROR==ReturnCode) { 
CatalogEntry->SetProvider (*NextProvider); 
CatalogEntry->SetProviderCatalogEntry (NextProviderCatalogEntry); 
} 
} //if 
} 
} 
if ((NO_ERROR==ReturnCode) 
&& (CatalogEntry->GetProviderCatalogEntry()->GetProtocolInfo()->ProtocolChain.ChainLen==BASE_PROTOCOL)) 
*BaseProviderCatalogEntry = CatalogEntry->GetProviderCatalogEntry(); 
 
break; 
} 
} 
 
    ReleaseCatalogLock(); 
    return(ReturnCode); 
} 
 
 
  
INT 
DCATALOG::GetCatalogItemFromCatalogEntryId( 
    IN  DWORD                     CatalogEntryId, 
    OUT PPROTO_CATALOG_ITEM FAR * CatalogItem 
    ) 
/*++ 
 
Routine Description: 
 
    This  procedure  retrieves  a  reference  to a catalog item given a catalog 
    entry ID to search for. 
 
 
Arguments: 
 
    CatalogEntryId  - Supplies The ID of a catalog entry to be searched for. 
 
    CatalogItem     - Returns a reference to the catalog item with the matching 
                      catalog entry ID if it is found, otherwise returns NULL. 
 
Return Value: 
 
  The  function  returns  NO_ERROR  if  successful, otherwise it returns an 
  appropriate WinSock error code. 
--*/ 
{ 
    PLIST_ENTRY         ListMember; 
    INT                 ReturnCode=WSASYSNOTREADY; 
    PPROTO_CATALOG_ITEM CatalogEntry; 
 
    assert(CatalogItem != NULL); 
 
    // Prepare for early error return 
    * CatalogItem = NULL; 
 
    AcquireCatalogLock(); 
 
    ListMember = m_protocol_list.Flink; 
 
    while (ListMember != & m_protocol_list) { 
 
        CatalogEntry = CONTAINING_RECORD( 
            ListMember, 
            PROTO_CATALOG_ITEM, 
            m_CatalogLinkage); 
        ListMember = ListMember->Flink; 
        if (CatalogEntry->GetProtocolInfo()->dwCatalogEntryId == 
CatalogEntryId) { 
            * CatalogItem = CatalogEntry; 
            ReturnCode = NO_ERROR; 
break; 
        } //if 
    } //while 
 
    ReleaseCatalogLock(); 
    return(ReturnCode); 
}  // GetCatalogItemFromCatalogEntryId 
 
 
  
INT 
DCATALOG::LoadProvider( 
    IN PPROTO_CATALOG_ITEM CatalogEntry, 
    IN LPWSAPROTOCOL_INFOW lpProtocolInfo, 
    OUT PDPROVIDER         *Provider 
    ) 
/*++ 
 
Routine Description: 
 
    Load   the   provider  described  by  CatalogEntry. 
 
Arguments: 
 
    CatalogEntry - Supplies  a reference to a protocol catalog entry describing 
                   the provider to load. 
 
    lpProtocolInfo - Protocol info structure to pass to provider when 
loading it 
 
    Provider     - Returns a reference to the newly loaded provider object. 
 
Return Value: 
 
    The  function  returns NO_ERROR if successful, otherwise it returns an 
    appropriate WinSock error code. 
--*/ 
{ 
    INT ReturnCode = WSA_NOT_ENOUGH_MEMORY; 
    PDPROVIDER LocalProvider; 
 
    assert(CatalogEntry != NULL); 
    assert(Provider != NULL); 
 
    *Provider = NULL; 
 
    LocalProvider = new(DPROVIDER); 
    if (LocalProvider) { 
 
        ReturnCode = LocalProvider->Initialize( 
            CatalogEntry->GetLibraryPath(), 
            lpProtocolInfo 
            ); 
        if (NO_ERROR == ReturnCode) { 
            *Provider = LocalProvider; 
        } //if 
        else { 
            delete(LocalProvider); 
        } //else 
    } //if 
    return(ReturnCode); 
}  // LoadProvider 
 
 
  
VOID 
DCATALOG::AppendCatalogItem( 
    IN  PPROTO_CATALOG_ITEM  CatalogItem 
    ) 
/*++ 
 
Routine Description: 
 
    This procedure appends a catalog item to the end of the (in-memory) catalog 
    object.   It becomes the last item in the catalog. 
 
Arguments: 
 
    CatalogItem - Supplies a reference to the catalog item to be added. 
 
Return Value: 
 
    None 
--*/ 
{ 
    assert(CatalogItem != NULL); 
 
    InsertTailList( 
        & m_protocol_list,               // ListHead 
        & CatalogItem->m_CatalogLinkage  // Entry 
       ); 
    m_num_items++; 
}  // AppendCatalogItem 
 
 
  
VOID 
DCATALOG::RemoveCatalogItem( 
    IN  PPROTO_CATALOG_ITEM  CatalogItem 
    ) 
/*++ 
 
Routine Description: 
 
    This  procedure removes a catalog item from the (in-memory) catalog object. 
    The catalog information in the registry is NOT updated. 
 
Arguments: 
 
    CatalogItem - Supplies a reference to the catalog item to be removed. 
 
Return Value: 
 
    None 
--*/ 
{ 
    assert(CatalogItem != NULL); 
 
    RemoveEntryList( 
        & CatalogItem->m_CatalogLinkage  // Entry 
        ); 
    assert(m_num_items > 0); 
    m_num_items--; 
}  // RemoveCatalogItem