mdns.c

Go to the documentation of this file.

#define MDNS_C


// Includes

#include "TCPIP.h"
#include "mdns.h"


// Local defines

// Thats the maximum interval for an MDNS resolve. The resolve message is 
// repeated starting with 1 second interval and doubling each time until this
// maximum interval is reached.
#define MAXREPEAT_INTERVAL (TICK_HOUR)

// The predefined TTLs are used in the DNS entries...
#define DNS_DEFAULT_TTL 120ul   // In seconds...
#define DNS_RR_TTL      4500ul  // In seconds...

// Some special label identifiers...
#define DNS_ROOT_LABEL          (0xFF)
#define DNS_UNSPECIFIED_LABEL   (0xFF)


// Indices for dynamic label list entries.
#define TCP_SERVICE_NAME_IDX    (14)
#define QUERY_SERVICE_NAME_IDX  (15)
#define QUERY_NAME_IDX          (16)


// Count of labels and DNS entries stored here (see the lists below).
#define DNS_ENTRIES (sizeof(_asDNSEntries)/sizeof(DNS_ENTRY))
#define DNS_LABELS (sizeof(_asROMLabelList)/sizeof(ROM char *))


// This define sets the number of probe entries (from index zero to this
// number). The probe packets include only this entries:
#define DNS_PROBE_ENTRIES   2

// This define sets the number of goodbye entries (counted from the last
// index downwards).
#define DNS_GOODBYE_ENTRIES 1

// Needed maximum string length (must be greater than the maximum stored name 
// in the DNS entry table.
#define MAX_DNS_NAME_LEN    100


// Local typedefs

// Internal MDNS states
typedef enum
{
    MDNS_STOPPED = 0,
    MDNS_WAIT_FOR_PROBING,
    MDNS_SECOND_PROBE,
    MDNS_THIRD_PROBE,
    MDNS_FIRST_ANNOUNCING,
    MDNS_SECOND_ANNOUNCING,
    MDNS_THIRD_ANNOUNCING,
    MDNS_FOURTH_ANNOUNCING,
    MDNS_FIFTH_ANNOUNCING,
    MDNS_IDLE
} SM_MDNS;

// Internal MDNS Responder states
typedef enum
{
    MDNSR_STOPPED = 0,
    MDNSR_SERVICE,
    MDNSR_NAME,
    MDNSR_RESOLVED
} SM_MDNSR;


// Header of the (M)DNS message
typedef struct _DNS_HEADER
{
    WORD_VAL TransactionID;
    WORD_VAL Flags;
    WORD_VAL Questions;
    WORD_VAL Answers;
    WORD_VAL AuthoritativeRecords;
    WORD_VAL AdditionalRecords;
} DNS_HEADER;

// Structure of one DNS entry.
typedef struct
{
    BYTE        u8FirstLabelIdx;
    WORD_VAL    u16Type;
    DWORD_VAL   u32TTL;
    WORD_VAL    u16DataLength;
    void *      pData;
    BYTE        u8DNSFirstLabelIdx;
    BYTE        u8NumberOfAddRRs;
    ROM char *  pAddRRList;
    BOOL        bUnique;
} DNS_ENTRY;

// Single chain link structure for DNS names (pointer to the higher DNS tree
// hierarchy) which are located in flash.
typedef struct
{
    ROM char *  pLabel; // Pointer to a DNS label (maximum 63 bytes) as string.
    BYTE        u8PrevIndex;    // 0xFF if root
} DNS_ROMLABEL;


// Simple structure for DNS names located in RAM (dynamic labels).
typedef struct
{
    char *  pLabel;
} DNS_RAMLABEL;

// With this structure an DNS query (consisting of DNS name and type qualifier)
// is described. The structure is therefore used for sending queries.
typedef struct
{
    BYTE        u8FirstLabelIdx;
    WORD_VAL    u16Type;
} DNS_QUERY;

// This structures describes the architeture of an DNS service record.
typedef struct
{
    WORD_VAL    u16Priority;
    WORD_VAL    u16Weight;
    WORD_VAL    u16Port;
} SRV_ENTRY;

// Control fields for processing received queries and answers.
typedef struct
{
    BYTE bAnswer : 1;
    BYTE bUCAnswer : 1;
    BYTE bAdditional : 1;
} DNS_CONTROL;


// Local Variables

// Internal MDNS state machine
static SM_MDNS _eSM_MDNS = MDNS_STOPPED;
static UDP_SOCKET _sMDNSMCSocket = INVALID_UDP_SOCKET;
static DWORD _u32MdnsTimer;


// Variables for resolving services and names 

static BYTE _au8QuerySrvName[17];
static SRV_ENTRY _sQuerySrv;
static BYTE _au8QueryName[64];
static BYTE _au8QueryIP[4];
static DWORD _u32RetryTimer;
static DWORD _u32IntervalTime;
static SM_MDNSR _eSMResolver = MDNSR_STOPPED;



// Lists for ROM and RAM DNS label storage

