HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd-network/sd-dhcp6-client.c

52,870 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: b78d1c29ecd29aa0ae0c20d2f59d4428e346dcca

Lines 1001–1594 of 1,594

 
static int client_timeout_expire(sd_event_source *s, uint64_t usec, void *userdata) {
        sd_dhcp6_client *client = ASSERT_PTR(userdata);
        DHCP6_CLIENT_DONT_DESTROY(client);
        DHCP6State state;
 
        (void) event_source_disable(client->timeout_expire);
        (void) event_source_disable(client->timeout_t2);
        (void) event_source_disable(client->timeout_t1);
 
        state = client->state;
 
        client_stop(client, SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE);
 
        /* RFC 3315, section 18.1.4., says that "...the client may choose to
           use a Solicit message to locate a new DHCP server..." */
        if (state == DHCP6_STATE_REBIND)
                (void) client_start_transaction(client, DHCP6_STATE_SOLICITATION);
 
        return 0;
}
 
static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) {
        sd_dhcp6_client *client = ASSERT_PTR(userdata);
 
        (void) event_source_disable(client->timeout_t2);
        (void) event_source_disable(client->timeout_t1);
 
        log_dhcp6_client(client, "Timeout T2");
 
        (void) client_start_transaction(client, DHCP6_STATE_REBIND);
 
        return 0;
}
 
static int client_timeout_t1(sd_event_source *s, uint64_t usec, void *userdata) {
        sd_dhcp6_client *client = ASSERT_PTR(userdata);
 
        (void) event_source_disable(client->timeout_t1);
 
        log_dhcp6_client(client, "Timeout T1");
 
        (void) client_start_transaction(client, DHCP6_STATE_RENEW);
 
        return 0;
}
 
static int client_enter_bound_state(sd_dhcp6_client *client) {
        usec_t lifetime_t1, lifetime_t2, lifetime_valid;
        int r;
 
        assert(client);
        assert(client->lease);
        assert(IN_SET(client->state,
                      DHCP6_STATE_SOLICITATION,
                      DHCP6_STATE_REQUEST,
                      DHCP6_STATE_RENEW,
                      DHCP6_STATE_REBIND));
 
        (void) event_source_disable(client->receive_message);
        (void) event_source_disable(client->timeout_resend);
 
        r = sd_dhcp6_lease_get_t1(client->lease, &lifetime_t1);
        if (r < 0)
                goto error;
 
        r = sd_dhcp6_lease_get_t2(client->lease, &lifetime_t2);
        if (r < 0)
                goto error;
 
        r = sd_dhcp6_lease_get_valid_lifetime(client->lease, &lifetime_valid);
        if (r < 0)
                goto error;
 
        lifetime_t2 = client_timeout_compute_random(lifetime_t2);
        lifetime_t1 = client_timeout_compute_random(MIN(lifetime_t1, lifetime_t2));
 
        if (lifetime_t1 == USEC_INFINITY) {
                log_dhcp6_client(client, "Infinite T1");
                event_source_disable(client->timeout_t1);
        } else {
                log_dhcp6_client(client, "T1 expires in %s", FORMAT_TIMESPAN(lifetime_t1, USEC_PER_SEC));
                r = event_reset_time_relative(client->event, &client->timeout_t1,
                                              CLOCK_BOOTTIME,
                                              lifetime_t1, 10 * USEC_PER_SEC,
                                              client_timeout_t1, client,
                                              client->event_priority, "dhcp6-t1-timeout", true);
                if (r < 0)
                        goto error;
        }
 
        if (lifetime_t2 == USEC_INFINITY) {
                log_dhcp6_client(client, "Infinite T2");
                event_source_disable(client->timeout_t2);
        } else {
                log_dhcp6_client(client, "T2 expires in %s", FORMAT_TIMESPAN(lifetime_t2, USEC_PER_SEC));
                r = event_reset_time_relative(client->event, &client->timeout_t2,
                                              CLOCK_BOOTTIME,
                                              lifetime_t2, 10 * USEC_PER_SEC,
                                              client_timeout_t2, client,
                                              client->event_priority, "dhcp6-t2-timeout", true);
                if (r < 0)
                        goto error;
        }
 
        if (lifetime_valid == USEC_INFINITY) {
                log_dhcp6_client(client, "Infinite valid lifetime");
                event_source_disable(client->timeout_expire);
        } else {
                log_dhcp6_client(client, "Valid lifetime expires in %s", FORMAT_TIMESPAN(lifetime_valid, USEC_PER_SEC));
 
                r = event_reset_time_relative(client->event, &client->timeout_expire,
                                              CLOCK_BOOTTIME,
                                              lifetime_valid, USEC_PER_SEC,
                                              client_timeout_expire, client,
                                              client->event_priority, "dhcp6-lease-expire", true);
                if (r < 0)
                        goto error;
        }
 
        client_set_state(client, DHCP6_STATE_BOUND);
        client_notify(client, SD_DHCP6_CLIENT_EVENT_IP_ACQUIRE);
        return 0;
 
error:
        client_stop(client, r);
        return r;
}
 
