windows-xp/Source/XPSP1/NT/ds/dns/dnslib/print.c

/*++

Copyright (c) 1997-2001 Microsoft Corporation

Module Name:

    print.c

Abstract:

    Domain Name System (DNS) Library

    Print routines.

Author:

    Jim Gilroy (jamesg)     February 8, 1997

Revision History:

--*/


#include "local.h"
#include "svcguid.h"                    // RnR guids
#include "..\dnsapi\dnsapip.h"          // Private query stuff
#include "..\resolver\idl\resrpc.h"     // Resolver interface structs


//
//  Print globals
//

CRITICAL_SECTION    DnsAtomicPrintCs;
PCRITICAL_SECTION   pDnsAtomicPrintCs = NULL;

//
//  Empty string for simple switching of UTF-8/Unicode print
//      (macros in dnslib.h)
//

DWORD   DnsEmptyString = 0;


//
//  Indenting
//
//  Serve up as many indenting tabs as indent level indicates
//

CHAR    IndentString[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";

#define INDENT_STRING( level )  (IndentString + (sizeof(IndentString) - 1 - (level)))



//
//  Print Locking
//
//  Unless caller initilizes print locking by supplying lock,
//  print locking is disabled.
//

VOID
DnsPrint_InitLocking(
    IN      PCRITICAL_SECTION   pLock
    )
/*++

Routine Description:

    Setup DNS printing to use a lock.

    Can use already initialized lock from caller, or will
    create default lock.

Arguments:

    pLock - ptr to CS to use as lock;  if NULL, create one

Return Value:

    None

--*/
{
    if ( pLock )
    {
        pDnsAtomicPrintCs = pLock;
    }
    else if ( !pDnsAtomicPrintCs )
    {
        InitializeCriticalSection( &DnsAtomicPrintCs );
        pDnsAtomicPrintCs = &DnsAtomicPrintCs;
    }
}



VOID
DnsPrint_Lock(
    VOID
    )
/*++

Routine Description:

    Lock to get atomic DNS print.

--*/
{
    if ( pDnsAtomicPrintCs )
    {
        EnterCriticalSection( pDnsAtomicPrintCs );
    }
}


VOID
DnsPrint_Unlock(
    VOID
    )
/*++

Routine Description:

    Unlock to debug print.

--*/
{
    if ( pDnsAtomicPrintCs )
    {
        LeaveCriticalSection( pDnsAtomicPrintCs );
    }
}



//
//  Print routines for general types and structures
//

VOID
DnsPrint_String(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader       OPTIONAL,
    IN      PSTR            pszString,
    IN      BOOL            fUnicode,
    IN      PSTR            pszTrailer      OPTIONAL
    )
/*++

Routine Description:

    Print DNS string given in either Unicode or UTF-8 format.

--*/
{
    if ( !pszHeader )
    {
        pszHeader = "";
    }
    if ( !pszTrailer )
    {
        pszTrailer = "";
    }

    if ( ! pszString )
    {
        PrintRoutine(
            pContext,
            "%s(NULL DNS string ptr)%s",
            pszHeader,
            pszTrailer );
    }
    else if (fUnicode)
    {
        PrintRoutine(
            pContext,
            "%s%S%s",
            pszHeader,
            (PWSTR ) pszString,
            pszTrailer );
    }
    else
    {
        PrintRoutine(
            pContext,
            "%s%s%s",
            pszHeader,
            (PSTR ) pszString,
            pszTrailer );
    }
}



VOID
DnsPrint_StringCharSet(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader       OPTIONAL,
    IN      PSTR            pszString,
    IN      DNS_CHARSET     CharSet,
    IN      PSTR            pszTrailer      OPTIONAL
    )
/*++

Routine Description:

    Print string of given CHARSET.

--*/
{
    DnsPrint_String(
        PrintRoutine,
        pContext,
        pszHeader,
        pszString,
        (CharSet == DnsCharSetUnicode),
        pszTrailer );
}



VOID
DnsPrint_UnicodeStringBytes(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PWCHAR          pUnicode,
    IN      DWORD           Length
    )
/*++

Routine Description:

    Print chars (WORDs) of unicode string.

--*/
{
    DWORD   i;

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\twide string  %S\r\n"
        "\tlength       %d\r\n"
        "\tbytes        ",
        pszHeader,
        pUnicode,
        Length );

    for ( i=0; i<Length; i++ )
    {
        PrintRoutine(
            pContext,
            "%04hx ",
            pUnicode[i] );
    }
    printf( "\r\n" );
}



VOID
DnsPrint_Utf8StringBytes(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PCHAR           pUtf8,
    IN      DWORD           Length
    )
/*++

Routine Description:

    Print bytes of UTF8 string.

--*/
{
    DWORD   i;

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tUTF8 string  %s\r\n"
        "\tlength       %d\r\n"
        "\tbytes        ",
        pszHeader,
        pUtf8,
        Length );

    for ( i=0; i<Length; i++ )
    {
        PrintRoutine(
            pContext,
            "%02x ",
            (UCHAR) pUtf8[i] );
    }
    printf( "\r\n" );
}



VOID
DnsPrint_StringArray(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PSTR *          StringArray,
    IN      DWORD           Count,          OPTIONAL
    IN      BOOL            fUnicode
    )