// The list stores all known labels and forms a DNS tree due the single chain
// link mechanism. ROM Labels which consits of a single byte equal or greater
// '0x80' are pointer to the dynamic label list (_asRAMLabelList). In case the
// processing function looks up such a value, it can simple substract '0x80' to
// get the index for _asRAMLabelList.
ROM DNS_ROMLABEL _asROMLabelList[] =
{
// 0
    {HOSTNAME, 1},
// 1
    {(ROM BYTE *) "local", DNS_ROOT_LABEL},
// 2
    {(ROM BYTE *) "_http", 3},
// 3
    {(ROM BYTE *) "_tcp", 1},
// 4
    {(ROM BYTE *) "in-addr", 5},
// 5
    {(ROM BYTE *) "arpa", DNS_ROOT_LABEL},
// 6
    {(ROM BYTE *) "_services", 7},
// 7
    {(ROM BYTE *) "_dns-sd", 8},
// 8
    {(ROM BYTE *) "_udp", 1},
// 9
    {(ROM BYTE *) "\x80", 4},
// 10
    {(ROM BYTE *) "\x81", 9},
// 11
    {(ROM BYTE *) "\x82", 10},
// 12
    {(ROM BYTE *) "\x83", 11},
// 13
    {HOSTNAME, 2},
// 14 (TCP_QUERY_SERVICE_IDX) -> _pQuerySrv
    {(ROM BYTE *) "\x84", 3},
// 15 (QUERY_SERVICE_NAME_IDX) -> _pQueryName
    {(ROM BYTE *) "\x85", 14},
// 16 (QUERY_NAME_IDX) -> _pQueryName
    {(ROM BYTE *) "\x85", 1},
};



// Buffer for the (dynamic) IP label:
static BYTE _u8IPbuf[16];


// This list stores all dynamic labels. This labels are located in RAM, the
// pointers to this locations are stored here. Due the ROM label mechanism
// this list is part of the ROM label list (see documenation of 
// _asROMLabelList).
ROM DNS_RAMLABEL _asRAMLabelList[] =
{
    _u8IPbuf,
    &_u8IPbuf[4],
    &_u8IPbuf[8],
    &_u8IPbuf[12],
    _au8QuerySrvName,
    _au8QueryName,
};


// DNS entry table
// Each entry is a unique key value entry. The key consists of name and type.

// This a simple placeholder for a DNS name with zero length. Zero length label
// must store at least the zero for the root.
static BYTE _u8ZeroLength = 0;

// This service entry for the eWicht HTTP service is used by the DNS entry 
// table.
static SRV_ENTRY _sHttpService = {0,0,0x5000};  // htons(80)=0x5000


ROM DNS_ENTRY _asDNSEntries[] = 
{ 
    // hostname.local. A -> Local IP Address
    {0, DNS_TYPE_A, DNS_DEFAULT_TTL, 4, (void *) &sIPConfig.MyIPAddr, 
        DNS_UNSPECIFIED_LABEL, 0, 0, TRUE},

    // hostname._http._tcp.local. SRV -> hostname.local.
    {13, DNS_TYPE_SRV, DNS_DEFAULT_TTL, sizeof(SRV_ENTRY), &_sHttpService,
        0, 1, (ROM BYTE *) "\x000", TRUE},

    // ipaddr.in-addr.arpa. PTR -> hostname.local.
    {12, DNS_TYPE_PTR, DNS_DEFAULT_TTL, 0, 0, 0, 0, 0, TRUE},

    // _services._dns-sd._udp.local. PTR -> PTR
    {6, DNS_TYPE_PTR, DNS_RR_TTL, 0, 0, 2, 0, 0, FALSE},

    // hostname._http._tcp.local. TXT -> hostname.local.
    {13, DNS_TYPE_TXT, DNS_RR_TTL, 1, (void *) &_u8ZeroLength, 
        DNS_UNSPECIFIED_LABEL, 1, (ROM BYTE *) "\x000", TRUE},

    // _http._tcp.local. PTR -> hostname._http._tcp.local.
    {2, DNS_TYPE_PTR, DNS_RR_TTL, 0, 0, 
        13, 3, (ROM BYTE *) "\x000\x001\x004", FALSE}
};



// Control structures and variables for processing and sending frames.

static WORD_VAL _au16SendEntries[DNS_LABELS];
static DNS_CONTROL _sControl[DNS_ENTRIES];
static BYTE _u8UniqueEntries;



// Local function prototypes

static void _PutQuery(BOOL bProbe, BOOL bQU, DNS_QUERY * pQuery);
static BOOL _PrepareMulticast(BYTE nQueries, BYTE nAnswers, 
                                         BYTE nAuthoritives, BYTE nAdditional);
static void _SendRRList(BYTE nEntries, ROM DNS_ENTRY * pRRList, BOOL bGoodbye);
static void _PutDNSName(BYTE u8StartIndex);
static BYTE _u8GetDNSNameLength(BYTE u8LabelIndex);
static void _GetQueryData(WORD_VAL * psType, WORD_VAL * psClass);
static void _QueryLookUp(void);
static void _AnswerLookUp(BOOL bQuery);
BYTE _u8GetRRData(WORD_VAL * pType, WORD_VAL * pClass);
BYTE _u8GetStartLabelFromFrame(void);
void _CheckForQueryResponse(WORD_VAL u16Type, WORD_VAL * pu16Length, 
                                                            BYTE u8Startlabel);

