X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd-network%2Fsd-dhcp-client.c;h=2a46624f2e8c328e41c520e3377c96dd15f1c92d;hp=512bc9368df56e55f029a9dc1f54d766655c66f3;hb=8186d9dda0d3f8a853afe6fdbd605f42151fe165;hpb=e5b04c8de83aa17e324bae95f18a822931fb8078 diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index 512bc9368..2a46624f2 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -23,12 +23,14 @@ #include #include #include +#include #include #include #include "util.h" #include "list.h" #include "refcnt.h" +#include "async.h" #include "dhcp-protocol.h" #include "dhcp-internal.h" @@ -96,7 +98,8 @@ int sd_dhcp_client_set_request_option(sd_dhcp_client *client, uint8_t option) { size_t i; assert_return(client, -EINVAL); - assert_return (client->state == DHCP_STATE_INIT, -EBUSY); + assert_return (IN_SET(client->state, DHCP_STATE_INIT, + DHCP_STATE_STOPPED), -EBUSY); switch(option) { case DHCP_OPTION_PAD: @@ -126,7 +129,8 @@ int sd_dhcp_client_set_request_option(sd_dhcp_client *client, uint8_t option) { int sd_dhcp_client_set_request_address(sd_dhcp_client *client, const struct in_addr *last_addr) { assert_return(client, -EINVAL); - assert_return(client->state == DHCP_STATE_INIT, -EBUSY); + assert_return (IN_SET(client->state, DHCP_STATE_INIT, + DHCP_STATE_STOPPED), -EBUSY); if (last_addr) client->last_addr = last_addr->s_addr; @@ -138,8 +142,9 @@ int sd_dhcp_client_set_request_address(sd_dhcp_client *client, int sd_dhcp_client_set_index(sd_dhcp_client *client, int interface_index) { assert_return(client, -EINVAL); - assert_return(client->state == DHCP_STATE_INIT, -EBUSY); - assert_return(interface_index >= -1, -EINVAL); + assert_return (IN_SET(client->state, DHCP_STATE_INIT, + DHCP_STATE_STOPPED), -EBUSY); + assert_return(interface_index > 0, -EINVAL); client->index = interface_index; @@ -156,7 +161,7 @@ int sd_dhcp_client_set_mac(sd_dhcp_client *client, if (memcmp(&client->client_id.mac_addr, addr, ETH_ALEN) == 0) return 0; - if (client->state != DHCP_STATE_INIT) { + if (!IN_SET(client->state, DHCP_STATE_INIT, DHCP_STATE_STOPPED)) { log_dhcp_client(client, "Changing MAC address on running DHCP " "client, restarting"); need_restart = true; @@ -169,7 +174,7 @@ int sd_dhcp_client_set_mac(sd_dhcp_client *client, memcpy(&client->client_id.mac_addr, addr, ETH_ALEN); client->client_id.type = 0x01; - if (need_restart) + if (need_restart && client->state != DHCP_STATE_STOPPED) sd_dhcp_client_start(client); return 0; @@ -205,7 +210,7 @@ static int client_initialize(sd_dhcp_client *client) { client->receive_message = sd_event_source_unref(client->receive_message); - client->fd = safe_close(client->fd); + client->fd = asynchronous_close(client->fd); client->timeout_resend = sd_event_source_unref(client->timeout_resend); @@ -227,7 +232,21 @@ static int client_initialize(sd_dhcp_client *client) { static sd_dhcp_client *client_stop(sd_dhcp_client *client, int error) { assert_return(client, NULL); - log_dhcp_client(client, "STOPPED %d", error); + if (error < 0) + log_dhcp_client(client, "STOPPED: %s", strerror(-error)); + else { + switch(error) { + case DHCP_EVENT_STOP: + log_dhcp_client(client, "STOPPED"); + break; + case DHCP_EVENT_NO_LEASE: + log_dhcp_client(client, "STOPPED: No lease"); + break; + default: + log_dhcp_client(client, "STOPPED: Unknown reason"); + break; + } + } client = client_notify(client, error); @@ -237,59 +256,93 @@ static sd_dhcp_client *client_stop(sd_dhcp_client *client, int error) { return client; } -static int client_message_init(sd_dhcp_client *client, DHCPMessage *message, - uint8_t type, uint8_t **opt, size_t *optlen) { +static int client_message_init(sd_dhcp_client *client, DHCPPacket **ret, + uint8_t type, size_t *_optlen, size_t *_optoffset) { + _cleanup_free_ DHCPPacket *packet; + size_t optlen, optoffset, size; + be16_t max_size; int r; assert(client); assert(client->secs); - assert(message); - assert(opt); - assert(optlen); + assert(ret); + assert(_optlen); + assert(_optoffset); + assert(type == DHCP_DISCOVER || type == DHCP_REQUEST); - r = dhcp_message_init(message, BOOTREQUEST, client->xid, type, opt, - optlen); + optlen = DHCP_MIN_OPTIONS_SIZE; + size = sizeof(DHCPPacket) + optlen; + + packet = malloc0(size); + if (!packet) + return -ENOMEM; + + r = dhcp_message_init(&packet->dhcp, BOOTREQUEST, client->xid, type, + optlen, &optoffset); if (r < 0) return r; /* Although 'secs' field is a SHOULD in RFC 2131, certain DHCP servers refuse to issue an DHCP lease if 'secs' is set to zero */ - message->secs = htobe16(client->secs); - - memcpy(&message->chaddr, &client->client_id.mac_addr, ETH_ALEN); - - if (client->state == DHCP_STATE_RENEWING || - client->state == DHCP_STATE_REBINDING) - message->ciaddr = client->lease->address; + packet->dhcp.secs = htobe16(client->secs); + + /* RFC2132 section 4.1 + A client that cannot receive unicast IP datagrams until its protocol + software has been configured with an IP address SHOULD set the + BROADCAST bit in the 'flags' field to 1 in any DHCPDISCOVER or + DHCPREQUEST messages that client sends. The BROADCAST bit will + provide a hint to the DHCP server and BOOTP relay agent to broadcast + any messages to the client on the client's subnet. */ + packet->dhcp.flags = htobe16(0x8000); + + /* RFC2132 section 4.1.1: + The client MUST include its hardware address in the ’chaddr’ field, if + necessary for delivery of DHCP reply messages. + */ + memcpy(&packet->dhcp.chaddr, &client->client_id.mac_addr, ETH_ALEN); /* Some DHCP servers will refuse to issue an DHCP lease if the Client Identifier option is not set */ - r = dhcp_option_append(opt, optlen, DHCP_OPTION_CLIENT_IDENTIFIER, + r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_CLIENT_IDENTIFIER, sizeof(client->client_id), &client->client_id); if (r < 0) return r; - if (type == DHCP_DISCOVER || type == DHCP_REQUEST) { - be16_t max_size; - r = dhcp_option_append(opt, optlen, - DHCP_OPTION_PARAMETER_REQUEST_LIST, - client->req_opts_size, - client->req_opts); - if (r < 0) - return r; + /* RFC2131 section 3.5: + in its initial DHCPDISCOVER or DHCPREQUEST message, a + client may provide the server with a list of specific + parameters the client is interested in. If the client + includes a list of parameters in a DHCPDISCOVER message, + it MUST include that list in any subsequent DHCPREQUEST + messages. + */ + r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_PARAMETER_REQUEST_LIST, + client->req_opts_size, client->req_opts); + if (r < 0) + return r; - /* Some DHCP servers will send bigger DHCP packets than the - defined default size unless the Maximum Messge Size option - is explicitely set */ - max_size = htobe16(DHCP_IP_UDP_SIZE + DHCP_MESSAGE_SIZE + - DHCP_MIN_OPTIONS_SIZE); - r = dhcp_option_append(opt, optlen, - DHCP_OPTION_MAXIMUM_MESSAGE_SIZE, - 2, &max_size); - if (r < 0) - return r; - } + /* RFC2131 section 3.5: + The client SHOULD include the ’maximum DHCP message size’ option to + let the server know how large the server may make its DHCP messages. + + Note (from ConnMan): Some DHCP servers will send bigger DHCP packets + than the defined default size unless the Maximum Messge Size option + is explicitely set + */ + max_size = htobe16(size); + r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_MAXIMUM_MESSAGE_SIZE, + 2, &max_size); + if (r < 0) + return r; + + *_optlen = optlen; + *_optoffset = optoffset; + *ret = packet; + packet = NULL; return 0; } @@ -305,12 +358,15 @@ static int dhcp_client_send_raw(sd_dhcp_client *client, DHCPPacket *packet, static int client_send_discover(sd_dhcp_client *client) { _cleanup_free_ DHCPPacket *discover = NULL; - size_t optlen, len; - uint8_t *opt; + size_t optoffset, optlen; usec_t time_now; int r; assert(client); + assert(client->state == DHCP_STATE_INIT || + client->state == DHCP_STATE_SELECTING); + + /* See RFC2131 section 4.4.1 */ r = sd_event_now(client->event, CLOCK_MONOTONIC, &time_now); if (r < 0) @@ -321,31 +377,33 @@ static int client_send_discover(sd_dhcp_client *client) { * must always be strictly positive to deal with broken servers */ client->secs = ((time_now - client->start_time) / USEC_PER_SEC) ? : 1; - optlen = DHCP_MIN_OPTIONS_SIZE; - len = sizeof(DHCPPacket) + optlen; - - discover = malloc0(len); - if (!discover) - return -ENOMEM; - - r = client_message_init(client, &discover->dhcp, DHCP_DISCOVER, - &opt, &optlen); + r = client_message_init(client, &discover, DHCP_DISCOVER, + &optlen, &optoffset); if (r < 0) return r; + /* the client may suggest values for the network address + and lease time in the DHCPDISCOVER message. The client may include + the ’requested IP address’ option to suggest that a particular IP + address be assigned, and may include the ’IP address lease time’ + option to suggest the lease time it would like. + */ if (client->last_addr != INADDR_ANY) { - r = dhcp_option_append(&opt, &optlen, - DHCP_OPTION_REQUESTED_IP_ADDRESS, - 4, &client->last_addr); + r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_REQUESTED_IP_ADDRESS, + 4, &client->last_addr); if (r < 0) return r; } - r = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL); - if (r < 0) - return r; + r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_END, 0, NULL); - r = dhcp_client_send_raw(client, discover, len - optlen); + /* We currently ignore: + The client SHOULD wait a random time between one and ten seconds to + desynchronize the use of DHCP at startup. + */ + r = dhcp_client_send_raw(client, discover, sizeof(DHCPPacket) + optoffset); if (r < 0) return r; @@ -355,58 +413,80 @@ static int client_send_discover(sd_dhcp_client *client) { } static int client_send_request(sd_dhcp_client *client) { - _cleanup_free_ DHCPPacket *request; - size_t optlen, len; - uint8_t *opt; + _cleanup_free_ DHCPPacket *request = NULL; + size_t optoffset, optlen; int r; - optlen = DHCP_MIN_OPTIONS_SIZE; - len = sizeof(DHCPPacket) + optlen; - - request = malloc0(len); - if (!request) - return -ENOMEM; - - r = client_message_init(client, &request->dhcp, DHCP_REQUEST, &opt, - &optlen); + r = client_message_init(client, &request, DHCP_REQUEST, + &optlen, &optoffset); if (r < 0) return r; switch (client->state) { + /* See RFC2131 section 4.3.2 (note that there is a typo in the RFC, + SELECTING should be REQUESTING) + */ - case DHCP_STATE_INIT_REBOOT: - r = dhcp_option_append(&opt, &optlen, - DHCP_OPTION_REQUESTED_IP_ADDRESS, - 4, &client->last_addr); + case DHCP_STATE_REQUESTING: + /* Client inserts the address of the selected server in ’server + identifier’, ’ciaddr’ MUST be zero, ’requested IP address’ MUST be + filled in with the yiaddr value from the chosen DHCPOFFER. + */ + + r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_SERVER_IDENTIFIER, + 4, &client->lease->server_address); if (r < 0) return r; - break; - case DHCP_STATE_REQUESTING: - r = dhcp_option_append(&opt, &optlen, + r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0, DHCP_OPTION_REQUESTED_IP_ADDRESS, 4, &client->lease->address); if (r < 0) return r; - r = dhcp_option_append(&opt, &optlen, - DHCP_OPTION_SERVER_IDENTIFIER, - 4, &client->lease->server_address); + break; + + case DHCP_STATE_INIT_REBOOT: + /* ’server identifier’ MUST NOT be filled in, ’requested IP address’ + option MUST be filled in with client’s notion of its previously + assigned address. ’ciaddr’ MUST be zero. + */ + r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_REQUESTED_IP_ADDRESS, + 4, &client->last_addr); if (r < 0) return r; break; - case DHCP_STATE_INIT: - case DHCP_STATE_SELECTING: - case DHCP_STATE_REBOOTING: - case DHCP_STATE_BOUND: case DHCP_STATE_RENEWING: + /* ’server identifier’ MUST NOT be filled in, ’requested IP address’ + option MUST NOT be filled in, ’ciaddr’ MUST be filled in with + client’s IP address. + */ + + /* fall through */ case DHCP_STATE_REBINDING: + /* ’server identifier’ MUST NOT be filled in, ’requested IP address’ + option MUST NOT be filled in, ’ciaddr’ MUST be filled in with + client’s IP address. + + This message MUST be broadcast to the 0xffffffff IP broadcast address. + */ + request->dhcp.ciaddr = client->lease->address; break; + + case DHCP_STATE_INIT: + case DHCP_STATE_SELECTING: + case DHCP_STATE_REBOOTING: + case DHCP_STATE_BOUND: + case DHCP_STATE_STOPPED: + return -EINVAL; } - r = dhcp_option_append(&opt, &optlen, DHCP_OPTION_END, 0, NULL); + r = dhcp_option_append(&request->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_END, 0, NULL); if (r < 0) return r; @@ -415,18 +495,36 @@ static int client_send_request(sd_dhcp_client *client) { client->lease->server_address, DHCP_PORT_SERVER, &request->dhcp, - len - optlen - DHCP_IP_UDP_SIZE); + sizeof(DHCPMessage) + optoffset); } else { - r = dhcp_client_send_raw(client, request, len - optlen); + r = dhcp_client_send_raw(client, request, sizeof(DHCPPacket) + optoffset); } if (r < 0) return r; - log_dhcp_client(client, "REQUEST"); + switch (client->state) { + case DHCP_STATE_REQUESTING: + log_dhcp_client(client, "REQUEST (requesting)"); + break; + case DHCP_STATE_INIT_REBOOT: + log_dhcp_client(client, "REQUEST (init-reboot)"); + break; + case DHCP_STATE_RENEWING: + log_dhcp_client(client, "REQUEST (renewing)"); + break; + case DHCP_STATE_REBINDING: + log_dhcp_client(client, "REQUEST (rebinding)"); + break; + default: + log_dhcp_client(client, "REQUEST (invalid)"); + break; + } return 0; } +static int client_start(sd_dhcp_client *client); + static int client_timeout_resend(sd_event_source *s, uint64_t usec, void *userdata) { sd_dhcp_client *client = userdata; @@ -465,11 +563,18 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec, case DHCP_STATE_REBOOTING: /* start over as we did not receive a timely ack or nak */ - client->state = DHCP_STATE_INIT; - client->attempt = 1; - client->xid = random_u32(); + r = client_initialize(client); + if (r < 0) + goto error; + + r = client_start(client); + if (r < 0) + goto error; + else { + log_dhcp_client(client, "REBOOTED"); + return 0; + } - /* fall through */ case DHCP_STATE_INIT: case DHCP_STATE_INIT_REBOOT: case DHCP_STATE_SELECTING: @@ -482,6 +587,10 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec, next_timeout = time_now + (client->attempt - 1) * USEC_PER_SEC; break; + + case DHCP_STATE_STOPPED: + r = -EINVAL; + goto error; } next_timeout += (random_u32() & 0x1fffff); @@ -540,6 +649,10 @@ static int client_timeout_resend(sd_event_source *s, uint64_t usec, case DHCP_STATE_BOUND: break; + + case DHCP_STATE_STOPPED: + r = -EINVAL; + goto error; } return 0; @@ -605,7 +718,6 @@ static int client_start(sd_dhcp_client *client) { client->xid = random_u32(); r = dhcp_network_bind_raw_socket(client->index, &client->link, client->xid); - if (r < 0) { client_stop(client, r); return r; @@ -617,8 +729,6 @@ static int client_start(sd_dhcp_client *client) { client->secs = 0; } - log_dhcp_client(client, "STARTED"); - return client_initialize_events(client, client_receive_message_raw); } @@ -630,8 +740,8 @@ static int client_timeout_expire(sd_event_source *s, uint64_t usec, client = client_notify(client, DHCP_EVENT_EXPIRED); - /* lease was lost, start over if not freed */ - if (client) { + /* lease was lost, start over if not freed or stopped in callback */ + if (client && client->state != DHCP_STATE_STOPPED) { client_initialize(client); client_start(client); } @@ -644,7 +754,7 @@ static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) int r; client->receive_message = sd_event_source_unref(client->receive_message); - client->fd = safe_close(client->fd); + client->fd = asynchronous_close(client->fd); client->state = DHCP_STATE_REBINDING; client->attempt = 1; @@ -654,11 +764,8 @@ static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) client_stop(client, r); return 0; } - client->fd = r; - log_dhcp_client(client, "TIMEOUT T2"); - return client_initialize_events(client, client_receive_message_raw); } @@ -670,8 +777,7 @@ static int client_timeout_t1(sd_event_source *s, uint64_t usec, client->state = DHCP_STATE_RENEWING; client->attempt = 1; - r = dhcp_network_bind_udp_socket(client->index, - client->lease->address, + r = dhcp_network_bind_udp_socket(client->lease->address, DHCP_PORT_CLIENT); if (r < 0) { client_stop(client, r); @@ -680,8 +786,6 @@ static int client_timeout_t1(sd_event_source *s, uint64_t usec, client->fd = r; - log_dhcp_client(client, "TIMEOUT T1"); - return client_initialize_events(client, client_receive_message_udp); } @@ -722,6 +826,7 @@ static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer, } } + sd_dhcp_lease_unref(client->lease); client->lease = lease; lease = NULL; @@ -1022,6 +1127,8 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, r = client_start(client); if (r < 0) goto error; + + log_dhcp_client(client, "REBOOTED"); } goto error; @@ -1046,13 +1153,14 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, if (notify_event) { client = client_notify(client, notify_event); - if (!client) + if (!client || + client->state == DHCP_STATE_STOPPED) return 0; } client->receive_message = sd_event_source_unref(client->receive_message); - client->fd = safe_close(client->fd); + client->fd = asynchronous_close(client->fd); } else if (r == -ENOMSG) /* invalid message, let's ignore it */ return 0; @@ -1064,6 +1172,10 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, case DHCP_STATE_BOUND: break; + + case DHCP_STATE_STOPPED: + r = -EINVAL; + goto error; } error: @@ -1083,8 +1195,12 @@ static int client_receive_message_udp(sd_event_source *s, int fd, assert(client); r = ioctl(fd, FIONREAD, &buflen); - if (r < 0 || buflen <= 0) - buflen = sizeof(DHCPMessage) + DHCP_MIN_OPTIONS_SIZE; + if (r < 0) + return r; + + if (buflen < 0) + /* this can't be right */ + return -EIO; message = malloc0(buflen); if (!message) @@ -1093,7 +1209,7 @@ static int client_receive_message_udp(sd_event_source *s, int fd, len = read(fd, message, buflen); if (len < 0) { log_dhcp_client(client, "could not receive message from UDP " - "socket: %s", strerror(errno)); + "socket: %m"); return 0; } else if ((size_t)len < sizeof(DHCPMessage)) return 0; @@ -1121,8 +1237,12 @@ static int client_receive_message_raw(sd_event_source *s, int fd, assert(client); r = ioctl(fd, FIONREAD, &buflen); - if (r < 0 || buflen <= 0) - buflen = sizeof(DHCPPacket) + DHCP_MIN_OPTIONS_SIZE; + if (r < 0) + return r; + + if (buflen < 0) + /* this can't be right */ + return -EIO; packet = malloc0(buflen); if (!packet) @@ -1134,7 +1254,7 @@ static int client_receive_message_raw(sd_event_source *s, int fd, len = recvmsg(fd, &msg, 0); if (len < 0) { log_dhcp_client(client, "could not receive message from raw " - "socket: %s", strerror(errno)); + "socket: %m"); return 0; } else if ((size_t)len < sizeof(DHCPPacket)) return 0; @@ -1171,13 +1291,20 @@ int sd_dhcp_client_start(sd_dhcp_client *client) { if (client->last_addr) client->state = DHCP_STATE_INIT_REBOOT; - return client_start(client); + r = client_start(client); + if (r >= 0) + log_dhcp_client(client, "STARTED on ifindex %u with address %s", + client->index, + ether_ntoa(&client->client_id.mac_addr)); + + return r; } int sd_dhcp_client_stop(sd_dhcp_client *client) { assert_return(client, -EINVAL); - client_stop(client, DHCP_EVENT_STOP); + if (client_stop(client, DHCP_EVENT_STOP)) + client->state = DHCP_STATE_STOPPED; return 0; } @@ -1235,6 +1362,8 @@ sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) { sd_dhcp_client_detach_event(client); + sd_dhcp_lease_unref(client->lease); + free(client->req_opts); free(client);