Change fill_one() to accept a buffer pointer and capacity instead of a struct msg pointer. This is a pure refactor with no behavior change, preparing for option overload support where fill_one() will also write into the file and sname fields. Link: https://bugs.passt.top/show_bug.cgi?id=192 Signed-off-by: Anshu Kumari --- v7: - no changes. v6: - no changes. v5: - Restore debug messages for skipped options in fill() - Add /* code and length of option */ comment in size check - Use buf + *offset instead of &buf[*offset] for memcpy v3: - Restored removed comments: "If we don't have space to write the option, then just skip" and "Move to option". v2: - Renamed parameter cap → size. --- dhcp.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/dhcp.c b/dhcp.c index c3c74224..bb72b724 100644 --- a/dhcp.c +++ b/dhcp.c @@ -131,28 +131,29 @@ struct msg { } __attribute__((__packed__)); /** - * fill_one() - Fill a single option in message - * @m: Message to fill + * fill_one() - Fill a single option into a buffer + * @buf: Buffer to write option + * @size: Usable size of @buf (excluding end marker) * @o: Option number - * @offset: Current offset within options field, updated on insertion + * @offset: Current offset within @buf, updated on insertion * - * Return: false if m has space to write the option, true otherwise + * Return: false if @buf has space to write the option, true otherwise */ -static bool fill_one(struct msg *m, int o, int *offset) +static bool fill_one(uint8_t *buf, size_t size, int o, int *offset) { size_t slen = opts[o].slen; /* If we don't have space to write the option, then just skip */ - if (*offset + 2 /* code and length of option */ + slen > OPT_MAX) + if (*offset + 2 /* code and length of option */ + slen > size) return true; - m->o[*offset] = o; - m->o[*offset + 1] = slen; + buf[*offset] = o; + buf[*offset + 1] = slen; /* Move to option */ *offset += 2; - memcpy(&m->o[*offset], opts[o].s, slen); + memcpy(buf + *offset, opts[o].s, slen); opts[o].sent = 1; *offset += slen; @@ -177,19 +178,19 @@ static int fill(struct msg *m) * Put it there explicitly, unless requested via option 55. */ if (opts[55].clen > 0 && !memchr(opts[55].c, 53, opts[55].clen)) - if (fill_one(m, 53, &offset)) - debug("DHCP: skipping option 53"); + if (fill_one(m->o, OPT_MAX, 53, &offset)) + debug("DHCP: skipping option 53"); for (i = 0; i < opts[55].clen; i++) { o = opts[55].c[i]; if (opts[o].slen != -1) - if (fill_one(m, o, &offset)) + if (fill_one(m->o, OPT_MAX, o, &offset)) debug("DHCP: skipping option %i", o); } for (o = 0; o < 255; o++) { if (opts[o].slen != -1 && !opts[o].sent) - if (fill_one(m, o, &offset)) + if (fill_one(m->o, OPT_MAX, o, &offset)) debug("DHCP: skipping option %i", o); } -- 2.55.0

