diff options
Diffstat (limited to 'shared/n-dhcp4/src/n-dhcp4-outgoing.c')
| -rw-r--r-- | shared/n-dhcp4/src/n-dhcp4-outgoing.c | 372 |
1 files changed, 372 insertions, 0 deletions
diff --git a/shared/n-dhcp4/src/n-dhcp4-outgoing.c b/shared/n-dhcp4/src/n-dhcp4-outgoing.c new file mode 100644 index 00000000..c44b5880 --- /dev/null +++ b/shared/n-dhcp4/src/n-dhcp4-outgoing.c @@ -0,0 +1,372 @@ +/* + * DHCPv4 Outgoing Messages + * + * XXX + */ + +#include <assert.h> +#include <c-stdaux.h> +#include <endian.h> +#include <errno.h> +#include <inttypes.h> +#include <netinet/ip.h> +#include <netinet/udp.h> +#include <stdbool.h> +#include <stddef.h> +#include <stdlib.h> +#include <string.h> +#include "n-dhcp4.h" +#include "n-dhcp4-private.h" + +/** + * N_DHCP4_OUTGOING_MAX_PHDR - maximum protocol header size + * + * All DHCP4 messages-limits specify the size of the entire packet including + * the protocol layer (i.e., including the IP headers and UDP headers). To + * calculate the size we have remaining for the actual DHCP message, we need to + * substract the maximum possible header-length the linux-kernel might prepend + * to our messages. This turns out to be the maximum IP-header size (including + * optional IP headers, hence 60 bytes) plus the UDP header size (i.e., 8 + * bytes). + */ +#define N_DHCP4_OUTGOING_MAX_PHDR (N_DHCP4_NETWORK_IP_MAXIMUM_HEADER_SIZE + sizeof(struct udphdr)) + +/** + * n_dhcp4_outgoing_new() - Allocate new outgoing message + * @outgoingp: output argument to return allocate object through + * @max_size: maximum transmission size to use + * @overload: select sections to overload + * + * This allocates a new outgoing message and returns it to the caller. The + * caller can then append data to it and send it over the wire. + * + * The @max_size parameter specifies the transport-layer MTU to consider. If 0, + * N_DHCP4_NETWORK_IP_MINIMUM_MAX_SIZE is used. Note that this argument + * specifies the maximum packet size *INCLUDING* the IP-headers and UDP-header. + * Internally, the allocator makes sure to never create packets bigger than the + * specified MTU. The append functions will return an error, if the packet size + * would exceed the MTU. + * If you use a full UDP stack that supports packet fragmentation, you can + * specify the maximum packet size here (e.g., UINT16_MAX). + * + * Return: 0 on success, error code on failure. + */ +int n_dhcp4_outgoing_new(NDhcp4Outgoing **outgoingp, size_t max_size, uint8_t overload) { + _c_cleanup_(n_dhcp4_outgoing_freep) NDhcp4Outgoing *outgoing = NULL; + + c_assert(!(overload & ~(N_DHCP4_OVERLOAD_FILE | N_DHCP4_OVERLOAD_SNAME))); + + /* + * Make sure the minimum limit is bigger than the maximum protocol + * header plus the DHCP-message-header plus a single OPTION_END byte. + */ + static_assert(N_DHCP4_NETWORK_IP_MINIMUM_MAX_SIZE >= N_DHCP4_OUTGOING_MAX_PHDR + + sizeof(NDhcp4Message) + 1, + "Invalid minimum IP packet limit"); + + outgoing = calloc(1, sizeof(*outgoing)); + if (!outgoing) + return -ENOMEM; + + *outgoing = (NDhcp4Outgoing)N_DHCP4_OUTGOING_NULL(*outgoing); + outgoing->n_message = N_DHCP4_NETWORK_IP_MINIMUM_MAX_SIZE - N_DHCP4_OUTGOING_MAX_PHDR; + outgoing->i_message = offsetof(NDhcp4Message, options); + outgoing->max_size = outgoing->n_message; + outgoing->overload = overload; + + if (max_size > N_DHCP4_NETWORK_IP_MINIMUM_MAX_SIZE) + outgoing->max_size = max_size - N_DHCP4_OUTGOING_MAX_PHDR; + + outgoing->message = calloc(1, outgoing->n_message); + if (!outgoing->message) + return -ENOMEM; + + outgoing->message->magic = htonl(N_DHCP4_MESSAGE_MAGIC); + outgoing->message->options[0] = N_DHCP4_OPTION_END; + + *outgoingp = outgoing; + outgoing = NULL; + return 0; +} + +/** + * n_dhcp4_outgoing_free() - Deallocate outgoing message + * @outgoing: message to deallocate, or NULL + * + * This is the opposite to n_dhcp4_outgoing_new(). It deallocates and frees the + * passed object. If @outgoing is NULL, this is a no-op. + * + * Return: NULL is returned. + */ +NDhcp4Outgoing *n_dhcp4_outgoing_free(NDhcp4Outgoing *outgoing) { + if (!outgoing) + return NULL; + + free(outgoing->message); + free(outgoing); + + return NULL; +} + +/** + * n_dhcp4_outgoing_get_header() - Get pointer to the message header + * @outgoing: message to operate on + * + * This returns a pointer to the DHCP4 message header to the caller. The caller + * can use this to fill-in the header-fields. Note that all fields are + * initialized to their default values. Hence, you only need to override the + * fields where the default is not sufficient. + * + * Return: A pointer to the message header is returned. + */ +NDhcp4Header *n_dhcp4_outgoing_get_header(NDhcp4Outgoing *outgoing) { + return &outgoing->message->header; +} + +/** + * n_dhcp4_outgoing_get_raw() - Get the raw message blob + * @outgoing: message to operat on + * @rawp: output argument for the message-blob + * + * This function gives the caller access to the raw message-blob. That is, once + * message-marshaling is complete, use this to get the raw blob for sending. + * Note that this blob is only valid as long as you no longer append any + * further options to the message, nor modify it in any other way. + * + * Return: The size of the raw message blob is returned. + */ +size_t n_dhcp4_outgoing_get_raw(NDhcp4Outgoing *outgoing, const void **rawp) { + if (rawp) + *rawp = outgoing->message; + + /* + * Return the DHCP message until the END option, excluding any + * trailing padding. We overallocate during append, so the + * allocated message might be bigger than what we want to + * send on the wire. + */ + return outgoing->i_message + 1; +} + +static void n_dhcp4_outgoing_append_option(NDhcp4Outgoing *outgoing, + uint8_t option, + const void *data, + uint8_t n_data) { + uint8_t *blob = (void *)outgoing->message; + + blob[outgoing->i_message++] = option; + blob[outgoing->i_message++] = n_data; + memcpy(blob + outgoing->i_message, data, n_data); + outgoing->i_message += n_data; + blob[outgoing->i_message] = N_DHCP4_OPTION_END; +} + +/** + * n_dhcp4_outgoing_append() - Append option to outgoing message + * @outgoing: message to operate on + * @option: option code to append + * @data: data to append in the option + * @n_data: length of the data blob + * + * This appends another option to the given outgoing message. The data is taken + * verbatim and copied into the message. Note that no validation is done. If + * you provide an option multiple times, it will be added multiple times (spec + * then requires them to be interpreted as concatenated option, in case the + * option is marked as such). + * + * The size of a message is limited, based on the restriction passed to the + * outgoing-message constructor. If there is not enough free space to copy in + * the new option, N_DHCP4_E_NO_SPACE is returned. + * + * The order in which you append options might matter to some implementations. + * For example, the message-type is often expected to be the first option. We + * do not place such restrictions, but for compatibility with external + * implementations, you should follow these recommendations. + * Furthermore, we do not implement any kind of smart allocators. That is, all + * options are simply appended when you call this. But due to the overloading + * feature, fragmentation might matter. Hence, if you use overloading, overly + * big options might cause padding, and as such waste space. + * + * Return: 0 on success, negative error code on failure, N_DHCP4_E_NO_SPACE + * when there is not sufficient free space in the message. + */ +int n_dhcp4_outgoing_append(NDhcp4Outgoing *outgoing, + uint8_t option, + const void *data, + uint8_t n_data) { + NDhcp4Message *m; + uint8_t overload; + size_t rem, n; + + c_assert(option != N_DHCP4_OPTION_PAD); + c_assert(option != N_DHCP4_OPTION_END); + c_assert(option != N_DHCP4_OPTION_OVERLOAD); + + /* + * If the iterator is on the OPTIONs field, try appending the new blob. + * We need 2 header-bytes plus @n_data bytes. Additionally, we always + * reserve 3 trailing bytes for a possible OVERLOAD option, and 1 byte + * for the END marker. + */ + if (outgoing->i_message >= offsetof(NDhcp4Message, options)) { + rem = outgoing->n_message - outgoing->i_message; + + /* try fitting into remaining OPTIONs space */ + if (rem >= n_data + 2U + 3U + 1U) { + n_dhcp4_outgoing_append_option(outgoing, option, data, n_data); + return 0; + } + + /* try fitting into allowed OPTIONs space */ + if (outgoing->max_size - outgoing->i_message >= n_data + 2U + 3U + 1U) { + /* try over-allocation to reduce allocation pressure */ + n = outgoing->n_message + n_data + 128; + if (n > outgoing->max_size) + n = outgoing->max_size; + m = realloc(outgoing->message, n); + if (!m) + return -ENOMEM; + + memset((void *)m + outgoing->i_message, 0, n - outgoing->i_message); + outgoing->message = m; + outgoing->n_message = n; + n_dhcp4_outgoing_append_option(outgoing, option, data, n_data); + return 0; + } + + /* not enough remaining space, try OVERLOAD */ + if (!outgoing->overload) + return N_DHCP4_E_NO_SPACE; + + /* + * We ran out of space in the OPTIONs array, but overloading + * was enabled. This means, we can insert an OVERLOAD option + * and then use SNAME/FILE to store more options. + * Note that the three different sections cannot overlap and + * all must have an END marker. So as soon as we add the + * OVERLOAD option, we must make sure the other sections have + * the valid END marker. From then on, our *_append_option() + * helper makes sure to move the END marker with every + * insertion. + */ + overload = outgoing->overload; + n_dhcp4_outgoing_append_option(outgoing, N_DHCP4_OPTION_OVERLOAD, &overload, 1); + + if (overload & N_DHCP4_OVERLOAD_FILE) + outgoing->message->file[0] = N_DHCP4_OPTION_END; + if (overload & N_DHCP4_OVERLOAD_SNAME) + outgoing->message->sname[0] = N_DHCP4_OPTION_END; + + if (overload & N_DHCP4_OVERLOAD_FILE) + outgoing->i_message = offsetof(NDhcp4Message, file); + else if (overload & N_DHCP4_OVERLOAD_SNAME) + outgoing->i_message = offsetof(NDhcp4Message, sname); + } + + /* + * The OPTIONs section is full and OVERLOAD was enabled. Try writing + * into the FILE section. Always reserve 1 byte for the trailing END + * marker. + */ + if (outgoing->i_message >= offsetof(NDhcp4Message, file)) { + rem = sizeof(outgoing->message->file); + rem -= outgoing->i_message - offsetof(NDhcp4Message, file); + + if (rem >= n_data + 2U + 1U) { + n_dhcp4_outgoing_append_option(outgoing, option, data, n_data); + return 0; + } + + if (overload & N_DHCP4_OVERLOAD_SNAME) + outgoing->i_message = offsetof(NDhcp4Message, sname); + else + return N_DHCP4_E_NO_SPACE; + } + + /* + * OPTIONs and FILE are full, try putting data into the SNAME section + * as a last resort. + */ + if (outgoing->i_message >= offsetof(NDhcp4Message, sname)) { + rem = sizeof(outgoing->message->sname); + rem -= outgoing->i_message - offsetof(NDhcp4Message, sname); + + if (rem >= n_data + 2U + 1U) { + n_dhcp4_outgoing_append_option(outgoing, option, data, n_data); + return 0; + } + } + + return N_DHCP4_E_NO_SPACE; +} + +static int n_dhcp4_outgoing_append_u32(NDhcp4Outgoing *message, uint8_t option, uint32_t u32) { + uint32_t be32 = htonl(u32); + int r; + + r = n_dhcp4_outgoing_append(message, option, &be32, sizeof(be32)); + if (r) + return r; + + return 0; +} + +static int n_dhcp4_outgoing_append_in_addr(NDhcp4Outgoing *message, uint8_t option, struct in_addr addr) { + int r; + + r = n_dhcp4_outgoing_append(message, option, &addr.s_addr, sizeof(addr.s_addr)); + if (r) + return r; + + return 0; +} + +int n_dhcp4_outgoing_append_t1(NDhcp4Outgoing *message, uint32_t t1) { + return n_dhcp4_outgoing_append_u32(message, N_DHCP4_OPTION_RENEWAL_T1_TIME, t1); +} + +int n_dhcp4_outgoing_append_t2(NDhcp4Outgoing *message, uint32_t t2) { + return n_dhcp4_outgoing_append_u32(message, N_DHCP4_OPTION_REBINDING_T2_TIME, t2); +} + +int n_dhcp4_outgoing_append_lifetime(NDhcp4Outgoing *message, uint32_t lifetime) { + return n_dhcp4_outgoing_append_u32(message, N_DHCP4_OPTION_IP_ADDRESS_LEASE_TIME, lifetime); +} + +int n_dhcp4_outgoing_append_server_identifier(NDhcp4Outgoing *message, struct in_addr addr) { + return n_dhcp4_outgoing_append_in_addr(message, N_DHCP4_OPTION_SERVER_IDENTIFIER, addr); +} + +int n_dhcp4_outgoing_append_requested_ip(NDhcp4Outgoing *message, struct in_addr addr) { + return n_dhcp4_outgoing_append_in_addr(message, N_DHCP4_OPTION_REQUESTED_IP_ADDRESS, addr); +} + +void n_dhcp4_outgoing_set_secs(NDhcp4Outgoing *message, uint32_t secs) { + NDhcp4Header *header = n_dhcp4_outgoing_get_header(message); + + /* + * Some DHCP servers will reject DISCOVER or REQUEST messages if 'secs' + * is not set (i.e., set to 0), even though the spec allows it. + */ + c_assert(secs); + + header->secs = htonl(secs); +} + +void n_dhcp4_outgoing_set_xid(NDhcp4Outgoing *message, uint32_t xid) { + NDhcp4Header *header = n_dhcp4_outgoing_get_header(message); + + header->xid = xid; +} + +void n_dhcp4_outgoing_get_xid(NDhcp4Outgoing *message, uint32_t *xidp) { + NDhcp4Header *header = n_dhcp4_outgoing_get_header(message); + + *xidp = header->xid; +} + +void n_dhcp4_outgoing_set_yiaddr(NDhcp4Outgoing *message, struct in_addr yiaddr) { + NDhcp4Header *header = n_dhcp4_outgoing_get_header(message); + + header->yiaddr = yiaddr.s_addr; +} |