windows-xp/Source/XPSP1/NT/admin/pchealth/helpctr/shell/connectivity/hyperlinks.cpp

/******************************************************************************

Copyright (c) 2000 Microsoft Corporation

Module Name:
    HyperLinks.cpp

Abstract:
    This file contains the implementation of the HyperLinks library.

Revision History:
    Davide Massarenti   (Dmassare)  11/28/2000
        created

******************************************************************************/

#include "stdafx.h"

////////////////////////////////////////////////////////////////////////////////

static const DATE l_TIME_hour    = 1.0 / 24.0;
static const DATE l_TIME_minute  = l_TIME_hour / 60.0;
static const DATE l_TIME_second  = l_TIME_hour / 60.0;
static const DATE l_TIME_timeout = l_TIME_minute * 5.0;

static const WCHAR l_szMS_ITS     [] = L"ms-its:";
static const WCHAR l_szMSITSTORE  [] = L"mk:@MSITStore:";
static const WCHAR l_szITS        [] = L"its:";

static const WCHAR l_szHOMEPAGE   [] = L"hcp://services/centers/homepage";
static const WCHAR l_szSUPPORT    [] = L"hcp://services/centers/support";
static const WCHAR l_szOPTIONS    [] = L"hcp://services/centers/options";
static const WCHAR l_szUPDATE     [] = L"hcp://services/centers/update";
static const WCHAR l_szCOMPAT     [] = L"hcp://services/centers/compat";
static const WCHAR l_szTOOLS      [] = L"hcp://services/centers/tools";
static const WCHAR l_szERRMSG     [] = L"hcp://services/centers/errmsg";

static const WCHAR l_szSEARCH     [] = L"hcp://services/search";
static const WCHAR l_szINDEX      [] = L"hcp://services/index";
static const WCHAR l_szSUBSITE    [] = L"hcp://services/subsite";

static const WCHAR l_szFULLWINDOW [] = L"hcp://services/layout/fullwindow";
static const WCHAR l_szCONTENTONLY[] = L"hcp://services/layout/contentonly";
static const WCHAR l_szKIOSK      [] = L"hcp://services/layout/kiosk";
static const WCHAR l_szXML        [] = L"hcp://services/layout/xml";

static const WCHAR l_szREDIRECT   [] = L"hcp://services/redirect";

static const WCHAR l_szHCP        [] = L"hcp://";
static const WCHAR l_szHCP_redir  [] = L"hcp:";

static const WCHAR l_szAPPLICATION[] = L"app:";

static const WCHAR l_szRESOURCE   [] = L"res://";

////////////////////

typedef enum
{
    QFT_TEXT       ,
    QFT_URL        ,
    QFT_TAXONOMY   ,
    QFT_APPLICATION,
} QueryFieldType;

struct QueryField
{
    LPCWSTR        szName;
    QueryFieldType qft;
    bool           fOptional;
};

struct Pattern
{
    LPCWSTR            szTxt;
    size_t             iLen; /* -1 for complete match */
    HyperLinks::Format fmt;

    const QueryField*  rgQueryFields;
    size_t             iQueryFields;
};

////////////////////

static const QueryField l_rgTopic   [] = { { L"topic"      , QFT_URL        , false } };
static const QueryField l_rgTopicOpt[] = { { L"topic"      , QFT_URL        , true  } };

static const QueryField l_rgSEARCH  [] = { { L"query"      , QFT_TEXT       , false } ,
                                           { L"topic"      , QFT_URL        , true  } };

static const QueryField l_rgINDEX   [] = { { L"scope"      , QFT_APPLICATION, true  } ,
                                           { L"select"     , QFT_APPLICATION, true  } ,
                                           { L"topic"      , QFT_URL        , true  } };

static const QueryField l_rgSUBSITE [] = { { L"node"       , QFT_TAXONOMY   , false } ,
                                           { L"select"     , QFT_TAXONOMY   , true  } ,
                                           { L"topic"      , QFT_URL        , true  } };

static const QueryField l_rgXML     [] = { { L"definition" , QFT_URL        , false } ,
                                           { L"topic"      , QFT_URL        , true  } };

static const QueryField l_rgREDIRECT[] = { { L"online"     , QFT_URL        , false } ,
                                           { L"offline"    , QFT_URL        , false } };