Add a --dhcp-opt CODE,VALUE flag that sets any DHCP option by numeric code with type-aware parsing per RFC 2132. A type lookup table maps option codes to RFC 2132 value types (IPv4, IPv4 list, integer, string). dhcp_opt_parse() converts CLI strings to binary wire format; parsed options are stored in opts[] and injected into DHCP replies. Options set via --dhcp-opt (OPT_USER) take priority over host-derived defaults (OPT_DEFAULT). Link: https://bugs.passt.top/show_bug.cgi?id=192 Signed-off-by: Anshu Kumari --- v7: - Removed client-only options 50 (Requested IP) and 57 (Max Message Size) from dhcp_opt_types[] - Switched integer parsing from strtoul()/strtol() to parse_unsigned() for UINT8/UINT16/UINT32 types - Fixed alignment: use htons()/htonl() + memcpy() instead of direct pointer casts for UINT16/UINT32 encoding. - Used explicit OPT_DEFAULT check instead of != OPT_USER where the condition body does not set conf. - Removed unnecessary OPT_USER guard on option 121 - Checked inet_ntop() return value in dhcp_opt_to_str() v6: - dropped option 53. - Used parse_unsigned(), parse_literal(), parse_ipv4() from parse.c instead of manual strtoul/inet_pton. - Moved option-parsing variables into case 34 block scope. - Used htons()/htonl() for integer encoding. - Used assert() for boundary checks in dhcp_opt_to_str(). - Used snprintf() with %.*s for string formatting in dhcp_opt_to_str(). - Used sizeof(struct in_addr) instead of literal 4. - dhcp_opt_to_str() checks OPT_UNSET for all states, not just OPT_USER. - Added curly brackets for multi-line conditionals. - Dropped trailing comma after OPT_DEFAULT in initializers to reduce line length. v5: - Rename enum values: INT8/INT16/INT32/SINT32 → UINT8/UINT16/UINT32/INT32 - Change int len to size_t len in dhcp_opt_parse(), remove int casts - Make dhcp_opt_parse() static, add dhcp_set_opt() to store options directly in opts[] at startup instead of double-parsing via ctx->dhcp_opts - Add OPT_USER to enum opt_state to protect user options from being overwritten by built-in defaults - Add dhcp_opt_to_str() for conf_print() display - Remove dhcp_opts[] from struct ctx in passt.h - Remove conf_dhcp_option() wrapper from conf.c v4: - Renamed custom_opts to dhcp_opts, 256 entries indexed by option code, removed MAX_CUSTOM_DHCP_OPTS and count field. - Changed str buffer from 256 to 255 bytes. - Moved function to conf.c as static conf_dhcp_option(), renamed from dhcp_add_option(). - Made dhcp_opt_parse() non-static, declared in dhcp.h - Dropped val/len from ctx struct; conf_dhcp_option() validates with temp buffer, dhcp() parses str directly into opts[] at reply time. - Replaced strtok_r() + 256-byte buffer with strcspn() + INET_ADDRSTRLEN buffer. - Added DHCP_OPT_SINT32 for option 2 (Time Offset), uses strtol() per RFC 2132 Section 8.2. - All errors in dhcp_opt_parse() return -1, removed die() calls; caller handles error message consistently. - Removed redundant !slen check in DHCP_OPT_STR case. - Omitted explicit array size for dhcp_opt_types[], arraydded bounds check before lookup. - Added errno = 0 + errno check for strtoul() in case 34. - Fixed usage text: "Set DHCP option CODE to VAL". - Improved man page: added format description and examples v3: - Replaced DHCP_OPT_INTEGER with separate DHCP_OPT_INT8/INT16/INT32 enums, removed dhcp_opt_int_width[] array. - Shared logic between DHCP_OPT_IPV4 and DHCP_OPT_IPV4_LIST — parse both as list, error if >1 in single case. - Added errno = 0 before strtoul() and check after. - Fixed range check: 1ULL << (width * 8) for all widths including width==4. - strncpy → memcpy for DHCP_OPT_STR. - Moved enum to dhcp.c since not used in other files. - Removed options 55, 61 (client-only), 119 (DNS compression, use --dhcp-search instead), 33 (IP pairs not supported). - DHCP_OPT_PARSE_BUF 1024 → char tmp[256]. - Upgraded dhcp_add_option() to call dhcp_opt_parse() and populate val[]/len. - Aligned array entries for readability. - Added tab after @DHCP_OPT_IPV4_LIST: in kerneldoc. - Reject empty value strings before parsing - Reject leading/trailing/consecutive commas in IP list values. v2: - Replaced struct lookup table + dhcp_opt_type_lookup() function with flat dhcp_opt_types[256] array indexed by code. - Consolidated DHCP_OPT_UINT8/UINT16/UINT32 into single DHCP_OPT_INTEGER with dhcp_opt_int_width[256] table. - Dropped DHCP_OPT_ROUTES / option 121 entirely. - Added kerneldoc for enum dhcp_opt_type values. - Removed curly braces from switch cases, declarations before switch. - Added newlines before return statements. - Changed IP list delimiter from space to comma (--dhcp-opt 6,1.1.1.1,8.8.8.8). - Defined DHCP_OPT_PARSE_BUF constant for bare 1024. - Added len and val[255] fields to struct here (moved from patch 1). - Added kerneldoc for @custom_opts.len and @custom_opts.val. - Wired dhcp_opt_parse() into case 32 (--dhcp-boot) to populate val/len. --- conf.c | 27 ++++- dhcp.c | 332 +++++++++++++++++++++++++++++++++++++++++++++++++++----- dhcp.h | 2 + passt.1 | 41 +++++++ 4 files changed, 376 insertions(+), 26 deletions(-) diff --git a/conf.c b/conf.c index faf26814..c12a9335 100644 --- a/conf.c +++ b/conf.c @@ -47,6 +47,7 @@ #include "lineread.h" #include "isolation.h" #include "log.h" +#include "dhcp.h" #include "vhost_user.h" #include "epoll_ctl.h" #include "conf.h" @@ -632,7 +633,8 @@ static void usage(const char *name, FILE *f, int status) " -S, --search LIST Space-separated list, search domains\n" " a single, empty option disables the DNS search list\n" " -H, --hostname NAME Hostname to configure client with\n" - " --fqdn NAME FQDN to configure client with\n"); + " --fqdn NAME FQDN to configure client with\n" + " --dhcp-opt CODE,VAL Set DHCP option CODE to VAL\n"); if (strstr(name, "pasta")) FPRINTF(f, " default: don't use any search list\n"); else @@ -860,6 +862,10 @@ static void conf_print(const struct ctx *c) info(" router: %s", inet_ntop(AF_INET, &c->ip4.guest_gw, buf, sizeof(buf))); + for (i = 1; i < 255; i++) { + if (dhcp_opt_to_str(i, buf, sizeof(buf))) + info(" option %u: %s", i, buf); + } } for (i = 0; i < ARRAY_SIZE(c->ip4.dns); i++) { @@ -1348,6 +1354,7 @@ void conf(struct ctx *c, int argc, char **argv) {"stats", required_argument, NULL, 31 }, {"conf-path", required_argument, NULL, 'c' }, {"chroot-fallback", no_argument, NULL, 32 }, + {"dhcp-opt", required_argument, NULL, 34 }, { 0 }, }; const char *optstring = "+dqfel:hs:c:F:I:p:P:m:a:n:M:g:i:o:D:S:H:461t:u:T:U:"; @@ -1589,6 +1596,24 @@ void conf(struct ctx *c, int argc, char **argv) case 32: c->chroot_fallback = true; break; + case 34: { + unsigned long optcode; + + p = optarg; + + if (!parse_unsigned(&p, 0, &optcode) || + !parse_literal(&p, ",")) { + die("--dhcp-opt requires CODE,VALUE format"); + } + + if (optcode < 1 || optcode > 254) { + die("DHCP option code must be 1-254: %s", + optarg); + } + + dhcp_set_opt(optcode, p); + break; + } case 'd': c->debug = 1; c->quiet = 0; diff --git a/dhcp.c b/dhcp.c index 2a8a82f6..dd3ab6c6 100644 --- a/dhcp.c +++ b/dhcp.c @@ -23,6 +23,7 @@ #include #include #include +#include #include "util.h" #include "ip.h" @@ -32,15 +33,18 @@ #include "tap.h" #include "log.h" #include "dhcp.h" +#include "parse.h" /** * enum opt_conf - DHCP option configuration * @OPT_UNSET: Option not configured * @OPT_DEFAULT: Option derived from host configuration + * @OPT_USER: Option set via --dhcp-opt command line */ enum opt_conf { OPT_UNSET = 0, OPT_DEFAULT, + OPT_USER, }; /** @@ -50,7 +54,7 @@ enum opt_conf { * @s: Option payload from server * @clen: Length of option received from client, -1 if not received * @c: Option payload from client - * @conf: Option configuration (unset or default) + * @conf: Option configuration (unset, default, or user) */ struct opt { int sent; @@ -85,17 +89,20 @@ static struct opt opts[256]; */ void dhcp_init(void) { - /* Mask */ - opts[1] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; - /* Router */ - opts[3] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; - /* Lease time */ - opts[51] = (struct opt) { 0, 4, { 0xff, 0xff, 0xff, 0xff }, - 0, { 0 }, OPT_DEFAULT }; + if (opts[1].conf != OPT_USER) /* Mask */ + opts[1] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; + if (opts[3].conf != OPT_USER) /* Router */ + opts[3] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; + if (opts[51].conf != OPT_USER) { /* Lease time */ + opts[51] = (struct opt) { 0, 4, { 0xff, 0xff, 0xff, 0xff }, + 0, { 0 }, OPT_DEFAULT }; + } /* Type */ opts[53] = (struct opt) { 0, 1, { 0 }, 0, { 0 }, OPT_DEFAULT }; - /* Server ID */ - opts[54] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; + if (opts[54].conf != OPT_USER) { /* Server ID */ + opts[54] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, + OPT_DEFAULT }; + } } /** @@ -140,6 +147,271 @@ struct msg { uint8_t o[OPT_MAX + 1 /* End option */ ]; } __attribute__((__packed__)); +/** + * enum dhcp_opt_type - DHCP option value types per RFC 2132 + * @DHCP_OPT_NONE: Unsupported or unknown option + * @DHCP_OPT_STR: Variable-length string + * @DHCP_OPT_IPV4: Single IPv4 address + * @DHCP_OPT_IPV4_LIST: Multiple IPv4 addresses, comma-separated + * @DHCP_OPT_UINT8: Unsigned 8-bit integer + * @DHCP_OPT_UINT16: Unsigned 16-bit integer + * @DHCP_OPT_UINT32: Unsigned 32-bit integer + * @DHCP_OPT_INT32: Signed 32-bit integer + */ +enum dhcp_opt_type { + DHCP_OPT_NONE, + DHCP_OPT_STR, + DHCP_OPT_IPV4, + DHCP_OPT_IPV4_LIST, + DHCP_OPT_UINT8, + DHCP_OPT_UINT16, + DHCP_OPT_UINT32, + DHCP_OPT_INT32, +}; + +/** + * dhcp_opt_types - Maps option code to RFC 2132 value type, indexed by code + */ +static const enum dhcp_opt_type dhcp_opt_types[] = { + [1] = DHCP_OPT_IPV4, /* Subnet Mask */ + [2] = DHCP_OPT_INT32, /* Time Offset */ + [3] = DHCP_OPT_IPV4_LIST, /* Router */ + [4] = DHCP_OPT_IPV4_LIST, /* Time Server */ + [5] = DHCP_OPT_IPV4_LIST, /* Name Server */ + [6] = DHCP_OPT_IPV4_LIST, /* Domain Name Server */ + [7] = DHCP_OPT_IPV4_LIST, /* Log Server */ + [8] = DHCP_OPT_IPV4_LIST, /* Cookie Server */ + [9] = DHCP_OPT_IPV4_LIST, /* LPR Server */ + [10] = DHCP_OPT_IPV4_LIST, /* Impress Server */ + [11] = DHCP_OPT_IPV4_LIST, /* Resource Location Server */ + [12] = DHCP_OPT_STR, /* Host Name */ + [13] = DHCP_OPT_UINT16, /* Boot File Size */ + [15] = DHCP_OPT_STR, /* Domain Name */ + [16] = DHCP_OPT_IPV4, /* Swap Server */ + [17] = DHCP_OPT_STR, /* Root Path */ + [19] = DHCP_OPT_UINT8, /* IP Forwarding */ + [23] = DHCP_OPT_UINT8, /* Default IP TTL */ + [26] = DHCP_OPT_UINT16, /* Interface MTU */ + [28] = DHCP_OPT_IPV4, /* Broadcast Address */ + [37] = DHCP_OPT_UINT8, /* TCP Default TTL */ + [38] = DHCP_OPT_UINT32, /* TCP Keepalive Interval */ + [40] = DHCP_OPT_STR, /* NIS Domain Name */ + [41] = DHCP_OPT_IPV4_LIST, /* NIS Servers */ + [42] = DHCP_OPT_IPV4_LIST, /* NTP Servers */ + [44] = DHCP_OPT_IPV4_LIST, /* NetBIOS Name Server */ + [51] = DHCP_OPT_UINT32, /* IP Address Lease Time */ + [54] = DHCP_OPT_IPV4, /* Server Identifier */ + [58] = DHCP_OPT_UINT32, /* Renewal (T1) Time */ + [59] = DHCP_OPT_UINT32, /* Rebinding (T2) Time */ + [60] = DHCP_OPT_STR, /* Vendor Class Identifier */ + [66] = DHCP_OPT_STR, /* TFTP Server Name */ + [67] = DHCP_OPT_STR, /* Bootfile Name */ + [252] = DHCP_OPT_STR, /* WPAD URL */ +}; + +/** + * dhcp_opt_parse() - Parse a DHCP option value + * @code: DHCP option code + * @str: Value string from command line + * @buf: Output buffer for binary value + * @buf_len: Size of output buffer + * + * Return: number of bytes written to @buf, or -1 on error + */ +static int dhcp_opt_parse(uint8_t code, const char *str, + uint8_t *buf, size_t buf_len) +{ + enum dhcp_opt_type type; + unsigned long val; + uint8_t width; + size_t slen; + size_t len; + char *end; + + if (code >= ARRAY_SIZE(dhcp_opt_types)) + return -1; + + type = dhcp_opt_types[code]; + + if (!*str) + return -1; + + switch (type) { + case DHCP_OPT_NONE: + return -1; + case DHCP_OPT_IPV4: + case DHCP_OPT_IPV4_LIST: + len = 0; + + do { + if (len + sizeof(struct in_addr) > buf_len) + return -1; + + if (!parse_ipv4(&str, + (struct in_addr *)(buf + len))) + return -1; + + len += sizeof(struct in_addr); + + if (type == DHCP_OPT_IPV4) + break; + } while (parse_literal(&str, ",")); + + if (!len || !parse_eoi(str)) + return -1; + + return len; + case DHCP_OPT_UINT8: + case DHCP_OPT_UINT16: + case DHCP_OPT_UINT32: + case DHCP_OPT_INT32: + if (type == DHCP_OPT_UINT8) + width = 1; + else if (type == DHCP_OPT_UINT16) + width = 2; + else + width = 4; + + if (buf_len < width) + return -1; + + if (type == DHCP_OPT_INT32) { + long sval; + + errno = 0; + sval = strtol(str, &end, 0); + if (*end || errno || + sval < INT32_MIN || sval > INT32_MAX) + return -1; + val = (uint32_t)sval; + } else { + if (!parse_unsigned(&str, 0, &val) || + !parse_eoi(str) || + val >= (1ULL << (width * 8))) + return -1; + } + + if (type == DHCP_OPT_UINT16) { + uint16_t v16 = htons(val); + memcpy(buf, &v16, sizeof(v16)); + } else if (type == DHCP_OPT_UINT32 || + type == DHCP_OPT_INT32) { + uint32_t v32 = htonl(val); + memcpy(buf, &v32, sizeof(v32)); + } else { + buf[0] = val; + } + + return width; + case DHCP_OPT_STR: + slen = strlen(str); + + if (slen > buf_len) + return -1; + + memcpy(buf, str, slen); + + return slen; + } + + return -1; +} + +/** + * dhcp_set_opt() - Parse and store a user-specified DHCP option + * @code: DHCP option code + * @val_str: Value string from command line + */ +void dhcp_set_opt(uint8_t code, const char *val_str) +{ + int ret; + + ret = dhcp_opt_parse(code, val_str, opts[code].s, sizeof(opts[code].s)); + if (ret < 0) + die("Invalid value for DHCP option %u: %s", code, val_str); + + opts[code].slen = ret; + opts[code].conf = OPT_USER; +} + +/** + * dhcp_opt_to_str() - Render a binary DHCP option value to a printable string + * @code: DHCP option code + * @buf: Output string buffer + * @buf_len: Size of output buffer + * + * Return: pointer to @buf if option is set, NULL otherwise + */ +const char *dhcp_opt_to_str(uint8_t code, char *buf, size_t buf_len) +{ + enum dhcp_opt_type type; + unsigned int i; + int off = 0; + + if (opts[code].conf == OPT_UNSET) + return NULL; + + assert(code < ARRAY_SIZE(dhcp_opt_types)); + + type = dhcp_opt_types[code]; + + switch (type) { + case DHCP_OPT_IPV4: + case DHCP_OPT_IPV4_LIST: + for (i = 0; i + sizeof(struct in_addr) <= (unsigned int)opts[code].slen; + i += sizeof(struct in_addr)) { + if (off) { + if (off + 1 >= (int)buf_len) + return NULL; + buf[off++] = ','; + } + if (!inet_ntop(AF_INET, opts[code].s + i, + buf + off, buf_len - off)) + return NULL; + off += strlen(buf + off); + } + return buf; + case DHCP_OPT_UINT8: + case DHCP_OPT_UINT16: + case DHCP_OPT_UINT32: { + uint32_t val = 0; + + if (opts[code].slen == 1) { + val = opts[code].s[0]; + } else if (opts[code].slen == 2) { + uint16_t v16; + memcpy(&v16, opts[code].s, sizeof(v16)); + val = ntohs(v16); + } else if (opts[code].slen == 4) { + memcpy(&val, opts[code].s, sizeof(val)); + val = ntohl(val); + } + + if (snprintf(buf, buf_len, "%u", val) >= (int)buf_len) + return NULL; + return buf; + } + case DHCP_OPT_INT32: { + int32_t val; + uint32_t v32; + + assert(opts[code].slen == 4); + memcpy(&v32, opts[code].s, sizeof(v32)); + val = (int32_t)ntohl(v32); + + if (snprintf(buf, buf_len, "%d", val) >= (int)buf_len) + return NULL; + return buf; + } + case DHCP_OPT_STR: + (void)snprintf(buf, buf_len, "%.*s", + opts[code].slen, opts[code].s); + return buf; + default: + assert(0); + } +} + /** * fill_one() - Fill a single option into a buffer * @buf: Buffer to write option @@ -425,9 +697,14 @@ int dhcp(const struct ctx *c, struct iov_tail *data) info(" from %s", eth_ntop(m->chaddr, macstr, sizeof(macstr))); mask.s_addr = htonl(0xffffffff << (32 - c->ip4.prefix_len)); - memcpy(opts[1].s, &mask, sizeof(mask)); - memcpy(opts[3].s, &c->ip4.guest_gw, sizeof(c->ip4.guest_gw)); - memcpy(opts[54].s, &c->ip4.our_tap_addr, sizeof(c->ip4.our_tap_addr)); + if (opts[1].conf == OPT_DEFAULT) + memcpy(opts[1].s, &mask, sizeof(mask)); + if (opts[3].conf == OPT_DEFAULT) + memcpy(opts[3].s, &c->ip4.guest_gw, sizeof(c->ip4.guest_gw)); + if (opts[54].conf == OPT_DEFAULT) { + memcpy(opts[54].s, &c->ip4.our_tap_addr, + sizeof(c->ip4.our_tap_addr)); + } /* If the gateway is not on the assigned subnet, send an option 121 * (Classless Static Routing) adding a dummy route to it. @@ -444,25 +721,30 @@ int dhcp(const struct ctx *c, struct iov_tail *data) &c->ip4.guest_gw, sizeof(c->ip4.guest_gw)); } - if (c->mtu) { + if (opts[26].conf != OPT_USER && c->mtu) { + uint16_t mtu_n = htons(c->mtu); + opts[26].slen = 2; opts[26].conf = OPT_DEFAULT; - opts[26].s[0] = c->mtu / 256; - opts[26].s[1] = c->mtu % 256; + memcpy(opts[26].s, &mtu_n, sizeof(mtu_n)); } - for (i = 0, opts[6].slen = 0; - !c->no_dhcp_dns && i < ARRAY_SIZE(c->ip4.dns); i++) { - if (IN4_IS_ADDR_UNSPECIFIED(&c->ip4.dns[i])) - break; - ((struct in_addr *)opts[6].s)[i] = c->ip4.dns[i]; - opts[6].slen += sizeof(uint32_t); + if (opts[6].conf != OPT_USER) { + opts[6].slen = 0; + for (i = 0; + !c->no_dhcp_dns && i < ARRAY_SIZE(c->ip4.dns); + i++) { + if (IN4_IS_ADDR_UNSPECIFIED(&c->ip4.dns[i])) + break; + ((struct in_addr *)opts[6].s)[i] = c->ip4.dns[i]; + opts[6].slen += sizeof(uint32_t); + } + if (opts[6].slen) + opts[6].conf = OPT_DEFAULT; } - if (opts[6].slen) - opts[6].conf = OPT_DEFAULT; opt_len = strlen(c->hostname); - if (opt_len > 0) { + if (opts[12].conf != OPT_USER && opt_len > 0) { opts[12].slen = opt_len; opts[12].conf = OPT_DEFAULT; memcpy(opts[12].s, &c->hostname, opt_len); diff --git a/dhcp.h b/dhcp.h index cd50c99b..80abda65 100644 --- a/dhcp.h +++ b/dhcp.h @@ -8,5 +8,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data); void dhcp_init(void); +void dhcp_set_opt(uint8_t code, const char *val_str); +const char *dhcp_opt_to_str(uint8_t code, char *buf, size_t buf_len); #endif /* DHCP_H */ diff --git a/passt.1 b/passt.1 index 53e072a9..2bfe7d50 100644 --- a/passt.1 +++ b/passt.1 @@ -440,6 +440,47 @@ Send \fIname\fR as DHCP option 12 (hostname). FQDN to configure the client with. Send \fIname\fR as Client FQDN: DHCP option 81 and DHCPv6 option 39. +.TP +.BR \-\-dhcp-opt " " \fICODE\fR,\fIVALUE\fR +Set DHCP option \fICODE\fR (1\-254) to \fIVALUE\fR. The value format depends +on the option type and is determined automatically from the option code. +Multiple IPv4 addresses are comma-separated. +This option can be specified multiple times. If the same option code is +given more than once, the last value wins. Options set with +\fB\-\-dhcp-opt\fR override built-in values. +.PP +Examples: +.nf + \-\-dhcp-opt 6,8.8.8.8,4.4.4.4 + \-\-dhcp-opt 12,myhostname +.fi +.PP +Only the following option codes are supported (unsupported codes cause an error): +.RS +.TP +.B IPv4 address options +1 (Subnet Mask), 16 (Swap Server), 28 (Broadcast Address), +54 (Server Identifier) +.TP +.B IPv4 address list options (comma-separated) +3 (Router), 4 (Time Server), 5 (Name Server), 6 (DNS), 7 (Log Server), +8 (Cookie Server), 9 (LPR Server), 10 (Impress Server), +11 (Resource Location Server), 41 (NIS Servers), +42 (NTP Servers), 44 (NetBIOS Name Server) +.TP +.B Integer options +2 (Time Offset, 32-bit), 13 (Boot File Size, 16-bit), 19 (IP Forwarding, 8-bit), +23 (Default IP TTL, 8-bit), 26 (Interface MTU, 16-bit), +37 (TCP Default TTL, 8-bit), 38 (TCP Keepalive Interval, 32-bit), +51 (IP Address Lease Time, 32-bit), +58 (Renewal Time, 32-bit), 59 (Rebinding Time, 32-bit) +.TP +.B String options +12 (Host Name), 15 (Domain Name), 17 (Root Path), 40 (NIS Domain Name), +60 (Vendor Class Identifier), 66 (TFTP Server Name), +67 (Bootfile Name), 252 (WPAD URL) +.RE + .TP .BR \-t ", " \-\-tcp-ports " " \fIspec Configure TCP port forwarding to guest or namespace. \fIspec\fR can be either: -- 2.55.0