/*++

Routine Description:

    Print string array.

--*/
{
    DWORD   i = 0;
    PCHAR   pstr;

    if ( !pszHeader )
    {
        pszHeader = "StringArray:";
    }
    if ( !StringArray )
    {
        PrintRoutine(
            pContext,
            "%s  NULL pointer!\r\n",
            pszHeader );
    }

    DnsPrint_Lock();

    if ( Count )
    {
        PrintRoutine(
            pContext,
            "%s  Count = %d\r\n",
            pszHeader,
            Count );
    }
    else
    {
        PrintRoutine(
            pContext,
            "%s\r\n",
            pszHeader );
    }

    //
    //  print args
    //      - stop at Count (if given)
    //      OR
    //      - on NULL arg (if no count given)
    //

    while ( (!Count || i < Count) )
    {
        pstr = StringArray[i++];
        if ( !pstr && !Count )
        {
            break;
        }
        PrintRoutine(
            pContext,
            (fUnicode) ? "\t%S\r\n" : "\t%s\r\n",
            pstr );
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_Argv(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      CHAR **         Argv,
    IN      DWORD           Argc,            OPTIONAL
    IN      BOOL            fUnicode
    )
/*++

Routine Description:

    Print Argv array.

--*/
{
    //
    //  this is just special case of string print
    //

    DnsPrint_StringArray(
        PrintRoutine,
        pContext,
        pszHeader
            ? pszHeader
            : "Argv:",
        Argv,
        Argc,
        fUnicode );
}



VOID
DnsPrint_DwordArray(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PSTR            pszName,
    IN      DWORD           dwCount,
    IN      PDWORD          adwArray
    )
/*++

Routine Description:

    Print DWORD array.

--*/
{
    DWORD i;

    DnsPrint_Lock();

    if ( pszHeader )
    {
        PrintRoutine(
            pContext,
            pszHeader );
    }

    if ( !pszName )
    {
        pszName = "DWORD";
    }
    PrintRoutine(
        pContext,
        "%s Array Count = %d\r\n",
        pszName,
        dwCount );

    for( i=0; i<dwCount; i++ )
    {
        PrintRoutine(
            pContext,
            "\t%s[%d] => 0x%p (%d)\r\n",
            pszName,
            i,
            adwArray[i],
            adwArray[i] );
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_IpAddressArray(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PSTR            pszName,
    IN      DWORD           dwIpAddrCount,
    IN      PIP_ADDRESS     pIpAddrs
    )
/*++

Routine Description:

    Print IP address array.

--*/
{
    DWORD i;

    DnsPrint_Lock();

    if ( !pszName )
    {
        pszName = "IP Addr";
    }
    PrintRoutine(
        pContext,
        "%s%s Count = %d\r\n",
        pszHeader ? pszHeader : "",
        pszName,
        dwIpAddrCount );

    if ( dwIpAddrCount != 0  &&  pIpAddrs != NULL )
    {
        //  print array with count
        //  use character print so works even if NOT DWORD aligned

        for( i=0; i<dwIpAddrCount; i++ )
        {
            PrintRoutine(
                pContext,
                "\t%s[%d] => %d.%d.%d.%d\r\n",
                pszName,
                i,
                * ( (PUCHAR) &pIpAddrs[i] + 0 ),
                * ( (PUCHAR) &pIpAddrs[i] + 1 ),
                * ( (PUCHAR) &pIpAddrs[i] + 2 ),
                * ( (PUCHAR) &pIpAddrs[i] + 3 ) );
        }
    }

#if 0
    //  this spins if printing zero length IP_ARRAY struct

    else if ( pIpAddrs != NULL )
    {
        //  print NULL terminated array (ex. hostents IPs)

        i = 0;
        while ( pIpAddrs[i] )
        {
            PrintRoutine(
                pContext,
                "\t%s[%d] => %s\r\n",
                pszName,
                i,
                inet_ntoa( *(struct in_addr *) &pIpAddrs[i] ) );
        }
    }
#endif

    DnsPrint_Unlock();
}



VOID
DnsPrint_IpArray(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PSTR            pszName,
    IN      PIP_ARRAY       pIpArray
    )
/*++

Routine Description:

    Print IP address array struct

    Just pass through to more generic print routine.

--*/
{
    //  protect against NULL case

    if ( !pIpArray )
    {
        PrintRoutine(
            pContext,
            "%s\tNULL IP Array.\r\n",
            pszHeader ? pszHeader : "" );
    }

    //  call uncoupled IP array routine

    else
    {
        DnsPrint_IpAddressArray(
            PrintRoutine,
            pContext,
            pszHeader,
            pszName,
            pIpArray->AddrCount,
            pIpArray->AddrArray );
    }
}



VOID
DnsPrint_DnsAddrArray(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PDNS_ADDR_ARRAY     pAddrArray
    )
/*++

Routine Description:

    Print IP address info array.

--*/
{
    DWORD i;

    if ( !pszHeader )
    {
        pszHeader = "Addr Array";
    }
    if ( !pAddrArray )
    {
        PrintRoutine(
            pContext,
            "%s NULL AddrArray ptr.\r\n",
            pszHeader );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "  Ptr   = %p\r\n"
        "  Count = %d\r\n",
        pszHeader ? pszHeader : "IP Address Info",
        pAddrArray,
        pAddrArray->AddrCount );

    //
    //  print array up to count
    //
    //  DCR:  IP6 address info blob
    //

    for( i=0; i<pAddrArray->AddrCount; i++ )
    {
        IP_ADDRESS ip = pAddrArray->AddrArray[i].IpAddr;
        IP_ADDRESS subnetMask = pAddrArray->AddrArray[i].SubnetMask;

        PrintRoutine(
            pContext,
            "\tIP Address[%d] => %d.%d.%d.%d\r\n"
            "\tSubnetMask[%d] => %d.%d.%d.%d\r\n",
            i,
            (ip & 0xff),
            ((ip>>8) & 0xff),
            ((ip>>16) & 0xff),
            ((ip>>24) & 0xff),
            i,
            (subnetMask & 0xff),
            ((subnetMask>>8) & 0xff),
            ((subnetMask>>16) & 0xff),
            ((subnetMask>>24) & 0xff)
            );
    }
    
    DnsPrint_Unlock();
}



VOID
DnsPrint_Ip6Address(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PIP6_ADDRESS        pIp6Address,
    IN      PSTR                pszTrailer
    )
/*++

Routine Description:

    Print IP6 address.

Arguments:

    PrintRoutine -- print routine to call

    pContext -- first argument to print routine

    pszHeader -- header to print
        NOTE:  unlike other print routines this routine
        requires header to contain newline,tab, etc if
        multiline print is desired;  the reason is to allow
        use of this routine for single line print

    pIp6Address -- ptr to IP6 address to print

    pszTrailer -- trailer to print
        NOTE:  again this routine is designed to allow single
        line print;  if newline required after print, send
        newline in trailer

Return Value:

    Ptr to next location in buffer (the terminating NULL).

--*/
{
    CHAR    buffer[ IP6_ADDRESS_STRING_BUFFER_LENGTH ];

    if ( !pszHeader )
    {
        pszHeader = "IP6 Address: ";
    }
    if ( !pszTrailer )
    {
        pszHeader = "\r\n";
    }

    if ( !pIp6Address )
    {
        PrintRoutine(
            pContext,
            "%s NULL IP6 address ptr.%s",
            pszHeader,
            pszTrailer );
    }

    //  convert IP6 address to string

    Dns_Ip6AddressToString_A(
           buffer,
           pIp6Address );

    PrintRoutine(
        pContext,
        "%s%s%s",
        pszHeader,
        buffer,
        pszTrailer );
}



//
//  Print routines for DNS types and structures
//

INT
Dns_WritePacketNameToBuffer(
    OUT     PCHAR           pBuffer,
    OUT     PCHAR *         ppBufferOut,
    IN      PBYTE           pMsgName,
    IN      PDNS_HEADER     pMsgHead,       OPTIONAL
    IN      PBYTE           pMsgEnd         OPTIONAL
    )
/*++

Routine Description:

    Write packet name into buffer.

Arguments:

    pBuffer -       buffer to print to,
                    bounds checking done only on each loop to limit to
                    twice DNS_MAX_NAME_LENGTH, recommend input buffer
                    of at least that length

    ppBufferOut -   ptr to terminating NULL in buffer conversion, this
                    is position at which additional printing to buffer
                    could resume

    pMsgName -      ptr to name in packet to print

    pMsgHead -      ptr to DNS message;  need for offsetting, if not given
                    names are not printed past first offset

    pMsgEnd -       ptr to end of message, specifically byte immediately after
                    message

Return Value:

    Count of bytes in packet name occupied.
    This offset from pMsgName is the next field in the packet.

    Zero return indicates error in message name.

--*/
{
    register PUCHAR pchbuf;
    register PUCHAR pchmsg;
    register UCHAR  cch;
    PCHAR           pbufStop;
    PCHAR           pnextLabel;
    UCHAR           compressionType;
    WORD            offset;
    PCHAR           pbyteAfterFirstOffset = NULL;

    //
    //  no message end specified?
    //  make it max ptr so we can do single test for ptr validity
    //  rather than testing for pMsgEnd existence first
    //

    if ( !pMsgEnd )
    {
        pMsgEnd = (PVOID)(INT_PTR)(-1);
    }

    //
    //  loop until copy as printable name, or hit compression or name error
    //

    pchbuf = pBuffer;
    pbufStop = pchbuf + DNS_MAX_NAME_LENGTH + DNS_MAX_LABEL_LENGTH;
    pchmsg = pMsgName;

    while ( 1 )
    {
        //  bounds checking to survive bad packet
        //
        //  DEVNOTE:  note this is not strictly a bad packet (could be just a
        //      heck of a lot of labels) and we could
        //          a) let packet processing proceed without printing
        //          or
        //          b) require buffer that could contain max legal DNS name
        //      but not worth the effort

        if ( pchbuf >= pbufStop )
        {
            pchbuf += sprintf(
                        pchbuf,
                        "[ERROR name exceeds safe print buffer length]\r\n" );
            pchmsg = pMsgName;
            break;
        }

        cch = (UCHAR) *pchmsg++;
        compressionType = cch & 0xC0;

        DNSDBG( OFF, (
            "byte = (%d) (0x%02x)\r\n"
            "compress flag = (%d) (0x%02x)\r\n",
            cch, cch,
            compressionType, compressionType ));

        //
        //  normal length byte
        //      - write length field
        //      - copy label to print buffer
        //

        if ( compressionType == 0 )
        {
            pchbuf += sprintf( pchbuf, "(%d)", (INT)cch );

            //  terminate at root name

            if ( ! cch )
            {
                break;
            }

            //  check that within packet

            pnextLabel = pchmsg + cch;
            if ( pnextLabel >= pMsgEnd )
            {
                pchbuf += sprintf(
                            pchbuf,
                            "[ERROR length byte: 0x%02X at %p leads outside message]\r\n",
                            cch,
                            pchmsg );

                //  force zero byte return

                pchmsg = pMsgName;
                break;
            }

            //  copy label to output string

            memcpy(
                pchbuf,
                pchmsg,
                cch );

            pchbuf += cch;
            pchmsg = pnextLabel;
            continue;
        }

        //
        //  valid compression
        //

        else if ( compressionType == (UCHAR)0xC0 )
        {
            //  check that compression word not straddling message end

            if ( pchmsg >= pMsgEnd )
            {
                pchbuf += sprintf(
                            pchbuf,
                            "[ERROR compression word at %p is outside message]\r\n",
                            pchmsg );

                //  force zero byte return

                pchmsg = pMsgName;
                break;
            }

            //  calculate offset

            offset = cch;          // high byte
            offset <<= 8;
            offset |= *pchmsg++;   // low byte

            pchbuf += sprintf(
                        pchbuf,
                        "[%04hX]",
                        offset );

            if ( pMsgHead )
            {
                //
                //  on first compression, save ptr to byte immediately after
                //      name, so can calculate next byte
                //
                //  save ptr to next byte in mess, to calculate actual length
                //      name takes up in packet
                //

                if ( ! pbyteAfterFirstOffset )
                {
                    pbyteAfterFirstOffset = pchmsg;
                }

                //
                //  jump to offset for continuation of name
                //      - clear two highest bits to get length
                //

                offset = offset ^ 0xC000;
                DNS_ASSERT( (offset & 0xC000) == 0 );

                pnextLabel = (PCHAR)pMsgHead + offset;
                if ( pnextLabel >= pchmsg - sizeof(WORD) )
                {
                    pchbuf += sprintf(
                                pchbuf,
                                "[ERROR offset at %p to higher byte in packet %p]\r\n",
                                pchmsg - sizeof(WORD),
                                pnextLabel );
                    break;
                }
                pchmsg = pnextLabel;
                continue;
            }

            //  if no ptr to message head, can not continue at offset
            //  NULL terminate previous label

            else
            {
                *pchbuf++ = 0;
                break;
            }
        }

        //
        //  invalid compression
        //      - force zero byte return to indicate error

        else
        {
            pchbuf += sprintf(
                        pchbuf,
                        "[ERROR length byte: 0x%02X]",
                        cch );
            pchmsg = pMsgName;
            break;
        }
    }

    //
    //  return ptr to next position in output buffer
    //

    if ( ppBufferOut )
    {
        *ppBufferOut = pchbuf;
    }

    //
    //  return number of bytes read from message
    //

    if ( pbyteAfterFirstOffset )
    {
        pchmsg = pbyteAfterFirstOffset;
    }
    return (INT)( pchmsg - pMsgName );
}



INT
DnsPrint_PacketName(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,      OPTIONAL
    IN      PBYTE           pMsgName,
    IN      PDNS_HEADER     pMsgHead,       OPTIONAL
    IN      PBYTE           pMsgEnd,        OPTIONAL
    IN      PSTR            pszTrailer      OPTIONAL
    )
/*++

Routine Description:

    Print DNS name given in packet format.

Arguments:

    PrintRoutine -  routine to print with

    pszHeader -     header to print

    pMsgHead -      ptr to DNS message;  need for offsetting, if not given
                    names are not printed past first offset

    pMsgName -      ptr to name in packet to print

    pMsgEnd -       ptr to end of message;  OPTIONAL, but needed to protect
                    against AV accessing bad packet names

    pszTrailer -    trailer to print after name

Return Value:

    Count of bytes in packet name occupied.
    This offset from pMsgName is the next field in the packet.

    Zero return indicates error in message name.

--*/
{
    INT     countNameBytes;

    //  name buffer, allow space for full name, plus parens on length
    //  fields plus several compression flags

    CHAR    PrintName[ 2*DNS_MAX_NAME_LENGTH ];


    if ( ! pMsgName )
    {
        PrintRoutine(
            pContext,
            "%s(NULL packet name ptr)%s\r\n",
            pszHeader ? pszHeader : "",
            pszTrailer ? pszTrailer : ""
            );
        return 0;
    }

    //
    //  build packet name into buffer, then print
    //

    countNameBytes = Dns_WritePacketNameToBuffer(
                        PrintName,
                        NULL,
                        pMsgName,
                        pMsgHead,
                        pMsgEnd
                        );
    PrintRoutine(
        pContext,
        "%s%s%s",
        pszHeader ? pszHeader : "",
        PrintName,
        pszTrailer ? pszTrailer : ""
        );

    return( countNameBytes );
}



VOID
DnsPrint_Message(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PDNS_MSG_BUF    pMsg
    )
/*++

Routine Description:

    Print DNS message buffer.
    Includes context information as well as actual DNS message.

--*/
{
    PDNS_HEADER pmsgHeader;
    PCHAR       pchRecord;
    PBYTE       pmsgEnd;
    INT         i;
    INT         isection;
    INT         cchName;
    WORD        wLength;
    WORD        wOffset;
    WORD        wXid;
    WORD        wQuestionCount;
    WORD        wAnswerCount;
    WORD        wNameServerCount;
    WORD        wAdditionalCount;
    WORD        countSectionRR;
    BOOL        fFlipped = FALSE;

    DnsPrint_Lock();

    if ( pszHeader )
    {
        PrintRoutine(
            pContext,
            "%s\r\n",
            pszHeader );
    }

    //  get message info
    //
    //  note:  length may not be correctly set while building message,
    //      so make pmsgEnd greater of given length and pCurrent ptr
    //      but allow for case where set back to pre-OPT length
    //

    wLength = pMsg->MessageLength;
    pmsgHeader = &pMsg->MessageHead;
    pmsgEnd = ((PBYTE)pmsgHeader) + wLength;

    if ( pmsgEnd < pMsg->pCurrent &&
         pmsgEnd != pMsg->pPreOptEnd )
    {
        pmsgEnd = pMsg->pCurrent;
    }

    //
    //  print header info
    //

    PrintRoutine(
        pContext,
        "%s %s info at %p\r\n"
        "  Socket = %d\r\n"
        "  Remote addr %s, port %ld\r\n"
        "  Buf length = 0x%04x\r\n"
        "  Msg length = 0x%04x\r\n"
        "  Message:\r\n",
        ( pMsg->fTcp
            ? "TCP"
            : "UDP" ),
        ( pmsgHeader->IsResponse
            ? "response"
            : "question" ),
        pMsg,
        pMsg->Socket,
        MSG_REMOTE_IP_STRING( pMsg ),
        MSG_REMOTE_IP_PORT( pMsg ),
        pMsg->BufferLength,
        wLength
        );

    PrintRoutine(
        pContext,
        "    XID       0x%04hx\r\n"
        "    Flags     0x%04hx\r\n"
        "        QR        0x%lx (%s)\r\n"
        "        OPCODE    0x%lx (%s)\r\n"
        "        AA        0x%lx\r\n"
        "        TC        0x%lx\r\n"
        "        RD        0x%lx\r\n"
        "        RA        0x%lx\r\n"
        "        Z         0x%lx\r\n"
        "        RCODE     0x%lx (%s)\r\n"
        "    QCOUNT    0x%hx\r\n"
        "    ACOUNT    0x%hx\r\n"
        "    NSCOUNT   0x%hx\r\n"
        "    ARCOUNT   0x%hx\r\n",

        pmsgHeader->Xid,
        ntohs((*((PWORD)pmsgHeader + 1))),

        pmsgHeader->IsResponse,
        (pmsgHeader->IsResponse ? "response" : "question"),
        pmsgHeader->Opcode,
        Dns_OpcodeString( pmsgHeader->Opcode ),
        pmsgHeader->Authoritative,
        pmsgHeader->Truncation,
        pmsgHeader->RecursionDesired,
        pmsgHeader->RecursionAvailable,
        pmsgHeader->Reserved,
        pmsgHeader->ResponseCode,
        Dns_ResponseCodeString( pmsgHeader->ResponseCode ),

        pmsgHeader->QuestionCount,
        pmsgHeader->AnswerCount,
        pmsgHeader->NameServerCount,
        pmsgHeader->AdditionalCount );

    //
    //  determine if byte flipped and get correct count
    //

    wXid                = pmsgHeader->Xid;
    wQuestionCount      = pmsgHeader->QuestionCount;
    wAnswerCount        = pmsgHeader->AnswerCount;
    wNameServerCount    = pmsgHeader->NameServerCount;
    wAdditionalCount    = pmsgHeader->AdditionalCount;

    if ( wQuestionCount )
    {
        fFlipped = wQuestionCount & 0xff00;
    }
    else if ( wNameServerCount )
    {
        fFlipped = wNameServerCount & 0xff00;
    }
    if ( fFlipped )
    {
        wXid                = ntohs( wXid );
        wQuestionCount      = ntohs( wQuestionCount );
        wAnswerCount        = ntohs( wAnswerCount );
        wNameServerCount    = ntohs( wNameServerCount );
        wAdditionalCount    = ntohs( wAdditionalCount );
    }

    //
    //  catch record flipping problems -- all are flipped or none at all
    //      and no record count should be > 256 EXCEPT answer count
    //      during FAST zone transfer
    //

    DNS_ASSERT( ! (wQuestionCount & 0xff00) );
    DNS_ASSERT( ! (wNameServerCount & 0xff00) );
    DNS_ASSERT( ! (wAdditionalCount & 0xff00) );

#if 0
    //
    //  stop here if WINS response -- don't have parsing ready
    //

    if ( pmsgHeader->IsResponse && IS_WINS_XID(wXid) )
    {
        PrintRoutine(
            pContext,
            "  WINS Response packet.\r\n\r\n" );
        goto Unlock;
    }
#endif

    //
    //  print questions and resource records
    //

    pchRecord = (PCHAR)(pmsgHeader + 1);

    for ( isection=0; isection<4; isection++)
    {
        PrintRoutine(
            pContext,
            "  %s Section:\r\n",
            Dns_SectionNameString( isection, pmsgHeader->Opcode ) );

        if ( isection==0 )
        {
            countSectionRR = wQuestionCount;
        }
        else if ( isection==1 )
        {
            countSectionRR = wAnswerCount;
        }
        else if ( isection==2 )
        {
            countSectionRR = wNameServerCount;
        }
        else if ( isection==3 )
        {
            countSectionRR = wAdditionalCount;
        }

        for ( i=0; i < countSectionRR; i++ )
        {
            //
            //  verify not overrunning length
            //      - check against pCurrent as well as message length
            //        so can print packets while being built
            //

            wOffset = (WORD)(pchRecord - (PCHAR)pmsgHeader);
            if ( wOffset >= wLength
                    &&
                pchRecord >= pMsg->pCurrent )
            {
                PrintRoutine(
                    pContext,
                    "ERROR:  BOGUS PACKET:\r\n"
                    "\tFollowing RR (offset %d) past packet length (%d).\r\n",
                    wOffset,
                    wLength
                    );
                goto Unlock;
            }

            //
            //  print RR name
            //

            PrintRoutine(
                pContext,
                "    Name Offset = 0x%04x\r\n",
                wOffset
                );

            cchName = DnsPrint_PacketName(
                            PrintRoutine,
                            pContext,
                            "    Name      \"",
                            pchRecord,
                            pmsgHeader,
                            pmsgEnd,
                            "\"\r\n" );
            if ( ! cchName )
            {
                PrintRoutine(
                    pContext,
                    "ERROR:  Invalid name length, stop packet print\r\n" );
                DNS_ASSERT( FALSE );
                break;
            }
            pchRecord += cchName;

            //  print question or resource record

            if ( isection == 0 )
            {
                PrintRoutine(
                    pContext,
                    "      QTYPE   %d\r\n"
                    "      QCLASS  %d\r\n",
                    FlipUnalignedWord( pchRecord ),
                    FlipUnalignedWord( pchRecord + sizeof(WORD) )
                    );
                pchRecord += sizeof( DNS_WIRE_QUESTION );
            }
            else
            {
                pchRecord += DnsPrint_PacketRecord(
                                PrintRoutine,
                                pContext,
                                NULL,
                                (PDNS_WIRE_RECORD) pchRecord,
                                pmsgHeader,
                                pmsgEnd
                                );
            }
        }
    }

    //  check that at proper end of packet

    wOffset = (WORD)(pchRecord - (PCHAR)pmsgHeader);
    if ( pchRecord < pMsg->pCurrent || wOffset < wLength )
    {
        PrintRoutine(
            pContext,
            "WARNING:  message continues beyond these records\r\n"
            "\tpch = %p, pCurrent = %p, %d bytes\r\n"
            "\toffset = %d, msg length = %d, %d bytes\r\n",
            pchRecord,
            pMsg->pCurrent,
            pMsg->pCurrent - pchRecord,
            wOffset,
            wLength,
            wLength - wOffset );
    }
    PrintRoutine(
        pContext,
        "  Message length = %04x\n\r\n",
        wOffset );

Unlock:
    DnsPrint_Unlock();


}   // DnsPrint_Message



INT
DnsPrint_PacketRecord(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PDNS_WIRE_RECORD    pMsgRR,
    IN      PDNS_HEADER         pMsgHead,       OPTIONAL
    IN      PBYTE               pMsgEnd         OPTIONAL
    )
/*++

Routine Description:

    Print RR in packet format.

Arguments:

    pszHeader - Header message/name for RR.

    pMsgRR    - resource record to print

    pMsgHead  - ptr to DNS message;  need for offsetting, if not given
                names are not printed past first offset

    pMsgEnd   - ptr to end of message, specifically byte immediately after
                message

Return Value:

    Number of bytes in record.

--*/
{
    PCHAR   pdata = (PCHAR)(pMsgRR + 1);
    PCHAR   pdataStop;
    WORD    dlen = FlipUnalignedWord( &pMsgRR->DataLength );
    WORD    type;
    PCHAR   pRRString;

    DnsPrint_Lock();

    //
    //  print RR fixed fields
    //

    type = FlipUnalignedWord( &pMsgRR->RecordType );
    pRRString = Dns_RecordStringForType( type );

    if ( pszHeader )
    {
        PrintRoutine(
            pContext,
            "%s\r\n",
            pszHeader );
    }
    PrintRoutine(
        pContext,
        "      TYPE   %s  (%u)\r\n"
        "      CLASS  %u\r\n"
        "      TTL    %lu\r\n"
        "      DLEN   %u\r\n"
        "      DATA   ",
        pRRString,
        type,
        FlipUnalignedWord( &pMsgRR->RecordClass ),
        FlipUnalignedDword( &pMsgRR->TimeToLive ),
        dlen );

    //
    //  update records may not have data
    //

    if ( dlen == 0 )
    {
        PrintRoutine(
            pContext,
            "(none)\r\n" );
        goto Done;
    }

    //  stop byte after RR data

    pdataStop = pdata + dlen;
    if ( pMsgEnd < pdataStop )
    {
        PrintRoutine(
            pContext,
            "ERROR:  record at %p extends past end of packet!\n"
            "\tpmsg             = %p\n"
            "\tpmsgEnd          = %p\n"
            "\trecord end       = %p\n",
            pMsgRR,
            pMsgHead,
            pMsgEnd,
            pdataStop );
        goto Done;
    }

    //
    //  print RR data
    //

    switch ( type )
    {

    case DNS_TYPE_A:

        PrintRoutine(
            pContext,
            "%d.%d.%d.%d\r\n",
            * (PUCHAR)( pdata + 0 ),
            * (PUCHAR)( pdata + 1 ),
            * (PUCHAR)( pdata + 2 ),
            * (PUCHAR)( pdata + 3 )
            );
        break;

    case DNS_TYPE_AAAA:
    {
        IP6_ADDRESS ip6;

        RtlCopyMemory(
            &ip6,
            pdata,
            sizeof(ip6) );

        PrintRoutine(
            pContext,
            "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n",
            ip6.IP6Word[0],
            ip6.IP6Word[1],
            ip6.IP6Word[2],
            ip6.IP6Word[3],
            ip6.IP6Word[4],
            ip6.IP6Word[5],
            ip6.IP6Word[6],
            ip6.IP6Word[7]
            );
        break;
    }

    case DNS_TYPE_PTR:
    case DNS_TYPE_NS:
    case DNS_TYPE_CNAME:
    case DNS_TYPE_MD:
    case DNS_TYPE_MB:
    case DNS_TYPE_MF:
    case DNS_TYPE_MG:
    case DNS_TYPE_MR:

        //
        //  these RRs contain single domain name
        //

        DnsPrint_PacketName(
            PrintRoutine,
            pContext,
            NULL,
            pdata,
            pMsgHead,
            pMsgEnd,
            "\r\n" );
        break;

    case DNS_TYPE_MX:
    case DNS_TYPE_RT:
    case DNS_TYPE_AFSDB:

        //
        //  these RR contain
        //      - one preference value
        //      - one domain name
        //

        PrintRoutine(
            pContext,
            "%d ",
            FlipUnalignedWord( pdata )
            );
        DnsPrint_PacketName(
            PrintRoutine,
            pContext,
            NULL,
            pdata + sizeof(WORD),
            pMsgHead,
            pMsgEnd,
            "\r\n" );
        break;

    case DNS_TYPE_SOA:

        pdata += DnsPrint_PacketName(
                        PrintRoutine,
                        pContext,
                        "\r\n\t\tPrimaryServer: ",
                        pdata,
                        pMsgHead,
                        pMsgEnd,
                        NULL );
        pdata += DnsPrint_PacketName(
                        PrintRoutine,
                        pContext,
                        "\r\n\t\tAdministrator: ",
                        pdata,
                        pMsgHead,
                        pMsgEnd,
                        "\r\n" );
        PrintRoutine(
            pContext,
            "\t\tSerialNo     = %d\r\n"
            "\t\tRefresh      = %d\r\n"
            "\t\tRetry        = %d\r\n"
            "\t\tExpire       = %d\r\n"
            "\t\tMinimumTTL   = %d\r\n",
            FlipUnalignedDword( pdata ),
            FlipUnalignedDword( (PDWORD)pdata+1 ),
            FlipUnalignedDword( (PDWORD)pdata+2 ),
            FlipUnalignedDword( (PDWORD)pdata+3 ),
            FlipUnalignedDword( (PDWORD)pdata+4 )
            );
        break;

    case DNS_TYPE_MINFO:
    case DNS_TYPE_RP:

        //
        //  these RRs contain two domain names
        //

        pdata += DnsPrint_PacketName(
                        PrintRoutine,
                        pContext,
                        NULL,
                        pdata,
                        pMsgHead,
                        pMsgEnd,
                        NULL );
        DnsPrint_PacketName(
            PrintRoutine,
            pContext,
            "  ",
            pdata,
            pMsgHead,
            pMsgEnd,
            "\r\n" );
        break;

    case DNS_TYPE_TEXT:
    case DNS_TYPE_HINFO:
    case DNS_TYPE_ISDN:
    case DNS_TYPE_X25:
    {
        //
        //  all these are simply text string(s)
        //

        PCHAR   pch = pdata;
        PCHAR   pchStop = pch + dlen;
        UCHAR   cch;

        while ( pch < pchStop )
        {
            cch = (UCHAR) *pch++;

            PrintRoutine(
                pContext,
                "\t%.*s\r\n",
                 cch,
                 pch );

            pch += cch;
        }
        if ( pch != pchStop )
        {
            PrintRoutine(
                pContext,
                "ERROR:  Bad RR.  "
                "Text strings do not add to RR length.\r\n" );
        }
        break;
    }

    case DNS_TYPE_WKS:
    {
        INT i;

        PrintRoutine(
            pContext,
            "WKS: Address %d.%d.%d.%d\r\n"
            "\t\tProtocol %d\r\n"
            "\t\tBitmask\r\n",
            * (PUCHAR)( pdata + 0 ),
            * (PUCHAR)( pdata + 1 ),
            * (PUCHAR)( pdata + 2 ),
            * (PUCHAR)( pdata + 3 ),
            * (PUCHAR)( pdata + 4 ) );

        pdata += SIZEOF_WKS_FIXED_DATA;

        for ( i=0;  i < (INT)(dlen-SIZEOF_WKS_FIXED_DATA);  i++ )
        {
            PrintRoutine(
                pContext,
                "\t\t\tbyte[%d] = %x\r\n",
                i,
                (UCHAR) pdata[i] );
        }
        break;
    }

    case DNS_TYPE_NULL:

        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            NULL,
            "\t\t",
            pdata,
            dlen );
        break;

    case DNS_TYPE_SRV:

        //  SRV <priority> <weight> <port> <target host>

        PrintRoutine(
            pContext,
            "\t\tPriority     = %d\r\n"
            "\t\tWeight       = %d\r\n"
            "\t\tPort         = %d\r\n",
            FlipUnalignedWord( pdata ),
            FlipUnalignedWord( (PWORD)pdata+1 ),
            FlipUnalignedWord( (PWORD)pdata+2 )
            );
        DnsPrint_PacketName(
            PrintRoutine,
            pContext,
            "\t\tTarget host ",
            pdata + 3*sizeof(WORD),
            pMsgHead,
            pMsgEnd,
            "\r\n" );
        break;

    case DNS_TYPE_OPT:

        //
        //  OPT
        //      - RR class is buffer size
        //      - RR TTL contains
        //          <extended RCODE> low byte
        //          <version> second byte
        //          <flags-zero> high word
        //

        {
            BYTE    version;
            BYTE    extendedRcode;
            DWORD   fullRcode = 0;
            WORD    flags;

            extendedRcode = *( (PBYTE) &pMsgRR->TimeToLive );
            version = *( (PBYTE) &pMsgRR->TimeToLive + 1 );
            flags = *( (PWORD) &pMsgRR->TimeToLive + 1 );

            if ( pMsgHead->ResponseCode )
            {
                fullRcode = ((DWORD)extendedRcode << 4) +
                            (DWORD)pMsgHead->ResponseCode;
            }

            PrintRoutine(
                pContext,
                "\t\tBuffer Size  = %d\r\n"
                "\t\tRcode Ext    = %d (%x)\r\n"
                "\t\tRcode Full   = %d\r\n"
                "\t\tVersion      = %d\r\n"
                "\t\tFlags        = %x\r\n",
                FlipUnalignedWord( &pMsgRR->RecordClass ),
                extendedRcode, extendedRcode,
                fullRcode,
                version,
                flags );
        }
        break;

    case DNS_TYPE_TKEY:
    {
        DWORD   beginTime;
        DWORD   expireTime;
        WORD    keyLength;
        WORD    mode;
        WORD    extRcode;
        WORD    otherLength;

        otherLength = (WORD)DnsPrint_PacketName(
                                PrintRoutine,
                                pContext,
                                "\r\n\t\tAlgorithm:     ",
                                pdata,
                                pMsgHead,
                                pMsgEnd,
                                NULL );
        if ( !otherLength )
        {
            PrintRoutine(
                pContext,
                "Invalid algorithm name in TKEY RR!\r\n" );
        }
        pdata += otherLength;

        beginTime = InlineFlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);
        expireTime = InlineFlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);

        mode = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);
        extRcode = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);
        keyLength = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tCreate time    = %d\r\n"
            "\t\tExpire time    = %d\r\n"
            "\t\tMode           = %d\r\n"
            "\t\tExtended RCODE = %d\r\n"
            "\t\tKey Length     = %d\r\n",
            beginTime,
            expireTime,
            mode,
            extRcode,
            keyLength );

        if ( pdata + keyLength > pdataStop )
        {
            PrintRoutine(
                pContext,
                "Invalid key length:  exceeds record data!\r\n" );
            break;
        }
        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "\t\tKey:",
            "\t\t  ",       // line header
            pdata,
            keyLength );

        pdata += keyLength;
        if ( pdata + sizeof(WORD) > pdataStop )
        {
            break;
        }
        otherLength = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tOther Length   = %d\r\n",
            otherLength );

        if ( pdata + otherLength > pdataStop )
        {
            PrintRoutine(
                pContext,
                "Invalid other data length:  exceeds record data!\r\n" );
            break;
        }
        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "\t\tOther Data:",
            "\t\t  ",           // line header
            pdata,
            otherLength );
        break;
    }

    case DNS_TYPE_TSIG:
    {
        ULONGLONG   signTime;
        WORD        fudgeTime;
        WORD        sigLength;
        WORD        extRcode;
        WORD        wOriginalId;
        WORD        otherLength;

        otherLength = (WORD) DnsPrint_PacketName(
                                PrintRoutine,
                                pContext,
                                "\r\n\t\tAlgorithm:     ",
                                pdata,
                                pMsgHead,
                                pMsgEnd,
                                NULL );
        if ( !otherLength )
        {
            PrintRoutine(
                pContext,
                "Invalid algorithm name in TSIG RR!\r\n" );
        }
        pdata += otherLength;

        signTime = InlineFlipUnaligned48Bits( pdata );
        pdata += sizeof(DWORD) + sizeof(WORD);

        fudgeTime = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        sigLength = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tSigned time    = %I64u\r\n"
            "\t\tFudge time     = %u\r\n"
            "\t\tSig Length     = %u\r\n",
            signTime,
            fudgeTime,
            sigLength );

        if ( pdata + sigLength > pdataStop )
        {
            PrintRoutine(
                pContext,
                "Invalid signature length:  exceeds record data!\r\n" );
            break;
        }
        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "\t\tSignature:",
            "\t\t  ",           // line header
            pdata,
            sigLength );

        pdata += sigLength;
        if ( pdata + sizeof(DWORD) > pdataStop )
        {
            break;
        }
        wOriginalId = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        extRcode = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        otherLength = InlineFlipUnalignedWord( pdata );
        pdata += sizeof(WORD);

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tOriginal XID   = %x\r\n"
            "\t\tExtended RCODE = %u\r\n"
            "\t\tOther Length   = %u\r\n",
            wOriginalId,
            extRcode,
            otherLength );

        if ( pdata + otherLength > pdataStop )
        {
            PrintRoutine(
                pContext,
                "Invalid other data length:  exceeds record data!\r\n" );
            break;
        }
        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "\t\tOther Data:",
            "\t\t  ",           // line header
            pdata,
            otherLength );
        break;
    }

    case DNS_TYPE_WINS:
    {
        DWORD   i;
        DWORD   winsFlags;
        DWORD   lookupTimeout;
        DWORD   cacheTimeout;
        DWORD   winsCount;
        CHAR    flagString[ WINS_FLAG_MAX_LENGTH ];

        //
        //  WINS
        //      - scope/domain mapping flag
        //      - lookup timeout
        //      - cache timeout
        //      - WINS server count
        //      - WINS server list
        //

        winsFlags = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);
        lookupTimeout = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);
        cacheTimeout = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);
        winsCount = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);

        Dns_WinsRecordFlagString(
            winsFlags,
            flagString );

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tWINS flags     = %s (%08x)\r\n"
            "\t\tLookup timeout = %d\r\n"
            "\t\tCaching TTL    = %d\r\n",
            flagString,
            winsFlags,
            lookupTimeout,
            cacheTimeout );

        if ( pdata + (winsCount * SIZEOF_IP_ADDRESS) > pdataStop )
        {
            PrintRoutine(
                pContext,
                "ERROR:  WINS server count leads beyond record data length!\n"
                "\tpmsg             = %p\n"
                "\tpmsgEnd          = %p\n"
                "\tpRR              = %p\n"
                "\trecord data end  = %p\n"
                "\twins count       = %d\n"
                "\tend of wins IPs  = %p\n",
                pMsgHead,
                pMsgEnd,
                pMsgRR,
                pdataStop,
                winsCount,
                pdata + (winsCount * SIZEOF_IP_ADDRESS)
                );
            goto Done;
        }

        DnsPrint_IpAddressArray(
            PrintRoutine,
            pContext,
            NULL,
            "\tWINS",
            winsCount,
            (PIP_ADDRESS) pdata );
        break;
    }

    case DNS_TYPE_WINSR:
    {
        DWORD   winsFlags;
        DWORD   lookupTimeout;
        DWORD   cacheTimeout;
        CHAR    flagString[ WINS_FLAG_MAX_LENGTH ];

        //
        //  NBSTAT
        //      - scope/domain mapping flag
        //      - lookup timeout
        //      - cache timeout
        //      - result domain -- optional
        //

        winsFlags = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);
        lookupTimeout = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);
        cacheTimeout = FlipUnalignedDword( pdata );
        pdata += sizeof(DWORD);

        Dns_WinsRecordFlagString(
            winsFlags,
            flagString );

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tWINS-R flags   = %s (%08x)\r\n"
            "\t\tLookup timeout = %d\r\n"
            "\t\tCaching TTL    = %d\r\n",
            flagString,
            winsFlags,
            lookupTimeout,
            cacheTimeout );

        DnsPrint_PacketName(
            PrintRoutine,
            pContext,
            "\t\tResult domain  = ",
            pdata,
            pMsgHead,
            pMsgEnd,
            "\r\n" );
        break;
    }
    
    case DNS_TYPE_KEY:
    {
        WORD    flags;
        BYTE    protocol;
        BYTE    algorithm;
        INT     keyLength;
        CHAR    szKeyFlags[ 100 ];

        keyLength = dlen - SIZEOF_KEY_FIXED_DATA;

        flags = FlipUnalignedWord( pdata );
        pdata += sizeof( WORD );
        protocol = * ( PBYTE ) pdata;
        ++pdata;
        algorithm = * ( PBYTE ) pdata;
        ++pdata;

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tKEY flags      = 0x%04x %s\r\n"
            "\t\tKEY protocol   = %s (%d)\r\n"
            "\t\tKEY algorithm  = %s (%d)\r\n",
            (INT) flags,
            Dns_KeyFlagString( szKeyFlags, flags ),
            Dns_GetKeyProtocolString( protocol ),
            (INT) protocol,
            Dns_GetDnssecAlgorithmString( algorithm ),
            (INT) algorithm );

        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "\t\tPublic key:",
            "\t\t  ",           // line header
            pdata,
            keyLength );
        break;
    }

    case DNS_TYPE_SIG:
    {
        WORD    typeCovered;
        BYTE    algorithm;
        BYTE    labelCount;
        DWORD   originalTTL;
        DWORD   sigInception;
        DWORD   sigExpiration;
        WORD    keyTag;
        CHAR    szSigInception[ 100 ];
        CHAR    szSigExpiration[ 100 ];
        INT     sigLength;

        typeCovered = FlipUnalignedWord( pdata );
        pdata += sizeof( WORD );
        algorithm = * ( PBYTE ) pdata;
        ++pdata;
        labelCount = * ( PBYTE ) pdata;
        ++pdata;
        originalTTL = FlipUnalignedDword( pdata );
        pdata += sizeof( DWORD );
        sigExpiration = FlipUnalignedDword( pdata );
        pdata += sizeof( DWORD );
        sigInception = FlipUnalignedDword( pdata );
        pdata += sizeof( DWORD );
        keyTag = FlipUnalignedWord( pdata );
        pdata += sizeof( WORD );

        PrintRoutine(
            pContext,
            "\r\n"
            "\t\tSIG type covered  = %s\r\n"
            "\t\tSIG algorithm     = %s (%d)\r\n"
            "\t\tSIG label count   = %d\r\n"
            "\t\tSIG original TTL  = %d\r\n"
            "\t\tSIG expiration    = %s\r\n"
            "\t\tSIG inception     = %s\r\n"
            "\t\tSIG key tag       = %d\r\n",
            Dns_RecordStringForType( typeCovered ),
            Dns_GetDnssecAlgorithmString( ( BYTE ) algorithm ),
            ( INT ) algorithm,
            ( INT ) labelCount,
            ( INT ) originalTTL,
            Dns_SigTimeString( sigExpiration, szSigExpiration ),
            Dns_SigTimeString( sigInception, szSigInception ),
            ( INT ) keyTag );

        pdata += DnsPrint_PacketName(
                        PrintRoutine,
                        pContext,
                        "\t\tSIG signer's name = ",
                        pdata,
                        pMsgHead,
                        pMsgEnd,
                        "\r\n" );

        sigLength = ( INT ) ( pdataStop - pdata );

        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "\t\tSignature:",
            "\t\t  ",           // line header
            pdata,
            sigLength );
        break;
    }

    case DNS_TYPE_NXT:
        {
        INT         bitmapLength;
        INT         byteIdx;
        INT         bitIdx;

        pdata += DnsPrint_PacketName(
                        PrintRoutine,
                        pContext,
                        "\r\n\t\tNXT next name      = ",
                        pdata,
                        pMsgHead,
                        pMsgEnd,
                        "\r\n" );

        bitmapLength = ( INT ) ( pdataStop - pdata );

        PrintRoutine( pContext, "\t\tNXT types covered  = " );

        for ( byteIdx = 0; byteIdx < bitmapLength; ++byteIdx )
        {
            for ( bitIdx = ( byteIdx ? 0 : 1 ); bitIdx < 8; ++bitIdx )
            {
                PCHAR   pszType;

                if ( !( pdata[ byteIdx ] & ( 1 << bitIdx ) ) )
                {
                    continue;   // Bit value is zero - do not write string.
                }
                pszType = Dns_RecordStringForType( byteIdx * 8 + bitIdx );
                if ( !pszType )
                {
                    ASSERT( FALSE );
                    continue;   // This type has no string - do not write.
                }
                PrintRoutine( pContext, "%s ", pszType );
            } 
        }

        PrintRoutine( pContext, "\r\n" );
        break;
        }

    default:

        PrintRoutine(
            pContext,
            "Unknown resource record type %d at %p.\r\n",
            type,
            pMsgRR );

        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            NULL,
            "\t\t",
            pdata,
            dlen );
        break;
    }

