sd_dhcp_raw_option and sd_dhcp_option are essentially equivalent.
#include "dhcp-protocol.h"
#include "socket-util.h"
+typedef struct sd_dhcp_option {
+ unsigned n_ref;
+
+ uint8_t option;
+ void *data;
+ size_t length;
+} sd_dhcp_option;
+
+extern const struct hash_ops dhcp_option_hash_ops;
+
int dhcp_network_bind_raw_socket(int ifindex, union sockaddr_union *link,
uint32_t xid, const uint8_t *mac_addr,
size_t mac_addr_len, uint16_t arp_type,
break;
case SD_DHCP_OPTION_VENDOR_SPECIFIC: {
OrderedHashmap *s = (OrderedHashmap *) optval;
- struct sd_dhcp_raw_option *p;
+ struct sd_dhcp_option *p;
size_t l = 0;
Iterator i;
*offset += 2;
ORDERED_HASHMAP_FOREACH(p, s, i) {
- options[*offset] = p->type;
+ options[*offset] = p->option;
options[*offset + 1] = p->length;
memcpy(&options[*offset + 2], p->data, p->length);
*offset += 2 + p->length;
return message_type;
}
+
+static sd_dhcp_option* dhcp_option_free(sd_dhcp_option *i) {
+ if (!i)
+ return NULL;
+
+ free(i->data);
+ return mfree(i);
+}
+
+int sd_dhcp_option_new(uint8_t option, const void *data, size_t length, sd_dhcp_option **ret) {
+ assert_return(ret, -EINVAL);
+ assert_return(length == 0 || data, -EINVAL);
+
+ _cleanup_free_ void *q = memdup(data, length);
+ if (!q)
+ return -ENOMEM;
+
+ sd_dhcp_option *p = new(sd_dhcp_option, 1);
+ if (!p)
+ return -ENOMEM;
+
+ *p = (sd_dhcp_option) {
+ .n_ref = 1,
+ .option = option,
+ .length = length,
+ .data = TAKE_PTR(q),
+ };
+
+ *ret = TAKE_PTR(p);
+ return 0;
+}
+
+DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_option, sd_dhcp_option, dhcp_option_free);
+DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
+ dhcp_option_hash_ops,
+ void,
+ trivial_hash_func,
+ trivial_compare_func,
+ sd_dhcp_option,
+ sd_dhcp_option_unref);
usec_t expiration;
} DHCPLease;
-struct sd_dhcp_raw_option {
- unsigned n_ref;
-
- uint8_t type;
- uint8_t length;
-
- void *data;
-};
-
struct sd_dhcp_server {
unsigned n_ref;
#define RESTART_AFTER_NAK_MIN_USEC (1 * USEC_PER_SEC)
#define RESTART_AFTER_NAK_MAX_USEC (30 * USEC_PER_MINUTE)
-struct sd_dhcp_option {
- unsigned n_ref;
-
- uint8_t option;
- void *data;
- size_t length;
-};
-
struct sd_dhcp_client {
unsigned n_ref;
return 0;
}
-static sd_dhcp_option* dhcp_option_free(sd_dhcp_option *i) {
- if (!i)
- return NULL;
-
- free(i->data);
- return mfree(i);
-}
-
-int sd_dhcp_option_new(uint8_t option, void *data, size_t length, sd_dhcp_option **ret) {
- assert_return(ret, -EINVAL);
- assert_return(length == 0 || data, -EINVAL);
-
- _cleanup_free_ void *q = memdup(data, length);
- if (!q)
- return -ENOMEM;
-
- sd_dhcp_option *p = new(sd_dhcp_option, 1);
- if (!p)
- return -ENOMEM;
-
- *p = (sd_dhcp_option) {
- .n_ref = 1,
- .option = option,
- .length = length,
- .data = TAKE_PTR(q),
- };
-
- *ret = TAKE_PTR(p);
- return 0;
-}
-
-DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_option, sd_dhcp_option, dhcp_option_free);
-DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
- dhcp_option_hash_ops,
- void,
- trivial_hash_func,
- trivial_compare_func,
- sd_dhcp_option,
- sd_dhcp_option_unref);
-
int sd_dhcp_client_set_dhcp_option(sd_dhcp_client *client, sd_dhcp_option *v) {
int r;
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(dhcp_lease_hash_ops, DHCPClientId, client_id_hash_func, client_id_compare_func,
DHCPLease, dhcp_lease_free);
-static sd_dhcp_raw_option* raw_option_free(sd_dhcp_raw_option *i) {
- if (!i)
- return NULL;
-
- free(i->data);
- return mfree(i);
-}
-
-_public_ int sd_dhcp_raw_option_new(uint8_t type, char *data, size_t length, sd_dhcp_raw_option **ret) {
- _cleanup_(sd_dhcp_raw_option_unrefp) sd_dhcp_raw_option *p = NULL;
-
- assert_return(ret, -EINVAL);
-
- p = new(sd_dhcp_raw_option, 1);
- if (!p)
- return -ENOMEM;
-
- *p = (sd_dhcp_raw_option) {
- .n_ref = 1,
- .data = memdup(data, length),
- .length = length,
- .type = type,
- };
-
- if (!p->data)
- return -ENOMEM;
-
- *ret = TAKE_PTR(p);
- return 0;
-}
-
-DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_dhcp_raw_option, sd_dhcp_raw_option, raw_option_free);
-DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
- dhcp_raw_options_hash_ops,
- void,
- trivial_hash_func,
- trivial_compare_func,
- sd_dhcp_raw_option,
- sd_dhcp_raw_option_unref);
-
static sd_dhcp_server *dhcp_server_free(sd_dhcp_server *server) {
assert(server);
return 1;
}
-int sd_dhcp_server_add_raw_option(sd_dhcp_server *server, sd_dhcp_raw_option *v) {
+int sd_dhcp_server_add_option(sd_dhcp_server *server, sd_dhcp_option *v) {
int r;
assert_return(server, -EINVAL);
assert_return(v, -EINVAL);
- r = ordered_hashmap_ensure_allocated(&server->raw_option, &dhcp_raw_options_hash_ops);
+ r = ordered_hashmap_ensure_allocated(&server->raw_option, &dhcp_option_hash_ops);
if (r < 0)
return -ENOMEM;
if (r < 0)
return r;
- sd_dhcp_raw_option_ref(v);
+ sd_dhcp_option_ref(v);
return 1;
}
#include "sd-dhcp-server.h"
+#include "dhcp-internal.h"
#include "escape.h"
#include "networkd-dhcp-server.h"
#include "networkd-link.h"
int dhcp4_server_configure(Link *link) {
bool acquired_uplink = false;
- sd_dhcp_raw_option *p;
+ sd_dhcp_option *p;
Link *uplink = NULL;
Address *address;
Iterator i;
return r;
}
- ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_raw_options, i) {
- r = sd_dhcp_server_add_raw_option(link->dhcp_server, p);
+ ORDERED_HASHMAP_FOREACH(p, link->network->dhcp_server_options, i) {
+ r = sd_dhcp_server_add_option(link->dhcp_server, p);
if (r == -EEXIST)
continue;
if (r < 0)
void *data,
void *userdata) {
- _cleanup_(sd_dhcp_raw_option_unrefp) sd_dhcp_raw_option *opt = NULL, *old = NULL;
+ _cleanup_(sd_dhcp_option_unrefp) sd_dhcp_option *opt = NULL, *old = NULL;
_cleanup_free_ char *word = NULL, *q = NULL;
union in_addr_union addr;
DHCPOptionDataType type;
assert(data);
if (isempty(rvalue)) {
- network->dhcp_server_raw_options = ordered_hashmap_free(network->dhcp_server_raw_options);
+ network->dhcp_server_options = ordered_hashmap_free(network->dhcp_server_options);
return 0;
}
return -EINVAL;
}
- r = sd_dhcp_raw_option_new(u, udata, sz, &opt);
+ r = sd_dhcp_option_new(u, udata, sz, &opt);
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r,
"Failed to store DHCP send raw option '%s', ignoring assignment: %m", rvalue);
return 0;
}
- r = ordered_hashmap_ensure_allocated(&network->dhcp_server_raw_options, &dhcp_raw_options_hash_ops);
+ r = ordered_hashmap_ensure_allocated(&network->dhcp_server_options, &dhcp_option_hash_ops);
if (r < 0)
return log_oom();
/* Overwrite existing option */
- old = ordered_hashmap_remove(network->dhcp_server_raw_options, UINT_TO_PTR(u));
- r = ordered_hashmap_put(network->dhcp_server_raw_options, UINT_TO_PTR(u), opt);
+ old = ordered_hashmap_remove(network->dhcp_server_options, UINT_TO_PTR(u));
+ r = ordered_hashmap_put(network->dhcp_server_options, UINT_TO_PTR(u), opt);
if (r < 0) {
log_syntax(unit, LOG_ERR, filename, line, r,
"Failed to store DHCP server send raw option '%s'", rvalue);
set_free_free(network->dnssec_negative_trust_anchors);
ordered_hashmap_free(network->dhcp_send_options);
- ordered_hashmap_free(network->dhcp_server_raw_options);
+ ordered_hashmap_free(network->dhcp_server_options);
return mfree(network);
}
Set *dhcp_black_listed_ip;
Set *dhcp_request_options;
OrderedHashmap *dhcp_send_options;
- OrderedHashmap *dhcp_server_raw_options;
+ OrderedHashmap *dhcp_server_options;
/* DHCPv6 Client support*/
bool dhcp6_use_dns;
sd-dhcp6-lease.h
sd-dhcp-client.h
sd-dhcp-lease.h
+ sd-dhcp-option.h
sd-dhcp-server.h
sd-ipv4acd.h
sd-ipv4ll.h
#include <stdbool.h>
#include "sd-dhcp-lease.h"
+#include "sd-dhcp-option.h"
#include "sd-event.h"
#include "_sd-common.h"
};
typedef struct sd_dhcp_client sd_dhcp_client;
-typedef struct sd_dhcp_option sd_dhcp_option;
typedef int (*sd_dhcp_client_callback_t)(sd_dhcp_client *client, int event, void *userdata);
int sd_dhcp_client_set_callback(
sd_dhcp_client *client,
int type);
-int sd_dhcp_option_new(uint8_t option, void *data, size_t length, sd_dhcp_option **ret);
-sd_dhcp_option* sd_dhcp_option_ref(sd_dhcp_option *i);
-sd_dhcp_option* sd_dhcp_option_unref(sd_dhcp_option *i);
int sd_dhcp_client_set_dhcp_option(sd_dhcp_client *client, sd_dhcp_option *v);
int sd_dhcp_client_stop(sd_dhcp_client *client);
sd_event *sd_dhcp_client_get_event(sd_dhcp_client *client);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_dhcp_client, sd_dhcp_client_unref);
-_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_dhcp_option, sd_dhcp_option_unref);
_SD_END_DECLARATIONS;
--- /dev/null
+/* SPDX-License-Identifier: LGPL-2.1+ */
+#ifndef foosddhcpoptionhfoo
+#define foosddhcpoptionhfoo
+
+/***
+ Copyright © 2013 Intel Corporation. All rights reserved.
+ systemd is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or
+ (at your option) any later version.
+
+ systemd is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <inttypes.h>
+#include <sys/types.h>
+
+#include "_sd-common.h"
+
+_SD_BEGIN_DECLARATIONS;
+
+typedef struct sd_dhcp_option sd_dhcp_option;
+
+int sd_dhcp_option_new(uint8_t option, const void *data, size_t length, sd_dhcp_option **ret);
+sd_dhcp_option *sd_dhcp_option_ref(sd_dhcp_option *ra);
+sd_dhcp_option *sd_dhcp_option_unref(sd_dhcp_option *ra);
+
+_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_dhcp_option, sd_dhcp_option_unref);
+
+_SD_END_DECLARATIONS;
+
+#endif
#include <inttypes.h>
#include <netinet/in.h>
+#include "sd-dhcp-option.h"
#include "sd-event.h"
#include "_sd-common.h"
_SD_BEGIN_DECLARATIONS;
-extern const struct hash_ops dhcp_raw_options_hash_ops;
-
typedef struct sd_dhcp_server sd_dhcp_server;
-typedef struct sd_dhcp_raw_option sd_dhcp_raw_option;
int sd_dhcp_server_new(sd_dhcp_server **ret, int ifindex);
sd_dhcp_server *sd_dhcp_server_ref(sd_dhcp_server *server);
sd_dhcp_server *sd_dhcp_server_unref(sd_dhcp_server *server);
-int sd_dhcp_raw_option_new(uint8_t type, char *data, size_t lengt, sd_dhcp_raw_option **ret);
-sd_dhcp_raw_option *sd_dhcp_raw_option_ref(sd_dhcp_raw_option *ra);
-sd_dhcp_raw_option *sd_dhcp_raw_option_unref(sd_dhcp_raw_option *ra);
-
int sd_dhcp_server_attach_event(sd_dhcp_server *client, sd_event *event, int64_t priority);
int sd_dhcp_server_detach_event(sd_dhcp_server *client);
sd_event *sd_dhcp_server_get_event(sd_dhcp_server *client);
int sd_dhcp_server_set_sip(sd_dhcp_server *server, const struct in_addr sip[], unsigned n);
int sd_dhcp_server_set_emit_router(sd_dhcp_server *server, int enabled);
-int sd_dhcp_server_add_raw_option(sd_dhcp_server *server, sd_dhcp_raw_option *v);
+int sd_dhcp_server_add_option(sd_dhcp_server *server, sd_dhcp_option *v);
int sd_dhcp_server_set_max_lease_time(sd_dhcp_server *server, uint32_t t);
int sd_dhcp_server_set_default_lease_time(sd_dhcp_server *server, uint32_t t);
int sd_dhcp_server_forcerenew(sd_dhcp_server *server);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_dhcp_server, sd_dhcp_server_unref);
-_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_dhcp_raw_option, sd_dhcp_raw_option_unref);
_SD_END_DECLARATIONS;