// Implementation

BOOL bInitMDNSResponder(void)
{
    BYTE i = 0;
    NODE_INFO nodeInfo;

    // Prepare multicast address data for the frame.
    nodeInfo.MACAddr.v[0]= 0x01;
    nodeInfo.MACAddr.v[1]= 0x00;
    nodeInfo.MACAddr.v[2]= 0x5e;
    nodeInfo.MACAddr.v[3]= 0x00;
    nodeInfo.MACAddr.v[4]= 0x00;
    nodeInfo.MACAddr.v[5]= 0xfb;
    nodeInfo.IPAddr.v[0] = 224;
    nodeInfo.IPAddr.v[1] = 0;
    nodeInfo.IPAddr.v[2] = 0;
    nodeInfo.IPAddr.v[3] = 251;

    _eSM_MDNS = MDNS_STOPPED;

    _sMDNSMCSocket = UDPOpen(MDNS_PORT, &nodeInfo, MDNS_PORT);

    if(_sMDNSMCSocket == INVALID_UDP_SOCKET)
        return FALSE;

    // Determine the count of unique DNS entries (no PTR records!)
    _u8UniqueEntries = 0;
    for (i=0; i < DNS_ENTRIES; i++)
    {
        if ((_asDNSEntries[i].u16Type.Val != DNS_TYPE_PTR)&&
            (_asDNSEntries[i].bUnique==TRUE))
                _u8UniqueEntries++;
    }
    
    return TRUE;
}


void StartMDNSResponder(void)
{
    BYTE i = 0;

    MDNSStopResolving();

    // Prepare the IP labels!
    for (i=0;i<4;i++)
        sprintf(&_u8IPbuf[i<<2], "%u", sIPConfig.MyIPAddr.v[i]);

    // Start probing the DNS entries like described in the Multicast DNS 
    // internet draft chapter 9.1.

    _u32MdnsTimer = TickGet() + (rand() % ((DWORD)(TICKS_PER_SECOND >> 2)));
    _eSM_MDNS = MDNS_WAIT_FOR_PROBING;

/*
    From mDNS draft:
    When ready to send its mDNS probe packet(s) the host should first
    wait for a short random delay time, uniformly distributed in the
    range 0-250ms. This random delay is to guard against the case where a
    group of devices are powered on simultaneously, or a group of devices
    are connected to an Ethernet hub which is then powered on, or some
    other external event happens that might cause a group of hosts to all
    send synchronized probes.
*/
}


void StopMDNSResponder(void)
{
    // Stop any pending queries...
    MDNSStopResolving();

    if (_eSM_MDNS > MDNS_THIRD_PROBE)
    {
        // As seen in the Bonjour traces, we only send entries in the goodbye
        // packet which are shared entries which point to unique entries. 
        _PrepareMulticast(0, DNS_GOODBYE_ENTRIES, 0, 0);
        _SendRRList(DNS_GOODBYE_ENTRIES, 
                &_asDNSEntries[DNS_ENTRIES-DNS_GOODBYE_ENTRIES], 
                TRUE);
        UDPFlush();
    }
    
    _eSM_MDNS = MDNS_STOPPED;
}


MDNS_STATE eGetMDNSState(void)
{
    if (_eSM_MDNS == MDNS_STOPPED)
        return MDNS_HAS_STOPPED;
    else if (_eSM_MDNS > MDNS_FIRST_ANNOUNCING)
        return MDNS_IS_RUNNING;
    else
        return MDNS_IS_STARTING_UP;
}


