/*
 * Copyright (c) 2017-2023 Apple Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#import "unittest_common.h"
#import "mDNSMacOSX.h"
#import <XCTest/XCTest.h>

// This client request was generated using the following command: "dns-sd -Q 123server.dotbennu.com. A".
uint8_t query_client_msgbuf[35] = {
	0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x32, 0x33, 0x73, 0x65, 0x72, 0x76, 0x65,
	0x72, 0x2e, 0x64, 0x6f, 0x74, 0x62, 0x65, 0x6e, 0x6e, 0x75, 0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x00,
	0x01, 0x00, 0x01
};

// This uDNS message is a canned response that was originally captured by wireshark.
uint8_t query_response_msgbuf[108] = {
    0x69, 0x41, // transaction id
	0x85, 0x80, // flags
	0x00, 0x01, // 1 question for 123server.dotbennu.com. Addr
	0x00, 0x02,	// 2 anwsers: 123server.dotbennu.com. CNAME test212.dotbennu.com., test212.dotbennu.com. Addr 10.100.0.1,
	0x00, 0x01,	// 1 authorities anwser: dotbennu.com. NS cardinal2.apple.com.
	0x00, 0x00, 0x09, 0x31, 0x32, 0x33,
    0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x08, 0x64, 0x6f, 0x74, 0x62, 0x65, 0x6e, 0x6e, 0x75, 0x03,
    0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00,
    0x02, 0x56, 0x00, 0x0a, 0x07, 0x74, 0x65, 0x73, 0x74, 0x32, 0x31, 0x32, 0xc0, 0x16, 0xc0, 0x34,
    0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x04, 0x0a, 0x64, 0x00, 0x01, 0xc0, 0x16,
    0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x51, 0x80, 0x00, 0x12, 0x09, 0x63, 0x61, 0x72, 0x64, 0x69,
    0x6e, 0x61, 0x6c, 0x32, 0x05, 0x61, 0x70, 0x70, 0x6c, 0x65, 0xc0, 0x1f
};

// Variables associated with contents of the above uDNS message
#define uDNS_TargetQID 16745
char udns_original_domainname_cstr[] = "123server.dotbennu.com.";
char udns_cname_domainname_cstr[] = "test212.dotbennu.com.";
static const mDNSv4Addr dns_response_ipv4 = {{ 10, 100, 0, 1 }};

@interface CNameRecordTest : XCTestCase
{
    UDPSocket* local_socket;
    request_state* client_request_message;}
@end

@implementation CNameRecordTest

// The InitThisUnitTest() initializes the mDNSResponder environment as well as
// a DNSServer. It also allocates memory for a local_socket and client request.
// Note: This unit test does not send packets on the wire and it does not open sockets.
- (void)setUp
{
    // Init unit test environment and verify no error occurred.
    mStatus result = init_mdns_environment(mDNStrue);
    XCTAssertEqual(result, mStatus_NoError);
    
    // Add one DNS server and verify it was added.
    AddDNSServer_ut();
    XCTAssertEqual(CountOfUnicastDNSServers(&mDNSStorage), 1);
    
    // Create memory for a socket that is never used or opened.
    local_socket = (UDPSocket *) mDNSPlatformMemAllocateClear(sizeof(*local_socket));
    
    // Create memory for a request that is used to make this unit test's client request.
    client_request_message = calloc(1, sizeof(request_state));
}

- (void)tearDown
{
    mDNS *m = &mDNSStorage;
    request_state* req = client_request_message;
    DNSServer   *ptr, **p = &m->DNSServers;
    
    while (req->replies)
    {
        reply_state *reply = req->replies;
        req->replies = req->replies->next;
        mDNSPlatformMemFree(reply);
    }
    mDNSPlatformMemFree(req);
    
    mDNSPlatformMemFree(local_socket);
    
    while (*p)
    {
        ptr = *p;
        *p = (*p)->next;
        LogInfo("FinalizeUnitTest: Deleting server %p %#a:%d (%##s)", ptr, &ptr->addr, mDNSVal16(ptr->port), ptr->domain.c);
        mDNSPlatformMemFree(ptr);
    }
}

- (void)testCNameRecordTestSeries
{
    [self _startClientQueryRequest];
    [self _populateCacheWithClientResponseRecords];
    [self _simulateNetworkChangeAndVerify];
}

// This test simulates a uds client request by setting up a client request and then
// calling mDNSResponder's handle_client_request.  The handle_client_request function
// processes the request and starts a query.  This unit test verifies
// the client request and query were setup as expected.  This unit test also calls
// mDNS_execute which determines the cache does not contain the new question's
// answer.
- (void)_startClientQueryRequest
{
    mDNS *const m = &mDNSStorage;
    request_state* req = client_request_message;
    const uint8_t *const msgptr = query_client_msgbuf;
    const uint32_t msgsz = sizeof(query_client_msgbuf);
    mDNSs32 min_size = sizeof(DNSServiceFlags) + sizeof(mDNSu32) + 4;
    DNSQuestion *q;
    mStatus err = mStatus_NoError;
    char qname_cstr[MAX_ESCAPED_DOMAIN_NAME];
    
    // Process the unit test's client request
    start_client_request(req, msgptr, msgsz, query_request, local_socket);
    XCTAssertEqual(err, mStatus_NoError);
    
    // Verify the request fields were set as expected
    XCTAssertNil((__bridge id)req->next);
    XCTAssertNil((__bridge id)req->primary);
    XCTAssertEqual(req->sd, client_req_sd);
    XCTAssertEqual(req->process_id, client_req_process_id);
    XCTAssertFalse(strcmp(req->pid_name, client_req_pid_name));
    XCTAssertEqual(req->validUUID, mDNSfalse);
    XCTAssertEqual(req->errsd, 0);
    XCTAssertEqual(req->uid, client_req_uid);
    XCTAssertEqual(req->ts, t_complete);
    XCTAssertGreaterThan((mDNSs32)req->data_bytes, min_size);
    XCTAssertEqual(req->msgend, msgptr+msgsz);
    XCTAssertNil((__bridge id)(void*)req->msgbuf);
    XCTAssertEqual(req->hdr.version, VERSION);
    XCTAssertNil((__bridge id)req->replies);
    XCTAssertNotEqual(req->terminate, (req_termination_fn)0);
    XCTAssertEqual(req->flags, kDNSServiceFlagsReturnIntermediates);
    XCTAssertEqual(req->interfaceIndex, kDNSServiceInterfaceIndexAny);
    
    // Verify the query fields were set as expected
    q = &req->queryrecord->op.q;
    XCTAssertNotEqual(q, (DNSQuestion *)mDNSNULL);
    XCTAssertEqual(q, m->Questions);
    XCTAssertEqual(q, m->NewQuestions);
    XCTAssertEqual(q->SuppressUnusable, mDNSfalse);
    XCTAssertEqual(q->ReturnIntermed, mDNStrue);
    XCTAssertEqual(q->Suppressed, mDNSfalse);
    
    ConvertDomainNameToCString(&q->qname, qname_cstr);
    XCTAssertFalse(strcmp(qname_cstr, udns_original_domainname_cstr));
    XCTAssertEqual(q->qnamehash, DomainNameHashValue(&q->qname));
    
    XCTAssertEqual(q->InterfaceID, mDNSInterface_Any);
    XCTAssertEqual(q->flags, req->flags);
    XCTAssertEqual(q->qtype, 1);
    XCTAssertEqual(q->qclass, 1);
    XCTAssertEqual(q->LongLived, 0);
    XCTAssertEqual(q->ExpectUnique, mDNSfalse);
    XCTAssertEqual(q->ForceMCast, 0);
    XCTAssertEqual(q->TimeoutQuestion, 0);
    XCTAssertEqual(q->WakeOnResolve, 0);
    XCTAssertEqual(q->UseBackgroundTraffic, 0);
    XCTAssertEqual(q->ProxyQuestion, 0);
    XCTAssertNotEqual((void*)q->QuestionCallback, (void*)mDNSNULL);
    XCTAssertEqual(q->AppendSearchDomains, 0);
    XCTAssertNil((__bridge id)q->DuplicateOf);
    
    // Call mDNS_Execute to see if the new question, q, has an answer in the cache.
    // It won't be yet because the cache is empty.
    m->NextScheduledEvent = mDNS_TimeNow_NoLock(m);
    mDNS_Execute(m);
    
    // Verify mDNS_Execute processed the new question.
    XCTAssertNil((__bridge id)m->NewQuestions);
    
    // Verify the cache is empty and the request got no reply.
    XCTAssertEqual(m->rrcache_totalused, 0);
    XCTAssertNil((__bridge id)req->replies);
}

// This unit test receives a canned uDNS response message by calling the mDNSCoreReceive() function.
// It then verifies cache entries were added for the CNAME and A records that were contained in the
// answers of the canned response, query_response_msgbuf.  This unit test also verifies that
// 2 add events were generated for the client.
- (void)_populateCacheWithClientResponseRecords
{
    mDNS *const m = &mDNSStorage;
    DNSMessage *msgptr = (DNSMessage *)query_response_msgbuf;
    size_t msgsz = sizeof(query_response_msgbuf);
    struct reply_state *reply;
    request_state* req = client_request_message;
    DNSQuestion *q = &req->queryrecord->op.q;
    const uint8_t *data;
    const uint8_t *end;
    char name[kDNSServiceMaxDomainName];
    uint16_t rrtype, rrclass, rdlen;
    const uint8_t *rdata;
    size_t len;
    char domainname_cstr[MAX_ESCAPED_DOMAIN_NAME];
    
    // Receive and populate the cache with canned response
    receive_response(req, msgptr, msgsz);
    
    // Verify 2 cache entries for CName and A record are present
    mDNSu32 CacheUsed =0, notUsed =0;
    LogCacheRecords_ut(mDNS_TimeNow(m), &CacheUsed, &notUsed);
    XCTAssertEqual(CacheUsed, m->rrcache_totalused);
    XCTAssertEqual(CacheUsed, 4); // 2 for the CacheGroup object plus 2 for the A and CNAME records
    XCTAssertEqual(m->PktNum, 1); // one packet was received
    
    // Verify question's qname is now set with the A record's domainname
    ConvertDomainNameToCString(&q->qname, domainname_cstr);
    XCTAssertEqual(q->qnamehash, DomainNameHashValue(&q->qname));
    XCTAssertFalse(strcmp(domainname_cstr, udns_cname_domainname_cstr));
    
    // Verify client's add event for CNAME is properly formed
    reply = req->replies;
    XCTAssertNotEqual(reply, (reply_state*)mDNSNULL);
    XCTAssertNil((__bridge id)reply->next);
    
    data    = (uint8_t *)&reply->rhdr[1];
    end     = data+reply->totallen;
    get_string(&data, data+reply->totallen, name, kDNSServiceMaxDomainName);
    rrtype  = get_uint16(&data, end);
    rrclass = get_uint16(&data, end);
    rdlen   = get_uint16(&data, end);
    rdata   = get_rdata(&data, end, rdlen);
    len     = get_reply_len(name, rdlen);
    
    XCTAssertEqual(reply->totallen, len + sizeof(ipc_msg_hdr));
    XCTAssertEqual(reply->mhdr->version, VERSION);
    XCTAssertEqual(reply->mhdr->datalen, len);
    XCTAssertEqual(reply->mhdr->ipc_flags, 0);
    XCTAssertEqual(reply->mhdr->op, query_reply_op);
    
    XCTAssertEqual(reply->rhdr->flags, htonl(kDNSServiceFlagsAdd));
    XCTAssertEqual(reply->rhdr->ifi, kDNSServiceInterfaceIndexAny);
    XCTAssertEqual(reply->rhdr->error, kDNSServiceErr_NoError);
    
    XCTAssertEqual(rrtype, kDNSType_CNAME);
    XCTAssertEqual(rrclass, kDNSClass_IN);
    ConvertDomainNameToCString((const domainname *const)rdata, domainname_cstr);
    XCTAssertFalse(strcmp(domainname_cstr, "test212.dotbennu.com."));
    
    // The mDNS_Execute call generates an add event for the A record
    m->NextScheduledEvent = mDNS_TimeNow_NoLock(m);
    mDNS_Execute(m);
    
    // Verify the client's reply contains a properly formed add event for the A record.
    reply = req->replies;
    XCTAssertNotEqual(reply, (reply_state*)mDNSNULL);
    XCTAssertNotEqual(reply->next, (reply_state*)mDNSNULL);
    reply = reply->next;
    
    data    = (uint8_t *)&reply->rhdr[1];
    end     = data+reply->totallen;
    get_string(&data, data+reply->totallen, name, kDNSServiceMaxDomainName);
    rrtype  = get_uint16(&data, end);
    rrclass = get_uint16(&data, end);
    rdlen   = get_uint16(&data, end);
    rdata   = get_rdata(&data, end, rdlen);
    len     = get_reply_len(name, rdlen);
    
    XCTAssertEqual(reply->totallen, len + sizeof(ipc_msg_hdr));
    XCTAssertEqual(reply->mhdr->version, VERSION);
    XCTAssertEqual(reply->mhdr->datalen, len);
    
    XCTAssertEqual(reply->mhdr->ipc_flags, 0);
    XCTAssertEqual(reply->mhdr->op, query_reply_op);
    
    XCTAssertEqual(reply->rhdr->flags, htonl(kDNSServiceFlagsAdd));
    XCTAssertEqual(reply->rhdr->ifi, kDNSServiceInterfaceIndexAny);
    XCTAssertEqual(reply->rhdr->error, kDNSServiceErr_NoError);
    
    XCTAssertEqual(rrtype, kDNSType_A);
    XCTAssertEqual(rrclass, kDNSClass_IN);
    XCTAssertEqual(rdata[0], dns_response_ipv4.b[0]);
    XCTAssertEqual(rdata[1], dns_response_ipv4.b[1]);
    XCTAssertEqual(rdata[2], dns_response_ipv4.b[2]);
    XCTAssertEqual(rdata[3], dns_response_ipv4.b[3]);
}

// This function verifies the cache and event handling occurred as expected when a network change happened.
// The uDNS_SetupDNSConfig is called to simulate a network change and two outcomes occur. First the A record
// query is restarted and sent to a new DNS server. Second the cache records are purged. Then mDNS_Execute
// is called and it removes the purged cache records and generates a remove event for the A record.
// The following are verified:
//      1.) The restart of query for A record.
//      2.) The cache is empty after mDNS_Execute removes the cache entres.
//      3.) The remove event is verified by examining the request's reply data.
- (void)_simulateNetworkChangeAndVerify
{
    mDNS *const m = &mDNSStorage;
    request_state*  req = client_request_message;
    DNSQuestion*    q = &req->queryrecord->op.q;
    mDNSu32 CacheUsed =0, notUsed =0;
    const uint8_t *data;
    const uint8_t *end;
    char name[kDNSServiceMaxDomainName];
    uint16_t rrtype, rrclass, rdlen;
    const uint8_t *rdata;
    size_t len;
    
    // The uDNS_SetupDNSConfig reconfigures the resolvers so the A record query is restarted and
    // both the CNAME and A record are purged.
    force_uDNS_SetupDNSConfig_ut(m);

    // Verify the A record query was restarted.  This is done indirectly by noticing the transaction id and interval have changed.
    XCTAssertEqual(q->ThisQInterval, InitialQuestionInterval);
    XCTAssertNotEqual(q->TargetQID.NotAnInteger, uDNS_TargetQID);
    
    // Then mDNS_Execute removes both records from the cache and calls the client back with a remove event for A record.
    m->NextScheduledEvent = mDNS_TimeNow_NoLock(m);
    mDNS_Execute(m);
    
    // Verify the cache entries are removed
    LogCacheRecords_ut(mDNS_TimeNow(m), &CacheUsed, &notUsed);
    XCTAssertEqual(CacheUsed, m->rrcache_totalused);
    XCTAssertEqual(CacheUsed, 0);
    
    // Verify the A record's remove event is setup as expected in the reply data
    struct reply_state *reply;
    reply = req->replies;
    XCTAssertNotEqual(reply, (reply_state*)mDNSNULL);
    XCTAssertNotEqual(reply->next, (reply_state*)mDNSNULL);
    XCTAssertNotEqual(reply->next->next, (reply_state*)mDNSNULL);

    reply = reply->next->next; // Get to last event to verify remove event
    data    = (uint8_t *)&reply->rhdr[1];
    end     = data+reply->totallen;
    get_string(&data, data+reply->totallen, name, kDNSServiceMaxDomainName);
    rrtype  = get_uint16(&data, end);
    rrclass = get_uint16(&data, end);
    rdlen   = get_uint16(&data, end);
    rdata   = get_rdata(&data, end, rdlen);
    len     = get_reply_len(name, rdlen);
    
    XCTAssertEqual(reply->totallen, reply->mhdr->datalen + sizeof(ipc_msg_hdr));
    XCTAssertEqual(reply->mhdr->version, VERSION);
    XCTAssertEqual(reply->mhdr->datalen, len);
    XCTAssertEqual(reply->mhdr->ipc_flags, 0);
    XCTAssertEqual(reply->mhdr->op, query_reply_op);
    
    XCTAssertNotEqual(reply->rhdr->flags, htonl(kDNSServiceFlagsAdd));
    XCTAssertEqual(reply->rhdr->ifi, kDNSServiceInterfaceIndexAny);
    XCTAssertEqual(reply->rhdr->error, kDNSServiceErr_NoError);
    
    XCTAssertEqual(rrtype, kDNSType_A);
    XCTAssertEqual(rrclass, kDNSClass_IN);
    XCTAssertEqual(rdata[0], dns_response_ipv4.b[0]);
    XCTAssertEqual(rdata[1], dns_response_ipv4.b[1]);
    XCTAssertEqual(rdata[2], dns_response_ipv4.b[2]);
    XCTAssertEqual(rdata[3], dns_response_ipv4.b[3]);
}

@end