static const QueryField l_rgAPP     [] = { { L"topic"      , QFT_URL        , true  } };


static const Pattern l_rgPattern[] =
{
    { l_szMS_ITS     , MAXSTRLEN( l_szMS_ITS      ), HyperLinks::FMT_MSITS                                                      },
    { l_szMSITSTORE  , MAXSTRLEN( l_szMSITSTORE   ), HyperLinks::FMT_MSITS                                                      },
    { l_szITS        , MAXSTRLEN( l_szITS         ), HyperLinks::FMT_MSITS                                                      },

    ////////////////////

    { l_szHOMEPAGE   , -1                          , HyperLinks::FMT_CENTER_HOMEPAGE                                            },
    { l_szSUPPORT    , -1                          , HyperLinks::FMT_CENTER_SUPPORT    , l_rgTopicOpt, ARRAYSIZE(l_rgTopicOpt ) },
    { l_szOPTIONS    , -1                          , HyperLinks::FMT_CENTER_OPTIONS    , l_rgTopicOpt, ARRAYSIZE(l_rgTopicOpt ) },
    { l_szUPDATE     , -1                          , HyperLinks::FMT_CENTER_UPDATE                                              },
    { l_szCOMPAT     , -1                          , HyperLinks::FMT_CENTER_COMPAT                                              },
    { l_szTOOLS      , -1                          , HyperLinks::FMT_CENTER_TOOLS      , l_rgTopicOpt, ARRAYSIZE(l_rgTopicOpt ) },
    { l_szERRMSG     , -1                          , HyperLinks::FMT_CENTER_ERRMSG                                              },

    { l_szSEARCH     , -1                          , HyperLinks::FMT_SEARCH            , l_rgSEARCH  , ARRAYSIZE(l_rgSEARCH   ) },
    { l_szINDEX      , -1                          , HyperLinks::FMT_INDEX             , l_rgINDEX   , ARRAYSIZE(l_rgINDEX    ) },
    { l_szSUBSITE    , -1                          , HyperLinks::FMT_SUBSITE           , l_rgSUBSITE , ARRAYSIZE(l_rgSUBSITE  ) },

    { l_szFULLWINDOW , -1                          , HyperLinks::FMT_LAYOUT_FULLWINDOW , l_rgTopic   , ARRAYSIZE(l_rgTopic    ) },
    { l_szCONTENTONLY, -1                          , HyperLinks::FMT_LAYOUT_CONTENTONLY, l_rgTopic   , ARRAYSIZE(l_rgTopic    ) },
    { l_szKIOSK      , -1                          , HyperLinks::FMT_LAYOUT_KIOSK      , l_rgTopic   , ARRAYSIZE(l_rgTopic    ) },
    { l_szXML        , -1                          , HyperLinks::FMT_LAYOUT_XML        , l_rgXML     , ARRAYSIZE(l_rgXML      ) },

    { l_szREDIRECT   , -1                          , HyperLinks::FMT_REDIRECT          , l_rgREDIRECT, ARRAYSIZE(l_rgREDIRECT ) },

    { l_szHCP        , MAXSTRLEN( l_szHCP         ), HyperLinks::FMT_HCP                                                        },
    { l_szHCP_redir  , MAXSTRLEN( l_szHCP_redir   ), HyperLinks::FMT_HCP_REDIR                                                  },

    ////////////////////

    { l_szAPPLICATION, MAXSTRLEN( l_szAPPLICATION ), HyperLinks::FMT_APPLICATION       , l_rgAPP     , ARRAYSIZE(l_rgAPP      ) },

    ////////////////////

    { l_szRESOURCE   , MAXSTRLEN( l_szRESOURCE    ), HyperLinks::FMT_RESOURCE                                                   },

    ////////////////////

    { NULL                                                                                                                      }
};

HyperLinks::ParsedUrl::ParsedUrl()
{
                                                // MPC::wstring       m_strURL;
    m_fmt          = HyperLinks::FMT_INVALID;   // Format             m_fmt;
    m_state        = HyperLinks::STATE_INVALID; // State              m_state;
    m_dLastChecked = 0;                         // DATE               m_dLastChecked;
    m_fBackground  = true;                      // bool               m_fBackground;
                                                //
                                                // MPC::wstring       m_strBasePart;
                                                // MPC::WStringLookup m_mapQuery;
}