fill_one() previously returned true on overflow, but callers used this to log a skip message per option — which becomes noisy if the options field is full. Instead, rely on opts[].sent (already set by fill_one()) to detect unsent options: a final reporting loop walks all options and logs a single skip message for each one that couldn't be sent. This also makes the return value unnecessary, so change fill_one() to return void. Link: https://bugs.passt.top/show_bug.cgi?id=192 Signed-off-by: Anshu Kumari --- v7: - (new patch) Split out from the option overload patch into its own commit --- dhcp.c | 25 ++++++++----------------- 1 file changed, 8 insertions(+), 17 deletions(-) diff --git a/dhcp.c b/dhcp.c index 4dccae7b..6f69fd62 100644 --- a/dhcp.c +++ b/dhcp.c @@ -418,16 +418,14 @@ const char *dhcp_opt_to_str(uint8_t code, char *buf, size_t buf_len) * @size: Usable size of @buf (excluding end marker) * @o: Option number * @offset: Current offset within @buf, updated on insertion - * - * Return: false if @buf has space to write the option, true otherwise */ -static bool fill_one(uint8_t *buf, size_t size, int o, int *offset) +static void fill_one(uint8_t *buf, size_t size, int o, int *offset) { size_t slen = opts[o].slen; /* If we don't have space to write the option, then just skip */ if (*offset + 2 /* code and length of option */ + slen > size) - return true; + return; buf[*offset] = o; buf[*offset + 1] = slen; @@ -439,7 +437,6 @@ static bool fill_one(uint8_t *buf, size_t size, int o, int *offset) opts[o].sent = 1; *offset += slen; - return false; } /** @@ -459,24 +456,18 @@ static int fill(struct msg *m) * option 53 at the beginning of the list. * Put it there explicitly, unless requested via option 55. */ - if (opts[55].clen > 0 && !memchr(opts[55].c, 53, opts[55].clen)) { - if (fill_one(m->o, OPT_MAX, 53, &offset)) - debug("DHCP: skipping option 53"); - } + if (opts[55].clen > 0 && !memchr(opts[55].c, 53, opts[55].clen)) + fill_one(m->o, OPT_MAX, 53, &offset); for (i = 0; i < opts[55].clen; i++) { o = opts[55].c[i]; - if (opts[o].conf != OPT_UNSET) { - if (fill_one(m->o, OPT_MAX, o, &offset)) - debug("DHCP: skipping option %i", o); - } + if (opts[o].conf != OPT_UNSET) + fill_one(m->o, OPT_MAX, o, &offset); } for (o = 0; o < 255; o++) { - if (opts[o].conf != OPT_UNSET && !opts[o].sent) { - if (fill_one(m->o, OPT_MAX, o, &offset)) - debug("DHCP: skipping option %i", o); - } + if (opts[o].conf != OPT_UNSET && !opts[o].sent) + fill_one(m->o, OPT_MAX, o, &offset); } m->o[offset++] = 255; -- 2.55.0

