shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2025-02-03 13:47:04 +03:00
Code

sd-dhcp: clean-up of DHCP lease server code

Browse Source 
This is an attempt to clean-up the DHCP lease server type code a bit. We
now strictly use the same enum everywhere, and store server info in an
array. Moreover, we use the same nomenclature everywhere.

This only makes the changes in the sd-dhcp code. The networkd code is
untouched so far (but should be fixed up like this too. But it's more
complicated since this would then touch actual settings in .network
files).

Note that this also changes some field names in serialized lease files.
But given that these field names have not been part of a released
version of systemd yet, such a change should be ok.

This is pure renaming/refactoring, shouldn't actually change any
behaviour.
This commit is contained in:
Lennart Poettering 2020-05-29 11:26:24 +02:00 committed by Zbigniew Jędrzejewski-Szmek
parent eed44b715d
commit ddb82ec2a2
15 changed files with 173 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/libsystemd-network/dhcp-internal.h
View File

@ -7,7 +7,6 @@
#include <linux/if_packet.h>
#include <net/ethernet.h>
#include <net/if_arp.h>
#include <stdint.h>
#include "sd-dhcp-client.h"
@ -23,6 +22,11 @@ typedef struct sd_dhcp_option {
size_t length;
} sd_dhcp_option;
typedef struct DHCPServerData {
struct in_addr *addr;
size_t size;
} DHCPServerData;
extern const struct hash_ops dhcp_option_hash_ops;
int dhcp_network_bind_raw_socket(int ifindex, union sockaddr_union *link,

22
src/libsystemd-network/dhcp-lease-internal.h
View File

@ -5,11 +5,9 @@
Copyright © 2013 Intel Corporation. All rights reserved.
***/
#include <stdint.h>
#include <linux/if_packet.h>
#include "sd-dhcp-client.h"
#include "dhcp-internal.h"
#include "dhcp-protocol.h"
#include "list.h"
#include "util.h"
@ -52,23 +50,7 @@ struct sd_dhcp_lease {
struct in_addr *router;
size_t router_size;
struct in_addr *dns;
size_t dns_size;
struct in_addr *ntp;
size_t ntp_size;
struct in_addr *sip;
size_t sip_size;
struct in_addr *pop3_server;
size_t pop3_server_size;
struct in_addr *smtp_server;
size_t smtp_server_size;
struct in_addr *lpr_server;
size_t lpr_server_size;
DHCPServerData servers[_SD_DHCP_LEASE_SERVER_TYPE_MAX];
struct sd_dhcp_route *static_route;
size_t static_route_size, static_route_allocated;

3
src/libsystemd-network/dhcp-server-internal.h
View File

@ -56,8 +56,7 @@ struct sd_dhcp_server {
char *timezone;
struct in_addr *ntp, *dns, *sip, *pop3_server, *smtp_server, *lpr_server;
size_t n_ntp, n_dns, n_sip, n_pop3_server, n_smtp_server, n_lpr_server;
DHCPServerData servers[_SD_DHCP_LEASE_SERVER_TYPE_MAX];
OrderedHashmap *extra_options;
OrderedHashmap *vendor_options;

176
src/libsystemd-network/sd-dhcp-lease.c
View File

@ -98,78 +98,38 @@ int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu) {
int sd_dhcp_lease_get_servers(
sd_dhcp_lease *lease,
sd_dhcp_lease_info what,
sd_dhcp_lease_server_type what,
const struct in_addr **addr) {
assert_return(lease, -EINVAL);
assert_return(what >= 0, -EINVAL);
assert_return(what < _SD_DHCP_LEASE_SERVER_TYPE_MAX, -EINVAL);
assert_return(addr, -EINVAL);
switch (what) {
case SD_DHCP_LEASE_DNS_SERVERS:
if (lease->dns_size <= 0)
return -ENODATA;
if (lease->servers[what].size <= 0)
return -ENODATA;
*addr = lease->dns;
return (int) lease->dns_size;
case SD_DHCP_LEASE_NTP_SERVERS:
if (lease->ntp_size <= 0)
return -ENODATA;
*addr = lease->ntp;
return (int) lease->ntp_size;
case SD_DHCP_LEASE_SIP_SERVERS:
if (lease->sip_size <= 0)
return -ENODATA;
*addr = lease->sip;
return (int) lease->sip_size;
case SD_DHCP_LEASE_POP3_SERVERS:
if (lease->pop3_server_size <= 0)
return -ENODATA;
*addr = lease->pop3_server;
return (int) lease->pop3_server_size;
case SD_DHCP_LEASE_SMTP_SERVERS:
if (lease->smtp_server_size <= 0)
return -ENODATA;
*addr = lease->smtp_server;
return (int) lease->smtp_server_size;
case SD_DHCP_LEASE_LPR_SERVERS:
if (lease->lpr_server_size <= 0)
return -ENODATA;
*addr = lease->lpr_server;
return (int) lease->lpr_server_size;
default:
return log_debug_errno(SYNTHETIC_ERRNO(ENXIO),
"Unknown DHCP lease info item %d.", what);
}
*addr = lease->servers[what].addr;
return (int) lease->servers[what].size;
}
int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_DNS_SERVERS, addr);
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_DNS, addr);
}
int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_NTP_SERVERS, addr);
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_NTP, addr);
}
int sd_dhcp_lease_get_sip(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SIP_SERVERS, addr);
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SIP, addr);
}
int sd_dhcp_lease_get_pop3_server(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_POP3_SERVERS, addr);
int sd_dhcp_lease_get_pop3(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_POP3, addr);
}
int sd_dhcp_lease_get_smtp_server(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SMTP_SERVERS, addr);
int sd_dhcp_lease_get_smtp(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_SMTP, addr);
}
int sd_dhcp_lease_get_lpr_servers(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_LPR_SERVERS, addr);
int sd_dhcp_lease_get_lpr(sd_dhcp_lease *lease, const struct in_addr **addr) {
return sd_dhcp_lease_get_servers(lease, SD_DHCP_LEASE_LPR, addr);
}
int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname) {
@ -319,12 +279,10 @@ static sd_dhcp_lease *dhcp_lease_free(sd_dhcp_lease *lease) {
free(lease->timezone);
free(lease->hostname);
free(lease->domainname);
free(lease->dns);
free(lease->ntp);
free(lease->sip);
free(lease->pop3_server);
free(lease->smtp_server);
free(lease->lpr_server);
for (sd_dhcp_lease_server_type i = 0; i < _SD_DHCP_LEASE_SERVER_TYPE_MAX; i++)
free(lease->servers[i].addr);
free(lease->static_route);
free(lease->client_id);
free(lease->vendor_specific);
@ -430,7 +388,7 @@ static int lease_parse_domain(const uint8_t *option, size_t len, char **ret) {
}
static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
assert(option);
assert(option || len == 0);
assert(ret);
assert(n_ret);
@ -459,33 +417,24 @@ static int lease_parse_in_addrs(const uint8_t *option, size_t len, struct in_add
}
static int lease_parse_sip_server(const uint8_t *option, size_t len, struct in_addr **ret, size_t *n_ret) {
assert(option);
assert(option || len == 0);
assert(ret);
assert(n_ret);
if (len <= 0) {
if (len <= 0)
return -EINVAL;
/* The SIP record is like the other, regular server records, but prefixed with a single "encoding"
* byte that is either 0 or 1. We only support it to be 1 for now. Let's drop it and parse it like
* the other fields */
if (option[0] != 1) { /* We only support IP address encoding for now */
*ret = mfree(*ret);
*n_ret = 0;
} else {
size_t n_addresses;
struct in_addr *addresses;
int l = len - 1;
if (l % 4 != 0)
return -EINVAL;
n_addresses = l / 4;
addresses = newdup(struct in_addr, option + 1, n_addresses);
if (!addresses)
return -ENOMEM;
free(*ret);
*ret = addresses;
*n_ret = n_addresses;
return 0;
}
return 0;
return lease_parse_in_addrs(option + 1, len - 1, ret, n_ret);
}
static int lease_parse_routes(
@ -630,37 +579,37 @@ int dhcp_lease_parse_options(uint8_t code, uint8_t len, const void *option, void
break;
case SD_DHCP_OPTION_DOMAIN_NAME_SERVER:
r = lease_parse_in_addrs(option, len, &lease->dns, &lease->dns_size);
r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_DNS].addr, &lease->servers[SD_DHCP_LEASE_DNS].size);
if (r < 0)
log_debug_errno(r, "Failed to parse DNS server, ignoring: %m");
break;
case SD_DHCP_OPTION_NTP_SERVER:
r = lease_parse_in_addrs(option, len, &lease->ntp, &lease->ntp_size);
r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_NTP].addr, &lease->servers[SD_DHCP_LEASE_NTP].size);
if (r < 0)
log_debug_errno(r, "Failed to parse NTP server, ignoring: %m");
break;
case SD_DHCP_OPTION_SIP_SERVER:
r = lease_parse_sip_server(option, len, &lease->sip, &lease->sip_size);
r = lease_parse_sip_server(option, len, &lease->servers[SD_DHCP_LEASE_SIP].addr, &lease->servers[SD_DHCP_LEASE_SIP].size);
if (r < 0)
log_debug_errno(r, "Failed to parse SIP server, ignoring: %m");
break;
case SD_DHCP_OPTION_POP3_SERVER:
r = lease_parse_in_addrs(option, len, &lease->pop3_server, &lease->pop3_server_size);
r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_POP3].addr, &lease->servers[SD_DHCP_LEASE_POP3].size);
if (r < 0)
log_debug_errno(r, "Failed to parse POP3 server, ignoring: %m");
break;
case SD_DHCP_OPTION_SMTP_SERVER:
r = lease_parse_in_addrs(option, len, &lease->smtp_server, &lease->smtp_server_size);
r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_SMTP].addr, &lease->servers[SD_DHCP_LEASE_SMTP].size);
if (r < 0)
log_debug_errno(r, "Failed to parse SMTP server, ignoring: %m");
break;
case SD_DHCP_OPTION_LPR_SERVER:
r = lease_parse_in_addrs(option, len, &lease->lpr_server, &lease->lpr_server_size);
r = lease_parse_in_addrs(option, len, &lease->servers[SD_DHCP_LEASE_LPR].addr, &lease->servers[SD_DHCP_LEASE_LPR].size);
if (r < 0)
log_debug_errno(r, "Failed to parse LPR server, ignoring: %m");
break;
@ -1101,9 +1050,9 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
*dns = NULL,
*ntp = NULL,
*sip = NULL,
*pop3_server = NULL,
*smtp_server = NULL,
*lpr_server = NULL,
*pop3 = NULL,
*smtp = NULL,
*lpr = NULL,
*mtu = NULL,
*routes = NULL,
*domains = NULL,
@ -1133,9 +1082,9 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
"DNS", &dns,
"NTP", &ntp,
"SIP", &sip,
"POP3_SERVERS", &pop3_server,
"SMTP_SERVERS", &smtp_server,
"LPR_SERVERS", &lpr_server,
"POP3", &pop3,
"SMTP", &smtp,
"LPR", &lpr,
"MTU", &mtu,
"DOMAINNAME", &lease->domainname,
"HOSTNAME", &lease->hostname,
@ -1225,54 +1174,53 @@ int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file) {
}
if (dns) {
r = deserialize_in_addrs(&lease->dns, dns);
r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_DNS].addr, dns);
if (r < 0)
log_debug_errno(r, "Failed to deserialize DNS servers %s, ignoring: %m", dns);
else
lease->dns_size = r;
lease->servers[SD_DHCP_LEASE_DNS].size = r;
}
if (ntp) {
r = deserialize_in_addrs(&lease->ntp, ntp);
r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_NTP].addr, ntp);
if (r < 0)
log_debug_errno(r, "Failed to deserialize NTP servers %s, ignoring: %m", ntp);
else
lease->ntp_size = r;
lease->servers[SD_DHCP_LEASE_NTP].size = r;
}
if (sip) {
r = deserialize_in_addrs(&lease->sip, sip);
r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_SIP].addr, sip);
if (r < 0)
log_debug_errno(r, "Failed to deserialize SIP servers %s, ignoring: %m", sip);
else
lease->sip_size = r;
lease->servers[SD_DHCP_LEASE_SIP].size = r;
}
if (pop3_server) {
r = deserialize_in_addrs(&lease->pop3_server, pop3_server);
if (pop3) {
r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_POP3].addr, pop3);
if (r < 0)
log_debug_errno(r, "Failed to deserialize POP3 server %s, ignoring: %m", pop3_server);
log_debug_errno(r, "Failed to deserialize POP3 server %s, ignoring: %m", pop3);
else
lease->pop3_server_size = r;
lease->servers[SD_DHCP_LEASE_POP3].size = r;
}
if (smtp_server) {
r = deserialize_in_addrs(&lease->smtp_server, smtp_server);
if (smtp) {
r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_SMTP].addr, smtp);
if (r < 0)
log_debug_errno(r, "Failed to deserialize SMTP server %s, ignoring: %m", smtp_server);
log_debug_errno(r, "Failed to deserialize SMTP server %s, ignoring: %m", smtp);
else
lease->smtp_server_size = r;
lease->servers[SD_DHCP_LEASE_SMTP].size = r;
}
if (lpr_server) {
r = deserialize_in_addrs(&lease->lpr_server, lpr_server);
if (lpr) {
r = deserialize_in_addrs(&lease->servers[SD_DHCP_LEASE_LPR].addr, lpr);
if (r < 0)
log_debug_errno(r, "Failed to deserialize LPR server %s, ignoring: %m", lpr_server);
log_debug_errno(r, "Failed to deserialize LPR server %s, ignoring: %m", lpr);
else
lease->lpr_server_size = r;
lease->servers[SD_DHCP_LEASE_LPR].size = r;
}
if (mtu) {
r = safe_atou16(mtu, &lease->mtu);
if (r < 0)

149
src/libsystemd-network/sd-dhcp-server.c
View File

@ -3,6 +3,7 @@
Copyright © 2013 Intel Corporation. All rights reserved.
***/
#include <net/if_arp.h>
#include <sys/ioctl.h>
#include "sd-dhcp-server.h"
@ -143,12 +144,9 @@ static sd_dhcp_server *dhcp_server_free(sd_dhcp_server *server) {
sd_event_unref(server->event);
free(server->timezone);
free(server->dns);
free(server->ntp);
free(server->sip);
free(server->pop3_server);
free(server->smtp_server);
free(server->lpr_server);
for (sd_dhcp_lease_server_type i = 0; i < _SD_DHCP_LEASE_SERVER_TYPE_MAX; i++)
free(server->servers[i].addr);
hashmap_free(server->leases_by_client_id);
@ -461,8 +459,20 @@ static int server_send_offer(sd_dhcp_server *server, DHCPRequest *req,
return 0;
}
static int server_send_ack(sd_dhcp_server *server, DHCPRequest *req,
be32_t address) {
static int server_send_ack(
sd_dhcp_server *server,
DHCPRequest *req,
be32_t address) {
static const uint8_t option_map[_SD_DHCP_LEASE_SERVER_TYPE_MAX] = {
[SD_DHCP_LEASE_DNS] = SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
[SD_DHCP_LEASE_NTP] = SD_DHCP_OPTION_NTP_SERVER,
[SD_DHCP_LEASE_SIP] = SD_DHCP_OPTION_SIP_SERVER,
[SD_DHCP_LEASE_POP3] = SD_DHCP_OPTION_POP3_SERVER,
[SD_DHCP_LEASE_SMTP] = SD_DHCP_OPTION_SMTP_SERVER,
[SD_DHCP_LEASE_LPR] = SD_DHCP_OPTION_LPR_SERVER,
};
_cleanup_free_ DHCPPacket *packet = NULL;
be32_t lease_time;
sd_dhcp_option *j;
@ -495,59 +505,19 @@ static int server_send_ack(sd_dhcp_server *server, DHCPRequest *req,
return r;
}
if (server->n_dns > 0) {
for (sd_dhcp_lease_server_type k = 0; k < _SD_DHCP_LEASE_SERVER_TYPE_MAX; k++) {
if (server->servers[k].size <= 0)
continue;
r = dhcp_option_append(
&packet->dhcp, req->max_optlen, &offset, 0,
SD_DHCP_OPTION_DOMAIN_NAME_SERVER,
sizeof(struct in_addr) * server->n_dns, server->dns);
option_map[k],
sizeof(struct in_addr) * server->servers[k].size, server->servers[k].addr);
if (r < 0)
return r;
}
if (server->n_ntp > 0) {
r = dhcp_option_append(
&packet->dhcp, req->max_optlen, &offset, 0,
SD_DHCP_OPTION_NTP_SERVER,
sizeof(struct in_addr) * server->n_ntp, server->ntp);
if (r < 0)
return r;
}
if (server->n_sip > 0) {
r = dhcp_option_append(
&packet->dhcp, req->max_optlen, &offset, 0,
SD_DHCP_OPTION_SIP_SERVER,
sizeof(struct in_addr) * server->n_sip, server->sip);
if (r < 0)
return r;
}
if (server->n_pop3_server > 0) {
r = dhcp_option_append(
&packet->dhcp, req->max_optlen, &offset, 0,
SD_DHCP_OPTION_POP3_SERVER,
sizeof(struct in_addr) * server->n_pop3_server, server->pop3_server);
if (r < 0)
return r;
}
if (server->n_smtp_server > 0) {
r = dhcp_option_append(
&packet->dhcp, req->max_optlen, &offset, 0,
SD_DHCP_OPTION_SMTP_SERVER,
sizeof(struct in_addr) * server->n_smtp_server, server->smtp_server);
if (r < 0)
return r;
}
if (server->n_lpr_server > 0) {
r = dhcp_option_append(
&packet->dhcp, req->max_optlen, &offset, 0,
SD_DHCP_OPTION_LPR_SERVER,
sizeof(struct in_addr) * server->n_lpr_server, server->lpr_server);
if (r < 0)
return r;
}
if (server->timezone) {
r = dhcp_option_append(
@ -1139,87 +1109,50 @@ int sd_dhcp_server_set_default_lease_time(sd_dhcp_server *server, uint32_t t) {
int sd_dhcp_server_set_servers(
sd_dhcp_server *server,
sd_dhcp_lease_info what,
sd_dhcp_lease_server_type what,
const struct in_addr addresses[],
size_t n_addresses) {
struct in_addr *c = NULL;
assert_return(server, -EINVAL);
assert_return(addresses || n_addresses == 0, -EINVAL);
assert_return(what >= 0, -EINVAL);
assert_return(what < _SD_DHCP_LEASE_SERVER_TYPE_MAX, -EINVAL);
struct in_addr **a;
size_t *n_a;
switch (what) {
case SD_DHCP_LEASE_DNS_SERVERS:
a = &server->dns;
n_a = &server->n_dns;
break;
case SD_DHCP_LEASE_NTP_SERVERS:
a = &server->ntp;
n_a = &server->n_ntp;
break;
case SD_DHCP_LEASE_SIP_SERVERS:
a = &server->sip;
n_a = &server->n_sip;
break;
case SD_DHCP_LEASE_POP3_SERVERS:
a = &server->pop3_server;
n_a = &server->n_pop3_server;
break;
case SD_DHCP_LEASE_SMTP_SERVERS:
a = &server->smtp_server;
n_a = &server->n_smtp_server;
break;
case SD_DHCP_LEASE_LPR_SERVERS:
a = &server->lpr_server;
n_a = &server->n_lpr_server;
break;
default:
return log_debug_errno(SYNTHETIC_ERRNO(ENXIO),
"Unknown DHCP lease info item %d.", what);
}
if (*n_a == n_addresses &&
memcmp(*a, addresses, sizeof(struct in_addr) * n_addresses) == 0)
if (server->servers[what].size == n_addresses &&
memcmp(server->servers[what].addr, addresses, sizeof(struct in_addr) * n_addresses) == 0)
return 0;
struct in_addr *c = NULL;
if (n_addresses > 0) {
c = newdup(struct in_addr, addresses, n_addresses);
if (!c)
return -ENOMEM;
}
free(*a);
*a = c;
*n_a = n_addresses;
free(server->servers[what].addr);
server->servers[what].addr = c;
server->servers[what].size = n_addresses;
return 1;
}
int sd_dhcp_server_set_dns(sd_dhcp_server *server, const struct in_addr dns[], size_t n) {
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_DNS_SERVERS, dns, n);
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_DNS, dns, n);
}
int sd_dhcp_server_set_ntp(sd_dhcp_server *server, const struct in_addr ntp[], size_t n) {
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_NTP_SERVERS, ntp, n);
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_NTP, ntp, n);
}
int sd_dhcp_server_set_sip(sd_dhcp_server *server, const struct in_addr sip[], size_t n) {
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SIP_SERVERS, sip, n);
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SIP, sip, n);
}
int sd_dhcp_server_set_pop3(sd_dhcp_server *server, const struct in_addr pop3[], size_t n) {
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_POP3_SERVERS, pop3, n);
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_POP3, pop3, n);
}
int sd_dhcp_server_set_smtp(sd_dhcp_server *server, const struct in_addr smtp[], size_t n) {
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SMTP_SERVERS, smtp, n);
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_SMTP, smtp, n);
}
int sd_dhcp_server_set_lpr(sd_dhcp_server *server, const struct in_addr lpr[], size_t n) {
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_LPR_SERVERS, lpr, n);
return sd_dhcp_server_set_servers(server, SD_DHCP_LEASE_LPR, lpr, n);
}
int sd_dhcp_server_set_emit_router(sd_dhcp_server *server, int enabled) {

3
src/libsystemd-network/test-dhcp-client.c
View File

@ -4,10 +4,11 @@
***/
#include <errno.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <net/if.h>
#include "sd-dhcp-client.h"
#include "sd-event.h"

3
src/libsystemd-network/test-dhcp-option.c
View File

@ -1,4 +1,7 @@
/* SPDX-License-Identifier: LGPL-2.1+ */
#include <errno.h>
#include <net/if_arp.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

1
src/libsystemd-network/test-dhcp-server.c
View File

@ -4,6 +4,7 @@
***/
#include <errno.h>
#include <net/if_arp.h>
#include "sd-dhcp-server.h"
#include "sd-event.h"

36
src/network/networkd-dhcp-server.c
View File

@ -79,7 +79,7 @@ static int link_push_uplink_dns_to_dhcp_server(Link *link, sd_dhcp_server *s) {
static int link_push_uplink_to_dhcp_server(
Link *link,
sd_dhcp_lease_info what,
sd_dhcp_lease_server_type what,
sd_dhcp_server *s) {
_cleanup_free_ struct in_addr *addresses = NULL;
@ -90,35 +90,35 @@ static int link_push_uplink_to_dhcp_server(
if (!link->network)
return 0;
log_link_debug(link, "Copying %s from link", dhcp_lease_info_to_string(what));
log_link_debug(link, "Copying %s from link", dhcp_lease_server_type_to_string(what));
switch (what) {
case SD_DHCP_LEASE_DNS_SERVERS:
case SD_DHCP_LEASE_DNS:
/* DNS servers are stored as parsed data, so special handling is required.
* TODO: check if DNS servers should be stored unparsed too. */
return link_push_uplink_dns_to_dhcp_server(link, s);
case SD_DHCP_LEASE_NTP_SERVERS:
case SD_DHCP_LEASE_NTP:
servers = link->network->ntp;
lease_condition = link->network->dhcp_use_ntp;
break;
case SD_DHCP_LEASE_POP3_SERVERS:
case SD_DHCP_LEASE_POP3:
servers = link->network->pop3;
lease_condition = true;
break;
case SD_DHCP_LEASE_SMTP_SERVERS:
case SD_DHCP_LEASE_SMTP:
servers = link->network->smtp;
lease_condition = true;
break;
case SD_DHCP_LEASE_SIP_SERVERS:
case SD_DHCP_LEASE_SIP:
servers = link->network->sip;
lease_condition = link->network->dhcp_use_sip;
break;
case SD_DHCP_LEASE_LPR_SERVERS:
case SD_DHCP_LEASE_LPR:
servers = link->network->lpr;
lease_condition = true;
break;
@ -290,38 +290,38 @@ int dhcp4_server_configure(Link *link) {
const struct in_addr *servers;
unsigned n_servers;
} configs[] = {
[SD_DHCP_LEASE_DNS_SERVERS] = {
[SD_DHCP_LEASE_DNS] = {
link->network->dhcp_server_emit_dns,
link->network->dhcp_server_dns,
link->network->n_dhcp_server_dns,
},
[SD_DHCP_LEASE_NTP_SERVERS] = {
[SD_DHCP_LEASE_NTP] = {
link->network->dhcp_server_emit_ntp,
link->network->dhcp_server_ntp,
link->network->n_dhcp_server_ntp,
},
[SD_DHCP_LEASE_SIP_SERVERS] = {
[SD_DHCP_LEASE_SIP] = {
link->network->dhcp_server_emit_sip,
link->network->dhcp_server_sip,
link->network->n_dhcp_server_sip,
},
[SD_DHCP_LEASE_POP3_SERVERS] = {
[SD_DHCP_LEASE_POP3] = {
true,
link->network->dhcp_server_pop3,
link->network->n_dhcp_server_pop3,
},
[SD_DHCP_LEASE_SMTP_SERVERS] = {
[SD_DHCP_LEASE_SMTP] = {
true,
link->network->dhcp_server_smtp,
link->network->n_dhcp_server_smtp,
},
[SD_DHCP_LEASE_LPR_SERVERS] = {
[SD_DHCP_LEASE_LPR] = {
true,
link->network->dhcp_server_lpr,
link->network->n_dhcp_server_lpr,
},
};
assert_cc(ELEMENTSOF(configs) == _SD_DHCP_LEASE_INFO_MAX);
assert_cc(ELEMENTSOF(configs) == _SD_DHCP_LEASE_SERVER_TYPE_MAX);
for (unsigned n = 0; n < ELEMENTSOF(configs); n++)
if (configs[n].condition) {
@ -337,17 +337,17 @@ int dhcp4_server_configure(Link *link) {
if (!uplink) {
log_link_debug(link,
"Not emitting %s on link, couldn't find suitable uplink.",
dhcp_lease_info_to_string(n));
dhcp_lease_server_type_to_string(n));
r = 0;
} else if (uplink->network)
r = link_push_uplink_to_dhcp_server(uplink, n, link->dhcp_server);
else if (n == SD_DHCP_LEASE_DNS_SERVERS)
else if (n == SD_DHCP_LEASE_DNS)
r = dhcp4_server_set_dns_from_resolve_conf(link);
}
if (r < 0)
log_link_warning_errno(link, r,
"Failed to set %s for DHCP server, ignoring: %m",
dhcp_lease_info_to_string(n));
dhcp_lease_server_type_to_string(n));
}
r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);

20
src/network/networkd-link.c
View File

@ -4012,7 +4012,7 @@ static void serialize_addresses(
char **addresses,
sd_dhcp_lease *lease,
bool conditional,
sd_dhcp_lease_info what,
sd_dhcp_lease_server_type what,
sd_dhcp6_lease *lease6,
bool conditional6,
int (*lease6_get_addr)(sd_dhcp6_lease*, const struct in6_addr**),
@ -4138,7 +4138,7 @@ int link_save(Link *link) {
NULL,
link->dhcp_lease,
link->network->dhcp_use_dns,
SD_DHCP_LEASE_DNS_SERVERS,
SD_DHCP_LEASE_DNS,
dhcp6_lease,
link->network->dhcp6_use_dns,
sd_dhcp6_lease_get_dns,
@ -4162,7 +4162,7 @@ int link_save(Link *link) {
link->ntp ?: link->network->ntp,
link->dhcp_lease,
link->network->dhcp_use_ntp,
SD_DHCP_LEASE_NTP_SERVERS,
SD_DHCP_LEASE_NTP,
dhcp6_lease,
link->network->dhcp6_use_ntp,
sd_dhcp6_lease_get_ntp_addrs,
@ -4172,28 +4172,28 @@ int link_save(Link *link) {
link->network->sip,
link->dhcp_lease,
link->network->dhcp_use_sip,
SD_DHCP_LEASE_SIP_SERVERS,
SD_DHCP_LEASE_SIP,
false, NULL, NULL, NULL);
serialize_addresses(f, "POP3_SERVERS", NULL,
serialize_addresses(f, "POP3", NULL,
link->network->pop3,
link->dhcp_lease,
true,
SD_DHCP_LEASE_POP3_SERVERS,
SD_DHCP_LEASE_POP3,
false, NULL, NULL, NULL);
serialize_addresses(f, "SMTP_SERVERS", NULL,
serialize_addresses(f, "SMTP", NULL,
link->network->smtp,
link->dhcp_lease,
true,
SD_DHCP_LEASE_SMTP_SERVERS,
SD_DHCP_LEASE_SMTP,
false, NULL, NULL, NULL);
serialize_addresses(f, "LPR_SERVERS", NULL,
serialize_addresses(f, "LPR", NULL,
link->network->lpr,
link->dhcp_lease,
true,
SD_DHCP_LEASE_LPR_SERVERS,
SD_DHCP_LEASE_LPR,
false, NULL, NULL, NULL);
/************************************************************/

6
src/network/networkd-manager.c
View File

@ -1611,7 +1611,7 @@ static int manager_save(Manager *m) {
return r;
}
r = sd_dhcp_lease_get_pop3_server(link->dhcp_lease, &addresses);
r = sd_dhcp_lease_get_pop3(link->dhcp_lease, &addresses);
if (r > 0) {
r = ordered_set_put_in4_addrv(pop3, addresses, r, in4_addr_is_non_local);
if (r < 0)
@ -1619,7 +1619,7 @@ static int manager_save(Manager *m) {
} else if (r < 0 && r != -ENODATA)
return r;
r = sd_dhcp_lease_get_smtp_server(link->dhcp_lease, &addresses);
r = sd_dhcp_lease_get_smtp(link->dhcp_lease, &addresses);
if (r > 0) {
r = ordered_set_put_in4_addrv(smtp, addresses, r, in4_addr_is_non_local);
if (r < 0)
@ -1627,7 +1627,7 @@ static int manager_save(Manager *m) {
} else if (r < 0 && r != -ENODATA)
return r;
r = sd_dhcp_lease_get_lpr_servers(link->dhcp_lease, &addresses);
r = sd_dhcp_lease_get_lpr(link->dhcp_lease, &addresses);
if (r > 0) {
r = ordered_set_put_in4_addrv(lpr, addresses, r, in4_addr_is_non_local);
if (r < 0)

16
src/network/networkd-util.c
View File

@ -37,13 +37,13 @@ static const char* const duplicate_address_detection_address_family_table[_ADDRE
[ADDRESS_FAMILY_IPV6] = "ipv6",
};
static const char* const dhcp_lease_info_table[_SD_DHCP_LEASE_INFO_MAX] = {
[SD_DHCP_LEASE_DNS_SERVERS] = "DNS servers",
[SD_DHCP_LEASE_NTP_SERVERS] = "NTP servers",
[SD_DHCP_LEASE_SIP_SERVERS] = "SIP servers",
[SD_DHCP_LEASE_POP3_SERVERS] = "POP3 servers",
[SD_DHCP_LEASE_SMTP_SERVERS] = "SMTP servers",
[SD_DHCP_LEASE_LPR_SERVERS] = "LPR servers",
static const char* const dhcp_lease_server_type_table[_SD_DHCP_LEASE_SERVER_TYPE_MAX] = {
[SD_DHCP_LEASE_DNS] = "DNS servers",
[SD_DHCP_LEASE_NTP] = "NTP servers",
[SD_DHCP_LEASE_SIP] = "SIP servers",
[SD_DHCP_LEASE_POP3] = "POP3 servers",
[SD_DHCP_LEASE_SMTP] = "SMTP servers",
[SD_DHCP_LEASE_LPR] = "LPR servers",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(address_family, AddressFamily, ADDRESS_FAMILY_YES);
@ -52,7 +52,7 @@ DEFINE_STRING_TABLE_LOOKUP(routing_policy_rule_address_family, AddressFamily);
DEFINE_STRING_TABLE_LOOKUP(duplicate_address_detection_address_family, AddressFamily);
DEFINE_CONFIG_PARSE_ENUM(config_parse_link_local_address_family, link_local_address_family,
AddressFamily, "Failed to parse option");
DEFINE_STRING_TABLE_LOOKUP(dhcp_lease_info, sd_dhcp_lease_info);
DEFINE_STRING_TABLE_LOOKUP(dhcp_lease_server_type, sd_dhcp_lease_server_type);
int config_parse_address_family_with_kernel(
const char* unit,

4
src/network/networkd-util.h
View File

@ -40,8 +40,8 @@ AddressFamily routing_policy_rule_address_family_from_string(const char *s) _pur
const char *duplicate_address_detection_address_family_to_string(AddressFamily b) _const_;
AddressFamily duplicate_address_detection_address_family_from_string(const char *s) _pure_;
const char *dhcp_lease_info_to_string(sd_dhcp_lease_info info) _const_;
sd_dhcp_lease_info dhcp_lease_info_from_string(const char *s) _pure_;
const char *dhcp_lease_server_type_to_string(sd_dhcp_lease_server_type t) _const_;
sd_dhcp_lease_server_type dhcp_lease_server_type_from_string(const char *s) _pure_;
int kernel_route_expiration_supported(void);

27
src/systemd/sd-dhcp-lease.h
View File

@ -33,15 +33,16 @@ typedef struct sd_dhcp_route sd_dhcp_route;
sd_dhcp_lease *sd_dhcp_lease_ref(sd_dhcp_lease *lease);
sd_dhcp_lease *sd_dhcp_lease_unref(sd_dhcp_lease *lease);
typedef enum sd_dhcp_lease_info {
SD_DHCP_LEASE_DNS_SERVERS = 0,
SD_DHCP_LEASE_NTP_SERVERS,
SD_DHCP_LEASE_SIP_SERVERS,
SD_DHCP_LEASE_POP3_SERVERS,
SD_DHCP_LEASE_SMTP_SERVERS,
SD_DHCP_LEASE_LPR_SERVERS,
_SD_DHCP_LEASE_INFO_MAX,
} sd_dhcp_lease_info;
typedef enum sd_dhcp_lease_server_type {
SD_DHCP_LEASE_DNS,
SD_DHCP_LEASE_NTP,
SD_DHCP_LEASE_SIP,
SD_DHCP_LEASE_POP3,
SD_DHCP_LEASE_SMTP,
SD_DHCP_LEASE_LPR,
_SD_DHCP_LEASE_SERVER_TYPE_MAX,
_SD_DHCP_LEASE_SERVER_TYPE_INVALID = -1,
} sd_dhcp_lease_server_type;
int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_lifetime(sd_dhcp_lease *lease, uint32_t *lifetime);
@ -52,13 +53,13 @@ int sd_dhcp_lease_get_netmask(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_router(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_next_server(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_server_identifier(sd_dhcp_lease *lease, struct in_addr *addr);
int sd_dhcp_lease_get_servers(sd_dhcp_lease *lease, sd_dhcp_lease_info what, const struct in_addr **addr);
int sd_dhcp_lease_get_servers(sd_dhcp_lease *lease, sd_dhcp_lease_server_type what, const struct in_addr **addr);
int sd_dhcp_lease_get_dns(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_ntp(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_sip(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_pop3_server(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_smtp_server(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_lpr_servers(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_pop3(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_smtp(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_lpr(sd_dhcp_lease *lease, const struct in_addr **addr);
int sd_dhcp_lease_get_mtu(sd_dhcp_lease *lease, uint16_t *mtu);
int sd_dhcp_lease_get_domainname(sd_dhcp_lease *lease, const char **domainname);
int sd_dhcp_lease_get_search_domains(sd_dhcp_lease *lease, char ***domains);

2
src/systemd/sd-dhcp-server.h
View File

@ -52,7 +52,7 @@ int sd_dhcp_server_set_emit_router(sd_dhcp_server *server, int enabled);
int sd_dhcp_server_set_servers(
sd_dhcp_server *server,
sd_dhcp_lease_info what,
sd_dhcp_lease_server_type what,
const struct in_addr addresses[],
size_t n_addresses);