//-----------------------------------------------------------------------------
//
//
//  File: hshroute.h
//
//  Description: Hash Routing functions.  In many cases, domains are
//      identified by domain *and* routing informtion.  This additional
//      information is identified by router GUID and a DWORD idenitfier.
//      This header provides macros to create unique domain-name-like strings
//      from the domain name and additional routing information.
//
//  Author: Mike Swafford (MikeSwa)
//
//  History:
//      9/24/98 - MikeSwa Created
//
//  Copyright (C) 1998 Microsoft Corporation
//
//-----------------------------------------------------------------------------

#ifndef __HSHROUTE_H__
#define __HSHROUTE_H__

#include <dbgtrace.h>

//The following is a list of 1 character "types" that can be used to identify
//the type of routing information hashed.  It is unlikely that this list will
//grow significantly (or even at all).
typedef enum
{
    //Be sure to update FIRST_ROUTE_HASH_TYPE if you change the first type
    ROUTE_HASH_MESSAGE_TYPE = 0,
    ROUTE_HASH_SCHEDULE_ID,
    ROUTE_HASH_NUM_TYPES,
} eRouteHashType;
#define FIRST_ROUTE_HASH_TYPE ROUTE_HASH_MESSAGE_TYPE

_declspec (selectany) CHAR g_rgHashTypeChars[ROUTE_HASH_NUM_TYPES+1] =
{
    'M', //ROUTE_HASH_MESSAGE_TYPE
    'S', //ROUTE_HASH_SCHEDULE_ID
    '\0' //End of list
};

//---[ dwConvertHexChar ]------------------------------------------------------
//
//
//  Description:
//      Converts Hex character into an int from 0 to 15.
//  Parameters:
//      chHex   Hex character to convert
//  Returns:
//      DWORD value between 0 and 15
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline DWORD dwConvertHexChar(CHAR chHex)
{
    DWORD dwValue = 0;
    if (('0' <= chHex) && ('9' >= chHex))
        dwValue = chHex-'0';
    else if (('a' <= chHex) && ('f' >= chHex))
        dwValue = 10 + chHex-'a';
    else if (('A' <= chHex) && ('F' >= chHex))
        dwValue = 10 + chHex-'A';
    else
        _ASSERT(0 && "Invalid hex character");

    _ASSERT(15 >= dwValue);
    return dwValue;
}


//Format is <type>.GUID.DWORD... each byte takes 2 chars to encode in HEX
//  eg - M.00112233445566778899AABBCCDDEEFF.00112233.foo.com

//Offsets are defined to be used in ptr arith or array offsets
#define ROUTE_HASH_CHARS_IN_DWORD   (2*sizeof(DWORD))
#define ROUTE_HASH_CHARS_IN_GUID    (2*sizeof(GUID))
#define ROUTE_HASH_TYPE_OFFSET      0
#define ROUTE_HASH_GUID_OFFSET      2
#define ROUTE_HASH_DWORD_OFFSET     (3 + ROUTE_HASH_CHARS_IN_GUID)
#define ROUTE_HASH_DOMAIN_OFFSET    (4 + ROUTE_HASH_CHARS_IN_GUID + ROUTE_HASH_CHARS_IN_DWORD)
#define ROUTE_HASH_PREFIX_SIZE      sizeof(CHAR)*ROUTE_HASH_DOMAIN_OFFSET

//---[ erhtGetRouteHashType ]---------------------------------------------------
//
//
//  Description:
//      For a given hashed domain, will return the assocaiated eRouteHashType
//  Parameters:
//      IN  szHashedDomain  Hashed domain
//  Returns:
//      eRouteHashType of hashed domain
//      ROUTE_HASH_NUM_TYPES (and asserts) if domain is not a valid route hash
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline eRouteHashType erhtGetRouteHashType(LPSTR szHashedDomain)
{
    eRouteHashType erthRet = FIRST_ROUTE_HASH_TYPE;
    PCHAR pchRouteHashType = g_rgHashTypeChars;
    CHAR  chRouteHashType = szHashedDomain[ROUTE_HASH_TYPE_OFFSET];

    while (('\0' != *pchRouteHashType) &&
           (*pchRouteHashType != chRouteHashType))
    {
        pchRouteHashType++;
        erthRet = (eRouteHashType) (erthRet + 1);

        //we should not get to end of list
        _ASSERT(ROUTE_HASH_NUM_TYPES > erthRet);
    }

    return erthRet;
}

//---[ szGetDomainFromRouteHash ]----------------------------------------------
//
//
//  Description:
//      Returns the string of the unhashed domain from the hashed domain
//      string.  Do *NOT* attempt to free this string.
//  Parameters:
//      IN  szHashedDomain  Hashed domain
//  Returns:
//      Original... unhashed domain
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline LPSTR szGetDomainFromRouteHash(LPSTR szHashedDomain)
{
    _ASSERT('.' == szHashedDomain[ROUTE_HASH_DOMAIN_OFFSET-1]);
    return (szHashedDomain + ROUTE_HASH_DOMAIN_OFFSET);
}

