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=1603c41227ea72148cdbfe21ff23f0e4833c824f;hp=ba44069f662a4303b260b47c70ec339538fb07a0;hb=574cc928887851269c5919123dbdf8e1b2713b23;hpb=23289745d737a57ecc040e18abadebaaf69dc8d1 diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index ba44069f6..1603c4122 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -82,7 +82,7 @@ static int client_receive_message_raw(sd_event_source *s, int fd, uint32_t revents, void *userdata); static int client_receive_message_udp(sd_event_source *s, int fd, uint32_t revents, void *userdata); -static sd_dhcp_client *client_stop(sd_dhcp_client *client, int error); +static void client_stop(sd_dhcp_client *client, int error); int sd_dhcp_client_set_callback(sd_dhcp_client *client, sd_dhcp_client_cb_t cb, void *userdata) { @@ -153,6 +153,7 @@ int sd_dhcp_client_set_index(sd_dhcp_client *client, int interface_index) { int sd_dhcp_client_set_mac(sd_dhcp_client *client, const struct ether_addr *addr) { + DHCP_CLIENT_DONT_DESTROY(client); bool need_restart = false; assert_return(client, -EINVAL); @@ -165,12 +166,9 @@ int sd_dhcp_client_set_mac(sd_dhcp_client *client, log_dhcp_client(client, "Changing MAC address on running DHCP " "client, restarting"); need_restart = true; - client = client_stop(client, DHCP_EVENT_STOP); + client_stop(client, DHCP_EVENT_STOP); } - if (!client) - return 0; - memcpy(&client->client_id.mac_addr, addr, ETH_ALEN); client->client_id.type = 0x01; @@ -194,14 +192,9 @@ int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) { return 0; } -static sd_dhcp_client *client_notify(sd_dhcp_client *client, int event) { - if (client->cb) { - client = sd_dhcp_client_ref(client); +static void client_notify(sd_dhcp_client *client, int event) { + if (client->cb) client->cb(client, event, client->userdata); - client = sd_dhcp_client_unref(client); - } - - return client; } static int client_initialize(sd_dhcp_client *client) { @@ -229,8 +222,8 @@ static int client_initialize(sd_dhcp_client *client) { return 0; } -static sd_dhcp_client *client_stop(sd_dhcp_client *client, int error) { - assert_return(client, NULL); +static void client_stop(sd_dhcp_client *client, int error) { + assert(client); if (error < 0) log_dhcp_client(client, "STOPPED: %s", strerror(-error)); @@ -248,43 +241,59 @@ static sd_dhcp_client *client_stop(sd_dhcp_client *client, int error) { } } - client = client_notify(client, error); + client_notify(client, error); - if (client) - client_initialize(client); - - return client; + client_initialize(client); } -static int client_message_init(sd_dhcp_client *client, DHCPMessage *message, - uint8_t type, size_t optlen, size_t *optoffset) { +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(optoffset); + assert(ret); + assert(_optlen); + assert(_optoffset); assert(type == DHCP_DISCOVER || type == DHCP_REQUEST); - r = dhcp_message_init(message, BOOTREQUEST, client->xid, type, - optlen, optoffset); + 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); + 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(&message->chaddr, &client->client_id.mac_addr, ETH_ALEN); + 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(message, optlen, optoffset, 0, + r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0, DHCP_OPTION_CLIENT_IDENTIFIER, sizeof(client->client_id), &client->client_id); if (r < 0) @@ -299,7 +308,7 @@ static int client_message_init(sd_dhcp_client *client, DHCPMessage *message, it MUST include that list in any subsequent DHCPREQUEST messages. */ - r = dhcp_option_append(message, optlen, optoffset, 0, + r = dhcp_option_append(&packet->dhcp, optlen, &optoffset, 0, DHCP_OPTION_PARAMETER_REQUEST_LIST, client->req_opts_size, client->req_opts); if (r < 0) @@ -313,14 +322,18 @@ static int client_message_init(sd_dhcp_client *client, DHCPMessage *message, 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(message, optlen, optoffset, 0, + 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; } @@ -335,7 +348,7 @@ 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 optoffset, optlen, len; + size_t optoffset, optlen; usec_t time_now; int r; @@ -354,15 +367,8 @@ 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, - optlen, &optoffset); + r = client_message_init(client, &discover, DHCP_DISCOVER, + &optlen, &optoffset); if (r < 0) return r; @@ -382,6 +388,8 @@ static int client_send_discover(sd_dhcp_client *client) { r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0, DHCP_OPTION_END, 0, NULL); + if (r < 0) + return r; /* We currently ignore: The client SHOULD wait a random time between one and ten seconds to @@ -397,19 +405,12 @@ static int client_send_discover(sd_dhcp_client *client) { } static int client_send_request(sd_dhcp_client *client) { - _cleanup_free_ DHCPPacket *request; - size_t optoffset, optlen, len; + _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, - optlen, &optoffset); + r = client_message_init(client, &request, DHCP_REQUEST, + &optlen, &optoffset); if (r < 0) return r; @@ -519,6 +520,7 @@ 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; + DHCP_CLIENT_DONT_DESTROY(client); usec_t next_timeout = 0; uint64_t time_now; uint32_t time_left; @@ -726,13 +728,14 @@ static int client_start(sd_dhcp_client *client) { static int client_timeout_expire(sd_event_source *s, uint64_t usec, void *userdata) { sd_dhcp_client *client = userdata; + DHCP_CLIENT_DONT_DESTROY(client); log_dhcp_client(client, "EXPIRED"); - client = client_notify(client, DHCP_EVENT_EXPIRED); + client_notify(client, DHCP_EVENT_EXPIRED); /* lease was lost, start over if not freed or stopped in callback */ - if (client && client->state != DHCP_STATE_STOPPED) { + if (client->state != DHCP_STATE_STOPPED) { client_initialize(client); client_start(client); } @@ -742,6 +745,7 @@ static int client_timeout_expire(sd_event_source *s, uint64_t usec, static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) { sd_dhcp_client *client = userdata; + DHCP_CLIENT_DONT_DESTROY(client); int r; client->receive_message = sd_event_source_unref(client->receive_message); @@ -763,6 +767,7 @@ static int client_timeout_t2(sd_event_source *s, uint64_t usec, void *userdata) static int client_timeout_t1(sd_event_source *s, uint64_t usec, void *userdata) { sd_dhcp_client *client = userdata; + DHCP_CLIENT_DONT_DESTROY(client); int r; client->state = DHCP_STATE_RENEWING; @@ -1034,6 +1039,7 @@ static int client_set_lease_timeouts(sd_dhcp_client *client) { static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, int len) { + DHCP_CLIENT_DONT_DESTROY(client); int r = 0, notify_event = 0; assert(client); @@ -1143,9 +1149,8 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, goto error; if (notify_event) { - client = client_notify(client, notify_event); - if (!client || - client->state == DHCP_STATE_STOPPED) + client_notify(client, notify_event); + if (client->state == DHCP_STATE_STOPPED) return 0; } @@ -1200,7 +1205,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; @@ -1245,7 +1250,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; @@ -1292,10 +1297,12 @@ int sd_dhcp_client_start(sd_dhcp_client *client) { } int sd_dhcp_client_stop(sd_dhcp_client *client) { + DHCP_CLIENT_DONT_DESTROY(client); + assert_return(client, -EINVAL); - if (client_stop(client, DHCP_EVENT_STOP)) - client->state = DHCP_STATE_STOPPED; + client_stop(client, DHCP_EVENT_STOP); + client->state = DHCP_STATE_STOPPED; return 0; } @@ -1344,7 +1351,7 @@ sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client) { sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) { if (client && REFCNT_DEC(client->n_ref) <= 0) { - log_dhcp_client(client, "UNREF"); + log_dhcp_client(client, "FREE"); client_initialize(client); @@ -1357,18 +1364,13 @@ sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) { free(client->req_opts); free(client); - - return NULL; } - return client; + return NULL; } -DEFINE_TRIVIAL_CLEANUP_FUNC(sd_dhcp_client*, sd_dhcp_client_unref); -#define _cleanup_dhcp_client_free_ _cleanup_(sd_dhcp_client_unrefp) - int sd_dhcp_client_new(sd_dhcp_client **ret) { - _cleanup_dhcp_client_free_ sd_dhcp_client *client = NULL; + _cleanup_dhcp_client_unref_ sd_dhcp_client *client = NULL; assert_return(ret, -EINVAL);