Function CollectProbeClaims

engine/dlib/src/dlib/mdns.cpp:1344–1385

Extracts and sorts only the authority records that answer one probe question. This gives the exact claim set needed for pairwise tiebreaking.

    // Extracts and sorts only the authority records that answer one probe
    // question. This gives the exact claim set needed for pairwise tiebreaking.
    static bool CollectProbeClaims(const uint8_t* data, uint32_t size, uint32_t section_offset, uint16_t record_count,
                                   const char* target_name, ProbeRecord* records, uint32_t max_records, uint32_t* out_count)
    {
        *out_count = 0;

        uint32_t offset = section_offset;
        for (uint16_t i = 0; i < record_count && offset < size; ++i)
        {
            char name[256];
            uint16_t type = 0;
            uint16_t klass = 0;
            uint32_t ttl = 0;
            uint16_t rdlength = 0;
            if (!ReadName(data, size, &offset, name, sizeof(name))
                || !ReadU16(data, size, &offset, &type)
                || !ReadU16(data, size, &offset, &klass)
                || !ReadU32(data, size, &offset, &ttl)
                || !ReadU16(data, size, &offset, &rdlength))
            {
                return false;
            }

            (void) ttl;

            if (offset + rdlength > size)
                return false;

            const uint32_t rdata_offset = offset;
            offset += rdlength;

            if (!NameEquals(name, target_name) || (klass & ~DNS_CLASS_FLUSH) != DNS_CLASS_IN)
                continue;

            if (*out_count >= max_records || !DecodeIncomingProbeRecord(data, size, type, klass, rdata_offset, rdlength, &records[*out_count]))
                return false;

            ++(*out_count);
        }

        SortProbeRecords(records, *out_count);
        return true;
    }

    // Returns true when the remote authority claims outrank our tentative data,
    // meaning we lost the simultaneous-probe tiebreak for this unique name.