Done:

    DnsPrint_Unlock();

    return( sizeof(DNS_WIRE_RECORD) + dlen );
}



//
//  Print related utilities
//


INT
Dns_WriteFormattedSystemTimeToBuffer(
    OUT     PCHAR           pBuffer,
    IN      PSYSTEMTIME     pSystemTime
    )
/*++

Routine Description:

    Write SYSTEMTIME structure to buffer.

Arguments:

    pBuffer -- buffer to write into, assumed to have at least 50
                bytes available

    pSystemTime -- system time to convert;  assumed to be local, no
                    time zone conversion is done

Return Value:

    Bytes in formatted string.

--*/
{
    PCHAR   pend = pBuffer + 60;
    PCHAR   pstart = pBuffer;
    INT     count;

    pBuffer += GetDateFormat(
                    LOCALE_SYSTEM_DEFAULT,
                    LOCALE_NOUSEROVERRIDE,
                    (PSYSTEMTIME) pSystemTime,
                    NULL,
                    pBuffer,
                    (int)(pend - pBuffer) );

    //  Replace NULL from GetDateFormat with a space.

    *( pBuffer - 1 ) = ' ';

    pBuffer += GetTimeFormat(
                    LOCALE_SYSTEM_DEFAULT,
                    LOCALE_NOUSEROVERRIDE,
                    (PSYSTEMTIME) pSystemTime,
                    NULL,
                    pBuffer,
                    (int)(pend - pBuffer) );

    if ( pBuffer <= pstart+1 )
    {
        return( 0 );
    }
    return (INT)( pBuffer - pstart );
}