void MDNSResponder()
{
    BOOL bSendUnicast = TRUE;
    BYTE i=0;

    switch(_eSM_MDNS)
    {
    case MDNS_STOPPED:
        break;

    case MDNS_THIRD_PROBE:
        bSendUnicast = FALSE;
    case MDNS_SECOND_PROBE:
    case MDNS_WAIT_FOR_PROBING:
        if (TickGet() > _u32MdnsTimer)
        {
            /*
            From mDNS internet draft:
            250ms after the first query the host should send a second, then
            250ms after that a third. If, by 250ms after the third probe, no
            conflicting Multicast DNS responses have been received, the host may
            move to the next step, announcing. (Note that this is the one
            exception from the normal rule that there should be at least one
            second between repetitions of the same question, and the interval
            between subsequent repetitions should double.)
            */

            // Send a probe packet...
            _PrepareMulticast(DNS_PROBE_ENTRIES, 0, _u8UniqueEntries, 0);

            for(i=0; i < DNS_PROBE_ENTRIES; i++)
            {
                DNS_QUERY query;
                query.u8FirstLabelIdx = _asDNSEntries[i].u8FirstLabelIdx;
                query.u16Type = _asDNSEntries[i].u16Type;
                _PutQuery(TRUE, bSendUnicast, &query);
            }
        
            // Transfer the unique entries a authoritive nameserver...
            for (i=0; i < DNS_ENTRIES; i++)
            {
                if((_asDNSEntries[i].bUnique==TRUE)&&
                   (_asDNSEntries[i].u16Type.Val != DNS_TYPE_PTR))
                {
                    _SendRRList(1, &_asDNSEntries[i], FALSE);
                }
            }
            UDPFlush();

            _u32MdnsTimer += (DWORD)(TICKS_PER_SECOND >> 2);
            _eSM_MDNS++;
        }
        break;

    case MDNS_FIRST_ANNOUNCING:
    case MDNS_SECOND_ANNOUNCING:
    case MDNS_THIRD_ANNOUNCING:
    case MDNS_FOURTH_ANNOUNCING:
    case MDNS_FIFTH_ANNOUNCING:
        if (TickGet() > _u32MdnsTimer)
        {
            /* From mDNS internet draft:
            The Multicast DNS Responder MUST send at least two gratuitous
            responses, one second apart. A Responder MAY send up to eight
            gratuitous Responses, provided that the interval between gratuitous
            responses doubles with every response sent. */

            // Send an announce packet...
            _PrepareMulticast(0, DNS_ENTRIES, 0, 0);
            _SendRRList(DNS_ENTRIES, _asDNSEntries, FALSE);
            UDPFlush();

            _u32MdnsTimer += (TICKS_PER_SECOND)*
                                         (1<<(_eSM_MDNS-(MDNS_FIRST_ANNOUNCING)));
            _eSM_MDNS++;
        }
        break;
    }

    if((_eSM_MDNS > MDNS_FIRST_ANNOUNCING)&&
       ((_eSMResolver == MDNSR_SERVICE) || (_eSMResolver == MDNSR_NAME)))
    {
        if (TickGet() > _u32RetryTimer)
        {
            if (_u32IntervalTime<MAXREPEAT_INTERVAL)
                _u32IntervalTime = _u32IntervalTime << 1;

            _u32RetryTimer += _u32IntervalTime;
            if (_eSMResolver == MDNSR_SERVICE)
                MDNSResolveService(0, 0);           
            else
                MDNSResolveName(0);
        }
    }
}


void MDNSProcessFrame(NODE_INFO *remoteNode, IP_ADDR *localIP)
{
    DNS_HEADER head;
    BYTE i;

    // Multicast-IP 224.0.0.251 regardless of source IP OR
    // same subnet of local IP and source IP
    if ((localIP->Val != 0xFB0000E0ul) &&
        ((remoteNode->IPAddr.Val & sIPConfig.MyMask.Val) !=
         (sIPConfig.MyIPAddr.Val & sIPConfig.MyMask.Val)))
    {
        return;
    }


    // The following function call should always return TRUE!!!
    if (!UDPIsGetReady(_sMDNSMCSocket))
        return;

    // Received a frame to process. Prepare status fields:
    memset(_sControl, 0, sizeof(_sControl));


    // ToDo: Add unicast support here!
    // It is recommended feature of the mDNS internet draft (chapter 6) to 
    // answer as a unicast frame on unicast queries. It is not mandatory!
    // All informations are available here to generate a unicast answer easily.




    // Retrieve the DNS header and de-big-endian it

    // MDNS ignores the Query ID field (except for generating legacy responses)
    UDPGet(&head.TransactionID.v[1]);
    UDPGet(&head.TransactionID.v[0]);

    UDPGet(&head.Flags.v[1]);
    UDPGet(&head.Flags.v[0]);

    UDPGet(&head.Questions.v[1]);
    UDPGet(&head.Questions.v[0]);
    UDPGet(&head.Answers.v[1]);
    UDPGet(&head.Answers.v[0]);
    UDPGet(&head.AuthoritativeRecords.v[1]);
    UDPGet(&head.AuthoritativeRecords.v[0]);
    UDPGet(&head.AdditionalRecords.v[1]);
    UDPGet(&head.AdditionalRecords.v[0]);


    if (head.Flags.Val == 0)
    {
        // Standard query received. Maybe we can response it?
        BYTE j, answers = 0, additional = 0;

        // The responder only processes frames after probing is successfull.
        if (_eSM_MDNS < MDNS_SECOND_ANNOUNCING)
            goto MDNSProcessEnd;

        // We only reply to requests with at least one query.
        if (head.Questions.Val == 0)
            goto MDNSProcessEnd;

        while(head.Questions.Val--)
        {
            // Check all questions for known answers!
            _QueryLookUp();
        }

        while(head.Answers.Val--)
        {
            // Check all answers for known answers!
            _AnswerLookUp(TRUE);
        }

        // count the valid answers...
        for(i = 0; i < DNS_ENTRIES; i++)
        {
            if (_sControl[i].bAnswer == TRUE)
            {
                answers++;
                
                // Mark the additional records!
                // (see dns-sd internet draft chapter 13)
                for(j = 0; j < _asDNSEntries[i].u8NumberOfAddRRs; j++)
                {
                    BYTE add = _asDNSEntries[i].pAddRRList[j];
                    if (_sControl[add].bAnswer == FALSE)
                        _sControl[add].bAdditional = TRUE;
                }
            }
        }

        // count the valid additional fields...
        for(i = 0; i < DNS_ENTRIES; i++)
        {
            if (_sControl[i].bAdditional == TRUE)
                additional++;
        }

        if (answers)
        {
            // Send an answer packet...
            _PrepareMulticast(0, answers, 0, additional);

            for(i = 0; i < DNS_ENTRIES; i++)
            {
                if (_sControl[i].bAnswer == TRUE)
                    _SendRRList(1, &_asDNSEntries[i], FALSE);
            }
            
            if (additional)
            {
                for(i = 0; i < DNS_ENTRIES; i++)
                {
                    if (_sControl[i].bAdditional == TRUE)
                        _SendRRList(1, &_asDNSEntries[i], FALSE);
                }
            }

            UDPFlush();
        }
    }
    else if (head.Flags.Val & 0x8000)
    {
        // Response received. 

        // 1.1 Compare all answers (TYPE and NAME) with our local DNS entry
        // list. If the found matches include unique entries, there is a 
        // conflict on the network! The service will be stopped.

        // 1.2 If a DNS query is pending, save the matching answer to a 
        // answer list.

        while(head.Answers.Val--)
            _AnswerLookUp(FALSE);

        while(head.AuthoritativeRecords.Val--)
            _AnswerLookUp(FALSE);

        while(head.AdditionalRecords.Val--)
            _AnswerLookUp(FALSE);

        // Look for found answers which are ambiguous!
        for(i = 0; i < DNS_ENTRIES; i++)
        {
            if (_sControl[i].bAnswer == TRUE)
                break;
        }

        // Ambiguity is very bad and leads to a stopped MDNS service!
        if (i != DNS_ENTRIES)
            StopMDNSResponder();
        
    }

MDNSProcessEnd:
    UDPDiscard();
}


