/* dns-push.c * * Copyright (c) 2024 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 * * https://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. * * This file contains the SRP server test runner. */ #include "srp.h" #include #include #include "srp-test-runner.h" #include "srp-api.h" #include "dns-msg.h" #include "ioloop.h" #include "srp-mdns-proxy.h" #include "test-api.h" #include "srp-proxy.h" #include "srp-mdns-proxy.h" #include "test-dnssd.h" #include "test.h" #include "dnssd-proxy.h" #define DNSMessageHeader dns_wire_t #include "dso.h" #include "dso-utils.h" #define SUBSCRIBE_LIMIT 16 // SOA + SRV + A + AAAA || PTR + SRV + A + AAAA #define TXN_LIMIT SUBSCRIBE_LIMIT * 4 typedef struct push_test_state push_test_state_t; struct push_test_state { test_state_t *test_state; comm_t *dso_connection; wakeup_t *wait_for_remote_disconnect; dso_state_t *disconnect_expected; DNSServiceRef register_ref, ptr_sdref; DNSServiceRef txns[TXN_LIMIT]; int num_txns; uint16_t subscribe_xids[SUBSCRIBE_LIMIT]; int num_subscribe_xids, soa_index, ds_index[2]; char *hostname; char *srv_name; int num_service_adds_pre, num_service_removes, num_service_adds_post; int num_address_adds_pre, num_address_removes, num_address_adds_post; uint16_t keepalive_xid; int variant, num_a_records, num_aaaa_records; int num_txt_records, num_srv_records; bool push_send_bogus_keepalive, push_unsubscribe; bool push_subscribe_sent, have_address_records; bool server_was_crashed, server_is_being_crashed; bool test_dns_push, have_keepalive_response, need_service; }; static void test_dns_push_send_push_subscribe(push_test_state_t *push_state, const char *name, int rrtype); static void test_dns_push_dso_message_finished(void *context, message_t *UNUSED message, dso_state_t *dso) { push_test_state_t *push_state = context; if (dso->primary.opcode == kDSOType_DNSPushUnsubscribe) { if (dso->activities == NULL) { dispatch_async(dispatch_get_main_queue(), ^{ TEST_PASSED(push_state->test_state); }); } } } static void test_dns_push_send_push_unsubscribe(push_test_state_t *push_state, int index) { if (push_state->subscribe_xids[index] != 0) { struct iovec iov; dns_wire_t dns_message; uint8_t *buffer = (uint8_t *)&dns_message; dns_towire_state_t towire; dso_message_t message; INFO("unsubscribe %x %d", push_state->subscribe_xids[index], index); dso_make_message(&message, buffer, sizeof(dns_message), push_state->dso_connection->dso, true, false, 0, 0, NULL); memset(&towire, 0, sizeof(towire)); towire.p = &buffer[DNS_HEADER_SIZE]; towire.lim = towire.p + (sizeof(dns_message) - DNS_HEADER_SIZE); towire.message = &dns_message; dns_u16_to_wire(&towire, kDSOType_DNSPushUnsubscribe); dns_rdlength_begin(&towire); dns_u16_to_wire(&towire, push_state->subscribe_xids[index]); dns_rdlength_end(&towire); memset(&iov, 0, sizeof(iov)); iov.iov_len = towire.p - buffer; iov.iov_base = buffer; ioloop_send_message(push_state->dso_connection, NULL, &iov, 1); push_state->subscribe_xids[index] = 0; // Don't unsubscribe again. } } static void test_dns_push_unsubscribe_all(push_test_state_t *push_state) { struct iovec iov; INFO("unsubscribe"); dns_wire_t dns_message; uint8_t *buffer = (uint8_t *)&dns_message; dns_towire_state_t towire; dso_message_t message; if (!push_state->push_send_bogus_keepalive) { for (int i = 0; i < push_state->num_subscribe_xids; i++) { test_dns_push_send_push_unsubscribe(push_state, i); } } // Send a keepalive message so that we can get the response, since the unsubscribe is not a response-requiring request. dso_make_message(&message, buffer, sizeof(dns_message), push_state->dso_connection->dso, false, false, 0, 0, NULL); memset(&towire, 0, sizeof(towire)); towire.p = &buffer[DNS_HEADER_SIZE]; towire.lim = towire.p + (sizeof(dns_message) - DNS_HEADER_SIZE); towire.message = &dns_message; dns_u16_to_wire(&towire, kDSOType_Keepalive); dns_rdlength_begin(&towire); dns_u32_to_wire(&towire, 600); dns_u32_to_wire(&towire, 600); dns_rdlength_end(&towire); if (push_state->push_send_bogus_keepalive) { INFO("sending bogus keepalive"); // Send a badly formatted message. dns_u32_to_wire(&towire, 0x12345678); } push_state->keepalive_xid = dns_message.id; memset(&iov, 0, sizeof(iov)); iov.iov_len = towire.p - buffer; iov.iov_base = buffer; ioloop_send_message(push_state->dso_connection, NULL, &iov, 1); } static void test_dns_push_remote_disconnect_didnt_happen(void *context) { push_test_state_t *push_state = context; TEST_FAIL(push_state->test_state, "remote disconnect didn't happen"); } static void test_dns_push_handle_retry_delay(push_test_state_t *push_state, dso_state_t *dso, uint32_t delay) { INFO("Got our retry delay, %ums...", delay); push_state->wait_for_remote_disconnect = ioloop_wakeup_create(); TEST_FAIL_CHECK(push_state->test_state, push_state->wait_for_remote_disconnect != NULL, "can't wait for remote disconnect."); // Wait six seconds for remote disconnect, which should happen in five. ioloop_add_wake_event(push_state->wait_for_remote_disconnect, push_state, test_dns_push_remote_disconnect_didnt_happen, NULL, 6 * 1000); push_state->disconnect_expected = dso; } static void test_dns_push_address_update(push_test_state_t *push_state, dns_rr_t *rr, const char *name) { const char *record_name = "AAAA"; char ntop[INET6_ADDRSTRLEN]; int num; if (rr->type == dns_rrtype_a) { num = push_state->num_a_records; if (rr->ttl != 0xffffffff) { ++push_state->num_a_records; } inet_ntop(AF_INET, &rr->data.a, ntop, sizeof(ntop)); record_name = "A"; } else { num = push_state->num_aaaa_records; if (rr->ttl != 0xffffffff) { ++push_state->num_aaaa_records; } inet_ntop(AF_INET6, &rr->data.aaaa, ntop, sizeof(ntop)); } INFO("%s: %s %s record #%d: %s", name, rr->ttl == 0xffffffff ? "removed" : "added", record_name, num, ntop); } static void test_dns_push_update(push_test_state_t *push_state, dns_rr_t *rr) { char name[DNS_MAX_NAME_SIZE_ESCAPED + 1]; dns_name_print(rr->name, name, sizeof(name)); if (rr->type == dns_rrtype_soa) { TEST_FAIL_CHECK_STATUS(push_state->test_state, push_state->variant == PUSH_TEST_VARIANT_HARDWIRED, "SOA received in wrong variant: %s", name); char soaname[DNS_MAX_NAME_SIZE_ESCAPED + 1]; TEST_FAIL_CHECK_STATUS(push_state->test_state, !strcmp(name, "default.service.arpa."), "bad name for SOA: %s", name); dns_name_print(rr->data.soa.mname, soaname, sizeof(soaname)); INFO("%s in SOA %s ...", name, soaname); // Look up the SRV record for _dns-push-tls._tcp.default.service.arpa, so that we can get the hostname but also // validate that the SRV record is being advertised. push_state->srv_name = strdup("_dns-push-tls._tcp.default.service.arpa."); test_dns_push_send_push_subscribe(push_state, push_state->srv_name, dns_rrtype_srv); test_dns_push_send_push_unsubscribe(push_state, push_state->soa_index); } else if (rr->type == dns_rrtype_a || rr->type == dns_rrtype_aaaa) { test_dns_push_address_update(push_state, rr, name); if (push_state->server_was_crashed) { if (rr->ttl == 0xffffffff) { push_state->num_address_removes++; } else { push_state->num_address_adds_post++; } } else { push_state->num_address_adds_pre++; } } else if (rr->type == dns_rrtype_ptr) { TEST_FAIL_CHECK_STATUS(push_state->test_state, push_state->variant != PUSH_TEST_VARIANT_HARDWIRED, "PTR received in wrong variant: %s", name); TEST_FAIL_CHECK_STATUS(push_state->test_state, !strcmp(name, "_example._tcp.default.service.arpa."), "bad name for PTR: %s", name); char ptrname[DNS_MAX_NAME_SIZE_ESCAPED + 1]; dns_name_print(rr->data.ptr.name, ptrname, sizeof(ptrname)); INFO("%s %s IN PTR %s", rr->ttl == 0xffffffff ? "removed" : "added", name, ptrname); if (push_state->srv_name == NULL) { push_state->srv_name = strdup(ptrname); test_dns_push_send_push_subscribe(push_state, push_state->srv_name, dns_rrtype_srv); } if (push_state->server_was_crashed) { if (rr->ttl == 0xffffffff) { push_state->num_service_removes++; } else { push_state->num_service_adds_post++; } } else { push_state->num_service_adds_pre++; } } else if (rr->type == dns_rrtype_srv) { char hnbuf[DNS_MAX_NAME_SIZE_ESCAPED + 1]; dns_name_print(rr->data.ptr.name, hnbuf, sizeof(hnbuf)); INFO("%s IN SRV %s ...", name, hnbuf); TEST_FAIL_CHECK_STATUS(push_state->test_state, !strcmp(name, push_state->srv_name), "bad name for SRV: %s", name); // Look up address records for SOA name server name. if (push_state->hostname == NULL) { push_state->hostname = strdup(hnbuf); TEST_FAIL_CHECK_STATUS(push_state->test_state, push_state->hostname != NULL, "no memory for %s", hnbuf); dispatch_async(dispatch_get_main_queue(), ^{ test_dns_push_send_push_subscribe(push_state, push_state->hostname, dns_rrtype_a); }); dispatch_async(dispatch_get_main_queue(), ^{ test_dns_push_send_push_subscribe(push_state, push_state->hostname, dns_rrtype_aaaa); }); // At this point the DS queries should have been started, so we can remove them and make sure that works. if (push_state->variant == PUSH_TEST_VARIANT_HARDWIRED) { test_dns_push_send_push_unsubscribe(push_state, push_state->ds_index[0]); test_dns_push_send_push_unsubscribe(push_state, push_state->ds_index[1]); } } push_state->num_srv_records++; } else if (rr->type == dns_rrtype_txt) { char txt_buf[DNS_DATA_SIZE]; dns_txt_data_print(txt_buf, DNS_DATA_SIZE, rr->data.txt.len, rr->data.txt.data); INFO("%s IN TXT %s ...", name, txt_buf); push_state->num_txt_records++; } else { INFO("unexpected rrtype for %s in push update: %d", name, rr->type); } } static void test_dns_push_send_appropriate_subscribe(push_test_state_t *push_state) { if (push_state->variant == PUSH_TEST_VARIANT_HARDWIRED) { push_state->soa_index = push_state->num_subscribe_xids; test_dns_push_send_push_subscribe(push_state, "default.service.arpa", dns_rrtype_soa); push_state->ds_index[0] = push_state->num_subscribe_xids; test_dns_push_send_push_subscribe(push_state, "default.service.arpa", dns_rrtype_ds); push_state->ds_index[1] = push_state->num_subscribe_xids; test_dns_push_send_push_subscribe(push_state, "default.service.arpa", dns_rrtype_ds); } else { test_dns_push_send_push_subscribe(push_state, "_example._tcp.default.service.arpa", dns_rrtype_ptr); } push_state->push_subscribe_sent = true; } static void test_dns_push_satisfied_check(push_test_state_t *push_state) { // Check to see if we have all the address records we wanted. if (!push_state->have_address_records) { bool satisfied; switch(push_state->variant) { case PUSH_TEST_VARIANT_HARDWIRED: satisfied = push_state->num_a_records != 0 && push_state->num_aaaa_records != 0; break; case PUSH_TEST_VARIANT_DAEMON_CRASH: case PUSH_TEST_VARIANT_MDNS: satisfied = push_state->num_a_records != 0 || push_state->num_aaaa_records != 0; break; case PUSH_TEST_VARIANT_TWO_QUESTIONS: satisfied = push_state->num_srv_records > 0 && push_state->num_txt_records > 0; break; default: satisfied = false; } if (satisfied && push_state->variant == PUSH_TEST_VARIANT_DAEMON_CRASH) { if (!push_state->server_was_crashed) { // If the server hasn't been crashed yet // And we haven't already queued up a crash event if (!push_state->server_is_being_crashed) { push_state->server_is_being_crashed = true; // Queue up a crash event dispatch_after(dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 2), dispatch_get_main_queue(), ^{ push_state->server_was_crashed = true; push_state->num_a_records = push_state->num_aaaa_records = 0; dns_service_ref_t *ref = push_state->ptr_sdref; TEST_FAIL_CHECK(push_state->test_state, ref != NULL, "ptr sdref is gone!"); for (int i = 0; i < push_state->num_txns; i++) { DNSServiceRefDeallocate(push_state->txns[i]); } DNSServiceQueryRecordReply callback = ref->callback.query_record_reply; callback(ref, 0, 0, kDNSServiceErr_ServiceNotRunning, NULL, dns_rrtype_ptr, dns_qclass_in, 0, 0, 0, ref->context); }); } satisfied = false; } else { if (push_state->num_address_removes != push_state->num_address_adds_pre) { satisfied = false; } if (push_state->num_address_adds_pre != push_state->num_address_adds_post) { satisfied = false; } INFO("address removes: %d address adds pre: %d address adds post: %d", push_state->num_address_removes, push_state->num_address_adds_pre, push_state->num_address_adds_post); if (push_state->num_service_removes != push_state->num_service_adds_pre) { satisfied = false; } INFO("service removes: %d service adds pre: %d service adds post: %d", push_state->num_service_removes, push_state->num_service_adds_pre, push_state->num_service_adds_post); } } if (satisfied) { push_state->have_address_records = true; // If we've been asked to unsubscribe, do that. if (push_state->push_unsubscribe) { test_dns_push_unsubscribe_all(push_state); } else { // Finish any ongoing activities first... dispatch_async(dispatch_get_main_queue(), ^{ TEST_PASSED(push_state->test_state); }); } } } } static void test_dns_push_dns_response(push_test_state_t *push_state, message_t *message) { unsigned offset, max; dns_rr_t rr; uint8_t *message_bytes; bool question = true; int rdata_num = 0; int num_answers = ntohs(message->wire.ancount); message_bytes = (uint8_t *)message->wire.data; offset = 0; max = message->length - DNS_HEADER_SIZE; int rr_index = 0; int qdcount = ntohs(message->wire.qdcount); while (offset < max) { INFO("%d %d", offset, max); if (rr_index >= qdcount) { question = false; } if (!dns_rr_parse(&rr, message_bytes, max, &offset, !question, true)) { TEST_FAIL_STATUS(push_state->test_state, "dns RR parse failed on rr %d", rr_index); break; } if (!question) { if (rdata_num < num_answers) { test_dns_push_update(push_state, &rr); rdata_num++; } } dns_name_free(rr.name); rr.name = NULL; dns_rrdata_free(&rr); rr_index++; } test_dns_push_satisfied_check(push_state); } static void test_dns_push_dso_message(push_test_state_t *push_state, message_t *message, dso_state_t *dso, bool response) { unsigned offset, max; dns_rr_t rr; uint8_t *message_bytes; switch(dso->primary.opcode) { case kDSOType_RetryDelay: if (response) { TEST_FAIL(push_state->test_state, "server sent a retry delay TLV as a response."); } dso_retry_delay(dso, &message->wire); break; case kDSOType_Keepalive: if (response) { TEST_FAIL_STATUS(push_state->test_state, "keepalive response from server, rcode = %d", dns_rcode_get(&message->wire)); } else { INFO("Keepalive from server"); } // We need to wait for the first keepalive response before sending a DNS push subscribe, since until we get // it we don't have a session. So this actually kicks off the first (possibly only) DNS Push subscribe in the // test. if (!push_state->push_subscribe_sent) { push_state->have_keepalive_response = true; if (!push_state->need_service) { test_dns_push_send_appropriate_subscribe(push_state); } } break; case kDSOType_DNSPushSubscribe: if (response) { // This is a protocol error--the response isn't supposed to contain a primary TLV. TEST_FAIL_STATUS(push_state->test_state, "DNS Push response from server, rcode = %d", dns_rcode_get(&message->wire)); } else { INFO("Unexpected DNS Push request from server, rcode = %d", dns_rcode_get(&message->wire)); } break; case kDSOType_DNSPushUpdate: // DNS Push Updates are never responses. // DNS Push updates are compressed, so we can't just parse data out of the primary--we need to align // our parse with the start of the message data. message_bytes = (uint8_t *)message->wire.data; offset = (unsigned)(dso->primary.payload - message_bytes); // difference can never be greater than sizeof(message->wire). max = offset + dso->primary.length; while (offset < max) { if (!dns_rr_parse(&rr, message_bytes, max, &offset, true, true)) { // Should have emitted an error earlier break; } test_dns_push_update(push_state, &rr); dns_name_free(rr.name); rr.name = NULL; dns_rrdata_free(&rr); } test_dns_push_satisfied_check(push_state); break; case kDSOType_NoPrimaryTLV: // No Primary TLV if (response) { bool subscribe_acked = false; for (int i = 0; i < push_state->num_subscribe_xids; i++) { if (message->wire.id == htons(push_state->subscribe_xids[i])) { int rcode = dns_rcode_get(&message->wire); INFO("DNS Push Subscribe response from server, rcode = %d", rcode); if (rcode != dns_rcode_noerror) { TEST_FAIL_STATUS(push_state->test_state, "subscribe for %x failed", push_state->subscribe_xids[i]); } subscribe_acked = true; } } if (subscribe_acked) { } else if (message->wire.id == push_state->keepalive_xid) { int rcode = dns_rcode_get(&message->wire); INFO("DNS Keepalive response from server, rcode = %d", rcode); exit(0); } else { int rcode = dns_rcode_get(&message->wire); INFO("Unexpected DSO response from server, rcode = %d", rcode); } } else { INFO("DSO request with no primary TLV."); exit(1); } break; default: INFO("dso_message: unexpected primary TLV %d", dso->primary.opcode); dso_simple_response(push_state->dso_connection, NULL, &message->wire, dns_rcode_dsotypeni); break; } } static void test_dns_push_dso_event_callback(void *context, void *event_context, dso_state_t *dso, dso_event_type_t eventType) { push_test_state_t *push_state = context; message_t *message; dso_query_receive_context_t *response_context; dso_disconnect_context_t *disconnect_context; switch(eventType) { case kDSOEventType_DNSMessage: // We shouldn't get here because we already handled any DNS messages message = event_context; INFO("DNS Message (opcode=%d) received from " PRI_S_SRP, dns_opcode_get(&message->wire), dso->remote_name); break; case kDSOEventType_DNSResponse: // We shouldn't get here because we already handled any DNS messages message = event_context; INFO("DNS Response (opcode=%d) received from " PRI_S_SRP, dns_opcode_get(&message->wire), dso->remote_name); break; case kDSOEventType_DSOMessage: INFO("DSO Message (Primary TLV=%d) received from " PRI_S_SRP, dso->primary.opcode, dso->remote_name); message = event_context; test_dns_push_dso_message(push_state, message, dso, false); break; case kDSOEventType_DSOResponse: INFO("DSO Response (Primary TLV=%d) received from " PRI_S_SRP, dso->primary.opcode, dso->remote_name); response_context = event_context; message = response_context->message_context; test_dns_push_dso_message(push_state, message, dso, true); break; case kDSOEventType_Finalize: INFO("Finalize"); break; case kDSOEventType_Connected: INFO("Connected to " PRI_S_SRP, dso->remote_name); break; case kDSOEventType_ConnectFailed: INFO("Connection to " PRI_S_SRP " failed", dso->remote_name); break; case kDSOEventType_Disconnected: INFO("Connection to " PRI_S_SRP " disconnected", dso->remote_name); if (dso == push_state->disconnect_expected) { INFO("remote end disconnected as expected."); exit(0); } break; case kDSOEventType_ShouldReconnect: INFO("Connection to " PRI_S_SRP " should reconnect (not for a server)", dso->remote_name); break; case kDSOEventType_Inactive: INFO("Inactivity timer went off, closing connection."); break; case kDSOEventType_Keepalive: INFO("should send a keepalive now."); break; case kDSOEventType_KeepaliveRcvd: if (!push_state->push_subscribe_sent && !push_state->need_service) { test_dns_push_send_appropriate_subscribe(push_state); } else { push_state->have_keepalive_response = true; } INFO("keepalive received."); break; case kDSOEventType_RetryDelay: disconnect_context = event_context; INFO("retry delay received, %d seconds", disconnect_context->reconnect_delay); test_dns_push_handle_retry_delay(push_state, dso, disconnect_context->reconnect_delay); break; } } static void test_dns_push_send_push_subscribe(push_test_state_t *push_state, const char *name, int rrtype) { struct iovec iov; dns_wire_t dns_message; uint8_t *buffer = (uint8_t *)&dns_message; dns_towire_state_t towire; dso_message_t message; int i = push_state->num_subscribe_xids; if (i >= SUBSCRIBE_LIMIT) { TEST_FAIL_STATUS(push_state->test_state, "subscribe xid limit reached: %d", i); } push_state->num_subscribe_xids++; if (push_state->test_dns_push) { // DNS Push subscription dso_make_message(&message, buffer, sizeof(dns_message), push_state->dso_connection->dso, false, false, 0, 0, NULL); push_state->subscribe_xids[i] = ntohs(dns_message.id); INFO("push subscribe for %s, rrtype %d, xid %x, num %d", name, rrtype, push_state->subscribe_xids[i], i); memset(&towire, 0, sizeof(towire)); towire.p = &buffer[DNS_HEADER_SIZE]; towire.lim = towire.p + (sizeof(dns_message) - DNS_HEADER_SIZE); towire.message = &dns_message; dns_u16_to_wire(&towire, kDSOType_DNSPushSubscribe); dns_rdlength_begin(&towire); dns_full_name_to_wire(NULL, &towire, name); dns_u16_to_wire(&towire, rrtype); dns_u16_to_wire(&towire, dns_qclass_in); dns_rdlength_end(&towire); } else { // Regular DNS query memset(&dns_message, 0, sizeof(dns_message)); dns_message.id = htons((uint16_t)srp_random16()); dns_qr_set(&dns_message, 0); // query dns_opcode_set(&dns_message, dns_opcode_query); int num_questions; if (rrtype == dns_rrtype_srv && push_state->variant == PUSH_TEST_VARIANT_TWO_QUESTIONS) { num_questions = 2; } else { num_questions = 1; } dns_message.qdcount = htons(num_questions); memset(&towire, 0, sizeof(towire)); towire.p = &buffer[DNS_HEADER_SIZE]; towire.lim = towire.p + (sizeof(dns_message) - DNS_HEADER_SIZE); towire.message = &dns_message; dns_name_pointer_t np; dns_full_name_to_wire(&np, &towire, name); dns_u16_to_wire(&towire, rrtype); dns_u16_to_wire(&towire, dns_qclass_in); if (num_questions == 2) { dns_pointer_to_wire(NULL, &towire, &np); dns_u16_to_wire(&towire, dns_rrtype_txt); dns_u16_to_wire(&towire, dns_qclass_in); } push_state->subscribe_xids[i] = ntohs(dns_message.id); INFO("DNS query for %s, rrtype %d, xid %x, num %d", name, rrtype, push_state->subscribe_xids[i], i); } memset(&iov, 0, sizeof(iov)); iov.iov_len = towire.p - buffer; iov.iov_base = buffer; ioloop_send_message(push_state->dso_connection, NULL, &iov, 1); } static void test_dns_push_connected(comm_t *connection, void *context) { push_test_state_t *push_state = context; struct iovec iov; INFO("connected"); connection->dso = dso_state_create(false, 3, connection->name, test_dns_push_dso_event_callback, push_state, NULL, push_state->dso_connection); if (connection->dso == NULL) { ERROR("can't create dso state object."); exit(1); } dns_wire_t dns_message; uint8_t *buffer = (uint8_t *)&dns_message; dns_towire_state_t towire; dso_message_t message; dso_make_message(&message, buffer, sizeof(dns_message), connection->dso, false, false, 0, 0, NULL); memset(&towire, 0, sizeof(towire)); towire.p = &buffer[DNS_HEADER_SIZE]; towire.lim = towire.p + (sizeof(dns_message) - DNS_HEADER_SIZE); towire.message = &dns_message; dns_u16_to_wire(&towire, kDSOType_Keepalive); dns_rdlength_begin(&towire); dns_u32_to_wire(&towire, 100); // Inactivity timeout dns_u32_to_wire(&towire, 100); // Keepalive interval dns_rdlength_end(&towire); memset(&iov, 0, sizeof(iov)); iov.iov_len = towire.p - buffer; iov.iov_base = buffer; ioloop_send_message(push_state->dso_connection, NULL, &iov, 1); } static void test_dns_push_disconnected(comm_t *UNUSED connection, void *context, int UNUSED error) { push_test_state_t *push_state = context; TEST_FAIL(push_state->test_state, "push server disconnect."); } static void test_dns_push_datagram_callback(comm_t *connection, message_t *message, void *context) { push_test_state_t *push_state = context; // If this is a DSO message, see if we have a session yet. switch(dns_opcode_get(&message->wire)) { case dns_opcode_query: test_dns_push_dns_response(push_state, message); return; case dns_opcode_dso: if (connection->dso == NULL) { INFO("dso message received with no DSO object on connection " PRI_S_SRP, connection->name); exit(1); } dso_message_received(connection->dso, (uint8_t *)&message->wire, message->length, message); return; } INFO("datagram on connection " PRI_S_SRP " not handled, type = %d.", connection->name, dns_opcode_get(&message->wire)); } static void test_dns_push_ready(void *context, uint16_t UNUSED port) { push_test_state_t *push_state = context; test_state_t *state = push_state->test_state; addr_t address; memset(&address, 0, sizeof(address)); address.sa.sa_family = AF_INET; address.sin.sin_port = htons(8530); address.sin.sin_addr.s_addr = htonl(0x7f000001); // localhost. // tls, stream, stable, opportunistic push_state->dso_connection = ioloop_connection_create(&address, true, true, true, true, test_dns_push_datagram_callback, test_dns_push_connected, test_dns_push_disconnected, NULL, push_state); TEST_FAIL_CHECK(state, push_state->dso_connection != NULL, "Unable to create dso connection."); } static bool test_listen_longevity_dnssd_proxy_configure(void) { dnssd_proxy_udp_port= 53000; dnssd_proxy_tcp_port = 53000; dnssd_proxy_tls_port = 8530; return true; } static bool test_dns_push_query_callback_intercept(DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *fullname, uint16_t rrtype, uint16_t rrclass, uint16_t rdlen, const void *vrdata, uint32_t ttl, void *context) { dns_service_ref_t *ref = sdRef; const uint8_t *rdata = vrdata; const uint8_t *new_rdata = rdata; uint8_t rdbuf[16]; if (rrtype == dns_rrtype_a) { if (rdata[0] == 169 && rdata[1] == 254) { new_rdata = rdbuf; rdbuf[0] = 10; rdbuf[1] = 255; rdbuf[2] = rdata[2]; rdbuf[3] = rdata[3]; } } else if (rrtype == dns_rrtype_aaaa) { if (rdata[0] == 0xfe && rdata[1] == 0x80) { new_rdata = rdbuf; rdbuf[0] = 0xfc; // Change to unused 0xFC address space memcpy(&rdbuf[1], rdata + 1, 15); // Keep the rest. } } DNSServiceQueryRecordReply callback = ref->callback.query_record_reply; callback(ref, flags, interfaceIndex, errorCode, fullname, rrtype, rrclass, rdlen, new_rdata, ttl, context); return false; } static void test_dns_push_register_example_service(push_test_state_t *push_state); static void test_dns_push_register_callback(const DNSServiceRef UNUSED sd_ref, const DNSServiceFlags UNUSED flags, const DNSServiceErrorType error, const char *const name, const char *const reg_type, const char *const domain, void *const context) { push_test_state_t *push_state = context; test_state_t *state = push_state->test_state; if (error == kDNSServiceErr_ServiceNotRunning) { INFO("example service deregistered due to server exit"); dispatch_after(dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC / 10), // 100ms dispatch_get_main_queue(), ^{ test_dns_push_register_example_service(push_state); }); } else { TEST_FAIL_CHECK_STATUS(state, error == kDNSServiceErr_NoError, "example service registration failed: %d", error); INFO("example service registered successfully -- %s.%s%s", name, reg_type, domain); if (push_state->need_service) { push_state->need_service = false; if (push_state->have_keepalive_response) { test_dns_push_send_appropriate_subscribe(push_state); } } } } static void test_dns_push_register_example_service(push_test_state_t *push_state) { uint8_t txt_data[] = { 0x08, 0x53, 0x49, 0x49, 0x3D, 0x35, 0x30, 0x30, 0x30, 0x07, 0x53, 0x41, 0x49, 0x3D, 0x33, 0x30, 0x30, 0x03, 0x54, 0x3D, 0x30 }; int ret = DNSServiceRegister(&push_state->register_ref, 0, kDNSServiceInterfaceIndexAny, NULL, "_example._tcp", NULL, NULL, 12345, sizeof(txt_data), txt_data, test_dns_push_register_callback, push_state); TEST_FAIL_CHECK(push_state->test_state, ret == kDNSServiceErr_NoError, "failed to register example service."); DNSServiceSetDispatchQueue(push_state->register_ref, dispatch_get_main_queue()); } static DNSServiceErrorType test_dns_push_crash_intercept(test_state_t *state, DNSServiceRef *sdRef, DNSServiceFlags flags, uint32_t interfaceIndex, const char *fullname, uint16_t rrtype, uint16_t rrclass, DNSServiceAttribute const *attr, DNSServiceQueryRecordReply callBack, void UNUSED *context) { dns_service_ref_t *ref = context; DNSServiceErrorType status = DNSServiceQueryRecordWithAttribute(sdRef, flags, interfaceIndex, fullname, rrtype, rrclass, attr, callBack, ref); // We're going to signal the daemon crash on the PTR query. push_test_state_t *push_state = state->context; if (status == kDNSServiceErr_NoError && rrtype == dns_rrtype_ptr) { push_state->ptr_sdref = ref; } else { if (push_state->num_txns < TXN_LIMIT) { push_state->txns[push_state->num_txns++] = ref; } } return status; } void test_dns_push(test_state_t *next_test, int variant) { extern srp_server_t *srp_servers; test_state_t *state = NULL; bool register_example_service = false; bool push = true; if (variant == PUSH_TEST_VARIANT_HARDWIRED) { const char *hardwired = " The goal of this test is to create DNS Push connection to the test server and attempt to\n" " look up a name that goes through the hardwired query path. If we get a response, the test\n" " succeeded."; state = test_state_create(srp_servers, "DNS Push Hardwired test", NULL, hardwired, NULL); } else if (variant == PUSH_TEST_VARIANT_MDNS) { const char *mdns = " The goal of this test is to create DNS Push connection to the test server and attempt to\n" " look up a name that goes through the local (mDNS) query path. If we get a response, the test\n" " succeeded."; state = test_state_create(srp_servers, "DNS Push Local test", NULL, mdns, NULL); register_example_service = true; } else if (variant == PUSH_TEST_VARIANT_DNS_MDNS) { const char *mdns = " The goal of this test is to create DSO connection to the test server and send a DNS query to\n" " look up a name that goes through the local (mDNS) query path. If we get a response, the test\n" " succeeded."; state = test_state_create(srp_servers, "DNS Local test", NULL, mdns, NULL); register_example_service = true; push = false; variant = PUSH_TEST_VARIANT_MDNS; } else if (variant == PUSH_TEST_VARIANT_TWO_QUESTIONS) { const char *two = " The goal of this test is to create DSO connection to the test server and send a DNS query with\n" " two questions on the same name, for a TXT and an SRV record. We will register a matter service to\n" " discover. If we get a well-formed response with answers for both service types, the test\n" " succeeded."; state = test_state_create(srp_servers, "DNS Local two-question test", NULL, two, NULL); register_example_service = true; push = false; variant = PUSH_TEST_VARIANT_TWO_QUESTIONS; } else if (variant == PUSH_TEST_VARIANT_DNS_HARDWIRED) { const char *hardwired = " The goal of this test is to create DSO connection to the test server and send a DNS query that\n" " looks up a name that goes through the hardwired query path. If we get a response, the test\n" " succeeded."; state = test_state_create(srp_servers, "DNS query Hardwired test", NULL, hardwired, NULL); push = false; variant = PUSH_TEST_VARIANT_HARDWIRED; } else if (variant == PUSH_TEST_VARIANT_DNS_CRASH) { const char *crash = " The goal of this test is to create DSO connection to the test server and attempt to\n" " look up a name that goes through the local (mDNS) query path. Once we have a result, we fake\n" " an mDNSResponder crash and make sure the query is successfully restarted."; state = test_state_create(srp_servers, "DNS query daemon crash test", NULL, crash, NULL); state->query_record_intercept = test_dns_push_crash_intercept; register_example_service = true; variant = PUSH_TEST_VARIANT_DAEMON_CRASH; push = false; } else if (variant == PUSH_TEST_VARIANT_DAEMON_CRASH) { const char *crash = " The goal of this test is to create DNS Push connection to the test server and attempt to\n" " look up a name that goes through the local (mDNS) query path. Once we have a result, we fake\n" " an mDNSResponder crash and make sure the query is successfully restarted."; state = test_state_create(srp_servers, "DNS Push daemon crash test", NULL, crash, NULL); state->query_record_intercept = test_dns_push_crash_intercept; register_example_service = true; } state->next = next_test; push_test_state_t *push_state = calloc(1, sizeof (*push_state)); TEST_FAIL_CHECK(state, push_state != NULL, "no memory for test-specific state."); state->context = push_state; push_state->test_state = state; push_state->variant = variant; push_state->test_dns_push = push; // Might as well always test push_state->push_unsubscribe = true; srp_test_dnssd_tls_listener_ready = test_dns_push_ready; srp_test_tls_listener_context = push_state; srp_test_dso_message_finished = test_dns_push_dso_message_finished; srp_proxy_init("local"); srp_test_enable_stub_router(state, srp_servers); state->dns_service_query_callback_intercept = test_dns_push_query_callback_intercept; state->dnssd_proxy_configurer = test_listen_longevity_dnssd_proxy_configure; TEST_FAIL_CHECK(state, init_dnssd_proxy(srp_servers), "failed to setup dnssd-proxy"); if (register_example_service) { push_state->need_service = true; test_dns_push_register_example_service(push_state); } // Test should not take longer than ten seconds. srp_test_state_add_timeout(state, 20); } // Local Variables: // mode: C // tab-width: 4 // c-file-style: "bsd" // c-basic-offset: 4 // fill-column: 108 // indent-tabs-mode: nil // End: