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=da41c478eaeb477ba286001e5517abc6014ccca9;hb=574cc928887851269c5919123dbdf8e1b2713b23;hpb=7429b07f822348dc5a87208ce107f5f6bf02656d diff --git a/src/libsystemd-network/sd-dhcp-client.c b/src/libsystemd-network/sd-dhcp-client.c index da41c478e..1603c4122 100644 --- a/src/libsystemd-network/sd-dhcp-client.c +++ b/src/libsystemd-network/sd-dhcp-client.c @@ -23,11 +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" @@ -35,6 +38,8 @@ #include "sd-dhcp-client.h" struct sd_dhcp_client { + RefCount n_ref; + DHCPState state; sd_event *event; int event_priority; @@ -77,6 +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 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) { @@ -92,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: @@ -122,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; @@ -134,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; @@ -144,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); @@ -152,17 +162,17 @@ 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"); - sd_dhcp_client_stop(client); need_restart = true; + client_stop(client, DHCP_EVENT_STOP); } 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; @@ -182,11 +192,9 @@ int sd_dhcp_client_get_lease(sd_dhcp_client *client, sd_dhcp_lease **ret) { return 0; } -static int client_notify(sd_dhcp_client *client, int event) { +static void client_notify(sd_dhcp_client *client, int event) { if (client->cb) client->cb(client, event, client->userdata); - - return 0; } static int client_initialize(sd_dhcp_client *client) { @@ -195,7 +203,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); @@ -214,71 +222,117 @@ static int client_initialize(sd_dhcp_client *client) { return 0; } -static int client_stop(sd_dhcp_client *client, int error) { - assert_return(client, -EINVAL); +static void client_stop(sd_dhcp_client *client, int error) { + assert(client); + + 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_notify(client, error); client_initialize(client); - - log_dhcp_client(client, "STOPPED"); - - return 0; } -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; } @@ -294,12 +348,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) @@ -310,31 +367,35 @@ 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); + r = dhcp_option_append(&discover->dhcp, optlen, &optoffset, 0, + DHCP_OPTION_END, 0, NULL); if (r < 0) return r; - 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; @@ -344,58 +405,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; @@ -404,21 +487,40 @@ 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; + DHCP_CLIENT_DONT_DESTROY(client); usec_t next_timeout = 0; uint64_t time_now; uint32_t time_left; @@ -454,11 +556,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: @@ -471,6 +580,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); @@ -529,6 +642,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; @@ -594,7 +711,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; @@ -606,32 +722,34 @@ 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); } 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_notify(client, DHCP_EVENT_EXPIRED); - /* start over as the lease was lost */ - client_initialize(client); - client_start(client); + /* lease was lost, start over if not freed or stopped in callback */ + if (client->state != DHCP_STATE_STOPPED) { + client_initialize(client); + client_start(client); + } return 0; } 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); - client->fd = safe_close(client->fd); + client->fd = asynchronous_close(client->fd); client->state = DHCP_STATE_REBINDING; client->attempt = 1; @@ -641,24 +759,21 @@ 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); } 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; 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); @@ -667,8 +782,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); } @@ -709,6 +822,7 @@ static int client_handle_offer(sd_dhcp_client *client, DHCPMessage *offer, } } + sd_dhcp_lease_unref(client->lease); client->lease = lease; lease = NULL; @@ -925,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); @@ -1009,6 +1124,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; @@ -1031,12 +1148,15 @@ static int client_handle_message(sd_dhcp_client *client, DHCPMessage *message, if (r < 0) goto error; - if (notify_event) + if (notify_event) { client_notify(client, notify_event); + if (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; @@ -1048,13 +1168,17 @@ 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: if (r < 0 || r == DHCP_EVENT_NO_LEASE) - return client_stop(client, r); + client_stop(client, r); - return 0; + return r; } static int client_receive_message_udp(sd_event_source *s, int fd, @@ -1067,8 +1191,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) @@ -1077,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; @@ -1105,8 +1233,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) @@ -1118,14 +1250,16 @@ 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; for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) { - if (cmsg->cmsg_level == SOL_PACKET && cmsg->cmsg_type == PACKET_AUXDATA) { - struct tpacket_auxdata *aux = (void *)CMSG_DATA(cmsg); + if (cmsg->cmsg_level == SOL_PACKET && + cmsg->cmsg_type == PACKET_AUXDATA && + cmsg->cmsg_len == CMSG_LEN(sizeof(struct tpacket_auxdata))) { + struct tpacket_auxdata *aux = (struct tpacket_auxdata*)CMSG_DATA(cmsg); checksum = !(aux->tp_status & TP_STATUS_CSUMNOTREADY); break; @@ -1153,11 +1287,24 @@ 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) { - return client_stop(client, DHCP_EVENT_STOP); + DHCP_CLIENT_DONT_DESTROY(client); + + assert_return(client, -EINVAL); + + client_stop(client, DHCP_EVENT_STOP); + client->state = DHCP_STATE_STOPPED; + + return 0; } int sd_dhcp_client_attach_event(sd_dhcp_client *client, sd_event *event, @@ -1195,22 +1342,35 @@ sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client) { return client->event; } -void sd_dhcp_client_free(sd_dhcp_client *client) { - if (!client) - return; - - sd_dhcp_client_stop(client); - sd_dhcp_client_detach_event(client); +sd_dhcp_client *sd_dhcp_client_ref(sd_dhcp_client *client) { + if (client) + assert_se(REFCNT_INC(client->n_ref) >= 2); - free(client->req_opts); - free(client); + return client; } -DEFINE_TRIVIAL_CLEANUP_FUNC(sd_dhcp_client*, sd_dhcp_client_free); -#define _cleanup_dhcp_client_free_ _cleanup_(sd_dhcp_client_freep) +sd_dhcp_client *sd_dhcp_client_unref(sd_dhcp_client *client) { + if (client && REFCNT_DEC(client->n_ref) <= 0) { + log_dhcp_client(client, "FREE"); + + client_initialize(client); + + client->receive_message = + sd_event_source_unref(client->receive_message); + + sd_dhcp_client_detach_event(client); + + sd_dhcp_lease_unref(client->lease); + + free(client->req_opts); + free(client); + } + + return NULL; +} 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); @@ -1218,6 +1378,7 @@ int sd_dhcp_client_new(sd_dhcp_client **ret) { if (!client) return -ENOMEM; + client->n_ref = REFCNT_INIT; client->state = DHCP_STATE_INIT; client->index = -1; client->fd = -1;