BOOL bMDNSNameIsResolved(IP_ADDR * pIP)
{
    if (_eSMResolver != MDNSR_RESOLVED)
        return FALSE;
    memcpy(pIP,(void *)_au8QueryIP, 4);
    return TRUE; 
}


BOOL bMDNSServiceIsResolved(IP_ADDR * pIP, WORD_VAL * pu16Port)
{
    if (bMDNSNameIsResolved(pIP) == TRUE)
    {
        *pu16Port = _sQuerySrv.u16Port;
        return TRUE;
    }
    return FALSE;
}


void MDNSStopResolving(void)
{
    _eSMResolver = MDNSR_STOPPED;
}


void MDNSResolveName(char * pName)
{
    DNS_QUERY query;

    // Copy the name to query in dynamic query field.
    if (pName)
    {
        // Initial query!
        strcpy(_au8QueryName, pName);
        _u32RetryTimer = TickGet() + TICKS_PER_SECOND;
        _u32IntervalTime = TICKS_PER_SECOND;
    }

    query.u16Type.Val = DNS_TYPE_A;
    query.u8FirstLabelIdx = QUERY_NAME_IDX;

    _PrepareMulticast(1, 0, 0, 0);
    _PutQuery(FALSE, FALSE, &query);

    UDPFlush();

    _eSMResolver = MDNSR_NAME;
}


void MDNSResolveService(char * pName, ROM char * pServiceName)
{
    DNS_QUERY query;

    // Copy the name and the service to query in dynamic query field.
    if (pName)
    {
        // Initial query
        strcpypgm2ram(_au8QuerySrvName, pServiceName);
        strcpy(_au8QueryName, pName);
        _u32RetryTimer = TickGet() + TICKS_PER_SECOND;
        _u32IntervalTime = TICKS_PER_SECOND;
    }

    query.u16Type.Val = DNS_TYPE_SRV;
    query.u8FirstLabelIdx = QUERY_SERVICE_NAME_IDX;

    _PrepareMulticast(1, 0, 0, 0);
    _PutQuery(FALSE, FALSE, &query);

    UDPFlush();

    _eSMResolver = MDNSR_SERVICE;
}


static BYTE _u8GetDNSNameLength(BYTE u8LabelIndex)
{
    BYTE i=0;

    while(u8LabelIndex != DNS_ROOT_LABEL)
    {
        ROM BYTE * pRomLabel = _asROMLabelList[u8LabelIndex].pLabel;

        if (_au16SendEntries[u8LabelIndex].Val)
        {
            // Message compression field.
            i+=2;
            return i;
        }

        // Add one length byte for the length field
        i++;
        if (*pRomLabel & 0x80)
        {
            // Pointer to a RAM-Label.
            BYTE ramidx = (*pRomLabel) & 0x7F;
            BYTE * pRamLabel = _asRAMLabelList[ramidx].pLabel;
            
            // Put the length...
            i += strlen(pRamLabel);
        }
        else
            i += strlenpgm(pRomLabel);
    
        u8LabelIndex = _asROMLabelList[u8LabelIndex].u8PrevIndex;   
    }

    // Add the root label length indicator.
    return i++;
}


