sd-dhcp: parse error message in DECLINE or NAK

If a client sends a DECLINE or a server sends a NAK, they can include
a string with a message to explain the error. Parse this and print it
at debug level.

1 files changed, 63 insertions, 46 deletions

diff --git a/src/libsystemd-network/dhcp-option.c b/src/libsystemd-network/dhcp-option.c
index a6c410ba91..1de7f3639c 100644
--- a/src/libsystemd-network/dhcp-option.c
+++ b/src/libsystemd-network/dhcp-option.c
@@ -24,6 +24,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "alloc-util.h"
+#include "utf8.h"
+
 #include "dhcp-internal.h"
 
 static int option_append(uint8_t options[], size_t size, size_t *offset,
@@ -139,72 +142,84 @@ int dhcp_option_append(DHCPMessage *message, size_t size, size_t *offset,
 }
 
 static int parse_options(const uint8_t options[], size_t buflen, uint8_t *overload,
-                         uint8_t *message_type, dhcp_option_cb_t cb,
+                         uint8_t *message_type, char **error_message, dhcp_option_cb_t cb,
                          void *userdata) {
         uint8_t code, len;
+        const uint8_t *option;
         size_t offset = 0;
 
         while (offset < buflen) {
-                switch (options[offset]) {
-                case DHCP_OPTION_PAD:
-                        offset++;
+                code = options[offset ++];
 
-                        break;
+                switch (code) {
+                case DHCP_OPTION_PAD:
+                        continue;
 
                 case DHCP_OPTION_END:
                         return 0;
+                }
 
-                case DHCP_OPTION_MESSAGE_TYPE:
-                        if (buflen < offset + 3)
-                                return -ENOBUFS;
+                if (buflen < offset + 1)
+                        return -ENOBUFS;
+
+                len = options[offset ++];
 
-                        len = options[++offset];
+                if (buflen < offset + len)
+                        return -EINVAL;
+
+                option = &options[offset];
+
+                switch (code) {
+                case DHCP_OPTION_MESSAGE_TYPE:
                         if (len != 1)
                                 return -EINVAL;
 
                         if (message_type)
-                                *message_type = options[++offset];
-                        else
-                                offset++;
-
-                        offset++;
+                                *message_type = *option;
 
                         break;
 
-                case DHCP_OPTION_OVERLOAD:
-                        if (buflen < offset + 3)
-                                return -ENOBUFS;
-
-                        len = options[++offset];
-                        if (len != 1)
+                case DHCP_OPTION_ERROR_MESSAGE:
+                        if (len == 0)
                                 return -EINVAL;
 
-                        if (overload)
-                                *overload = options[++offset];
-                        else
-                                offset++;
+                        if (error_message) {
+                                _cleanup_free_ char *string = NULL;
 
-                        offset++;
+                                /* Accept a trailing NUL byte */
+                                if (memchr(option, 0, len - 1))
+                                        return -EINVAL;
 
-                        break;
+                                string = strndup((const char *) option, len);
+                                if (!string)
+                                        return -ENOMEM;
 
-                default:
-                        if (buflen < offset + 3)
-                                return -ENOBUFS;
+                                if (!ascii_is_valid(string))
+                                        return -EINVAL;
 
-                        code = options[offset];
-                        len = options[++offset];
+                                free(*error_message);
+                                *error_message = string;
+                                string = NULL;
+                        }
 
-                        if (buflen < ++offset + len)
+                        break;
+                case DHCP_OPTION_OVERLOAD:
+                        if (len != 1)
                                 return -EINVAL;
 
-                        if (cb)
-                                cb(code, len, &options[offset], userdata);
+                        if (overload)
+                                *overload = *option;
 
-                        offset += len;
+                        break;
+
+                default:
+                        if (cb)
+                                cb(code, len, option, userdata);
 
                         break;
                 }
+
+                offset += len;
         }
 
         if (offset < buflen)
@@ -213,8 +228,8 @@ static int parse_options(const uint8_t options[], size_t buflen, uint8_t *overlo
         return 0;
 }
 
-int dhcp_option_parse(DHCPMessage *message, size_t len,
-                      dhcp_option_cb_t cb, void *userdata) {
+int dhcp_option_parse(DHCPMessage *message, size_t len, dhcp_option_cb_t cb, void *userdata, char **_error_message) {
+        _cleanup_free_ char *error_message = NULL;
         uint8_t overload = 0;
         uint8_t message_type = 0;
         int r;
@@ -227,27 +242,29 @@ int dhcp_option_parse(DHCPMessage *message, size_t len,
 
         len -= sizeof(DHCPMessage);
 
-        r = parse_options(message->options, len, &overload, &message_type,
-                          cb, userdata);
+        r = parse_options(message->options, len, &overload, &message_type, &error_message, cb, userdata);
         if (r < 0)
                 return r;
 
         if (overload & DHCP_OVERLOAD_FILE) {
-                r = parse_options(message->file, sizeof(message->file),
-                                NULL, &message_type, cb, userdata);
+                r = parse_options(message->file, sizeof(message->file), NULL, &message_type, &error_message, cb, userdata);
                 if (r < 0)
                         return r;
         }
 
         if (overload & DHCP_OVERLOAD_SNAME) {
-                r = parse_options(message->sname, sizeof(message->sname),
-                                NULL, &message_type, cb, userdata);
+                r = parse_options(message->sname, sizeof(message->sname), NULL, &message_type, &error_message, cb, userdata);
                 if (r < 0)
                         return r;
         }
 
-        if (message_type)
-                return message_type;
+        if (message_type == 0)
+                return -ENOMSG;
+
+        if (_error_message && IN_SET(message_type, DHCP_NAK, DHCP_DECLINE)) {
+                *_error_message = error_message;
+                error_message = NULL;
+        }
 
-        return -ENOMSG;
+        return message_type;
 }