Implement option splitting per RFC 3396 for options that may exceed 255 bytes. A concat_req[] lookup table marks options requiring concatenation (currently option 81, Client FQDN per RFC 4702). The opts[].s buffer is resized from 255 to OPT_CONCAT_MAX to hold the maximum data that can be split across the options field, file field, and sname field. When a concatenation-requiring option does not fit as a single option in any field, fill() calls fill_split() to split it across fields in RFC 3396 order: options field first, then file, then sname. Each split chunk is capped at 255 bytes per the DHCP option length field limit. Link: https://bugs.passt.top/show_bug.cgi?id=192 Signed-off-by: Anshu Kumari --- v7: - Capped each split chunk at 255 bytes: chunk = MIN(MIN(remaining, avail), 255) to prevent overflow in the uint8_t length field - Replaced inline space calculation with a dry-run pass via fill_split_areas() - Moved OPT_MAX and OPT_CONCAT_MAX definitions above struct opt. - Reordered struct opt fields to place s[OPT_CONCAT_MAX] - Added dry_run parameter to fill_split() v6: - Merged v5 patches 6/7 and 7/7 into a single patch. - Replaced DHCP_OPT_STR_CONCAT enum value and is_concat_opt() helper with a concat_req[] boolean lookup table. - Used MIN() macro instead of ternary for chunk size. - Fixed space calculation to account for 2-byte code+length overhead per chunk. v5: - New patch: implement option splitting per RFC 3396 for options exceeding 255 bytes - Add DHCP_OPT_STR_CONCAT type, is_concat_opt(), fill_split() helpers - Resize opts[].s from 255 to OPT_CONCAT_MAX (497) bytes - Add /* fallthrough */ between DHCP_OPT_STR and DHCP_OPT_STR_CONCAT case --- dhcp.c | 160 ++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 142 insertions(+), 18 deletions(-) diff --git a/dhcp.c b/dhcp.c index 63ac8e3d..990b650d 100644 --- a/dhcp.c +++ b/dhcp.c @@ -35,6 +35,19 @@ #include "dhcp.h" #include "parse.h" +#define OPT_MIN 60 /* RFC 951 */ + +/* Total option size (excluding end option) is 576 (RFC 2131), minus + * offset of options (268), minus end option (1). + */ +#define OPT_MAX 307 + +/* RFC 3396: maximum option data that can be split across options field + * (OPT_MAX - 2), file field (64 - 2), and sname field (128 - 2), + * minus code+length overhead per portion. + */ +#define OPT_CONCAT_MAX (OPT_MAX - 2 + 64 - 2 + 128 - 2) + /** * enum opt_conf - DHCP option configuration * @OPT_UNSET: Option not configured @@ -51,18 +64,18 @@ enum opt_conf { * struct opt - DHCP option * @sent: Convenience flag, set while filling replies * @slen: Length of option defined for server - * @s: Option payload from server * @clen: Length of option received from client, -1 if not received * @c: Option payload from client * @conf: Option configuration (unset, default, or user) + * @s: Option payload from server */ struct opt { int sent; int slen; - uint8_t s[255]; int clen; uint8_t c[255]; enum opt_conf conf; + uint8_t s[OPT_CONCAT_MAX]; }; static struct opt opts[256]; @@ -79,32 +92,23 @@ static struct opt opts[256]; #define DHCPINFORM 8 #define DHCPFORCERENEW 9 -#define OPT_MIN 60 /* RFC 951 */ - -/* Total option size (excluding end option) is 576 (RFC 2131), minus - * offset of options (268), minus end option (1). - */ -#define OPT_MAX 307 - /** * dhcp_init() - Initialise DHCP options */ void dhcp_init(void) { if (opts[1].conf != OPT_USER) /* Mask */ - opts[1] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; + opts[1] = (struct opt) { 0, 4, 0, { 0 }, OPT_DEFAULT, { 0 } }; if (opts[3].conf != OPT_USER) /* Router */ - opts[3] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, OPT_DEFAULT }; + opts[3] = (struct opt) { 0, 4, 0, { 0 }, OPT_DEFAULT, { 0 } }; if (opts[51].conf != OPT_USER) { /* Lease time */ - opts[51] = (struct opt) { 0, 4, { 0xff, 0xff, 0xff, 0xff }, - 0, { 0 }, OPT_DEFAULT }; + opts[51] = (struct opt) { 0, 4, 0, { 0 }, OPT_DEFAULT, + { 0xff, 0xff, 0xff, 0xff } }; } /* Type */ - opts[53] = (struct opt) { 0, 1, { 0 }, 0, { 0 }, OPT_DEFAULT }; - if (opts[54].conf != OPT_USER) { /* Server ID */ - opts[54] = (struct opt) { 0, 4, { 0 }, 0, { 0 }, - OPT_DEFAULT }; - } + opts[53] = (struct opt) { 0, 1, 0, { 0 }, OPT_DEFAULT, { 0 } }; + if (opts[54].conf != OPT_USER) /* Server ID */ + opts[54] = (struct opt) { 0, 4, 0, { 0 }, OPT_DEFAULT, { 0 } }; } /** @@ -211,6 +215,11 @@ static const enum dhcp_opt_type dhcp_opt_types[] = { [252] = DHCP_OPT_STR, /* WPAD URL */ }; +/* Options requiring RFC 3396 concatenation, indexed by code */ +static const bool concat_req[256] = { + [81] = true, /* Client FQDN (RFC 4702, Section 2) */ +}; + /** * dhcp_opt_parse() - Parse a DHCP option value * @code: DHCP option code @@ -308,6 +317,9 @@ static int dhcp_opt_parse(uint8_t code, const char *str, case DHCP_OPT_STR: slen = strlen(str); + if (!concat_req[code] && slen > 255) + return -1; + if (slen > buf_len) return -1; @@ -441,6 +453,45 @@ static void fill_one(uint8_t *buf, size_t size, int o, int *offset) *offset += slen; } +/** + * fill_split() - Write a split portion of an option into a buffer + * @buf: Buffer to write into + * @size: Usable size of @buf + * @o: Option number (code) + * @offset: Current offset within @buf, updated on write + * @data: Pointer to remaining option data to write + * @remaining: Bytes of option data still to write + * @dry_run: If true, calculate size without writing to @buf + * + * Return: number of data bytes written (excluding code+length header) + */ +static size_t fill_split(uint8_t *buf, size_t size, int o, int *offset, + const uint8_t *data, size_t remaining, + bool dry_run) +{ + size_t avail, chunk; + + if (*offset + 2 >= (int)size) + return 0; + + avail = size - *offset - 2; + chunk = MIN(MIN(remaining, avail), 255); + if (!chunk) + return 0; + + if (!dry_run) { + buf[*offset] = o; + buf[*offset + 1] = chunk; + } + *offset += 2; + + if (!dry_run) + memcpy(buf + *offset, data, chunk); + *offset += chunk; + + return chunk; +} + /** * enum dhcp_overload - DHCP option overload values (RFC 2132, Section 9.3) * @DHCP_OVERLOAD_NONE: No overload @@ -453,6 +504,43 @@ enum dhcp_overload { DHCP_OVERLOAD_SNAME = 2, }; +/** + * fill_split_areas() - Write a split option across options, file, and sname areas + * @m: Message to write into + * @opt_size: Usable size of the options area + * @o: Option number (code) + * @opt_off: Current offset within options area, updated on write + * @file_off: Current offset within file area, updated on write + * @sname_off: Current offset within sname area, updated on write + * @has_bootfile: If true, skip the file field + * @dry_run: If true, calculate size without writing + * + * Return: total data bytes written across all areas + */ +static size_t fill_split_areas(struct msg *m, size_t opt_size, int o, + int *opt_off, int *file_off, int *sname_off, + bool has_bootfile, bool dry_run) +{ + size_t written = 0; + + written += fill_split(m->o, opt_size, o, opt_off, + opts[o].s, opts[o].slen, dry_run); + if (written < (size_t)opts[o].slen && !has_bootfile) { + written += fill_split(m->file, sizeof(m->file) - 1, o, + file_off, + opts[o].s + written, + opts[o].slen - written, dry_run); + } + if (written < (size_t)opts[o].slen) { + written += fill_split(m->sname, sizeof(m->sname) - 1, o, + sname_off, + opts[o].s + written, + opts[o].slen - written, dry_run); + } + + return written; +} + /** * fill() - Fill options in message, with overload into file/sname if needed * @m: Message to fill @@ -504,6 +592,42 @@ static int fill(struct msg *m, bool has_bootfile) } } + /* RFC 3396: split concatenation-requiring options that didn't fit + * as a single option. Split order: options, file, sname. + */ + foreach_opt(o) { + int dry_off, dry_file_off, dry_sname_off; + size_t total, written; + + if (opts[o].conf == OPT_UNSET || opts[o].sent || + !concat_req[o]) + continue; + + /* Dry run: verify the option fits across all areas */ + dry_off = offset; + dry_file_off = file_off; + dry_sname_off = sname_off; + + total = fill_split_areas(m, size, o, + &dry_off, &dry_file_off, + &dry_sname_off, + has_bootfile, true); + + if (total < (size_t)opts[o].slen) { + debug("DHCP: skipping option %i (no space to split)", + o); + continue; + } + + /* Actual write */ + written = fill_split_areas(m, size, o, + &offset, &file_off, &sname_off, + has_bootfile, false); + + if (written >= (size_t)opts[o].slen) + opts[o].sent = 1; + } + /* Report any options that could not be sent */ foreach_opt(o) { if (opts[o].conf != OPT_UNSET && !opts[o].sent) -- 2.55.0