static void _PutDNSName(BYTE u8LabelIndex)
{
    while(u8LabelIndex != DNS_ROOT_LABEL)
    {
        ROM BYTE * pRomLabel = _asROMLabelList[u8LabelIndex].pLabel;
        
        if (_au16SendEntries[u8LabelIndex].Val)
        {
            // DNS name already sent via UDP (Do message compression).
            UDPPut(0xc0 | (_au16SendEntries[u8LabelIndex].v[1]));
            
            // Insert the position.
            UDPPut(_au16SendEntries[u8LabelIndex].v[0]);
            return;
        }
        else
        {
            // Save the offset for message compression:
            _au16SendEntries[u8LabelIndex].Val = UDPGetPutOffset();

            if (*pRomLabel & 0x80)
            {
                // Pointer to a RAM-Label.
                BYTE ramidx = (*pRomLabel) & 0x7F;
                BYTE * pRamLabel = _asRAMLabelList[ramidx].pLabel;
                
                // Put the length...
                UDPPut(strlen(pRamLabel));
    
                UDPPutString(pRamLabel);
            }
            else
            {
                // Pointer to a ROM-Label.
    
                // Put the length...
                UDPPut(strlenpgm(pRomLabel));
    
                UDPPutROMString(pRomLabel);
            }
        
            u8LabelIndex = _asROMLabelList[u8LabelIndex].u8PrevIndex;
        }
    }
    
    // Put the string terminator character
    UDPPut(0x00);
}


static void _GetQueryData(WORD_VAL * psType, WORD_VAL * psClass)
{
    // Get the type from the received packet
    UDPGet(&psType->v[1]);  
    UDPGet(&psType->v[0]);

    // Get the class from the received packet
    UDPGet(&psClass->v[1]); 
    UDPGet(&psClass->v[0]); 
}


static void _AnswerLookUp(BOOL bQuery)
{
    BYTE startlabel=0, i=0;
    WORD j=0;
    WORD_VAL type=0, class=0;
    WORD_VAL length, locallength;
    DWORD_VAL ttl = 0;
    BOOL bKeyMatch = FALSE;
    BOOL bEntryMatch = FALSE;

    // 1) Get the start label from the frame...
    startlabel = _u8GetRRData(&type, &class);   

    
    // 2) Read out the rest of the answer section...
    UDPGet(&ttl.v[3]);
    UDPGet(&ttl.v[2]);
    UDPGet(&ttl.v[1]);
    UDPGet(&ttl.v[0]);

    UDPGet(&length.v[1]);
    UDPGet(&length.v[0]);


    // 3) Unknown DNS name: Stop the processing.
    if (startlabel == DNS_UNSPECIFIED_LABEL)
    {
        // read out the payload and throw it away
        UDPGetArray(NULL, length.Val);
        return;
    }


    // 4) Get the DNS entry for the found name/type key.
    for(i=0; i < DNS_ENTRIES; i++)
    {
        if ((_asDNSEntries[i].u8FirstLabelIdx == startlabel)&&
            (_asDNSEntries[i].u16Type.Val == type.Val))
        {
            bKeyMatch = TRUE;
            locallength.Val = 
                      _u8GetDNSNameLength(_asDNSEntries[i].u8DNSFirstLabelIdx);

            if(length.Val != _asDNSEntries[i].u16DataLength.Val+locallength.Val)
                break;

            // Check the payload for equality!
            for (j=0; j<_asDNSEntries[i].u16DataLength.Val; j++)
            {
                BYTE tmp = 0;
                UDPGet(&tmp);
                length.Val--;
                if (tmp!=((BYTE *)(_asDNSEntries[i].pData))[j])
                    break;
            }
            
            if (j!=_asDNSEntries[i].u16DataLength.Val)
                break;

            if ((_asDNSEntries[i].u8DNSFirstLabelIdx!=DNS_UNSPECIFIED_LABEL)&&
                (_u8GetStartLabelFromFrame() !=
                                          _asDNSEntries[i].u8DNSFirstLabelIdx))
            {
                // _u8GetStartLabelFromFrame() reads out the hole name:
                // No payload is left?! Check this out!
                length.Val = 0;
                break;
            }

            // Like described in mDNS internet draft (chapter 7.1 Known Answer
            // Suppression): Check the TTL of an received possible answer. If
            // the entry is to old, send a new answer.
            if ((_asDNSEntries[i].u32TTL.Val >> 1)<ttl.Val)
            {
                // Thats our answer. Surpress it in a answer packet!
                _sControl[i].bAnswer = FALSE;
            }

            bEntryMatch = TRUE;
            break;
        }
    }
    
    // Look, if it is a answer for a running query...
    if ((bQuery==FALSE)&&(bKeyMatch==FALSE))
        _CheckForQueryResponse(type, &length, startlabel);

    
    // read out the rest of the answer RR.
    if (length.Val)
        UDPGetArray(NULL,length.Val);

    // Check the uniqueness of the found DNS entry!
    if ((bQuery==FALSE)&&(bKeyMatch==TRUE)&&(_asDNSEntries[i].bUnique==TRUE))
    {
        // Thats a ambiguous DNS entry! Mark it for the calling function.
        _sControl[i].bAnswer = TRUE;
    }
    return;
}