//
//  Response code print
//

#define DNS_RCODE_UNKNOWN   (DNS_RCODE_BADTIME + 1)

PCHAR   ResponseCodeStringTable[] =
{
    "NOERROR",
    "FORMERR",
    "SERVFAIL",
    "NXDOMAIN",
    "NOTIMP",
    "REFUSED",
    "YXDOMAIN",
    "YXRRSET",
    "NXRRSET",
    "NOTAUTH",
    "NOTZONE",
    "11 - unknown\r\n",
    "12 - unknown\r\n",
    "13 - unknown\r\n",
    "14 - unknown\r\n",
    "15 - unknown\r\n",

    //  DNS RCODEs stop at 15 -- these extended errors are available for security

    "BADSIG",
    "BADKEY",
    "BADTIME",
    "UNKNOWN"
};


PCHAR
Dns_ResponseCodeString(
    IN      INT     ResponseCode
    )
/*++

Routine Description:

    Get string corresponding to a response code.

Arguments:

    ResponseCode - response code

Return Value:

    Ptr to string for code.

--*/
{
    if ( ResponseCode > DNS_RCODE_UNKNOWN )
    {
        ResponseCode = DNS_RCODE_UNKNOWN;
    }
    return( ResponseCodeStringTable[ ResponseCode ] );
}



//
//  More detailed RCODE strings
//

PCHAR   ResponseCodeExplanationStringTable[] =
{
    "NOERROR:  no error",
    "FORMERR:  format error",
    "SERVFAIL:  server failure",
    "NXDOMAIN:  name error",
    "NOTIMP:  not implemented",
    "REFUSED",
    "YXDOMAIN:  name exists that should not",
    "YXRRSET:  RR set exists that should not",
    "NXRRSET:  required RR set does not exist",
    "NOTAUTH:  not authoritative",
    "NOTZONE:  name not in zone",
    "11 - unknown",
    "12 - unknown",
    "13 - unknown",
    "14 - unknown",
    "15 - unknown",

    //  DNS RCODEs stop at 15 -- these extended errors are available for security

    "BADSIG:  bad signature",
    "BADKEY:  bad signature",
    "BADTIME:  invalid or expired time on signature or key",
    "UNKNOWN"
};


PCHAR
Dns_ResponseCodeExplanationString(
    IN      INT     ResponseCode
    )
/*++

Routine Description:

    Get string corresponding to a response code.
    Basically for use by packet debug routine above.

Arguments:

    ResponseCode - response code

Return Value:

    Ptr to string for code.

--*/
{
    if ( ResponseCode > DNS_RCODE_UNKNOWN )
    {
        ResponseCode = DNS_RCODE_UNKNOWN;
    }
    return( ResponseCodeExplanationStringTable[ ResponseCode ] );
}



PCHAR
Dns_KeyFlagString(
    IN OUT      PCHAR       pszBuff,
    IN          WORD        Flags
    )
/*++

Routine Description:

    Formats a human-readable string based on the flags value
    (DNSSEC KEY RR flags). See RFC2535 section 3.2.1.

Arguments:

    pszBuff - buffer to dump string into should be min 100 chars

    flags - flag value to generate string for

Return Value:

    pszBuff

--*/
{
    BOOL    fZoneKey = FALSE;

    *pszBuff = '\0';

    // "type" bits

    if ( ( Flags & 0xC000 ) == 0xC000 )
    {
        strcat( pszBuff, "NOKEY " );
    }
    else if ( ( Flags & 0xC000 ) == 0x8000 )
    {
        strcat( pszBuff, "NOAUTH " );
    }
    else if ( ( Flags & 0xC000 ) == 0x4000 )
    {
        strcat( pszBuff, "NOCONF " );
    }
    else
    {
        strcat( pszBuff, "NOAUTH NOCONF " );
    }

    //  extended bit

    if ( Flags & 0x1000 )
    {
        strcat( pszBuff, "EXTEND " );
    }

    //  name type bits

    if ( ( Flags & 0x0300 ) == 0x0300 )
    {
        strcat( pszBuff, "RESNT " );    // reserved name type
    }
    else if ( ( Flags & 0x0200 ) == 0x0100 )
    {
        strcat( pszBuff, "ENTITY " );
    }
    else if ( ( Flags & 0x0100 ) == 0x4000 )
    {
        strcat( pszBuff, "ZONE " );
        fZoneKey = TRUE;
    }
    else
    {
        strcat( pszBuff, "USER " );
    }

    //  signatory bits
    
    if ( fZoneKey )
    {
        strcat( pszBuff, ( Flags & 0x0008 ) ? "MODEA " : "MODEB " );
        if ( Flags & 0x0004 )
        {
            strcat( pszBuff, "STRONG " );
        }
        if ( Flags & 0x0002 )
        {
            strcat( pszBuff, "UNIQ " );
        }
    }
    else
    {
        if ( Flags & 0x0008 )
        {
            strcat( pszBuff, "ZCTRL " );
        }
        if ( Flags & 0x0004 )
        {
            strcat( pszBuff, "STRONG " );
        }
        if ( Flags & 0x0002 )
        {
            strcat( pszBuff, "UNIQ " );
        }
    }

    return pszBuff;
}



//
//  Opcode print
//