On Thu, 1 Oct 2026 18:45:55 +0530 Anshu Kumari wrote:

@@ -243,6 +256,7 @@ static void opt_set_dns_search(const struct ctx *c, size_t max_len) int i;

opts[119].slen = 0; + opts[119].conf = OPT_DEFAULT;

I think that at this point, instead of doing this...

for (i = 0; i < 255; i++) max_len -= opts[i].slen; @@ -291,7 +305,7 @@ static void opt_set_dns_search(const struct ctx *c, size_t max_len) }

if (!opts[119].slen) - opts[119].slen = -1; + opts[119].conf = OPT_UNSET;

...it would make more sense to simply set opts[119].conf here, that is: if (opts[119].slen) opts[119].conf = OPT_DEFAULT; -- Stefano

On Thu, 1 Oct 2026 18:45:57 +0530 Anshu Kumari wrote:

Add a convenience shorthand --dhcp-boot FILE that sets the boot file name (DHCP option 67) for network boot. This is equivalent to --dhcp-opt 67,FILE.

Per RFC 2132, Section 9.5, the boot file name is placed in the 'file' header field of the DHCP reply.

Link: https://bugs.passt.top/show_bug.cgi?id=192 Signed-off-by: Anshu Kumari --- v7: - moved ```has_bootfile``` declaration and initialization in this patch.