static int log_invalid_message_type(sd_dhcp6_client *client, const DHCP6Message *message) {
        const char *type_str;
 
        assert(client);
        assert(message);
 
        type_str = dhcp6_message_type_to_string(message->type);
        if (type_str)
                return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
                                              "Received unexpected %s message, ignoring.", type_str);
        else
                return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
                                              "Received unsupported message type %u, ignoring.", message->type);
}
 
static int client_process_information(
                sd_dhcp6_client *client,
                DHCP6Message *message,
                size_t len,
                const triple_timestamp *timestamp,
                const struct in6_addr *server_address) {
 
        _cleanup_(sd_dhcp6_lease_unrefp) sd_dhcp6_lease *lease = NULL;
        int r;
 
        assert(client);
        assert(message);
 
        if (message->type != DHCP6_MESSAGE_REPLY)
                return log_invalid_message_type(client, message);
 
        r = dhcp6_lease_new_from_message(client, message, len, timestamp, server_address, &lease);
        if (r < 0)
                return log_dhcp6_client_errno(client, r, "Failed to process received reply message, ignoring: %m");
 
        log_dhcp6_client(client, "Processed %s message", dhcp6_message_type_to_string(message->type));
 
        sd_dhcp6_lease_unref(client->lease);
        client->lease = TAKE_PTR(lease);
 
        /* Do not call client_stop() here, as it frees the acquired lease. */
        (void) event_source_disable(client->receive_message);
        (void) event_source_disable(client->timeout_resend);
        client_set_state(client, DHCP6_STATE_STOPPED);
 
        client_notify(client, SD_DHCP6_CLIENT_EVENT_INFORMATION_REQUEST);
        return 0;
}
 
static int client_process_reply(
                sd_dhcp6_client *client,
                DHCP6Message *message,
                size_t len,
                const triple_timestamp *timestamp,
                const struct in6_addr *server_address) {
 
        _cleanup_(sd_dhcp6_lease_unrefp) sd_dhcp6_lease *lease = NULL;
        int r;
 
        assert(client);
        assert(message);
 
        if (message->type != DHCP6_MESSAGE_REPLY)
                return log_invalid_message_type(client, message);
 
        r = dhcp6_lease_new_from_message(client, message, len, timestamp, server_address, &lease);
        if (r == -EADDRNOTAVAIL) {
 
                /* If NoBinding status code is received, we cannot request the address anymore.
                 * Let's restart transaction from the beginning. */
 
                if (client->state == DHCP6_STATE_REQUEST)
                        /* The lease is not acquired yet, hence it is not necessary to notify the restart. */
                        client_cleanup(client);
                else
                        /* We need to notify the previous lease was expired. */
                        client_stop(client, SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE);
 
                return client_start_transaction(client, DHCP6_STATE_SOLICITATION);
        }
        if (r < 0)
                return log_dhcp6_client_errno(client, r, "Failed to process received reply message, ignoring: %m");
 
        log_dhcp6_client(client, "Processed %s message", dhcp6_message_type_to_string(message->type));
 
        sd_dhcp6_lease_unref(client->lease);
        client->lease = TAKE_PTR(lease);
 
        return client_enter_bound_state(client);
}
 
