| /* 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 <dns_sd.h> |
| #include <arpa/inet.h> |
| #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: |
