system/ulib/mdns/mdns-test.cpp

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <mdns/mdns.h>

#include <errno.h>
#include <unittest/unittest.h>

// Test values.
const uint8_t kRdata[4] = {0xA, 0xB, 0xC};
const char kRrName[] = "test_rr";

// Test state manages sample values for testing. It is always initialized the
// same way.
//
// TODO(kjharland): Rector existing tests to use this and reduce boilerplate.
struct test_data {
    bool reset() {
        // Init message.
        mdns_init_message(&message);

        // Init rr.
        strcpy(rr.name, kRrName);
        rr.type = RR_TYPE_AAAA;
        rr.clazz = RR_CLASS_IN;
        rr.rdata = const_cast<uint8_t*>(kRdata);
        rr.rdlength = sizeof(kRdata);
        rr.ttl = 42;
        return true;
    }

    mdns_message message;
    mdns_rr rr;
};

// Returns true iff the given question has the given expected properties.
static bool verify_question(mdns_question* q, char* domain, uint16_t qtype, uint16_t qclass) {
    ASSERT_STR_EQ(q->domain, domain, "question has incorrect domain");
    ASSERT_EQ(q->qtype, qtype, "question has incorrect type");
    ASSERT_EQ(q->qclass, qclass, "question has incorrect class");
    return true;
}

// Returns true iff the given resource record has the given expected properties.
static bool verify_rr(mdns_rr* rr,
                      char* name,
                      uint16_t type,
                      uint16_t clazz,
                      uint8_t* rdata,
                      uint16_t rdlength,
                      uint32_t ttl) {
    ASSERT_STR_EQ(rr->name, name, "rr has incorrect name");
    ASSERT_EQ(rr->type, type, "rr has incorrect type");
    ASSERT_EQ(rr->clazz, clazz, "rr has incorrect class");
    ASSERT_EQ(rr->rdlength, rdlength, "rr has incorrect rdlength");
    ASSERT_EQ(rr->ttl, ttl, "rr has incorrect ttl");
    return true;
}

// Returns true iff the given message is zeroed out.
static bool verify_message_is_zeroed(mdns_message* message) {
    ASSERT_EQ(message->header.id, 0, "id should be zero");
    ASSERT_EQ(message->header.flags, 0, "flags should be zero");
    ASSERT_EQ(message->header.qd_count, 0, "question count should be zero");
    ASSERT_EQ(message->header.an_count, 0, "answer count should be zero");
    ASSERT_EQ(message->header.ns_count, 0, "name server count should be zero");
    ASSERT_EQ(message->header.ar_count, 0, "addition resource count should be zero");
    ASSERT_NULL(message->questions, "questions should be null");
    ASSERT_NULL(message->answers, "answers should be null");
    ASSERT_NULL(message->authorities, "authorities should be null");
    return true;
}

static bool test_mdns_init_message(void) {
    BEGIN_TEST;

    mdns_message message;
    mdns_init_message(&message);
    EXPECT_TRUE(verify_message_is_zeroed(&message), "message was not zeroed");
    mdns_free_message(&message);

    END_TEST;
}

static bool test_mdns_add_first_question(void) {
    BEGIN_TEST;

    mdns_message message;
    mdns_init_message(&message);
    EXPECT_EQ(message.header.qd_count, 0, "question count should be zero");
    EXPECT_NULL(message.questions, "questions should be null");

    char domain[20] = "https://fuchsia.com";
    uint16_t qtype = 0x1234;
    uint16_t qclass = 0xABCD;

    int retval = mdns_add_question(&message, domain, qtype, qclass);
    EXPECT_EQ(retval, 0, "should return zero if no error");
    EXPECT_EQ(message.header.qd_count, 1, "question count should be one");
    EXPECT_TRUE(verify_question(message.questions, domain, qtype, qclass));
    EXPECT_NULL(message.questions->next, "last question next ptr should be NULL");

    mdns_free_message(&message);

    END_TEST;
}