PCHAR   OpcodeStringTable[] =
{
    "QUERY",
    "IQUERY",
    "SRV_STATUS",
    "UNKNOWN",
    "NOTIFY",
    "UPDATE",
    "UNKNOWN?"
};

CHAR    OpcodeCharacterTable[] =
{
    'Q',
    'I',
    'S',
    'K',
    'N',
    'U',
    '?'
};

#define DNS_OPCODE_UNSPEC (DNS_OPCODE_UPDATE + 1)


PCHAR
Dns_OpcodeString(
    IN      INT     Opcode
    )
/*++

Routine Description:

    Get string corresponding to a response code.

Arguments:

    Opcode - response code

Return Value:

    Ptr to string for code.

--*/
{
    if ( Opcode > DNS_OPCODE_UNSPEC )
    {
        Opcode = DNS_OPCODE_UNSPEC;
    }
    return( OpcodeStringTable[ Opcode ] );
}



CHAR
Dns_OpcodeCharacter(
    IN      INT     Opcode
    )
/*++

Routine Description:

    Get string corresponding to an opcode.

Arguments:

    Opcode - response code

Return Value:

    Ptr to string for code.

--*/
{
    if ( Opcode > DNS_OPCODE_UNSPEC )
    {
        Opcode = DNS_OPCODE_UNSPEC;
    }
    return( OpcodeCharacterTable[ Opcode ] );
}



//
//  Section names
//
//  With update get a new set of section names.
//  Provide single interface to putting a name on them.
//

PSTR  SectionNameArray[5] =
{
    "Question",
    "Answer",
    "Authority",
    "Additional",
    "ERROR:  Invalid Section"
};

PSTR  UpdateSectionNameArray[5] =
{
    "Zone",
    "Prerequisite",
    "Update",
    "Additional",
    "ERROR:  Invalid Section"
};

PCHAR
Dns_SectionNameString(
    IN      INT     iSection,
    IN      INT     iOpcode
    )
/*++

Routine Description:

    Get string corresponding to name of RR section id.
    For use by packet debug routine above.

Arguments:

    iSection - section id (0-3 for Question-Additional)

    iOpcode - opcode

Return Value:

    Ptr to string for section name.

--*/
{
    if ( iSection >= 4 )
    {
        iSection = 4;
    }

    if ( iOpcode == DNS_OPCODE_UPDATE )
    {
        return( UpdateSectionNameArray[iSection] );
    }
    else
    {
        return( SectionNameArray[iSection] );
    }
}


VOID
DnsPrint_MessageNoContext(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PDNS_HEADER     pMsgHead,
    IN      WORD            wLength     OPTIONAL
    )
/*++

Routine Description:

    Print DNS message buffer.
    Includes context information as well as actual DNS message.

--*/
{
    PCHAR       pchRecord;
    PBYTE       pmsgEnd;
    INT         i;
    INT         isection;
    INT         cchName;
    WORD        wOffset;
    WORD        wXid;
    WORD        wQuestionCount;
    WORD        wAnswerCount;
    WORD        wNameServerCount;
    WORD        wAdditionalCount;
    WORD        countSectionRR;
    BOOL        fFlipped = FALSE;

    //
    //  processing limits
    //      - if length given set stop limit
    //      - if length not given set wLength so checks against
    //          length overrun always fail (are ok)
    //

    if ( wLength )
    {
        pmsgEnd = ((PBYTE)pMsgHead) + wLength;
    }
    else
    {
        wLength = MAXWORD;
        pmsgEnd = NULL;
    }


    DnsPrint_Lock();

    if ( pszHeader )
    {
        PrintRoutine( pContext, "%s\r\n", pszHeader );
    }

    PrintRoutine(
        pContext,
        "DNS message header at %p\r\n",
        pMsgHead );

    PrintRoutine(
        pContext,
        "    XID       0x%04hx\r\n"
        "    Flags     0x%04hx\r\n"
        "        QR        0x%lx (%s)\r\n"
        "        OPCODE    0x%lx (%s)\r\n"
        "        AA        0x%lx\r\n"
        "        TC        0x%lx\r\n"
        "        RD        0x%lx\r\n"
        "        RA        0x%lx\r\n"
        "        Z         0x%lx\r\n"
        "        RCODE     0x%lx (%s)\r\n"
        "    QCOUNT    0x%hx\r\n"
        "    ACOUNT    0x%hx\r\n"
        "    NSCOUNT   0x%hx\r\n"
        "    ARCOUNT   0x%hx\r\n",

        pMsgHead->Xid,
        ntohs((*((PWORD)pMsgHead + 1))),

        pMsgHead->IsResponse,
        (pMsgHead->IsResponse ? "response" : "question"),
        pMsgHead->Opcode,
        Dns_OpcodeString( pMsgHead->Opcode ),
        pMsgHead->Authoritative,
        pMsgHead->Truncation,
        pMsgHead->RecursionDesired,
        pMsgHead->RecursionAvailable,
        pMsgHead->Reserved,
        pMsgHead->ResponseCode,
        Dns_ResponseCodeString( pMsgHead->ResponseCode ),

        pMsgHead->QuestionCount,
        pMsgHead->AnswerCount,
        pMsgHead->NameServerCount,
        pMsgHead->AdditionalCount );

    //
    //  determine if byte flipped and get correct count
    //

    wXid                = pMsgHead->Xid;
    wQuestionCount      = pMsgHead->QuestionCount;
    wAnswerCount        = pMsgHead->AnswerCount;
    wNameServerCount    = pMsgHead->NameServerCount;
    wAdditionalCount    = pMsgHead->AdditionalCount;

    if ( wQuestionCount )
    {
        fFlipped = wQuestionCount & 0xff00;
    }
    else if ( wNameServerCount )
    {
        fFlipped = wNameServerCount & 0xff00;
    }
    if ( fFlipped )
    {
        wXid                = ntohs( wXid );
        wQuestionCount      = ntohs( wQuestionCount );
        wAnswerCount        = ntohs( wAnswerCount );
        wNameServerCount    = ntohs( wNameServerCount );
        wAdditionalCount    = ntohs( wAdditionalCount );
    }

    //
    //  catch record flipping problems -- all are flipped or none at all
    //      and no record count should be > 256 EXCEPT answer count
    //      during FAST zone transfer
    //

    DNS_ASSERT( ! (wQuestionCount & 0xff00) );
    DNS_ASSERT( ! (wNameServerCount & 0xff00) );
    DNS_ASSERT( ! (wAdditionalCount & 0xff00) );

#if 0
    //
    //  stop here if WINS response -- don't have parsing ready
    //

    if ( pMsgHead->IsResponse && IS_WINS_XID(wXid) )
    {
        PrintRoutine( pContext, "  WINS Response packet.\r\n\r\n" );
        goto Unlock;
    }
#endif

    //
    //  print questions and resource records
    //

    pchRecord = (PCHAR)(pMsgHead + 1);

    for ( isection=0; isection<4; isection++)
    {
        PrintRoutine(
            pContext,
            "  %s Section:\r\n",
            Dns_SectionNameString( isection, pMsgHead->Opcode ) );

        if ( isection==0 )
        {
            countSectionRR = wQuestionCount;
        }
        else if ( isection==1 )
        {
            countSectionRR = wAnswerCount;
        }
        else if ( isection==2 )
        {
            countSectionRR = wNameServerCount;
        }
        else if ( isection==3 )
        {
            countSectionRR = wAdditionalCount;
        }

        for ( i=0; i < countSectionRR; i++ )
        {
            //
            //  verify not overrunning length
            //      - check against pCurrent as well as message length
            //        so can print packets while being built
            //

            wOffset = (WORD)(pchRecord - (PCHAR)pMsgHead);

            if ( wOffset >= wLength )
            {
                PrintRoutine(
                    pContext,
                    "ERROR:  BOGUS PACKET:\r\n"
                    "\tFollowing RR (offset %d) past packet length (%d).\r\n",
                    wOffset,
                    wLength
                    );
                goto Unlock;
            }

            //
            //  print RR name
            //

            PrintRoutine(
                pContext,
                "    Name Offset = 0x%04x\r\n",
                wOffset
                );

            cchName = DnsPrint_PacketName(
                            PrintRoutine,
                            pContext,
                            "    Name      \"",
                            pchRecord,
                            pMsgHead,
                            pmsgEnd,
                            "\"\r\n" );
            if ( !cchName )
            {
                PrintRoutine(
                    pContext,
                    "ERROR:  Invalid name length, stop packet print\r\n" );
                DNS_ASSERT( FALSE );
                break;
            }
            pchRecord += cchName;

            //  print question or resource record

            if ( isection == 0 )
            {
                PrintRoutine(
                    pContext,
                    "      QTYPE   %d\r\n"
                    "      QCLASS  %d\r\n",
                    FlipUnalignedWord( pchRecord ),
                    FlipUnalignedWord( pchRecord + sizeof(WORD) )
                    );
                pchRecord += sizeof( DNS_WIRE_QUESTION );
            }
            else
            {
                pchRecord += DnsPrint_PacketRecord(
                                PrintRoutine,
                                pContext,
                                NULL,
                                (PDNS_WIRE_RECORD) pchRecord,
                                pMsgHead,
                                pmsgEnd
                                );
            }
        }
    }

    //  check that at proper end of packet

    wOffset = (WORD)(pchRecord - (PCHAR)pMsgHead);
    PrintRoutine(
        pContext,
        "  Message length = %04x\r\n\r\n",
        wOffset );

    //  print warning if given message length and did not end up
    //  at end of message
    //  note:  pmsgEnd test in case passed wLength==0, in which case
    //  wLength set to MAXDWORD above

    if ( pmsgEnd && wOffset < wLength )
    {
        PrintRoutine(
            pContext,
            "WARNING:  message continues beyond these records\r\n"
            "\tpch = %p\r\n"
            "\toffset = %d, msg length = %d, %d bytes\r\n",
            pchRecord,
            wOffset,
            wLength,
            wLength - wOffset );

        DnsPrint_RawOctets(
            PrintRoutine,
            pContext,
            "Remaining bytes:",
            NULL,
            pchRecord,
            (wLength - wOffset) );
    }

Unlock:
    DnsPrint_Unlock();


} // DnsPrint_MessageNoContext



DWORD
DnsStringPrint_Guid(
    OUT     PCHAR           pBuffer,
    IN      PGUID           pGuid
    )
/*++

Routine Description:

    Print GUID to buffer.

Arguments:

    pBuffer - buffer to print to
        buffer must be big enough for GUID string
        GUID_STRING_BUFFER_LENGTH covers it

    pGuid - GUID to print

Return Value:

    Count of bytes printed to string.

--*/
{
    if ( !pGuid )
    {
        *pBuffer = 0;
        return 0;
    }

    return  sprintf(
                pBuffer,
                "%08x-%04x-%04x-%04x-%02x%02x%02x%02x%02x%02x",
                pGuid->Data1,
                pGuid->Data2,
                pGuid->Data3,
                *(PWORD) &pGuid->Data4[0],
                pGuid->Data4[2],
                pGuid->Data4[3],
                pGuid->Data4[4],
                pGuid->Data4[5],
                pGuid->Data4[6],
                pGuid->Data4[7],
                pGuid->Data4[8] );
}



VOID
DnsPrint_Guid(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PGUID           pGuid
    )
/*++

Routine Description:

    Print GUID

Arguments:

    pszHeader - Header message/name for RR.

    pGuid -- ptr to GUID to print

Return Value:

    None.

--*/
{
    CHAR    guidBuffer[ GUID_STRING_BUFFER_LENGTH ];

    if ( !pszHeader )
    {
        pszHeader = "Guid";
    }
    if ( !pGuid )
    {
        PrintRoutine(
            pContext,
            "%s:  NULL GUID pointer!\r\n",
            pszHeader );
    }

    //  convert GUID to string

    DnsStringPrint_Guid(
        guidBuffer,
        pGuid );

    PrintRoutine(
        pContext,
        "%s:  (%p) %s\r\n",
        pszHeader,
        pGuid,
        guidBuffer );
}



DWORD
DnsStringPrint_RawOctets(
    OUT     PCHAR           pBuffer,
    IN      PCHAR           pchData,
    IN      DWORD           dwLength,
    IN      PSTR            pszLineHeader,
    IN      DWORD           dwLineLength
    )
/*++

Routine Description:

    Print raw octect data to sting

Arguments:

    pBuffer - buffer to print to

    pchData - data to print

    dwLength - length of data to print

    pszLineHeader - header on each line.

    dwLineLength - number of bytes to print on line;  default is 

Return Value:

    Count of bytes printed to string.

--*/
{
    INT     i;
    INT     lineCount = 0;
    PCHAR   pch = pBuffer;

    *pch = 0;

    //
    //  catch NULL pointer
    //      - return is null terminated
    //      - but indicate no bytes written
    //

    if ( !pchData )
    {
        return  0;
    }

    //
    //  write each byte in hex
    //      - if dwLineLength set break into lines with count
    //      or optional header
    //

    for ( i = 0; i < (INT)dwLength; i++ )
    {
        if ( dwLineLength  &&  (i % dwLineLength) == 0 )
        {
            if ( pszLineHeader )
            {
                pch += sprintf( pch, "\r\n%s", pszLineHeader );
            }
            else
            {
                pch += sprintf( pch, "\r\n%3d> ", i );
            }
            lineCount++;
        }

        pch += sprintf( pch, "%02x ", (UCHAR)pchData[i] );
    }

    return( (DWORD)(pch - pBuffer) );
}



VOID
DnsPrint_RawBinary(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PSTR            pszLineHeader,
    IN      PCHAR           pchData,
    IN      DWORD           dwLength,
    IN      DWORD           PrintSize
    )