static int client_process_advertise_or_rapid_commit_reply(
                sd_dhcp6_client *client,
                DHCP6Message *message,
                size_t len,
                const triple_timestamp *timestamp,
                const struct in6_addr *server_address) {
 
        _cleanup_(sd_dhcp6_lease_unrefp) sd_dhcp6_lease *lease = NULL;
        uint8_t pref_advertise, pref_lease = 0;
        int r;
 
        assert(client);
        assert(message);
 
        if (!IN_SET(message->type, DHCP6_MESSAGE_ADVERTISE, DHCP6_MESSAGE_REPLY))
                return log_invalid_message_type(client, message);
 
        r = dhcp6_lease_new_from_message(client, message, len, timestamp, server_address, &lease);
        if (r < 0)
                return log_dhcp6_client_errno(client, r, "Failed to process received %s message, ignoring: %m",
                                              dhcp6_message_type_to_string(message->type));
 
        if (message->type == DHCP6_MESSAGE_REPLY) {
                bool rapid_commit;
 
                if (!client->rapid_commit)
                        return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
                                                      "Received unexpected reply message, even we sent a solicit message without the rapid commit option, ignoring.");
 
                r = dhcp6_lease_get_rapid_commit(lease, &rapid_commit);
                if (r < 0)
                        return r;
 
                if (!rapid_commit)
                        return log_dhcp6_client_errno(client, SYNTHETIC_ERRNO(EINVAL),
                                                      "Received reply message without rapid commit flag, ignoring.");
 
                log_dhcp6_client(client, "Processed %s message", dhcp6_message_type_to_string(message->type));
 
                sd_dhcp6_lease_unref(client->lease);
                client->lease = TAKE_PTR(lease);
 
                return client_enter_bound_state(client);
        }
 
        r = dhcp6_lease_get_preference(lease, &pref_advertise);
        if (r < 0)
                return r;
 
        if (client->lease) {
                r = dhcp6_lease_get_preference(client->lease, &pref_lease);
                if (r < 0)
                        return r;
        }
 
        log_dhcp6_client(client, "Processed %s message", dhcp6_message_type_to_string(message->type));
 
        if (!client->lease || pref_advertise > pref_lease) {
                /* If this is the first advertise message or has higher preference, then save the lease. */
                sd_dhcp6_lease_unref(client->lease);
                client->lease = TAKE_PTR(lease);
        }
 
        if (pref_advertise == 255 || client->retransmit_count > 1)
                (void) client_start_transaction(client, DHCP6_STATE_REQUEST);
 
        return 0;
}
 
static int client_receive_message(
                sd_event_source *s,
                int fd, uint32_t
                revents,
                void *userdata) {
 
        sd_dhcp6_client *client = ASSERT_PTR(userdata);
        DHCP6_CLIENT_DONT_DESTROY(client);
        /* This needs to be initialized with zero. See #20741.
         * The issue is fixed on glibc-2.35 (8fba672472ae0055387e9315fc2eddfa6775ca79). */
        CMSG_BUFFER_TYPE(CMSG_SPACE_TIMEVAL) control = {};
        struct iovec iov;
        union sockaddr_union sa = {};
        struct msghdr msg = {
                .msg_name = &sa.sa,
                .msg_namelen = sizeof(sa),
                .msg_iov = &iov,
                .msg_iovlen = 1,
                .msg_control = &control,
                .msg_controllen = sizeof(control),
        };
        triple_timestamp t;
        _cleanup_free_ DHCP6Message *message = NULL;
        struct in6_addr *server_address = NULL;
        ssize_t buflen, len;
 
        buflen = next_datagram_size_fd(fd);
        if (ERRNO_IS_NEG_TRANSIENT(buflen) || ERRNO_IS_NEG_DISCONNECT(buflen))
                return 0;
        if (buflen < 0) {
                log_dhcp6_client_errno(client, buflen, "Failed to determine datagram size to read, ignoring: %m");
                return 0;
        }
 
        message = malloc(buflen);
        if (!message)
                return -ENOMEM;
 
        iov = IOVEC_MAKE(message, buflen);
 
        len = recvmsg_safe(fd, &msg, MSG_DONTWAIT);
        if (ERRNO_IS_NEG_TRANSIENT(len) || ERRNO_IS_NEG_DISCONNECT(len))
                return 0;
        if (len < 0) {
                log_dhcp6_client_errno(client, len, "Could not receive message from UDP socket, ignoring: %m");
                return 0;
        }
        if ((size_t) len < sizeof(DHCP6Message)) {
                log_dhcp6_client(client, "Too small to be DHCPv6 message: ignoring");
                return 0;
        }
 
        /* msg_namelen == 0 happens when running the test-suite over a socketpair */
        if (msg.msg_namelen > 0) {
                if (msg.msg_namelen != sizeof(struct sockaddr_in6) || sa.in6.sin6_family != AF_INET6) {
                        log_dhcp6_client(client, "Received message from invalid source, ignoring.");
                        return 0;
                }
 
                server_address = &sa.in6.sin6_addr;
        }
 
        triple_timestamp_from_cmsg(&t, &msg);
 
        if (client->transaction_id != (message->transaction_id & htobe32(0x00ffffff)))
                return 0;
 
        switch (client->state) {
        case DHCP6_STATE_INFORMATION_REQUEST:
                if (client_process_information(client, message, len, &t, server_address) < 0)
                        return 0;
                break;
 
        case DHCP6_STATE_SOLICITATION:
                if (client_process_advertise_or_rapid_commit_reply(client, message, len, &t, server_address) < 0)
                        return 0;
                break;
 
        case DHCP6_STATE_REQUEST:
        case DHCP6_STATE_RENEW:
        case DHCP6_STATE_REBIND:
                if (client_process_reply(client, message, len, &t, server_address) < 0)
                        return 0;
                break;
 
        case DHCP6_STATE_BOUND:
        case DHCP6_STATE_STOPPED:
        case DHCP6_STATE_STOPPING:
        default:
                assert_not_reached();
        }
 
        return 0;
}
 