static void _QueryLookUp(void)
{
    BYTE labellen = 0;
    BYTE namelen = 0;
    BYTE startlabel = 0, j = 0;
    WORD_VAL type = 0, class = 0;

    // 1) Get the start label from the frame.
    startlabel = _u8GetRRData(&type, &class);   
    if (startlabel == DNS_UNSPECIFIED_LABEL)
        return;


    // 2) Get the DNS entry for the found label row
    for(j=0; j < DNS_ENTRIES; j++)
    {
        if ((_asDNSEntries[j].u8FirstLabelIdx == startlabel)&&
            ((_asDNSEntries[j].u16Type.Val == type.Val) ||
             (type.Val == DNS_TYPE_ANY)))
        {
            // We know the answer!
            _sControl[j].bAnswer = TRUE;

            // Is a unicast reponse requested?
            if (class.v[1] & 0x80)
                _sControl[j].bUCAnswer = TRUE;
        }
    }

    return;
}


BYTE _u8GetRRData(WORD_VAL * pType, WORD_VAL * pClass)
{
    BYTE label = _u8GetStartLabelFromFrame();
    _GetQueryData(pType, pClass);

    // Check the class (only internet class is supported)
    if ((pClass->Val & 0x7FFF) != 0x0001)
        return DNS_UNSPECIFIED_LABEL;

    return label;
}


void _CheckForQueryResponse(WORD_VAL u16Type, WORD_VAL * pu16Length, 
                                                             BYTE u8Startlabel)
{
    if ((u16Type.Val==DNS_TYPE_SRV)&&
        (_eSMResolver == MDNSR_SERVICE)&&
        (u8Startlabel == QUERY_SERVICE_NAME_IDX))
    {
        // Service query is running and is resolved.
        BYTE labellen;

        // Name query is running and is resolved.
        UDPGet(&_sQuerySrv.u16Priority.v[1]);
        UDPGet(&_sQuerySrv.u16Priority.v[0]);
        UDPGet(&_sQuerySrv.u16Weight.v[1]);
        UDPGet(&_sQuerySrv.u16Weight.v[0]);
        UDPGet(&_sQuerySrv.u16Port.v[1]);
        UDPGet(&_sQuerySrv.u16Port.v[0]);

        pu16Length->Val = pu16Length->Val - sizeof(SRV_ENTRY);

        UDPGet(&labellen);
        if (labellen & 0xc0)
        {
            /*
            WORD_VAL pos;
            pos.v[1] = labellen & 0x3F;
            UDPGet(&pos.v[0]);
            labellen++;
            */
        }
        else
            UDPGetArray(_au8QueryName, labellen);

        _au8QueryName[labellen] = 0;    // Terminate the string.
        pu16Length->Val-= labellen+1;   // Correct the length field.

        // Start resolving the found name...
        _u32RetryTimer = TickGet() + TICKS_PER_SECOND;
        _u32IntervalTime = TICKS_PER_SECOND;
        _eSMResolver = MDNSR_NAME;
        strlwr(_au8QueryName);  
    }
    else if ((u16Type.Val==DNS_TYPE_A)&&
        (_eSMResolver == MDNSR_NAME)&&
        (u8Startlabel == QUERY_NAME_IDX))
    {
        // Name query is running and is resolved.
        UDPGetArray(_au8QueryIP, 4);
        pu16Length->Val = 0;
        _eSMResolver = MDNSR_RESOLVED;
    }
}


BYTE _u8GetStartLabelFromFrame(void)
{
    BOOL bFound = FALSE;
    BOOL bNoSpaceLeft = FALSE;
    BYTE labellen = 0, namelen = 0, labelcount = 0, i, j;
    BYTE name[MAX_DNS_NAME_LEN];
    WORD_VAL udppos = u16MACGetCurrentReadPtrPos();

    memset(name, 0, MAX_DNS_NAME_LEN);

    // 1) Fetch complete DNS name (until pointer or root) from UDP frame.
    while(1)
    {
        labellen = MACGet();        // Get the length field

        if (labellen & 0xc0)
        {
            // Message compression label
            WORD_VAL address;
            address.v[1] = labellen & 0x3F;
            address.v[0] = MACGet();

            // Seek to the label position
            MACSetReadPtrInRx(sizeof(IP_HEADER)+sizeof(UDP_HEADER)+address.Val);
            continue;
        }
        
        if (labellen == 0)
            // root
            break;


        // Is space left for more names?
        if ((namelen+labellen) > MAX_DNS_NAME_LEN)
        {
            // No space left...
            bNoSpaceLeft = TRUE;
            break;
        }

        name[namelen++] = labellen;

        MACGetArray(&name[namelen], labellen);

        // DNS does not distinguish between lower and upper:    
        strlwr(&name[namelen]); 

        namelen += labellen;
    }

    // 3) Reseek 
    MACSetCurrentReadPtrPos(udppos);
    

    //  4) Read out the name from the UDP frame
    while(UDPGet(&labellen) == TRUE)
    {
        if (labellen & 0xc0)
        {
            BYTE dummy;
            UDPGet(&dummy);
            break;
        }
        else if (labellen == 0)
            break;

        UDPGetArray(NULL, labellen);
    }

    if (bNoSpaceLeft == TRUE)
        return DNS_UNSPECIFIED_LABEL;


    // 5) Compare the local labels with the DNS labels (starting at the leafs).
    for(i=0; i<DNS_LABELS; i++)
    {
        BYTE index = i; // Startindex
        namelen = 0;

        while(1)
        {
            ROM BYTE * pRomLabel;

            labellen = name[namelen++];
            if (labellen == 0)
            {
                // Root
                if (index == DNS_ROOT_LABEL)
                    bFound = TRUE;

                break;
            }

            pRomLabel = _asROMLabelList[index].pLabel;
            if (*pRomLabel & 0x80)
            {
                // RAM-Label
                BYTE ramidx = (*pRomLabel) & 0x7F;
                BYTE * pRamLabel = _asRAMLabelList[ramidx].pLabel;
                
                if (memcmp((void*)&name[namelen],(void*) pRamLabel, labellen)!=0)
                    break;
            }
            else
            {
                // ROM-Label
                if (memcmppgm2ram(&name[namelen], pRomLabel, labellen)!=0)
                    break;
            }
            
            index = _asROMLabelList[index].u8PrevIndex;
            namelen += labellen;
        };

        // DNS name already found?
        if(bFound == TRUE)
            break;
    }



    // Go back, if we have not found anything.
    if (bFound == FALSE)
        return DNS_UNSPECIFIED_LABEL;

    return i;
}