HRESULT HyperLinks::ParsedUrl::Initialize( /*[in]*/ LPCWSTR szURL )
{
    __HCP_FUNC_ENTRY( "HyperLinks::ParsedUrl::Initialize" );

    HRESULT hr;

    SANITIZEWSTR(szURL);


    m_strURL  = szURL;
    m_fmt     = HyperLinks::FMT_INVALID;
    m_state   = HyperLinks::STATE_NOTPROCESSED;


    MPC::HTML::ParseHREF( m_strURL.c_str(), m_strBasePart, m_mapQuery );


    if(m_strBasePart.size() == 0)
    {
        m_state = HyperLinks::STATE_MALFORMED;
    }
    else if(MPC::MSITS::IsCHM( m_strBasePart.c_str() ))
    {
        m_fmt = HyperLinks::FMT_MSITS;
    }
    else
    {
        CComBSTR bstrURL( m_strBasePart.c_str() ); if(bstrURL) ::CharLowerW( bstrURL );

        szURL = bstrURL;
        for(const Pattern* ptr=l_rgPattern; ptr->szTxt; ptr++)
        {
            int iCmp;

            if(ptr->iLen) iCmp = wcsncmp( szURL, ptr->szTxt, ptr->iLen );
            else          iCmp = wcscmp ( szURL, ptr->szTxt            );

            if(iCmp == 0)
            {
                const QueryField* field = ptr->rgQueryFields;

                for(size_t i=0; i<ptr->iQueryFields; i++, field++)
                {
                    CComBSTR bstrValue;

                    if(GetQueryField( field->szName, bstrValue ) == false)
                    {
                        if(field->fOptional == false)
                        {
                            m_state = HyperLinks::STATE_MALFORMED;
                            break;
                        }
                    }
                    else
                    {
                        if(field->qft == QFT_TEXT)
                        {
                            ;
                        }
                        else if(field->qft == QFT_URL)
                        {
                            if(FAILED(IsValid( bstrValue )))
                            {
                                m_state = HyperLinks::STATE_MALFORMED;
                                break;
                            }
                        }
                        else if(field->qft == QFT_TAXONOMY)
                        {
                            /* TO DO */
                        }
                        else if(field->qft == QFT_APPLICATION)
                        {
                            /* TO DO */
                        }
                    }
                }

                m_fmt = ptr->fmt;
                break;
            }
        }

        //
        // If the URL begins with HCP: but not HCP://, it's a protocol redirection, so recurse.
        //
        if(m_fmt == HyperLinks::FMT_HCP_REDIR)
        {
            __MPC_SET_ERROR_AND_EXIT(hr, Initialize( szURL + MAXSTRLEN( l_szHCP_redir ) ));
        }

        if(m_fmt == HyperLinks::FMT_INVALID) // Still not resolved...
        {
            MPC::URL        url;
            INTERNET_SCHEME scheme;

            if(SUCCEEDED(url.put_URL   ( szURL  )) &&
               SUCCEEDED(url.get_Scheme( scheme ))  )
            {
                switch(scheme)
                {
                case INTERNET_SCHEME_UNKNOWN   : m_fmt   = HyperLinks::FMT_INTERNET_UNKNOWN   ; break;
                case INTERNET_SCHEME_FTP       : m_fmt   = HyperLinks::FMT_INTERNET_FTP       ; break;
                case INTERNET_SCHEME_GOPHER    : m_fmt   = HyperLinks::FMT_INTERNET_GOPHER    ; break;
                case INTERNET_SCHEME_HTTP      : m_fmt   = HyperLinks::FMT_INTERNET_HTTP      ; break;
                case INTERNET_SCHEME_HTTPS     : m_fmt   = HyperLinks::FMT_INTERNET_HTTPS     ; break;
                case INTERNET_SCHEME_FILE      : m_fmt   = HyperLinks::FMT_INTERNET_FILE      ; break;
                case INTERNET_SCHEME_NEWS      : m_fmt   = HyperLinks::FMT_INTERNET_NEWS      ; break;
                case INTERNET_SCHEME_MAILTO    : m_fmt   = HyperLinks::FMT_INTERNET_MAILTO    ; break;
                case INTERNET_SCHEME_SOCKS     : m_fmt   = HyperLinks::FMT_INTERNET_SOCKS     ; break;
                case INTERNET_SCHEME_JAVASCRIPT: m_fmt   = HyperLinks::FMT_INTERNET_JAVASCRIPT; break;
                case INTERNET_SCHEME_VBSCRIPT  : m_fmt   = HyperLinks::FMT_INTERNET_VBSCRIPT  ; break;
                default                        : m_state = HyperLinks::STATE_MALFORMED        ; break;
                }
            }
        }
    }

    hr = S_OK;



    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

bool HyperLinks::ParsedUrl::IsLocal()
{
    switch(m_fmt)
    {
    case HyperLinks::FMT_INTERNET_UNKNOWN   :
    case HyperLinks::FMT_INTERNET_FTP       :
    case HyperLinks::FMT_INTERNET_GOPHER    :
    case HyperLinks::FMT_INTERNET_HTTP      :
    case HyperLinks::FMT_INTERNET_HTTPS     :
    case HyperLinks::FMT_INTERNET_FILE      :
    case HyperLinks::FMT_INTERNET_NEWS      :
    case HyperLinks::FMT_INTERNET_MAILTO    :
    case HyperLinks::FMT_INTERNET_SOCKS     :
    case HyperLinks::FMT_INTERNET_JAVASCRIPT:
    case HyperLinks::FMT_INTERNET_VBSCRIPT  :
        return false;

    case HyperLinks::FMT_MSITS:
        //
        // Make sure it's not on a network share!
        //
        {
            CComBSTR bstrStorageName;
            CComBSTR bstrFilePath;

            if(MPC::MSITS::IsCHM( m_strURL.c_str(), &bstrStorageName, &bstrFilePath ))
            {
                if(wcsncmp( L"\\\\", SAFEBSTR(bstrStorageName), 2 ) == 0)
                {
                    return false;
                }
            }
        }
        break;

    }

    return true;
}

HyperLinks::State HyperLinks::ParsedUrl::CheckState( /*[in/out]*/ bool& fFirstWinInetUse )
{
    HRESULT  hr;
    State    state = HyperLinks::STATE_NOTFOUND;
    LPCWSTR  szURL = m_strURL.c_str();
    LPCWSTR  szEnd;
    CComBSTR bstrURL;

    //
    // Skip the bookmark sign.
    //
    if((szEnd = wcschr( szURL, '#' )))
    {
        bstrURL.Attach( ::SysAllocStringLen( szURL, (szEnd - szURL) ) );
        szURL = SAFEBSTR( bstrURL );
    }

    switch(m_fmt)
    {
    case HyperLinks::FMT_INVALID            :
        state = HyperLinks::STATE_MALFORMED;
        break;

    case HyperLinks::FMT_INTERNET_FTP       :
    case HyperLinks::FMT_INTERNET_GOPHER    :
    case HyperLinks::FMT_INTERNET_HTTP      :
    case HyperLinks::FMT_INTERNET_HTTPS     :
    case HyperLinks::FMT_INTERNET_FILE      :
    case HyperLinks::FMT_INTERNET_NEWS      :
		while(1)
        {
            DWORD dwTimeout = m_fBackground ? HC_TIMEOUT_LINKCHECKER_BACKGROUND : HC_TIMEOUT_LINKCHECKER_FOREGROUND;

            if(SUCCEEDED(hr = MPC::Connectivity::DestinationReachable( szURL, dwTimeout )))
            {
                state = HyperLinks::STATE_ALIVE;
            }
            else if(hr == E_INVALIDARG) // Unsupported protocol, assume the link is OK.
            {
                state = HyperLinks::STATE_ALIVE;
            }
            else if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
            {
                state = HyperLinks::STATE_NOTFOUND;
            }
            else if(hr == HRESULT_FROM_WIN32(ERROR_INTERNET_DISCONNECTED))
            {
                state = HyperLinks::STATE_OFFLINE;
            }
            else
            {
                //
                // If it's the first time through, it could be that WinINET couldn't activate the proxy code in time...
                //
                if(fFirstWinInetUse == true)
                {
					fFirstWinInetUse = false; continue;
                }

				if(SUCCEEDED(MPC::Connectivity::NetworkAlive( dwTimeout )))
				{
					state = HyperLinks::STATE_UNREACHABLE;
				}
				else
				{
					state = HyperLinks::STATE_OFFLINE;
				}
            }

            fFirstWinInetUse = false; break;
        }
        break;

    case HyperLinks::FMT_INTERNET_UNKNOWN   :
    case HyperLinks::FMT_INTERNET_MAILTO    :
    case HyperLinks::FMT_INTERNET_SOCKS     :
    case HyperLinks::FMT_INTERNET_JAVASCRIPT:
    case HyperLinks::FMT_INTERNET_VBSCRIPT  :
        state = HyperLinks::STATE_ALIVE;
        break;

    case HyperLinks::FMT_HCP                :
        {
            CComPtr<IInternetProtocolRoot> obj;

            state = HyperLinks::STATE_NOTFOUND;

            if(SUCCEEDED(CHCPProtocol::CreateInstance( &obj )))
            {
                if(SUCCEEDED(obj->Start( szURL, NULL, NULL, 0, NULL )))
                {
                    state = HyperLinks::STATE_ALIVE;
                }
            }
        }
        break;

    case HyperLinks::FMT_MSITS              :
        {
            MPC::wstring     strUrlModified;
            MPC::wstring     strUrlModified2;
            CComBSTR         bstrStorageName;
            CComBSTR         bstrFilePath;
            CComPtr<IStream> stream;

            state = HyperLinks::STATE_NOTFOUND;

            CPCHWrapProtocolInfo::NormalizeUrl( szURL                 , strUrlModified , /*fReverse*/true  );
            CPCHWrapProtocolInfo::NormalizeUrl( strUrlModified.c_str(), strUrlModified2, /*fReverse*/false );
            if(MPC::MSITS::IsCHM( strUrlModified2.c_str(), &bstrStorageName, &bstrFilePath ))
            {
                if(SUCCEEDED(MPC::MSITS::OpenAsStream( bstrStorageName, bstrFilePath, &stream )))
                {
                    state = HyperLinks::STATE_ALIVE;
                }
            }
        }
        break;

    case HyperLinks::FMT_CENTER_HOMEPAGE    :
    case HyperLinks::FMT_CENTER_SUPPORT     :
    case HyperLinks::FMT_CENTER_OPTIONS     :
    case HyperLinks::FMT_CENTER_UPDATE      :
    case HyperLinks::FMT_CENTER_COMPAT      :
    case HyperLinks::FMT_CENTER_TOOLS       :
    case HyperLinks::FMT_CENTER_ERRMSG      :
        state = HyperLinks::STATE_ALIVE;
        break;

    case HyperLinks::FMT_SEARCH             :
    case HyperLinks::FMT_INDEX              :
    case HyperLinks::FMT_SUBSITE            :
        state = HyperLinks::STATE_ALIVE;
        break;

    case HyperLinks::FMT_LAYOUT_FULLWINDOW  :
    case HyperLinks::FMT_LAYOUT_CONTENTONLY :
    case HyperLinks::FMT_LAYOUT_KIOSK       :
    case HyperLinks::FMT_LAYOUT_XML         :
        state = HyperLinks::STATE_ALIVE;
        break;

    case HyperLinks::FMT_REDIRECT           :
        state = HyperLinks::STATE_ALIVE;
        break;

    case HyperLinks::FMT_APPLICATION        :
        state = HyperLinks::STATE_ALIVE;
        break;

    case HyperLinks::FMT_RESOURCE           :
        state = HyperLinks::STATE_UNREACHABLE;
        break;
    }

    m_dLastChecked = MPC::GetLocalTime();

    return state;
}

bool HyperLinks::ParsedUrl::IsOkToProceed()
{
    switch(m_state)
    {
    case HyperLinks::STATE_NOTPROCESSED:
    case HyperLinks::STATE_CHECKING    :
    case HyperLinks::STATE_ALIVE       :
        return true;
    }

    return false;
}


bool HyperLinks::ParsedUrl::HasQueryField( /*[in]*/ LPCWSTR szField )
{
    MPC::WStringLookupIter it = m_mapQuery.find( szField );

    return (it != m_mapQuery.end());
}

bool HyperLinks::ParsedUrl::GetQueryField( /*[in]*/ LPCWSTR szField, /*[in]*/ CComBSTR& bstrValue )
{
    MPC::WStringLookupIter it = m_mapQuery.find( szField );

    if(it != m_mapQuery.end())
    {
        bstrValue = it->second.c_str();
        return true;
    }

    bstrValue.Empty();
    return false;
}

////////////////////////////////////////////////////////////////////////////////

HyperLinks::UrlHandle::UrlHandle()
{
    m_main = NULL; // Lookup*    m_main;
    m_pu   = NULL; // ParsedUrl* m_pu;
}

HyperLinks::UrlHandle::~UrlHandle()
{
    Release();
}

void HyperLinks::UrlHandle::Attach( /*[in]*/ Lookup*    main ,
                                    /*[in]*/ ParsedUrl* pu   )
{
    Release();

    m_main = main; if(main) main->Lock();
    m_pu   = pu;
}

void HyperLinks::UrlHandle::Release()
{
    if(m_main) m_main->Unlock();

    m_main = NULL;
    m_pu   = NULL;
}

////////////////////////////////////////////////////////////////////////////////

HyperLinks::Lookup::Lookup()
{
    // PendingUrlList m_lst;
    // UrlMap         m_map;
}

HyperLinks::Lookup::~Lookup()
{
    Thread_Wait();
}

////////////////////

HyperLinks::Lookup* HyperLinks::Lookup::s_GLOBAL( NULL );

HRESULT HyperLinks::Lookup::InitializeSystem()
{
    if(s_GLOBAL == NULL)
    {
        s_GLOBAL = new HyperLinks::Lookup;
    }

    return s_GLOBAL ? S_OK : E_OUTOFMEMORY;
}

void HyperLinks::Lookup::FinalizeSystem()
{
    if(s_GLOBAL)
    {
        delete s_GLOBAL; s_GLOBAL = NULL;
    }
}

////////////////////

HRESULT HyperLinks::Lookup::RunChecker()
{
    __HCP_FUNC_ENTRY( "HyperLinks::Lookup::RunChecker" );

    HRESULT                      hr;
    MPC::SmartLock<_ThreadModel> lock( this );
    bool                         fFirstWinInetUse = true;


    Thread_SignalMain();

    while(Thread_IsAborted() == false)
    {
        bool           fSleep  = true;
        ParsedUrl*     urlBest = NULL;
        PendingUrlIter it;

        //
        // Look for the first query store not ready and execute it.
        //
        for(it = m_lst.begin(); it != m_lst.end();)
        {
            ParsedUrl* url = *it;

            if(url->m_state != HyperLinks::STATE_NOTPROCESSED)
            {
                m_lst.erase( it );

                it      = m_lst.begin();
                urlBest = NULL;
            }
            else
            {
                if(url->m_fBackground == false)
                {
                    urlBest = url;
                    break;
                }

                urlBest = url;
                it++;
            }
        }

        if(urlBest)
        {
            State state = HyperLinks::STATE_NOTFOUND;

            //
            // Remove this query from the pending list.
            //
            for(it = m_lst.begin(); it != m_lst.end(); )
            {
                if(*it == urlBest)
                {
                    m_lst.erase( it );

                    it = m_lst.begin();
                }
                else
                {
                    it++;
                }
            }

            DebugLog( L"%%%%%%%%%%%%%%%%%%%% CHECKING %s\n", urlBest->m_strURL.c_str() );
            urlBest->m_state = HyperLinks::STATE_CHECKING;

            lock = NULL;
            __MPC_PROTECT( state = urlBest->CheckState( fFirstWinInetUse ) );
            lock = this;

            urlBest->m_state = state;

            Thread_SignalMain();

            fSleep = false;
        }

        if(fSleep)
        {
            lock = NULL;
            Thread_WaitForEvents( NULL, INFINITE );
            lock = this;
        }
    }

    hr = S_OK;


    Thread_Abort();

    __HCP_FUNC_EXIT(hr);
}

HRESULT HyperLinks::Lookup::CreateItem( /*[in ]*/ LPCWSTR     szURL ,
                                        /*[out]*/ ParsedUrl*& pu    )
{
    __HCP_FUNC_ENTRY( "HyperLinks::Lookup::CreateItem" );

    HRESULT        hr;
    UrlIter        it;
    MPC::wstringUC strURL( SAFEWSTR( szURL ) );

    it = m_map.find( strURL );
    if(it == m_map.end())
    {
        pu = &(m_map[ strURL ]);

        __MPC_EXIT_IF_METHOD_FAILS(hr, pu->Initialize( szURL ));
    }
    else
    {
        pu = &it->second;
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}

////////////////////

HRESULT HyperLinks::Lookup::Queue( /*[in]*/ LPCWSTR szURL )
{
    UrlHandle uh;

    return Get( szURL, uh );
}

HRESULT HyperLinks::Lookup::Get( /*[in]*/ LPCWSTR    szURL          ,
                                 /*[in]*/ UrlHandle& uh             ,
                                 /*[in]*/ DWORD      dwWaitForCheck ,
                                 /*[in]*/ bool       fForce         )
{
    __HCP_FUNC_ENTRY( "HyperLinks::Lookup::Get" );

    HRESULT                      hr;
    MPC::SmartLock<_ThreadModel> lock( this );
    ParsedUrl*                   pu;


    uh.Release();

    ////////////////////////////////////////////////////////////////////////////////

    if(Thread_IsRunning() == false)
    {
        lock = NULL;
        __MPC_EXIT_IF_METHOD_FAILS(hr, Thread_Start( this, RunChecker, NULL ));

        Thread_WaitNotificationFromWorker( INFINITE, /*fNoMessagePump*/true );
        lock = this;
    }

    ////////////////////////////////////////////////////////////////////////////////

    __MPC_EXIT_IF_METHOD_FAILS(hr, CreateItem( szURL, pu ));

    if(fForce)
    {
        pu->m_state = HyperLinks::STATE_NOTPROCESSED;
    }

    switch(pu->m_state)
    {
    case HyperLinks::STATE_ALIVE      :
    case HyperLinks::STATE_NOTFOUND   :
    case HyperLinks::STATE_UNREACHABLE:
    case HyperLinks::STATE_OFFLINE    :
        if(dwWaitForCheck)
        {
            //
            // Make sure the state is not stale.
            //
            DATE dNow = MPC::GetLocalTime();

            if((dNow - pu->m_dLastChecked) >= l_TIME_timeout)
            {
                pu->m_state = HyperLinks::STATE_NOTPROCESSED;
            }
        }
        break;
    }

    if(pu->m_state == HyperLinks::STATE_NOTPROCESSED)
    {
        bool fQueue = false;
        bool fWait  = false;

        if(dwWaitForCheck)
        {
            //
            // Elevate the URL to "important".
            //
            pu->m_fBackground = false;

            fWait = true;

            if(pu->IsLocal() == false)
            {
                fQueue = true;
            }
        }
        else
        {
            fQueue = true;
        }

        if(fQueue)
        {
            m_lst.push_back( pu );
            Thread_Signal();
        }

        if(fWait)
        {
            if(pu->IsLocal())
            {
                bool fFirstWinInetUse = false;

                pu->m_state = pu->CheckState( fFirstWinInetUse );
            }
            else
            {
                int iRetry = 5;

                dwWaitForCheck /= iRetry;

                while(pu->m_state == HyperLinks::STATE_NOTPROCESSED ||
                      pu->m_state == HyperLinks::STATE_CHECKING      )
                {
                    DWORD dwRes;

                    lock  = NULL;
                    dwRes = Thread_WaitNotificationFromWorker( dwWaitForCheck, /*fNoMessagePump*/true );
                    lock  = this;

                    if(iRetry-- == 0)
                    {
                        __MPC_SET_ERROR_AND_EXIT(hr, S_FALSE);
                    }
                }
            }
        }
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    if(pu) uh.Attach( this, pu );

    __HCP_FUNC_EXIT(hr);
}

////////////////////////////////////////////////////////////////////////////////

HRESULT HyperLinks::IsValid( /*[in]*/ LPCWSTR szURL )
{
    __HCP_FUNC_ENTRY( "HyperLinks::IsValid" );

    HRESULT   hr;
    ParsedUrl pu;

    __MPC_EXIT_IF_METHOD_FAILS(hr, pu.Initialize( szURL ));

    switch(pu.m_state)
    {
    case HyperLinks::STATE_INVALID  :
    case HyperLinks::STATE_MALFORMED:
        __MPC_SET_ERROR_AND_EXIT(hr, E_FAIL);
    }

    hr = S_OK;


    __HCP_FUNC_CLEANUP;

    __HCP_FUNC_EXIT(hr);
}