static bool test_mdns_add_nth_question(void) {
    BEGIN_TEST;

    mdns_message message;
    mdns_init_message(&message);
    EXPECT_EQ(message.header.qd_count, 0, "question count should be zero");
    EXPECT_NULL(message.questions, "questions should be null");

    char domain[20] = "https://fuchsia.com";
    uint16_t qtypeA = 0x1234;
    uint16_t qclassA = 0xABCD;

    int retval = mdns_add_question(&message, domain, qtypeA, qclassA);
    EXPECT_EQ(retval, 0, "should return zero if no error");

    message.header.qd_count = 4; // Fiddle with header to ensure it's reset.
    uint16_t qtypeB = 0x1235;
    uint16_t qclassB = 0xABCE;
    retval = mdns_add_question(&message, domain, qtypeB, qclassB);
    EXPECT_EQ(retval, 0, "should return zero if no error");

    EXPECT_EQ(message.header.qd_count, 2, "question count should be two");
    EXPECT_TRUE(verify_question(message.questions, domain, qtypeA, qclassA));
    EXPECT_NONNULL(message.questions->next, "non-last question next ptr should not be NULL");
    EXPECT_TRUE(verify_question(message.questions->next, domain, qtypeB, qclassB));
    EXPECT_NULL(message.questions->next->next, "last question next ptr should be NULL");

    mdns_free_message(&message);

    END_TEST;
}

static bool test_mdns_add_domain_too_long(void) {
    BEGIN_TEST;

    mdns_message message;
    mdns_init_message(&message);

    uint16_t qtype = 0x1234;
    uint16_t qclass = 0xABCD;

    char domain[MAX_DOMAIN_LENGTH + 1];
    memset(domain, 1, MAX_DOMAIN_LENGTH + 1);

    int retval = mdns_add_question(&message, domain, qtype, qclass);
    EXPECT_EQ(retval, -1, "should return -1 on error");
    EXPECT_EQ(errno, ENAMETOOLONG, "errno should be ENAMETOOLONG");
    EXPECT_NULL(message.questions, "question should not have been added on error");

    mdns_free_message(&message);

    END_TEST;
}