v6: - no changes.

v5: - replaced conf_dhcp_option() to dhcp_set_opt().

v4: - Changed argument name from URL to FILE in usage and man page. - Fixed UEFI HTTP boot wording in man page

v3: - case 32 now calls dhcp_add_option(c, 67, optarg). - Handles duplicate codes: --dhcp-boot and --dhcp-opt 67 coexist correctly, last value wins.

v2: - Removed separate dhcp_boot[PATH_MAX] field — --dhcp-boot foo now stores into custom_opts[] as code 67 (same as --dhcp-opt 67,foo) --- conf.c | 5 +++++ dhcp.c | 10 ++++++++++ passt.1 | 7 +++++++ 3 files changed, 22 insertions(+)

diff --git a/conf.c b/conf.c index c12a9335..37720bb5 100644 --- a/conf.c +++ b/conf.c @@ -634,6 +634,7 @@ static void usage(const char *name, FILE *f, int status) " a single, empty option disables the DNS search list\n" " -H, --hostname NAME Hostname to configure client with\n" " --fqdn NAME FQDN to configure client with\n" + " --dhcp-boot FILE Boot file name for network boot\n" " --dhcp-opt CODE,VAL Set DHCP option CODE to VAL\n"); if (strstr(name, "pasta")) FPRINTF(f, " default: don't use any search list\n"); @@ -1354,6 +1355,7 @@ void conf(struct ctx *c, int argc, char **argv) {"stats", required_argument, NULL, 31 }, {"conf-path", required_argument, NULL, 'c' }, {"chroot-fallback", no_argument, NULL, 32 }, + {"dhcp-boot", required_argument, NULL, 33 }, {"dhcp-opt", required_argument, NULL, 34 }, { 0 }, }; @@ -1596,6 +1598,9 @@ void conf(struct ctx *c, int argc, char **argv) case 32: c->chroot_fallback = true; break; + case 33: + dhcp_set_opt(67, optarg); + break; case 34: { unsigned long optcode;

diff --git a/dhcp.c b/dhcp.c index dd3ab6c6..4dccae7b 100644 --- a/dhcp.c +++ b/dhcp.c @@ -600,6 +600,7 @@ int dhcp(const struct ctx *c, struct iov_tail *data) const struct udphdr *uh; struct msg m_storage; struct msg const *m; + bool has_bootfile; struct msg reply; unsigned int i;

@@ -772,8 +773,17 @@ int dhcp(const struct ctx *c, struct iov_tail *data) if (!c->no_dhcp_dns_search) opt_set_dns_search(c, sizeof(m->o));

+ /* RFC 2132, Section 9.5: put boot file name in the 'file' header + * field. + */ + has_bootfile = opts[67].slen > 0 && + (size_t)opts[67].slen < sizeof(reply.file); + dlen = offsetof(struct msg, o) + fill(&reply);

+ if (has_bootfile) + memcpy(reply.file, opts[67].s, opts[67].slen); + if (m->flags & FLAG_BROADCAST) dst = in4addr_broadcast; else diff --git a/passt.1 b/passt.1 index 2bfe7d50..fdbe3d2c 100644 --- a/passt.1 +++ b/passt.1 @@ -440,6 +440,13 @@ Send \fIname\fR as DHCP option 12 (hostname). FQDN to configure the client with. Send \fIname\fR as Client FQDN: DHCP option 81 and DHCPv6 option 39.

+.TP +.BR \-\-dhcp-boot " " \fIfile

Given that options in conf() need to be renumbered anyway because of the merge conflict, what about moving this after --dhcp-opt in the documentation (it refers to it and it's a special case of it, so it would look more natural to have it afterwards) and then make ordering consistent in conf() and usage message?

+Convenience shorthand for \fB\-\-dhcp-opt\fR 67,\fIfile\fR. +Sets the boot file name (DHCP option 67) for network boot. +For UEFI HTTP boot, the vendor class identifier also needs to be set using +\fB\-\-dhcp-opt\fR 60,HTTPClient. + .TP .BR \-\-dhcp-opt " " \fICODE\fR,\fIVALUE\fR Set DHCP option \fICODE\fR (1\-254) to \fIVALUE\fR. The value format depends

-- Stefano

On Thu, 1 Oct 2026 18:45:59 +0530 Anshu Kumari wrote:

When the options field is full, overflow remaining DHCP options into the sname and file fields per RFC 2132 option 52.

Per RFC 2132, Section 9.5, the boot file name is always placed in the 'file' header field. When a boot file is set, the file field is reserved from overload and overflow uses only the sname field.

Link: https://bugs.passt.top/show_bug.cgi?id=192 Signed-off-by: Anshu Kumari ---

v7: - Removed overload function parameter - Added foreach_opt() macro to iterate option table

Till v6 both "patch 5/7" and "patch 6/7" were one. --- dhcp.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 68 insertions(+), 10 deletions(-)

diff --git a/dhcp.c b/dhcp.c index 6f69fd62..63ac8e3d 100644 --- a/dhcp.c +++ b/dhcp.c @@ -67,6 +67,8 @@ struct opt {

static struct opt opts[256];

+#define foreach_opt(o) for ((o) = 0; (size_t)(o) < ARRAY_SIZE(opts); (o)++) + #define DHCPDISCOVER 1 #define DHCPOFFER 2 #define DHCPREQUEST 3 @@ -440,13 +442,30 @@ static void fill_one(uint8_t *buf, size_t size, int o, int *offset) }

/** - * fill() - Fill options in message - * @m: Message to fill + * enum dhcp_overload - DHCP option overload values (RFC 2132, Section 9.3) + * @DHCP_OVERLOAD_NONE: No overload + * @DHCP_OVERLOAD_FILE: file field carries options + * @DHCP_OVERLOAD_SNAME: sname field carries options + */ +enum dhcp_overload { + DHCP_OVERLOAD_NONE = 0, + DHCP_OVERLOAD_FILE = 1, + DHCP_OVERLOAD_SNAME = 2, +}; + +/** + * fill() - Fill options in message, with overload into file/sname if needed + * @m: Message to fill + * @has_bootfile: Reserve file field for boot file name * * Return: current size of options field */ -static int fill(struct msg *m) +static int fill(struct msg *m, bool has_bootfile) { + enum dhcp_overload overload = DHCP_OVERLOAD_NONE; + int sname_off = 0, file_off = 0; + /* Reserve 3 bytes for option 52 (overload) if needed */ + size_t size = OPT_MAX - 3; int i, o, offset = 0;

for (o = 0; o < 255; o++) @@ -457,17 +476,54 @@ static int fill(struct msg *m) * Put it there explicitly, unless requested via option 55. */ if (opts[55].clen > 0 && !memchr(opts[55].c, 53, opts[55].clen)) - fill_one(m->o, OPT_MAX, 53, &offset); + fill_one(m->o, size, 53, &offset);

for (i = 0; i < opts[55].clen; i++) { o = opts[55].c[i]; if (opts[o].conf != OPT_UNSET) - fill_one(m->o, OPT_MAX, o, &offset); + fill_one(m->o, size, o, &offset); }

for (o = 0; o < 255; o++) { if (opts[o].conf != OPT_UNSET && !opts[o].sent) - fill_one(m->o, OPT_MAX, o, &offset); + fill_one(m->o, size, o, &offset); + } + + /* Overflow unsent options into sname, then file */ + foreach_opt(o) {

This comes from my suggestion on v6 but those were really subsequent steps (building a more specialised iterator on top of foreach_opt()), not alternatives. Look at flow_foreach() and flow_foreach_of_type() as examples. That is, here you could use: foreach_unsent_opt(o) fill_one(m->sname, sizeof(m->sname) - 1, o, &sname_off); with: #define foreach_unset_opt(o) \ foreach_opt((o)) \ /* NOLINTNEXTLINE(readability-inconsistent-ifelse-braces) */ \ if (opts[(o)].conf != OPT_UNSET && !opts[(o)].sent) ...the option with the reverse condition and "continue; else" could also work, I'm not sure what's the most practical here. The direct option looks more... direct, to me. The two loops below could use this iterator, and perhaps the one above as well (I haven't tried). Note that in 7/7 you could probably switch to this other iterator as well, without the explicit need for the base foreach_opt(o) iterator, but I would suggest to keep them as two different macros anyway, it's clearer and more reusable.

+ if (opts[o].conf == OPT_UNSET || opts[o].sent) + continue; + fill_one(m->sname, sizeof(m->sname) - 1, o, &sname_off); + } + + if (!has_bootfile) { + foreach_opt(o) { + if (opts[o].conf == OPT_UNSET || opts[o].sent) + continue; + fill_one(m->file, sizeof(m->file) - 1, o, &file_off); + } + } + + /* Report any options that could not be sent */ + foreach_opt(o) { + if (opts[o].conf != OPT_UNSET && !opts[o].sent) + debug("DHCP: skipping option %i", o); + } + + if (sname_off) { + m->sname[sname_off] = 255; + overload |= DHCP_OVERLOAD_SNAME; + } + + if (file_off) { + m->file[file_off] = 255; + overload |= DHCP_OVERLOAD_FILE; + } + + if (overload) { + m->o[offset++] = 52; + m->o[offset++] = 1; + m->o[offset++] = overload; }

m->o[offset++] = 255; @@ -761,16 +817,18 @@ int dhcp(const struct ctx *c, struct iov_tail *data) } }

- if (!c->no_dhcp_dns_search) - opt_set_dns_search(c, sizeof(m->o)); + if (!c->no_dhcp_dns_search) { + /* 3 bytes reserved for option 52 (code, length, value) */ + opt_set_dns_search(c, OPT_MAX - 3); + }

/* RFC 2132, Section 9.5: put boot file name in the 'file' header - * field. + * field. Reserve the file field from overload. */ has_bootfile = opts[67].slen > 0 && (size_t)opts[67].slen < sizeof(reply.file);

- dlen = offsetof(struct msg, o) + fill(&reply); + dlen = offsetof(struct msg, o) + fill(&reply, has_bootfile);

if (has_bootfile) memcpy(reply.file, opts[67].s, opts[67].slen);

-- Stefano