static int client_send_release(sd_dhcp6_client *client) {
        sd_dhcp6_lease *lease;
 
        assert(client);
 
        if (!client->send_release)
                return 0;
 
        if (sd_dhcp6_client_get_lease(client, &lease) < 0)
                return 0;
 
        if (!lease->ia_na && !lease->ia_pd)
                return 0;
 
        client_set_state(client, DHCP6_STATE_STOPPING);
        return dhcp6_client_send_message(client);
}
 
int sd_dhcp6_client_stop(sd_dhcp6_client *client) {
        int r;
 
        if (!client)
                return 0;
 
        /* Intentionally ignoring failure to send DHCP6 release. The DHCPv6 client
         * engine is about to release its UDP socket unconditionally. */
        r = client_send_release(client);
        if (r < 0)
                log_dhcp6_client_errno(client, r,
                                       "Failed to send DHCPv6 release message, ignoring: %m");
 
        client_stop(client, SD_DHCP6_CLIENT_EVENT_STOP);
 
        client->receive_message = sd_event_source_unref(client->receive_message);
        client->fd = safe_close(client->fd);
 
        return 0;
}
 
int sd_dhcp6_client_is_running(sd_dhcp6_client *client) {
        if (!client)
                return false;
 
        return client->state != DHCP6_STATE_STOPPED;
}
 
int sd_dhcp6_client_start(sd_dhcp6_client *client) {
        DHCP6State state = DHCP6_STATE_SOLICITATION;
        int r;
 
        assert_return(client, -EINVAL);
        assert_return(client->event, -EINVAL);
        assert_return(client->ifindex > 0, -EINVAL);
        assert_return(in6_addr_is_link_local(&client->local_address) > 0, -EINVAL);
        assert_return(!sd_dhcp6_client_is_running(client), -EBUSY);
        assert_return(client->information_request || client->request_ia != 0, -EINVAL);
 
        /* Even if the client is in the STOPPED state, the lease acquired in the previous information
         * request may be stored. */
        client->lease = sd_dhcp6_lease_unref(client->lease);
 
        r = client_ensure_iaid(client);
        if (r < 0)
                return r;
 
        r = client_ensure_duid(client);
        if (r < 0)
                return r;
 
        if (client->fd < 0) {
                r = dhcp6_network_bind_udp_socket(client->ifindex, &client->local_address);
                if (r < 0)
                        return log_dhcp6_client_errno(client, r,
                                                      "Failed to bind to UDP socket at address %s: %m",
                                                      IN6_ADDR_TO_STRING(&client->local_address));
 
                client->fd = r;
        }
 
        if (!client->receive_message) {
                _cleanup_(sd_event_source_disable_unrefp) sd_event_source *s = NULL;
 
                r = sd_event_add_io(client->event, &s, client->fd, EPOLLIN, client_receive_message, client);
                if (r < 0)
                        return r;
 
                r = sd_event_source_set_priority(s, client->event_priority);
                if (r < 0)
                        return r;
 
                r = sd_event_source_set_description(s, "dhcp6-receive-message");
                if (r < 0)
                        return r;
 
                client->receive_message = TAKE_PTR(s);
        }
 
        if (client->information_request) {
                usec_t t = now(CLOCK_MONOTONIC);
 
                if (t < usec_add(client->information_request_time_usec, client->information_refresh_time_usec))
                        return 0;
 
                client->information_request_time_usec = t;
                state = DHCP6_STATE_INFORMATION_REQUEST;
        }
 
        log_dhcp6_client(client, "Starting in %s mode",
                         client->information_request ? "Information request" : "Solicit");
 
        return client_start_transaction(client, state);
}
 