static bool test_mdns_add_first_answer(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();

    int retval = mdns_add_answer(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                 t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(retval, 0, "should return zero if no error");
    EXPECT_NONNULL(t.message.answers, "answer was not added");
    EXPECT_EQ(t.message.header.an_count, 1, "answer count should be one");
    EXPECT_TRUE(verify_rr(t.message.answers, t.rr.name, t.rr.type, t.rr.clazz,
                          t.rr.rdata, t.rr.rdlength, t.rr.ttl));

    END_TEST;
}

static bool test_mdns_add_nth_answer(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();

    int retval = mdns_add_answer(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                 t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(retval, 0, "should return zero if no error");

    char other_name[] = "other name";
    uint16_t other_type = RR_TYPE_A;
    uint16_t other_clazz = RR_CLASS_IN;
    uint8_t other_rdata[] = {t.rr.rdata[0]};
    uint16_t other_rdlength = sizeof(other_rdata) / sizeof(uint8_t);
    uint32_t other_ttl = t.rr.ttl + 1;
    retval = mdns_add_answer(&t.message, other_name, other_type, other_clazz,
                             other_rdata, other_rdlength, other_ttl);
    EXPECT_NONNULL(t.message.answers, "answer was not added");
    EXPECT_EQ(t.message.header.an_count, 2, "answer count should be two");

    EXPECT_TRUE(verify_rr(t.message.answers, t.rr.name, t.rr.type, t.rr.clazz,
                          t.rr.rdata, t.rr.rdlength, t.rr.ttl));

    EXPECT_NONNULL(t.message.answers->next, "second answer was not added");
    EXPECT_TRUE(verify_rr(t.message.answers->next, other_name, other_type,
                          other_clazz, other_rdata, other_rdlength, other_ttl));
    EXPECT_NULL(t.message.answers->next->next,
                "second answer nextptr should be null");

    END_TEST;
}

static bool test_mdns_add_answer_bad_rr_type(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();
    t.rr.type = (uint16_t)(RR_TYPE_A + 1); // Unsupported record type.
    int retval = mdns_add_answer(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                 t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(errno, EINVAL, "errno should be EINVAL when given bad rr type");
    EXPECT_EQ(retval, -1, "should return value < zero on error");
    EXPECT_NULL(t.message.answers, "should not have added answer to message");
    EXPECT_EQ(t.message.header.an_count, 0, "answer count should be zero");

    END_TEST;
}

static bool test_mdns_add_answer_bad_rr_class(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();
    t.rr.clazz = (uint16_t)(RR_CLASS_IN + 1); // Unsupported record class.
    int retval = mdns_add_answer(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                 t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(errno, EINVAL, "errno should be EINVAL when given bad rr class");
    EXPECT_EQ(retval, -1, "should return value < zero on error");
    EXPECT_NULL(t.message.answers, "should not have added answer to message");
    EXPECT_EQ(t.message.header.an_count, 0, "answer count should be zero");

    END_TEST;
}

static bool test_mdns_add_first_authority(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();

    int retval = mdns_add_authority(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                    t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(retval, 0, "should return zero if no error");
    EXPECT_NONNULL(t.message.authorities, "authority was not added");
    EXPECT_EQ(t.message.header.ns_count, 1, "authority count should be one");
    EXPECT_TRUE(verify_rr(t.message.authorities, t.rr.name, t.rr.type, t.rr.clazz,
                          t.rr.rdata, t.rr.rdlength, t.rr.ttl));

    END_TEST;
}

static bool test_mdns_add_nth_authority(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();

    int retval = mdns_add_authority(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                    t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(retval, 0, "should return zero if no error");

    char other_name[] = "other name";
    uint16_t other_type = RR_TYPE_A;
    uint16_t other_clazz = RR_CLASS_IN;
    uint8_t other_rdata[] = {t.rr.rdata[0]};
    uint16_t other_rdlength = sizeof(other_rdata) / sizeof(uint8_t);
    uint32_t other_ttl = t.rr.ttl + 1;
    retval = mdns_add_authority(&t.message, other_name, other_type, other_clazz,
                                other_rdata, other_rdlength, other_ttl);
    EXPECT_NONNULL(t.message.authorities, "authority was not added");
    EXPECT_EQ(t.message.header.ns_count, 2, "authority count should be two");

    EXPECT_TRUE(verify_rr(t.message.authorities, t.rr.name, t.rr.type, t.rr.clazz,
                          t.rr.rdata, t.rr.rdlength, t.rr.ttl));

    EXPECT_NONNULL(t.message.authorities->next, "second authority was not added");
    EXPECT_TRUE(verify_rr(t.message.authorities->next, other_name, other_type,
                          other_clazz, other_rdata, other_rdlength, other_ttl));
    EXPECT_NULL(t.message.authorities->next->next,
                "second authority nextptr should be null");

    END_TEST;
}

static bool test_mdns_add_authority_bad_rr_type(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();
    t.rr.type = (uint16_t)(RR_TYPE_A + 1); // Unsupported record type.
    int retval = mdns_add_authority(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                    t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(errno, EINVAL, "errno should be EINVAL when given bad rr type");
    EXPECT_EQ(retval, -1, "should return value < zero on error");
    EXPECT_NULL(t.message.authorities, "should not have added authority to message");
    EXPECT_EQ(t.message.header.ns_count, 0, "authority count should be zero");

    END_TEST;
}

static bool test_mdns_add_authority_bad_rr_class(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();
    t.rr.clazz = (uint16_t)(RR_CLASS_IN + 1); // Unsupported record class.
    int retval = mdns_add_authority(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                    t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(errno, EINVAL, "errno should be EINVAL when given bad rr class");
    EXPECT_EQ(retval, -1, "should return value < zero on error");
    EXPECT_NULL(t.message.authorities, "should not have added authority to message");
    EXPECT_EQ(t.message.header.ns_count, 0, "authority count should be zero");

    END_TEST;
}

static bool test_mdns_add_first_additional(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();

    int retval = mdns_add_additional(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                     t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(retval, 0, "should return zero if no error");
    EXPECT_NONNULL(t.message.additionals, "additional was not added");
    EXPECT_EQ(t.message.header.ar_count, 1, "additional count should be one");
    EXPECT_TRUE(verify_rr(t.message.additionals, t.rr.name, t.rr.type, t.rr.clazz,
                          t.rr.rdata, t.rr.rdlength, t.rr.ttl));

    END_TEST;
}

static bool test_mdns_add_nth_additional(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();

    int retval = mdns_add_additional(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                     t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(retval, 0, "should return zero if no error");

    char other_name[] = "other name";
    uint16_t other_type = RR_TYPE_A;
    uint16_t other_clazz = RR_CLASS_IN;
    uint8_t other_rdata[] = {t.rr.rdata[0]};
    uint16_t other_rdlength = sizeof(other_rdata) / sizeof(uint8_t);
    uint32_t other_ttl = t.rr.ttl + 1;
    retval = mdns_add_additional(&t.message, other_name, other_type, other_clazz,
                                 other_rdata, other_rdlength, other_ttl);
    EXPECT_NONNULL(t.message.additionals, "additional was not added");
    EXPECT_EQ(t.message.header.ar_count, 2, "additional count should be two");

    EXPECT_TRUE(verify_rr(t.message.additionals, t.rr.name, t.rr.type, t.rr.clazz,
                          t.rr.rdata, t.rr.rdlength, t.rr.ttl));

    EXPECT_NONNULL(t.message.additionals->next, "second additional was not added");
    EXPECT_TRUE(verify_rr(t.message.additionals->next, other_name, other_type,
                          other_clazz, other_rdata, other_rdlength, other_ttl));
    EXPECT_NULL(t.message.additionals->next->next,
                "second additional nextptr should be null");

    END_TEST;
}

static bool test_mdns_add_additional_bad_rr_type(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();
    t.rr.type = (uint16_t)(RR_TYPE_A + 1); // Unsupported record type.
    int retval = mdns_add_additional(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                     t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(errno, EINVAL, "errno should be EINVAL when given bad rr type");
    EXPECT_EQ(retval, -1, "should return value < zero on error");
    EXPECT_NULL(t.message.additionals, "should not have added additional to message");
    EXPECT_EQ(t.message.header.ar_count, 0, "additional count should be zero");

    END_TEST;
}

static bool test_mdns_add_additional_bad_rr_class(void) {
    BEGIN_TEST;

    test_data t;
    t.reset();
    t.rr.clazz = (uint16_t)(RR_CLASS_IN + 1); // Unsupported record class.
    int retval = mdns_add_additional(&t.message, t.rr.name, t.rr.type, t.rr.clazz,
                                     t.rr.rdata, t.rr.rdlength, t.rr.ttl);
    EXPECT_EQ(errno, EINVAL, "errno should be EINVAL when given bad rr class");
    EXPECT_EQ(retval, -1, "should return value < zero on error");
    EXPECT_NULL(t.message.additionals, "should not have added additional to message");
    EXPECT_EQ(t.message.header.ar_count, 0, "additional count should be zero");

    END_TEST;
}

static bool test_mdns_free_message(void) {
    BEGIN_TEST;

    mdns_message message;
    mdns_init_message(&message);

    char domain[20] = "https://fuchsia.com";
    int retval = mdns_add_question(&message, domain, 0, 0);
    EXPECT_EQ(retval, 0, "should return zero if no error");
    retval = mdns_add_question(&message, domain, 0, 0);
    EXPECT_EQ(retval, 0, "should return zero if no error");

    // Double check questions were successfully added.
    EXPECT_NONNULL(message.questions, "first question was not added");
    EXPECT_NONNULL(message.questions->next, "second question was not added");

    mdns_free_message(&message);
    EXPECT_TRUE(verify_message_is_zeroed(&message), "message was not zeroed");

    END_TEST;
}

static bool test_mdns_unmarshal_incomplete_header(void) {
    BEGIN_TEST;

    mdns_message message;
    uint16_t encoded_message[] = {0};

    // pass buf_len value smaller than MDNS_HEADER_SIZE to indicate the full
    // message did not fit into the provided buffer.
    int retval = mdns_unmarshal(encoded_message, MDNS_HEADER_SIZE - 1, &message);
    EXPECT_LT(retval, 0, "should have returned a negative value on error");
    EXPECT_TRUE(verify_message_is_zeroed(&message),
                "message was mutated even though decoding failed");

    retval = mdns_unmarshal(encoded_message, MDNS_HEADER_SIZE - 5, &message);
    EXPECT_LT(retval, 0, "should have returned a negative value on error");
    EXPECT_TRUE(verify_message_is_zeroed(&message),
                "message was mutated even though decoding failed");

    retval = mdns_unmarshal(encoded_message, 0, &message);
    EXPECT_LT(retval, 0, "should have returned a negative value on error");
    EXPECT_TRUE(verify_message_is_zeroed(&message),
                "message was mutated even though decoding failed");

    END_TEST;
}

static bool test_mdns_unmarshal_empty_message(void) {
    BEGIN_TEST;

    mdns_message message;

    // Completely empty message.
    uint16_t encoded_message_1[] = {
        // Header section
        0, // ID
        0, // Flags section
        0, // Question count
        0, // Answer count
        0, // Authority count
        0, // Additionals count
        // No message content.
    };

    int retval = mdns_unmarshal(encoded_message_1, MDNS_HEADER_SIZE, &message);
    EXPECT_EQ(retval, MDNS_HEADER_SIZE, "should have read 12 bytes");
    EXPECT_TRUE(verify_message_is_zeroed(&message),
                "message is not zeroed even though input data was empty");

    // Message with ID and flags but still "empty" because no questions or
    // records are inside.
    uint16_t encoded_message_2[] = {
        // Header section
        0xABCD, // ID
        0xCDEF, // Flags section
        0,      // Question count
        0,      // Answer count
        0,      // Authority count
        0,      // Additionals count
        // No message content.
    };

    retval = mdns_unmarshal(encoded_message_2, MDNS_HEADER_SIZE, &message);
    EXPECT_EQ(retval, MDNS_HEADER_SIZE, "should have read 12 bytes");
    EXPECT_EQ(message.header.id, 0xABCD, "ID should be 0xABCD (171)");
    EXPECT_EQ(message.header.flags, 0xCDEF, "flags should be 0xCDEF (205)");
    EXPECT_EQ(message.header.qd_count, 0, "question count should be 0");
    EXPECT_EQ(message.header.qd_count, 0, "answer count should be 0");
    EXPECT_EQ(message.header.qd_count, 0, "authority count should be 0");
    EXPECT_EQ(message.header.qd_count, 0, "additionals count should be 0");
    EXPECT_NULL(message.questions, "questions should be null");
    EXPECT_NULL(message.answers, "answers should be null");
    EXPECT_NULL(message.authorities, "authorities should be null");
    EXPECT_NULL(message.additionals, "additionals should be null");
    END_TEST;
}

BEGIN_TEST_CASE(mdns_free_message)
RUN_TEST(test_mdns_free_message)
END_TEST_CASE(mdns_free_message)

BEGIN_TEST_CASE(mdns_init_message)
RUN_TEST(test_mdns_init_message)
END_TEST_CASE(mdns_init_message)

BEGIN_TEST_CASE(mdns_add_question)
RUN_TEST(test_mdns_add_first_question)
RUN_TEST(test_mdns_add_nth_question)
RUN_TEST(test_mdns_add_domain_too_long)
END_TEST_CASE(mdns_add_question)

BEGIN_TEST_CASE(mdns_add_answer)
RUN_TEST(test_mdns_add_first_answer)
RUN_TEST(test_mdns_add_nth_answer)
RUN_TEST(test_mdns_add_answer_bad_rr_type)
RUN_TEST(test_mdns_add_answer_bad_rr_class)
END_TEST_CASE(mdns_add_answer)

BEGIN_TEST_CASE(mdns_add_authority)
RUN_TEST(test_mdns_add_first_authority)
RUN_TEST(test_mdns_add_nth_authority)
RUN_TEST(test_mdns_add_authority_bad_rr_type)
RUN_TEST(test_mdns_add_authority_bad_rr_class)
END_TEST_CASE(mdns_add_authority)

BEGIN_TEST_CASE(mdns_add_additional)
RUN_TEST(test_mdns_add_first_additional)
RUN_TEST(test_mdns_add_nth_additional)
RUN_TEST(test_mdns_add_additional_bad_rr_type)
RUN_TEST(test_mdns_add_additional_bad_rr_class)
END_TEST_CASE(mdns_add_additional)

BEGIN_TEST_CASE(test_mdns_unmarshal)
RUN_TEST(test_mdns_unmarshal_incomplete_header)
RUN_TEST(test_mdns_unmarshal_empty_message)
END_TEST_CASE(test_mdns_unmarshal)

int main(int argc, char* argv[]) {
    return unittest_run_all_tests(argc, argv) ? 0 : -1;
}