/*++

Routine Description:

    Print raw data.

Arguments:

    pszHeader - Header message/name for RR.

    pszLineHeader - Header on each line.

    pchData - data to print

    dwLength - length of data to print

    PrintSize - size to print in
        size(QWORD)
        size(DWORD)
        size(WORD)
        defaults to bytes

Return Value:

    None.

--*/
{
    DWORD   i;
    DWORD   lineCount = 0;
    CHAR    buf[ 2000 ];
    PCHAR   pch = buf;
    PCHAR   pbyte;
    PCHAR   pend;

    DnsPrint_Lock();

    if ( pszHeader )
    {
        PrintRoutine(
            pContext,
            "%s",
            pszHeader );
    }

    buf[0] = 0;

    //
    //  print bytes
    //      - write 16 bytes a line
    //      - buffer up 10 lines for speed
    //
    //  note:  we'll write a partial (<16 byte) line the first
    //      time if data is unaligned with PrintSize, then we'll
    //      write at 16 a pop
    //

    if ( PrintSize == 0 )
    {
        PrintSize = 1;
    }

    i = 0;
    pch = buf;
    pend = (PBYTE)pchData + dwLength;

    while ( i < dwLength )
    {
        DWORD   lineBytes = (i%16);

        if ( lineBytes==0 || lineBytes > (16-PrintSize) )
        {
            if ( lineCount > 10 )
            {
                PrintRoutine( pContext, buf );
                lineCount = 0;
                pch = buf;
            }

            if ( pszLineHeader )
            {
                pch += sprintf( pch, "\r\n%s", pszLineHeader );
            }
            else
            {
                pch += sprintf( pch, "\r\n\t%3d> ", i );
            }
            lineCount++;

            //if ( i >= 128 && dlen > 256 )
            //{
            //    PrintRoutine( pContext, "skipping remaining bytes ...\r\n" ));
            //}
        }

        pbyte = &pchData[i];

        if ( PrintSize == sizeof(QWORD) &&
             POINTER_IS_ALIGNED( pbyte, ALIGN_QUAD ) &&
             pbyte + sizeof(QWORD) <= pend )
        {
            pch += sprintf( pch, "%I64x ", *(PQWORD)pbyte );
            i += sizeof(QWORD);
        }
        else if ( PrintSize == sizeof(DWORD) &&
                  POINTER_IS_ALIGNED( pbyte, ALIGN_DWORD ) &&
                  pbyte + sizeof(DWORD) <= pend )
        {
            pch += sprintf( pch, "%08x ", *(PDWORD)pbyte );
            i += sizeof(DWORD);
        }
        else if ( PrintSize == sizeof(WORD) &&
                  POINTER_IS_ALIGNED( pbyte, ALIGN_WORD ) &&
                  pbyte + sizeof(WORD) <= pend )
        {
            pch += sprintf( pch, "%04x ", *(PWORD)pbyte );
            i += sizeof(WORD);
        }
        else  // default to byte print
        {
            pch += sprintf( pch, "%02x ", *pbyte );
            i++;
        }
    }

    //  print remaining bytes in buffer

    PrintRoutine(
        pContext,
        "%s\r\n",
        buf );

    DnsPrint_Unlock();
}



VOID
DnsPrint_RawOctets(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PSTR            pszLineHeader,
    IN      PCHAR           pchData,
    IN      DWORD           dwLength
    )
/*++

Routine Description:

    Print raw octect data.

Arguments:

    pszHeader - Header message/name for RR.

    pszLineHeader - Header on each line.

    pchData - data to print

    dwLength - length of data to print

Return Value:

    None.

--*/
{
    INT     i;
    INT     lineCount = 0;
    CHAR    buf[ 2000 ];
    PCHAR   pch = buf;

    DnsPrint_Lock();

    if ( pszHeader )
    {
        PrintRoutine(
            pContext,
            "%s",
            pszHeader );
    }

    buf[0] = 0;

    //  buffer every 20 lines for speed

    for ( i = 0; i < (INT)dwLength; i++ )
    {
        if ( !(i%16) )
        {
            if ( lineCount > 10 )
            {
                PrintRoutine( pContext, buf );
                lineCount = 0;
                pch = buf;
            }

            if ( pszLineHeader )
            {
                pch += sprintf( pch, "\r\n%s", pszLineHeader );
            }
            else
            {
                pch += sprintf( pch, "\r\n%3d> ", i );
            }
            lineCount++;

            //if ( i >= 128 && dlen > 256 )
            //{
            //    PrintRoutine( pContext, "skipping remaining bytes ...\r\n" ));
            //}
        }

        pch += sprintf( pch, "%02x ", (UCHAR)pchData[i] );
    }

    //  print remaining bytes in buffer

    PrintRoutine(
        pContext,
        "%s\r\n",
        buf );

    DnsPrint_Unlock();
}



VOID
DnsPrint_ParsedRecord(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PDNS_PARSED_RR  pParsedRR
    )
/*++

Routine Description:

    Print parsed RR structure.

Arguments:

    pszHeader - Header message/name for RR.

    pParsedRR - parsed RR to print

Return Value:

    None.

--*/
{
    if ( !pszHeader )
    {
        pszHeader = "Parsed RR:";
    }

    if ( !pParsedRR )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL ParsedRR ptr." );
        return;
    }

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tpchName      = %p\r\n"
        "\tpchRR        = %p\r\n"
        "\tpchData      = %p\r\n"
        "\tpchNextRR    = %p\r\n"
        "\twType        = %d\r\n"
        "\twClass       = %d\r\n"
        "\tTTL          = %d\r\n"
        "\twDataLength  = %d\r\n",
        pszHeader,
        pParsedRR->pchName,
        pParsedRR->pchRR,
        pParsedRR->pchData,
        pParsedRR->pchNextRR,
        pParsedRR->Type,
        pParsedRR->Class,
        pParsedRR->Ttl,
        pParsedRR->DataLength
        );
}



//
//  Winsock RnR structures
//

VOID
DnsPrint_FdSet(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      struct fd_set * pfd_set
    )
/*++

Routine Description:

    Print sockets in FD_SET.

--*/
{
    INT count;
    INT i;

    DNS_ASSERT( pfd_set );

    count = (INT) pfd_set->fd_count;

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s  (count = %d)\r\n",
        pszHeader ? pszHeader : "FD_SET:",
        count );

    for (i=0; i<count; i++)
    {
        PrintRoutine(
            pContext,
            "\tsocket[%d] = %d\r\n",
            i,
            pfd_set->fd_array[i] );
    }
    DnsPrint_Unlock();
}



VOID
DnsPrint_Sockaddr(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      DWORD           Indent,
    IN      PSOCKADDR       pSockaddr,
    IN      INT             iSockaddrLength
    )