//---[ guidGetGUIDFromRouteHash ]----------------------------------------------
//
//
//  Description:
//      Extracts the guid from the route hash
//  Parameters:
//      IN     szHashedDomain   Hashed domain
//      IN OUT pguid            Extracted GUID
//  Returns:
//      -
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline void GetGUIDFromRouteHash(LPSTR szHashedDomain, IN OUT GUID *pguid)
{
    DWORD *pdwGuid = (DWORD *) pguid;
    LPSTR szGUIDString = szHashedDomain+ROUTE_HASH_GUID_OFFSET;

    _ASSERT(sizeof(GUID)/sizeof(DWORD) == 4); //should be 4 DWORDs in GUID

    //Reverse operation of hash... convert to array of 4 DWORDs
    for (int i = 0; i < 4; i++)
    {
        pdwGuid[i] = 0;
        for (int j = 0;j < ROUTE_HASH_CHARS_IN_DWORD; j++)
        {
            pdwGuid[i] *= 16;
            pdwGuid[i] += dwConvertHexChar(*szGUIDString);
            szGUIDString++;
        }
    }
    _ASSERT('.' == *szGUIDString);
}

//---[ dwGetIDFromRouteHash ]--------------------------------------------------
//
//
//  Description:
//      Extracts DWORD ID from route hash
//  Parameters:
//      IN     szHashedDomain   Hashed domain
//  Returns:
//      DWORD ID encoded in route hash
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline DWORD dwGetIDFromRouteHash(LPSTR szHashedDomain)
{
    _ASSERT(szHashedDomain);
    LPSTR szDWORDString = szHashedDomain+ROUTE_HASH_DWORD_OFFSET;
    DWORD dwID = 0;

    for (int i = 0; i < ROUTE_HASH_CHARS_IN_DWORD; i++)
    {
        dwID *= 16;
        dwID += dwConvertHexChar(*szDWORDString);
        szDWORDString++;
    }

    _ASSERT('.' == *szDWORDString);
    return dwID;
}

//---[ dwGetSizeForRouteHash ]--------------------------------------------------
//
//
//  Description:
//      Returns the required sizeof the hash buffer from the string
//      length of the domain
//  Parameters:
//      IN  cbDomainName    string length of domain name (in bytes)
//  Returns:
//      size (in bytes) of buffer required to create route hash
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline DWORD dwGetSizeForRouteHash(DWORD cbDomainName)
{
    //include prefix size and NULL char
    return (cbDomainName + sizeof(CHAR) + ROUTE_HASH_PREFIX_SIZE);
}

//---[ CreateRouteHash ]-------------------------------------------------------
//
//
//  Description:
//      Creates a route-hashed domain name from a given domain name and
//      routing information.
//  Parameters:
//      IN     cbDomainName     string length of domain name (in bytes)
//      IN     szDomainName     Name of domain to hash
//      IN     pguid            Ptr to GUID of router
//      IN     dwRouterID       ID Provided by router
//      IN OUT szHashedDomain   Buffer that is filled with route-hashed domain
//                              name
//      IN     cbHashedDomain   Size of output buffer
//  Returns:
//      -
//  History:
//      9/24/98 - MikeSwa Created
//
//-----------------------------------------------------------------------------
inline void CreateRouteHash(IN     DWORD cbDomainName,
                            IN     const LPSTR szDomainName,
                            IN     eRouteHashType erhtType,
                            IN     GUID *pguidRouter,
                            IN     DWORD dwRouterID,
                            IN OUT LPSTR szHashedDomain,
                            IN OUT DWORD cbHashedDomain)
{
    _ASSERT(ROUTE_HASH_NUM_TYPES > erhtType);
    _ASSERT(pguidRouter);
    _ASSERT(sizeof(GUID) == 16);
    DWORD *pdwGuids = (DWORD *) pguidRouter;

    _ASSERT(cbHashedDomain >= dwGetSizeForRouteHash(cbDomainName));

    _snprintf(szHashedDomain, cbHashedDomain, "%c.%08X%08X%08X%08X.%08X.%s",
            g_rgHashTypeChars[erhtType], pdwGuids[0], pdwGuids[1], pdwGuids[2],
            pdwGuids[3], dwRouterID, szDomainName);

    // ensure that the string is terminated
    szHashedDomain[cbHashedDomain-1] = 0;

    _ASSERT('.' == szHashedDomain[ROUTE_HASH_GUID_OFFSET-1]);
    _ASSERT('.' == szHashedDomain[ROUTE_HASH_DWORD_OFFSET-1]);
    _ASSERT('.' == szHashedDomain[ROUTE_HASH_DOMAIN_OFFSET-1]);
}


#endif //__HSHROUTE_H__