| /* thread-device.c |
| * |
| * Copyright (c) 2023-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. |
| * |
| * Functionality required to get a Thread device that is already connected to a Thread |
| * mesh to act as an SRP server. |
| */ |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <pwd.h> |
| #include <errno.h> |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| #include <fcntl.h> |
| #include <time.h> |
| #include <dns_sd.h> |
| #include <net/if.h> |
| #include <inttypes.h> |
| #include <sys/resource.h> |
| #include <netinet/icmp6.h> |
| #include <os/feature_private.h> |
| #include "srp.h" |
| #include "dns-msg.h" |
| #include "srp-crypto.h" |
| #include "ioloop.h" |
| #include "srp-gw.h" |
| #include "srp-proxy.h" |
| #include "srp-mdns-proxy.h" |
| #include "dnssd-proxy.h" |
| #include "config-parse.h" |
| #include "cti-services.h" |
| #include "thread-device.h" |
| #include "state-machine.h" |
| #include "thread-service.h" |
| #include "service-tracker.h" |
| #include "service-publisher.h" |
| #include "thread-tracker.h" |
| #include "node-type-tracker.h" |
| #include "dnssd-client.h" |
| |
| static void |
| thread_device_rloc16_callback(void *context, uint16_t rloc16, cti_status_t status) |
| { |
| srp_server_t *server_state = context; |
| |
| if (status != kCTIStatus_NoError) { |
| ERROR("rloc16 get failed with status %d", status); |
| } else { |
| bool start = false; |
| server_state->rloc16 = rloc16; |
| INFO("server_state->rloc16 updated to %d", server_state->rloc16); |
| |
| server_state->srp_on_demand = os_feature_enabled(mDNSResponder, srp_on_demand); |
| INFO("srp on demand is " PUB_S_SRP, server_state->srp_on_demand ? "enabled" : "disabled"); |
| |
| // Now we can start. |
| if (server_state->service_tracker == NULL) { |
| server_state->service_tracker = service_tracker_create(server_state); |
| if (server_state->service_tracker == NULL) { |
| FAULT("can't create service tracker."); |
| return; |
| } |
| start = true; |
| } |
| if (server_state->thread_tracker == NULL) { |
| server_state->thread_tracker = thread_tracker_create(server_state); |
| if (server_state->thread_tracker == NULL) { |
| FAULT("can't create thread tracker."); |
| return; |
| } |
| start = true; |
| } |
| if (server_state->node_type_tracker == NULL) { |
| server_state->node_type_tracker = node_type_tracker_create(server_state); |
| if (server_state->node_type_tracker == NULL) { |
| FAULT("can't create node type tracker."); |
| return; |
| } |
| start = true; |
| } |
| if (server_state->service_publisher == NULL) { |
| server_state->service_publisher = service_publisher_create(server_state); |
| if (server_state->service_publisher == NULL) { |
| FAULT("can't create service publisher."); |
| return; |
| } |
| start = true; |
| } |
| if (server_state->dnssd_client == NULL) { |
| server_state->dnssd_client = dnssd_client_create(server_state); |
| if (server_state->dnssd_client == NULL) { |
| FAULT("can't create dnssd client"); |
| return; |
| } |
| start = true; |
| } |
| if (start) { |
| thread_tracker_start(server_state->thread_tracker); |
| node_type_tracker_start(server_state->node_type_tracker); |
| service_publisher_start(server_state->service_publisher); |
| dnssd_client_start(server_state->dnssd_client); |
| } |
| } |
| } |
| |
| // Start browsing for SRP service, and, if it makes sense, advertise as an SRP server. |
| void |
| thread_device_startup(srp_server_t *NONNULL server_state) |
| { |
| // Just in case we get called without a shutdown having happened, before starting up again, do the |
| // shutdown. This will be a no-op if it has already been done. Don't flush missing services, since we might |
| // get a request for a missing service before we get the thread startup command. |
| thread_device_shutdown(server_state); |
| |
| INFO("starting up"); |
| |
| // Before we can actually do anything, we need our RLOC16. |
| int status = cti_get_rloc16(server_state, &server_state->thread_rloc16_context, server_state, |
| thread_device_rloc16_callback, NULL); |
| if (status != kCTIStatus_NoError) { |
| FAULT("can't get rloc16: %d", status); |
| } |
| } |
| |
| void |
| thread_device_stop(srp_server_t *NONNULL server_state) |
| { |
| INFO("stopping"); |
| if (server_state->service_tracker != NULL) { |
| service_tracker_cancel_probes(server_state->service_tracker); |
| service_tracker_cancel(server_state->service_tracker); |
| service_tracker_release(server_state->service_tracker); |
| server_state->service_tracker = NULL; |
| } |
| if (server_state->thread_tracker != NULL) { |
| thread_tracker_cancel(server_state->thread_tracker); |
| thread_tracker_release(server_state->thread_tracker); |
| server_state->thread_tracker = NULL; |
| } |
| if (server_state->node_type_tracker != NULL) { |
| node_type_tracker_cancel(server_state->node_type_tracker); |
| node_type_tracker_release(server_state->node_type_tracker); |
| server_state->node_type_tracker = NULL; |
| } |
| if (server_state->service_publisher != NULL) { |
| service_publisher_cancel(server_state->service_publisher); |
| service_publisher_release(server_state->service_publisher); |
| server_state->service_publisher = NULL; |
| } |
| if (server_state->dnssd_client != NULL) { |
| dnssd_client_cancel(server_state->dnssd_client); |
| dnssd_client_release(server_state->dnssd_client); |
| server_state->dnssd_client = NULL; |
| } |
| } |
| |
| void |
| thread_device_shutdown(srp_server_t *NONNULL server_state) |
| { |
| INFO("shutting down"); |
| if (server_state->thread_rloc16_context != NULL) { |
| cti_events_discontinue(server_state->thread_rloc16_context); |
| server_state->thread_rloc16_context = NULL; |
| } |
| if (server_state->wed_tracker != NULL) { |
| cti_events_discontinue(server_state->wed_tracker); |
| server_state->wed_tracker = NULL; |
| } |
| thread_device_stop(server_state); |
| } |
| |
| // Local Variables: |
| // mode: C |
| // tab-width: 4 |
| // c-file-style: "bsd" |
| // c-basic-offset: 4 |
| // fill-column: 120 |
| // indent-tabs-mode: nil |
| // End: |