/*++

Routine Description:

    Print sockaddr structure and length used in call.

--*/
{
    PSTR    pindent = INDENT_STRING( Indent );

    if ( !pszHeader )
    {
        pszHeader = "Sockaddr:";
    }

    if ( !pSockaddr )
    {
        PrintRoutine(
            pContext,
            "%s%s\tNULL Sockaddr passed to print.\r\n",
            pindent,
            pszHeader );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s%s\r\n"
        "%s\tpointer         = %p\r\n"
        "%s\tlength          = %d\r\n"
        "%s\tsa_family       = %d\r\n",
        pindent,    pszHeader,
        pindent,    pSockaddr,
        pindent,    iSockaddrLength,
        pindent,    pSockaddr->sa_family
        );

    switch ( pSockaddr->sa_family )
    {

    case AF_INET:
        {
            PSOCKADDR_IN    psin = (PSOCKADDR_IN) pSockaddr;
    
            PrintRoutine(
                pContext,
                "%s\tsin_port        = %04x\r\n"
                "%s\tsin_addr        = %s (%08x)\r\n"
                "%s\tsin_zero        = %08x %08x\r\n",
                pindent,    psin->sin_port,
                pindent,    inet_ntoa( psin->sin_addr ),
                            psin->sin_addr.s_addr,
                pindent,    *(PDWORD) &psin->sin_zero[0],
                            *(PDWORD) &psin->sin_zero[4]
                );
            break;
        }

    case AF_INET6:
        {
            PSOCKADDR_IN6  psin = (PSOCKADDR_IN6) pSockaddr;

            CHAR    buffer[ IP6_ADDRESS_STRING_BUFFER_LENGTH ];

            Dns_Ip6AddressToString_A(
                buffer,
                (PIP6_ADDRESS) &psin->sin6_addr );

            PrintRoutine(
                pContext,
                "%s\tsin6_port       = %04x\r\n"
                "%s\tsin6_flowinfo   = %08x\r\n"
                "%s\tsin6_addr       = %s\r\n"
                "%s\tsin6_scope_id   = %08x\r\n",
                pindent,    psin->sin6_port,
                pindent,    psin->sin6_flowinfo,
                pindent,    buffer,
                pindent,    psin->sin6_scope_id
                );
            break;
        }       
                
    default:

        //  print unknown in WORDs
        //  limit print as this is probably a busted sockaddr due to bug
        {       
            DnsPrint_RawBinary(
                PrintRoutine,
                pContext,
                "\tdata:  ",
                pindent,            // line header
                pSockaddr->sa_data,
                iSockaddrLength < 100
                    ? iSockaddrLength
                    : 100,
                sizeof(WORD)
                );
            break;
        }
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_AddrInfo(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      DWORD           Indent,
    IN      PADDRINFO       pAddrInfo
    )
/*++

Routine Description:

    Print ADDRINFO structure.

--*/
{
    PSTR    pindent = INDENT_STRING( Indent );

    if ( !pszHeader )
    {
        pszHeader = "AddrInfo:";
    }

    if ( !pAddrInfo )
    {
        PrintRoutine(
            pContext,
            "%s%s NULL AddrInfo.\r\n",
            pindent,
            pszHeader  );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s%s\n"
        "%s\tPtr            = %p\r\n"
        "%s\tNext Ptr       = %p\r\n"
        "%s\tFlags          = %08x\r\n"
        "%s\tFamily         = %d\r\n"
        "%s\tSockType       = %d\r\n"
        "%s\tProtocol       = %d\r\n"
        "%s\tAddrLength     = %d\r\n"
        "%s\tName           = %s\r\n",
        pindent,    pszHeader,
        pindent,    pAddrInfo,
        pindent,    pAddrInfo->ai_next,
        pindent,    pAddrInfo->ai_flags,
        pindent,    pAddrInfo->ai_family,
        pindent,    pAddrInfo->ai_socktype,
        pindent,    pAddrInfo->ai_protocol,
        pindent,    pAddrInfo->ai_addrlen,
        pindent,    pAddrInfo->ai_canonname
        );

    DnsPrint_Sockaddr(
        PrintRoutine,
        pContext,
        NULL,
        Indent + 1,
        pAddrInfo->ai_addr,
        pAddrInfo->ai_addrlen );

    DnsPrint_Unlock();
}



VOID
DnsPrint_AddrInfoList(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      DWORD           Indent,
    IN      PADDRINFO       pAddrInfo
    )
/*++

Routine Description:

    Print ADDRINFO structure.

--*/
{
    PADDRINFO   paddr = pAddrInfo;
    PSTR        pindent = INDENT_STRING( Indent );

    //
    //  list header
    //

    if ( !pszHeader )
    {
        pszHeader = "AddrInfo List:";
    }

    if ( !paddr )
    {
        PrintRoutine(
            pContext,
            "%s%s NULL AddrInfo List.\r\n",
            pindent,
            pszHeader  );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s%s\n",
        pindent, pszHeader
        );

    //
    //  print each ADDRINFO in list
    //

    while ( paddr )
    {
        DnsPrint_AddrInfo(
            PrintRoutine,
            pContext,
            NULL,
            Indent,
            paddr );

        paddr = paddr->ai_next;
    }

    PrintRoutine(
        pContext,
        "End of AddrInfo list\n\n"
        );

    DnsPrint_Unlock();
}



VOID
DnsPrint_SocketAddress(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      DWORD           Indent,
    IN      PSOCKET_ADDRESS pSocketAddress
    )
/*++

Routine Description:

    Print SOCKET_ADDRESS structure.

--*/
{
    PSTR    pindent = INDENT_STRING( Indent );

    if ( !pszHeader )
    {
        pszHeader = "SocketAddress:";
    }

    if ( !pSocketAddress )
    {
        PrintRoutine(
            pContext,
            "%s%s NULL SocketAddress.\r\n",
            pindent,
            pszHeader  );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s%s\n"
        "%s\tpSockaddr        = %p\r\n"
        "%s\tiSockaddrLength  = %d\r\n",
        pindent,    pszHeader,
        pindent,    pSocketAddress->lpSockaddr,
        pindent,    pSocketAddress->iSockaddrLength );

    DnsPrint_Sockaddr(
        PrintRoutine,
        pContext,
        NULL,
        Indent,
        pSocketAddress->lpSockaddr,
        pSocketAddress->iSockaddrLength );

    DnsPrint_Unlock();
}



VOID
DnsPrint_CsAddr(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      DWORD           Indent,
    IN      PCSADDR_INFO    pCsAddr
    )
/*++

Routine Description:

    Print CSADDR_INFO structure.

Arguments:

    PrintRoutine    - routine to print with

    pParam          - ptr to print context

    pszHeader       - header

    Indent          - indent count, for formatting CSADDR inside larger struct

    pCsAddr         - ptr to CSADDRINFO to print

Return Value:

    None.

--*/
{
    PSTR    pindent = INDENT_STRING( Indent );

    if ( !pszHeader )
    {
        pszHeader = "CSAddrInfo:";
    }

    if ( !pCsAddr )
    {
        PrintRoutine(
            pContext,
            "%s%s \tNULL CSADDR_INFO ptr.\r\n",
            pindent,    pszHeader
            );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s%s\r\n"
        "%s\tPtr        = %p\n"
        "%s\tSocketType = %d\n"
        "%s\tProtocol   = %d\n",
        pindent,    pszHeader,
        pindent,    pCsAddr,
        pindent,    pCsAddr->iSocketType,
        pindent,    pCsAddr->iProtocol
        );

    DnsPrint_SocketAddress(
        PrintRoutine,
        pContext,
        "LocalAddress:",
        Indent,
        & pCsAddr->LocalAddr
        );

    DnsPrint_SocketAddress(
        PrintRoutine,
        pContext,
        "RemoteAddress:",
        Indent,
        & pCsAddr->RemoteAddr
        );

    DnsPrint_Unlock();
}




VOID
DnsPrint_AfProtocolsArray(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PAFPROTOCOLS    pProtocolArray,
    IN      DWORD           ProtocolCount
    )
/*++

Routine Description:

    Print AFPROTOCOLS array.

Arguments:

    PrintRoutine - routine to print with

    pszHeader   - header

    pProtocolArray - protocols array

    ProtocolCount  - array count

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "AFPROTOCOLS Array:";
    }

    //  print
    //      - array + count
    //      - each protocol element

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tProtocol Array   = %p\r\n"
        "\tProtocol Count   = %d\r\n",
        pszHeader,
        pProtocolArray,
        ProtocolCount );

    if ( pProtocolArray )
    {
        for ( i=0;  i<ProtocolCount;  i++ )
        {
            PrintRoutine(
                pContext,
                "\t\tfamily = %d;  proto = %d\r\n",
                pProtocolArray[i].iAddressFamily,
                pProtocolArray[i].iProtocol );
        }
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_WsaQuerySet(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      LPWSAQUERYSET   pQuerySet,
    IN      BOOL            fUnicode
    )
/*++

Routine Description:

    Print WSAQUERYSET structure.

Arguments:

    PrintRoutine - routine to print with

    pszHeader   - header

    pQuerySet   - ptr to WSAQUERYSET to print

    fUnicode    - TRUE if WSAQUERYSET is wide (WSAQUERYSETW)
                  FALSE if ANSI

Return Value:

    None.

--*/
{
    CHAR    serviceGuidBuffer[ GUID_STRING_BUFFER_LENGTH ];
    CHAR    nameSpaceGuidBuffer[ GUID_STRING_BUFFER_LENGTH ];
    DWORD   i;


    if ( !pszHeader )
    {
        pszHeader = "WSAQuerySet:";
    }

    if ( !pQuerySet )
    {
        PrintRoutine(
            pContext,
            "%s NULL QuerySet ptr\r\n",
            pszHeader );
        return;
    }

    //  convert GUIDs to strings

    DnsStringPrint_Guid(
        serviceGuidBuffer,
        pQuerySet->lpServiceClassId
        );
    DnsStringPrint_Guid(
        nameSpaceGuidBuffer,
        pQuerySet->lpNSProviderId
        );

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tSize                 = %d\r\n"
        "\tServiceInstanceName  = %S%s\r\n"
        "\tService GUID         = (%p) %s\r\n"
        "\tWSA version          = %p %x %d\r\n"
        "\tComment              = %S%s\r\n"
        "\tName Space           = %d %s\r\n"
        "\tName Space GUID      = (%p) %s\r\n"
        "\tContext              = %S%s\r\n"
        "\tNumberOfProtocols    = %d\r\n"
        "\tProtocol Array       = %p\r\n"
        "\tQueryString          = %S%s\r\n"
        "\tCS Addr Count        = %d\r\n"
        "\tCS Addr Array        = %p\r\n"
        "\tOutput Flags         = %08x\r\n"
        "\tpBlob                = %p\r\n",

        pszHeader,
        pQuerySet->dwSize,
        DNSSTRING_WIDE( fUnicode, pQuerySet->lpszServiceInstanceName ),
        DNSSTRING_ANSI( fUnicode, pQuerySet->lpszServiceInstanceName ),
        pQuerySet->lpServiceClassId,
        serviceGuidBuffer,
        pQuerySet->lpVersion,
        ( pQuerySet->lpVersion ) ? pQuerySet->lpVersion->dwVersion : 0,
        ( pQuerySet->lpVersion ) ? pQuerySet->lpVersion->ecHow : 0,

        DNSSTRING_WIDE( fUnicode, pQuerySet->lpszComment ),
        DNSSTRING_ANSI( fUnicode, pQuerySet->lpszComment ),
        pQuerySet->dwNameSpace,
        Dns_GetRnrNameSpaceIdString( pQuerySet->dwNameSpace ),
        pQuerySet->lpNSProviderId,
        nameSpaceGuidBuffer,
        DNSSTRING_WIDE( fUnicode, pQuerySet->lpszContext ),
        DNSSTRING_ANSI( fUnicode, pQuerySet->lpszContext ),

        pQuerySet->dwNumberOfProtocols,
        pQuerySet->lpafpProtocols,
        DNSSTRING_WIDE( fUnicode, pQuerySet->lpszQueryString ),
        DNSSTRING_ANSI( fUnicode, pQuerySet->lpszQueryString ),

        pQuerySet->dwNumberOfCsAddrs,
        pQuerySet->lpcsaBuffer,
        pQuerySet->dwOutputFlags,
        pQuerySet->lpBlob
        );

    //  print address-family\protocols array

    if ( pQuerySet->lpafpProtocols )
    {
        DnsPrint_AfProtocolsArray(
            PrintRoutine,
            pContext,
            "\tAFPROTOCOLS Array:",
            pQuerySet->lpafpProtocols,
            pQuerySet->dwNumberOfProtocols );
    }

    //  print CSADDR_INFO array

    if ( pQuerySet->dwNumberOfCsAddrs &&
         pQuerySet->lpcsaBuffer )
    {
        PrintRoutine(
            pContext,
            "--- CS_ADDR array:\r\n" );

        for ( i=0;  i<pQuerySet->dwNumberOfCsAddrs;  i++ )
        {
            DnsPrint_CsAddr(
                PrintRoutine,
                pContext,
                NULL,
                1,          // indent one level
                & pQuerySet->lpcsaBuffer[i] );
        }
    }

    //  print blob (the hostent)

    //
    //  DCR_FIX0:  need some sort of test for blob type?
    //      - most blobs are hostent, but some are servent
    //

    if ( pQuerySet->lpBlob )
    {
        GUID ianaGuid = SVCID_INET_SERVICEBYNAME;

        PrintRoutine(
            pContext,
            "--- BLOB:\n"
            "\tcbSize       = %d\r\n"
            "\tpBlobData    = %p\r\n",
            pQuerySet->lpBlob->cbSize,
            pQuerySet->lpBlob->pBlobData
            );

        //  note:  can't print blob as hostent
        //      1) may not be hostent
        //      2) is passed with offsets rather than pointers

        DnsPrint_RawBinary(
            PrintRoutine,
            pContext,
            NULL,
            "\t\t",
            pQuerySet->lpBlob->pBlobData,
            pQuerySet->lpBlob->cbSize,
            sizeof(DWORD)
            );
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_WsaNsClassInfo(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PWSANSCLASSINFO pInfo,
    IN      BOOL            fUnicode
    )
/*++

Routine Description:

    Print WSACLASSINFO structure.

Arguments:

    PrintRoutine - routine to print with

    pszHeader   - header

    pInfo       - ptr to WSACLASSINFO to print

    fUnicode    - TRUE if WSACLASSINFO is wide (WSACLASSINFOW)
                  FALSE if ANSI

Return Value:

    None.

--*/
{
    if ( !pszHeader )
    {
        pszHeader = "WSANsClassInfo:";
    }

    if ( !pInfo )
    {
        PrintRoutine(
            pContext,
            "%s NULL NsClassInfo ptr\r\n",
            pszHeader );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tPtr                  = %d\r\n"
        "\tName                 = %S%s\r\n"
        "\tName Space           = %d\r\n"
        "\tValue Type           = %d\r\n"
        "\tValue Size           = %d\r\n"
        "\tpValue               = %p\r\n",
        pszHeader,
        pInfo,
        DNSSTRING_WIDE( fUnicode, pInfo->lpszName ),
        DNSSTRING_ANSI( fUnicode, pInfo->lpszName ),
        pInfo->dwNameSpace,
        pInfo->dwValueType,
        pInfo->dwValueSize,
        pInfo->lpValue
        );

    if ( pInfo->lpValue )
    {
        PrintRoutine(
            pContext,
            "--- Value:\r\n"
            );

        DnsPrint_RawBinary(
            PrintRoutine,
            pContext,
            NULL,
            "\t\t",
            pInfo->lpValue,
            pInfo->dwValueSize,
            sizeof(BYTE)        // print in bytes
            );
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_WsaServiceClassInfo(
    IN      PRINT_ROUTINE           PrintRoutine,
    IN OUT  PPRINT_CONTEXT          pContext,
    IN      PSTR                    pszHeader,
    IN      LPWSASERVICECLASSINFO   pInfo,
    IN      BOOL                    fUnicode
    )
/*++

Routine Description:

    Print WSASERVICECLASSINFO structure.

Arguments:

    PrintRoutine - routine to print with

    pszHeader   - header

    pInfo       - ptr to WSASERVICECLASSINFO to print

    fUnicode    - TRUE if WSASERVICECLASSINFO is wide (WSASERVICECLASSINFOW)
                  FALSE if ANSI

Return Value:

    None.

--*/
{
    CHAR    serviceClassGuidBuffer[ GUID_STRING_BUFFER_LENGTH ];

    if ( !pszHeader )
    {
        pszHeader = "WSAServiceClassInfo:";
    }

    if ( !pInfo )
    {
        PrintRoutine(
            pContext,
            "%s NULL ServiceClassInfo ptr\r\n",
            pszHeader );
        return;
    }

    //  convert GUID to strings

    DnsStringPrint_Guid(
        serviceClassGuidBuffer,
        pInfo->lpServiceClassId
        );

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tPtr                  = %p\r\n"
        "\tClass GUID           = (%p) %s\r\n"
        "\tClassName            = %S%s\r\n"
        "\tClass Info Count     = %d\r\n"
        "\tClass Info Array     = %p\r\n",
        pszHeader,
        pInfo,
        serviceClassGuidBuffer,
        DNSSTRING_WIDE( fUnicode, pInfo->lpszServiceClassName ),
        DNSSTRING_ANSI( fUnicode, pInfo->lpszServiceClassName ),
        pInfo->dwCount,
        pInfo->lpClassInfos
        );

    if ( pInfo->lpClassInfos )
    {
        DWORD   i;

        for ( i=0; i<pInfo->dwCount; i++ )
        {
            DnsPrint_WsaNsClassInfo(
                PrintRoutine,
                pContext,
                NULL,       // default header
                & pInfo->lpClassInfos[i],
                fUnicode
                );
        }
    }

    DnsPrint_Unlock();
}



VOID
DnsPrint_Hostent(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PHOSTENT        pHostent,
    IN      BOOL            fUnicode
    )
/*++

Routine Description:

    Print hostent structure.

Arguments:

    PrintRoutine - routine to print with

    pszHeader   - header

    pHostent    - ptr to hostent

    fUnicode    - TRUE if hostent is unicode
                  FALSE if ANSI

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Hostent:";
    }

    if ( !pHostent )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL Hostent ptr." );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\th_name               = %p %S%s\n"
        "\th_aliases            = %p\n"
        "\th_addrtype           = %d\n"
        "\th_length             = %d\n"
        "\th_addrlist           = %p\n",
        pszHeader,
        pHostent->h_name,
        DNSSTRING_WIDE( fUnicode, pHostent->h_name ),
        DNSSTRING_ANSI( fUnicode, pHostent->h_name ),
        pHostent->h_aliases,
        pHostent->h_addrtype,
        pHostent->h_length,
        pHostent->h_addr_list
        );

    //  print the aliases

    if ( pHostent->h_aliases )
    {
        PSTR *  paliasArray = pHostent->h_aliases;
        PSTR    palias;

        while ( palias = *paliasArray++ )
        {
            PrintRoutine(
                pContext,
                "\tAlias = (%p) %S%s\n",
                palias,
                DNSSTRING_WIDE( fUnicode, palias ),
                DNSSTRING_ANSI( fUnicode, palias ) );
        }
    }

    //  print the addresses

    if ( pHostent->h_addr_list )
    {
        PCHAR * ppaddr = pHostent->h_addr_list;
        PCHAR   pip;
        INT     i = 0;
        INT     family = pHostent->h_addrtype;
        INT     addrLength = pHostent->h_length;
        CHAR    stringBuf[ IP6_ADDRESS_STRING_BUFFER_LENGTH ];

        while ( pip = ppaddr[i] )
        {
            DWORD   bufLength = IP6_ADDRESS_STRING_BUFFER_LENGTH;

            Dns_AddressToString_A(
                stringBuf,
                & bufLength,
                pip,
                addrLength,
                family );

            PrintRoutine(
                pContext,
                "\tAddr[%d] = %s \t(ptr=%p)\n",
                i,
                stringBuf,
                pip );
            i++;
        }
    }

    DnsPrint_Unlock();
}



//
//  Query print routines
//

VOID
DnsPrint_QueryBlob(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PQUERY_BLOB         pBlob
    )
/*++

Routine Description:

    Print query blob.

Arguments:

    PrintRoutine - routine to print with

    pContext    - print context

    pszHeader   - header

    pBlob       - query info

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Query Blob:";
    }

    if ( !pBlob )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL Query Blob ptr." );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "\tname orig        %S\n"
        "\tname orig wire   %s\n"
        "\tname wire        %s\n"
        "\ttype             %d\n"
        "\tflags            %08x\n"

        "\tname length      %d\n"
        "\tname attributes  %08x\n"
        "\tquery count      %d\n"
        "\tname flags       %08x\n"
        "\tfappendedName    %d\n"

        "\tstatus           %d\n"
        "\trcode            %d\n"
        "\tnetfail status   %d\n"
        "\tcache negative   %d\n"
        "\tno ip local      %d\n"
        "\trecords          %p\n"
        "\tlocal records    %p\n"

        "\tnetwork info     %p\n"
        "\tserver IPs       %p\n"
        "\tpmsg             %p\n"
        "\tevent            %p\n",

        pBlob->pNameOrig,
        pBlob->pNameOrigWire,
        pBlob->pNameWire,
        pBlob->wType,
        pBlob->Flags,
    
        pBlob->NameLength,
        pBlob->NameAttributes,
        pBlob->QueryCount,
        pBlob->NameFlags,
        pBlob->fAppendedName,
    
        pBlob->Status,
        pBlob->Rcode,
        pBlob->NetFailureStatus,
        pBlob->fCacheNegative,
        pBlob->fNoIpLocal,
        pBlob->pRecords,
        pBlob->pLocalRecords,

        pBlob->pNetworkInfo,
        pBlob->pDnsServers,
        pBlob->pRecvMsg,
        pBlob->hEvent
        );

    //  DCR_FIX0:  cleanup when results in use

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Records:\n",
        pBlob->pRecords );

    //  DCR_FIX0:  use results when ready

    DnsPrint_Unlock();
}



VOID
DnsPrint_QueryResults(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PDNS_RESULTS        pResults
    )
/*++

Routine Description:

    Print query results.

Arguments:

    PrintRoutine - routine to print with

    pContext    - print context

    pszHeader   - header

    pResults    - results info

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Results:";
    }

    if ( !pResults )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL Results ptr." );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "\tstatus       %d\n"
        "\trcode        %d\n"
        "\tserver       %s\n"
        "\tpanswer      %p\n"
        "\tpalias       %p\n"
        "\tpauthority   %p\n"
        "\tpadditional  %p\n"
        "\tpsig         %p\n"
        "\tpmsg         %p\n",
        pResults->Status,
        pResults->Rcode,
        IP_STRING( pResults->ServerIp ),
        pResults->pAnswerRecords,
        pResults->pAliasRecords,
        pResults->pAuthorityRecords,
        pResults->pAdditionalRecords,
        pResults->pSigRecords,
        pResults->pMessage
        );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "\tAnswer records:\n",
        pResults->pAnswerRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "\tAlias records:\n",
        pResults->pAliasRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "\tAuthority records:\n",
        pResults->pAuthorityRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "\tAdditional records:\n",
        pResults->pAdditionalRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "\tSignature records:\n",
        pResults->pSigRecords );

    DnsPrint_Unlock();
}



VOID
DnsPrint_ParsedMessage(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PDNS_PARSED_MESSAGE pParsed
    )
/*++

Routine Description:

    Print parsed message.

Arguments:

    PrintRoutine - routine to print with

    pContext    - print context

    pszHeader   - header

    pResults       - query info

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Parsed Message:";
    }

    if ( !pParsed )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL Parsed Message ptr." );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "\tstatus       %d (%08x)\n"
        "\tchar set     %d\n",
        pParsed->Status, pParsed->Status,
        pParsed->CharSet
        );

    PrintRoutine(
        pContext,
        "\tquestion:\n"
        "\t\tname       %S%s\n"
        "\t\ttype       %d\n"
        "\t\tclass      %d\n",
        PRINT_STRING_WIDE_CHARSET( pParsed->pQuestionName, pParsed->CharSet ),
        PRINT_STRING_ANSI_CHARSET( pParsed->pQuestionName, pParsed->CharSet ),
        pParsed->QuestionType,
        pParsed->QuestionClass
        );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Answer records:\n",
        pParsed->pAnswerRecords );
    
    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Alias records:\n",
        pParsed->pAliasRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Authority records:\n",
        pParsed->pAuthorityRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Additional records:\n",
        pParsed->pAdditionalRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Signature records:\n",
        pParsed->pSigRecords );

    DnsPrint_Unlock();
}



VOID
DnsPrint_QueryInfo(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PDNS_QUERY_INFO     pQueryInfo
    )
/*++

Routine Description:

    Print query info

Arguments:

    PrintRoutine - routine to print with

    pContext    - print context

    pszHeader   - header

    pQueryInfo  - query info

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Query Info:";
    }

    if ( !pQueryInfo )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL Query Info ptr." );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\n"
        "\tpointer      %p\n"
        "\tstatus       %d (%08x)\n"
        "\tchar set     %d\n"
        "\tname         %S%s\n"
        "\tname resv.   %s\n"
        "\ttype         %d\n"
        "\trcode        %d\n"
        "\tflags        %08x\n"

        "\tpanswer      %p\n"
        "\tpalias       %p\n"
        "\tpauthority   %p\n"
        "\tpadditional  %p\n"
        //"\tpsig         %p\n"

        "\tevent        %p\n"
        "\tpDnsServers  %p\n"
        "\tpmsg         %p\n",

        pszHeader,
        pQueryInfo,
        pQueryInfo->Status, pQueryInfo->Status,
        pQueryInfo->CharSet,
        PRINT_STRING_WIDE_CHARSET( pQueryInfo->pName, pQueryInfo->CharSet ),
        PRINT_STRING_ANSI_CHARSET( pQueryInfo->pName, pQueryInfo->CharSet ),
        pQueryInfo->pReservedName,
        pQueryInfo->Type,
        pQueryInfo->Rcode,
        pQueryInfo->Flags,

        pQueryInfo->pAnswerRecords,
        pQueryInfo->pAliasRecords,
        pQueryInfo->pAuthorityRecords,
        pQueryInfo->pAdditionalRecords,
        //pQueryInfo->pSigRecords,

        pQueryInfo->hEvent,
        pQueryInfo->pDnsServers,
        pQueryInfo->pMessage
        );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Answer records:\n",
        pQueryInfo->pAnswerRecords );
    
    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Alias records:\n",
        pQueryInfo->pAliasRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Authority records:\n",
        pQueryInfo->pAuthorityRecords );

    DnsPrint_RecordSet(
        PrintRoutine,
        pContext,
        "Additional records:\n",
        pQueryInfo->pAdditionalRecords );

    //DnsPrint_RecordSet(
    //    "Signature records:\n",
    //    pQueryInfo->pSigRecords );

    DnsPrint_Unlock();
}



VOID
DnsPrint_EnvarInfo(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pContext,
    IN      PSTR                pszHeader,
    IN      PENVAR_DWORD_INFO   pEnvar
    )
/*++

Routine Description:

    Print envar data

Arguments:

    PrintRoutine - routine to print with

    pContext    - print context

    pszHeader -- header to print with

    pEnvar -- ptr to envar info

Return Value:

    ERROR_SUCCESS if successful.
    ErrorCode on failure.

--*/
{
    PrintRoutine(
        pContext,
        "%s\n"
        "\tId       = %d\n"
        "\tValue    = %p\n"
        "\tfFound   = %d\n",
        pszHeader ? pszHeader : "Envar Info:",
        pEnvar->Id,
        pEnvar->Value,
        pEnvar->fFound
        );
}



//
//  Network info print routines.
//

VOID
DnsPrint_NetworkInfo(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pPrintContext,
    IN      LPSTR               pszHeader,
    IN      PDNS_NETINFO        pNetworkInfo
    )
/*++

Routine Description:

    Prints and validates network info structure.
    Should also touch all the memory and AV when bogus.

Arguments:

    pNetworkInfo -- network info to print

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "NetworkInfo:";
    }
    if ( !pNetworkInfo )
    {
        PrintRoutine(
            pPrintContext,
            "%s NULL NetworkInfo.\n",
            pszHeader );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pPrintContext,
        "%s\n"
        "\tpointer          = %p\n"
        "\tpszHostName      = %s\n"
        "\tpszDomainName    = %s\n"
        "\tpSearchList      = %p\n"
        "\tTimeStamp        = %d\n"
        "\tInfoFlags        = %08x\n"
        "\tReturnFlags      = %08x\n"
        "\tAdapterCount     = %d\n"
        "\tAdapterArraySize = %d\n",
        pszHeader,
        pNetworkInfo,
        pNetworkInfo->pszHostName,
        pNetworkInfo->pszDomainName,
        pNetworkInfo->pSearchList,
        pNetworkInfo->TimeStamp,
        pNetworkInfo->InfoFlags,
        pNetworkInfo->ReturnFlags,
        pNetworkInfo->AdapterCount,
        pNetworkInfo->MaxAdapterCount );

    //  print search list

    DnsPrint_SearchList(
        PrintRoutine,
        pPrintContext,
        "Search List: ",
        pNetworkInfo->pSearchList );

    //  print server lists

    for ( i=0; i < pNetworkInfo->AdapterCount; i++ )
    {
        CHAR    header[60];

        sprintf( header, "AdapterInfo[%d]:", i );

        DnsPrint_AdapterInfo(
            PrintRoutine,
            pPrintContext,
            header,
            pNetworkInfo->AdapterArray[i] );
    }
    PrintRoutine(
        pPrintContext,
        "\n" );

    DnsPrint_Unlock();
}



VOID
DnsPrint_AdapterInfo(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pPrintContext,
    IN      LPSTR               pszHeader,
    IN      PDNS_ADAPTER        pAdapter
    )
/*++

Routine Description:

    Prints and validates DNS adapter info.
    Should also touch all the memory and AV when bogus.

Arguments:

    pAdapter -- DNS adapter to print

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Adapter Info:";
    }
    if ( !pAdapter )
    {
        PrintRoutine(
            pPrintContext,
            "%s NULL Adapter info.\n",
            pszHeader );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pPrintContext,
        "%s\n"
        "\tpointer          = %p\n"
        "\tDomain           = %s\n"
        "\tGuid Name        = %s\n"
        "\tInterfaceIndex   = %d\n"
        "\tInfoFlags        = %08x\n"
        "\tStatus           = %d\n"
        "\tRunFlags         = %08x\n"
        "\tServerIndex      = %d\n"
        "\tServerCount      = %d\n"
        "\tServerArraySize  = %d\n",
        pszHeader,
        pAdapter,
        pAdapter->pszAdapterDomain,
        pAdapter->pszAdapterGuidName,
        pAdapter->InterfaceIndex,
        pAdapter->InfoFlags,
        pAdapter->Status,
        pAdapter->RunFlags,
        pAdapter->ServerIndex,
        pAdapter->ServerCount,
        pAdapter->MaxServerCount );

    //  DNS server info

    for ( i=0; i < pAdapter->ServerCount; i++ )
    {
        //  DCR:  IP6 DNS server address

        PrintRoutine(
            pPrintContext,
            "\tDNS Server [%d]:\n"
            "\t\tIpAddr     = %s\n"
            "\t\tPriority   = %d\n"
            "\t\tStatus     = %d (%08x)\n",
            i,
            IP_STRING( pAdapter->ServerArray[i].IpAddress ),
            pAdapter->ServerArray[i].Priority,
            pAdapter->ServerArray[i].Status,
            pAdapter->ServerArray[i].Status
            );
    }

    //  IP address info

    DnsPrint_IpArray(
        PrintRoutine,
        pPrintContext,
        "IP Addrs",
        "IP",
        pAdapter->pAdapterIPAddresses );

    DnsPrint_IpArray(
        PrintRoutine,
        pPrintContext,
        "IP Addr Subnets",
        "Mask",
        pAdapter->pAdapterIPSubnetMasks );

    DnsPrint_Unlock();
}



VOID
DnsPrint_SearchList(
    IN      PRINT_ROUTINE       PrintRoutine,
    IN OUT  PPRINT_CONTEXT      pPrintContext,
    IN      LPSTR               pszHeader,
    IN      PSEARCH_LIST        pSearchList
    )
/*++

Routine Description:

    Prints and validates DNS search list.
    Should also touch all the memory and AV when bogus.

Arguments:

    pSearchList -- search list to print

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "DNS Search List:";
    }

    if ( ! pSearchList )
    {
        PrintRoutine(
            pPrintContext,
            "%s NULL search list.\n",
            pszHeader );
        return;
    }

    DnsPrint_Lock();

    PrintRoutine(
        pPrintContext,
        "%s\n"
        "\tpointer        = %p\n"
        "\tpszDomain      = %s\n"
        "\tcNameCount     = %d\n"
        "\tcTotalListSize = %d\n"
        "\tCurrentName    = %d\n"
        "\tSearchListNames:\n",
        pszHeader,
        pSearchList,
        pSearchList->pszDomainOrZoneName,
        pSearchList->NameCount,
        pSearchList->MaxNameCount,
        pSearchList->CurrentNameIndex
        );

    for ( i=0; i < pSearchList->NameCount; i++ )
    {
        PrintRoutine(
            pPrintContext,
            "\t\t%s (Flags: %08x)\n",
            pSearchList->SearchNameArray[i].pszName,
            pSearchList->SearchNameArray[i].Flags );
    }
    DnsPrint_Unlock();
}



VOID
DnsPrint_HostentBlob(
    IN      PRINT_ROUTINE   PrintRoutine,
    IN OUT  PPRINT_CONTEXT  pContext,
    IN      PSTR            pszHeader,
    IN      PHOSTENT_BLOB   pBlob
    )
/*++

Routine Description:

    Print hostent structure.

Arguments:

    PrintRoutine - routine to print with

    pszHeader   - header

    pBlob       - ptr to hostent blob

Return Value:

    None.

--*/
{
    DWORD   i;

    if ( !pszHeader )
    {
        pszHeader = "Hostent Blob:";
    }

    if ( !pBlob )
    {
        PrintRoutine(
            pContext,
            "%s %s\r\n",
            pszHeader,
            "NULL Hostent blob ptr." );
        return;
    }

    //  print the struct

    DnsPrint_Lock();

    PrintRoutine(
        pContext,
        "%s\r\n"
        "\tPtr                  = %p\n"
        "\tpHostent             = %p\n"
        "\tfAllocatedBlob       = %d\n"
        "\tfAllocatedBuf        = %d\n"
        "\tpBuffer              = %p\n"
        "\tBufferLength         = %d\n"
        "\tAvailLength          = %d\n"
        "\tpAvailBuffer         = %p\n"
        "\tpCurrent             = %p\n"
        "\tBytesLeft            = %d\n"
        "\tMaxAliasCount        = %d\n"
        "\tAliasCount           = %d\n"
        "\tMaxAddrCount         = %d\n"
        "\tAddrCount            = %d\n"
        "\tfWroteName           = %d\n"
        "\tfUnicode             = %d\n"
        "\tCharSet              = %d\n",
        pszHeader,
        pBlob,
        pBlob->pHostent,
        pBlob->fAllocatedBlob,
        pBlob->fAllocatedBuf,
        pBlob->pBuffer,
        pBlob->BufferLength,
        pBlob->AvailLength,
        pBlob->pAvailBuffer,
        pBlob->pCurrent,
        pBlob->BytesLeft,
        pBlob->MaxAliasCount,
        pBlob->AliasCount,
        pBlob->MaxAddrCount,
        pBlob->AddrCount,
        pBlob->fWroteName,
        pBlob->fUnicode,
        pBlob->CharSet
        );

    //  print the hostent

    if ( pBlob->pHostent )
    {
        DnsPrint_Hostent(
            PrintRoutine,
            pContext,
            NULL,
            pBlob->pHostent,
            pBlob->fUnicode
            );
    }

    DnsPrint_Unlock();
}

//
//  End of print.c
//