static BOOL _PrepareMulticast(BYTE nQueries, BYTE nAnswers, 
                                          BYTE nAuthoritives, BYTE nAdditional)
{
    if(!UDPIsPutReady(_sMDNSMCSocket))
        return FALSE;

    // Reset the message compression fields...
    memset(_au16SendEntries, 0, sizeof(_au16SendEntries));

    UDPPut(0x00);   // Transaction ID is always zero in multicasts.
    UDPPut(0x00);


    /*
    Taken from Internet draft:
    AA (Authoritative Answer) Bit

    In query messages, the Authoritative Answer bit MUST be zero on
    transmission, and MUST be ignored on reception.
    
    In response messages for Multicast Domains, the Authoritative Answer
    bit MUST be set to one (not setting this bit implies there's some
    other place where "better" information may be found) and MUST be
    ignored on reception.
    */

    if (nQueries)
        UDPPut(0x00);       // Standard query without recursion
    else
        UDPPut(0x84);       // Response
    UDPPut(0x00);   

    UDPPut(0x00);
    UDPPut(nQueries);       // questions
    
    UDPPut(0x00);
    UDPPut(nAnswers);       // answers

    UDPPut(0x00);
    UDPPut(nAuthoritives);      // Name server resource records.
    UDPPut(0x00);
    UDPPut(nAdditional);        // Additional records

    return TRUE;
}


static void _SendRRList(BYTE nEntries, ROM DNS_ENTRY * pRRList, BOOL bGoodbye)
{
    BYTE i = 0;
 
    for(; i < nEntries; i++)
    {
        WORD_VAL len = 0;

        _PutDNSName(pRRList[i].u8FirstLabelIdx);

        // Transfer type...
        UDPPut(pRRList[i].u16Type.v[1]);
        UDPPut(pRRList[i].u16Type.v[0]);

        // Transfer class (Internet)
        UDPPut(pRRList[i].bUnique<<7);  
        UDPPut(0x01);

        // Transfer TTL (zero if goodbye)
        if (bGoodbye == FALSE)
        {
            UDPPut(pRRList[i].u32TTL.v[3]); 
            UDPPut(pRRList[i].u32TTL.v[2]);
            UDPPut(pRRList[i].u32TTL.v[1]);
            UDPPut(pRRList[i].u32TTL.v[0]);
        }
        else
        {
            UDPPut(0);  
            UDPPut(0);
            UDPPut(0);
            UDPPut(0);
        }

        // Transfer data length (first add RAM and ROM payload)
        len.Val = pRRList[i].u16DataLength.Val +
                        _u8GetDNSNameLength(pRRList[i].u8DNSFirstLabelIdx);
        UDPPut(len.v[1]);
        UDPPut(len.v[0]);       

        // Transfer the RAM payload if available...
        if (pRRList[i].u16DataLength.Val)
            UDPPutArray(pRRList[i].pData, pRRList[i].u16DataLength.Val);

        // Transfer the DNS payload if available...
        if (pRRList[i].u8DNSFirstLabelIdx != DNS_ROOT_LABEL)
            _PutDNSName(pRRList[i].u8DNSFirstLabelIdx);
    }
}



static void _PutQuery(BOOL bProbe, BOOL bQU, DNS_QUERY * pQuery)
{
    BYTE i = 0;
    _PutDNSName(pQuery->u8FirstLabelIdx);

    // Type...
    if (bProbe==TRUE)
    {
        UDPPut(DNS_TYPE_ANY>>8);
        UDPPut(DNS_TYPE_ANY);
    }
    else
    {
        UDPPut(pQuery->u16Type.v[1]);
        UDPPut(pQuery->u16Type.v[0]);
    }

    // Class...
    /*
    Taken from Internet draft:
    Repurposing of top bit of qclass in Question Section
    
    In the Question Section of a Multicast DNS Query, the top bit of the
    qclass field is used to indicate that unicast responses are preferred
    for this particular question.   
    */

    UDPPut(bQU<<7); // Force unicast reponse, if requested.     
    UDPPut(0x01);   // Class: IN (Internet)
}

---