int sd_dhcp6_client_attach_event(sd_dhcp6_client *client, sd_event *event, int64_t priority) {
        int r;
 
        assert_return(client, -EINVAL);
        assert_return(!client->event, -EBUSY);
        assert_return(!sd_dhcp6_client_is_running(client), -EBUSY);
 
        if (event)
                client->event = sd_event_ref(event);
        else {
                r = sd_event_default(&client->event);
                if (r < 0)
                        return r;
        }
 
        client->event_priority = priority;
 
        return 0;
}
 
int sd_dhcp6_client_detach_event(sd_dhcp6_client *client) {
        assert_return(client, -EINVAL);
        assert_return(!sd_dhcp6_client_is_running(client), -EBUSY);
 
        client->event = sd_event_unref(client->event);
 
        return 0;
}
 
sd_event *sd_dhcp6_client_get_event(sd_dhcp6_client *client) {
        assert_return(client, NULL);
 
        return client->event;
}
 
int sd_dhcp6_client_attach_device(sd_dhcp6_client *client, sd_device *dev) {
        assert_return(client, -EINVAL);
 
        return device_unref_and_replace_new_ref(client->dev, dev);
}
 
static sd_dhcp6_client *dhcp6_client_free(sd_dhcp6_client *client) {
        if (!client)
                return NULL;
 
        sd_dhcp6_lease_unref(client->lease);
 
        sd_event_source_disable_unref(client->receive_message);
        sd_event_source_disable_unref(client->timeout_resend);
        sd_event_source_disable_unref(client->timeout_expire);
        sd_event_source_disable_unref(client->timeout_t1);
        sd_event_source_disable_unref(client->timeout_t2);
        sd_event_unref(client->event);
 
        client->fd = safe_close(client->fd);
 
        sd_device_unref(client->dev);
 
        free(client->req_opts);
        free(client->fqdn);
        free(client->mudurl);
        dhcp6_ia_clear_addresses(&client->ia_pd);
        ordered_hashmap_free(client->extra_options);
        ordered_set_free(client->vendor_options);
        strv_free(client->user_class);
        strv_free(client->vendor_class);
        free(client->ifname);
 
        return mfree(client);
}
 
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp6_client, sd_dhcp6_client, dhcp6_client_free);
 
int sd_dhcp6_client_new(sd_dhcp6_client **ret) {
        _cleanup_(sd_dhcp6_client_unrefp) sd_dhcp6_client *client = NULL;
 
        assert_return(ret, -EINVAL);
 
        client = new(sd_dhcp6_client, 1);
        if (!client)
                return -ENOMEM;
 
        *client = (sd_dhcp6_client) {
                .n_ref = 1,
                .ia_na.type = SD_DHCP6_OPTION_IA_NA,
                .ia_pd.type = SD_DHCP6_OPTION_IA_PD,
                .ifindex = -1,
                .request_ia = DHCP6_REQUEST_IA_NA | DHCP6_REQUEST_IA_PD,
                .fd = -EBADF,
                .rapid_commit = true,
        };
 
        *ret = TAKE_PTR(client);
 
        return 0;
}