repo
stringlengths 1
152
⌀ | file
stringlengths 14
221
| code
stringlengths 501
25k
| file_length
int64 501
25k
| avg_line_length
float64 20
99.5
| max_line_length
int64 21
134
| extension_type
stringclasses 2
values |
|---|---|---|---|---|---|---|
null |
systemd-main/src/libsystemd-network/dhcp6-protocol.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <errno.h>
#include <netinet/ip6.h>
#include <netinet/udp.h>
#include "macro.h"
#include "sparse-endian.h"
struct DHCP6Message {
union {
struct {
uint8_t type;
uint8_t _pad[3];
} _packed_;
be32_t transaction_id;
};
uint8_t options[];
} _packed_;
typedef struct DHCP6Message DHCP6Message;
#define DHCP6_MIN_OPTIONS_SIZE \
1280 - sizeof(struct ip6_hdr) - sizeof(struct udphdr)
#define IN6ADDR_ALL_DHCP6_RELAY_AGENTS_AND_SERVERS_INIT \
{ { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02 } } }
enum {
DHCP6_PORT_SERVER = 547,
DHCP6_PORT_CLIENT = 546,
};
#define DHCP6_INF_TIMEOUT (1 * USEC_PER_SEC)
#define DHCP6_INF_MAX_RT (120 * USEC_PER_SEC)
#define DHCP6_SOL_MAX_DELAY (1 * USEC_PER_SEC)
#define DHCP6_SOL_TIMEOUT (1 * USEC_PER_SEC)
#define DHCP6_SOL_MAX_RT (120 * USEC_PER_SEC)
#define DHCP6_REQ_TIMEOUT (1 * USEC_PER_SEC)
#define DHCP6_REQ_MAX_RT (120 * USEC_PER_SEC)
#define DHCP6_REQ_MAX_RC 10
#define DHCP6_REN_TIMEOUT (10 * USEC_PER_SEC)
#define DHCP6_REN_MAX_RT (600 * USEC_PER_SEC)
#define DHCP6_REB_TIMEOUT (10 * USEC_PER_SEC)
#define DHCP6_REB_MAX_RT (600 * USEC_PER_SEC)
typedef enum DHCP6State {
DHCP6_STATE_STOPPED,
DHCP6_STATE_INFORMATION_REQUEST,
DHCP6_STATE_SOLICITATION,
DHCP6_STATE_REQUEST,
DHCP6_STATE_BOUND,
DHCP6_STATE_RENEW,
DHCP6_STATE_REBIND,
DHCP6_STATE_STOPPING,
_DHCP6_STATE_MAX,
_DHCP6_STATE_INVALID = -EINVAL,
} DHCP6State;
/* https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml#dhcpv6-parameters-1 */
typedef enum DHCP6MessageType {
DHCP6_MESSAGE_SOLICIT = 1, /* RFC 8415 */
DHCP6_MESSAGE_ADVERTISE = 2, /* RFC 8415 */
DHCP6_MESSAGE_REQUEST = 3, /* RFC 8415 */
DHCP6_MESSAGE_CONFIRM = 4, /* RFC 8415 */
DHCP6_MESSAGE_RENEW = 5, /* RFC 8415 */
DHCP6_MESSAGE_REBIND = 6, /* RFC 8415 */
DHCP6_MESSAGE_REPLY = 7, /* RFC 8415 */
DHCP6_MESSAGE_RELEASE = 8, /* RFC 8415 */
DHCP6_MESSAGE_DECLINE = 9, /* RFC 8415 */
DHCP6_MESSAGE_RECONFIGURE = 10, /* RFC 8415 */
DHCP6_MESSAGE_INFORMATION_REQUEST = 11, /* RFC 8415 */
DHCP6_MESSAGE_RELAY_FORWARD = 12, /* RFC 8415 */
DHCP6_MESSAGE_RELAY_REPLY = 13, /* RFC 8415 */
DHCP6_MESSAGE_LEASE_QUERY = 14, /* RFC 5007 */
DHCP6_MESSAGE_LEASE_QUERY_REPLY = 15, /* RFC 5007 */
DHCP6_MESSAGE_LEASE_QUERY_DONE = 16, /* RFC 5460 */
DHCP6_MESSAGE_LEASE_QUERY_DATA = 17, /* RFC 5460 */
DHCP6_MESSAGE_RECONFIGURE_REQUEST = 18, /* RFC 6977 */
DHCP6_MESSAGE_RECONFIGURE_REPLY = 19, /* RFC 6977 */
DHCP6_MESSAGE_DHCPV4_QUERY = 20, /* RFC 7341 */
DHCP6_MESSAGE_DHCPV4_RESPONSE = 21, /* RFC 7341 */
DHCP6_MESSAGE_ACTIVE_LEASE_QUERY = 22, /* RFC 7653 */
DHCP6_MESSAGE_START_TLS = 23, /* RFC 7653 */
DHCP6_MESSAGE_BINDING_UPDATE = 24, /* RFC 8156 */
DHCP6_MESSAGE_BINDING_REPLY = 25, /* RFC 8156 */
DHCP6_MESSAGE_POOL_REQUEST = 26, /* RFC 8156 */
DHCP6_MESSAGE_POOL_RESPONSE = 27, /* RFC 8156 */
DHCP6_MESSAGE_UPDATE_REQUEST = 28, /* RFC 8156 */
DHCP6_MESSAGE_UPDATE_REQUEST_ALL = 29, /* RFC 8156 */
DHCP6_MESSAGE_UPDATE_DONE = 30, /* RFC 8156 */
DHCP6_MESSAGE_CONNECT = 31, /* RFC 8156 */
DHCP6_MESSAGE_CONNECT_REPLY = 32, /* RFC 8156 */
DHCP6_MESSAGE_DISCONNECT = 33, /* RFC 8156 */
DHCP6_MESSAGE_STATE = 34, /* RFC 8156 */
DHCP6_MESSAGE_CONTACT = 35, /* RFC 8156 */
_DHCP6_MESSAGE_TYPE_MAX,
_DHCP6_MESSAGE_TYPE_INVALID = -EINVAL,
} DHCP6MessageType;
typedef enum DHCP6NTPSubOption {
DHCP6_NTP_SUBOPTION_SRV_ADDR = 1,
DHCP6_NTP_SUBOPTION_MC_ADDR = 2,
DHCP6_NTP_SUBOPTION_SRV_FQDN = 3,
_DHCP6_NTP_SUBOPTION_MAX,
_DHCP6_NTP_SUBOPTION_INVALID = -EINVAL,
} DHCP6NTPSubOption;
/*
* RFC 8415, RFC 5007 and RFC 7653 status codes:
* https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml#dhcpv6-parameters-5
*/
typedef enum DHCP6Status {
DHCP6_STATUS_SUCCESS = 0,
DHCP6_STATUS_UNSPEC_FAIL = 1,
DHCP6_STATUS_NO_ADDRS_AVAIL = 2,
DHCP6_STATUS_NO_BINDING = 3,
DHCP6_STATUS_NOT_ON_LINK = 4,
DHCP6_STATUS_USE_MULTICAST = 5,
DHCP6_STATUS_NO_PREFIX_AVAIL = 6,
DHCP6_STATUS_UNKNOWN_QUERY_TYPE = 7,
DHCP6_STATUS_MALFORMED_QUERY = 8,
DHCP6_STATUS_NOT_CONFIGURED = 9,
DHCP6_STATUS_NOT_ALLOWED = 10,
DHCP6_STATUS_QUERY_TERMINATED = 11,
DHCP6_STATUS_DATA_MISSING = 12,
DHCP6_STATUS_CATCHUP_COMPLETE = 13,
DHCP6_STATUS_NOT_SUPPORTED = 14,
DHCP6_STATUS_TLS_CONNECTION_REFUSED = 15,
DHCP6_STATUS_ADDRESS_IN_USE = 16,
DHCP6_STATUS_CONFIGURATION_CONFLICT = 17,
DHCP6_STATUS_MISSING_BINDING_INFORMATION = 18,
DHCP6_STATUS_OUTDATED_BINDING_INFORMATION = 19,
DHCP6_STATUS_SERVER_SHUTTING_DOWN = 20,
DHCP6_STATUS_DNS_UPDATE_NOT_SUPPORTED = 21,
DHCP6_STATUS_EXCESSIVE_TIME_SKEW = 22,
_DHCP6_STATUS_MAX,
_DHCP6_STATUS_INVALID = -EINVAL,
} DHCP6Status;
typedef enum DHCP6FQDNFlag {
DHCP6_FQDN_FLAG_S = 1 << 0,
DHCP6_FQDN_FLAG_O = 1 << 1,
DHCP6_FQDN_FLAG_N = 1 << 2,
} DHCP6FQDNFlag;
const char *dhcp6_state_to_string(DHCP6State s) _const_;
const char *dhcp6_message_type_to_string(DHCP6MessageType s) _const_;
DHCP6MessageType dhcp6_message_type_from_string(const char *s) _pure_;
const char *dhcp6_message_status_to_string(DHCP6Status s) _const_;
DHCP6Status dhcp6_message_status_from_string(const char *s) _pure_;
int dhcp6_message_status_to_errno(DHCP6Status s);
| 7,208 | 44.339623 | 100 |
h
|
null |
systemd-main/src/libsystemd-network/fuzz-dhcp-client.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <sys/socket.h>
#include <unistd.h>
#include "alloc-util.h"
#include "fuzz.h"
#include "sd-event.h"
#include "sd-dhcp-client.c"
int dhcp_network_bind_raw_socket(
int ifindex,
union sockaddr_union *link,
uint32_t id,
const struct hw_addr_data *hw_addr,
const struct hw_addr_data *bcast_addr,
uint16_t arp_type,
uint16_t port,
bool so_priority_set,
int so_priority) {
int fd;
fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
if (fd < 0)
return -errno;
return fd;
}
int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) {
return len;
}
int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port, int ip_service_type) {
int fd;
fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
if (fd < 0)
return -errno;
return fd;
}
int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port, const void *packet, size_t len) {
return len;
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
uint8_t mac_addr[] = {'A', 'B', 'C', '1', '2', '3'};
uint8_t bcast_addr[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
_cleanup_(sd_dhcp_client_unrefp) sd_dhcp_client *client = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
int res, r;
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
r = sd_dhcp_client_new(&client, false);
assert_se(r >= 0);
assert_se(client);
assert_se(sd_event_new(&e) >= 0);
r = sd_dhcp_client_attach_event(client, e, 0);
assert_se(r >= 0);
assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0);
assert_se(sd_dhcp_client_set_mac(client, mac_addr, bcast_addr, ETH_ALEN, ARPHRD_ETHER) >= 0);
dhcp_client_set_test_mode(client, true);
res = sd_dhcp_client_start(client);
assert_se(IN_SET(res, 0, -EINPROGRESS));
client->xid = 2;
(void) client_handle_offer(client, (DHCPMessage*) data, size);
assert_se(sd_dhcp_client_stop(client) >= 0);
return 0;
}
| 2,424 | 28.216867 | 107 |
c
|
null |
systemd-main/src/libsystemd-network/fuzz-dhcp-server-relay.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "fuzz.h"
#include "sd-dhcp-server.c"
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
return len;
}
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags) {
return 0;
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
struct in_addr address = {.s_addr = htobe32(UINT32_C(10) << 24 | UINT32_C(1))};
union in_addr_union relay_address;
_cleanup_free_ uint8_t *message = NULL;
if (size < sizeof(DHCPMessage))
return 0;
assert_se(sd_dhcp_server_new(&server, 1) >= 0);
assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
assert_se(sd_dhcp_server_configure_pool(server, &address, 24, 0, 0) >= 0);
assert_se(in_addr_from_string(AF_INET, "192.168.5.1", &relay_address) >= 0);
assert_se(sd_dhcp_server_set_relay_target(server, &relay_address.in) >= 0);
assert_se(sd_dhcp_server_set_bind_to_interface(server, false) >= 0);
assert_se(sd_dhcp_server_set_relay_agent_information(server, "string:sample_circuit_id", "string:sample_remote_id") >= 0);
size_t buflen = size;
buflen += relay_agent_information_length(server->agent_circuit_id, server->agent_remote_id) + 2;
assert_se(message = malloc(buflen));
memcpy(message, data, size);
server->fd = open("/dev/null", O_RDWR|O_CLOEXEC|O_NOCTTY);
assert_se(server->fd >= 0);
(void) dhcp_server_relay_message(server, (DHCPMessage *) message, size - sizeof(DHCPMessage), buflen);
return 0;
}
| 1,818 | 37.702128 | 130 |
c
|
null |
systemd-main/src/libsystemd-network/fuzz-dhcp-server.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "fuzz.h"
#include "sd-dhcp-server.c"
/* stub out network so that the server doesn't send */
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
return len;
}
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags) {
return 0;
}
static int add_lease(sd_dhcp_server *server, const struct in_addr *server_address, uint8_t i) {
_cleanup_(dhcp_lease_freep) DHCPLease *lease = NULL;
int r;
assert(server);
lease = new(DHCPLease, 1);
if (!lease)
return -ENOMEM;
*lease = (DHCPLease) {
.address = htobe32(UINT32_C(10) << 24 | i),
.chaddr = { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
.expiration = UINT64_MAX,
.gateway = server_address->s_addr,
.hlen = ETH_ALEN,
.htype = ARPHRD_ETHER,
.client_id.length = 2,
};
lease->client_id.data = new(uint8_t, lease->client_id.length);
if (!lease->client_id.data)
return -ENOMEM;
lease->client_id.data[0] = 2;
lease->client_id.data[1] = i;
lease->server = server; /* This must be set just before hashmap_put(). */
r = hashmap_ensure_put(&server->bound_leases_by_client_id, &dhcp_lease_hash_ops, &lease->client_id, lease);
if (r < 0)
return r;
r = hashmap_ensure_put(&server->bound_leases_by_address, NULL, UINT32_TO_PTR(lease->address), lease);
if (r < 0)
return r;
TAKE_PTR(lease);
return 0;
}
static int add_static_lease(sd_dhcp_server *server, uint8_t i) {
uint8_t id[2] = { 2, i };
assert(server);
return sd_dhcp_server_set_static_lease(
server,
&(struct in_addr) { .s_addr = htobe32(UINT32_C(10) << 24 | i)},
id, ELEMENTSOF(id));
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
struct in_addr address = { .s_addr = htobe32(UINT32_C(10) << 24 | UINT32_C(1))};
_cleanup_free_ uint8_t *duped = NULL;
if (size < sizeof(DHCPMessage))
return 0;
assert_se(duped = memdup(data, size));
assert_se(sd_dhcp_server_new(&server, 1) >= 0);
assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
server->fd = open("/dev/null", O_RDWR|O_CLOEXEC|O_NOCTTY);
assert_se(server->fd >= 0);
assert_se(sd_dhcp_server_configure_pool(server, &address, 24, 0, 0) >= 0);
/* add leases to the pool to expose additional code paths */
assert_se(add_lease(server, &address, 2) >= 0);
assert_se(add_lease(server, &address, 3) >= 0);
/* add static leases */
assert_se(add_static_lease(server, 3) >= 0);
assert_se(add_static_lease(server, 4) >= 0);
(void) dhcp_server_handle_message(server, (DHCPMessage*) duped, size);
return 0;
}
| 3,273 | 31.415842 | 121 |
c
|
null |
systemd-main/src/libsystemd-network/fuzz-dhcp6-client.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <unistd.h>
#include "sd-dhcp6-client.h"
#include "sd-event.h"
#include "dhcp6-internal.h"
#include "event-util.h"
#include "fd-util.h"
#include "fuzz.h"
static int test_dhcp_fd[2] = PIPE_EBADF;
int dhcp6_network_send_udp_socket(int s, struct in6_addr *server_address, const void *packet, size_t len) {
return len;
}
int dhcp6_network_bind_udp_socket(int index, struct in6_addr *local_address) {
assert_se(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_dhcp_fd) >= 0);
return TAKE_FD(test_dhcp_fd[0]);
}
static void fuzz_client(sd_dhcp6_client *client, const uint8_t *data, size_t size, DHCP6State state) {
assert_se(sd_dhcp6_client_set_information_request(client, state == DHCP6_STATE_INFORMATION_REQUEST) >= 0);
assert_se(sd_dhcp6_client_start(client) >= 0);
client->state = state;
if (size >= sizeof(DHCP6Message))
assert_se(dhcp6_client_set_transaction_id(client, ((const DHCP6Message *) data)->transaction_id) == 0);
/* These states does not require lease to send message. */
if (IN_SET(client->state, DHCP6_STATE_INFORMATION_REQUEST, DHCP6_STATE_SOLICITATION))
assert_se(dhcp6_client_send_message(client) >= 0);
assert_se(write(test_dhcp_fd[1], data, size) == (ssize_t) size);
assert_se(sd_event_run(sd_dhcp6_client_get_event(client), UINT64_MAX) > 0);
/* Check the state transition. */
if (client->state != state)
switch (state) {
case DHCP6_STATE_INFORMATION_REQUEST:
assert_se(client->state == DHCP6_STATE_STOPPED);
break;
case DHCP6_STATE_SOLICITATION:
assert_se(IN_SET(client->state, DHCP6_STATE_REQUEST, DHCP6_STATE_BOUND));
break;
case DHCP6_STATE_REQUEST:
assert_se(IN_SET(client->state, DHCP6_STATE_BOUND, DHCP6_STATE_SOLICITATION));
break;
default:
assert_not_reached();
}
/* Send message if the client has a lease. */
if (state != DHCP6_STATE_INFORMATION_REQUEST && sd_dhcp6_client_get_lease(client, NULL) >= 0) {
client->state = DHCP6_STATE_REQUEST;
dhcp6_client_send_message(client);
}
assert_se(sd_dhcp6_client_stop(client) >= 0);
test_dhcp_fd[1] = safe_close(test_dhcp_fd[1]);
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_dhcp6_client_unrefp) sd_dhcp6_client *client = NULL;
_cleanup_(sd_dhcp6_option_unrefp) sd_dhcp6_option *v1 = NULL, *v2 = NULL;
struct in6_addr address = { { { 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01 } } };
struct in6_addr hint = { { { 0x3f, 0xfe, 0x05, 0x01, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } };
static const char *v1_data = "hogehoge", *v2_data = "foobar";
if (outside_size_range(size, 0, 65536))
return 0;
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_dhcp6_client_new(&client) >= 0);
assert_se(sd_dhcp6_client_attach_event(client, e, 0) >= 0);
assert_se(sd_dhcp6_client_set_ifindex(client, 42) >= 0);
assert_se(sd_dhcp6_client_set_local_address(client, &address) >= 0);
dhcp6_client_set_test_mode(client, true);
/* Used when sending message. */
assert_se(sd_dhcp6_client_set_fqdn(client, "example.com") == 1);
assert_se(sd_dhcp6_client_set_request_mud_url(client, "https://www.example.com/mudfile.json") >= 0);
assert_se(sd_dhcp6_client_set_request_user_class(client, STRV_MAKE("u1", "u2", "u3")) >= 0);
assert_se(sd_dhcp6_client_set_request_vendor_class(client, STRV_MAKE("v1", "v2", "v3")) >= 0);
assert_se(sd_dhcp6_client_set_prefix_delegation_hint(client, 48, &hint) >= 0);
assert_se(sd_dhcp6_option_new(123, v1_data, strlen(v1_data), 12345, &v1) >= 0);
assert_se(sd_dhcp6_option_new(456, v2_data, strlen(v2_data), 45678, &v2) >= 0);
assert_se(sd_dhcp6_client_add_vendor_option(client, v1) >= 0);
assert_se(sd_dhcp6_client_add_vendor_option(client, v2) >= 0);
fuzz_client(client, data, size, DHCP6_STATE_INFORMATION_REQUEST);
fuzz_client(client, data, size, DHCP6_STATE_SOLICITATION);
/* If size is zero, then the resend timer will be triggered at first,
* but in the REQUEST state the client must have a lease. */
if (size == 0)
return 0;
fuzz_client(client, data, size, DHCP6_STATE_REQUEST);
return 0;
}
| 4,815 | 43.183486 | 119 |
c
|
null |
systemd-main/src/libsystemd-network/fuzz-lldp-rx.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <unistd.h>
#include "sd-event.h"
#include "sd-lldp-rx.h"
#include "fd-util.h"
#include "fuzz.h"
#include "lldp-network.h"
static int test_fd[2] = PIPE_EBADF;
int lldp_network_bind_raw_socket(int ifindex) {
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
return -errno;
return test_fd[0];
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL;
if (outside_size_range(size, 0, 2048))
return 0;
assert_se(sd_event_new(&e) == 0);
assert_se(sd_lldp_rx_new(&lldp_rx) >= 0);
assert_se(sd_lldp_rx_set_ifindex(lldp_rx, 42) >= 0);
assert_se(sd_lldp_rx_attach_event(lldp_rx, e, 0) >= 0);
assert_se(sd_lldp_rx_start(lldp_rx) >= 0);
assert_se(write(test_fd[1], data, size) == (ssize_t) size);
assert_se(sd_event_run(e, 0) >= 0);
assert_se(sd_lldp_rx_stop(lldp_rx) >= 0);
assert_se(sd_lldp_rx_detach_event(lldp_rx) >= 0);
test_fd[1] = safe_close(test_fd[1]);
return 0;
}
| 1,257 | 27.590909 | 92 |
c
|
null |
systemd-main/src/libsystemd-network/fuzz-ndisc-rs.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <arpa/inet.h>
#include <netinet/icmp6.h>
#include <unistd.h>
#include "sd-ndisc.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "fuzz.h"
#include "icmp6-util.h"
#include "ndisc-internal.h"
#include "socket-util.h"
static int test_fd[2] = PIPE_EBADF;
int icmp6_bind_router_solicitation(int index) {
assert_se(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) >= 0);
return test_fd[0];
}
int icmp6_bind_router_advertisement(int index) {
return -ENOSYS;
}
int icmp6_receive(int fd, void *iov_base, size_t iov_len,
struct in6_addr *dst, triple_timestamp *timestamp) {
assert_se(read(fd, iov_base, iov_len) == (ssize_t) iov_len);
if (timestamp)
triple_timestamp_get(timestamp);
return 0;
}
int icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr) {
return 0;
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
struct ether_addr mac_addr = {
.ether_addr_octet = {'A', 'B', 'C', '1', '2', '3'}
};
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
if (outside_size_range(size, 0, 2048))
return 0;
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_ndisc_new(&nd) >= 0);
assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
assert_se(sd_ndisc_start(nd) >= 0);
assert_se(write(test_fd[1], data, size) == (ssize_t) size);
(void) sd_event_run(e, UINT64_MAX);
assert_se(sd_ndisc_stop(nd) >= 0);
close(test_fd[1]);
return 0;
}
| 1,838 | 27.734375 | 100 |
c
|
null |
systemd-main/src/libsystemd-network/icmp6-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <errno.h>
#include <netinet/icmp6.h>
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <net/if.h>
#include <linux/if_packet.h>
#include "fd-util.h"
#include "icmp6-util.h"
#include "in-addr-util.h"
#include "io-util.h"
#include "socket-util.h"
#define IN6ADDR_ALL_ROUTERS_MULTICAST_INIT \
{ { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 } } }
#define IN6ADDR_ALL_NODES_MULTICAST_INIT \
{ { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } } }
static int icmp6_bind_router_message(const struct icmp6_filter *filter,
const struct ipv6_mreq *mreq) {
int ifindex = mreq->ipv6mr_interface;
_cleanup_close_ int s = -EBADF;
int r;
assert(filter);
assert(mreq);
s = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK, IPPROTO_ICMPV6);
if (s < 0)
return -errno;
if (setsockopt(s, IPPROTO_ICMPV6, ICMP6_FILTER, filter, sizeof(*filter)) < 0)
return -errno;
if (setsockopt(s, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, mreq, sizeof(*mreq)) < 0)
return -errno;
/* RFC 3315, section 6.7, bullet point 2 may indicate that an
IPV6_PKTINFO socket option also applies for ICMPv6 multicast.
Empirical experiments indicates otherwise and therefore an
IPV6_MULTICAST_IF socket option is used here instead */
r = setsockopt_int(s, IPPROTO_IPV6, IPV6_MULTICAST_IF, ifindex);
if (r < 0)
return r;
r = setsockopt_int(s, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, false);
if (r < 0)
return r;
r = setsockopt_int(s, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, 255);
if (r < 0)
return r;
r = setsockopt_int(s, IPPROTO_IPV6, IPV6_UNICAST_HOPS, 255);
if (r < 0)
return r;
r = setsockopt_int(s, SOL_IPV6, IPV6_RECVHOPLIMIT, true);
if (r < 0)
return r;
r = setsockopt_int(s, SOL_SOCKET, SO_TIMESTAMP, true);
if (r < 0)
return r;
r = socket_bind_to_ifindex(s, ifindex);
if (r < 0)
return r;
return TAKE_FD(s);
}
int icmp6_bind_router_solicitation(int ifindex) {
struct icmp6_filter filter = {};
struct ipv6_mreq mreq = {
.ipv6mr_multiaddr = IN6ADDR_ALL_NODES_MULTICAST_INIT,
.ipv6mr_interface = ifindex,
};
ICMP6_FILTER_SETBLOCKALL(&filter);
ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
return icmp6_bind_router_message(&filter, &mreq);
}
int icmp6_bind_router_advertisement(int ifindex) {
struct icmp6_filter filter = {};
struct ipv6_mreq mreq = {
.ipv6mr_multiaddr = IN6ADDR_ALL_ROUTERS_MULTICAST_INIT,
.ipv6mr_interface = ifindex,
};
ICMP6_FILTER_SETBLOCKALL(&filter);
ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filter);
return icmp6_bind_router_message(&filter, &mreq);
}
int icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr) {
struct sockaddr_in6 dst = {
.sin6_family = AF_INET6,
.sin6_addr = IN6ADDR_ALL_ROUTERS_MULTICAST_INIT,
};
struct {
struct nd_router_solicit rs;
struct nd_opt_hdr rs_opt;
struct ether_addr rs_opt_mac;
} _packed_ rs = {
.rs.nd_rs_type = ND_ROUTER_SOLICIT,
.rs_opt.nd_opt_type = ND_OPT_SOURCE_LINKADDR,
.rs_opt.nd_opt_len = 1,
};
struct iovec iov = {
.iov_base = &rs,
.iov_len = sizeof(rs),
};
struct msghdr msg = {
.msg_name = &dst,
.msg_namelen = sizeof(dst),
.msg_iov = &iov,
.msg_iovlen = 1,
};
assert(s >= 0);
assert(ether_addr);
rs.rs_opt_mac = *ether_addr;
if (sendmsg(s, &msg, 0) < 0)
return -errno;
return 0;
}
int icmp6_receive(int fd, void *buffer, size_t size, struct in6_addr *ret_dst,
triple_timestamp *ret_timestamp) {
/* This needs to be initialized with zero. See #20741. */
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(int)) + /* ttl */
CMSG_SPACE_TIMEVAL) control = {};
struct iovec iov = {};
union sockaddr_union sa = {};
struct msghdr msg = {
.msg_name = &sa.sa,
.msg_namelen = sizeof(sa),
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = &control,
.msg_controllen = sizeof(control),
};
struct cmsghdr *cmsg;
struct in6_addr addr = {};
triple_timestamp t = {};
ssize_t len;
iov = IOVEC_MAKE(buffer, size);
len = recvmsg_safe(fd, &msg, MSG_DONTWAIT);
if (len < 0)
return (int) len;
if ((size_t) len != size)
return -EINVAL;
if (msg.msg_namelen == sizeof(struct sockaddr_in6) &&
sa.in6.sin6_family == AF_INET6) {
addr = sa.in6.sin6_addr;
if (!in6_addr_is_link_local(&addr))
return -EADDRNOTAVAIL;
} else if (msg.msg_namelen > 0)
return -EPFNOSUPPORT;
/* namelen == 0 only happens when running the test-suite over a socketpair */
assert(!(msg.msg_flags & MSG_TRUNC));
CMSG_FOREACH(cmsg, &msg) {
if (cmsg->cmsg_level == SOL_IPV6 &&
cmsg->cmsg_type == IPV6_HOPLIMIT &&
cmsg->cmsg_len == CMSG_LEN(sizeof(int))) {
int hops = *CMSG_TYPED_DATA(cmsg, int);
if (hops != 255)
return -EMULTIHOP;
}
if (cmsg->cmsg_level == SOL_SOCKET &&
cmsg->cmsg_type == SCM_TIMESTAMP &&
cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval))) {
struct timeval *tv = memcpy(&(struct timeval) {}, CMSG_DATA(cmsg), sizeof(struct timeval));
triple_timestamp_from_realtime(&t, timeval_load(tv));
}
}
if (!triple_timestamp_is_set(&t))
triple_timestamp_get(&t);
*ret_dst = addr;
*ret_timestamp = t;
return 0;
}
| 6,875 | 30.833333 | 115 |
c
|
null |
systemd-main/src/libsystemd-network/icmp6-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2014-2015 Intel Corporation. All rights reserved.
***/
#include <net/ethernet.h>
#include "time-util.h"
#define IN6ADDR_ALL_ROUTERS_MULTICAST_INIT \
{ { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 } } }
#define IN6ADDR_ALL_NODES_MULTICAST_INIT \
{ { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } } }
int icmp6_bind_router_solicitation(int ifindex);
int icmp6_bind_router_advertisement(int ifindex);
int icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr);
int icmp6_receive(int fd, void *buffer, size_t size, struct in6_addr *ret_dst,
triple_timestamp *ret_timestamp);
| 851 | 33.08 | 79 |
h
|
null |
systemd-main/src/libsystemd-network/lldp-neighbor.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "escape.h"
#include "ether-addr-util.h"
#include "hexdecoct.h"
#include "in-addr-util.h"
#include "lldp-neighbor.h"
#include "memory-util.h"
#include "missing_network.h"
#include "unaligned.h"
static void lldp_neighbor_id_hash_func(const LLDPNeighborID *id, struct siphash *state) {
assert(id);
assert(state);
siphash24_compress(id->chassis_id, id->chassis_id_size, state);
siphash24_compress(&id->chassis_id_size, sizeof(id->chassis_id_size), state);
siphash24_compress(id->port_id, id->port_id_size, state);
siphash24_compress(&id->port_id_size, sizeof(id->port_id_size), state);
}
int lldp_neighbor_id_compare_func(const LLDPNeighborID *x, const LLDPNeighborID *y) {
assert(x);
assert(y);
return memcmp_nn(x->chassis_id, x->chassis_id_size, y->chassis_id, y->chassis_id_size)
?: memcmp_nn(x->port_id, x->port_id_size, y->port_id, y->port_id_size);
}
DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
lldp_neighbor_hash_ops,
LLDPNeighborID,
lldp_neighbor_id_hash_func,
lldp_neighbor_id_compare_func,
sd_lldp_neighbor,
lldp_neighbor_unlink);
int lldp_neighbor_prioq_compare_func(const void *a, const void *b) {
const sd_lldp_neighbor *x = a, *y = b;
assert(x);
assert(y);
return CMP(x->until, y->until);
}
sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) {
if (!n)
return NULL;
assert(n->n_ref > 0 || n->lldp_rx);
n->n_ref++;
return n;
}
static sd_lldp_neighbor *lldp_neighbor_free(sd_lldp_neighbor *n) {
if (!n)
return NULL;
free(n->id.port_id);
free(n->id.chassis_id);
free(n->port_description);
free(n->system_name);
free(n->system_description);
free(n->mud_url);
free(n->chassis_id_as_string);
free(n->port_id_as_string);
return mfree(n);
}
sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) {
/* Drops one reference from the neighbor. Note that the object is not freed unless it is already unlinked from
* the sd_lldp object. */
if (!n)
return NULL;
assert(n->n_ref > 0);
n->n_ref--;
if (n->n_ref <= 0 && !n->lldp_rx)
lldp_neighbor_free(n);
return NULL;
}
sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n) {
/* Removes the neighbor object from the LLDP object, and frees it if it also has no other reference. */
if (!n)
return NULL;
if (!n->lldp_rx)
return NULL;
/* Only remove the neighbor object from the hash table if it's in there, don't complain if it isn't. This is
* because we are used as destructor call for hashmap_clear() and thus sometimes are called to de-register
* ourselves from the hashtable and sometimes are called after we already are de-registered. */
(void) hashmap_remove_value(n->lldp_rx->neighbor_by_id, &n->id, n);
assert_se(prioq_remove(n->lldp_rx->neighbor_by_expiry, n, &n->prioq_idx) >= 0);
n->lldp_rx = NULL;
if (n->n_ref <= 0)
lldp_neighbor_free(n);
return NULL;
}
sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size) {
sd_lldp_neighbor *n;
if (raw_size > SIZE_MAX - ALIGN(sizeof(sd_lldp_neighbor)))
return NULL;
n = malloc0(ALIGN(sizeof(sd_lldp_neighbor)) + raw_size);
if (!n)
return NULL;
n->raw_size = raw_size;
n->n_ref = 1;
return n;
}
static int parse_string(sd_lldp_rx *lldp_rx, char **s, const void *q, size_t n) {
const char *p = q;
char *k;
assert(s);
assert(p || n == 0);
if (*s) {
log_lldp_rx(lldp_rx, "Found duplicate string, ignoring field.");
return 0;
}
/* Strip trailing NULs, just to be nice */
while (n > 0 && p[n-1] == 0)
n--;
if (n <= 0) /* Ignore empty strings */
return 0;
/* Look for inner NULs */
if (memchr(p, 0, n)) {
log_lldp_rx(lldp_rx, "Found inner NUL in string, ignoring field.");
return 0;
}
/* Let's escape weird chars, for security reasons */
k = cescape_length(p, n);
if (!k)
return log_oom_debug();
free_and_replace(*s, k);
return 1;
}
int lldp_neighbor_parse(sd_lldp_neighbor *n) {
struct ether_header h;
const uint8_t *p;
size_t left;
int r;
assert(n);
if (n->raw_size < sizeof(struct ether_header))
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Received truncated packet, ignoring.");
memcpy(&h, LLDP_NEIGHBOR_RAW(n), sizeof(h));
if (h.ether_type != htobe16(ETHERTYPE_LLDP))
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Received packet with wrong type, ignoring.");
if (h.ether_dhost[0] != 0x01 ||
h.ether_dhost[1] != 0x80 ||
h.ether_dhost[2] != 0xc2 ||
h.ether_dhost[3] != 0x00 ||
h.ether_dhost[4] != 0x00 ||
!IN_SET(h.ether_dhost[5], 0x00, 0x03, 0x0e))
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Received packet with wrong destination address, ignoring.");
memcpy(&n->source_address, h.ether_shost, sizeof(struct ether_addr));
memcpy(&n->destination_address, h.ether_dhost, sizeof(struct ether_addr));
p = (const uint8_t*) LLDP_NEIGHBOR_RAW(n) + sizeof(struct ether_header);
left = n->raw_size - sizeof(struct ether_header);
for (;;) {
uint8_t type;
uint16_t length;
if (left < 2)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"TLV lacks header, ignoring.");
type = p[0] >> 1;
length = p[1] + (((uint16_t) (p[0] & 1)) << 8);
p += 2, left -= 2;
if (left < length)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"TLV truncated, ignoring datagram.");
switch (type) {
case SD_LLDP_TYPE_END:
if (length != 0)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"End marker TLV not zero-sized, ignoring datagram.");
/* Note that after processing the SD_LLDP_TYPE_END left could still be > 0
* as the message may contain padding (see IEEE 802.1AB-2016, sec. 8.5.12) */
goto end_marker;
case SD_LLDP_TYPE_CHASSIS_ID:
if (length < 2 || length > 256)
/* includes the chassis subtype, hence one extra byte */
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Chassis ID field size out of range, ignoring datagram.");
if (n->id.chassis_id)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Duplicate chassis ID field, ignoring datagram.");
n->id.chassis_id = memdup(p, length);
if (!n->id.chassis_id)
return log_oom_debug();
n->id.chassis_id_size = length;
break;
case SD_LLDP_TYPE_PORT_ID:
if (length < 2 || length > 256)
/* includes the port subtype, hence one extra byte */
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Port ID field size out of range, ignoring datagram.");
if (n->id.port_id)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Duplicate port ID field, ignoring datagram.");
n->id.port_id = memdup(p, length);
if (!n->id.port_id)
return log_oom_debug();
n->id.port_id_size = length;
break;
case SD_LLDP_TYPE_TTL:
if (length != 2)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"TTL field has wrong size, ignoring datagram.");
if (n->has_ttl)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Duplicate TTL field, ignoring datagram.");
n->ttl = unaligned_read_be16(p);
n->has_ttl = true;
break;
case SD_LLDP_TYPE_PORT_DESCRIPTION:
r = parse_string(n->lldp_rx, &n->port_description, p, length);
if (r < 0)
return r;
break;
case SD_LLDP_TYPE_SYSTEM_NAME:
r = parse_string(n->lldp_rx, &n->system_name, p, length);
if (r < 0)
return r;
break;
case SD_LLDP_TYPE_SYSTEM_DESCRIPTION:
r = parse_string(n->lldp_rx, &n->system_description, p, length);
if (r < 0)
return r;
break;
case SD_LLDP_TYPE_SYSTEM_CAPABILITIES:
if (length != 4)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"System capabilities field has wrong size.");
n->system_capabilities = unaligned_read_be16(p);
n->enabled_capabilities = unaligned_read_be16(p + 2);
n->has_capabilities = true;
break;
case SD_LLDP_TYPE_PRIVATE:
if (length < 4)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Found private TLV that is too short, ignoring.");
/* RFC 8520: MUD URL */
if (memcmp(p, SD_LLDP_OUI_IANA_MUD, sizeof(SD_LLDP_OUI_IANA_MUD)) == 0) {
r = parse_string(n->lldp_rx, &n->mud_url, p + sizeof(SD_LLDP_OUI_IANA_MUD),
length - sizeof(SD_LLDP_OUI_IANA_MUD));
if (r < 0)
return r;
}
break;
}
p += length, left -= length;
}
end_marker:
if (!n->id.chassis_id || !n->id.port_id || !n->has_ttl)
return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"One or more mandatory TLV missing in datagram. Ignoring.");
n->rindex = sizeof(struct ether_header);
return 0;
}
void lldp_neighbor_start_ttl(sd_lldp_neighbor *n) {
assert(n);
if (n->ttl > 0) {
usec_t base;
/* Use the packet's timestamp if there is one known */
base = triple_timestamp_by_clock(&n->timestamp, CLOCK_BOOTTIME);
if (!timestamp_is_set(base))
base = now(CLOCK_BOOTTIME); /* Otherwise, take the current time */
n->until = usec_add(base, n->ttl * USEC_PER_SEC);
} else
n->until = 0;
if (n->lldp_rx)
prioq_reshuffle(n->lldp_rx->neighbor_by_expiry, n, &n->prioq_idx);
}
bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b) {
if (a == b)
return true;
if (!a || !b)
return false;
if (a->raw_size != b->raw_size)
return false;
return memcmp(LLDP_NEIGHBOR_RAW(a), LLDP_NEIGHBOR_RAW(b), a->raw_size) == 0;
}
int sd_lldp_neighbor_get_source_address(sd_lldp_neighbor *n, struct ether_addr* address) {
assert_return(n, -EINVAL);
assert_return(address, -EINVAL);
*address = n->source_address;
return 0;
}
int sd_lldp_neighbor_get_destination_address(sd_lldp_neighbor *n, struct ether_addr* address) {
assert_return(n, -EINVAL);
assert_return(address, -EINVAL);
*address = n->destination_address;
return 0;
}
int sd_lldp_neighbor_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(size, -EINVAL);
*ret = LLDP_NEIGHBOR_RAW(n);
*size = n->raw_size;
return 0;
}
int sd_lldp_neighbor_get_chassis_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
assert_return(n, -EINVAL);
assert_return(type, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(size, -EINVAL);
assert(n->id.chassis_id_size > 0);
*type = *(uint8_t*) n->id.chassis_id;
*ret = (uint8_t*) n->id.chassis_id + 1;
*size = n->id.chassis_id_size - 1;
return 0;
}
static int format_mac_address(const void *data, size_t sz, char **ret) {
struct ether_addr a;
char *k;
assert(data || sz <= 0);
if (sz != 7)
return 0;
memcpy(&a, (uint8_t*) data + 1, sizeof(a));
k = new(char, ETHER_ADDR_TO_STRING_MAX);
if (!k)
return -ENOMEM;
*ret = ether_addr_to_string(&a, k);
return 1;
}
static int format_network_address(const void *data, size_t sz, char **ret) {
union in_addr_union a;
int family, r;
if (sz == 6 && ((uint8_t*) data)[1] == 1) {
memcpy(&a.in, (uint8_t*) data + 2, sizeof(a.in));
family = AF_INET;
} else if (sz == 18 && ((uint8_t*) data)[1] == 2) {
memcpy(&a.in6, (uint8_t*) data + 2, sizeof(a.in6));
family = AF_INET6;
} else
return 0;
r = in_addr_to_string(family, &a, ret);
if (r < 0)
return r;
return 1;
}
int sd_lldp_neighbor_get_chassis_id_as_string(sd_lldp_neighbor *n, const char **ret) {
char *k;
int r;
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (n->chassis_id_as_string) {
*ret = n->chassis_id_as_string;
return 0;
}
assert(n->id.chassis_id_size > 0);
switch (*(uint8_t*) n->id.chassis_id) {
case SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT:
case SD_LLDP_CHASSIS_SUBTYPE_INTERFACE_ALIAS:
case SD_LLDP_CHASSIS_SUBTYPE_PORT_COMPONENT:
case SD_LLDP_CHASSIS_SUBTYPE_INTERFACE_NAME:
case SD_LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED:
k = cescape_length((char*) n->id.chassis_id + 1, n->id.chassis_id_size - 1);
if (!k)
return -ENOMEM;
goto done;
case SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS:
r = format_mac_address(n->id.chassis_id, n->id.chassis_id_size, &k);
if (r < 0)
return r;
if (r > 0)
goto done;
break;
case SD_LLDP_CHASSIS_SUBTYPE_NETWORK_ADDRESS:
r = format_network_address(n->id.chassis_id, n->id.chassis_id_size, &k);
if (r < 0)
return r;
if (r > 0)
goto done;
break;
}
/* Generic fallback */
k = hexmem(n->id.chassis_id, n->id.chassis_id_size);
if (!k)
return -ENOMEM;
done:
*ret = n->chassis_id_as_string = k;
return 0;
}
int sd_lldp_neighbor_get_port_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
assert_return(n, -EINVAL);
assert_return(type, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(size, -EINVAL);
assert(n->id.port_id_size > 0);
*type = *(uint8_t*) n->id.port_id;
*ret = (uint8_t*) n->id.port_id + 1;
*size = n->id.port_id_size - 1;
return 0;
}
int sd_lldp_neighbor_get_port_id_as_string(sd_lldp_neighbor *n, const char **ret) {
char *k;
int r;
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (n->port_id_as_string) {
*ret = n->port_id_as_string;
return 0;
}
assert(n->id.port_id_size > 0);
switch (*(uint8_t*) n->id.port_id) {
case SD_LLDP_PORT_SUBTYPE_INTERFACE_ALIAS:
case SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT:
case SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME:
case SD_LLDP_PORT_SUBTYPE_LOCALLY_ASSIGNED:
k = cescape_length((char*) n->id.port_id + 1, n->id.port_id_size - 1);
if (!k)
return -ENOMEM;
goto done;
case SD_LLDP_PORT_SUBTYPE_MAC_ADDRESS:
r = format_mac_address(n->id.port_id, n->id.port_id_size, &k);
if (r < 0)
return r;
if (r > 0)
goto done;
break;
case SD_LLDP_PORT_SUBTYPE_NETWORK_ADDRESS:
r = format_network_address(n->id.port_id, n->id.port_id_size, &k);
if (r < 0)
return r;
if (r > 0)
goto done;
break;
}
/* Generic fallback */
k = hexmem(n->id.port_id, n->id.port_id_size);
if (!k)
return -ENOMEM;
done:
*ret = n->port_id_as_string = k;
return 0;
}
int sd_lldp_neighbor_get_ttl(sd_lldp_neighbor *n, uint16_t *ret_sec) {
assert_return(n, -EINVAL);
assert_return(ret_sec, -EINVAL);
*ret_sec = n->ttl;
return 0;
}
int sd_lldp_neighbor_get_system_name(sd_lldp_neighbor *n, const char **ret) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (!n->system_name)
return -ENODATA;
*ret = n->system_name;
return 0;
}
int sd_lldp_neighbor_get_system_description(sd_lldp_neighbor *n, const char **ret) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (!n->system_description)
return -ENODATA;
*ret = n->system_description;
return 0;
}
int sd_lldp_neighbor_get_port_description(sd_lldp_neighbor *n, const char **ret) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (!n->port_description)
return -ENODATA;
*ret = n->port_description;
return 0;
}
int sd_lldp_neighbor_get_mud_url(sd_lldp_neighbor *n, const char **ret) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (!n->mud_url)
return -ENODATA;
*ret = n->mud_url;
return 0;
}
int sd_lldp_neighbor_get_system_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (!n->has_capabilities)
return -ENODATA;
*ret = n->system_capabilities;
return 0;
}
int sd_lldp_neighbor_get_enabled_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
if (!n->has_capabilities)
return -ENODATA;
*ret = n->enabled_capabilities;
return 0;
}
int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
int r;
assert_return(ret, -EINVAL);
assert_return(raw || raw_size <= 0, -EINVAL);
n = lldp_neighbor_new(raw_size);
if (!n)
return -ENOMEM;
memcpy_safe(LLDP_NEIGHBOR_RAW(n), raw, raw_size);
r = lldp_neighbor_parse(n);
if (r < 0)
return r;
*ret = TAKE_PTR(n);
return r;
}
int sd_lldp_neighbor_tlv_rewind(sd_lldp_neighbor *n) {
assert_return(n, -EINVAL);
assert(n->raw_size >= sizeof(struct ether_header));
n->rindex = sizeof(struct ether_header);
return n->rindex < n->raw_size;
}
int sd_lldp_neighbor_tlv_next(sd_lldp_neighbor *n) {
size_t length;
assert_return(n, -EINVAL);
if (n->rindex == n->raw_size) /* EOF */
return -ESPIPE;
if (n->rindex + 2 > n->raw_size) /* Truncated message */
return -EBADMSG;
length = LLDP_NEIGHBOR_TLV_LENGTH(n);
if (n->rindex + 2 + length > n->raw_size)
return -EBADMSG;
n->rindex += 2 + length;
return n->rindex < n->raw_size;
}
int sd_lldp_neighbor_tlv_get_type(sd_lldp_neighbor *n, uint8_t *type) {
assert_return(n, -EINVAL);
assert_return(type, -EINVAL);
if (n->rindex == n->raw_size) /* EOF */
return -ESPIPE;
if (n->rindex + 2 > n->raw_size)
return -EBADMSG;
*type = LLDP_NEIGHBOR_TLV_TYPE(n);
return 0;
}
int sd_lldp_neighbor_tlv_is_type(sd_lldp_neighbor *n, uint8_t type) {
uint8_t k;
int r;
assert_return(n, -EINVAL);
r = sd_lldp_neighbor_tlv_get_type(n, &k);
if (r < 0)
return r;
return type == k;
}
int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t *subtype) {
const uint8_t *d;
size_t length;
int r;
assert_return(n, -EINVAL);
assert_return(oui, -EINVAL);
assert_return(subtype, -EINVAL);
r = sd_lldp_neighbor_tlv_is_type(n, SD_LLDP_TYPE_PRIVATE);
if (r < 0)
return r;
if (r == 0)
return -ENXIO;
length = LLDP_NEIGHBOR_TLV_LENGTH(n);
if (length < 4)
return -EBADMSG;
if (n->rindex + 2 + length > n->raw_size)
return -EBADMSG;
d = LLDP_NEIGHBOR_TLV_DATA(n);
memcpy(oui, d, 3);
*subtype = d[3];
return 0;
}
int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype) {
uint8_t k[3], st;
int r;
r = sd_lldp_neighbor_tlv_get_oui(n, k, &st);
if (r == -ENXIO)
return 0;
if (r < 0)
return r;
return memcmp(k, oui, 3) == 0 && st == subtype;
}
int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
size_t length;
assert_return(n, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(size, -EINVAL);
/* Note that this returns the full TLV, including the TLV header */
if (n->rindex + 2 > n->raw_size)
return -EBADMSG;
length = LLDP_NEIGHBOR_TLV_LENGTH(n);
if (n->rindex + 2 + length > n->raw_size)
return -EBADMSG;
*ret = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
*size = length + 2;
return 0;
}
int sd_lldp_neighbor_get_timestamp(sd_lldp_neighbor *n, clockid_t clock, uint64_t *ret) {
assert_return(n, -EINVAL);
assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
assert_return(clock_supported(clock), -EOPNOTSUPP);
assert_return(ret, -EINVAL);
if (!triple_timestamp_is_set(&n->timestamp))
return -ENODATA;
*ret = triple_timestamp_by_clock(&n->timestamp, clock);
return 0;
}
| 24,938 | 30.330402 | 118 |
c
|
null |
systemd-main/src/libsystemd-network/lldp-neighbor.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include <sys/types.h>
#include "sd-lldp-rx.h"
#include "hash-funcs.h"
#include "lldp-rx-internal.h"
#include "time-util.h"
typedef struct LLDPNeighborID {
/* The spec calls this an "MSAP identifier" */
void *chassis_id;
size_t chassis_id_size;
void *port_id;
size_t port_id_size;
} LLDPNeighborID;
struct sd_lldp_neighbor {
/* Neighbor objects stay around as long as they are linked into an "sd_lldp_rx" object or n_ref > 0. */
sd_lldp_rx *lldp_rx;
unsigned n_ref;
triple_timestamp timestamp;
usec_t until;
unsigned prioq_idx;
struct ether_addr source_address;
struct ether_addr destination_address;
LLDPNeighborID id;
/* The raw packet size. The data is appended to the object, accessible via LLDP_NEIGHBOR_RAW() */
size_t raw_size;
/* The current read index for the iterative TLV interface */
size_t rindex;
/* And a couple of fields parsed out. */
bool has_ttl:1;
bool has_capabilities:1;
bool has_port_vlan_id:1;
uint16_t ttl;
uint16_t system_capabilities;
uint16_t enabled_capabilities;
char *port_description;
char *system_name;
char *system_description;
char *mud_url;
uint16_t port_vlan_id;
char *chassis_id_as_string;
char *port_id_as_string;
};
static inline void *LLDP_NEIGHBOR_RAW(const sd_lldp_neighbor *n) {
return (uint8_t*) n + ALIGN(sizeof(sd_lldp_neighbor));
}
static inline uint8_t LLDP_NEIGHBOR_TLV_TYPE(const sd_lldp_neighbor *n) {
return ((uint8_t*) LLDP_NEIGHBOR_RAW(n))[n->rindex] >> 1;
}
static inline size_t LLDP_NEIGHBOR_TLV_LENGTH(const sd_lldp_neighbor *n) {
uint8_t *p;
p = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
return p[1] + (((size_t) (p[0] & 1)) << 8);
}
static inline void* LLDP_NEIGHBOR_TLV_DATA(const sd_lldp_neighbor *n) {
return ((uint8_t*) LLDP_NEIGHBOR_RAW(n)) + n->rindex + 2;
}
extern const struct hash_ops lldp_neighbor_hash_ops;
int lldp_neighbor_id_compare_func(const LLDPNeighborID *x, const LLDPNeighborID *y);
int lldp_neighbor_prioq_compare_func(const void *a, const void *b);
sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n);
sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size);
int lldp_neighbor_parse(sd_lldp_neighbor *n);
void lldp_neighbor_start_ttl(sd_lldp_neighbor *n);
bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b);
| 2,660 | 27.612903 | 111 |
h
|
null |
systemd-main/src/libsystemd-network/lldp-rx-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-event.h"
#include "sd-lldp-rx.h"
#include "hashmap.h"
#include "network-common.h"
#include "prioq.h"
struct sd_lldp_rx {
unsigned n_ref;
int ifindex;
char *ifname;
int fd;
sd_event *event;
int64_t event_priority;
sd_event_source *io_event_source;
sd_event_source *timer_event_source;
Prioq *neighbor_by_expiry;
Hashmap *neighbor_by_id;
uint64_t neighbors_max;
sd_lldp_rx_callback_t callback;
void *userdata;
uint16_t capability_mask;
struct ether_addr filter_address;
};
const char* lldp_rx_event_to_string(sd_lldp_rx_event_t e) _const_;
sd_lldp_rx_event_t lldp_rx_event_from_string(const char *s) _pure_;
#define log_lldp_rx_errno(lldp_rx, error, fmt, ...) \
log_interface_prefix_full_errno( \
"LLDP Rx: ", \
sd_lldp_rx, lldp_rx, \
error, fmt, ##__VA_ARGS__)
#define log_lldp_rx(lldp_rx, fmt, ...) \
log_interface_prefix_full_errno_zerook( \
"LLDP Rx: ", \
sd_lldp_rx, lldp_rx, \
0, fmt, ##__VA_ARGS__)
| 1,359 | 26.755102 | 67 |
h
|
null |
systemd-main/src/libsystemd-network/ndisc-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include "sd-ndisc.h"
#include "network-common.h"
#include "time-util.h"
#define NDISC_ROUTER_SOLICITATION_INTERVAL (4U * USEC_PER_SEC)
#define NDISC_MAX_ROUTER_SOLICITATION_INTERVAL (3600U * USEC_PER_SEC)
#define NDISC_MAX_ROUTER_SOLICITATIONS 3U
struct sd_ndisc {
unsigned n_ref;
int ifindex;
char *ifname;
int fd;
sd_event *event;
int event_priority;
struct ether_addr mac_addr;
sd_event_source *recv_event_source;
sd_event_source *timeout_event_source;
sd_event_source *timeout_no_ra;
usec_t retransmit_time;
sd_ndisc_callback_t callback;
void *userdata;
};
const char* ndisc_event_to_string(sd_ndisc_event_t e) _const_;
sd_ndisc_event_t ndisc_event_from_string(const char *s) _pure_;
#define log_ndisc_errno(ndisc, error, fmt, ...) \
log_interface_prefix_full_errno( \
"NDISC: ", \
sd_ndisc, ndisc, \
error, fmt, ##__VA_ARGS__)
#define log_ndisc(ndisc, fmt, ...) \
log_interface_prefix_full_errno_zerook( \
"NDISC: ", \
sd_ndisc, ndisc, \
0, fmt, ##__VA_ARGS__)
| 1,483 | 27.538462 | 69 |
h
|
null |
systemd-main/src/libsystemd-network/ndisc-router.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <netinet/icmp6.h>
#include "sd-ndisc.h"
#include "alloc-util.h"
#include "dns-domain.h"
#include "hostname-util.h"
#include "memory-util.h"
#include "missing_network.h"
#include "ndisc-internal.h"
#include "ndisc-router.h"
#include "strv.h"
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_ndisc_router, sd_ndisc_router, mfree);
sd_ndisc_router *ndisc_router_new(size_t raw_size) {
sd_ndisc_router *rt;
if (raw_size > SIZE_MAX - ALIGN(sizeof(sd_ndisc_router)))
return NULL;
rt = malloc0(ALIGN(sizeof(sd_ndisc_router)) + raw_size);
if (!rt)
return NULL;
rt->raw_size = raw_size;
rt->n_ref = 1;
return rt;
}
int sd_ndisc_router_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
assert_return(rt, -EINVAL);
assert_return(ret_addr, -EINVAL);
if (in6_addr_is_null(&rt->address))
return -ENODATA;
*ret_addr = rt->address;
return 0;
}
int sd_ndisc_router_get_timestamp(sd_ndisc_router *rt, clockid_t clock, uint64_t *ret) {
assert_return(rt, -EINVAL);
assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
assert_return(clock_supported(clock), -EOPNOTSUPP);
assert_return(ret, -EINVAL);
if (!triple_timestamp_is_set(&rt->timestamp))
return -ENODATA;
*ret = triple_timestamp_by_clock(&rt->timestamp, clock);
return 0;
}
int sd_ndisc_router_get_raw(sd_ndisc_router *rt, const void **ret, size_t *size) {
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(size, -EINVAL);
*ret = NDISC_ROUTER_RAW(rt);
*size = rt->raw_size;
return 0;
}
int ndisc_router_parse(sd_ndisc *nd, sd_ndisc_router *rt) {
struct nd_router_advert *a;
const uint8_t *p;
bool has_mtu = false, has_flag_extension = false;
size_t left;
assert(rt);
if (rt->raw_size < sizeof(struct nd_router_advert))
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Too small to be a router advertisement, ignoring.");
/* Router advertisement packets are neatly aligned to 64-bit boundaries, hence we can access them directly */
a = NDISC_ROUTER_RAW(rt);
if (a->nd_ra_type != ND_ROUTER_ADVERT)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Received ND packet that is not a router advertisement, ignoring.");
if (a->nd_ra_code != 0)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Received ND packet with wrong RA code, ignoring.");
rt->hop_limit = a->nd_ra_curhoplimit;
rt->flags = a->nd_ra_flags_reserved; /* the first 8 bits */
rt->lifetime = be16toh(a->nd_ra_router_lifetime);
rt->preference = (rt->flags >> 3) & 3;
if (!IN_SET(rt->preference, SD_NDISC_PREFERENCE_LOW, SD_NDISC_PREFERENCE_HIGH))
rt->preference = SD_NDISC_PREFERENCE_MEDIUM;
p = (const uint8_t*) NDISC_ROUTER_RAW(rt) + sizeof(struct nd_router_advert);
left = rt->raw_size - sizeof(struct nd_router_advert);
for (;;) {
uint8_t type;
size_t length;
if (left == 0)
break;
if (left < 2)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Option lacks header, ignoring datagram.");
type = p[0];
length = p[1] * 8;
if (length == 0)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Zero-length option, ignoring datagram.");
if (left < length)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Option truncated, ignoring datagram.");
switch (type) {
case SD_NDISC_OPTION_PREFIX_INFORMATION:
if (length != 4*8)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Prefix option of invalid size, ignoring datagram.");
if (p[2] > 128)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Bad prefix length, ignoring datagram.");
break;
case SD_NDISC_OPTION_MTU: {
uint32_t m;
if (has_mtu) {
log_ndisc(nd, "MTU option specified twice, ignoring.");
break;
}
if (length != 8)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"MTU option of invalid size, ignoring datagram.");
m = be32toh(*(uint32_t*) (p + 4));
if (m >= IPV6_MIN_MTU) /* ignore invalidly small MTUs */
rt->mtu = m;
has_mtu = true;
break;
}
case SD_NDISC_OPTION_ROUTE_INFORMATION:
if (length < 1*8 || length > 3*8)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Route information option of invalid size, ignoring datagram.");
if (p[2] > 128)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Bad route prefix length, ignoring datagram.");
break;
case SD_NDISC_OPTION_RDNSS:
if (length < 3*8 || (length % (2*8)) != 1*8)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG), "RDNSS option has invalid size.");
break;
case SD_NDISC_OPTION_FLAGS_EXTENSION:
if (has_flag_extension) {
log_ndisc(nd, "Flags extension option specified twice, ignoring.");
break;
}
if (length < 1*8)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Flags extension option has invalid size.");
/* Add in the additional flags bits */
rt->flags |=
((uint64_t) p[2] << 8) |
((uint64_t) p[3] << 16) |
((uint64_t) p[4] << 24) |
((uint64_t) p[5] << 32) |
((uint64_t) p[6] << 40) |
((uint64_t) p[7] << 48);
has_flag_extension = true;
break;
case SD_NDISC_OPTION_DNSSL:
if (length < 2*8)
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"DNSSL option has invalid size.");
break;
}
p += length, left -= length;
}
rt->rindex = sizeof(struct nd_router_advert);
return 0;
}
int sd_ndisc_router_get_hop_limit(sd_ndisc_router *rt, uint8_t *ret) {
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
*ret = rt->hop_limit;
return 0;
}
int sd_ndisc_router_get_flags(sd_ndisc_router *rt, uint64_t *ret_flags) {
assert_return(rt, -EINVAL);
assert_return(ret_flags, -EINVAL);
*ret_flags = rt->flags;
return 0;
}
int sd_ndisc_router_get_lifetime(sd_ndisc_router *rt, uint16_t *ret_lifetime) {
assert_return(rt, -EINVAL);
assert_return(ret_lifetime, -EINVAL);
*ret_lifetime = rt->lifetime;
return 0;
}
int sd_ndisc_router_get_preference(sd_ndisc_router *rt, unsigned *ret) {
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
*ret = rt->preference;
return 0;
}
int sd_ndisc_router_get_mtu(sd_ndisc_router *rt, uint32_t *ret) {
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
if (rt->mtu <= 0)
return -ENODATA;
*ret = rt->mtu;
return 0;
}
int sd_ndisc_router_option_rewind(sd_ndisc_router *rt) {
assert_return(rt, -EINVAL);
assert(rt->raw_size >= sizeof(struct nd_router_advert));
rt->rindex = sizeof(struct nd_router_advert);
return rt->rindex < rt->raw_size;
}
int sd_ndisc_router_option_next(sd_ndisc_router *rt) {
size_t length;
assert_return(rt, -EINVAL);
if (rt->rindex == rt->raw_size) /* EOF */
return -ESPIPE;
if (rt->rindex + 2 > rt->raw_size) /* Truncated message */
return -EBADMSG;
length = NDISC_ROUTER_OPTION_LENGTH(rt);
if (rt->rindex + length > rt->raw_size)
return -EBADMSG;
rt->rindex += length;
return rt->rindex < rt->raw_size;
}
int sd_ndisc_router_option_get_type(sd_ndisc_router *rt, uint8_t *ret) {
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
if (rt->rindex == rt->raw_size) /* EOF */
return -ESPIPE;
if (rt->rindex + 2 > rt->raw_size) /* Truncated message */
return -EBADMSG;
*ret = NDISC_ROUTER_OPTION_TYPE(rt);
return 0;
}
int sd_ndisc_router_option_is_type(sd_ndisc_router *rt, uint8_t type) {
uint8_t k;
int r;
assert_return(rt, -EINVAL);
r = sd_ndisc_router_option_get_type(rt, &k);
if (r < 0)
return r;
return type == k;
}
int sd_ndisc_router_option_get_raw(sd_ndisc_router *rt, const void **ret, size_t *size) {
size_t length;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(size, -EINVAL);
/* Note that this returns the full option, including the option header */
if (rt->rindex + 2 > rt->raw_size)
return -EBADMSG;
length = NDISC_ROUTER_OPTION_LENGTH(rt);
if (rt->rindex + length > rt->raw_size)
return -EBADMSG;
*ret = (uint8_t*) NDISC_ROUTER_RAW(rt) + rt->rindex;
*size = length;
return 0;
}
static int get_prefix_info(sd_ndisc_router *rt, struct nd_opt_prefix_info **ret) {
struct nd_opt_prefix_info *ri;
size_t length;
int r;
assert(rt);
assert(ret);
r = sd_ndisc_router_option_is_type(rt, SD_NDISC_OPTION_PREFIX_INFORMATION);
if (r < 0)
return r;
if (r == 0)
return -EMEDIUMTYPE;
length = NDISC_ROUTER_OPTION_LENGTH(rt);
if (length != sizeof(struct nd_opt_prefix_info))
return -EBADMSG;
ri = (struct nd_opt_prefix_info*) ((uint8_t*) NDISC_ROUTER_RAW(rt) + rt->rindex);
if (ri->nd_opt_pi_prefix_len > 128)
return -EBADMSG;
*ret = ri;
return 0;
}
int sd_ndisc_router_prefix_get_valid_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
struct nd_opt_prefix_info *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_prefix_info(rt, &ri);
if (r < 0)
return r;
*ret = be32toh(ri->nd_opt_pi_valid_time);
return 0;
}
int sd_ndisc_router_prefix_get_preferred_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
struct nd_opt_prefix_info *pi;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_prefix_info(rt, &pi);
if (r < 0)
return r;
*ret = be32toh(pi->nd_opt_pi_preferred_time);
return 0;
}
int sd_ndisc_router_prefix_get_flags(sd_ndisc_router *rt, uint8_t *ret) {
struct nd_opt_prefix_info *pi;
uint8_t flags;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_prefix_info(rt, &pi);
if (r < 0)
return r;
flags = pi->nd_opt_pi_flags_reserved;
if ((flags & ND_OPT_PI_FLAG_AUTO) && (pi->nd_opt_pi_prefix_len != 64)) {
log_ndisc(NULL, "Invalid prefix length, ignoring prefix for stateless autoconfiguration.");
flags &= ~ND_OPT_PI_FLAG_AUTO;
}
*ret = flags;
return 0;
}
int sd_ndisc_router_prefix_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
struct nd_opt_prefix_info *pi;
int r;
assert_return(rt, -EINVAL);
assert_return(ret_addr, -EINVAL);
r = get_prefix_info(rt, &pi);
if (r < 0)
return r;
*ret_addr = pi->nd_opt_pi_prefix;
return 0;
}
int sd_ndisc_router_prefix_get_prefixlen(sd_ndisc_router *rt, unsigned *ret) {
struct nd_opt_prefix_info *pi;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_prefix_info(rt, &pi);
if (r < 0)
return r;
if (pi->nd_opt_pi_prefix_len > 128)
return -EBADMSG;
*ret = pi->nd_opt_pi_prefix_len;
return 0;
}
static int get_route_info(sd_ndisc_router *rt, uint8_t **ret) {
uint8_t *ri;
size_t length;
int r;
assert(rt);
assert(ret);
r = sd_ndisc_router_option_is_type(rt, SD_NDISC_OPTION_ROUTE_INFORMATION);
if (r < 0)
return r;
if (r == 0)
return -EMEDIUMTYPE;
length = NDISC_ROUTER_OPTION_LENGTH(rt);
if (length < 1*8 || length > 3*8)
return -EBADMSG;
ri = (uint8_t*) NDISC_ROUTER_RAW(rt) + rt->rindex;
if (ri[2] > 128)
return -EBADMSG;
*ret = ri;
return 0;
}
int sd_ndisc_router_route_get_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_route_info(rt, &ri);
if (r < 0)
return r;
*ret = be32toh(*(uint32_t*) (ri + 4));
return 0;
}
int sd_ndisc_router_route_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret_addr, -EINVAL);
r = get_route_info(rt, &ri);
if (r < 0)
return r;
zero(*ret_addr);
memcpy(ret_addr, ri + 8, NDISC_ROUTER_OPTION_LENGTH(rt) - 8);
return 0;
}
int sd_ndisc_router_route_get_prefixlen(sd_ndisc_router *rt, unsigned *ret) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_route_info(rt, &ri);
if (r < 0)
return r;
*ret = ri[2];
return 0;
}
int sd_ndisc_router_route_get_preference(sd_ndisc_router *rt, unsigned *ret) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_route_info(rt, &ri);
if (r < 0)
return r;
*ret = (ri[3] >> 3) & 3;
if (!IN_SET(*ret, SD_NDISC_PREFERENCE_LOW, SD_NDISC_PREFERENCE_HIGH))
*ret = SD_NDISC_PREFERENCE_MEDIUM;
return 0;
}
static int get_rdnss_info(sd_ndisc_router *rt, uint8_t **ret) {
size_t length;
int r;
assert(rt);
assert(ret);
r = sd_ndisc_router_option_is_type(rt, SD_NDISC_OPTION_RDNSS);
if (r < 0)
return r;
if (r == 0)
return -EMEDIUMTYPE;
length = NDISC_ROUTER_OPTION_LENGTH(rt);
if (length < 3*8 || (length % (2*8)) != 1*8)
return -EBADMSG;
*ret = (uint8_t*) NDISC_ROUTER_RAW(rt) + rt->rindex;
return 0;
}
int sd_ndisc_router_rdnss_get_addresses(sd_ndisc_router *rt, const struct in6_addr **ret) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_rdnss_info(rt, &ri);
if (r < 0)
return r;
*ret = (const struct in6_addr*) (ri + 8);
return (NDISC_ROUTER_OPTION_LENGTH(rt) - 8) / 16;
}
int sd_ndisc_router_rdnss_get_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_rdnss_info(rt, &ri);
if (r < 0)
return r;
*ret = be32toh(*(uint32_t*) (ri + 4));
return 0;
}
static int get_dnssl_info(sd_ndisc_router *rt, uint8_t **ret) {
size_t length;
int r;
assert(rt);
assert(ret);
r = sd_ndisc_router_option_is_type(rt, SD_NDISC_OPTION_DNSSL);
if (r < 0)
return r;
if (r == 0)
return -EMEDIUMTYPE;
length = NDISC_ROUTER_OPTION_LENGTH(rt);
if (length < 2*8)
return -EBADMSG;
*ret = (uint8_t*) NDISC_ROUTER_RAW(rt) + rt->rindex;
return 0;
}
int sd_ndisc_router_dnssl_get_domains(sd_ndisc_router *rt, char ***ret) {
_cleanup_strv_free_ char **l = NULL;
_cleanup_free_ char *e = NULL;
size_t n = 0, left;
uint8_t *ri, *p;
bool first = true;
int r;
unsigned k = 0;
assert_return(rt, -EINVAL);
assert_return(ret, -EINVAL);
r = get_dnssl_info(rt, &ri);
if (r < 0)
return r;
p = ri + 8;
left = NDISC_ROUTER_OPTION_LENGTH(rt) - 8;
for (;;) {
if (left == 0) {
if (n > 0) /* Not properly NUL terminated */
return -EBADMSG;
break;
}
if (*p == 0) {
/* Found NUL termination */
if (n > 0) {
_cleanup_free_ char *normalized = NULL;
e[n] = 0;
r = dns_name_normalize(e, 0, &normalized);
if (r < 0)
return r;
/* Ignore the root domain name or "localhost" and friends */
if (!is_localhost(normalized) &&
!dns_name_is_root(normalized)) {
if (strv_push(&l, normalized) < 0)
return -ENOMEM;
normalized = NULL;
k++;
}
}
n = 0;
first = true;
p++, left--;
continue;
}
/* Check for compression (which is not allowed) */
if (*p > 63)
return -EBADMSG;
if (1U + *p + 1U > left)
return -EBADMSG;
if (!GREEDY_REALLOC(e, n + !first + DNS_LABEL_ESCAPED_MAX + 1U))
return -ENOMEM;
if (first)
first = false;
else
e[n++] = '.';
r = dns_label_escape((char*) p+1, *p, e + n, DNS_LABEL_ESCAPED_MAX);
if (r < 0)
return r;
n += r;
left -= 1 + *p;
p += 1 + *p;
}
if (strv_isempty(l)) {
*ret = NULL;
return 0;
}
*ret = TAKE_PTR(l);
return k;
}
int sd_ndisc_router_dnssl_get_lifetime(sd_ndisc_router *rt, uint32_t *ret_sec) {
uint8_t *ri;
int r;
assert_return(rt, -EINVAL);
assert_return(ret_sec, -EINVAL);
r = get_dnssl_info(rt, &ri);
if (r < 0)
return r;
*ret_sec = be32toh(*(uint32_t*) (ri + 4));
return 0;
}
int sd_ndisc_router_captive_portal_get_uri(sd_ndisc_router *rt, const char **ret_uri, size_t *ret_size) {
int r;
const char *nd_opt_captive_portal;
size_t length;
assert_return(rt, -EINVAL);
assert_return(ret_uri, -EINVAL);
r = sd_ndisc_router_option_is_type(rt, SD_NDISC_OPTION_CAPTIVE_PORTAL);
if (r < 0)
return r;
if (r == 0)
return -EMEDIUMTYPE;
r = sd_ndisc_router_option_get_raw(rt, (void *)&nd_opt_captive_portal, &length);
if (r < 0)
return r;
/* The length field has units of 8 octets */
assert(length % 8 == 0);
if (length == 0)
return -EBADMSG;
/* Check that the message is not truncated by an embedded NUL.
* NUL padding to a multiple of 8 is expected. */
size_t size = strnlen(nd_opt_captive_portal + 2, length - 2);
if (DIV_ROUND_UP(size + 2, 8) != length / 8)
return -EBADMSG;
/* Let's not return an empty buffer */
if (size == 0) {
*ret_uri = NULL;
*ret_size = 0;
return 0;
}
*ret_uri = nd_opt_captive_portal + 2;
*ret_size = size;
return 0;
}
| 22,209 | 28.223684 | 119 |
c
|
null |
systemd-main/src/libsystemd-network/ndisc-router.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include "sd-ndisc.h"
#include "time-util.h"
struct sd_ndisc_router {
unsigned n_ref;
triple_timestamp timestamp;
struct in6_addr address;
/* The raw packet size. The data is appended to the object, accessible via NDIS_ROUTER_RAW() */
size_t raw_size;
/* The current read index for the iterative option interface */
size_t rindex;
uint64_t flags;
unsigned preference;
uint16_t lifetime;
uint8_t hop_limit;
uint32_t mtu;
};
static inline void* NDISC_ROUTER_RAW(const sd_ndisc_router *rt) {
return (uint8_t*) rt + ALIGN(sizeof(sd_ndisc_router));
}
static inline void *NDISC_ROUTER_OPTION_DATA(const sd_ndisc_router *rt) {
return ((uint8_t*) NDISC_ROUTER_RAW(rt)) + rt->rindex;
}
static inline uint8_t NDISC_ROUTER_OPTION_TYPE(const sd_ndisc_router *rt) {
return ((uint8_t*) NDISC_ROUTER_OPTION_DATA(rt))[0];
}
static inline size_t NDISC_ROUTER_OPTION_LENGTH(const sd_ndisc_router *rt) {
return ((uint8_t*) NDISC_ROUTER_OPTION_DATA(rt))[1] * 8;
}
sd_ndisc_router *ndisc_router_new(size_t raw_size);
int ndisc_router_parse(sd_ndisc *nd, sd_ndisc_router *rt);
| 1,327 | 26.102041 | 103 |
h
|
null |
systemd-main/src/libsystemd-network/network-common.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "log-link.h"
#define log_interface_prefix_full_errno_zerook(prefix, type, val, error, fmt, ...) \
({ \
int _e = (error); \
if (DEBUG_LOGGING) { \
const char *_n = NULL; \
type *_v = (val); \
\
if (_v) \
(void) type##_get_ifname(_v, &_n); \
log_interface_full_errno_zerook( \
_n, LOG_DEBUG, _e, prefix fmt, \
##__VA_ARGS__); \
} \
-ERRNO_VALUE(_e); \
})
#define log_interface_prefix_full_errno(prefix, type, val, error, fmt, ...) \
({ \
int _error = (error); \
ASSERT_NON_ZERO(_error); \
log_interface_prefix_full_errno_zerook( \
prefix, type, val, _error, fmt, ##__VA_ARGS__); \
})
int get_ifname(int ifindex, char **ifname);
| 1,649 | 52.225806 | 84 |
h
|
null |
systemd-main/src/libsystemd-network/network-internal.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <arpa/inet.h>
#include <linux/if.h>
#include <netinet/ether.h>
#include "sd-ndisc.h"
#include "alloc-util.h"
#include "dhcp-lease-internal.h"
#include "extract-word.h"
#include "hexdecoct.h"
#include "log.h"
#include "network-internal.h"
#include "parse-util.h"
size_t serialize_in_addrs(FILE *f,
const struct in_addr *addresses,
size_t size,
bool *with_leading_space,
bool (*predicate)(const struct in_addr *addr)) {
assert(f);
assert(addresses);
size_t count = 0;
bool _space = false;
if (!with_leading_space)
with_leading_space = &_space;
for (size_t i = 0; i < size; i++) {
if (predicate && !predicate(&addresses[i]))
continue;
if (*with_leading_space)
fputc(' ', f);
fputs(IN4_ADDR_TO_STRING(&addresses[i]), f);
count++;
*with_leading_space = true;
}
return count;
}
int deserialize_in_addrs(struct in_addr **ret, const char *string) {
_cleanup_free_ struct in_addr *addresses = NULL;
int size = 0;
assert(ret);
assert(string);
for (;;) {
_cleanup_free_ char *word = NULL;
struct in_addr *new_addresses;
int r;
r = extract_first_word(&string, &word, NULL, 0);
if (r < 0)
return r;
if (r == 0)
break;
new_addresses = reallocarray(addresses, size + 1, sizeof(struct in_addr));
if (!new_addresses)
return -ENOMEM;
else
addresses = new_addresses;
r = inet_pton(AF_INET, word, &(addresses[size]));
if (r <= 0)
continue;
size++;
}
*ret = size > 0 ? TAKE_PTR(addresses) : NULL;
return size;
}
void serialize_in6_addrs(FILE *f, const struct in6_addr *addresses, size_t size, bool *with_leading_space) {
assert(f);
assert(addresses);
assert(size);
bool _space = false;
if (!with_leading_space)
with_leading_space = &_space;
for (size_t i = 0; i < size; i++) {
if (*with_leading_space)
fputc(' ', f);
fputs(IN6_ADDR_TO_STRING(&addresses[i]), f);
*with_leading_space = true;
}
}
int deserialize_in6_addrs(struct in6_addr **ret, const char *string) {
_cleanup_free_ struct in6_addr *addresses = NULL;
int size = 0;
assert(ret);
assert(string);
for (;;) {
_cleanup_free_ char *word = NULL;
struct in6_addr *new_addresses;
int r;
r = extract_first_word(&string, &word, NULL, 0);
if (r < 0)
return r;
if (r == 0)
break;
new_addresses = reallocarray(addresses, size + 1, sizeof(struct in6_addr));
if (!new_addresses)
return -ENOMEM;
else
addresses = new_addresses;
r = inet_pton(AF_INET6, word, &(addresses[size]));
if (r <= 0)
continue;
size++;
}
*ret = TAKE_PTR(addresses);
return size;
}
void serialize_dhcp_routes(FILE *f, const char *key, sd_dhcp_route **routes, size_t size) {
assert(f);
assert(key);
assert(routes);
assert(size);
fprintf(f, "%s=", key);
for (size_t i = 0; i < size; i++) {
struct in_addr dest, gw;
uint8_t length;
assert_se(sd_dhcp_route_get_destination(routes[i], &dest) >= 0);
assert_se(sd_dhcp_route_get_gateway(routes[i], &gw) >= 0);
assert_se(sd_dhcp_route_get_destination_prefix_length(routes[i], &length) >= 0);
fprintf(f, "%s,%s%s",
IN4_ADDR_PREFIX_TO_STRING(&dest, length),
IN4_ADDR_TO_STRING(&gw),
i < size - 1 ? " ": "");
}
fputs("\n", f);
}
int deserialize_dhcp_routes(struct sd_dhcp_route **ret, size_t *ret_size, const char *string) {
_cleanup_free_ struct sd_dhcp_route *routes = NULL;
size_t size = 0;
assert(ret);
assert(ret_size);
assert(string);
/* WORD FORMAT: dst_ip/dst_prefixlen,gw_ip */
for (;;) {
_cleanup_free_ char *word = NULL;
char *tok, *tok_end;
unsigned n;
int r;
r = extract_first_word(&string, &word, NULL, 0);
if (r < 0)
return r;
if (r == 0)
break;
if (!GREEDY_REALLOC(routes, size + 1))
return -ENOMEM;
tok = word;
/* get the subnet */
tok_end = strchr(tok, '/');
if (!tok_end)
continue;
*tok_end = '\0';
r = inet_aton(tok, &routes[size].dst_addr);
if (r == 0)
continue;
tok = tok_end + 1;
/* get the prefixlen */
tok_end = strchr(tok, ',');
if (!tok_end)
continue;
*tok_end = '\0';
r = safe_atou(tok, &n);
if (r < 0 || n > 32)
continue;
routes[size].dst_prefixlen = (uint8_t) n;
tok = tok_end + 1;
/* get the gateway */
r = inet_aton(tok, &routes[size].gw_addr);
if (r == 0)
continue;
size++;
}
*ret_size = size;
*ret = TAKE_PTR(routes);
return 0;
}
int serialize_dhcp_option(FILE *f, const char *key, const void *data, size_t size) {
_cleanup_free_ char *hex_buf = NULL;
assert(f);
assert(key);
assert(data);
hex_buf = hexmem(data, size);
if (!hex_buf)
return -ENOMEM;
fprintf(f, "%s=%s\n", key, hex_buf);
return 0;
}
| 6,634 | 26.761506 | 108 |
c
|
null |
systemd-main/src/libsystemd-network/network-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include <stdio.h>
#include "sd-dhcp-lease.h"
size_t serialize_in_addrs(FILE *f,
const struct in_addr *addresses,
size_t size,
bool *with_leading_space,
bool (*predicate)(const struct in_addr *addr));
int deserialize_in_addrs(struct in_addr **addresses, const char *string);
void serialize_in6_addrs(FILE *f, const struct in6_addr *addresses,
size_t size,
bool *with_leading_space);
int deserialize_in6_addrs(struct in6_addr **addresses, const char *string);
/* don't include "dhcp-lease-internal.h" as it causes conflicts between netinet/ip.h and linux/ip.h */
struct sd_dhcp_route;
struct sd_dhcp_lease;
void serialize_dhcp_routes(FILE *f, const char *key, struct sd_dhcp_route **routes, size_t size);
int deserialize_dhcp_routes(struct sd_dhcp_route **ret, size_t *ret_size, const char *string);
/* It is not necessary to add deserialize_dhcp_option(). Use unhexmem() instead. */
int serialize_dhcp_option(FILE *f, const char *key, const void *data, size_t size);
int dhcp_lease_save(sd_dhcp_lease *lease, const char *lease_file);
int dhcp_lease_load(sd_dhcp_lease **ret, const char *lease_file);
| 1,344 | 41.03125 | 102 |
h
|
null |
systemd-main/src/libsystemd-network/radv-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2017 Intel Corporation. All rights reserved.
***/
#include "sd-radv.h"
#include "list.h"
#include "network-common.h"
#include "sparse-endian.h"
#include "time-util.h"
/* RFC 4861 section 6.2.1.
* MaxRtrAdvInterval
* The maximum time allowed between sending unsolicited multicast Router Advertisements from the
* interface, in seconds. MUST be no less than 4 seconds and no greater than 1800 seconds.
* Default: 600 seconds */
#define RADV_MIN_MAX_TIMEOUT_USEC (4 * USEC_PER_SEC)
#define RADV_MAX_MAX_TIMEOUT_USEC (1800 * USEC_PER_SEC)
#define RADV_DEFAULT_MAX_TIMEOUT_USEC (600 * USEC_PER_SEC)
/* RFC 4861 section 6.2.1.
* MinRtrAdvInterval
* The minimum time allowed between sending unsolicited multicast Router Advertisements from the
* interface, in seconds. MUST be no less than 3 seconds and no greater than .75 * MaxRtrAdvInterval.
* Default: 0.33 * MaxRtrAdvInterval If MaxRtrAdvInterval >= 9 seconds; otherwise, the Default is
* MaxRtrAdvInterval (Note, this should be a typo. We use 0.75 * MaxRtrAdvInterval). */
#define RADV_MIN_MIN_TIMEOUT_USEC (3 * USEC_PER_SEC)
/* RFC 4861 section 6.2.4.
* AdvDefaultLifetime
* The value to be placed in the Router Lifetime field of Router Advertisements sent from the interface,
* in seconds. MUST be either zero or between MaxRtrAdvInterval and 9000 seconds. A value of zero
* indicates that the router is not to be used as a default router. These limits may be overridden by
* specific documents that describe how IPv6 operates over different link layers. For instance, in a
* point-to-point link the peers may have enough information about the number and status of devices at
* the other end so that advertisements are needed less frequently.
* Default: 3 * MaxRtrAdvInterval */
#define RADV_MIN_ROUTER_LIFETIME_USEC RADV_MIN_MAX_TIMEOUT_USEC
#define RADV_MAX_ROUTER_LIFETIME_USEC (9000 * USEC_PER_SEC)
#define RADV_DEFAULT_ROUTER_LIFETIME_USEC (3 * RADV_DEFAULT_MAX_TIMEOUT_USEC)
/* draft-ietf-6man-slaac-renum-02 section 4.1.1.
* AdvPreferredLifetime: max(AdvDefaultLifetime, 3 * MaxRtrAdvInterval)
* AdvValidLifetime: 2 * AdvPreferredLifetime */
#define RADV_DEFAULT_PREFERRED_LIFETIME_USEC CONST_MAX(RADV_DEFAULT_ROUTER_LIFETIME_USEC, 3 * RADV_DEFAULT_MAX_TIMEOUT_USEC)
#define RADV_DEFAULT_VALID_LIFETIME_USEC (2 * RADV_DEFAULT_PREFERRED_LIFETIME_USEC)
/* RFC 4861 section 10.
* MAX_INITIAL_RTR_ADVERT_INTERVAL 16 seconds
* MAX_INITIAL_RTR_ADVERTISEMENTS 3 transmissions
* MAX_FINAL_RTR_ADVERTISEMENTS 3 transmissions
* MIN_DELAY_BETWEEN_RAS 3 seconds
* MAX_RA_DELAY_TIME .5 seconds */
#define RADV_MAX_INITIAL_RTR_ADVERT_INTERVAL_USEC (16 * USEC_PER_SEC)
#define RADV_MAX_INITIAL_RTR_ADVERTISEMENTS 3
#define RADV_MAX_FINAL_RTR_ADVERTISEMENTS 3
#define RADV_MIN_DELAY_BETWEEN_RAS 3
#define RADV_MAX_RA_DELAY_TIME_USEC (500 * USEC_PER_MSEC)
#define RADV_OPT_ROUTE_INFORMATION 24
#define RADV_OPT_RDNSS 25
#define RADV_OPT_DNSSL 31
enum RAdvState {
RADV_STATE_IDLE = 0,
RADV_STATE_ADVERTISING = 1,
};
typedef enum RAdvState RAdvState;
struct sd_radv_opt_dns {
uint8_t type;
uint8_t length;
uint16_t reserved;
be32_t lifetime;
} _packed_;
struct sd_radv {
unsigned n_ref;
RAdvState state;
int ifindex;
char *ifname;
sd_event *event;
int event_priority;
struct ether_addr mac_addr;
uint8_t hop_limit;
uint8_t flags;
uint32_t mtu;
usec_t lifetime_usec; /* timespan */
int fd;
unsigned ra_sent;
sd_event_source *recv_event_source;
sd_event_source *timeout_event_source;
unsigned n_prefixes;
LIST_HEAD(sd_radv_prefix, prefixes);
unsigned n_route_prefixes;
LIST_HEAD(sd_radv_route_prefix, route_prefixes);
size_t n_rdnss;
struct sd_radv_opt_dns *rdnss;
struct sd_radv_opt_dns *dnssl;
};
#define radv_prefix_opt__contents { \
uint8_t type; \
uint8_t length; \
uint8_t prefixlen; \
uint8_t flags; \
be32_t lifetime_valid; \
be32_t lifetime_preferred; \
uint32_t reserved; \
struct in6_addr in6_addr; \
}
struct radv_prefix_opt radv_prefix_opt__contents;
/* We need the opt substructure to be packed, because we use it in send(). But
* if we use _packed_, this means that the structure cannot be used directly in
* normal code in general, because the fields might not be properly aligned.
* But in this particular case, the structure is defined in a way that gives
* proper alignment, even without the explicit _packed_ attribute. To appease
* the compiler we use the "unpacked" structure, but we also verify that
* structure contains no holes, so offsets are the same when _packed_ is used.
*/
struct radv_prefix_opt__packed radv_prefix_opt__contents _packed_;
assert_cc(sizeof(struct radv_prefix_opt) == sizeof(struct radv_prefix_opt__packed));
struct sd_radv_prefix {
unsigned n_ref;
struct radv_prefix_opt opt;
LIST_FIELDS(struct sd_radv_prefix, prefix);
/* These are timespans, NOT points in time. */
usec_t lifetime_valid_usec;
usec_t lifetime_preferred_usec;
/* These are points in time specified with clock_boottime_or_monotonic(), NOT timespans. */
usec_t valid_until;
usec_t preferred_until;
};
#define radv_route_prefix_opt__contents { \
uint8_t type; \
uint8_t length; \
uint8_t prefixlen; \
uint8_t flags_reserved; \
be32_t lifetime; \
struct in6_addr in6_addr; \
}
struct radv_route_prefix_opt radv_route_prefix_opt__contents;
struct radv_route_prefix_opt__packed radv_route_prefix_opt__contents _packed_;
assert_cc(sizeof(struct radv_route_prefix_opt) == sizeof(struct radv_route_prefix_opt__packed));
struct sd_radv_route_prefix {
unsigned n_ref;
struct radv_route_prefix_opt opt;
LIST_FIELDS(struct sd_radv_route_prefix, prefix);
/* This is a timespan, NOT a point in time. */
usec_t lifetime_usec;
/* This is a point in time specified with clock_boottime_or_monotonic(), NOT a timespan. */
usec_t valid_until;
};
#define log_radv_errno(radv, error, fmt, ...) \
log_interface_prefix_full_errno( \
"RADV: ", \
sd_radv, radv, \
error, fmt, ##__VA_ARGS__)
#define log_radv(radv, fmt, ...) \
log_interface_prefix_full_errno_zerook( \
"RADV: ", \
sd_radv, radv, \
0, fmt, ##__VA_ARGS__)
| 7,421 | 39.336957 | 129 |
h
|
null |
systemd-main/src/libsystemd-network/sd-ipv4acd.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Axis Communications AB. All rights reserved.
***/
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/if_ether.h>
#include <stdio.h>
#include <stdlib.h>
#include "sd-ipv4acd.h"
#include "alloc-util.h"
#include "arp-util.h"
#include "ether-addr-util.h"
#include "event-util.h"
#include "fd-util.h"
#include "in-addr-util.h"
#include "memory-util.h"
#include "network-common.h"
#include "random-util.h"
#include "siphash24.h"
#include "string-table.h"
#include "string-util.h"
#include "time-util.h"
/* Constants from the RFC */
#define PROBE_WAIT_USEC (1U * USEC_PER_SEC)
#define PROBE_NUM 3U
#define PROBE_MIN_USEC (1U * USEC_PER_SEC)
#define PROBE_MAX_USEC (2U * USEC_PER_SEC)
#define ANNOUNCE_WAIT_USEC (2U * USEC_PER_SEC)
#define ANNOUNCE_NUM 2U
#define ANNOUNCE_INTERVAL_USEC (2U * USEC_PER_SEC)
#define MAX_CONFLICTS 10U
#define RATE_LIMIT_INTERVAL_USEC (60U * USEC_PER_SEC)
#define DEFEND_INTERVAL_USEC (10U * USEC_PER_SEC)
typedef enum IPv4ACDState {
IPV4ACD_STATE_INIT,
IPV4ACD_STATE_STARTED,
IPV4ACD_STATE_WAITING_PROBE,
IPV4ACD_STATE_PROBING,
IPV4ACD_STATE_WAITING_ANNOUNCE,
IPV4ACD_STATE_ANNOUNCING,
IPV4ACD_STATE_RUNNING,
_IPV4ACD_STATE_MAX,
_IPV4ACD_STATE_INVALID = -EINVAL,
} IPv4ACDState;
struct sd_ipv4acd {
unsigned n_ref;
IPv4ACDState state;
int ifindex;
int fd;
char *ifname;
unsigned n_iteration;
unsigned n_conflict;
sd_event_source *receive_message_event_source;
sd_event_source *timer_event_source;
usec_t defend_window;
struct in_addr address;
/* External */
struct ether_addr mac_addr;
sd_event *event;
int event_priority;
sd_ipv4acd_callback_t callback;
void *userdata;
sd_ipv4acd_check_mac_callback_t check_mac_callback;
void *check_mac_userdata;
};
#define log_ipv4acd_errno(acd, error, fmt, ...) \
log_interface_prefix_full_errno( \
"IPv4ACD: ", \
sd_ipv4acd, acd, \
error, fmt, ##__VA_ARGS__)
#define log_ipv4acd(acd, fmt, ...) \
log_interface_prefix_full_errno_zerook( \
"IPv4ACD: ", \
sd_ipv4acd, acd, \
0, fmt, ##__VA_ARGS__)
static const char * const ipv4acd_state_table[_IPV4ACD_STATE_MAX] = {
[IPV4ACD_STATE_INIT] = "init",
[IPV4ACD_STATE_STARTED] = "started",
[IPV4ACD_STATE_WAITING_PROBE] = "waiting-probe",
[IPV4ACD_STATE_PROBING] = "probing",
[IPV4ACD_STATE_WAITING_ANNOUNCE] = "waiting-announce",
[IPV4ACD_STATE_ANNOUNCING] = "announcing",
[IPV4ACD_STATE_RUNNING] = "running",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(ipv4acd_state, IPv4ACDState);
static void ipv4acd_set_state(sd_ipv4acd *acd, IPv4ACDState st, bool reset_counter) {
assert(acd);
assert(st < _IPV4ACD_STATE_MAX);
if (st != acd->state)
log_ipv4acd(acd, "%s -> %s", ipv4acd_state_to_string(acd->state), ipv4acd_state_to_string(st));
if (st == acd->state && !reset_counter)
acd->n_iteration++;
else {
acd->state = st;
acd->n_iteration = 0;
}
}
static void ipv4acd_reset(sd_ipv4acd *acd) {
assert(acd);
(void) event_source_disable(acd->timer_event_source);
acd->receive_message_event_source = sd_event_source_disable_unref(acd->receive_message_event_source);
acd->fd = safe_close(acd->fd);
ipv4acd_set_state(acd, IPV4ACD_STATE_INIT, true);
}
static sd_ipv4acd *ipv4acd_free(sd_ipv4acd *acd) {
assert(acd);
ipv4acd_reset(acd);
sd_event_source_unref(acd->timer_event_source);
sd_ipv4acd_detach_event(acd);
free(acd->ifname);
return mfree(acd);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_ipv4acd, sd_ipv4acd, ipv4acd_free);
int sd_ipv4acd_new(sd_ipv4acd **ret) {
_cleanup_(sd_ipv4acd_unrefp) sd_ipv4acd *acd = NULL;
assert_return(ret, -EINVAL);
acd = new(sd_ipv4acd, 1);
if (!acd)
return -ENOMEM;
*acd = (sd_ipv4acd) {
.n_ref = 1,
.state = IPV4ACD_STATE_INIT,
.ifindex = -1,
.fd = -EBADF,
};
*ret = TAKE_PTR(acd);
return 0;
}
static void ipv4acd_client_notify(sd_ipv4acd *acd, int event) {
assert(acd);
if (!acd->callback)
return;
acd->callback(acd, event, acd->userdata);
}
int sd_ipv4acd_stop(sd_ipv4acd *acd) {
IPv4ACDState old_state;
if (!acd)
return 0;
old_state = acd->state;
ipv4acd_reset(acd);
if (old_state == IPV4ACD_STATE_INIT)
return 0;
log_ipv4acd(acd, "STOPPED");
ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_STOP);
return 0;
}
static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata);
static int ipv4acd_set_next_wakeup(sd_ipv4acd *acd, usec_t usec, usec_t random_usec) {
usec_t next_timeout, time_now;
assert(acd);
next_timeout = usec;
if (random_usec > 0)
next_timeout += (usec_t) random_u64() % random_usec;
assert_se(sd_event_now(acd->event, CLOCK_BOOTTIME, &time_now) >= 0);
return event_reset_time(acd->event, &acd->timer_event_source,
CLOCK_BOOTTIME,
time_now + next_timeout, 0,
ipv4acd_on_timeout, acd,
acd->event_priority, "ipv4acd-timer", true);
}
static int ipv4acd_on_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
sd_ipv4acd *acd = ASSERT_PTR(userdata);
int r = 0;
switch (acd->state) {
case IPV4ACD_STATE_STARTED:
acd->defend_window = 0;
ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_PROBE, true);
if (acd->n_conflict >= MAX_CONFLICTS) {
log_ipv4acd(acd, "Max conflicts reached, delaying by %s",
FORMAT_TIMESPAN(RATE_LIMIT_INTERVAL_USEC, 0));
r = ipv4acd_set_next_wakeup(acd, RATE_LIMIT_INTERVAL_USEC, PROBE_WAIT_USEC);
} else
r = ipv4acd_set_next_wakeup(acd, 0, PROBE_WAIT_USEC);
if (r < 0)
goto fail;
break;
case IPV4ACD_STATE_WAITING_PROBE:
case IPV4ACD_STATE_PROBING:
/* Send a probe */
r = arp_send_probe(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
if (r < 0) {
log_ipv4acd_errno(acd, r, "Failed to send ARP probe: %m");
goto fail;
}
log_ipv4acd(acd, "Probing "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));
if (acd->n_iteration < PROBE_NUM - 2) {
ipv4acd_set_state(acd, IPV4ACD_STATE_PROBING, false);
r = ipv4acd_set_next_wakeup(acd, PROBE_MIN_USEC, (PROBE_MAX_USEC-PROBE_MIN_USEC));
if (r < 0)
goto fail;
} else {
ipv4acd_set_state(acd, IPV4ACD_STATE_WAITING_ANNOUNCE, true);
r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_WAIT_USEC, 0);
if (r < 0)
goto fail;
}
break;
case IPV4ACD_STATE_ANNOUNCING:
if (acd->n_iteration >= ANNOUNCE_NUM - 1) {
ipv4acd_set_state(acd, IPV4ACD_STATE_RUNNING, false);
break;
}
_fallthrough_;
case IPV4ACD_STATE_WAITING_ANNOUNCE:
/* Send announcement packet */
r = arp_send_announcement(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
if (r < 0) {
log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
goto fail;
}
log_ipv4acd(acd, "Announcing "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));
ipv4acd_set_state(acd, IPV4ACD_STATE_ANNOUNCING, false);
r = ipv4acd_set_next_wakeup(acd, ANNOUNCE_INTERVAL_USEC, 0);
if (r < 0)
goto fail;
if (acd->n_iteration == 0) {
acd->n_conflict = 0;
ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_BIND);
}
break;
default:
assert_not_reached();
}
return 0;
fail:
sd_ipv4acd_stop(acd);
return 0;
}
static bool ipv4acd_arp_conflict(sd_ipv4acd *acd, const struct ether_arp *arp, bool announced) {
assert(acd);
assert(arp);
/* RFC 5227 section 2.1.1.
* "the host receives any ARP packet (Request *or* Reply) on the interface where the probe is
* being performed, where the packet's 'sender IP address' is the address being probed for,
* then the host MUST treat this address as being in use by some other host" */
if (memcmp(arp->arp_spa, &acd->address, sizeof(struct in_addr)) == 0)
return true;
if (announced)
/* the TPA matched instead of SPA, this is not a conflict */
return false;
/* "any ARP Probe where the packet's 'target IP address' is the address being probed for, and
* the packet's 'sender hardware address' is not the hardware address of any of the host's
* interfaces, then the host SHOULD similarly treat this as an address conflict" */
if (arp->ea_hdr.ar_op != htobe16(ARPOP_REQUEST))
return false; /* not ARP Request, ignoring. */
if (memeqzero(arp->arp_spa, sizeof(struct in_addr)) == 0)
return false; /* not ARP Probe, ignoring. */
if (memcmp(arp->arp_tpa, &acd->address, sizeof(struct in_addr)) != 0)
return false; /* target IP address does not match, BPF code is broken? */
if (acd->check_mac_callback &&
acd->check_mac_callback(acd, (const struct ether_addr*) arp->arp_sha, acd->check_mac_userdata) > 0)
/* sender hardware is one of the host's interfaces, ignoring. */
return false;
return true; /* conflict! */
}
static void ipv4acd_on_conflict(sd_ipv4acd *acd) {
assert(acd);
acd->n_conflict++;
log_ipv4acd(acd, "Conflict on "IPV4_ADDRESS_FMT_STR" (%u)", IPV4_ADDRESS_FMT_VAL(acd->address), acd->n_conflict);
ipv4acd_reset(acd);
ipv4acd_client_notify(acd, SD_IPV4ACD_EVENT_CONFLICT);
}
static int ipv4acd_on_packet(
sd_event_source *s,
int fd,
uint32_t revents,
void *userdata) {
sd_ipv4acd *acd = ASSERT_PTR(userdata);
struct ether_arp packet;
ssize_t n;
int r;
assert(s);
assert(fd >= 0);
n = recv(fd, &packet, sizeof(struct ether_arp), 0);
if (n < 0) {
if (ERRNO_IS_TRANSIENT(errno) || ERRNO_IS_DISCONNECT(errno))
return 0;
log_ipv4acd_errno(acd, errno, "Failed to read ARP packet: %m");
goto fail;
}
if ((size_t) n != sizeof(struct ether_arp)) {
log_ipv4acd(acd, "Ignoring too short ARP packet.");
return 0;
}
switch (acd->state) {
case IPV4ACD_STATE_ANNOUNCING:
case IPV4ACD_STATE_RUNNING:
if (ipv4acd_arp_conflict(acd, &packet, true)) {
usec_t ts;
assert_se(sd_event_now(acd->event, CLOCK_BOOTTIME, &ts) >= 0);
/* Defend address */
if (ts > acd->defend_window) {
acd->defend_window = ts + DEFEND_INTERVAL_USEC;
r = arp_send_announcement(acd->fd, acd->ifindex, &acd->address, &acd->mac_addr);
if (r < 0) {
log_ipv4acd_errno(acd, r, "Failed to send ARP announcement: %m");
goto fail;
}
log_ipv4acd(acd, "Defending "IPV4_ADDRESS_FMT_STR, IPV4_ADDRESS_FMT_VAL(acd->address));
} else
ipv4acd_on_conflict(acd);
}
break;
case IPV4ACD_STATE_WAITING_PROBE:
case IPV4ACD_STATE_PROBING:
case IPV4ACD_STATE_WAITING_ANNOUNCE:
if (ipv4acd_arp_conflict(acd, &packet, false))
ipv4acd_on_conflict(acd);
break;
default:
assert_not_reached();
}
return 0;
fail:
sd_ipv4acd_stop(acd);
return 0;
}
int sd_ipv4acd_set_ifindex(sd_ipv4acd *acd, int ifindex) {
assert_return(acd, -EINVAL);
assert_return(ifindex > 0, -EINVAL);
assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
acd->ifindex = ifindex;
return 0;
}
int sd_ipv4acd_get_ifindex(sd_ipv4acd *acd) {
if (!acd)
return -EINVAL;
return acd->ifindex;
}
int sd_ipv4acd_set_ifname(sd_ipv4acd *acd, const char *ifname) {
assert_return(acd, -EINVAL);
assert_return(ifname, -EINVAL);
if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
return -EINVAL;
return free_and_strdup(&acd->ifname, ifname);
}
int sd_ipv4acd_get_ifname(sd_ipv4acd *acd, const char **ret) {
int r;
assert_return(acd, -EINVAL);
r = get_ifname(acd->ifindex, &acd->ifname);
if (r < 0)
return r;
if (ret)
*ret = acd->ifname;
return 0;
}
int sd_ipv4acd_set_mac(sd_ipv4acd *acd, const struct ether_addr *addr) {
int r;
assert_return(acd, -EINVAL);
assert_return(addr, -EINVAL);
assert_return(!ether_addr_is_null(addr), -EINVAL);
acd->mac_addr = *addr;
if (!sd_ipv4acd_is_running(acd))
return 0;
assert(acd->fd >= 0);
r = arp_update_filter(acd->fd, &acd->address, &acd->mac_addr);
if (r < 0) {
ipv4acd_reset(acd);
return r;
}
return 0;
}
int sd_ipv4acd_detach_event(sd_ipv4acd *acd) {
assert_return(acd, -EINVAL);
acd->event = sd_event_unref(acd->event);
return 0;
}
int sd_ipv4acd_attach_event(sd_ipv4acd *acd, sd_event *event, int64_t priority) {
int r;
assert_return(acd, -EINVAL);
assert_return(!acd->event, -EBUSY);
if (event)
acd->event = sd_event_ref(event);
else {
r = sd_event_default(&acd->event);
if (r < 0)
return r;
}
acd->event_priority = priority;
return 0;
}
int sd_ipv4acd_set_callback(sd_ipv4acd *acd, sd_ipv4acd_callback_t cb, void *userdata) {
assert_return(acd, -EINVAL);
acd->callback = cb;
acd->userdata = userdata;
return 0;
}
int sd_ipv4acd_set_check_mac_callback(sd_ipv4acd *acd, sd_ipv4acd_check_mac_callback_t cb, void *userdata) {
assert_return(acd, -EINVAL);
acd->check_mac_callback = cb;
acd->check_mac_userdata = userdata;
return 0;
}
int sd_ipv4acd_set_address(sd_ipv4acd *acd, const struct in_addr *address) {
int r;
assert_return(acd, -EINVAL);
assert_return(address, -EINVAL);
assert_return(in4_addr_is_set(address), -EINVAL);
if (in4_addr_equal(&acd->address, address))
return 0;
acd->address = *address;
if (!sd_ipv4acd_is_running(acd))
return 0;
assert(acd->fd >= 0);
r = arp_update_filter(acd->fd, &acd->address, &acd->mac_addr);
if (r < 0)
goto fail;
r = ipv4acd_set_next_wakeup(acd, 0, 0);
if (r < 0)
goto fail;
ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
return 0;
fail:
ipv4acd_reset(acd);
return r;
}
int sd_ipv4acd_get_address(sd_ipv4acd *acd, struct in_addr *address) {
assert_return(acd, -EINVAL);
assert_return(address, -EINVAL);
*address = acd->address;
return 0;
}
int sd_ipv4acd_is_running(sd_ipv4acd *acd) {
assert_return(acd, false);
return acd->state != IPV4ACD_STATE_INIT;
}
int sd_ipv4acd_start(sd_ipv4acd *acd, bool reset_conflicts) {
int r;
assert_return(acd, -EINVAL);
assert_return(acd->event, -EINVAL);
assert_return(acd->ifindex > 0, -EINVAL);
assert_return(in4_addr_is_set(&acd->address), -EINVAL);
assert_return(!ether_addr_is_null(&acd->mac_addr), -EINVAL);
assert_return(acd->state == IPV4ACD_STATE_INIT, -EBUSY);
r = arp_network_bind_raw_socket(acd->ifindex, &acd->address, &acd->mac_addr);
if (r < 0)
return r;
close_and_replace(acd->fd, r);
if (reset_conflicts)
acd->n_conflict = 0;
r = sd_event_add_io(acd->event, &acd->receive_message_event_source, acd->fd, EPOLLIN, ipv4acd_on_packet, acd);
if (r < 0)
goto fail;
r = sd_event_source_set_priority(acd->receive_message_event_source, acd->event_priority);
if (r < 0)
goto fail;
(void) sd_event_source_set_description(acd->receive_message_event_source, "ipv4acd-receive-message");
r = ipv4acd_set_next_wakeup(acd, 0, 0);
if (r < 0)
goto fail;
ipv4acd_set_state(acd, IPV4ACD_STATE_STARTED, true);
return 0;
fail:
ipv4acd_reset(acd);
return r;
}
| 18,544 | 29.302288 | 121 |
c
|
null |
systemd-main/src/libsystemd-network/sd-ipv4ll.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Axis Communications AB. All rights reserved.
***/
#include <arpa/inet.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include "sd-id128.h"
#include "sd-ipv4acd.h"
#include "sd-ipv4ll.h"
#include "alloc-util.h"
#include "ether-addr-util.h"
#include "in-addr-util.h"
#include "network-common.h"
#include "random-util.h"
#include "siphash24.h"
#include "sparse-endian.h"
#include "string-util.h"
#define IPV4LL_NETWORK UINT32_C(0xA9FE0000)
#define IPV4LL_NETMASK UINT32_C(0xFFFF0000)
#define IPV4LL_DONT_DESTROY(ll) \
_cleanup_(sd_ipv4ll_unrefp) _unused_ sd_ipv4ll *_dont_destroy_##ll = sd_ipv4ll_ref(ll)
struct sd_ipv4ll {
unsigned n_ref;
sd_ipv4acd *acd;
be32_t address; /* the address pushed to ACD */
struct ether_addr mac;
struct {
le64_t value;
le64_t generation;
} seed;
bool seed_set;
/* External */
be32_t claimed_address;
sd_ipv4ll_callback_t callback;
void *userdata;
sd_ipv4ll_check_mac_callback_t check_mac_callback;
void *check_mac_userdata;
};
#define log_ipv4ll_errno(ll, error, fmt, ...) \
log_interface_prefix_full_errno( \
"IPv4LL: ", \
sd_ipv4ll, ll, \
error, fmt, ##__VA_ARGS__)
#define log_ipv4ll(ll, fmt, ...) \
log_interface_prefix_full_errno_zerook( \
"IPv4LL: ", \
sd_ipv4ll, ll, \
0, fmt, ##__VA_ARGS__)
static void ipv4ll_on_acd(sd_ipv4acd *acd, int event, void *userdata);
static int ipv4ll_check_mac(sd_ipv4acd *acd, const struct ether_addr *mac, void *userdata);
static sd_ipv4ll *ipv4ll_free(sd_ipv4ll *ll) {
assert(ll);
sd_ipv4acd_unref(ll->acd);
return mfree(ll);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_ipv4ll, sd_ipv4ll, ipv4ll_free);
int sd_ipv4ll_new(sd_ipv4ll **ret) {
_cleanup_(sd_ipv4ll_unrefp) sd_ipv4ll *ll = NULL;
int r;
assert_return(ret, -EINVAL);
ll = new0(sd_ipv4ll, 1);
if (!ll)
return -ENOMEM;
ll->n_ref = 1;
r = sd_ipv4acd_new(&ll->acd);
if (r < 0)
return r;
r = sd_ipv4acd_set_callback(ll->acd, ipv4ll_on_acd, ll);
if (r < 0)
return r;
r = sd_ipv4acd_set_check_mac_callback(ll->acd, ipv4ll_check_mac, ll);
if (r < 0)
return r;
*ret = TAKE_PTR(ll);
return 0;
}
int sd_ipv4ll_stop(sd_ipv4ll *ll) {
if (!ll)
return 0;
return sd_ipv4acd_stop(ll->acd);
}
int sd_ipv4ll_set_ifindex(sd_ipv4ll *ll, int ifindex) {
assert_return(ll, -EINVAL);
assert_return(ifindex > 0, -EINVAL);
assert_return(sd_ipv4ll_is_running(ll) == 0, -EBUSY);
return sd_ipv4acd_set_ifindex(ll->acd, ifindex);
}
int sd_ipv4ll_get_ifindex(sd_ipv4ll *ll) {
if (!ll)
return -EINVAL;
return sd_ipv4acd_get_ifindex(ll->acd);
}
int sd_ipv4ll_set_ifname(sd_ipv4ll *ll, const char *ifname) {
assert_return(ll, -EINVAL);
assert_return(ifname, -EINVAL);
return sd_ipv4acd_set_ifname(ll->acd, ifname);
}
int sd_ipv4ll_get_ifname(sd_ipv4ll *ll, const char **ret) {
assert_return(ll, -EINVAL);
return sd_ipv4acd_get_ifname(ll->acd, ret);
}
int sd_ipv4ll_set_mac(sd_ipv4ll *ll, const struct ether_addr *addr) {
int r;
assert_return(ll, -EINVAL);
assert_return(addr, -EINVAL);
assert_return(!ether_addr_is_null(addr), -EINVAL);
r = sd_ipv4acd_set_mac(ll->acd, addr);
if (r < 0)
return r;
ll->mac = *addr;
return 0;
}
int sd_ipv4ll_detach_event(sd_ipv4ll *ll) {
assert_return(ll, -EINVAL);
return sd_ipv4acd_detach_event(ll->acd);
}
int sd_ipv4ll_attach_event(sd_ipv4ll *ll, sd_event *event, int64_t priority) {
assert_return(ll, -EINVAL);
return sd_ipv4acd_attach_event(ll->acd, event, priority);
}
int sd_ipv4ll_set_callback(sd_ipv4ll *ll, sd_ipv4ll_callback_t cb, void *userdata) {
assert_return(ll, -EINVAL);
ll->callback = cb;
ll->userdata = userdata;
return 0;
}
int sd_ipv4ll_set_check_mac_callback(sd_ipv4ll *ll, sd_ipv4ll_check_mac_callback_t cb, void *userdata) {
assert_return(ll, -EINVAL);
ll->check_mac_callback = cb;
ll->check_mac_userdata = userdata;
return 0;
}
int sd_ipv4ll_get_address(sd_ipv4ll *ll, struct in_addr *address) {
assert_return(ll, -EINVAL);
assert_return(address, -EINVAL);
if (ll->claimed_address == 0)
return -ENOENT;
address->s_addr = ll->claimed_address;
return 0;
}
int sd_ipv4ll_set_address_seed(sd_ipv4ll *ll, uint64_t seed) {
assert_return(ll, -EINVAL);
assert_return(sd_ipv4ll_is_running(ll) == 0, -EBUSY);
ll->seed.value = htole64(seed);
ll->seed_set = true;
return 0;
}
int sd_ipv4ll_is_running(sd_ipv4ll *ll) {
assert_return(ll, false);
return sd_ipv4acd_is_running(ll->acd);
}
int sd_ipv4ll_set_address(sd_ipv4ll *ll, const struct in_addr *address) {
int r;
assert_return(ll, -EINVAL);
assert_return(address, -EINVAL);
assert_return(in4_addr_is_link_local_dynamic(address), -EINVAL);
r = sd_ipv4acd_set_address(ll->acd, address);
if (r < 0)
return r;
ll->address = address->s_addr;
return 0;
}
#define PICK_HASH_KEY SD_ID128_MAKE(15,ac,82,a6,d6,3f,49,78,98,77,5d,0c,69,02,94,0b)
static int ipv4ll_pick_address(sd_ipv4ll *ll) {
be32_t addr;
assert(ll);
do {
uint64_t h;
h = siphash24(&ll->seed, sizeof(ll->seed), PICK_HASH_KEY.bytes);
/* Increase the generation counter by one */
ll->seed.generation = htole64(le64toh(ll->seed.generation) + 1);
addr = htobe32((h & UINT32_C(0x0000FFFF)) | IPV4LL_NETWORK);
} while (addr == ll->address ||
IN_SET(be32toh(addr) & 0x0000FF00U, 0x0000U, 0xFF00U));
log_ipv4ll(ll, "Picked new IP address %s.", IN4_ADDR_TO_STRING((const struct in_addr*) &addr));
return sd_ipv4ll_set_address(ll, &(struct in_addr) { addr });
}
#define MAC_HASH_KEY SD_ID128_MAKE(df,04,22,98,3f,ad,14,52,f9,87,2e,d1,9c,70,e2,f2)
static int ipv4ll_start_internal(sd_ipv4ll *ll, bool reset_generation) {
int r;
bool picked_address = false;
assert_return(ll, -EINVAL);
assert_return(!ether_addr_is_null(&ll->mac), -EINVAL);
/* If no random seed is set, generate some from the MAC address */
if (!ll->seed_set)
ll->seed.value = htole64(siphash24(ll->mac.ether_addr_octet, ETH_ALEN, MAC_HASH_KEY.bytes));
if (reset_generation)
ll->seed.generation = 0;
if (ll->address == 0) {
r = ipv4ll_pick_address(ll);
if (r < 0)
return r;
picked_address = true;
}
r = sd_ipv4acd_start(ll->acd, reset_generation);
if (r < 0) {
/* We couldn't start? If so, let's forget the picked address again, the user might make a change and
* retry, and we want the new data to take effect when picking an address. */
if (picked_address)
ll->address = 0;
return r;
}
return 1;
}
int sd_ipv4ll_start(sd_ipv4ll *ll) {
assert_return(ll, -EINVAL);
if (sd_ipv4ll_is_running(ll))
return 0;
return ipv4ll_start_internal(ll, true);
}
int sd_ipv4ll_restart(sd_ipv4ll *ll) {
ll->address = 0;
return ipv4ll_start_internal(ll, false);
}
static void ipv4ll_client_notify(sd_ipv4ll *ll, int event) {
assert(ll);
if (ll->callback)
ll->callback(ll, event, ll->userdata);
}
void ipv4ll_on_acd(sd_ipv4acd *acd, int event, void *userdata) {
sd_ipv4ll *ll = ASSERT_PTR(userdata);
IPV4LL_DONT_DESTROY(ll);
int r;
assert(acd);
switch (event) {
case SD_IPV4ACD_EVENT_STOP:
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_STOP);
ll->claimed_address = 0;
break;
case SD_IPV4ACD_EVENT_BIND:
ll->claimed_address = ll->address;
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_BIND);
break;
case SD_IPV4ACD_EVENT_CONFLICT:
/* if an address was already bound we must call up to the
user to handle this, otherwise we just try again */
if (ll->claimed_address != 0) {
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_CONFLICT);
ll->claimed_address = 0;
} else {
r = sd_ipv4ll_restart(ll);
if (r < 0)
goto error;
}
break;
default:
assert_not_reached();
}
return;
error:
ipv4ll_client_notify(ll, SD_IPV4LL_EVENT_STOP);
}
static int ipv4ll_check_mac(sd_ipv4acd *acd, const struct ether_addr *mac, void *userdata) {
sd_ipv4ll *ll = ASSERT_PTR(userdata);
if (ll->check_mac_callback)
return ll->check_mac_callback(ll, mac, ll->check_mac_userdata);
return 0;
}
| 9,833 | 25.868852 | 116 |
c
|
null |
systemd-main/src/libsystemd-network/sd-lldp-rx.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <arpa/inet.h>
#include <linux/sockios.h>
#include <sys/ioctl.h>
#include "sd-lldp-rx.h"
#include "alloc-util.h"
#include "ether-addr-util.h"
#include "event-util.h"
#include "fd-util.h"
#include "lldp-neighbor.h"
#include "lldp-network.h"
#include "lldp-rx-internal.h"
#include "memory-util.h"
#include "network-common.h"
#include "socket-util.h"
#include "sort-util.h"
#include "string-table.h"
#define LLDP_DEFAULT_NEIGHBORS_MAX 128U
static const char * const lldp_rx_event_table[_SD_LLDP_RX_EVENT_MAX] = {
[SD_LLDP_RX_EVENT_ADDED] = "added",
[SD_LLDP_RX_EVENT_REMOVED] = "removed",
[SD_LLDP_RX_EVENT_UPDATED] = "updated",
[SD_LLDP_RX_EVENT_REFRESHED] = "refreshed",
};
DEFINE_STRING_TABLE_LOOKUP(lldp_rx_event, sd_lldp_rx_event_t);
static void lldp_rx_flush_neighbors(sd_lldp_rx *lldp_rx) {
assert(lldp_rx);
hashmap_clear(lldp_rx->neighbor_by_id);
}
static void lldp_rx_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n) {
assert(lldp_rx);
assert(event >= 0 && event < _SD_LLDP_RX_EVENT_MAX);
if (!lldp_rx->callback)
return (void) log_lldp_rx(lldp_rx, "Received '%s' event.", lldp_rx_event_to_string(event));
log_lldp_rx(lldp_rx, "Invoking callback for '%s' event.", lldp_rx_event_to_string(event));
lldp_rx->callback(lldp_rx, event, n, lldp_rx->userdata);
}
static int lldp_rx_make_space(sd_lldp_rx *lldp_rx, size_t extra) {
usec_t t = USEC_INFINITY;
bool changed = false;
assert(lldp_rx);
/* Remove all entries that are past their TTL, and more until at least the specified number of extra entries
* are free. */
for (;;) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
n = prioq_peek(lldp_rx->neighbor_by_expiry);
if (!n)
break;
sd_lldp_neighbor_ref(n);
if (hashmap_size(lldp_rx->neighbor_by_id) > LESS_BY(lldp_rx->neighbors_max, extra))
goto remove_one;
if (t == USEC_INFINITY)
t = now(CLOCK_BOOTTIME);
if (n->until > t)
break;
remove_one:
lldp_neighbor_unlink(n);
lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, n);
changed = true;
}
return changed;
}
static bool lldp_rx_keep_neighbor(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) {
assert(lldp_rx);
assert(n);
/* Don't keep data with a zero TTL */
if (n->ttl <= 0)
return false;
/* Filter out data from the filter address */
if (!ether_addr_is_null(&lldp_rx->filter_address) &&
ether_addr_equal(&lldp_rx->filter_address, &n->source_address))
return false;
/* Only add if the neighbor has a capability we are interested in. Note that we also store all neighbors with
* no caps field set. */
if (n->has_capabilities &&
(n->enabled_capabilities & lldp_rx->capability_mask) == 0)
return false;
/* Keep everything else */
return true;
}
static int lldp_rx_start_timer(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *neighbor);
static int lldp_rx_add_neighbor(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *old = NULL;
bool keep;
int r;
assert(lldp_rx);
assert(n);
assert(!n->lldp_rx);
keep = lldp_rx_keep_neighbor(lldp_rx, n);
/* First retrieve the old entry for this MSAP */
old = hashmap_get(lldp_rx->neighbor_by_id, &n->id);
if (old) {
sd_lldp_neighbor_ref(old);
if (!keep) {
lldp_neighbor_unlink(old);
lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, old);
return 0;
}
if (lldp_neighbor_equal(n, old)) {
/* Is this equal, then restart the TTL counter, but don't do anything else. */
old->timestamp = n->timestamp;
lldp_rx_start_timer(lldp_rx, old);
lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REFRESHED, old);
return 0;
}
/* Data changed, remove the old entry, and add a new one */
lldp_neighbor_unlink(old);
} else if (!keep)
return 0;
/* Then, make room for at least one new neighbor */
lldp_rx_make_space(lldp_rx, 1);
r = hashmap_ensure_put(&lldp_rx->neighbor_by_id, &lldp_neighbor_hash_ops, &n->id, n);
if (r < 0)
goto finish;
r = prioq_ensure_put(&lldp_rx->neighbor_by_expiry, lldp_neighbor_prioq_compare_func, n, &n->prioq_idx);
if (r < 0) {
assert_se(hashmap_remove(lldp_rx->neighbor_by_id, &n->id) == n);
goto finish;
}
n->lldp_rx = lldp_rx;
lldp_rx_start_timer(lldp_rx, n);
lldp_rx_callback(lldp_rx, old ? SD_LLDP_RX_EVENT_UPDATED : SD_LLDP_RX_EVENT_ADDED, n);
return 1;
finish:
if (old)
lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, old);
return r;
}
static int lldp_rx_handle_datagram(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) {
int r;
assert(lldp_rx);
assert(n);
r = lldp_neighbor_parse(n);
if (r < 0)
return r;
r = lldp_rx_add_neighbor(lldp_rx, n);
if (r < 0)
return log_lldp_rx_errno(lldp_rx, r, "Failed to add datagram. Ignoring.");
log_lldp_rx(lldp_rx, "Successfully processed LLDP datagram.");
return 0;
}
static int lldp_rx_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
ssize_t space, length;
sd_lldp_rx *lldp_rx = ASSERT_PTR(userdata);
struct timespec ts;
assert(fd >= 0);
space = next_datagram_size_fd(fd);
if (space < 0) {
if (ERRNO_IS_TRANSIENT(space) || ERRNO_IS_DISCONNECT(space))
return 0;
log_lldp_rx_errno(lldp_rx, space, "Failed to determine datagram size to read, ignoring: %m");
return 0;
}
n = lldp_neighbor_new(space);
if (!n) {
log_oom_debug();
return 0;
}
length = recv(fd, LLDP_NEIGHBOR_RAW(n), n->raw_size, MSG_DONTWAIT);
if (length < 0) {
if (ERRNO_IS_TRANSIENT(errno) || ERRNO_IS_DISCONNECT(errno))
return 0;
log_lldp_rx_errno(lldp_rx, errno, "Failed to read LLDP datagram, ignoring: %m");
return 0;
}
if ((size_t) length != n->raw_size) {
log_lldp_rx(lldp_rx, "Packet size mismatch, ignoring");
return 0;
}
/* Try to get the timestamp of this packet if it is known */
if (ioctl(fd, SIOCGSTAMPNS, &ts) >= 0)
triple_timestamp_from_realtime(&n->timestamp, timespec_load(&ts));
else
triple_timestamp_get(&n->timestamp);
(void) lldp_rx_handle_datagram(lldp_rx, n);
return 0;
}
static void lldp_rx_reset(sd_lldp_rx *lldp_rx) {
assert(lldp_rx);
(void) event_source_disable(lldp_rx->timer_event_source);
lldp_rx->io_event_source = sd_event_source_disable_unref(lldp_rx->io_event_source);
lldp_rx->fd = safe_close(lldp_rx->fd);
}
int sd_lldp_rx_is_running(sd_lldp_rx *lldp_rx) {
if (!lldp_rx)
return false;
return lldp_rx->fd >= 0;
}
int sd_lldp_rx_start(sd_lldp_rx *lldp_rx) {
int r;
assert_return(lldp_rx, -EINVAL);
assert_return(lldp_rx->event, -EINVAL);
assert_return(lldp_rx->ifindex > 0, -EINVAL);
if (sd_lldp_rx_is_running(lldp_rx))
return 0;
assert(!lldp_rx->io_event_source);
lldp_rx->fd = lldp_network_bind_raw_socket(lldp_rx->ifindex);
if (lldp_rx->fd < 0)
return lldp_rx->fd;
r = sd_event_add_io(lldp_rx->event, &lldp_rx->io_event_source, lldp_rx->fd, EPOLLIN, lldp_rx_receive_datagram, lldp_rx);
if (r < 0)
goto fail;
r = sd_event_source_set_priority(lldp_rx->io_event_source, lldp_rx->event_priority);
if (r < 0)
goto fail;
(void) sd_event_source_set_description(lldp_rx->io_event_source, "lldp-rx-io");
log_lldp_rx(lldp_rx, "Started LLDP client");
return 1;
fail:
lldp_rx_reset(lldp_rx);
return r;
}
int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx) {
if (!sd_lldp_rx_is_running(lldp_rx))
return 0;
log_lldp_rx(lldp_rx, "Stopping LLDP client");
lldp_rx_reset(lldp_rx);
lldp_rx_flush_neighbors(lldp_rx);
return 1;
}
int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64_t priority) {
int r;
assert_return(lldp_rx, -EINVAL);
assert_return(!sd_lldp_rx_is_running(lldp_rx), -EBUSY);
assert_return(!lldp_rx->event, -EBUSY);
if (event)
lldp_rx->event = sd_event_ref(event);
else {
r = sd_event_default(&lldp_rx->event);
if (r < 0)
return r;
}
lldp_rx->event_priority = priority;
return 0;
}
int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx) {
assert_return(lldp_rx, -EINVAL);
assert_return(!sd_lldp_rx_is_running(lldp_rx), -EBUSY);
lldp_rx->io_event_source = sd_event_source_disable_unref(lldp_rx->io_event_source);
lldp_rx->timer_event_source = sd_event_source_disable_unref(lldp_rx->timer_event_source);
lldp_rx->event = sd_event_unref(lldp_rx->event);
return 0;
}
sd_event* sd_lldp_rx_get_event(sd_lldp_rx *lldp_rx) {
assert_return(lldp_rx, NULL);
return lldp_rx->event;
}
int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata) {
assert_return(lldp_rx, -EINVAL);
lldp_rx->callback = cb;
lldp_rx->userdata = userdata;
return 0;
}
int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex) {
assert_return(lldp_rx, -EINVAL);
assert_return(ifindex > 0, -EINVAL);
assert_return(!sd_lldp_rx_is_running(lldp_rx), -EBUSY);
lldp_rx->ifindex = ifindex;
return 0;
}
int sd_lldp_rx_set_ifname(sd_lldp_rx *lldp_rx, const char *ifname) {
assert_return(lldp_rx, -EINVAL);
assert_return(ifname, -EINVAL);
if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
return -EINVAL;
return free_and_strdup(&lldp_rx->ifname, ifname);
}
int sd_lldp_rx_get_ifname(sd_lldp_rx *lldp_rx, const char **ret) {
int r;
assert_return(lldp_rx, -EINVAL);
r = get_ifname(lldp_rx->ifindex, &lldp_rx->ifname);
if (r < 0)
return r;
if (ret)
*ret = lldp_rx->ifname;
return 0;
}
static sd_lldp_rx *lldp_rx_free(sd_lldp_rx *lldp_rx) {
if (!lldp_rx)
return NULL;
lldp_rx_reset(lldp_rx);
sd_lldp_rx_detach_event(lldp_rx);
lldp_rx_flush_neighbors(lldp_rx);
hashmap_free(lldp_rx->neighbor_by_id);
prioq_free(lldp_rx->neighbor_by_expiry);
free(lldp_rx->ifname);
return mfree(lldp_rx);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp_rx, sd_lldp_rx, lldp_rx_free);
int sd_lldp_rx_new(sd_lldp_rx **ret) {
_cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL;
assert_return(ret, -EINVAL);
lldp_rx = new(sd_lldp_rx, 1);
if (!lldp_rx)
return -ENOMEM;
*lldp_rx = (sd_lldp_rx) {
.n_ref = 1,
.fd = -EBADF,
.neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX,
.capability_mask = UINT16_MAX,
};
*ret = TAKE_PTR(lldp_rx);
return 0;
}
static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
sd_lldp_rx *lldp_rx = userdata;
int r;
r = lldp_rx_make_space(lldp_rx, 0);
if (r < 0) {
log_lldp_rx_errno(lldp_rx, r, "Failed to make space, ignoring: %m");
return 0;
}
r = lldp_rx_start_timer(lldp_rx, NULL);
if (r < 0) {
log_lldp_rx_errno(lldp_rx, r, "Failed to restart timer, ignoring: %m");
return 0;
}
return 0;
}
static int lldp_rx_start_timer(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *neighbor) {
sd_lldp_neighbor *n;
assert(lldp_rx);
assert(lldp_rx->event);
if (neighbor)
lldp_neighbor_start_ttl(neighbor);
n = prioq_peek(lldp_rx->neighbor_by_expiry);
if (!n)
return event_source_disable(lldp_rx->timer_event_source);
return event_reset_time(lldp_rx->event, &lldp_rx->timer_event_source,
CLOCK_BOOTTIME,
n->until, 0,
on_timer_event, lldp_rx,
lldp_rx->event_priority, "lldp-rx-timer", true);
}
static inline int neighbor_compare_func(sd_lldp_neighbor * const *a, sd_lldp_neighbor * const *b) {
assert(a);
assert(b);
assert(*a);
assert(*b);
return lldp_neighbor_id_compare_func(&(*a)->id, &(*b)->id);
}
int sd_lldp_rx_get_neighbors(sd_lldp_rx *lldp_rx, sd_lldp_neighbor ***ret) {
_cleanup_free_ sd_lldp_neighbor **l = NULL;
sd_lldp_neighbor *n;
int k = 0;
assert_return(lldp_rx, -EINVAL);
assert_return(ret, -EINVAL);
if (hashmap_isempty(lldp_rx->neighbor_by_id)) { /* Special shortcut */
*ret = NULL;
return 0;
}
l = new0(sd_lldp_neighbor*, hashmap_size(lldp_rx->neighbor_by_id));
if (!l)
return -ENOMEM;
HASHMAP_FOREACH(n, lldp_rx->neighbor_by_id)
l[k++] = sd_lldp_neighbor_ref(n);
assert((size_t) k == hashmap_size(lldp_rx->neighbor_by_id));
/* Return things in a stable order */
typesafe_qsort(l, k, neighbor_compare_func);
*ret = TAKE_PTR(l);
return k;
}
int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t m) {
assert_return(lldp_rx, -EINVAL);
assert_return(m > 0, -EINVAL);
lldp_rx->neighbors_max = m;
lldp_rx_make_space(lldp_rx, 0);
return 0;
}
int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask) {
assert_return(lldp_rx, -EINVAL);
assert_return(mask != 0, -EINVAL);
lldp_rx->capability_mask = mask;
return 0;
}
int sd_lldp_rx_set_filter_address(sd_lldp_rx *lldp_rx, const struct ether_addr *addr) {
assert_return(lldp_rx, -EINVAL);
/* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so
* that our own can be filtered out here. */
if (addr)
lldp_rx->filter_address = *addr;
else
zero(lldp_rx->filter_address);
return 0;
}
| 15,673 | 28.798479 | 128 |
c
|
null |
systemd-main/src/libsystemd-network/sd-lldp-tx.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <arpa/inet.h>
#include <linux/sockios.h>
#include <sys/ioctl.h>
#include "sd-event.h"
#include "sd-id128.h"
#include "sd-lldp-tx.h"
#include "alloc-util.h"
#include "ether-addr-util.h"
#include "fd-util.h"
#include "hostname-util.h"
#include "network-common.h"
#include "random-util.h"
#include "socket-util.h"
#include "string-util.h"
#include "time-util.h"
#include "unaligned.h"
#include "web-util.h"
/* The LLDP spec calls this "txFastInit", see 9.2.5.19 */
#define LLDP_FAST_TX_INIT 4U
/* The LLDP spec calls this "msgTxHold", see 9.2.5.6 */
#define LLDP_TX_HOLD 4U
/* The jitter range to add, see 9.2.2. */
#define LLDP_TX_JITTER_USEC (400U * USEC_PER_MSEC)
/* The LLDP spec calls this msgTxInterval, but we subtract half the jitter off it. */
#define LLDP_TX_INTERVAL_USEC (30U * USEC_PER_SEC - LLDP_TX_JITTER_USEC / 2)
/* The LLDP spec calls this msgFastTx, but we subtract half the jitter off it. */
#define LLDP_FAST_TX_INTERVAL_USEC (1U * USEC_PER_SEC - LLDP_TX_JITTER_USEC / 2)
#define LLDP_TX_TTL ((uint16_t) DIV_ROUND_UP(LLDP_TX_INTERVAL_USEC * LLDP_TX_HOLD + 1, USEC_PER_SEC))
static const struct ether_addr lldp_multicast_addr[_SD_LLDP_MULTICAST_MODE_MAX] = {
[SD_LLDP_MULTICAST_MODE_NEAREST_BRIDGE] = {{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x0e }},
[SD_LLDP_MULTICAST_MODE_NON_TPMR_BRIDGE] = {{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 }},
[SD_LLDP_MULTICAST_MODE_CUSTOMER_BRIDGE] = {{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 }},
};
struct sd_lldp_tx {
unsigned n_ref;
int ifindex;
char *ifname;
sd_event *event;
int64_t event_priority;
sd_event_source *timer_event_source;
unsigned fast_tx;
sd_lldp_multicast_mode_t mode;
struct ether_addr hwaddr;
char *port_description;
char *hostname;
char *pretty_hostname;
char *mud_url;
uint16_t supported_capabilities;
uint16_t enabled_capabilities;
};
#define log_lldp_tx_errno(lldp_tx, error, fmt, ...) \
log_interface_prefix_full_errno( \
"LLDP Tx: ", \
sd_lldp_tx, lldp_tx, \
error, fmt, ##__VA_ARGS__)
#define log_lldp_tx(lldp_tx, fmt, ...) \
log_interface_prefix_full_errno_zerook( \
"LLDP Tx: ", \
sd_lldp_tx, lldp_tx, \
0, fmt, ##__VA_ARGS__)
static sd_lldp_tx *lldp_tx_free(sd_lldp_tx *lldp_tx) {
if (!lldp_tx)
return NULL;
sd_lldp_tx_detach_event(lldp_tx);
free(lldp_tx->port_description);
free(lldp_tx->hostname);
free(lldp_tx->pretty_hostname);
free(lldp_tx->mud_url);
free(lldp_tx->ifname);
return mfree(lldp_tx);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp_tx, sd_lldp_tx, lldp_tx_free);
int sd_lldp_tx_new(sd_lldp_tx **ret) {
_cleanup_(sd_lldp_tx_unrefp) sd_lldp_tx *lldp_tx = NULL;
assert_return(ret, -EINVAL);
lldp_tx = new(sd_lldp_tx, 1);
if (!lldp_tx)
return -ENOMEM;
*lldp_tx = (sd_lldp_tx) {
.n_ref = 1,
.mode = _SD_LLDP_MULTICAST_MODE_INVALID,
};
*ret = TAKE_PTR(lldp_tx);
return 0;
}
int sd_lldp_tx_set_ifindex(sd_lldp_tx *lldp_tx, int ifindex) {
assert_return(lldp_tx, -EINVAL);
assert_return(ifindex > 0, -EINVAL);
lldp_tx->ifindex = ifindex;
return 0;
}
int sd_lldp_tx_set_ifname(sd_lldp_tx *lldp_tx, const char *ifname) {
assert_return(lldp_tx, -EINVAL);
assert_return(ifname, -EINVAL);
if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
return -EINVAL;
return free_and_strdup(&lldp_tx->ifname, ifname);
}
int sd_lldp_tx_get_ifname(sd_lldp_tx *lldp_tx, const char **ret) {
int r;
assert_return(lldp_tx, -EINVAL);
r = get_ifname(lldp_tx->ifindex, &lldp_tx->ifname);
if (r < 0)
return r;
if (ret)
*ret = lldp_tx->ifname;
return 0;
}
int sd_lldp_tx_set_multicast_mode(sd_lldp_tx *lldp_tx, sd_lldp_multicast_mode_t mode) {
assert_return(lldp_tx, -EINVAL);
assert_return(mode >= 0 && mode < _SD_LLDP_MULTICAST_MODE_MAX, -EINVAL);
lldp_tx->mode = mode;
return 0;
}
int sd_lldp_tx_set_hwaddr(sd_lldp_tx *lldp_tx, const struct ether_addr *hwaddr) {
assert_return(lldp_tx, -EINVAL);
assert_return(!ether_addr_is_null(hwaddr), -EINVAL);
lldp_tx->hwaddr = *hwaddr;
return 0;
}
int sd_lldp_tx_set_capabilities(sd_lldp_tx *lldp_tx, uint16_t supported, uint16_t enabled) {
assert_return(lldp_tx, -EINVAL);
assert_return((enabled & ~supported) == 0, -EINVAL);
lldp_tx->supported_capabilities = supported;
lldp_tx->enabled_capabilities = enabled;
return 0;
}
int sd_lldp_tx_set_port_description(sd_lldp_tx *lldp_tx, const char *port_description) {
assert_return(lldp_tx, -EINVAL);
/* An empty string unset the previously set hostname. */
if (strlen_ptr(port_description) >= 512)
return -EINVAL;
return free_and_strdup(&lldp_tx->port_description, empty_to_null(port_description));
}
int sd_lldp_tx_set_hostname(sd_lldp_tx *lldp_tx, const char *hostname) {
assert_return(lldp_tx, -EINVAL);
/* An empty string unset the previously set hostname. */
if (!isempty(hostname)) {
assert_cc(HOST_NAME_MAX < 512);
if (!hostname_is_valid(hostname, 0))
return -EINVAL;
}
return free_and_strdup(&lldp_tx->hostname, empty_to_null(hostname));
}
int sd_lldp_tx_set_pretty_hostname(sd_lldp_tx *lldp_tx, const char *pretty_hostname) {
assert_return(lldp_tx, -EINVAL);
/* An empty string unset the previously set hostname. */
if (strlen_ptr(pretty_hostname) >= 512)
return -EINVAL;
return free_and_strdup(&lldp_tx->pretty_hostname, empty_to_null(pretty_hostname));
}
int sd_lldp_tx_set_mud_url(sd_lldp_tx *lldp_tx, const char *mud_url) {
assert_return(lldp_tx, -EINVAL);
/* An empty string unset the previously set hostname. */
if (!isempty(mud_url)) {
/* Unless the maximum length of each value is 511, the MUD url must be smaller than 256.
* See RFC 8520. */
if (strlen(mud_url) >= 256)
return -EINVAL;
if (!http_url_is_valid(mud_url))
return -EINVAL;
}
return free_and_strdup(&lldp_tx->mud_url, empty_to_null(mud_url));
}
static size_t lldp_tx_calculate_maximum_packet_size(sd_lldp_tx *lldp_tx, const char *hostname, const char *pretty_hostname) {
assert(lldp_tx);
assert(lldp_tx->ifindex > 0);
return sizeof(struct ether_header) +
/* Chassis ID */
2 + 1 + (SD_ID128_STRING_MAX - 1) +
/* Port ID */
2 + 1 + strlen_ptr(lldp_tx->ifname) +
/* TTL */
2 + 2 +
/* Port description */
2 + strlen_ptr(lldp_tx->port_description) +
/* System name */
2 + strlen_ptr(hostname) +
/* System description */
2 + strlen_ptr(pretty_hostname) +
/* MUD URL */
2 + sizeof(SD_LLDP_OUI_IANA_MUD) + strlen_ptr(lldp_tx->mud_url) +
/* System Capabilities */
2 + 4 +
/* End */
2;
}
static int packet_append_tlv_header(uint8_t *packet, size_t packet_size, size_t *offset, uint8_t type, size_t data_len) {
assert(packet);
assert(offset);
/*
* +--------+--------+--------------
* |TLV Type| len | value
* |(7 bits)|(9 bits)|(0-511 octets)
* +--------+--------+--------------
* where:
*
* len = indicates the length of value
*/
/* The type field is 7-bits. */
if (type >= 128)
return -EINVAL;
/* The data length field is 9-bits. */
if (data_len >= 512)
return -EINVAL;
if (packet_size < 2 + data_len)
return -ENOBUFS;
if (*offset > packet_size - 2 - data_len)
return -ENOBUFS;
packet[(*offset)++] = (type << 1) | !!(data_len >> 8);
packet[(*offset)++] = data_len & (size_t) UINT8_MAX;
return 0;
}
static int packet_append_prefixed_string(
uint8_t *packet,
size_t packet_size,
size_t *offset,
uint8_t type,
size_t prefix_len,
const void *prefix,
const char *str) {
size_t len;
int r;
assert(packet);
assert(offset);
assert(prefix_len == 0 || prefix);
if (isempty(str))
return 0;
len = strlen(str);
/* Check for overflow */
if (len > SIZE_MAX - prefix_len)
return -ENOBUFS;
r = packet_append_tlv_header(packet, packet_size, offset, type, prefix_len + len);
if (r < 0)
return r;
memcpy_safe(packet + *offset, prefix, prefix_len);
*offset += prefix_len;
memcpy(packet + *offset, str, len);
*offset += len;
return 0;
}
static int packet_append_string(
uint8_t *packet,
size_t packet_size,
size_t *offset,
uint8_t type,
const char *str) {
return packet_append_prefixed_string(packet, packet_size, offset, type, 0, NULL, str);
}
static int lldp_tx_create_packet(sd_lldp_tx *lldp_tx, size_t *ret_packet_size, uint8_t **ret_packet) {
_cleanup_free_ char *hostname = NULL, *pretty_hostname = NULL;
_cleanup_free_ uint8_t *packet = NULL;
struct ether_header *header;
size_t packet_size, offset;
sd_id128_t machine_id;
int r;
assert(lldp_tx);
assert(lldp_tx->ifindex > 0);
assert(ret_packet_size);
assert(ret_packet);
/* If ifname is not set yet, set ifname from ifindex. */
r = sd_lldp_tx_get_ifname(lldp_tx, NULL);
if (r < 0)
return r;
r = sd_id128_get_machine(&machine_id);
if (r < 0)
return r;
if (!lldp_tx->hostname)
(void) gethostname_strict(&hostname);
if (!lldp_tx->pretty_hostname)
(void) get_pretty_hostname(&pretty_hostname);
packet_size = lldp_tx_calculate_maximum_packet_size(lldp_tx,
lldp_tx->hostname ?: hostname,
lldp_tx->pretty_hostname ?: pretty_hostname);
packet = new(uint8_t, packet_size);
if (!packet)
return -ENOMEM;
header = (struct ether_header*) packet;
header->ether_type = htobe16(ETHERTYPE_LLDP);
memcpy(header->ether_dhost, lldp_multicast_addr + lldp_tx->mode, ETH_ALEN);
memcpy(header->ether_shost, &lldp_tx->hwaddr, ETH_ALEN);
offset = sizeof(struct ether_header);
/* The three mandatory TLVs must appear first, in this specific order:
* 1. Chassis ID
* 2. Port ID
* 3. Time To Live
*/
r = packet_append_prefixed_string(packet, packet_size, &offset, SD_LLDP_TYPE_CHASSIS_ID,
1, (const uint8_t[]) { SD_LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED },
SD_ID128_TO_STRING(machine_id));
if (r < 0)
return r;
r = packet_append_prefixed_string(packet, packet_size, &offset, SD_LLDP_TYPE_PORT_ID,
1, (const uint8_t[]) { SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME },
lldp_tx->ifname);
if (r < 0)
return r;
r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_TTL, 2);
if (r < 0)
return r;
unaligned_write_be16(packet + offset, LLDP_TX_TTL);
offset += 2;
/* Optional TLVs follow, in no specific order: */
r = packet_append_string(packet, packet_size, &offset, SD_LLDP_TYPE_PORT_DESCRIPTION,
lldp_tx->port_description);
if (r < 0)
return r;
r = packet_append_string(packet, packet_size, &offset, SD_LLDP_TYPE_SYSTEM_NAME,
lldp_tx->hostname ?: hostname);
if (r < 0)
return r;
r = packet_append_string(packet, packet_size, &offset, SD_LLDP_TYPE_SYSTEM_DESCRIPTION,
lldp_tx->pretty_hostname ?: pretty_hostname);
if (r < 0)
return r;
/* See section 12 of RFC 8520.
* +--------+--------+----------+---------+--------------
* |TLV Type| len | OUI |subtype | MUDString
* | =127 | |= 00 00 5E| = 1 |
* |(7 bits)|(9 bits)|(3 octets)|(1 octet)|(1-255 octets)
* +--------+--------+----------+---------+--------------
* where:
*
* o TLV Type = 127 indicates a vendor-specific TLV
* o len = indicates the TLV string length
* o OUI = 00 00 5E is the organizationally unique identifier of IANA
* o subtype = 1 (as assigned by IANA for the MUDstring)
* o MUDstring = the length MUST NOT exceed 255 octets
*/
r = packet_append_prefixed_string(packet, packet_size, &offset, SD_LLDP_TYPE_PRIVATE,
sizeof(SD_LLDP_OUI_IANA_MUD), SD_LLDP_OUI_IANA_MUD,
lldp_tx->mud_url);
if (r < 0)
return r;
r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_SYSTEM_CAPABILITIES, 4);
if (r < 0)
return r;
unaligned_write_be16(packet + offset, lldp_tx->supported_capabilities);
offset += 2;
unaligned_write_be16(packet + offset, lldp_tx->enabled_capabilities);
offset += 2;
r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_END, 0);
if (r < 0)
return r;
*ret_packet_size = offset;
*ret_packet = TAKE_PTR(packet);
return 0;
}
static int lldp_tx_send_packet(sd_lldp_tx *lldp_tx, size_t packet_size, const uint8_t *packet) {
_cleanup_close_ int fd = -EBADF;
union sockaddr_union sa;
ssize_t l;
assert(lldp_tx);
assert(lldp_tx->ifindex > 0);
assert(packet_size > sizeof(struct ether_header));
assert(packet);
sa = (union sockaddr_union) {
.ll.sll_family = AF_PACKET,
.ll.sll_protocol = htobe16(ETHERTYPE_LLDP),
.ll.sll_ifindex = lldp_tx->ifindex,
.ll.sll_halen = ETH_ALEN,
};
memcpy(sa.ll.sll_addr, lldp_multicast_addr + lldp_tx->mode, ETH_ALEN);
fd = socket(AF_PACKET, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
if (fd < 0)
return -errno;
l = sendto(fd, packet, packet_size, MSG_NOSIGNAL, &sa.sa, sizeof(sa.ll));
if (l < 0)
return -errno;
if ((size_t) l != packet_size)
return -EIO;
return 0;
}
static int lldp_tx_send(sd_lldp_tx *lldp_tx) {
_cleanup_free_ uint8_t *packet = NULL;
size_t packet_size = 0; /* avoid false maybe-uninitialized warning */
int r;
assert(lldp_tx);
r = lldp_tx_create_packet(lldp_tx, &packet_size, &packet);
if (r < 0)
return r;
return lldp_tx_send_packet(lldp_tx, packet_size, packet);
}
int sd_lldp_tx_attach_event(sd_lldp_tx *lldp_tx, sd_event *event, int64_t priority) {
int r;
assert_return(lldp_tx, -EINVAL);
assert_return(!lldp_tx->event, -EBUSY);
if (event)
lldp_tx->event = sd_event_ref(event);
else {
r = sd_event_default(&lldp_tx->event);
if (r < 0)
return r;
}
lldp_tx->event_priority = priority;
return 0;
}
int sd_lldp_tx_detach_event(sd_lldp_tx *lldp_tx) {
assert_return(lldp_tx, -EINVAL);
lldp_tx->timer_event_source = sd_event_source_disable_unref(lldp_tx->timer_event_source);
lldp_tx->event = sd_event_unref(lldp_tx->event);
return 0;
}
static usec_t lldp_tx_get_delay(sd_lldp_tx *lldp_tx) {
assert(lldp_tx);
return usec_add(lldp_tx->fast_tx > 0 ? LLDP_FAST_TX_INTERVAL_USEC : LLDP_TX_INTERVAL_USEC,
(usec_t) random_u64() % LLDP_TX_JITTER_USEC);
}
static int lldp_tx_reset_timer(sd_lldp_tx *lldp_tx) {
usec_t delay;
int r;
assert(lldp_tx);
assert(lldp_tx->timer_event_source);
delay = lldp_tx_get_delay(lldp_tx);
r = sd_event_source_set_time_relative(lldp_tx->timer_event_source, delay);
if (r < 0)
return r;
return sd_event_source_set_enabled(lldp_tx->timer_event_source, SD_EVENT_ONESHOT);
}
static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
sd_lldp_tx *lldp_tx = ASSERT_PTR(userdata);
int r;
r = lldp_tx_send(lldp_tx);
if (r < 0)
log_lldp_tx_errno(lldp_tx, r, "Failed to send packet, ignoring: %m");
if (lldp_tx->fast_tx > 0)
lldp_tx->fast_tx--;
r = lldp_tx_reset_timer(lldp_tx);
if (r < 0)
log_lldp_tx_errno(lldp_tx, r, "Failed to reset timer: %m");
return 0;
}
int sd_lldp_tx_is_running(sd_lldp_tx *lldp_tx) {
int enabled;
if (!lldp_tx)
return 0;
if (!lldp_tx->timer_event_source)
return 0;
if (sd_event_source_get_enabled(lldp_tx->timer_event_source, &enabled) < 0)
return 0;
return enabled == SD_EVENT_ONESHOT;
}
int sd_lldp_tx_stop(sd_lldp_tx *lldp_tx) {
if (!lldp_tx)
return 0;
if (!lldp_tx->timer_event_source)
return 0;
(void) sd_event_source_set_enabled(lldp_tx->timer_event_source, SD_EVENT_OFF);
return 1;
}
int sd_lldp_tx_start(sd_lldp_tx *lldp_tx) {
usec_t delay;
int r;
assert_return(lldp_tx, -EINVAL);
assert_return(lldp_tx->event, -EINVAL);
assert_return(lldp_tx->ifindex > 0, -EINVAL);
assert_return(lldp_tx->mode >= 0 && lldp_tx->mode < _SD_LLDP_MULTICAST_MODE_MAX, -EINVAL);
assert_return(!ether_addr_is_null(&lldp_tx->hwaddr), -EINVAL);
if (sd_lldp_tx_is_running(lldp_tx))
return 0;
lldp_tx->fast_tx = LLDP_FAST_TX_INIT;
if (lldp_tx->timer_event_source) {
r = lldp_tx_reset_timer(lldp_tx);
if (r < 0)
return log_lldp_tx_errno(lldp_tx, r, "Failed to re-enable timer: %m");
return 0;
}
delay = lldp_tx_get_delay(lldp_tx);
r = sd_event_add_time_relative(lldp_tx->event, &lldp_tx->timer_event_source,
CLOCK_BOOTTIME, delay, 0,
on_timer_event, lldp_tx);
if (r < 0)
return r;
(void) sd_event_source_set_description(lldp_tx->timer_event_source, "lldp-tx-timer");
(void) sd_event_source_set_priority(lldp_tx->timer_event_source, lldp_tx->event_priority);
return 0;
}
| 20,112 | 30.976153 | 125 |
c
|
null |
systemd-main/src/libsystemd-network/sd-ndisc.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <netinet/icmp6.h>
#include <netinet/in.h>
#include "sd-ndisc.h"
#include "alloc-util.h"
#include "event-util.h"
#include "fd-util.h"
#include "icmp6-util.h"
#include "in-addr-util.h"
#include "memory-util.h"
#include "ndisc-internal.h"
#include "ndisc-router.h"
#include "network-common.h"
#include "random-util.h"
#include "socket-util.h"
#include "string-table.h"
#include "string-util.h"
#define NDISC_TIMEOUT_NO_RA_USEC (NDISC_ROUTER_SOLICITATION_INTERVAL * NDISC_MAX_ROUTER_SOLICITATIONS)
static const char * const ndisc_event_table[_SD_NDISC_EVENT_MAX] = {
[SD_NDISC_EVENT_TIMEOUT] = "timeout",
[SD_NDISC_EVENT_ROUTER] = "router",
};
DEFINE_STRING_TABLE_LOOKUP(ndisc_event, sd_ndisc_event_t);
static void ndisc_callback(sd_ndisc *ndisc, sd_ndisc_event_t event, sd_ndisc_router *rt) {
assert(ndisc);
assert(event >= 0 && event < _SD_NDISC_EVENT_MAX);
if (!ndisc->callback)
return (void) log_ndisc(ndisc, "Received '%s' event.", ndisc_event_to_string(event));
log_ndisc(ndisc, "Invoking callback for '%s' event.", ndisc_event_to_string(event));
ndisc->callback(ndisc, event, rt, ndisc->userdata);
}
int sd_ndisc_set_callback(
sd_ndisc *nd,
sd_ndisc_callback_t callback,
void *userdata) {
assert_return(nd, -EINVAL);
nd->callback = callback;
nd->userdata = userdata;
return 0;
}
int sd_ndisc_set_ifindex(sd_ndisc *nd, int ifindex) {
assert_return(nd, -EINVAL);
assert_return(ifindex > 0, -EINVAL);
assert_return(nd->fd < 0, -EBUSY);
nd->ifindex = ifindex;
return 0;
}
int sd_ndisc_set_ifname(sd_ndisc *nd, const char *ifname) {
assert_return(nd, -EINVAL);
assert_return(ifname, -EINVAL);
if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
return -EINVAL;
return free_and_strdup(&nd->ifname, ifname);
}
int sd_ndisc_get_ifname(sd_ndisc *nd, const char **ret) {
int r;
assert_return(nd, -EINVAL);
r = get_ifname(nd->ifindex, &nd->ifname);
if (r < 0)
return r;
if (ret)
*ret = nd->ifname;
return 0;
}
int sd_ndisc_set_mac(sd_ndisc *nd, const struct ether_addr *mac_addr) {
assert_return(nd, -EINVAL);
if (mac_addr)
nd->mac_addr = *mac_addr;
else
zero(nd->mac_addr);
return 0;
}
int sd_ndisc_attach_event(sd_ndisc *nd, sd_event *event, int64_t priority) {
int r;
assert_return(nd, -EINVAL);
assert_return(nd->fd < 0, -EBUSY);
assert_return(!nd->event, -EBUSY);
if (event)
nd->event = sd_event_ref(event);
else {
r = sd_event_default(&nd->event);
if (r < 0)
return 0;
}
nd->event_priority = priority;
return 0;
}
int sd_ndisc_detach_event(sd_ndisc *nd) {
assert_return(nd, -EINVAL);
assert_return(nd->fd < 0, -EBUSY);
nd->event = sd_event_unref(nd->event);
return 0;
}
sd_event *sd_ndisc_get_event(sd_ndisc *nd) {
assert_return(nd, NULL);
return nd->event;
}
static void ndisc_reset(sd_ndisc *nd) {
assert(nd);
(void) event_source_disable(nd->timeout_event_source);
(void) event_source_disable(nd->timeout_no_ra);
nd->retransmit_time = 0;
nd->recv_event_source = sd_event_source_disable_unref(nd->recv_event_source);
nd->fd = safe_close(nd->fd);
}
static sd_ndisc *ndisc_free(sd_ndisc *nd) {
assert(nd);
ndisc_reset(nd);
sd_event_source_unref(nd->timeout_event_source);
sd_event_source_unref(nd->timeout_no_ra);
sd_ndisc_detach_event(nd);
free(nd->ifname);
return mfree(nd);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_ndisc, sd_ndisc, ndisc_free);
int sd_ndisc_new(sd_ndisc **ret) {
_cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
assert_return(ret, -EINVAL);
nd = new(sd_ndisc, 1);
if (!nd)
return -ENOMEM;
*nd = (sd_ndisc) {
.n_ref = 1,
.fd = -EBADF,
};
*ret = TAKE_PTR(nd);
return 0;
}
static int ndisc_handle_datagram(sd_ndisc *nd, sd_ndisc_router *rt) {
int r;
assert(nd);
assert(rt);
r = ndisc_router_parse(nd, rt);
if (r < 0)
return r;
log_ndisc(nd, "Received Router Advertisement: flags %s preference %s lifetime %" PRIu16 " sec",
rt->flags & ND_RA_FLAG_MANAGED ? "MANAGED" : rt->flags & ND_RA_FLAG_OTHER ? "OTHER" : "none",
rt->preference == SD_NDISC_PREFERENCE_HIGH ? "high" : rt->preference == SD_NDISC_PREFERENCE_LOW ? "low" : "medium",
rt->lifetime);
ndisc_callback(nd, SD_NDISC_EVENT_ROUTER, rt);
return 0;
}
static int ndisc_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_ndisc_router_unrefp) sd_ndisc_router *rt = NULL;
sd_ndisc *nd = ASSERT_PTR(userdata);
ssize_t buflen;
int r;
assert(s);
assert(nd->event);
buflen = next_datagram_size_fd(fd);
if (buflen < 0) {
if (ERRNO_IS_TRANSIENT(buflen) || ERRNO_IS_DISCONNECT(buflen))
return 0;
log_ndisc_errno(nd, buflen, "Failed to determine datagram size to read, ignoring: %m");
return 0;
}
rt = ndisc_router_new(buflen);
if (!rt)
return -ENOMEM;
r = icmp6_receive(fd, NDISC_ROUTER_RAW(rt), rt->raw_size, &rt->address, &rt->timestamp);
if (r < 0) {
if (ERRNO_IS_TRANSIENT(r) || ERRNO_IS_DISCONNECT(r))
return 0;
switch (r) {
case -EADDRNOTAVAIL:
log_ndisc(nd, "Received RA from non-link-local address %s. Ignoring.",
IN6_ADDR_TO_STRING(&rt->address));
break;
case -EMULTIHOP:
log_ndisc(nd, "Received RA with invalid hop limit. Ignoring.");
break;
case -EPFNOSUPPORT:
log_ndisc(nd, "Received invalid source address from ICMPv6 socket. Ignoring.");
break;
default:
log_ndisc_errno(nd, r, "Unexpected error while reading from ICMPv6, ignoring: %m");
break;
}
return 0;
}
(void) event_source_disable(nd->timeout_event_source);
(void) ndisc_handle_datagram(nd, rt);
return 0;
}
static usec_t ndisc_timeout_compute_random(usec_t val) {
/* compute a time that is random within ±10% of the given value */
return val - val / 10 +
(random_u64() % (2 * USEC_PER_SEC)) * val / 10 / USEC_PER_SEC;
}
static int ndisc_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
sd_ndisc *nd = ASSERT_PTR(userdata);
usec_t time_now;
int r;
assert(s);
assert(nd->event);
assert_se(sd_event_now(nd->event, CLOCK_BOOTTIME, &time_now) >= 0);
if (!nd->retransmit_time)
nd->retransmit_time = ndisc_timeout_compute_random(NDISC_ROUTER_SOLICITATION_INTERVAL);
else {
if (nd->retransmit_time > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 2)
nd->retransmit_time = ndisc_timeout_compute_random(NDISC_MAX_ROUTER_SOLICITATION_INTERVAL);
else
nd->retransmit_time += ndisc_timeout_compute_random(nd->retransmit_time);
}
r = event_reset_time(nd->event, &nd->timeout_event_source,
CLOCK_BOOTTIME,
time_now + nd->retransmit_time, 10 * USEC_PER_MSEC,
ndisc_timeout, nd,
nd->event_priority, "ndisc-timeout-no-ra", true);
if (r < 0)
goto fail;
r = icmp6_send_router_solicitation(nd->fd, &nd->mac_addr);
if (r < 0)
log_ndisc_errno(nd, r, "Failed to send Router Solicitation, next solicitation in %s, ignoring: %m",
FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_SEC));
else
log_ndisc(nd, "Sent Router Solicitation, next solicitation in %s",
FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_SEC));
return 0;
fail:
(void) sd_ndisc_stop(nd);
return 0;
}
static int ndisc_timeout_no_ra(sd_event_source *s, uint64_t usec, void *userdata) {
sd_ndisc *nd = ASSERT_PTR(userdata);
assert(s);
log_ndisc(nd, "No RA received before link confirmation timeout");
(void) event_source_disable(nd->timeout_no_ra);
ndisc_callback(nd, SD_NDISC_EVENT_TIMEOUT, NULL);
return 0;
}
int sd_ndisc_stop(sd_ndisc *nd) {
if (!nd)
return 0;
if (nd->fd < 0)
return 0;
log_ndisc(nd, "Stopping IPv6 Router Solicitation client");
ndisc_reset(nd);
return 1;
}
int sd_ndisc_start(sd_ndisc *nd) {
int r;
usec_t time_now;
assert_return(nd, -EINVAL);
assert_return(nd->event, -EINVAL);
assert_return(nd->ifindex > 0, -EINVAL);
if (nd->fd >= 0)
return 0;
assert(!nd->recv_event_source);
r = sd_event_now(nd->event, CLOCK_BOOTTIME, &time_now);
if (r < 0)
goto fail;
nd->fd = icmp6_bind_router_solicitation(nd->ifindex);
if (nd->fd < 0)
return nd->fd;
r = sd_event_add_io(nd->event, &nd->recv_event_source, nd->fd, EPOLLIN, ndisc_recv, nd);
if (r < 0)
goto fail;
r = sd_event_source_set_priority(nd->recv_event_source, nd->event_priority);
if (r < 0)
goto fail;
(void) sd_event_source_set_description(nd->recv_event_source, "ndisc-receive-message");
r = event_reset_time(nd->event, &nd->timeout_event_source,
CLOCK_BOOTTIME,
time_now + USEC_PER_SEC / 2, 1 * USEC_PER_SEC, /* See RFC 8415 sec. 18.2.1 */
ndisc_timeout, nd,
nd->event_priority, "ndisc-timeout", true);
if (r < 0)
goto fail;
r = event_reset_time(nd->event, &nd->timeout_no_ra,
CLOCK_BOOTTIME,
time_now + NDISC_TIMEOUT_NO_RA_USEC, 10 * USEC_PER_MSEC,
ndisc_timeout_no_ra, nd,
nd->event_priority, "ndisc-timeout-no-ra", true);
if (r < 0)
goto fail;
log_ndisc(nd, "Started IPv6 Router Solicitation client");
return 1;
fail:
ndisc_reset(nd);
return r;
}
| 11,323 | 28.56658 | 133 |
c
|
null |
systemd-main/src/libsystemd-network/test-acd.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/veth.h>
#include <net/if.h>
#include "sd-event.h"
#include "sd-ipv4acd.h"
#include "sd-netlink.h"
#include "in-addr-util.h"
#include "tests.h"
static void acd_handler(sd_ipv4acd *acd, int event, void *userdata) {
assert_se(acd);
switch (event) {
case SD_IPV4ACD_EVENT_BIND:
log_info("bound");
break;
case SD_IPV4ACD_EVENT_CONFLICT:
log_info("conflict");
break;
case SD_IPV4ACD_EVENT_STOP:
log_error("the client was stopped");
break;
default:
assert_not_reached();
}
}
static int client_run(int ifindex, const struct in_addr *pa, const struct ether_addr *ha, sd_event *e) {
sd_ipv4acd *acd;
assert_se(sd_ipv4acd_new(&acd) >= 0);
assert_se(sd_ipv4acd_attach_event(acd, e, 0) >= 0);
assert_se(sd_ipv4acd_set_ifindex(acd, ifindex) >= 0);
assert_se(sd_ipv4acd_set_mac(acd, ha) >= 0);
assert_se(sd_ipv4acd_set_address(acd, pa) >= 0);
assert_se(sd_ipv4acd_set_callback(acd, acd_handler, NULL) >= 0);
log_info("starting IPv4ACD client");
assert_se(sd_ipv4acd_start(acd, true) >= 0);
assert_se(sd_event_loop(e) >= 0);
assert_se(!sd_ipv4acd_unref(acd));
return EXIT_SUCCESS;
}
static int test_acd(const char *ifname, const char *address) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL;
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL, *reply = NULL;
union in_addr_union pa;
struct ether_addr ha;
int ifindex;
assert_se(in_addr_from_string(AF_INET, address, &pa) >= 0);
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_netlink_open(&rtnl) >= 0);
assert_se(sd_netlink_attach_event(rtnl, e, 0) >= 0);
assert_se(sd_rtnl_message_new_link(rtnl, &m, RTM_GETLINK, 0) >= 0);
assert_se(sd_netlink_message_append_string(m, IFLA_IFNAME, ifname) >= 0);
assert_se(sd_netlink_call(rtnl, m, 0, &reply) >= 0);
assert_se(sd_rtnl_message_link_get_ifindex(reply, &ifindex) >= 0);
assert_se(sd_netlink_message_read_ether_addr(reply, IFLA_ADDRESS, &ha) >= 0);
client_run(ifindex, &pa.in, &ha, e);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
test_setup_logging(LOG_DEBUG);
if (argc == 3)
return test_acd(argv[1], argv[2]);
else {
log_error("This program takes two arguments.\n"
"\t %s <ifname> <IPv4 address>", program_invocation_short_name);
return EXIT_FAILURE;
}
}
| 2,874 | 29.263158 | 104 |
c
|
null |
systemd-main/src/libsystemd-network/test-dhcp-client.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2013 Intel Corporation. All rights reserved.
***/
#include <errno.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#if HAVE_VALGRIND_VALGRIND_H
# include <valgrind/valgrind.h>
#endif
#include "sd-dhcp-client.h"
#include "sd-event.h"
#include "alloc-util.h"
#include "dhcp-identifier.h"
#include "dhcp-internal.h"
#include "dhcp-protocol.h"
#include "ether-addr-util.h"
#include "fd-util.h"
#include "random-util.h"
#include "tests.h"
static struct hw_addr_data hw_addr = {
.length = ETH_ALEN,
.ether = {{ 'A', 'B', 'C', '1', '2', '3' }},
}, bcast_addr = {
.length = ETH_ALEN,
.ether = {{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }},
};
typedef int (*test_callback_recv_t)(size_t size, DHCPMessage *dhcp);
static bool verbose = true;
static int test_fd[2];
static test_callback_recv_t callback_recv;
static be32_t xid;
static void test_request_basic(sd_event *e) {
int r;
sd_dhcp_client *client;
if (verbose)
printf("* %s\n", __func__);
/* Initialize client without Anonymize settings. */
r = sd_dhcp_client_new(&client, false);
assert_se(r >= 0);
assert_se(client);
r = sd_dhcp_client_attach_event(client, e, 0);
assert_se(r >= 0);
assert_se(sd_dhcp_client_set_request_option(NULL, 0) == -EINVAL);
assert_se(sd_dhcp_client_set_request_address(NULL, NULL) == -EINVAL);
assert_se(sd_dhcp_client_set_ifindex(NULL, 0) == -EINVAL);
assert_se(sd_dhcp_client_set_ifindex(client, 15) == 0);
assert_se(sd_dhcp_client_set_ifindex(client, -42) == -EINVAL);
assert_se(sd_dhcp_client_set_ifindex(client, -1) == -EINVAL);
assert_se(sd_dhcp_client_set_ifindex(client, 0) == -EINVAL);
assert_se(sd_dhcp_client_set_ifindex(client, 1) == 0);
assert_se(sd_dhcp_client_set_hostname(client, "host") == 1);
assert_se(sd_dhcp_client_set_hostname(client, "host.domain") == 1);
assert_se(sd_dhcp_client_set_hostname(client, NULL) == 1);
assert_se(sd_dhcp_client_set_hostname(client, "~host") == -EINVAL);
assert_se(sd_dhcp_client_set_hostname(client, "~host.domain") == -EINVAL);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_SUBNET_MASK) == 0);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_ROUTER) == 0);
/* This PRL option is not set when using Anonymize, but in this test
* Anonymize settings are not being used. */
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME) == 0);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME) == 0);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_DOMAIN_NAME_SERVER) == 0);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PAD) == -EINVAL);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_END) == -EINVAL);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_MESSAGE_TYPE) == -EINVAL);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_OVERLOAD) == -EINVAL);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST) == -EINVAL);
/* RFC7844: option 33 (SD_DHCP_OPTION_STATIC_ROUTE) is set in the
* default PRL when using Anonymize, so it is changed to other option
* that is not set by default, to check that it was set successfully.
* Options not set by default (using or not anonymize) are option 17
* (SD_DHCP_OPTION_ROOT_PATH) and 42 (SD_DHCP_OPTION_NTP_SERVER) */
assert_se(sd_dhcp_client_set_request_option(client, 17) == 1);
assert_se(sd_dhcp_client_set_request_option(client, 17) == 0);
assert_se(sd_dhcp_client_set_request_option(client, 42) == 1);
assert_se(sd_dhcp_client_set_request_option(client, 17) == 0);
sd_dhcp_client_unref(client);
}
static void test_request_anonymize(sd_event *e) {
int r;
sd_dhcp_client *client;
if (verbose)
printf("* %s\n", __func__);
/* Initialize client with Anonymize settings. */
r = sd_dhcp_client_new(&client, true);
assert_se(r >= 0);
assert_se(client);
r = sd_dhcp_client_attach_event(client, e, 0);
assert_se(r >= 0);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_NETBIOS_NAME_SERVER) == 0);
/* This PRL option is not set when using Anonymize */
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_HOST_NAME) == 1);
assert_se(sd_dhcp_client_set_request_option(client, SD_DHCP_OPTION_PARAMETER_REQUEST_LIST) == -EINVAL);
/* RFC7844: option 101 (SD_DHCP_OPTION_NEW_TZDB_TIMEZONE) is not set in the
* default PRL when using Anonymize, */
assert_se(sd_dhcp_client_set_request_option(client, 101) == 1);
assert_se(sd_dhcp_client_set_request_option(client, 101) == 0);
sd_dhcp_client_unref(client);
}
static void test_checksum(void) {
uint8_t buf[20] = {
0x45, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
0x40, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff
};
if (verbose)
printf("* %s\n", __func__);
assert_se(dhcp_packet_checksum((uint8_t*)&buf, 20) == be16toh(0x78ae));
}
static void test_dhcp_identifier_set_iaid(void) {
uint32_t iaid_legacy;
be32_t iaid;
assert_se(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy = */ true, &iaid_legacy) >= 0);
assert_se(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy = */ false, &iaid) >= 0);
/* we expect, that the MAC address was hashed. The legacy value is in native
* endianness. */
assert_se(iaid_legacy == 0x8dde4ba8u);
assert_se(iaid == htole32(0x8dde4ba8u));
#if __BYTE_ORDER == __LITTLE_ENDIAN
assert_se(iaid == iaid_legacy);
#else
assert_se(iaid == bswap_32(iaid_legacy));
#endif
}
static int check_options(uint8_t code, uint8_t len, const void *option, void *userdata) {
switch (code) {
case SD_DHCP_OPTION_CLIENT_IDENTIFIER:
{
uint32_t iaid;
struct duid duid;
size_t duid_len;
assert_se(dhcp_identifier_set_duid_en(/* test_mode = */ true, &duid, &duid_len) >= 0);
assert_se(dhcp_identifier_set_iaid(NULL, &hw_addr, /* legacy = */ true, &iaid) >= 0);
assert_se(len == sizeof(uint8_t) + sizeof(uint32_t) + duid_len);
assert_se(len == 19);
assert_se(((uint8_t*) option)[0] == 0xff);
assert_se(memcmp((uint8_t*) option + 1, &iaid, sizeof(iaid)) == 0);
assert_se(memcmp((uint8_t*) option + 5, &duid, duid_len) == 0);
break;
}
default:
break;
}
return 0;
}
int dhcp_network_send_raw_socket(int s, const union sockaddr_union *link, const void *packet, size_t len) {
size_t size;
_cleanup_free_ DHCPPacket *discover = NULL;
uint16_t ip_check, udp_check;
assert_se(s >= 0);
assert_se(packet);
size = sizeof(DHCPPacket);
assert_se(len > size);
discover = memdup(packet, len);
assert_se(discover->ip.ttl == IPDEFTTL);
assert_se(discover->ip.protocol == IPPROTO_UDP);
assert_se(discover->ip.saddr == INADDR_ANY);
assert_se(discover->ip.daddr == INADDR_BROADCAST);
assert_se(discover->udp.source == be16toh(DHCP_PORT_CLIENT));
assert_se(discover->udp.dest == be16toh(DHCP_PORT_SERVER));
ip_check = discover->ip.check;
discover->ip.ttl = 0;
discover->ip.check = discover->udp.len;
udp_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip.ttl, len - 8);
assert_se(udp_check == 0xffff);
discover->ip.ttl = IPDEFTTL;
discover->ip.check = ip_check;
ip_check = ~dhcp_packet_checksum((uint8_t*)&discover->ip, sizeof(discover->ip));
assert_se(ip_check == 0xffff);
assert_se(discover->dhcp.xid);
assert_se(memcmp(discover->dhcp.chaddr, hw_addr.bytes, hw_addr.length) == 0);
size = len - sizeof(struct iphdr) - sizeof(struct udphdr);
assert_se(callback_recv);
callback_recv(size, &discover->dhcp);
return 575;
}
int dhcp_network_bind_raw_socket(
int ifindex,
union sockaddr_union *link,
uint32_t id,
const struct hw_addr_data *_hw_addr,
const struct hw_addr_data *_bcast_addr,
uint16_t arp_type,
uint16_t port,
bool so_priority_set,
int so_priority) {
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
return -errno;
return test_fd[0];
}
int dhcp_network_bind_udp_socket(int ifindex, be32_t address, uint16_t port, int ip_service_type) {
int fd;
fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
if (fd < 0)
return -errno;
return fd;
}
int dhcp_network_send_udp_socket(int s, be32_t address, uint16_t port, const void *packet, size_t len) {
return 0;
}
static int test_discover_message_verify(size_t size, struct DHCPMessage *dhcp) {
int res;
res = dhcp_option_parse(dhcp, size, check_options, NULL, NULL);
assert_se(res == DHCP_DISCOVER);
if (verbose)
printf(" recv DHCP Discover 0x%08x\n", be32toh(dhcp->xid));
return 0;
}
static void test_discover_message(sd_event *e) {
sd_dhcp_client *client;
int res, r;
if (verbose)
printf("* %s\n", __func__);
r = sd_dhcp_client_new(&client, false);
assert_se(r >= 0);
assert_se(client);
r = sd_dhcp_client_attach_event(client, e, 0);
assert_se(r >= 0);
assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0);
assert_se(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER) >= 0);
dhcp_client_set_test_mode(client, true);
assert_se(sd_dhcp_client_set_request_option(client, 248) >= 0);
callback_recv = test_discover_message_verify;
res = sd_dhcp_client_start(client);
assert_se(IN_SET(res, 0, -EINPROGRESS));
sd_event_run(e, UINT64_MAX);
sd_dhcp_client_stop(client);
sd_dhcp_client_unref(client);
test_fd[1] = safe_close(test_fd[1]);
callback_recv = NULL;
}
static uint8_t test_addr_acq_offer[] = {
0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
0x6f, 0x95, 0x2f, 0x30, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x02, 0x36,
0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static uint8_t test_addr_acq_ack[] = {
0x45, 0x10, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00,
0x80, 0x11, 0xb3, 0x84, 0xc0, 0xa8, 0x02, 0x01,
0xc0, 0xa8, 0x02, 0xbf, 0x00, 0x43, 0x00, 0x44,
0x01, 0x34, 0x00, 0x00, 0x02, 0x01, 0x06, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8, 0x02, 0xbf,
0xc0, 0xa8, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36,
0x04, 0xc0, 0xa8, 0x02, 0x01, 0x33, 0x04, 0x00,
0x00, 0x02, 0x58, 0x01, 0x04, 0xff, 0xff, 0xff,
0x00, 0x2a, 0x04, 0xc0, 0xa8, 0x02, 0x01, 0x0f,
0x09, 0x6c, 0x61, 0x62, 0x2e, 0x69, 0x6e, 0x74,
0x72, 0x61, 0x03, 0x04, 0xc0, 0xa8, 0x02, 0x01,
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static int test_addr_acq_acquired(sd_dhcp_client *client, int event,
void *userdata) {
sd_event *e = userdata;
sd_dhcp_lease *lease;
struct in_addr addr;
const struct in_addr *addrs;
assert_se(client);
assert_se(IN_SET(event, SD_DHCP_CLIENT_EVENT_IP_ACQUIRE, SD_DHCP_CLIENT_EVENT_SELECTING));
assert_se(sd_dhcp_client_get_lease(client, &lease) >= 0);
assert_se(lease);
assert_se(sd_dhcp_lease_get_address(lease, &addr) >= 0);
assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[44],
sizeof(addr.s_addr)) == 0);
assert_se(sd_dhcp_lease_get_netmask(lease, &addr) >= 0);
assert_se(memcmp(&addr.s_addr, &test_addr_acq_ack[285],
sizeof(addr.s_addr)) == 0);
assert_se(sd_dhcp_lease_get_router(lease, &addrs) == 1);
assert_se(memcmp(&addrs[0].s_addr, &test_addr_acq_ack[308],
sizeof(addrs[0].s_addr)) == 0);
if (verbose)
printf(" DHCP address acquired\n");
sd_event_exit(e, 0);
return 0;
}
static int test_addr_acq_recv_request(size_t size, DHCPMessage *request) {
uint16_t udp_check = 0;
uint8_t *msg_bytes = (uint8_t *)request;
int res;
res = dhcp_option_parse(request, size, check_options, NULL, NULL);
assert_se(res == DHCP_REQUEST);
assert_se(xid == request->xid);
assert_se(msg_bytes[size - 1] == SD_DHCP_OPTION_END);
if (verbose)
printf(" recv DHCP Request 0x%08x\n", be32toh(xid));
memcpy(&test_addr_acq_ack[26], &udp_check, sizeof(udp_check));
memcpy(&test_addr_acq_ack[32], &xid, sizeof(xid));
memcpy(&test_addr_acq_ack[56], hw_addr.bytes, hw_addr.length);
callback_recv = NULL;
res = write(test_fd[1], test_addr_acq_ack,
sizeof(test_addr_acq_ack));
assert_se(res == sizeof(test_addr_acq_ack));
if (verbose)
printf(" send DHCP Ack\n");
return 0;
};
static int test_addr_acq_recv_discover(size_t size, DHCPMessage *discover) {
uint16_t udp_check = 0;
uint8_t *msg_bytes = (uint8_t *)discover;
int res;
res = dhcp_option_parse(discover, size, check_options, NULL, NULL);
assert_se(res == DHCP_DISCOVER);
assert_se(msg_bytes[size - 1] == SD_DHCP_OPTION_END);
xid = discover->xid;
if (verbose)
printf(" recv DHCP Discover 0x%08x\n", be32toh(xid));
memcpy(&test_addr_acq_offer[26], &udp_check, sizeof(udp_check));
memcpy(&test_addr_acq_offer[32], &xid, sizeof(xid));
memcpy(&test_addr_acq_offer[56], hw_addr.bytes, hw_addr.length);
callback_recv = test_addr_acq_recv_request;
res = write(test_fd[1], test_addr_acq_offer,
sizeof(test_addr_acq_offer));
assert_se(res == sizeof(test_addr_acq_offer));
if (verbose)
printf(" sent DHCP Offer\n");
return 0;
}
static void test_addr_acq(sd_event *e) {
sd_dhcp_client *client;
int res, r;
if (verbose)
printf("* %s\n", __func__);
r = sd_dhcp_client_new(&client, false);
assert_se(r >= 0);
assert_se(client);
r = sd_dhcp_client_attach_event(client, e, 0);
assert_se(r >= 0);
assert_se(sd_dhcp_client_set_ifindex(client, 42) >= 0);
assert_se(sd_dhcp_client_set_mac(client, hw_addr.bytes, bcast_addr.bytes, hw_addr.length, ARPHRD_ETHER) >= 0);
dhcp_client_set_test_mode(client, true);
assert_se(sd_dhcp_client_set_callback(client, test_addr_acq_acquired, e) >= 0);
callback_recv = test_addr_acq_recv_discover;
assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
2 * USEC_PER_SEC, 0,
NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
res = sd_dhcp_client_start(client);
assert_se(IN_SET(res, 0, -EINPROGRESS));
assert_se(sd_event_loop(e) >= 0);
assert_se(sd_dhcp_client_set_callback(client, NULL, NULL) >= 0);
assert_se(sd_dhcp_client_stop(client) >= 0);
sd_dhcp_client_unref(client);
test_fd[1] = safe_close(test_fd[1]);
callback_recv = NULL;
xid = 0;
}
int main(int argc, char *argv[]) {
_cleanup_(sd_event_unrefp) sd_event *e;
test_setup_logging(LOG_DEBUG);
assert_se(sd_event_new(&e) >= 0);
test_request_basic(e);
test_request_anonymize(e);
test_checksum();
test_dhcp_identifier_set_iaid();
test_discover_message(e);
test_addr_acq(e);
#if HAVE_VALGRIND_VALGRIND_H
/* Make sure the async_close thread has finished.
* valgrind would report some of the phread_* structures
* as not cleaned up properly. */
if (RUNNING_ON_VALGRIND)
sleep(1);
#endif
return 0;
}
| 20,707 | 35.846975 | 118 |
c
|
null |
systemd-main/src/libsystemd-network/test-dhcp-option.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <net/if_arp.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "alloc-util.h"
#include "dhcp-internal.h"
#include "dhcp-protocol.h"
#include "macro.h"
#include "memory-util.h"
struct option_desc {
uint8_t sname[64];
int snamelen;
uint8_t file[128];
int filelen;
uint8_t options[128];
int len;
bool success;
int filepos;
int snamepos;
int pos;
};
static bool verbose = false;
static struct option_desc option_tests[] = {
{ {}, 0, {}, 0, { 42, 5, 65, 66, 67, 68, 69 }, 7, false, },
{ {}, 0, {}, 0, { 42, 5, 65, 66, 67, 68, 69, 0, 0,
SD_DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 12, true, },
{ {}, 0, {}, 0, { 8, 255, 70, 71, 72 }, 5, false, },
{ {}, 0, {}, 0, { 0x35, 0x01, 0x05, 0x36, 0x04, 0x01, 0x00, 0xa8,
0xc0, 0x33, 0x04, 0x00, 0x01, 0x51, 0x80, 0x01,
0x04, 0xff, 0xff, 0xff, 0x00, 0x03, 0x04, 0xc0,
0xa8, 0x00, 0x01, 0x06, 0x04, 0xc0, 0xa8, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
40, true, },
{ {}, 0, {}, 0, { SD_DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_OFFER,
42, 3, 0, 0, 0 }, 8, true, },
{ {}, 0, {}, 0, { 42, 2, 1, 2, 44 }, 5, false, },
{ {}, 0,
{ 222, 3, 1, 2, 3, SD_DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_NAK }, 8,
{ SD_DHCP_OPTION_OVERLOAD, 1, DHCP_OVERLOAD_FILE }, 3, true, },
{ { 1, 4, 1, 2, 3, 4, SD_DHCP_OPTION_MESSAGE_TYPE, 1, DHCP_ACK }, 9,
{ 222, 3, 1, 2, 3 }, 5,
{ SD_DHCP_OPTION_OVERLOAD, 1,
DHCP_OVERLOAD_FILE|DHCP_OVERLOAD_SNAME }, 3, true, },
};
static const char *dhcp_type(int type) {
switch (type) {
case DHCP_DISCOVER:
return "DHCPDISCOVER";
case DHCP_OFFER:
return "DHCPOFFER";
case DHCP_REQUEST:
return "DHCPREQUEST";
case DHCP_DECLINE:
return "DHCPDECLINE";
case DHCP_ACK:
return "DHCPACK";
case DHCP_NAK:
return "DHCPNAK";
case DHCP_RELEASE:
return "DHCPRELEASE";
default:
return "unknown";
}
}
static void test_invalid_buffer_length(void) {
DHCPMessage message;
assert_se(dhcp_option_parse(&message, 0, NULL, NULL, NULL) == -EINVAL);
assert_se(dhcp_option_parse(&message, sizeof(DHCPMessage) - 1, NULL, NULL, NULL) == -EINVAL);
}
static void test_message_init(void) {
_cleanup_free_ DHCPMessage *message = NULL;
size_t optlen = 4, optoffset;
size_t len = sizeof(DHCPMessage) + optlen;
uint8_t *magic;
message = malloc0(len);
assert_se(dhcp_message_init(message, BOOTREQUEST, 0x12345678,
DHCP_DISCOVER, ARPHRD_ETHER, ETH_ALEN, (uint8_t[16]){},
optlen, &optoffset) >= 0);
assert_se(message->xid == htobe32(0x12345678));
assert_se(message->op == BOOTREQUEST);
magic = (uint8_t*)&message->magic;
assert_se(magic[0] == 99);
assert_se(magic[1] == 130);
assert_se(magic[2] == 83);
assert_se(magic[3] == 99);
assert_se(dhcp_option_parse(message, len, NULL, NULL, NULL) >= 0);
}
static DHCPMessage *create_message(uint8_t *options, uint16_t optlen,
uint8_t *file, uint8_t filelen,
uint8_t *sname, uint8_t snamelen) {
DHCPMessage *message;
size_t len = sizeof(DHCPMessage) + optlen;
message = malloc0(len);
assert_se(message);
memcpy_safe(&message->options, options, optlen);
memcpy_safe(&message->file, file, filelen);
memcpy_safe(&message->sname, sname, snamelen);
return message;
}
static void test_ignore_opts(uint8_t *descoption, int *descpos, int *desclen) {
assert_se(*descpos >= 0);
while (*descpos < *desclen) {
switch (descoption[*descpos]) {
case SD_DHCP_OPTION_PAD:
*descpos += 1;
break;
case SD_DHCP_OPTION_MESSAGE_TYPE:
case SD_DHCP_OPTION_OVERLOAD:
*descpos += 3;
break;
default:
return;
}
}
}
static int test_options_cb(uint8_t code, uint8_t len, const void *option, void *userdata) {
struct option_desc *desc = userdata;
uint8_t *descoption = NULL;
int *desclen = NULL, *descpos = NULL;
uint8_t optcode = 0;
uint8_t optlen = 0;
assert_se((!desc && !code && !len) || desc);
if (!desc)
return -EINVAL;
assert_se(code != SD_DHCP_OPTION_PAD);
assert_se(code != SD_DHCP_OPTION_END);
assert_se(code != SD_DHCP_OPTION_MESSAGE_TYPE);
assert_se(code != SD_DHCP_OPTION_OVERLOAD);
while (desc->pos >= 0 || desc->filepos >= 0 || desc->snamepos >= 0) {
if (desc->pos >= 0) {
descoption = &desc->options[0];
desclen = &desc->len;
descpos = &desc->pos;
} else if (desc->filepos >= 0) {
descoption = &desc->file[0];
desclen = &desc->filelen;
descpos = &desc->filepos;
} else if (desc->snamepos >= 0) {
descoption = &desc->sname[0];
desclen = &desc->snamelen;
descpos = &desc->snamepos;
}
assert_se(descoption && desclen && descpos);
if (*desclen)
test_ignore_opts(descoption, descpos, desclen);
if (*descpos < *desclen)
break;
if (*descpos == *desclen)
*descpos = -1;
}
assert_se(descpos);
assert_se(*descpos != -1);
optcode = descoption[*descpos];
optlen = descoption[*descpos + 1];
if (verbose)
printf("DHCP code %2d(%2d) len %2d(%2d) ", code, optcode,
len, optlen);
assert_se(code == optcode);
assert_se(len == optlen);
for (unsigned i = 0; i < len; i++) {
if (verbose)
printf("0x%02x(0x%02x) ",
((uint8_t*) option)[i],
descoption[*descpos + 2 + i]);
assert_se(((uint8_t*) option)[i] == descoption[*descpos + 2 + i]);
}
if (verbose)
printf("\n");
*descpos += optlen + 2;
test_ignore_opts(descoption, descpos, desclen);
if (desc->pos != -1 && desc->pos == desc->len)
desc->pos = -1;
if (desc->filepos != -1 && desc->filepos == desc->filelen)
desc->filepos = -1;
if (desc->snamepos != -1 && desc->snamepos == desc->snamelen)
desc->snamepos = -1;
return 0;
}
static void test_options(struct option_desc *desc) {
uint8_t *options = NULL;
uint8_t *file = NULL;
uint8_t *sname = NULL;
int optlen = 0;
int filelen = 0;
int snamelen = 0;
int buflen = 0;
_cleanup_free_ DHCPMessage *message = NULL;
int res;
if (desc) {
file = &desc->file[0];
filelen = desc->filelen;
if (!filelen)
desc->filepos = -1;
sname = &desc->sname[0];
snamelen = desc->snamelen;
if (!snamelen)
desc->snamepos = -1;
options = &desc->options[0];
optlen = desc->len;
desc->pos = 0;
}
message = create_message(options, optlen, file, filelen,
sname, snamelen);
buflen = sizeof(DHCPMessage) + optlen;
if (!desc) {
assert_se((res = dhcp_option_parse(message, buflen, test_options_cb, NULL, NULL)) == -ENOMSG);
} else if (desc->success) {
assert_se((res = dhcp_option_parse(message, buflen, test_options_cb, desc, NULL)) >= 0);
assert_se(desc->pos == -1 && desc->filepos == -1 && desc->snamepos == -1);
} else
assert_se((res = dhcp_option_parse(message, buflen, test_options_cb, desc, NULL)) < 0);
if (verbose)
printf("DHCP type %s\n", dhcp_type(res));
}
static void test_option_removal(struct option_desc *desc) {
_cleanup_free_ DHCPMessage *message = create_message(&desc->options[0], desc->len, NULL, 0, NULL, 0);
assert_se(dhcp_option_parse(message, sizeof(DHCPMessage) + desc->len, NULL, NULL, NULL) >= 0);
assert_se((desc->len = dhcp_option_remove_option(message->options, desc->len, SD_DHCP_OPTION_MESSAGE_TYPE)) >= 0);
assert_se(dhcp_option_parse(message, sizeof(DHCPMessage) + desc->len, NULL, NULL, NULL) < 0);
}
static uint8_t the_options[64] = {
'A', 'B', 'C', 'D',
160, 2, 0x11, 0x12,
0,
31, 8, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
0,
55, 3, 0x51, 0x52, 0x53,
17, 7, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
255
};
static void test_option_set(void) {
_cleanup_free_ DHCPMessage *result = NULL;
size_t offset = 0, len, pos;
result = malloc0(sizeof(DHCPMessage) + 11);
assert_se(result);
result->options[0] = 'A';
result->options[1] = 'B';
result->options[2] = 'C';
result->options[3] = 'D';
assert_se(dhcp_option_append(result, 0, &offset, 0, SD_DHCP_OPTION_PAD,
0, NULL) == -ENOBUFS);
assert_se(offset == 0);
offset = 4;
assert_se(dhcp_option_append(result, 5, &offset, 0, SD_DHCP_OPTION_PAD,
0, NULL) == -ENOBUFS);
assert_se(offset == 4);
assert_se(dhcp_option_append(result, 6, &offset, 0, SD_DHCP_OPTION_PAD,
0, NULL) >= 0);
assert_se(offset == 5);
offset = pos = 4;
len = 11;
while (pos < len && the_options[pos] != SD_DHCP_OPTION_END) {
assert_se(dhcp_option_append(result, len, &offset, DHCP_OVERLOAD_SNAME,
the_options[pos],
the_options[pos + 1],
&the_options[pos + 2]) >= 0);
if (the_options[pos] == SD_DHCP_OPTION_PAD)
pos++;
else
pos += 2 + the_options[pos + 1];
if (pos < len)
assert_se(offset == pos);
}
for (unsigned i = 0; i < 9; i++) {
if (verbose)
printf("%2u: 0x%02x(0x%02x) (options)\n", i, result->options[i],
the_options[i]);
assert_se(result->options[i] == the_options[i]);
}
if (verbose)
printf("%2d: 0x%02x(0x%02x) (options)\n", 9, result->options[9],
(unsigned) SD_DHCP_OPTION_END);
assert_se(result->options[9] == SD_DHCP_OPTION_END);
if (verbose)
printf("%2d: 0x%02x(0x%02x) (options)\n", 10, result->options[10],
(unsigned) SD_DHCP_OPTION_PAD);
assert_se(result->options[10] == SD_DHCP_OPTION_PAD);
for (unsigned i = 0; i < pos - 8; i++) {
if (verbose)
printf("%2u: 0x%02x(0x%02x) (sname)\n", i, result->sname[i],
the_options[i + 9]);
assert_se(result->sname[i] == the_options[i + 9]);
}
if (verbose)
printf ("\n");
}
int main(int argc, char *argv[]) {
test_invalid_buffer_length();
test_message_init();
test_options(NULL);
for (unsigned i = 0; i < ELEMENTSOF(option_tests); i++)
test_options(&option_tests[i]);
test_option_set();
for (unsigned i = 0; i < ELEMENTSOF(option_tests); i++) {
struct option_desc *desc = &option_tests[i];
if (!desc->success || desc->snamelen > 0 || desc->filelen > 0)
continue;
test_option_removal(desc);
}
return 0;
}
| 12,839 | 32.524804 | 122 |
c
|
null |
systemd-main/src/libsystemd-network/test-dhcp-server.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2013 Intel Corporation. All rights reserved.
***/
#include <errno.h>
#include <net/if_arp.h>
#include "sd-dhcp-server.h"
#include "sd-event.h"
#include "dhcp-server-internal.h"
#include "tests.h"
static void test_pool(struct in_addr *address, unsigned size, int ret) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
assert_se(sd_dhcp_server_new(&server, 1) >= 0);
assert_se(sd_dhcp_server_configure_pool(server, address, 8, 0, size) == ret);
}
static int test_basic(bool bind_to_interface) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
struct in_addr address_lo = {
.s_addr = htobe32(INADDR_LOOPBACK),
};
struct in_addr address_any = {
.s_addr = htobe32(INADDR_ANY),
};
int r;
log_debug("/* %s(bind_to_interface=%s) */", __func__, yes_no(bind_to_interface));
assert_se(sd_event_new(&event) >= 0);
/* attach to loopback interface */
assert_se(sd_dhcp_server_new(&server, 1) >= 0);
assert_se(server);
server->bind_to_interface = bind_to_interface;
assert_se(sd_dhcp_server_attach_event(server, event, 0) >= 0);
assert_se(sd_dhcp_server_attach_event(server, event, 0) == -EBUSY);
assert_se(sd_dhcp_server_get_event(server) == event);
assert_se(sd_dhcp_server_detach_event(server) >= 0);
assert_se(!sd_dhcp_server_get_event(server));
assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
assert_se(sd_dhcp_server_attach_event(server, NULL, 0) == -EBUSY);
assert_se(sd_dhcp_server_ref(server) == server);
assert_se(!sd_dhcp_server_unref(server));
assert_se(sd_dhcp_server_start(server) == -EUNATCH);
assert_se(sd_dhcp_server_configure_pool(server, &address_any, 28, 0, 0) == -EINVAL);
assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 38, 0, 0) == -ERANGE);
assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0) >= 0);
assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0) >= 0);
test_pool(&address_any, 1, -EINVAL);
test_pool(&address_lo, 1, 0);
r = sd_dhcp_server_start(server);
if (r == -EPERM)
return r;
assert_se(r >= 0);
assert_se(sd_dhcp_server_start(server) >= 0);
assert_se(sd_dhcp_server_stop(server) >= 0);
assert_se(sd_dhcp_server_stop(server) >= 0);
assert_se(sd_dhcp_server_start(server) >= 0);
return 0;
}
static void test_message_handler(void) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
struct {
DHCPMessage message;
struct {
uint8_t code;
uint8_t length;
uint8_t type;
} _packed_ option_type;
struct {
uint8_t code;
uint8_t length;
be32_t address;
} _packed_ option_requested_ip;
struct {
uint8_t code;
uint8_t length;
be32_t address;
} _packed_ option_server_id;
struct {
uint8_t code;
uint8_t length;
uint8_t id[7];
} _packed_ option_client_id;
struct {
uint8_t code;
uint8_t length;
uint8_t hostname[6];
} _packed_ option_hostname;
uint8_t end;
} _packed_ test = {
.message.op = BOOTREQUEST,
.message.htype = ARPHRD_ETHER,
.message.hlen = ETHER_ADDR_LEN,
.message.xid = htobe32(0x12345678),
.message.chaddr = { 'A', 'B', 'C', 'D', 'E', 'F' },
.option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE,
.option_type.length = 1,
.option_type.type = DHCP_DISCOVER,
.option_hostname.code = SD_DHCP_OPTION_HOST_NAME,
.option_hostname.length = 6,
.option_hostname.hostname = { 'T', 'E', 'S', 'T', 'H', 'N' },
.end = SD_DHCP_OPTION_END,
};
struct in_addr address_lo = {
.s_addr = htobe32(INADDR_LOOPBACK),
};
struct in_addr static_lease_address = {
.s_addr = htobe32(INADDR_LOOPBACK + 42),
};
static uint8_t static_lease_client_id[7] = {0x01, 'A', 'B', 'C', 'D', 'E', 'G' };
log_debug("/* %s */", __func__);
assert_se(sd_dhcp_server_new(&server, 1) >= 0);
assert_se(sd_dhcp_server_configure_pool(server, &address_lo, 8, 0, 0) >= 0);
assert_se(sd_dhcp_server_set_static_lease(server, &static_lease_address, static_lease_client_id,
ELEMENTSOF(static_lease_client_id)) >= 0);
assert_se(sd_dhcp_server_attach_event(server, NULL, 0) >= 0);
assert_se(sd_dhcp_server_start(server) >= 0);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.end = 0;
/* TODO, shouldn't this fail? */
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.end = SD_DHCP_OPTION_END;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.option_type.code = 0;
test.option_type.length = 0;
test.option_type.type = 0;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
test.option_type.code = SD_DHCP_OPTION_MESSAGE_TYPE;
test.option_type.length = 1;
test.option_type.type = DHCP_DISCOVER;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.message.op = 0;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
test.message.op = BOOTREQUEST;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.message.htype = 0;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.message.htype = ARPHRD_ETHER;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.message.hlen = 0;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == -EBADMSG);
test.message.hlen = ETHER_ADDR_LEN;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_OFFER);
test.option_type.type = DHCP_REQUEST;
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
test.option_requested_ip.code = SD_DHCP_OPTION_REQUESTED_IP_ADDRESS;
test.option_requested_ip.length = 4;
test.option_requested_ip.address = htobe32(0x12345678);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_NAK);
test.option_server_id.code = SD_DHCP_OPTION_SERVER_IDENTIFIER;
test.option_server_id.length = 4;
test.option_server_id.address = htobe32(INADDR_LOOPBACK);
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
test.option_server_id.address = htobe32(0x12345678);
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
test.option_server_id.address = htobe32(INADDR_LOOPBACK);
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 4);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 3);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
test.option_client_id.code = SD_DHCP_OPTION_CLIENT_IDENTIFIER;
test.option_client_id.length = 7;
test.option_client_id.id[0] = 0x01;
test.option_client_id.id[1] = 'A';
test.option_client_id.id[2] = 'B';
test.option_client_id.id[3] = 'C';
test.option_client_id.id[4] = 'D';
test.option_client_id.id[5] = 'E';
test.option_client_id.id[6] = 'F';
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 30);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
/* request address reserved for static lease (unmatching client ID) */
test.option_client_id.id[6] = 'H';
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
/* request unmatching address */
test.option_client_id.id[6] = 'G';
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 41);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == 0);
/* request matching address */
test.option_client_id.id[6] = 'G';
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
/* try again */
test.option_client_id.id[6] = 'G';
test.option_requested_ip.address = htobe32(INADDR_LOOPBACK + 42);
assert_se(dhcp_server_handle_message(server, (DHCPMessage*)&test, sizeof(test)) == DHCP_ACK);
}
static uint64_t client_id_hash_helper(DHCPClientId *id, uint8_t key[HASH_KEY_SIZE]) {
struct siphash state;
siphash24_init(&state, key);
client_id_hash_func(id, &state);
return htole64(siphash24_finalize(&state));
}
static void test_client_id_hash(void) {
DHCPClientId a = {
.length = 4,
}, b = {
.length = 4,
};
uint8_t hash_key[HASH_KEY_SIZE] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
};
log_debug("/* %s */", __func__);
a.data = (uint8_t*)strdup("abcd");
b.data = (uint8_t*)strdup("abcd");
assert_se(client_id_compare_func(&a, &b) == 0);
assert_se(client_id_hash_helper(&a, hash_key) == client_id_hash_helper(&b, hash_key));
a.length = 3;
assert_se(client_id_compare_func(&a, &b) != 0);
a.length = 4;
assert_se(client_id_compare_func(&a, &b) == 0);
assert_se(client_id_hash_helper(&a, hash_key) == client_id_hash_helper(&b, hash_key));
b.length = 3;
assert_se(client_id_compare_func(&a, &b) != 0);
b.length = 4;
assert_se(client_id_compare_func(&a, &b) == 0);
assert_se(client_id_hash_helper(&a, hash_key) == client_id_hash_helper(&b, hash_key));
free(b.data);
b.data = (uint8_t*)strdup("abce");
assert_se(client_id_compare_func(&a, &b) != 0);
free(a.data);
free(b.data);
}
static void test_static_lease(void) {
_cleanup_(sd_dhcp_server_unrefp) sd_dhcp_server *server = NULL;
log_debug("/* %s */", __func__);
assert_se(sd_dhcp_server_new(&server, 1) >= 0);
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
(uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)) >= 0);
/* Duplicated entry. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
(uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)) == -EEXIST);
/* Address is conflicted. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020304 },
(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)) == -EEXIST);
/* Client ID is conflicted. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020305 },
(uint8_t*) &(uint32_t) { 0x01020304 }, sizeof(uint32_t)) == -EEXIST);
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020305 },
(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)) >= 0);
/* Remove the previous entry. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)) >= 0);
/* Then, set a different address. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x01020306 },
(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)) >= 0);
/* Remove again. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)) >= 0);
/* Try to remove non-existent entry. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
(uint8_t*) &(uint32_t) { 0x01020305 }, sizeof(uint32_t)) >= 0);
/* Try to remove non-existent entry. */
assert_se(sd_dhcp_server_set_static_lease(server, &(struct in_addr) { .s_addr = 0x00000000 },
(uint8_t*) &(uint32_t) { 0x01020306 }, sizeof(uint32_t)) >= 0);
}
int main(int argc, char *argv[]) {
int r;
test_setup_logging(LOG_DEBUG);
test_client_id_hash();
test_static_lease();
r = test_basic(true);
if (r < 0)
return log_tests_skipped_errno(r, "cannot start dhcp server(bound to interface)");
r = test_basic(false);
if (r < 0)
return log_tests_skipped_errno(r, "cannot start dhcp server(non-bound to interface)");
test_message_handler();
return 0;
}
| 14,952 | 44.175227 | 119 |
c
|
null |
systemd-main/src/libsystemd-network/test-ipv4ll.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Axis Communications AB. All rights reserved.
***/
#include <errno.h>
#include <netinet/if_ether.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include "sd-ipv4ll.h"
#include "arp-util.h"
#include "fd-util.h"
#include "socket-util.h"
#include "tests.h"
static bool verbose = false;
static bool extended = false;
static int test_fd[2];
static int basic_request_handler_bind = 0;
static int basic_request_handler_stop = 0;
static void* basic_request_handler_userdata = (void*) 0xCABCAB;
static void basic_request_handler(sd_ipv4ll *ll, int event, void *userdata) {
assert_se(userdata == basic_request_handler_userdata);
switch (event) {
case SD_IPV4LL_EVENT_STOP:
basic_request_handler_stop = 1;
break;
case SD_IPV4LL_EVENT_BIND:
basic_request_handler_bind = 1;
break;
default:
assert_se(0);
break;
}
}
int arp_send_packet(
int fd,
int ifindex,
const struct in_addr *pa,
const struct ether_addr *ha,
bool announce) {
struct ether_arp ea = {};
assert_se(fd >= 0);
assert_se(ifindex > 0);
assert_se(pa);
assert_se(ha);
if (send(fd, &ea, sizeof(struct ether_arp), 0) < 0)
return -errno;
return 0;
}
int arp_update_filter(int fd, const struct in_addr *a, const struct ether_addr *eth_mac) {
return 0;
}
int arp_network_bind_raw_socket(int ifindex, const struct in_addr *a, const struct ether_addr *eth_mac) {
if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
return -errno;
return test_fd[0];
}
static void test_public_api_setters(sd_event *e) {
struct in_addr address = {};
uint64_t seed = 0;
sd_ipv4ll *ll;
struct ether_addr mac_addr = {
.ether_addr_octet = {'A', 'B', 'C', '1', '2', '3'}};
if (verbose)
printf("* %s\n", __func__);
assert_se(sd_ipv4ll_new(&ll) == 0);
assert_se(ll);
assert_se(sd_ipv4ll_attach_event(NULL, NULL, 0) == -EINVAL);
assert_se(sd_ipv4ll_attach_event(ll, e, 0) == 0);
assert_se(sd_ipv4ll_attach_event(ll, e, 0) == -EBUSY);
assert_se(sd_ipv4ll_set_callback(NULL, NULL, NULL) == -EINVAL);
assert_se(sd_ipv4ll_set_callback(ll, NULL, NULL) == 0);
assert_se(sd_ipv4ll_set_address(ll, &address) == -EINVAL);
address.s_addr |= htobe32(169U << 24 | 254U << 16);
assert_se(sd_ipv4ll_set_address(ll, &address) == -EINVAL);
address.s_addr |= htobe32(0x00FF);
assert_se(sd_ipv4ll_set_address(ll, &address) == -EINVAL);
address.s_addr |= htobe32(0xF000);
assert_se(sd_ipv4ll_set_address(ll, &address) == 0);
address.s_addr |= htobe32(0x0F00);
assert_se(sd_ipv4ll_set_address(ll, &address) == -EINVAL);
assert_se(sd_ipv4ll_set_address_seed(NULL, seed) == -EINVAL);
assert_se(sd_ipv4ll_set_address_seed(ll, seed) == 0);
assert_se(sd_ipv4ll_set_mac(NULL, NULL) == -EINVAL);
assert_se(sd_ipv4ll_set_mac(ll, NULL) == -EINVAL);
assert_se(sd_ipv4ll_set_mac(ll, &mac_addr) == 0);
assert_se(sd_ipv4ll_set_ifindex(NULL, -1) == -EINVAL);
assert_se(sd_ipv4ll_set_ifindex(ll, -1) == -EINVAL);
assert_se(sd_ipv4ll_set_ifindex(ll, -99) == -EINVAL);
assert_se(sd_ipv4ll_set_ifindex(ll, 1) == 0);
assert_se(sd_ipv4ll_ref(ll) == ll);
assert_se(sd_ipv4ll_unref(ll) == NULL);
/* Cleanup */
assert_se(sd_ipv4ll_unref(ll) == NULL);
}
static void test_basic_request(sd_event *e, const struct in_addr *start_address) {
sd_ipv4ll *ll;
struct ether_arp arp;
struct ether_addr mac_addr = {
.ether_addr_octet = {'A', 'B', 'C', '1', '2', '3'}};
if (verbose)
printf("* %s\n", __func__);
assert_se(sd_ipv4ll_new(&ll) == 0);
if (in4_addr_is_set(start_address))
assert_se(sd_ipv4ll_set_address(ll, start_address) >= 0);
assert_se(sd_ipv4ll_start(ll) == -EINVAL);
assert_se(sd_ipv4ll_attach_event(ll, e, 0) == 0);
assert_se(sd_ipv4ll_start(ll) == -EINVAL);
assert_se(sd_ipv4ll_set_mac(ll, &mac_addr) == 0);
assert_se(sd_ipv4ll_start(ll) == -EINVAL);
assert_se(sd_ipv4ll_set_callback(ll, basic_request_handler,
basic_request_handler_userdata) == 0);
assert_se(sd_ipv4ll_start(ll) == -EINVAL);
assert_se(sd_ipv4ll_set_ifindex(ll, 1) == 0);
assert_se(sd_ipv4ll_start(ll) == 1);
sd_event_run(e, UINT64_MAX);
assert_se(sd_ipv4ll_start(ll) == 0);
assert_se(sd_ipv4ll_is_running(ll));
/* PROBE */
sd_event_run(e, UINT64_MAX);
assert_se(recv(test_fd[1], &arp, sizeof(struct ether_arp), 0) == sizeof(struct ether_arp));
if (extended) {
/* PROBE */
sd_event_run(e, UINT64_MAX);
assert_se(recv(test_fd[1], &arp, sizeof(struct ether_arp), 0) == sizeof(struct ether_arp));
/* PROBE */
sd_event_run(e, UINT64_MAX);
assert_se(recv(test_fd[1], &arp, sizeof(struct ether_arp), 0) == sizeof(struct ether_arp));
sd_event_run(e, UINT64_MAX);
assert_se(basic_request_handler_bind == 1);
if (in4_addr_is_set(start_address)) {
struct in_addr address;
assert_se(sd_ipv4ll_get_address(ll, &address) >= 0);
assert_se(start_address->s_addr == address.s_addr);
}
}
sd_ipv4ll_stop(ll);
assert_se(basic_request_handler_stop == 1);
/* Cleanup */
assert_se(sd_ipv4ll_unref(ll) == NULL);
safe_close(test_fd[1]);
}
int main(int argc, char *argv[]) {
struct in_addr start_address = {};
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
test_setup_logging(LOG_DEBUG);
assert_se(sd_event_new(&e) >= 0);
test_public_api_setters(e);
test_basic_request(e, &start_address);
basic_request_handler_bind = 0;
basic_request_handler_stop = 0;
start_address.s_addr = htobe32(169U << 24 | 254U << 16 | 1U << 8 | 2U);
test_basic_request(e, &start_address);
return 0;
}
| 6,732 | 31.52657 | 107 |
c
|
null |
systemd-main/src/libsystemd-network/test-lldp-rx.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <arpa/inet.h>
#include <errno.h>
#include <net/ethernet.h>
#include <stdio.h>
#include <unistd.h>
#include "sd-event.h"
#include "sd-lldp-rx.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "lldp-network.h"
#include "macro.h"
#include "string-util.h"
#include "tests.h"
#define TEST_LLDP_PORT "em1"
#define TEST_LLDP_TYPE_SYSTEM_NAME "systemd-lldp"
#define TEST_LLDP_TYPE_SYSTEM_DESC "systemd-lldp-desc"
static int test_fd[2] = PIPE_EBADF;
static int lldp_rx_handler_calls;
int lldp_network_bind_raw_socket(int ifindex) {
if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
return -errno;
return test_fd[0];
}
static void lldp_rx_handler(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata) {
lldp_rx_handler_calls++;
}
static int start_lldp_rx(sd_lldp_rx **lldp_rx, sd_event *e, sd_lldp_rx_callback_t cb, void *cb_data) {
int r;
r = sd_lldp_rx_new(lldp_rx);
if (r < 0)
return r;
r = sd_lldp_rx_set_ifindex(*lldp_rx, 42);
if (r < 0)
return r;
r = sd_lldp_rx_set_callback(*lldp_rx, cb, cb_data);
if (r < 0)
return r;
r = sd_lldp_rx_attach_event(*lldp_rx, e, 0);
if (r < 0)
return r;
r = sd_lldp_rx_start(*lldp_rx);
if (r < 0)
return r;
return 0;
}
static int stop_lldp_rx(sd_lldp_rx *lldp_rx) {
int r;
r = sd_lldp_rx_stop(lldp_rx);
if (r < 0)
return r;
r = sd_lldp_rx_detach_event(lldp_rx);
if (r < 0)
return r;
sd_lldp_rx_unref(lldp_rx);
safe_close(test_fd[1]);
return 0;
}
static void test_receive_basic_packet(sd_event *e) {
static const uint8_t frame[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x07, 0x04, 0x00, 0x01, 0x02, /* Chassis: MAC, 00:01:02:03:04:05 */
0x03, 0x04, 0x05,
0x04, 0x04, 0x05, 0x31, 0x2f, 0x33, /* Port: interface name, "1/3" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
/* LLDP optional TLVs */
0x08, 0x04, 0x50, 0x6f, 0x72, 0x74, /* Port Description: "Port" */
0x0a, 0x03, 0x53, 0x59, 0x53, /* System Name: "SYS" */
0x0c, 0x04, 0x66, 0x6f, 0x6f, 0x00, /* System Description: "foo" (NULL-terminated) */
0x00, 0x00 /* End Of LLDPDU */
};
sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors;
uint8_t type;
const void *data;
uint16_t ttl;
size_t length;
const char *str;
lldp_rx_handler_calls = 0;
assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
sd_event_run(e, 0);
assert_se(lldp_rx_handler_calls == 1);
assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 1);
assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[0], &type, &data, &length) == 0);
assert_se(type == SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS);
assert_se(length == ETH_ALEN);
assert_se(!memcmp(data, "\x00\x01\x02\x03\x04\x05", ETH_ALEN));
assert_se(sd_lldp_neighbor_get_port_id(neighbors[0], &type, &data, &length) == 0);
assert_se(type == SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME);
assert_se(length == 3);
assert_se(!memcmp(data, "1/3", 3));
assert_se(sd_lldp_neighbor_get_port_description(neighbors[0], &str) == 0);
assert_se(streq(str, "Port"));
assert_se(sd_lldp_neighbor_get_system_name(neighbors[0], &str) == 0);
assert_se(streq(str, "SYS"));
assert_se(sd_lldp_neighbor_get_system_description(neighbors[0], &str) == 0);
assert_se(streq(str, "foo"));
assert_se(sd_lldp_neighbor_get_ttl(neighbors[0], &ttl) == 0);
assert_se(ttl == 120);
sd_lldp_neighbor_unref(neighbors[0]);
free(neighbors);
assert_se(stop_lldp_rx(lldp_rx) == 0);
}
static void test_receive_incomplete_packet(sd_event *e) {
sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors;
uint8_t frame[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x07, 0x04, 0x00, 0x01, 0x02, /* Chassis: MAC, 00:01:02:03:04:05 */
0x03, 0x04, 0x05,
0x04, 0x04, 0x05, 0x31, 0x2f, 0x33, /* Port: interface name, "1/3" */
/* Missing TTL */
0x00, 0x00 /* End Of LLDPDU */
};
lldp_rx_handler_calls = 0;
assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
sd_event_run(e, 0);
assert_se(lldp_rx_handler_calls == 0);
assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 0);
assert_se(stop_lldp_rx(lldp_rx) == 0);
}
static void test_receive_oui_packet(sd_event *e) {
sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors;
uint8_t frame[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x07, 0x04, 0x00, 0x01, 0x02, /* Chassis: MAC, 00:01:02:03:04:05 */
0x03, 0x04, 0x05,
0x04, 0x04, 0x05, 0x31, 0x2f, 0x33, /* Port TLV: interface name, "1/3" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
/* LLDP optional TLVs */
0xfe, 0x06, 0x00, 0x80, 0xc2, 0x01, /* Port VLAN ID: 0x1234 */
0x12, 0x34,
0xfe, 0x07, 0x00, 0x80, 0xc2, 0x02, /* Port and protocol: flag 1, PPVID 0x7788 */
0x01, 0x77, 0x88,
0xfe, 0x0d, 0x00, 0x80, 0xc2, 0x03, /* VLAN Name: ID 0x1234, name "Vlan51" */
0x12, 0x34, 0x06, 0x56, 0x6c, 0x61,
0x6e, 0x35, 0x31,
0xfe, 0x06, 0x00, 0x80, 0xc2, 0x06, /* Management VID: 0x0102 */
0x01, 0x02,
0xfe, 0x09, 0x00, 0x80, 0xc2, 0x07, /* Link aggregation: status 1, ID 0x00140012 */
0x01, 0x00, 0x14, 0x00, 0x12,
0xfe, 0x07, 0x00, 0x12, 0x0f, 0x02, /* 802.3 Power via MDI: PSE, MDI enabled */
0x07, 0x01, 0x00,
0x00, 0x00 /* End of LLDPDU */
};
lldp_rx_handler_calls = 0;
assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
sd_event_run(e, 0);
assert_se(lldp_rx_handler_calls == 1);
assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 1);
assert_se(sd_lldp_neighbor_tlv_rewind(neighbors[0]) >= 0);
assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_CHASSIS_ID) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_PORT_ID) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_TTL) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_PORT_VLAN_ID) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_PORT_PROTOCOL_VLAN_ID) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_VLAN_NAME) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_MANAGEMENT_VID) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_LINK_AGGREGATION) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_3, SD_LLDP_OUI_802_3_SUBTYPE_POWER_VIA_MDI) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_END) > 0);
assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) == 0);
sd_lldp_neighbor_unref(neighbors[0]);
free(neighbors);
assert_se(stop_lldp_rx(lldp_rx) == 0);
}
static void test_multiple_neighbors_sorted(sd_event *e) {
static const uint8_t frame1[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x04, 0x01, '1', '/', '2', /* Chassis component: "1/2" */
0x04, 0x04, 0x02, '2', '/', '3', /* Port component: "2/3" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
0x00, 0x00 /* End Of LLDPDU */
};
static const uint8_t frame2[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x04, 0x01, '2', '/', '1', /* Chassis component: "2/1" */
0x04, 0x04, 0x02, '1', '/', '3', /* Port component: "1/3" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
0x00, 0x00 /* End Of LLDPDU */
};
static const uint8_t frame3[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x05, 0x01, '2', '/', '1', '0', /* Chassis component: "2/10" */
0x04, 0x04, 0x02, '1', '/', '0', /* Port component: "1/0" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
0x00, 0x00 /* End Of LLDPDU */
};
static const uint8_t frame4[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x05, 0x01, '2', '/', '1', '9', /* Chassis component: "2/19" */
0x04, 0x04, 0x02, '1', '/', '0', /* Port component: "1/0" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
0x00, 0x00 /* End Of LLDPDU */
};
static const uint8_t frame5[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x04, 0x01, '1', '/', '2', /* Chassis component: "1/2" */
0x04, 0x05, 0x02, '2', '/', '1', '0', /* Port component: "2/10" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
0x00, 0x00 /* End Of LLDPDU */
};
static const uint8_t frame6[] = {
/* Ethernet header */
0x01, 0x80, 0xc2, 0x00, 0x00, 0x03, /* Destination MAC */
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /* Source MAC */
0x88, 0xcc, /* Ethertype */
/* LLDP mandatory TLVs */
0x02, 0x04, 0x01, '1', '/', '2', /* Chassis component: "1/2" */
0x04, 0x05, 0x02, '2', '/', '3', '9', /* Port component: "2/10" */
0x06, 0x02, 0x00, 0x78, /* TTL: 120 seconds */
0x00, 0x00 /* End Of LLDPDU */
};
static const char* expected[] = {
/* ordered pairs of Chassis+Port */
"1/2", "2/10",
"1/2", "2/3",
"1/2", "2/39",
"2/1", "1/3",
"2/10", "1/0",
"2/19", "1/0",
};
sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors;
int i;
uint8_t type;
const void *data;
size_t length, expected_length;
uint16_t ttl;
lldp_rx_handler_calls = 0;
assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame1, sizeof(frame1)) == sizeof(frame1));
sd_event_run(e, 0);
assert_se(write(test_fd[1], frame2, sizeof(frame2)) == sizeof(frame2));
sd_event_run(e, 0);
assert_se(write(test_fd[1], frame3, sizeof(frame3)) == sizeof(frame3));
sd_event_run(e, 0);
assert_se(write(test_fd[1], frame4, sizeof(frame4)) == sizeof(frame4));
sd_event_run(e, 0);
assert_se(write(test_fd[1], frame5, sizeof(frame5)) == sizeof(frame5));
sd_event_run(e, 0);
assert_se(write(test_fd[1], frame6, sizeof(frame6)) == sizeof(frame6));
sd_event_run(e, 0);
assert_se(lldp_rx_handler_calls == 6);
assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 6);
for (i = 0; i < 6; i++) {
assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[i], &type, &data, &length) == 0);
assert_se(type == SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT);
expected_length = strlen(expected[2 * i]);
assert_se(length == expected_length);
assert_se(memcmp(data, expected[2 * i], expected_length) == 0);
assert_se(sd_lldp_neighbor_get_port_id(neighbors[i], &type, &data, &length) == 0);
assert_se(type == SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT);
expected_length = strlen(expected[2 * i + 1]);
assert_se(length == expected_length);
assert_se(memcmp(data, expected[2 * i + 1], expected_length) == 0);
assert_se(sd_lldp_neighbor_get_ttl(neighbors[i], &ttl) == 0);
assert_se(ttl == 120);
}
for (i = 0; i < 6; i++)
sd_lldp_neighbor_unref(neighbors[i]);
free(neighbors);
assert_se(stop_lldp_rx(lldp_rx) == 0);
}
int main(int argc, char *argv[]) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
test_setup_logging(LOG_DEBUG);
/* LLDP reception tests */
assert_se(sd_event_new(&e) == 0);
test_receive_basic_packet(e);
test_receive_incomplete_packet(e);
test_receive_oui_packet(e);
test_multiple_neighbors_sorted(e);
return 0;
}
| 16,730 | 43.145119 | 133 |
c
|
null |
systemd-main/src/libsystemd-network/test-ndisc-ra.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2017 Intel Corporation. All rights reserved.
***/
#include <netinet/icmp6.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "sd-radv.h"
#include "alloc-util.h"
#include "hexdecoct.h"
#include "icmp6-util.h"
#include "socket-util.h"
#include "strv.h"
#include "tests.h"
static struct ether_addr mac_addr = {
.ether_addr_octet = { 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53 }
};
static uint8_t advertisement[] = {
/* ICMPv6 Router Advertisement, no checksum */
0x86, 0x00, 0x00, 0x00, 0x40, 0xc0, 0x00, 0xb4,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* Source Link Layer Address Option */
0x01, 0x01, 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53,
/* Prefix Information Option */
0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x01, 0xf4,
0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x00,
0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* Prefix Information Option */
0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x0e, 0x10,
0x00, 0x00, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00,
0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* Prefix Information Option */
0x03, 0x04, 0x30, 0xc0, 0x00, 0x00, 0x0e, 0x10,
0x00, 0x00, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00,
0x20, 0x01, 0x0d, 0xb8, 0xc0, 0x01, 0x0d, 0xad,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/* Recursive DNS Server Option */
0x19, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
/* DNS Search List Option */
0x1f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
0x03, 0x6c, 0x61, 0x62, 0x05, 0x69, 0x6e, 0x74,
0x72, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static bool test_stopped;
static int test_fd[2];
static struct {
struct in6_addr address;
unsigned char prefixlen;
uint32_t valid;
uint32_t preferred;
bool successful;
} prefix[] = {
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 64,
500, 440, true },
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 64,
/* indicate default valid and preferred lifetimes for the test code */
0, 0, true },
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 58,
0, 0,
/* indicate that this prefix already exists */
false },
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 120,
0, 0,
/* indicate that this prefix already exists */
false },
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0x0b, 0x16, 0xd0, 0x0d,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 12,
0, 0,
/* indicate that this prefix already exists */
false },
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0xc0, 0x01, 0x0d, 0xad,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 48,
0, 0, true },
{ { { { 0x20, 0x01, 0x0d, 0xb8, 0xc0, 0x01, 0x0d, 0xad,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }, 60,
0, 0,
/* indicate that this prefix already exists */
false },
};
static const struct in6_addr test_rdnss = { { { 0x20, 0x01, 0x0d, 0xb8,
0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01 } } };
static const char *test_dnssl[] = { "lab.intra",
NULL };
TEST(radv_prefix) {
sd_radv_prefix *p;
assert_se(sd_radv_prefix_new(&p) >= 0);
assert_se(sd_radv_prefix_set_onlink(NULL, true) < 0);
assert_se(sd_radv_prefix_set_onlink(p, true) >= 0);
assert_se(sd_radv_prefix_set_onlink(p, false) >= 0);
assert_se(sd_radv_prefix_set_address_autoconfiguration(NULL, true) < 0);
assert_se(sd_radv_prefix_set_address_autoconfiguration(p, true) >= 0);
assert_se(sd_radv_prefix_set_address_autoconfiguration(p, false) >= 0);
assert_se(sd_radv_prefix_set_valid_lifetime(NULL, 1, 1) < 0);
assert_se(sd_radv_prefix_set_valid_lifetime(p, 0, 0) >= 0);
assert_se(sd_radv_prefix_set_valid_lifetime(p, 300 * USEC_PER_SEC, USEC_INFINITY) >= 0);
assert_se(sd_radv_prefix_set_valid_lifetime(p, 300 * USEC_PER_SEC, USEC_PER_YEAR) >= 0);
assert_se(sd_radv_prefix_set_preferred_lifetime(NULL, 1, 1) < 0);
assert_se(sd_radv_prefix_set_preferred_lifetime(p, 0, 0) >= 0);
assert_se(sd_radv_prefix_set_preferred_lifetime(p, 300 * USEC_PER_SEC, USEC_INFINITY) >= 0);
assert_se(sd_radv_prefix_set_preferred_lifetime(p, 300 * USEC_PER_SEC, USEC_PER_YEAR) >= 0);
assert_se(sd_radv_prefix_set_prefix(NULL, NULL, 0) < 0);
assert_se(sd_radv_prefix_set_prefix(p, NULL, 0) < 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 64) >= 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 0) < 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 1) < 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 2) < 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 3) >= 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 125) >= 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 128) >= 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 129) < 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[0].address, 255) < 0);
p = sd_radv_prefix_unref(p);
assert_se(!p);
}
TEST(radv) {
sd_radv *ra;
assert_se(sd_radv_new(&ra) >= 0);
assert_se(ra);
assert_se(sd_radv_set_ifindex(NULL, 0) < 0);
assert_se(sd_radv_set_ifindex(ra, 0) < 0);
assert_se(sd_radv_set_ifindex(ra, -1) < 0);
assert_se(sd_radv_set_ifindex(ra, -2) < 0);
assert_se(sd_radv_set_ifindex(ra, 42) >= 0);
assert_se(sd_radv_set_mac(NULL, NULL) < 0);
assert_se(sd_radv_set_mac(ra, NULL) >= 0);
assert_se(sd_radv_set_mac(ra, &mac_addr) >= 0);
assert_se(sd_radv_set_mtu(NULL, 0) < 0);
assert_se(sd_radv_set_mtu(ra, 0) < 0);
assert_se(sd_radv_set_mtu(ra, 1279) < 0);
assert_se(sd_radv_set_mtu(ra, 1280) >= 0);
assert_se(sd_radv_set_mtu(ra, ~0) >= 0);
assert_se(sd_radv_set_hop_limit(NULL, 0) < 0);
assert_se(sd_radv_set_hop_limit(ra, 0) >= 0);
assert_se(sd_radv_set_hop_limit(ra, ~0) >= 0);
assert_se(sd_radv_set_router_lifetime(NULL, 0) < 0);
assert_se(sd_radv_set_router_lifetime(ra, 0) >= 0);
assert_se(sd_radv_set_router_lifetime(ra, USEC_INFINITY) < 0);
assert_se(sd_radv_set_router_lifetime(ra, USEC_PER_YEAR) < 0);
assert_se(sd_radv_set_router_lifetime(ra, 300 * USEC_PER_SEC) >= 0);
assert_se(sd_radv_set_preference(NULL, 0) < 0);
assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_LOW) >= 0);
assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_MEDIUM) >= 0);
assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_HIGH) >= 0);
assert_se(sd_radv_set_preference(ra, ~0) < 0);
assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_HIGH) >= 0);
assert_se(sd_radv_set_router_lifetime(ra, 300 * USEC_PER_SEC) >= 0);
assert_se(sd_radv_set_router_lifetime(ra, 0) < 0);
assert_se(sd_radv_set_preference(ra, SD_NDISC_PREFERENCE_MEDIUM) >= 0);
assert_se(sd_radv_set_router_lifetime(ra, 0) >= 0);
assert_se(sd_radv_set_managed_information(NULL, true) < 0);
assert_se(sd_radv_set_managed_information(ra, true) >= 0);
assert_se(sd_radv_set_managed_information(ra, false) >= 0);
assert_se(sd_radv_set_other_information(NULL, true) < 0);
assert_se(sd_radv_set_other_information(ra, true) >= 0);
assert_se(sd_radv_set_other_information(ra, false) >= 0);
assert_se(sd_radv_set_rdnss(NULL, 0, NULL, 0) < 0);
assert_se(sd_radv_set_rdnss(ra, 0, NULL, 0) >= 0);
assert_se(sd_radv_set_rdnss(ra, 0, NULL, 128) < 0);
assert_se(sd_radv_set_rdnss(ra, 600, &test_rdnss, 0) >= 0);
assert_se(sd_radv_set_rdnss(ra, 600, &test_rdnss, 1) >= 0);
assert_se(sd_radv_set_rdnss(ra, 0, &test_rdnss, 1) >= 0);
assert_se(sd_radv_set_rdnss(ra, 0, NULL, 0) >= 0);
assert_se(sd_radv_set_dnssl(ra, 0, NULL) >= 0);
assert_se(sd_radv_set_dnssl(ra, 600, NULL) >= 0);
assert_se(sd_radv_set_dnssl(ra, 0, (char **)test_dnssl) >= 0);
assert_se(sd_radv_set_dnssl(ra, 600, (char **)test_dnssl) >= 0);
ra = sd_radv_unref(ra);
assert_se(!ra);
}
int icmp6_bind_router_solicitation(int ifindex) {
return -ENOSYS;
}
int icmp6_bind_router_advertisement(int ifindex) {
assert_se(ifindex == 42);
return test_fd[1];
}
int icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr) {
return 0;
}
int icmp6_receive(int fd, void *iov_base, size_t iov_len,
struct in6_addr *dst, triple_timestamp *timestamp) {
assert_se(read (fd, iov_base, iov_len) == (ssize_t)iov_len);
if (timestamp)
triple_timestamp_get(timestamp);
return 0;
}
static int radv_recv(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
sd_radv *ra = userdata;
unsigned char buf[168];
size_t i;
assert_se(read(test_fd[0], &buf, sizeof(buf)) == sizeof(buf));
/* router lifetime must be zero when test is stopped */
if (test_stopped) {
advertisement[6] = 0x00;
advertisement[7] = 0x00;
}
printf ("Received Router Advertisement with lifetime %i\n",
(advertisement[6] << 8) + advertisement[7]);
/* test only up to buf size, rest is not yet implemented */
for (i = 0; i < sizeof(buf); i++) {
if (!(i % 8))
printf("%3zu: ", i);
printf("0x%02x", buf[i]);
assert_se(buf[i] == advertisement[i]);
if ((i + 1) % 8)
printf(", ");
else
printf("\n");
}
if (test_stopped) {
sd_event *e;
e = sd_radv_get_event(ra);
sd_event_exit(e, 0);
return 0;
}
assert_se(sd_radv_stop(ra) >= 0);
test_stopped = true;
return 0;
}
TEST(ra) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_event_source_unrefp) sd_event_source *recv_router_advertisement = NULL;
_cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
assert_se(socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) >= 0);
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_radv_new(&ra) >= 0);
assert_se(ra);
assert_se(sd_radv_attach_event(ra, e, 0) >= 0);
assert_se(sd_radv_set_ifindex(ra, 42) >= 0);
assert_se(sd_radv_set_mac(ra, &mac_addr) >= 0);
assert_se(sd_radv_set_router_lifetime(ra, 180 * USEC_PER_SEC) >= 0);
assert_se(sd_radv_set_hop_limit(ra, 64) >= 0);
assert_se(sd_radv_set_managed_information(ra, true) >= 0);
assert_se(sd_radv_set_other_information(ra, true) >= 0);
assert_se(sd_radv_set_rdnss(ra, 60, &test_rdnss, 1) >= 0);
assert_se(sd_radv_set_dnssl(ra, 60, (char **)test_dnssl) >= 0);
for (unsigned i = 0; i < ELEMENTSOF(prefix); i++) {
sd_radv_prefix *p;
printf("Test prefix %u\n", i);
assert_se(sd_radv_prefix_new(&p) >= 0);
assert_se(sd_radv_prefix_set_prefix(p, &prefix[i].address,
prefix[i].prefixlen) >= 0);
if (prefix[i].valid > 0)
assert_se(sd_radv_prefix_set_valid_lifetime(p, prefix[i].valid * USEC_PER_SEC, USEC_INFINITY) >= 0);
if (prefix[i].preferred > 0)
assert_se(sd_radv_prefix_set_preferred_lifetime(p, prefix[i].preferred * USEC_PER_SEC, USEC_INFINITY) >= 0);
assert_se((sd_radv_add_prefix(ra, p) >= 0) == prefix[i].successful);
/* If the previous sd_radv_add_prefix() succeeds, then also the second call should also succeed. */
assert_se((sd_radv_add_prefix(ra, p) >= 0) == prefix[i].successful);
p = sd_radv_prefix_unref(p);
assert_se(!p);
}
assert_se(sd_event_add_io(e, &recv_router_advertisement, test_fd[0], EPOLLIN, radv_recv, ra) >= 0);
assert_se(sd_event_source_set_io_fd_own(recv_router_advertisement, true) >= 0);
assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
2 * USEC_PER_SEC, 0,
NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
assert_se(sd_radv_start(ra) >= 0);
assert_se(sd_event_loop(e) >= 0);
}
DEFINE_TEST_MAIN(LOG_DEBUG);
| 13,772 | 39.628319 | 132 |
c
|
null |
systemd-main/src/libsystemd-network/test-ndisc-rs.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <netinet/icmp6.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "sd-ndisc.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "hexdecoct.h"
#include "icmp6-util.h"
#include "socket-util.h"
#include "strv.h"
#include "ndisc-internal.h"
#include "tests.h"
static struct ether_addr mac_addr = {
.ether_addr_octet = {'A', 'B', 'C', '1', '2', '3'}
};
static bool verbose = false;
static int test_fd[2];
static sd_ndisc *test_timeout_nd;
typedef int (*send_ra_t)(uint8_t flags);
static send_ra_t send_ra_function;
static void router_dump(sd_ndisc_router *rt) {
struct in6_addr addr;
uint8_t hop_limit;
uint64_t t, flags;
uint32_t mtu;
uint16_t lifetime;
unsigned preference;
int r;
assert_se(rt);
log_info("--");
assert_se(sd_ndisc_router_get_address(rt, &addr) == -ENODATA);
assert_se(sd_ndisc_router_get_timestamp(rt, CLOCK_REALTIME, &t) >= 0);
log_info("Timestamp: %s", FORMAT_TIMESTAMP(t));
assert_se(sd_ndisc_router_get_timestamp(rt, CLOCK_MONOTONIC, &t) >= 0);
log_info("Monotonic: %" PRIu64, t);
if (sd_ndisc_router_get_hop_limit(rt, &hop_limit) < 0)
log_info("No hop limit set");
else
log_info("Hop limit: %u", hop_limit);
assert_se(sd_ndisc_router_get_flags(rt, &flags) >= 0);
log_info("Flags: <%s|%s>",
flags & ND_RA_FLAG_OTHER ? "OTHER" : "",
flags & ND_RA_FLAG_MANAGED ? "MANAGED" : "");
assert_se(sd_ndisc_router_get_preference(rt, &preference) >= 0);
log_info("Preference: %s",
preference == SD_NDISC_PREFERENCE_LOW ? "low" :
preference == SD_NDISC_PREFERENCE_HIGH ? "high" : "medium");
assert_se(sd_ndisc_router_get_lifetime(rt, &lifetime) >= 0);
log_info("Lifetime: %" PRIu16, lifetime);
if (sd_ndisc_router_get_mtu(rt, &mtu) < 0)
log_info("No MTU set");
else
log_info("MTU: %" PRIu32, mtu);
r = sd_ndisc_router_option_rewind(rt);
for (;;) {
uint8_t type;
assert_se(r >= 0);
if (r == 0)
break;
assert_se(sd_ndisc_router_option_get_type(rt, &type) >= 0);
log_info(">> Option %u", type);
switch (type) {
case SD_NDISC_OPTION_SOURCE_LL_ADDRESS:
case SD_NDISC_OPTION_TARGET_LL_ADDRESS: {
_cleanup_free_ char *c = NULL;
const void *p;
size_t n;
assert_se(sd_ndisc_router_option_get_raw(rt, &p, &n) >= 0);
assert_se(n > 2);
assert_se(c = hexmem((uint8_t*) p + 2, n - 2));
log_info("Address: %s", c);
break;
}
case SD_NDISC_OPTION_PREFIX_INFORMATION: {
uint32_t lifetime_valid, lifetime_preferred;
unsigned prefix_len;
uint8_t pfl;
struct in6_addr a;
assert_se(sd_ndisc_router_prefix_get_valid_lifetime(rt, &lifetime_valid) >= 0);
log_info("Valid Lifetime: %" PRIu32, lifetime_valid);
assert_se(sd_ndisc_router_prefix_get_preferred_lifetime(rt, &lifetime_preferred) >= 0);
log_info("Preferred Lifetime: %" PRIu32, lifetime_preferred);
assert_se(sd_ndisc_router_prefix_get_flags(rt, &pfl) >= 0);
log_info("Flags: <%s|%s>",
pfl & ND_OPT_PI_FLAG_ONLINK ? "ONLINK" : "",
pfl & ND_OPT_PI_FLAG_AUTO ? "AUTO" : "");
assert_se(sd_ndisc_router_prefix_get_prefixlen(rt, &prefix_len) >= 0);
log_info("Prefix Length: %u", prefix_len);
assert_se(sd_ndisc_router_prefix_get_address(rt, &a) >= 0);
log_info("Prefix: %s", IN6_ADDR_TO_STRING(&a));
break;
}
case SD_NDISC_OPTION_RDNSS: {
const struct in6_addr *a;
uint32_t lt;
int n, i;
n = sd_ndisc_router_rdnss_get_addresses(rt, &a);
assert_se(n > 0);
for (i = 0; i < n; i++)
log_info("DNS: %s", IN6_ADDR_TO_STRING(a + i));
assert_se(sd_ndisc_router_rdnss_get_lifetime(rt, <) >= 0);
log_info("Lifetime: %" PRIu32, lt);
break;
}
case SD_NDISC_OPTION_DNSSL: {
_cleanup_strv_free_ char **l = NULL;
uint32_t lt;
int n, i;
n = sd_ndisc_router_dnssl_get_domains(rt, &l);
assert_se(n > 0);
for (i = 0; i < n; i++)
log_info("Domain: %s", l[i]);
assert_se(sd_ndisc_router_dnssl_get_lifetime(rt, <) >= 0);
log_info("Lifetime: %" PRIu32, lt);
break;
}}
r = sd_ndisc_router_option_next(rt);
}
}
int icmp6_bind_router_solicitation(int ifindex) {
assert_se(ifindex == 42);
if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
return -errno;
return test_fd[0];
}
int icmp6_bind_router_advertisement(int ifindex) {
return -ENOSYS;
}
int icmp6_receive(int fd, void *iov_base, size_t iov_len,
struct in6_addr *dst, triple_timestamp *timestamp) {
assert_se(read (fd, iov_base, iov_len) == (ssize_t)iov_len);
if (timestamp)
triple_timestamp_get(timestamp);
return 0;
}
static int send_ra(uint8_t flags) {
uint8_t advertisement[] = {
0x86, 0x00, 0xde, 0x83, 0x40, 0xc0, 0x00, 0xb4,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x04, 0x40, 0xc0, 0x00, 0x00, 0x01, 0xf4,
0x00, 0x00, 0x01, 0xb8, 0x00, 0x00, 0x00, 0x00,
0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x19, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
0x20, 0x01, 0x0d, 0xb8, 0xde, 0xad, 0xbe, 0xef,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x1f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c,
0x03, 0x6c, 0x61, 0x62, 0x05, 0x69, 0x6e, 0x74,
0x72, 0x61, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x78, 0x2b, 0xcb, 0xb3, 0x6d, 0x53,
};
advertisement[5] = flags;
assert_se(write(test_fd[1], advertisement, sizeof(advertisement)) ==
sizeof(advertisement));
if (verbose)
printf(" sent RA with flag 0x%02x\n", flags);
return 0;
}
int icmp6_send_router_solicitation(int s, const struct ether_addr *ether_addr) {
if (!send_ra_function)
return 0;
return send_ra_function(0);
}
static void test_callback(sd_ndisc *nd, sd_ndisc_event_t event, sd_ndisc_router *rt, void *userdata) {
sd_event *e = userdata;
static unsigned idx = 0;
uint64_t flags_array[] = {
0,
0,
0,
ND_RA_FLAG_OTHER,
ND_RA_FLAG_MANAGED
};
uint64_t flags;
assert_se(nd);
if (event != SD_NDISC_EVENT_ROUTER)
return;
router_dump(rt);
assert_se(sd_ndisc_router_get_flags(rt, &flags) >= 0);
assert_se(flags == flags_array[idx]);
idx++;
if (verbose)
printf(" got event 0x%02" PRIx64 "\n", flags);
if (idx < ELEMENTSOF(flags_array)) {
send_ra(flags_array[idx]);
return;
}
sd_event_exit(e, 0);
}
TEST(rs) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
send_ra_function = send_ra;
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_ndisc_new(&nd) >= 0);
assert_se(nd);
assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
assert_se(sd_ndisc_set_callback(nd, test_callback, e) >= 0);
assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
30 * USEC_PER_SEC, 0,
NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
assert_se(sd_ndisc_stop(nd) >= 0);
assert_se(sd_ndisc_start(nd) >= 0);
assert_se(sd_ndisc_start(nd) >= 0);
assert_se(sd_ndisc_stop(nd) >= 0);
test_fd[1] = safe_close(test_fd[1]);
assert_se(sd_ndisc_start(nd) >= 0);
assert_se(sd_event_loop(e) >= 0);
test_fd[1] = safe_close(test_fd[1]);
}
static int test_timeout_value(uint8_t flags) {
static int count = 0;
static usec_t last = 0;
sd_ndisc *nd = test_timeout_nd;
usec_t min, max;
assert_se(nd);
assert_se(nd->event);
if (++count >= 20)
sd_event_exit(nd->event, 0);
if (last == 0) {
/* initial RT = IRT + RAND*IRT */
min = NDISC_ROUTER_SOLICITATION_INTERVAL -
NDISC_ROUTER_SOLICITATION_INTERVAL / 10;
max = NDISC_ROUTER_SOLICITATION_INTERVAL +
NDISC_ROUTER_SOLICITATION_INTERVAL / 10;
} else {
/* next RT = 2*RTprev + RAND*RTprev */
min = 2 * last - last / 10;
max = 2 * last + last / 10;
}
/* final RT > MRT */
if (last * 2 > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL) {
min = NDISC_MAX_ROUTER_SOLICITATION_INTERVAL -
NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 10;
max = NDISC_MAX_ROUTER_SOLICITATION_INTERVAL +
NDISC_MAX_ROUTER_SOLICITATION_INTERVAL / 10;
}
log_info("backoff timeout interval %2d %s%s <= %s <= %s",
count,
last * 2 > NDISC_MAX_ROUTER_SOLICITATION_INTERVAL ? "(max) ": "",
FORMAT_TIMESPAN(min, USEC_PER_MSEC),
FORMAT_TIMESPAN(nd->retransmit_time, USEC_PER_MSEC),
FORMAT_TIMESPAN(max, USEC_PER_MSEC));
assert_se(min <= nd->retransmit_time);
assert_se(max >= nd->retransmit_time);
last = nd->retransmit_time;
assert_se(sd_event_source_set_time(nd->timeout_event_source, 0) >= 0);
return 0;
}
TEST(timeout) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
send_ra_function = test_timeout_value;
assert_se(sd_event_new(&e) >= 0);
assert_se(sd_ndisc_new(&nd) >= 0);
assert_se(nd);
test_timeout_nd = nd;
assert_se(sd_ndisc_attach_event(nd, e, 0) >= 0);
assert_se(sd_ndisc_set_ifindex(nd, 42) >= 0);
assert_se(sd_ndisc_set_mac(nd, &mac_addr) >= 0);
assert_se(sd_event_add_time_relative(e, NULL, CLOCK_BOOTTIME,
30 * USEC_PER_SEC, 0,
NULL, INT_TO_PTR(-ETIMEDOUT)) >= 0);
assert_se(sd_ndisc_start(nd) >= 0);
assert_se(sd_event_loop(e) >= 0);
test_fd[1] = safe_close(test_fd[1]);
}
DEFINE_TEST_MAIN(LOG_DEBUG);
| 12,178 | 31.827493 | 111 |
c
|
null |
systemd-main/src/libsystemd-network/test-sd-dhcp-lease.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "dhcp-lease-internal.h"
#include "macro.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
/* According to RFC1035 section 4.1.4, a domain name in a message can be either:
* - a sequence of labels ending in a zero octet
* - a pointer
* - a sequence of labels ending with a pointer
*/
TEST(dhcp_lease_parse_search_domains_basic) {
int r;
_cleanup_strv_free_ char **domains = NULL;
static const uint8_t optionbuf[] = {
0x03, 'F', 'O', 'O', 0x03, 'B', 'A', 'R', 0x00,
0x04, 'A', 'B', 'C', 'D', 0x03, 'E', 'F', 'G', 0x00,
};
r = dhcp_lease_parse_search_domains(optionbuf, sizeof(optionbuf), &domains);
assert_se(r == 2);
assert_se(streq(domains[0], "FOO.BAR"));
assert_se(streq(domains[1], "ABCD.EFG"));
}
TEST(dhcp_lease_parse_search_domains_ptr) {
int r;
_cleanup_strv_free_ char **domains = NULL;
static const uint8_t optionbuf[] = {
0x03, 'F', 'O', 'O', 0x00, 0xC0, 0x00,
};
r = dhcp_lease_parse_search_domains(optionbuf, sizeof(optionbuf), &domains);
assert_se(r == 2);
assert_se(streq(domains[0], "FOO"));
assert_se(streq(domains[1], "FOO"));
}
TEST(dhcp_lease_parse_search_domains_labels_and_ptr) {
int r;
_cleanup_strv_free_ char **domains = NULL;
static const uint8_t optionbuf[] = {
0x03, 'F', 'O', 'O', 0x03, 'B', 'A', 'R', 0x00,
0x03, 'A', 'B', 'C', 0xC0, 0x04,
};
r = dhcp_lease_parse_search_domains(optionbuf, sizeof(optionbuf), &domains);
assert_se(r == 2);
assert_se(streq(domains[0], "FOO.BAR"));
assert_se(streq(domains[1], "ABC.BAR"));
}
/* Tests for exceptions. */
TEST(dhcp_lease_parse_search_domains_no_data) {
_cleanup_strv_free_ char **domains = NULL;
static const uint8_t optionbuf[3] = {0, 0, 0};
assert_se(dhcp_lease_parse_search_domains(NULL, 0, &domains) == -ENODATA);
assert_se(dhcp_lease_parse_search_domains(optionbuf, 0, &domains) == -ENODATA);
}
TEST(dhcp_lease_parse_search_domains_loops) {
_cleanup_strv_free_ char **domains = NULL;
static const uint8_t optionbuf[] = {
0x03, 'F', 'O', 'O', 0x00, 0x03, 'B', 'A', 'R', 0xC0, 0x06,
};
assert_se(dhcp_lease_parse_search_domains(optionbuf, sizeof(optionbuf), &domains) == -EBADMSG);
}
TEST(dhcp_lease_parse_search_domains_wrong_len) {
_cleanup_strv_free_ char **domains = NULL;
static const uint8_t optionbuf[] = {
0x03, 'F', 'O', 'O', 0x03, 'B', 'A', 'R', 0x00,
0x04, 'A', 'B', 'C', 'D', 0x03, 'E', 'F', 'G', 0x00,
};
assert_se(dhcp_lease_parse_search_domains(optionbuf, sizeof(optionbuf) - 5, &domains) == -EBADMSG);
}
DEFINE_TEST_MAIN(LOG_INFO);
| 2,969 | 33.137931 | 107 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-common-errors.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "sd-bus.h"
#include "bus-common-errors.h"
#include "bus-error.h"
BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map bus_common_errors[] = {
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_UNIT, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_UNIT_FOR_PID, ESRCH),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_UNIT_EXISTS, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_LOAD_FAILED, EIO),
SD_BUS_ERROR_MAP(BUS_ERROR_BAD_UNIT_SETTING, ENOEXEC),
SD_BUS_ERROR_MAP(BUS_ERROR_JOB_FAILED, EREMOTEIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_JOB, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_NOT_SUBSCRIBED, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_ALREADY_SUBSCRIBED, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_ONLY_BY_DEPENDENCY, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_TRANSACTION_JOBS_CONFLICTING, EDEADLK),
SD_BUS_ERROR_MAP(BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC, EDEADLK),
SD_BUS_ERROR_MAP(BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE, EDEADLK),
SD_BUS_ERROR_MAP(BUS_ERROR_UNIT_MASKED, ERFKILL),
SD_BUS_ERROR_MAP(BUS_ERROR_UNIT_GENERATED, EADDRNOTAVAIL),
SD_BUS_ERROR_MAP(BUS_ERROR_UNIT_LINKED, ELOOP),
SD_BUS_ERROR_MAP(BUS_ERROR_JOB_TYPE_NOT_APPLICABLE, EBADR),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_ISOLATION, EPERM),
SD_BUS_ERROR_MAP(BUS_ERROR_SHUTTING_DOWN, ECANCELED),
SD_BUS_ERROR_MAP(BUS_ERROR_SCOPE_NOT_RUNNING, EHOSTDOWN),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_DYNAMIC_USER, ESRCH),
SD_BUS_ERROR_MAP(BUS_ERROR_NOT_REFERENCED, EUNATCH),
SD_BUS_ERROR_MAP(BUS_ERROR_DISK_FULL, ENOSPC),
SD_BUS_ERROR_MAP(BUS_ERROR_FILE_DESCRIPTOR_STORE_DISABLED,
EHOSTDOWN),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_MACHINE, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_IMAGE, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_MACHINE_FOR_PID, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_MACHINE_EXISTS, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_PRIVATE_NETWORKING, ENOSYS),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_USER_MAPPING, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_GROUP_MAPPING, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_PORTABLE_IMAGE, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_BAD_PORTABLE_IMAGE_TYPE, EMEDIUMTYPE),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_SESSION, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SESSION_FOR_PID, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_USER, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_USER_FOR_PID, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_SEAT, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_SESSION_NOT_ON_SEAT, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_NOT_IN_CONTROL, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_DEVICE_IS_TAKEN, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_DEVICE_NOT_TAKEN, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_OPERATION_IN_PROGRESS, EINPROGRESS),
SD_BUS_ERROR_MAP(BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_SESSION_BUSY, EBUSY),
SD_BUS_ERROR_MAP(BUS_ERROR_NOT_YOUR_DEVICE, EPERM),
SD_BUS_ERROR_MAP(BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED, EALREADY),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_NTP_SUPPORT, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_PROCESS, ESRCH),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_NAME_SERVERS, ESRCH),
SD_BUS_ERROR_MAP(BUS_ERROR_INVALID_REPLY, EINVAL),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_RR, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_CNAME_LOOP, EDEADLK),
SD_BUS_ERROR_MAP(BUS_ERROR_ABORTED, ECANCELED),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_SERVICE, EUNATCH),
SD_BUS_ERROR_MAP(BUS_ERROR_DNSSEC_FAILED, EHOSTUNREACH),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_TRUST_ANCHOR, EHOSTUNREACH),
SD_BUS_ERROR_MAP(BUS_ERROR_RR_TYPE_UNSUPPORTED, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_LINK, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_LINK_BUSY, EBUSY),
SD_BUS_ERROR_MAP(BUS_ERROR_NETWORK_DOWN, ENETDOWN),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SOURCE, ESRCH),
SD_BUS_ERROR_MAP(BUS_ERROR_STUB_LOOP, ELOOP),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_DNSSD_SERVICE, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_DNSSD_SERVICE_EXISTS, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_FORMERR, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_SERVFAIL, EHOSTDOWN),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_NXDOMAIN, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_NOTIMP, ENOSYS),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_REFUSED, EACCES),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_YXDOMAIN, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_YRRSET, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_NXRRSET, ENOENT),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_NOTAUTH, EACCES),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_NOTZONE, EREMOTE),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADVERS, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADKEY, EKEYREJECTED),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADTIME, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADMODE, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADNAME, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADALG, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADTRUNC, EBADMSG),
SD_BUS_ERROR_MAP(BUS_ERROR_DNS_BADCOOKIE, EBADR),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_TRANSFER, ENXIO),
SD_BUS_ERROR_MAP(BUS_ERROR_TRANSFER_IN_PROGRESS, EBUSY),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_PRODUCT_UUID, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_FILE_IS_PROTECTED, EACCES),
SD_BUS_ERROR_MAP(BUS_ERROR_READ_ONLY_FILESYSTEM, EROFS),
SD_BUS_ERROR_MAP(BUS_ERROR_SPEED_METER_INACTIVE, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_UNMANAGED_INTERFACE, EOPNOTSUPP),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_SUCH_HOME, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_UID_IN_USE, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_USER_NAME_EXISTS, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_EXISTS, EEXIST),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_ALREADY_ACTIVE, EALREADY),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_ALREADY_FIXATED, EALREADY),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_UNFIXATED, EADDRNOTAVAIL),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_NOT_ACTIVE, EALREADY),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_ABSENT, EREMOTE),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_BUSY, EBUSY),
SD_BUS_ERROR_MAP(BUS_ERROR_BAD_PASSWORD, ENOKEY),
SD_BUS_ERROR_MAP(BUS_ERROR_LOW_PASSWORD_QUALITY, EUCLEAN),
SD_BUS_ERROR_MAP(BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN, EBADSLT),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_PIN_NEEDED, ENOANO),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_PROTECTED_AUTHENTICATION_PATH_NEEDED, ERFKILL),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_USER_PRESENCE_NEEDED, EMEDIUMTYPE),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_USER_VERIFICATION_NEEDED, ENOCSI),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_ACTION_TIMEOUT, ENOSTR),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_PIN_LOCKED, EOWNERDEAD),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_BAD_PIN, ENOLCK),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_BAD_PIN_FEW_TRIES_LEFT, ETOOMANYREFS),
SD_BUS_ERROR_MAP(BUS_ERROR_TOKEN_BAD_PIN_ONE_TRY_LEFT, EUCLEAN),
SD_BUS_ERROR_MAP(BUS_ERROR_BAD_SIGNATURE, EKEYREJECTED),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_RECORD_MISMATCH, EUCLEAN),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_RECORD_DOWNGRADE, ESTALE),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_RECORD_SIGNED, EROFS),
SD_BUS_ERROR_MAP(BUS_ERROR_BAD_HOME_SIZE, ERANGE),
SD_BUS_ERROR_MAP(BUS_ERROR_NO_PRIVATE_KEY, ENOPKG),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_LOCKED, ENOEXEC),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_NOT_LOCKED, ENOEXEC),
SD_BUS_ERROR_MAP(BUS_ERROR_TOO_MANY_OPERATIONS, ENOBUFS),
SD_BUS_ERROR_MAP(BUS_ERROR_AUTHENTICATION_LIMIT_HIT, ETOOMANYREFS),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_CANT_AUTHENTICATE, EKEYREVOKED),
SD_BUS_ERROR_MAP(BUS_ERROR_HOME_IN_USE, EADDRINUSE),
SD_BUS_ERROR_MAP(BUS_ERROR_REBALANCE_NOT_NEEDED, EALREADY),
SD_BUS_ERROR_MAP_END
};
| 9,796 | 63.453947 | 88 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-common-errors.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "bus-error.h"
#define BUS_ERROR_NO_SUCH_UNIT "org.freedesktop.systemd1.NoSuchUnit"
#define BUS_ERROR_NO_UNIT_FOR_PID "org.freedesktop.systemd1.NoUnitForPID"
#define BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID "org.freedesktop.systemd1.NoUnitForInvocationID"
#define BUS_ERROR_UNIT_EXISTS "org.freedesktop.systemd1.UnitExists"
#define BUS_ERROR_LOAD_FAILED "org.freedesktop.systemd1.LoadFailed"
#define BUS_ERROR_BAD_UNIT_SETTING "org.freedesktop.systemd1.BadUnitSetting"
#define BUS_ERROR_JOB_FAILED "org.freedesktop.systemd1.JobFailed"
#define BUS_ERROR_NO_SUCH_JOB "org.freedesktop.systemd1.NoSuchJob"
#define BUS_ERROR_NOT_SUBSCRIBED "org.freedesktop.systemd1.NotSubscribed"
#define BUS_ERROR_ALREADY_SUBSCRIBED "org.freedesktop.systemd1.AlreadySubscribed"
#define BUS_ERROR_ONLY_BY_DEPENDENCY "org.freedesktop.systemd1.OnlyByDependency"
#define BUS_ERROR_TRANSACTION_JOBS_CONFLICTING "org.freedesktop.systemd1.TransactionJobsConflicting"
#define BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC "org.freedesktop.systemd1.TransactionOrderIsCyclic"
#define BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE "org.freedesktop.systemd1.TransactionIsDestructive"
#define BUS_ERROR_UNIT_MASKED "org.freedesktop.systemd1.UnitMasked"
#define BUS_ERROR_UNIT_GENERATED "org.freedesktop.systemd1.UnitGenerated"
#define BUS_ERROR_UNIT_LINKED "org.freedesktop.systemd1.UnitLinked"
#define BUS_ERROR_UNIT_BAD_PATH "org.freedesktop.systemd1.UnitBadPath"
#define BUS_ERROR_JOB_TYPE_NOT_APPLICABLE "org.freedesktop.systemd1.JobTypeNotApplicable"
#define BUS_ERROR_NO_ISOLATION "org.freedesktop.systemd1.NoIsolation"
#define BUS_ERROR_SHUTTING_DOWN "org.freedesktop.systemd1.ShuttingDown"
#define BUS_ERROR_SCOPE_NOT_RUNNING "org.freedesktop.systemd1.ScopeNotRunning"
#define BUS_ERROR_NO_SUCH_DYNAMIC_USER "org.freedesktop.systemd1.NoSuchDynamicUser"
#define BUS_ERROR_NOT_REFERENCED "org.freedesktop.systemd1.NotReferenced"
#define BUS_ERROR_DISK_FULL "org.freedesktop.systemd1.DiskFull"
#define BUS_ERROR_NOTHING_TO_CLEAN "org.freedesktop.systemd1.NothingToClean"
#define BUS_ERROR_UNIT_BUSY "org.freedesktop.systemd1.UnitBusy"
#define BUS_ERROR_UNIT_INACTIVE "org.freedesktop.systemd1.UnitInactive"
#define BUS_ERROR_FREEZE_CANCELLED "org.freedesktop.systemd1.FreezeCancelled"
#define BUS_ERROR_FILE_DESCRIPTOR_STORE_DISABLED \
"org.freedesktop.systemd1.FileDescriptorStoreDisabled"
#define BUS_ERROR_NO_SUCH_MACHINE "org.freedesktop.machine1.NoSuchMachine"
#define BUS_ERROR_NO_SUCH_IMAGE "org.freedesktop.machine1.NoSuchImage"
#define BUS_ERROR_NO_MACHINE_FOR_PID "org.freedesktop.machine1.NoMachineForPID"
#define BUS_ERROR_MACHINE_EXISTS "org.freedesktop.machine1.MachineExists"
#define BUS_ERROR_NO_PRIVATE_NETWORKING "org.freedesktop.machine1.NoPrivateNetworking"
#define BUS_ERROR_NO_SUCH_USER_MAPPING "org.freedesktop.machine1.NoSuchUserMapping"
#define BUS_ERROR_NO_SUCH_GROUP_MAPPING "org.freedesktop.machine1.NoSuchGroupMapping"
#define BUS_ERROR_NO_SUCH_PORTABLE_IMAGE "org.freedesktop.portable1.NoSuchImage"
#define BUS_ERROR_BAD_PORTABLE_IMAGE_TYPE "org.freedesktop.portable1.BadImageType"
#define BUS_ERROR_NO_SUCH_SESSION "org.freedesktop.login1.NoSuchSession"
#define BUS_ERROR_NO_SESSION_FOR_PID "org.freedesktop.login1.NoSessionForPID"
#define BUS_ERROR_NO_SUCH_USER "org.freedesktop.login1.NoSuchUser"
#define BUS_ERROR_NO_USER_FOR_PID "org.freedesktop.login1.NoUserForPID"
#define BUS_ERROR_NO_SUCH_SEAT "org.freedesktop.login1.NoSuchSeat"
#define BUS_ERROR_SESSION_NOT_ON_SEAT "org.freedesktop.login1.SessionNotOnSeat"
#define BUS_ERROR_NOT_IN_CONTROL "org.freedesktop.login1.NotInControl"
#define BUS_ERROR_DEVICE_IS_TAKEN "org.freedesktop.login1.DeviceIsTaken"
#define BUS_ERROR_DEVICE_NOT_TAKEN "org.freedesktop.login1.DeviceNotTaken"
#define BUS_ERROR_OPERATION_IN_PROGRESS "org.freedesktop.login1.OperationInProgress"
#define BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED "org.freedesktop.login1.SleepVerbNotSupported"
#define BUS_ERROR_SESSION_BUSY "org.freedesktop.login1.SessionBusy"
#define BUS_ERROR_NOT_YOUR_DEVICE "org.freedesktop.login1.NotYourDevice"
#define BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED "org.freedesktop.timedate1.AutomaticTimeSyncEnabled"
#define BUS_ERROR_NO_NTP_SUPPORT "org.freedesktop.timedate1.NoNTPSupport"
#define BUS_ERROR_NO_SUCH_PROCESS "org.freedesktop.systemd1.NoSuchProcess"
#define BUS_ERROR_NO_NAME_SERVERS "org.freedesktop.resolve1.NoNameServers"
#define BUS_ERROR_INVALID_REPLY "org.freedesktop.resolve1.InvalidReply"
#define BUS_ERROR_NO_SUCH_RR "org.freedesktop.resolve1.NoSuchRR"
#define BUS_ERROR_CNAME_LOOP "org.freedesktop.resolve1.CNameLoop"
#define BUS_ERROR_ABORTED "org.freedesktop.resolve1.Aborted"
#define BUS_ERROR_NO_SUCH_SERVICE "org.freedesktop.resolve1.NoSuchService"
#define BUS_ERROR_DNSSEC_FAILED "org.freedesktop.resolve1.DnssecFailed"
#define BUS_ERROR_NO_TRUST_ANCHOR "org.freedesktop.resolve1.NoTrustAnchor"
#define BUS_ERROR_RR_TYPE_UNSUPPORTED "org.freedesktop.resolve1.ResourceRecordTypeUnsupported"
#define BUS_ERROR_NO_SUCH_LINK "org.freedesktop.resolve1.NoSuchLink"
#define BUS_ERROR_LINK_BUSY "org.freedesktop.resolve1.LinkBusy"
#define BUS_ERROR_NETWORK_DOWN "org.freedesktop.resolve1.NetworkDown"
#define BUS_ERROR_NO_SOURCE "org.freedesktop.resolve1.NoSource"
#define BUS_ERROR_STUB_LOOP "org.freedesktop.resolve1.StubLoop"
#define BUS_ERROR_NO_SUCH_DNSSD_SERVICE "org.freedesktop.resolve1.NoSuchDnssdService"
#define BUS_ERROR_DNSSD_SERVICE_EXISTS "org.freedesktop.resolve1.DnssdServiceExists"
#define _BUS_ERROR_DNS "org.freedesktop.resolve1.DnsError."
#define BUS_ERROR_DNS_FORMERR _BUS_ERROR_DNS "FORMERR"
#define BUS_ERROR_DNS_SERVFAIL _BUS_ERROR_DNS "SERVFAIL"
#define BUS_ERROR_DNS_NXDOMAIN _BUS_ERROR_DNS "NXDOMAIN"
#define BUS_ERROR_DNS_NOTIMP _BUS_ERROR_DNS "NOTIMP"
#define BUS_ERROR_DNS_REFUSED _BUS_ERROR_DNS "REFUSED"
#define BUS_ERROR_DNS_YXDOMAIN _BUS_ERROR_DNS "YXDOMAIN"
#define BUS_ERROR_DNS_YRRSET _BUS_ERROR_DNS "YRRSET"
#define BUS_ERROR_DNS_NXRRSET _BUS_ERROR_DNS "NXRRSET"
#define BUS_ERROR_DNS_NOTAUTH _BUS_ERROR_DNS "NOTAUTH"
#define BUS_ERROR_DNS_NOTZONE _BUS_ERROR_DNS "NOTZONE"
#define BUS_ERROR_DNS_BADVERS _BUS_ERROR_DNS "BADVERS"
#define BUS_ERROR_DNS_BADKEY _BUS_ERROR_DNS "BADKEY"
#define BUS_ERROR_DNS_BADTIME _BUS_ERROR_DNS "BADTIME"
#define BUS_ERROR_DNS_BADMODE _BUS_ERROR_DNS "BADMODE"
#define BUS_ERROR_DNS_BADNAME _BUS_ERROR_DNS "BADNAME"
#define BUS_ERROR_DNS_BADALG _BUS_ERROR_DNS "BADALG"
#define BUS_ERROR_DNS_BADTRUNC _BUS_ERROR_DNS "BADTRUNC"
#define BUS_ERROR_DNS_BADCOOKIE _BUS_ERROR_DNS "BADCOOKIE"
#define BUS_ERROR_NO_SUCH_TRANSFER "org.freedesktop.import1.NoSuchTransfer"
#define BUS_ERROR_TRANSFER_IN_PROGRESS "org.freedesktop.import1.TransferInProgress"
#define BUS_ERROR_NO_PRODUCT_UUID "org.freedesktop.hostname1.NoProductUUID"
#define BUS_ERROR_FILE_IS_PROTECTED "org.freedesktop.hostname1.FileIsProtected"
#define BUS_ERROR_READ_ONLY_FILESYSTEM "org.freedesktop.hostname1.ReadOnlyFilesystem"
#define BUS_ERROR_SPEED_METER_INACTIVE "org.freedesktop.network1.SpeedMeterInactive"
#define BUS_ERROR_UNMANAGED_INTERFACE "org.freedesktop.network1.UnmanagedInterface"
#define BUS_ERROR_NO_SUCH_HOME "org.freedesktop.home1.NoSuchHome"
#define BUS_ERROR_UID_IN_USE "org.freedesktop.home1.UIDInUse"
#define BUS_ERROR_USER_NAME_EXISTS "org.freedesktop.home1.UserNameExists"
#define BUS_ERROR_HOME_EXISTS "org.freedesktop.home1.HomeExists"
#define BUS_ERROR_HOME_ALREADY_ACTIVE "org.freedesktop.home1.HomeAlreadyActive"
#define BUS_ERROR_HOME_ALREADY_FIXATED "org.freedesktop.home1.HomeAlreadyFixated"
#define BUS_ERROR_HOME_UNFIXATED "org.freedesktop.home1.HomeUnfixated"
#define BUS_ERROR_HOME_NOT_ACTIVE "org.freedesktop.home1.HomeNotActive"
#define BUS_ERROR_HOME_ABSENT "org.freedesktop.home1.HomeAbsent"
#define BUS_ERROR_HOME_BUSY "org.freedesktop.home1.HomeBusy"
#define BUS_ERROR_BAD_PASSWORD "org.freedesktop.home1.BadPassword"
#define BUS_ERROR_BAD_RECOVERY_KEY "org.freedesktop.home1.BadRecoveryKey"
#define BUS_ERROR_LOW_PASSWORD_QUALITY "org.freedesktop.home1.LowPasswordQuality"
#define BUS_ERROR_BAD_PASSWORD_AND_NO_TOKEN "org.freedesktop.home1.BadPasswordAndNoToken"
#define BUS_ERROR_TOKEN_PIN_NEEDED "org.freedesktop.home1.TokenPinNeeded"
#define BUS_ERROR_TOKEN_PROTECTED_AUTHENTICATION_PATH_NEEDED \
"org.freedesktop.home1.TokenProtectedAuthenticationPathNeeded"
#define BUS_ERROR_TOKEN_USER_PRESENCE_NEEDED "org.freedesktop.home1.TokenUserPresenceNeeded"
#define BUS_ERROR_TOKEN_USER_VERIFICATION_NEEDED \
"org.freedesktop.home1.TokenUserVerificationNeeded"
#define BUS_ERROR_TOKEN_ACTION_TIMEOUT "org.freedesktop.home1.TokenActionTimeout"
#define BUS_ERROR_TOKEN_PIN_LOCKED "org.freedesktop.home1.TokenPinLocked"
#define BUS_ERROR_TOKEN_BAD_PIN "org.freedesktop.home1.BadPin"
#define BUS_ERROR_TOKEN_BAD_PIN_FEW_TRIES_LEFT "org.freedesktop.home1.BadPinFewTriesLeft"
#define BUS_ERROR_TOKEN_BAD_PIN_ONE_TRY_LEFT "org.freedesktop.home1.BadPinOneTryLeft"
#define BUS_ERROR_BAD_SIGNATURE "org.freedesktop.home1.BadSignature"
#define BUS_ERROR_HOME_RECORD_MISMATCH "org.freedesktop.home1.RecordMismatch"
#define BUS_ERROR_HOME_RECORD_DOWNGRADE "org.freedesktop.home1.RecordDowngrade"
#define BUS_ERROR_HOME_RECORD_SIGNED "org.freedesktop.home1.RecordSigned"
#define BUS_ERROR_BAD_HOME_SIZE "org.freedesktop.home1.BadHomeSize"
#define BUS_ERROR_NO_PRIVATE_KEY "org.freedesktop.home1.NoPrivateKey"
#define BUS_ERROR_HOME_LOCKED "org.freedesktop.home1.HomeLocked"
#define BUS_ERROR_HOME_NOT_LOCKED "org.freedesktop.home1.HomeNotLocked"
#define BUS_ERROR_NO_DISK_SPACE "org.freedesktop.home1.NoDiskSpace"
#define BUS_ERROR_TOO_MANY_OPERATIONS "org.freedesktop.home1.TooManyOperations"
#define BUS_ERROR_AUTHENTICATION_LIMIT_HIT "org.freedesktop.home1.AuthenticationLimitHit"
#define BUS_ERROR_HOME_CANT_AUTHENTICATE "org.freedesktop.home1.HomeCantAuthenticate"
#define BUS_ERROR_HOME_IN_USE "org.freedesktop.home1.HomeInUse"
#define BUS_ERROR_REBALANCE_NOT_NEEDED "org.freedesktop.home1.RebalanceNotNeeded"
BUS_ERROR_MAP_ELF_USE(bus_common_errors);
| 11,842 | 74.916667 | 109 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-container.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <unistd.h>
#include "bus-container.h"
#include "bus-internal.h"
#include "bus-socket.h"
#include "fd-util.h"
#include "namespace-util.h"
#include "process-util.h"
#include "string-util.h"
int bus_container_connect_socket(sd_bus *b) {
_cleanup_close_pair_ int pair[2] = PIPE_EBADF;
_cleanup_close_ int pidnsfd = -EBADF, mntnsfd = -EBADF, usernsfd = -EBADF, rootfd = -EBADF;
int r, error_buf = 0;
pid_t child;
ssize_t n;
assert(b);
assert(b->input_fd < 0);
assert(b->output_fd < 0);
assert(b->nspid > 0 || b->machine);
if (b->nspid <= 0) {
log_debug("sd-bus: connecting bus%s%s to machine %s...",
b->description ? " " : "", strempty(b->description), b->machine);
r = container_get_leader(b->machine, &b->nspid);
if (r < 0)
return r;
} else
log_debug("sd-bus: connecting bus%s%s to namespace of PID "PID_FMT"...",
b->description ? " " : "", strempty(b->description), b->nspid);
r = namespace_open(b->nspid, &pidnsfd, &mntnsfd, NULL, &usernsfd, &rootfd);
if (r < 0)
return log_debug_errno(r, "Failed to open namespace of PID "PID_FMT": %m", b->nspid);
b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
if (b->input_fd < 0)
return log_debug_errno(errno, "Failed to create a socket: %m");
b->input_fd = fd_move_above_stdio(b->input_fd);
b->output_fd = b->input_fd;
bus_socket_setup(b);
if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, pair) < 0)
return log_debug_errno(errno, "Failed to create a socket pair: %m");
r = namespace_fork("(sd-buscntrns)", "(sd-buscntr)", NULL, 0, FORK_RESET_SIGNALS|FORK_DEATHSIG,
pidnsfd, mntnsfd, -1, usernsfd, rootfd, &child);
if (r < 0)
return log_debug_errno(r, "Failed to create namespace for (sd-buscntr): %m");
if (r == 0) {
pair[0] = safe_close(pair[0]);
r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
if (r < 0) {
/* Try to send error up */
error_buf = errno;
(void) write(pair[1], &error_buf, sizeof(error_buf));
_exit(EXIT_FAILURE);
}
_exit(EXIT_SUCCESS);
}
pair[1] = safe_close(pair[1]);
r = wait_for_terminate_and_check("(sd-buscntrns)", child, 0);
if (r < 0)
return r;
bool nonzero_exit_status = r != EXIT_SUCCESS;
n = read(pair[0], &error_buf, sizeof(error_buf));
if (n < 0)
return log_debug_errno(errno, "Failed to read error status from (sd-buscntr): %m");
if (n > 0) {
if (n != sizeof(error_buf))
return log_debug_errno(SYNTHETIC_ERRNO(EIO),
"Read error status of unexpected length %zd from (sd-buscntr): %m", n);
if (error_buf < 0)
return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
"Got unexpected error status from (sd-buscntr): %m");
if (error_buf == EINPROGRESS)
return 1;
if (error_buf > 0)
return log_debug_errno(error_buf, "(sd-buscntr) failed to connect to D-Bus socket: %m");
}
if (nonzero_exit_status)
return -EPROTO;
return bus_socket_start_auth(b);
}
| 3,841 | 35.942308 | 118 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-error.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include "sd-bus.h"
#include "alloc-util.h"
#include "bus-error.h"
#include "errno-list.h"
#include "errno-util.h"
#include "string-util.h"
#include "strv.h"
BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map bus_standard_errors[] = {
SD_BUS_ERROR_MAP(SD_BUS_ERROR_FAILED, EACCES),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_NO_MEMORY, ENOMEM),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_SERVICE_UNKNOWN, EHOSTUNREACH),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_NAME_HAS_NO_OWNER, ENXIO),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_NO_REPLY, ETIMEDOUT),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_IO_ERROR, EIO),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_BAD_ADDRESS, EADDRNOTAVAIL),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_NOT_SUPPORTED, EOPNOTSUPP),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_LIMITS_EXCEEDED, ENOBUFS),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_ACCESS_DENIED, EACCES),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_AUTH_FAILED, EACCES),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_NO_SERVER, EHOSTDOWN),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_TIMEOUT, ETIMEDOUT),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_NO_NETWORK, ENONET),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_ADDRESS_IN_USE, EADDRINUSE),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_DISCONNECTED, ECONNRESET),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_INVALID_ARGS, EINVAL),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_FILE_NOT_FOUND, ENOENT),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_FILE_EXISTS, EEXIST),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_UNKNOWN_METHOD, EBADR),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_UNKNOWN_OBJECT, EBADR),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_UNKNOWN_INTERFACE, EBADR),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_UNKNOWN_PROPERTY, EBADR),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_PROPERTY_READ_ONLY, EROFS),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, ESRCH),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_INVALID_SIGNATURE, EINVAL),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_INCONSISTENT_MESSAGE, EBADMSG),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_TIMED_OUT, ETIMEDOUT),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_MATCH_RULE_NOT_FOUND, ENOENT),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_MATCH_RULE_INVALID, EINVAL),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_INTERACTIVE_AUTHORIZATION_REQUIRED, EACCES),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_INVALID_FILE_CONTENT, EINVAL),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN, ESRCH),
SD_BUS_ERROR_MAP(SD_BUS_ERROR_OBJECT_PATH_IN_USE, EBUSY),
SD_BUS_ERROR_MAP_END
};
/* GCC maps this magically to the beginning and end of the BUS_ERROR_MAP section */
extern const sd_bus_error_map __start_SYSTEMD_BUS_ERROR_MAP[];
extern const sd_bus_error_map __stop_SYSTEMD_BUS_ERROR_MAP[];
/* Additional maps registered with sd_bus_error_add_map() are in this
* NULL terminated array */
static const sd_bus_error_map **additional_error_maps = NULL;
static int bus_error_name_to_errno(const char *name) {
const sd_bus_error_map **map, *m;
const char *p;
int r;
if (!name)
return EINVAL;
p = startswith(name, "System.Error.");
if (p) {
r = errno_from_name(p);
if (r < 0)
return EIO;
return r;
}
if (additional_error_maps)
for (map = additional_error_maps; *map; map++)
for (m = *map;; m++) {
/* For additional error maps the end marker is actually the end marker */
if (m->code == BUS_ERROR_MAP_END_MARKER)
break;
if (streq(m->name, name)) {
assert(m->code > 0);
return m->code;
}
}
m = ALIGN_PTR(__start_SYSTEMD_BUS_ERROR_MAP);
while (m < __stop_SYSTEMD_BUS_ERROR_MAP) {
/* For magic ELF error maps, the end marker might
* appear in the middle of things, since multiple maps
* might appear in the same section. Hence, let's skip
* over it, but realign the pointer to the next 8 byte
* boundary, which is the selected alignment for the
* arrays. */
if (m->code == BUS_ERROR_MAP_END_MARKER) {
m = ALIGN_PTR(m + 1);
continue;
}
if (streq(m->name, name)) {
assert(m->code > 0);
return m->code;
}
m++;
}
return EIO;
}
static sd_bus_error errno_to_bus_error_const(int error) {
if (error < 0)
error = -error;
switch (error) {
case ENOMEM:
return BUS_ERROR_OOM;
case EPERM:
case EACCES:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_ACCESS_DENIED, "Access denied");
case EINVAL:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INVALID_ARGS, "Invalid argument");
case ESRCH:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, "No such process");
case ENOENT:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_NOT_FOUND, "File not found");
case EEXIST:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_EXISTS, "File exists");
case ETIMEDOUT:
case ETIME:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_TIMEOUT, "Timed out");
case EIO:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_IO_ERROR, "Input/output error");
case ENETRESET:
case ECONNABORTED:
case ECONNRESET:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_DISCONNECTED, "Disconnected");
case EOPNOTSUPP:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NOT_SUPPORTED, "Not supported");
case EADDRNOTAVAIL:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_BAD_ADDRESS, "Address not available");
case ENOBUFS:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_LIMITS_EXCEEDED, "Limits exceeded");
case EADDRINUSE:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_ADDRESS_IN_USE, "Address in use");
case EBADMSG:
return SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Inconsistent message");
}
return SD_BUS_ERROR_NULL;
}
static int errno_to_bus_error_name_new(int error, char **ret) {
const char *name;
char *n;
if (error < 0)
error = -error;
name = errno_to_name(error);
if (!name)
return 0;
n = strjoin("System.Error.", name);
if (!n)
return -ENOMEM;
*ret = n;
return 1;
}
bool bus_error_is_dirty(sd_bus_error *e) {
if (!e)
return false;
return e->name || e->message || e->_need_free != 0;
}
_public_ void sd_bus_error_free(sd_bus_error *e) {
if (!e)
return;
if (e->_need_free > 0) {
free((void*) e->name);
free((void*) e->message);
}
*e = SD_BUS_ERROR_NULL;
}
_public_ int sd_bus_error_set(sd_bus_error *e, const char *name, const char *message) {
int r;
if (!name)
return 0;
if (e) {
assert_return(!bus_error_is_dirty(e), -EINVAL);
e->name = strdup(name);
if (!e->name) {
*e = BUS_ERROR_OOM;
return -ENOMEM;
}
if (message)
e->message = strdup(message);
e->_need_free = 1;
}
r = bus_error_name_to_errno(name);
assert(r > 0);
return -r;
}
_public_ int sd_bus_error_setfv(sd_bus_error *e, const char *name, const char *format, va_list ap) {
int r;
if (!name)
return 0;
if (e) {
assert_return(!bus_error_is_dirty(e), -EINVAL);
e->name = strdup(name);
if (!e->name) {
*e = BUS_ERROR_OOM;
return -ENOMEM;
}
if (format) {
_cleanup_free_ char *mesg = NULL;
/* If we hit OOM on formatting the pretty message, we ignore
* this, since we at least managed to write the error name */
if (vasprintf(&mesg, format, ap) >= 0)
e->message = TAKE_PTR(mesg);
}
e->_need_free = 1;
}
r = bus_error_name_to_errno(name);
assert(r > 0);
return -r;
}
_public_ int sd_bus_error_setf(sd_bus_error *e, const char *name, const char *format, ...) {
int r;
if (format) {
va_list ap;
va_start(ap, format);
r = sd_bus_error_setfv(e, name, format, ap);
assert(!name || r < 0);
va_end(ap);
return r;
}
r = sd_bus_error_set(e, name, NULL);
assert(!name || r < 0);
return r;
}
_public_ int sd_bus_error_copy(sd_bus_error *dest, const sd_bus_error *e) {
if (!sd_bus_error_is_set(e))
return 0;
if (!dest)
goto finish;
assert_return(!bus_error_is_dirty(dest), -EINVAL);
/*
* _need_free < 0 indicates that the error is temporarily const, needs deep copying
* _need_free == 0 indicates that the error is perpetually const, needs no deep copying
* _need_free > 0 indicates that the error is fully dynamic, needs deep copying
*/
if (e->_need_free == 0)
*dest = *e;
else {
dest->name = strdup(e->name);
if (!dest->name) {
*dest = BUS_ERROR_OOM;
return -ENOMEM;
}
if (e->message)
dest->message = strdup(e->message);
dest->_need_free = 1;
}
finish:
return -bus_error_name_to_errno(e->name);
}
_public_ int sd_bus_error_move(sd_bus_error *dest, sd_bus_error *e) {
int r;
if (!sd_bus_error_is_set(e)) {
if (dest)
*dest = SD_BUS_ERROR_NULL;
return 0;
}
r = -bus_error_name_to_errno(e->name);
if (dest) {
*dest = *e;
*e = SD_BUS_ERROR_NULL;
} else
sd_bus_error_free(e);
return r;
}
_public_ int sd_bus_error_set_const(sd_bus_error *e, const char *name, const char *message) {
if (!name)
return 0;
if (!e)
goto finish;
assert_return(!bus_error_is_dirty(e), -EINVAL);
*e = SD_BUS_ERROR_MAKE_CONST(name, message);
finish:
return -bus_error_name_to_errno(name);
}
_public_ int sd_bus_error_is_set(const sd_bus_error *e) {
if (!e)
return 0;
return !!e->name;
}
_public_ int sd_bus_error_has_name(const sd_bus_error *e, const char *name) {
if (!e)
return 0;
return streq_ptr(e->name, name);
}
_public_ int sd_bus_error_has_names_sentinel(const sd_bus_error *e, ...) {
if (!e || !e->name)
return 0;
va_list ap;
const char *p;
va_start(ap, e);
while ((p = va_arg(ap, const char *)))
if (streq(p, e->name))
break;
va_end(ap);
return !!p;
}
_public_ int sd_bus_error_get_errno(const sd_bus_error* e) {
if (!e || !e->name)
return 0;
return bus_error_name_to_errno(e->name);
}
static void bus_error_strerror(sd_bus_error *e, int error) {
size_t k = 64;
char *m;
assert(e);
for (;;) {
char *x;
m = new(char, k);
if (!m)
return;
errno = 0;
x = strerror_r(error, m, k);
if (errno == ERANGE || strlen(x) >= k - 1) {
free(m);
k *= 2;
continue;
}
if (errno) {
free(m);
return;
}
if (x == m) {
if (e->_need_free > 0) {
/* Error is already dynamic, let's just update the message */
free((char*) e->message);
e->message = x;
} else {
char *t;
/* Error was const so far, let's make it dynamic, if we can */
t = strdup(e->name);
if (!t) {
free(m);
return;
}
e->_need_free = 1;
e->name = t;
e->message = x;
}
} else {
free(m);
if (e->_need_free > 0) {
char *t;
/* Error is dynamic, let's hence make the message also dynamic */
t = strdup(x);
if (!t)
return;
free((char*) e->message);
e->message = t;
} else {
/* Error is const, hence we can just override */
e->message = x;
}
}
return;
}
}
_public_ int sd_bus_error_set_errno(sd_bus_error *e, int error) {
if (error < 0)
error = -error;
if (!e)
return -error;
if (error == 0)
return 0;
assert_return(!bus_error_is_dirty(e), -EINVAL);
/* First, try a const translation */
*e = errno_to_bus_error_const(error);
if (!sd_bus_error_is_set(e)) {
int k;
/* If that didn't work, try a dynamic one. */
k = errno_to_bus_error_name_new(error, (char**) &e->name);
if (k > 0)
e->_need_free = 1;
else if (k < 0) {
*e = BUS_ERROR_OOM;
return -error;
} else
*e = BUS_ERROR_FAILED;
}
/* Now, fill in the message from strerror_r() if we can */
bus_error_strerror(e, error);
return -error;
}
_public_ int sd_bus_error_set_errnofv(sd_bus_error *e, int error, const char *format, va_list ap) {
PROTECT_ERRNO;
if (error < 0)
error = -error;
if (!e)
return -error;
if (error == 0)
return 0;
assert_return(!bus_error_is_dirty(e), -EINVAL);
/* First, try a const translation */
*e = errno_to_bus_error_const(error);
if (!sd_bus_error_is_set(e)) {
int k;
/* If that didn't work, try a dynamic one */
k = errno_to_bus_error_name_new(error, (char**) &e->name);
if (k > 0)
e->_need_free = 1;
else if (k < 0) {
*e = BUS_ERROR_OOM;
return -ENOMEM;
} else
*e = BUS_ERROR_FAILED;
}
if (format) {
_cleanup_free_ char *m = NULL;
/* Then, let's try to fill in the supplied message */
errno = error; /* Make sure that %m resolves to the specified error */
if (vasprintf(&m, format, ap) < 0)
goto fail;
if (e->_need_free <= 0) {
char *t;
t = strdup(e->name);
if (!t)
goto fail;
e->_need_free = 1;
e->name = t;
}
e->message = TAKE_PTR(m);
return -error;
}
fail:
/* If that didn't work, use strerror_r() for the message */
bus_error_strerror(e, error);
return -error;
}
_public_ int sd_bus_error_set_errnof(sd_bus_error *e, int error, const char *format, ...) {
int r;
if (error < 0)
error = -error;
if (!e)
return -error;
if (error == 0)
return 0;
assert_return(!bus_error_is_dirty(e), -EINVAL);
if (format) {
va_list ap;
va_start(ap, format);
r = sd_bus_error_set_errnofv(e, error, format, ap);
va_end(ap);
return r;
}
return sd_bus_error_set_errno(e, error);
}
const char* _bus_error_message(const sd_bus_error *e, int error, char buf[static ERRNO_BUF_LEN]) {
/* Sometimes, the D-Bus server is a little bit too verbose with
* its error messages, so let's override them here */
if (sd_bus_error_has_name(e, SD_BUS_ERROR_ACCESS_DENIED))
return "Access denied";
if (e && e->message)
return e->message;
return strerror_r(abs(error), buf, ERRNO_BUF_LEN);
}
static bool map_ok(const sd_bus_error_map *map) {
for (; map->code != BUS_ERROR_MAP_END_MARKER; map++)
if (!map->name || map->code <=0)
return false;
return true;
}
_public_ int sd_bus_error_add_map(const sd_bus_error_map *map) {
const sd_bus_error_map **maps = NULL;
unsigned n = 0;
assert_return(map, -EINVAL);
assert_return(map_ok(map), -EINVAL);
if (additional_error_maps)
for (; additional_error_maps[n] != NULL; n++)
if (additional_error_maps[n] == map)
return 0;
maps = reallocarray(additional_error_maps, n + 2, sizeof(struct sd_bus_error_map*));
if (!maps)
return -ENOMEM;
maps[n] = map;
maps[n+1] = NULL;
additional_error_maps = maps;
return 1;
}
| 19,697 | 30.316375 | 106 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-error.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "sd-bus.h"
#include "errno-util.h"
#include "macro.h"
bool bus_error_is_dirty(sd_bus_error *e);
const char* _bus_error_message(const sd_bus_error *e, int error, char buf[static ERRNO_BUF_LEN]);
/* Note: the lifetime of the compound literal is the immediately surrounding block,
* see C11 §6.5.2.5, and
* https://stackoverflow.com/questions/34880638/compound-literal-lifetime-and-if-blocks */
#define bus_error_message(e, error) _bus_error_message(e, error, (char[ERRNO_BUF_LEN]){})
#define BUS_ERROR_OOM SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_NO_MEMORY, "Out of memory")
#define BUS_ERROR_FAILED SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FAILED, "Operation failed")
/*
* There are two ways to register error maps with the error translation
* logic: by using BUS_ERROR_MAP_ELF_REGISTER, which however only
* works when linked into the same ELF module, or via
* sd_bus_error_add_map() which is the official, external API, that
* works from any module.
*
* Note that BUS_ERROR_MAP_ELF_REGISTER has to be used as decorator in
* the bus error table, and BUS_ERROR_MAP_ELF_USE has to be used at
* least once per compilation unit (i.e. per library), to ensure that
* the error map is really added to the final binary.
*
* In addition, set the retain attribute so that the section cannot be
* discarded by ld --gc-sections -z start-stop-gc. Older compilers would
* warn for the unknown attribute, so just disable -Wattributes.
*/
#define BUS_ERROR_MAP_ELF_REGISTER \
_Pragma("GCC diagnostic ignored \"-Wattributes\"") \
_section_("SYSTEMD_BUS_ERROR_MAP") \
_used_ \
_retain_ \
_alignptr_ \
_variable_no_sanitize_address_
#define BUS_ERROR_MAP_ELF_USE(errors) \
extern const sd_bus_error_map errors[]; \
_used_ \
static const sd_bus_error_map * const CONCATENATE(errors ## _copy_, __COUNTER__) = errors;
/* We use something exotic as end marker, to ensure people build the
* maps using the macsd-ros. */
#define BUS_ERROR_MAP_END_MARKER -'x'
BUS_ERROR_MAP_ELF_USE(bus_standard_errors);
| 2,523 | 42.517241 | 98 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <pthread.h>
#include "sd-bus.h"
#include "bus-error.h"
#include "bus-kernel.h"
#include "bus-match.h"
#include "constants.h"
#include "hashmap.h"
#include "list.h"
#include "prioq.h"
#include "runtime-scope.h"
#include "socket-util.h"
#include "time-util.h"
/* Note that we use the new /run prefix here (instead of /var/run) since we require them to be aliases and
* that way we become independent of /var being mounted */
#define DEFAULT_SYSTEM_BUS_ADDRESS "unix:path=/run/dbus/system_bus_socket"
#define DEFAULT_USER_BUS_ADDRESS_FMT "unix:path=%s/bus"
struct reply_callback {
sd_bus_message_handler_t callback;
usec_t timeout_usec; /* this is a relative timeout until we reach the BUS_HELLO state, and an absolute one right after */
uint64_t cookie;
unsigned prioq_idx;
};
struct filter_callback {
sd_bus_message_handler_t callback;
unsigned last_iteration;
LIST_FIELDS(struct filter_callback, callbacks);
};
struct match_callback {
sd_bus_message_handler_t callback;
sd_bus_message_handler_t install_callback;
sd_bus_slot *install_slot; /* The AddMatch() call */
unsigned last_iteration;
/* Don't dispatch this slot with messages that arrived in any iteration before or at the this
* one. We use this to ensure that matches don't apply "retroactively" and confuse the caller:
* only messages received after the match was installed will be considered. */
uint64_t after;
char *match_string;
struct bus_match_node *match_node;
};
struct node {
char *path;
struct node *parent;
LIST_HEAD(struct node, child);
LIST_FIELDS(struct node, siblings);
LIST_HEAD(struct node_callback, callbacks);
LIST_HEAD(struct node_vtable, vtables);
LIST_HEAD(struct node_enumerator, enumerators);
LIST_HEAD(struct node_object_manager, object_managers);
};
struct node_callback {
struct node *node;
bool is_fallback:1;
unsigned last_iteration;
sd_bus_message_handler_t callback;
LIST_FIELDS(struct node_callback, callbacks);
};
struct node_enumerator {
struct node *node;
sd_bus_node_enumerator_t callback;
unsigned last_iteration;
LIST_FIELDS(struct node_enumerator, enumerators);
};
struct node_object_manager {
struct node *node;
LIST_FIELDS(struct node_object_manager, object_managers);
};
struct node_vtable {
struct node *node;
bool is_fallback:1;
unsigned last_iteration;
char *interface;
const sd_bus_vtable *vtable;
sd_bus_object_find_t find;
LIST_FIELDS(struct node_vtable, vtables);
};
struct vtable_member {
const char *path;
const char *interface;
const char *member;
struct node_vtable *parent;
unsigned last_iteration;
const sd_bus_vtable *vtable;
};
typedef enum BusSlotType {
BUS_REPLY_CALLBACK,
BUS_FILTER_CALLBACK,
BUS_MATCH_CALLBACK,
BUS_NODE_CALLBACK,
BUS_NODE_ENUMERATOR,
BUS_NODE_VTABLE,
BUS_NODE_OBJECT_MANAGER,
_BUS_SLOT_INVALID = -EINVAL,
} BusSlotType;
struct sd_bus_slot {
unsigned n_ref;
BusSlotType type:8;
/* Slots can be "floating" or not. If they are not floating (the usual case) then they reference the
* bus object they are associated with. This means the bus object stays allocated at least as long as
* there is a slot around associated with it. If it is floating, then the slot's lifecycle is bound
* to the lifecycle of the bus: it will be disconnected from the bus when the bus is destroyed, and
* it keeping the slot reffed hence won't mean the bus stays reffed too. Internally this means the
* reference direction is reversed: floating slots objects are referenced by the bus object, and not
* vice versa. */
bool floating;
bool match_added;
sd_bus *bus;
void *userdata;
sd_bus_destroy_t destroy_callback;
char *description;
LIST_FIELDS(sd_bus_slot, slots);
union {
struct reply_callback reply_callback;
struct filter_callback filter_callback;
struct match_callback match_callback;
struct node_callback node_callback;
struct node_enumerator node_enumerator;
struct node_object_manager node_object_manager;
struct node_vtable node_vtable;
};
};
enum bus_state {
BUS_UNSET,
BUS_WATCH_BIND, /* waiting for the socket to appear via inotify */
BUS_OPENING, /* the kernel's connect() is still not ready */
BUS_AUTHENTICATING, /* we are currently in the "SASL" authorization phase of dbus */
BUS_HELLO, /* we are waiting for the Hello() response */
BUS_RUNNING,
BUS_CLOSING,
BUS_CLOSED,
_BUS_STATE_MAX,
};
static inline bool BUS_IS_OPEN(enum bus_state state) {
return state > BUS_UNSET && state < BUS_CLOSING;
}
enum bus_auth {
_BUS_AUTH_INVALID,
BUS_AUTH_EXTERNAL,
BUS_AUTH_ANONYMOUS
};
struct sd_bus {
unsigned n_ref;
enum bus_state state;
int input_fd, output_fd;
int inotify_fd;
int message_version;
int message_endian;
bool can_fds:1;
bool bus_client:1;
bool ucred_valid:1;
bool is_server:1;
bool anonymous_auth:1;
bool prefer_readv:1;
bool prefer_writev:1;
bool match_callbacks_modified:1;
bool filter_callbacks_modified:1;
bool nodes_modified:1;
bool trusted:1;
bool manual_peer_interface:1;
bool allow_interactive_authorization:1;
bool exit_on_disconnect:1;
bool exited:1;
bool exit_triggered:1;
bool is_local:1;
bool watch_bind:1;
bool is_monitor:1;
bool accept_fd:1;
bool attach_timestamp:1;
bool connected_signal:1;
bool close_on_exit:1;
RuntimeScope runtime_scope;
signed int use_memfd:2;
void *rbuffer;
size_t rbuffer_size;
sd_bus_message **rqueue;
size_t rqueue_size;
sd_bus_message **wqueue;
size_t wqueue_size;
size_t windex;
uint64_t cookie;
uint64_t read_counter; /* A counter for each incoming msg */
char *unique_name;
uint64_t unique_id;
struct bus_match_node match_callbacks;
Prioq *reply_callbacks_prioq;
OrderedHashmap *reply_callbacks;
LIST_HEAD(struct filter_callback, filter_callbacks);
Hashmap *nodes;
Hashmap *vtable_methods;
Hashmap *vtable_properties;
union sockaddr_union sockaddr;
socklen_t sockaddr_size;
pid_t nspid;
char *machine;
sd_id128_t server_id;
char *address;
unsigned address_index;
int last_connect_error;
enum bus_auth auth;
unsigned auth_index;
struct iovec auth_iovec[3];
size_t auth_rbegin;
char *auth_buffer;
usec_t auth_timeout;
struct ucred ucred;
char *label;
gid_t *groups;
size_t n_groups;
union sockaddr_union sockaddr_peer;
socklen_t sockaddr_size_peer;
uint64_t creds_mask;
int *fds;
size_t n_fds;
char *exec_path;
char **exec_argv;
/* We do locking around the memfd cache, since we want to
* allow people to process a sd_bus_message in a different
* thread then it was generated on and free it there. Since
* adding something to the memfd cache might happen when a
* message is released, we hence need to protect this bit with
* a mutex. */
pthread_mutex_t memfd_cache_mutex;
struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
unsigned n_memfd_cache;
uint64_t origin_id;
pid_t busexec_pid;
unsigned iteration_counter;
sd_event_source *input_io_event_source;
sd_event_source *output_io_event_source;
sd_event_source *time_event_source;
sd_event_source *quit_event_source;
sd_event_source *inotify_event_source;
sd_event *event;
int event_priority;
pid_t tid;
sd_bus_message *current_message;
sd_bus_slot *current_slot;
sd_bus_message_handler_t current_handler;
void *current_userdata;
sd_bus **default_bus_ptr;
char *description;
char *patch_sender;
sd_bus_track *track_queue;
LIST_HEAD(sd_bus_slot, slots);
LIST_HEAD(sd_bus_track, tracks);
int *inotify_watches;
size_t n_inotify_watches;
/* zero means use value specified by $SYSTEMD_BUS_TIMEOUT= environment variable or built-in default */
usec_t method_call_timeout;
};
/* For method calls we timeout at 25s, like in the D-Bus reference implementation */
#define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))
/* For the authentication phase we grant 90s, to provide extra room during boot, when RNGs and such are not filled up
* with enough entropy yet and might delay the boot */
#define BUS_AUTH_TIMEOUT ((usec_t) DEFAULT_TIMEOUT_USEC)
#define BUS_WQUEUE_MAX (384*1024)
#define BUS_RQUEUE_MAX (384*1024)
#define BUS_MESSAGE_SIZE_MAX (128*1024*1024)
#define BUS_AUTH_SIZE_MAX (64*1024)
/* Note that the D-Bus specification states that bus paths shall have no size limit. We enforce here one
* anyway, since truly unbounded strings are a security problem. The limit we pick is relatively large however,
* to not clash unnecessarily with real-life applications. */
#define BUS_PATH_SIZE_MAX (64*1024)
#define BUS_CONTAINER_DEPTH 128
/* Defined by the specification as maximum size of an array in bytes */
#define BUS_ARRAY_MAX_SIZE 67108864
#define BUS_FDS_MAX 1024
#define BUS_EXEC_ARGV_MAX 256
bool interface_name_is_valid(const char *p) _pure_;
bool service_name_is_valid(const char *p) _pure_;
bool member_name_is_valid(const char *p) _pure_;
bool object_path_is_valid(const char *p) _pure_;
char *object_path_startswith(const char *a, const char *b) _pure_;
bool namespace_complex_pattern(const char *pattern, const char *value) _pure_;
bool path_complex_pattern(const char *pattern, const char *value) _pure_;
bool namespace_simple_pattern(const char *pattern, const char *value) _pure_;
bool path_simple_pattern(const char *pattern, const char *value) _pure_;
int bus_message_type_from_string(const char *s, uint8_t *u);
const char *bus_message_type_to_string(uint8_t u) _pure_;
#define error_name_is_valid interface_name_is_valid
sd_bus *bus_resolve(sd_bus *bus);
int bus_ensure_running(sd_bus *bus);
int bus_start_running(sd_bus *bus);
int bus_next_address(sd_bus *bus);
int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m);
int bus_rqueue_make_room(sd_bus *bus);
bool bus_origin_changed(sd_bus *bus);
char *bus_address_escape(const char *v);
int bus_attach_io_events(sd_bus *b);
int bus_attach_inotify_event(sd_bus *b);
void bus_close_inotify_fd(sd_bus *b);
void bus_close_io_fds(sd_bus *b);
int bus_add_match_full(
sd_bus *bus,
sd_bus_slot **slot,
bool asynchronous,
const char *match,
sd_bus_message_handler_t callback,
sd_bus_message_handler_t install_callback,
void *userdata,
uint64_t timeout_usec);
#define OBJECT_PATH_FOREACH_PREFIX(prefix, path) \
for (char *_slash = ({ strcpy((prefix), (path)); streq((prefix), "/") ? NULL : strrchr((prefix), '/'); }) ; \
_slash && ((_slash[(_slash) == (prefix)] = 0), true); \
_slash = streq((prefix), "/") ? NULL : strrchr((prefix), '/'))
/* If we are invoking callbacks of a bus object, ensure unreffing the
* bus from the callback doesn't destroy the object we are working on */
#define BUS_DONT_DESTROY(bus) \
_cleanup_(sd_bus_unrefp) _unused_ sd_bus *_dont_destroy_##bus = sd_bus_ref(bus)
int bus_set_address_system(sd_bus *bus);
int bus_set_address_user(sd_bus *bus);
int bus_set_address_system_remote(sd_bus *b, const char *host);
int bus_set_address_machine(sd_bus *b, RuntimeScope runtime_scope, const char *machine);
int bus_maybe_reply_error(sd_bus_message *m, int r, sd_bus_error *error);
#define bus_assert_return(expr, r, error) \
do { \
if (!assert_log(expr, #expr)) \
return sd_bus_error_set_errno(error, r); \
} while (false)
void bus_enter_closing(sd_bus *bus);
void bus_set_state(sd_bus *bus, enum bus_state state);
| 13,102 | 29.614486 | 129 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-introspect.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdio.h>
#include "sd-bus.h"
#include "memstream-util.h"
#include "ordered-set.h"
struct introspect {
MemStream m;
char *interface_name;
bool trusted;
};
int introspect_begin(struct introspect *i, bool trusted);
int introspect_write_default_interfaces(struct introspect *i, bool object_manager);
int introspect_write_child_nodes(struct introspect *i, OrderedSet *s, const char *prefix);
int introspect_write_interface(
struct introspect *i,
const char *interface_name,
const sd_bus_vtable *v);
int introspect_finish(struct introspect *i, char **ret);
void introspect_done(struct introspect *i);
| 744 | 27.653846 | 90 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-kernel.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#if HAVE_VALGRIND_MEMCHECK_H
#include <valgrind/memcheck.h>
#endif
#include <fcntl.h>
#include <malloc.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-kernel.h"
#include "bus-label.h"
#include "bus-message.h"
#include "capability-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "memfd-util.h"
#include "parse-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
#include "user-util.h"
#include "memory-util.h"
void close_and_munmap(int fd, void *address, size_t size) {
if (size > 0)
assert_se(munmap(address, PAGE_ALIGN(size)) >= 0);
safe_close(fd);
}
void bus_flush_memfd(sd_bus *b) {
assert(b);
for (unsigned i = 0; i < b->n_memfd_cache; i++)
close_and_munmap(b->memfd_cache[i].fd, b->memfd_cache[i].address, b->memfd_cache[i].mapped);
}
| 982 | 22.404762 | 108 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-kernel.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-bus.h"
#define MEMFD_CACHE_MAX 32
/* When we cache a memfd block for reuse, we will truncate blocks
* longer than this in order not to keep too much data around. */
#define MEMFD_CACHE_ITEM_SIZE_MAX (128*1024)
/* This determines at which minimum size we prefer sending memfds over
* sending vectors */
#define MEMFD_MIN_SIZE (512*1024)
struct memfd_cache {
int fd;
void *address;
size_t mapped;
size_t allocated;
};
void close_and_munmap(int fd, void *address, size_t size);
void bus_flush_memfd(sd_bus *bus);
| 625 | 24.04 | 70 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-message.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <byteswap.h>
#include <stdbool.h>
#include <sys/socket.h>
#include "sd-bus.h"
#include "bus-creds.h"
#include "bus-protocol.h"
#include "macro.h"
#include "time-util.h"
struct bus_container {
char enclosing;
/* Indexes into the signature string */
unsigned index, saved_index;
char *signature;
size_t before, begin, end;
/* pointer to the array size value, if this is a value */
uint32_t *array_size;
char *peeked_signature;
};
struct bus_body_part {
struct bus_body_part *next;
void *data;
void *mmap_begin;
size_t size;
size_t mapped;
size_t allocated;
uint64_t memfd_offset;
int memfd;
bool free_this:1;
bool munmap_this:1;
bool sealed:1;
bool is_zero:1;
};
struct sd_bus_message {
/* Caveat: a message can be referenced in two different ways: the main (user-facing) way will also
* pin the bus connection object the message is associated with. The secondary way ("queued") is used
* when a message is in the read or write queues of the bus connection object, which will not pin the
* bus connection object. This is necessary so that we don't have to have a pair of cyclic references
* between a message that is queued and its connection: as soon as a message is only referenced by
* the connection (by means of being queued) and the connection itself has no other references it
* will be freed. */
unsigned n_ref; /* Counter of references that pin the connection */
unsigned n_queued; /* Counter of references that do not pin the connection */
sd_bus *bus;
uint64_t reply_cookie;
const char *path;
const char *interface;
const char *member;
const char *destination;
const char *sender;
sd_bus_error error;
sd_bus_creds creds;
usec_t monotonic;
usec_t realtime;
uint64_t seqnum;
uint64_t verify_destination_id;
bool sealed:1;
bool dont_send:1;
bool allow_fds:1;
bool free_header:1;
bool free_fds:1;
bool poisoned:1;
bool sensitive:1;
/* The first bytes of the message */
struct bus_header *header;
size_t fields_size;
size_t body_size;
size_t user_body_size;
struct bus_body_part body;
struct bus_body_part *body_end;
unsigned n_body_parts;
size_t rindex;
struct bus_body_part *cached_rindex_part;
size_t cached_rindex_part_begin;
uint32_t n_fds;
int *fds;
struct bus_container root_container, *containers;
size_t n_containers;
struct iovec *iovec;
struct iovec iovec_fixed[2];
unsigned n_iovec;
char *peeked_signature;
/* If set replies to this message must carry the signature
* specified here to successfully seal. This is initialized
* from the vtable data */
const char *enforced_reply_signature;
usec_t timeout;
size_t header_offsets[_BUS_MESSAGE_HEADER_MAX];
unsigned n_header_offsets;
uint64_t read_counter;
};
static inline bool BUS_MESSAGE_NEED_BSWAP(sd_bus_message *m) {
return m->header->endian != BUS_NATIVE_ENDIAN;
}
static inline uint16_t BUS_MESSAGE_BSWAP16(sd_bus_message *m, uint16_t u) {
return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_16(u) : u;
}
static inline uint32_t BUS_MESSAGE_BSWAP32(sd_bus_message *m, uint32_t u) {
return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_32(u) : u;
}
static inline uint64_t BUS_MESSAGE_BSWAP64(sd_bus_message *m, uint64_t u) {
return BUS_MESSAGE_NEED_BSWAP(m) ? bswap_64(u) : u;
}
static inline uint64_t BUS_MESSAGE_COOKIE(sd_bus_message *m) {
return BUS_MESSAGE_BSWAP32(m, m->header->serial);
}
static inline size_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
return
sizeof(struct bus_header) +
ALIGN8(m->fields_size) +
m->body_size;
}
static inline size_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
return
sizeof(struct bus_header) +
ALIGN8(m->fields_size);
}
static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
return (uint8_t*) m->header + sizeof(struct bus_header);
}
int bus_message_get_blob(sd_bus_message *m, void **buffer, size_t *sz);
int bus_message_from_malloc(
sd_bus *bus,
void *buffer,
size_t length,
int *fds,
size_t n_fds,
const char *label,
sd_bus_message **ret);
int bus_message_get_arg(sd_bus_message *m, unsigned i, const char **str);
int bus_message_get_arg_strv(sd_bus_message *m, unsigned i, char ***strv);
#define MESSAGE_FOREACH_PART(part, i, m) \
for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++, (part) = (part)->next)
int bus_body_part_map(struct bus_body_part *part);
void bus_body_part_unmap(struct bus_body_part *part);
int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_bus_error *e, sd_bus_message **m);
int bus_message_remarshal(sd_bus *bus, sd_bus_message **m);
void bus_message_set_sender_driver(sd_bus *bus, sd_bus_message *m);
void bus_message_set_sender_local(sd_bus *bus, sd_bus_message *m);
sd_bus_message* bus_message_ref_queued(sd_bus_message *m, sd_bus *bus);
sd_bus_message* bus_message_unref_queued(sd_bus_message *m, sd_bus *bus);
char** bus_message_make_log_fields(sd_bus_message *m);
| 5,725 | 28.822917 | 109 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-objects.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "bus-internal.h"
#include "bus-introspect.h"
const sd_bus_vtable* bus_vtable_next(const sd_bus_vtable *vtable, const sd_bus_vtable *v);
bool bus_vtable_has_names(const sd_bus_vtable *vtable);
int bus_process_object(sd_bus *bus, sd_bus_message *m);
void bus_node_gc(sd_bus *b, struct node *n);
int introspect_path(
sd_bus *bus,
const char *path,
struct node *n,
bool require_fallback,
bool ignore_nodes_modified,
bool *found_object,
char **ret,
sd_bus_error *error);
| 668 | 30.857143 | 90 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-protocol.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <endian.h>
#include "macro.h"
/* Packet header */
struct _packed_ bus_header {
uint8_t endian;
uint8_t type;
uint8_t flags;
uint8_t version;
uint32_t body_size;
/* Note that what the bus spec calls "serial" we'll call "cookie" instead, because we don't
* want to imply that the cookie was in any way monotonically increasing. */
uint32_t serial;
uint32_t fields_size;
};
/* Endianness */
enum {
_BUS_INVALID_ENDIAN = 0,
BUS_LITTLE_ENDIAN = 'l',
BUS_BIG_ENDIAN = 'B',
#if __BYTE_ORDER == __BIG_ENDIAN
BUS_NATIVE_ENDIAN = BUS_BIG_ENDIAN,
BUS_REVERSE_ENDIAN = BUS_LITTLE_ENDIAN
#else
BUS_NATIVE_ENDIAN = BUS_LITTLE_ENDIAN,
BUS_REVERSE_ENDIAN = BUS_BIG_ENDIAN
#endif
};
/* Flags */
enum {
BUS_MESSAGE_NO_REPLY_EXPECTED = 1 << 0,
BUS_MESSAGE_NO_AUTO_START = 1 << 1,
BUS_MESSAGE_ALLOW_INTERACTIVE_AUTHORIZATION = 1 << 2,
};
/* Header fields */
enum {
_BUS_MESSAGE_HEADER_INVALID = 0,
BUS_MESSAGE_HEADER_PATH,
BUS_MESSAGE_HEADER_INTERFACE,
BUS_MESSAGE_HEADER_MEMBER,
BUS_MESSAGE_HEADER_ERROR_NAME,
BUS_MESSAGE_HEADER_REPLY_SERIAL,
BUS_MESSAGE_HEADER_DESTINATION,
BUS_MESSAGE_HEADER_SENDER,
BUS_MESSAGE_HEADER_SIGNATURE,
BUS_MESSAGE_HEADER_UNIX_FDS,
_BUS_MESSAGE_HEADER_MAX
};
/* RequestName parameters */
enum {
BUS_NAME_ALLOW_REPLACEMENT = 1 << 0,
BUS_NAME_REPLACE_EXISTING = 1 << 1,
BUS_NAME_DO_NOT_QUEUE = 1 << 2,
};
/* RequestName returns */
enum {
BUS_NAME_PRIMARY_OWNER = 1,
BUS_NAME_IN_QUEUE = 2,
BUS_NAME_EXISTS = 3,
BUS_NAME_ALREADY_OWNER = 4
};
/* ReleaseName returns */
enum {
BUS_NAME_RELEASED = 1,
BUS_NAME_NON_EXISTENT = 2,
BUS_NAME_NOT_OWNER = 3,
};
/* StartServiceByName returns */
enum {
BUS_START_REPLY_SUCCESS = 1,
BUS_START_REPLY_ALREADY_RUNNING = 2,
};
| 2,143 | 23.089888 | 99 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-signature.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "bus-signature.h"
#include "bus-type.h"
static int signature_element_length_internal(
const char *s,
bool allow_dict_entry,
unsigned array_depth,
unsigned struct_depth,
size_t *l) {
int r;
if (!s)
return -EINVAL;
assert(l);
if (bus_type_is_basic(*s) || *s == SD_BUS_TYPE_VARIANT) {
*l = 1;
return 0;
}
if (*s == SD_BUS_TYPE_ARRAY) {
size_t t;
if (array_depth >= 32)
return -EINVAL;
r = signature_element_length_internal(s + 1, true, array_depth+1, struct_depth, &t);
if (r < 0)
return r;
*l = t + 1;
return 0;
}
if (*s == SD_BUS_TYPE_STRUCT_BEGIN) {
const char *p = s + 1;
if (struct_depth >= 32)
return -EINVAL;
while (*p != SD_BUS_TYPE_STRUCT_END) {
size_t t;
r = signature_element_length_internal(p, false, array_depth, struct_depth+1, &t);
if (r < 0)
return r;
p += t;
}
if (p - s < 2)
/* D-Bus spec: Empty structures are not allowed; there
* must be at least one type code between the parentheses.
*/
return -EINVAL;
*l = p - s + 1;
return 0;
}
if (*s == SD_BUS_TYPE_DICT_ENTRY_BEGIN && allow_dict_entry) {
const char *p = s + 1;
unsigned n = 0;
if (struct_depth >= 32)
return -EINVAL;
while (*p != SD_BUS_TYPE_DICT_ENTRY_END) {
size_t t;
if (n == 0 && !bus_type_is_basic(*p))
return -EINVAL;
r = signature_element_length_internal(p, false, array_depth, struct_depth+1, &t);
if (r < 0)
return r;
p += t;
n++;
}
if (n != 2)
return -EINVAL;
*l = p - s + 1;
return 0;
}
return -EINVAL;
}
int signature_element_length(const char *s, size_t *l) {
return signature_element_length_internal(s, true, 0, 0, l);
}
bool signature_is_single(const char *s, bool allow_dict_entry) {
int r;
size_t t;
if (!s)
return false;
r = signature_element_length_internal(s, allow_dict_entry, 0, 0, &t);
if (r < 0)
return false;
return s[t] == 0;
}
bool signature_is_pair(const char *s) {
if (!s)
return false;
if (!bus_type_is_basic(*s))
return false;
return signature_is_single(s + 1, false);
}
bool signature_is_valid(const char *s, bool allow_dict_entry) {
const char *p;
int r;
if (!s)
return false;
p = s;
while (*p) {
size_t t;
r = signature_element_length_internal(p, allow_dict_entry, 0, 0, &t);
if (r < 0)
return false;
p += t;
}
return p - s <= SD_BUS_MAXIMUM_SIGNATURE_LENGTH;
}
| 3,708 | 24.231293 | 105 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-socket.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-bus.h"
void bus_socket_setup(sd_bus *b);
int bus_socket_connect(sd_bus *b);
int bus_socket_exec(sd_bus *b);
int bus_socket_take_fd(sd_bus *b);
int bus_socket_start_auth(sd_bus *b);
int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx);
int bus_socket_read_message(sd_bus *bus);
int bus_socket_process_opening(sd_bus *b);
int bus_socket_process_authenticating(sd_bus *b);
int bus_socket_process_watch_bind(sd_bus *b);
bool bus_socket_auth_needs_write(sd_bus *b);
| 563 | 25.857143 | 74 |
h
|
null |
systemd-main/src/libsystemd/sd-bus/bus-track.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-track.h"
#include "string-util.h"
struct track_item {
unsigned n_ref;
char *name;
sd_bus_slot *slot;
};
struct sd_bus_track {
unsigned n_ref;
unsigned n_adding; /* are we in the process of adding a new name? */
sd_bus *bus;
sd_bus_track_handler_t handler;
void *userdata;
Hashmap *names;
LIST_FIELDS(sd_bus_track, queue);
Iterator iterator;
bool in_list:1; /* In bus->tracks? */
bool in_queue:1; /* In bus->track_queue? */
bool modified:1;
bool recursive:1;
sd_bus_destroy_t destroy_callback;
LIST_FIELDS(sd_bus_track, tracks);
};
#define MATCH_FOR_NAME(name) \
strjoina("type='signal'," \
"sender='org.freedesktop.DBus'," \
"path='/org/freedesktop/DBus'," \
"interface='org.freedesktop.DBus'," \
"member='NameOwnerChanged'," \
"arg0='", name, "'")
static struct track_item* track_item_free(struct track_item *i) {
if (!i)
return NULL;
sd_bus_slot_unref(i->slot);
free(i->name);
return mfree(i);
}
DEFINE_PRIVATE_TRIVIAL_UNREF_FUNC(struct track_item, track_item, track_item_free);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct track_item*, track_item_unref);
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(track_item_hash_ops, char, string_hash_func, string_compare_func,
struct track_item, track_item_free);
static void bus_track_add_to_queue(sd_bus_track *track) {
assert(track);
/* Adds the bus track object to the queue of objects we should dispatch next, subject to a number of
* conditions. */
/* Already in the queue? */
if (track->in_queue)
return;
/* if we are currently in the process of adding a new name, then let's not enqueue this just yet, let's wait
* until the addition is complete. */
if (track->n_adding > 0)
return;
/* still referenced? */
if (hashmap_size(track->names) > 0)
return;
/* Nothing to call? */
if (!track->handler)
return;
/* Already closed? */
if (!track->in_list)
return;
LIST_PREPEND(queue, track->bus->track_queue, track);
track->in_queue = true;
}
static void bus_track_remove_from_queue(sd_bus_track *track) {
assert(track);
if (!track->in_queue)
return;
LIST_REMOVE(queue, track->bus->track_queue, track);
track->in_queue = false;
}
static int bus_track_remove_name_fully(sd_bus_track *track, const char *name) {
struct track_item *i;
assert(track);
assert(name);
i = hashmap_remove(track->names, name);
if (!i)
return 0;
track_item_free(i);
bus_track_add_to_queue(track);
track->modified = true;
return 1;
}
_public_ int sd_bus_track_new(
sd_bus *bus,
sd_bus_track **track,
sd_bus_track_handler_t handler,
void *userdata) {
sd_bus_track *t;
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(track, -EINVAL);
if (!bus->bus_client)
return -EINVAL;
t = new0(sd_bus_track, 1);
if (!t)
return -ENOMEM;
t->n_ref = 1;
t->handler = handler;
t->userdata = userdata;
t->bus = sd_bus_ref(bus);
LIST_PREPEND(tracks, bus->tracks, t);
t->in_list = true;
bus_track_add_to_queue(t);
*track = t;
return 0;
}
static sd_bus_track *track_free(sd_bus_track *track) {
assert(track);
if (track->in_list)
LIST_REMOVE(tracks, track->bus->tracks, track);
bus_track_remove_from_queue(track);
track->names = hashmap_free(track->names);
track->bus = sd_bus_unref(track->bus);
if (track->destroy_callback)
track->destroy_callback(track->userdata);
return mfree(track);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_bus_track, sd_bus_track, track_free);
static int on_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
sd_bus_track *track = ASSERT_PTR(userdata);
const char *name;
int r;
assert(message);
r = sd_bus_message_read(message, "sss", &name, NULL, NULL);
if (r < 0)
return 0;
bus_track_remove_name_fully(track, name);
return 0;
}
_public_ int sd_bus_track_add_name(sd_bus_track *track, const char *name) {
_cleanup_(track_item_unrefp) struct track_item *n = NULL;
struct track_item *i;
const char *match;
int r;
assert_return(track, -EINVAL);
assert_return(service_name_is_valid(name), -EINVAL);
i = hashmap_get(track->names, name);
if (i) {
if (track->recursive) {
assert(i->n_ref > 0);
/* Manual overflow check (instead of a DEFINE_TRIVIAL_REF_FUNC() helper or so), so
* that we can return a proper error, given this is almost always called in a
* directly client controllable way, and thus better should never hit an assertion
* here. */
if (i->n_ref >= UINT_MAX)
return -EOVERFLOW;
i->n_ref++;
}
bus_track_remove_from_queue(track);
return 0;
}
r = hashmap_ensure_allocated(&track->names, &track_item_hash_ops);
if (r < 0)
return r;
n = new(struct track_item, 1);
if (!n)
return -ENOMEM;
*n = (struct track_item) {
.n_ref = 1,
};
n->name = strdup(name);
if (!n->name)
return -ENOMEM;
/* First, subscribe to this name */
match = MATCH_FOR_NAME(name);
bus_track_remove_from_queue(track); /* don't dispatch this while we work in it */
r = sd_bus_add_match_async(track->bus, &n->slot, match, on_name_owner_changed, NULL, track);
if (r < 0) {
bus_track_add_to_queue(track);
return r;
}
r = hashmap_put(track->names, n->name, n);
if (r < 0) {
bus_track_add_to_queue(track);
return r;
}
/* Second, check if it is currently existing, or maybe doesn't, or maybe disappeared already. */
track->n_adding++; /* again, make sure this isn't dispatch while we are working in it */
r = sd_bus_get_name_creds(track->bus, name, 0, NULL);
track->n_adding--;
if (r < 0) {
hashmap_remove(track->names, name);
bus_track_add_to_queue(track);
return r;
}
TAKE_PTR(n);
bus_track_remove_from_queue(track);
track->modified = true;
return 1;
}
_public_ int sd_bus_track_remove_name(sd_bus_track *track, const char *name) {
struct track_item *i;
assert_return(name, -EINVAL);
if (!track) /* Treat a NULL track object as an empty track object */
return 0;
i = hashmap_get(track->names, name);
if (!i)
return 0;
assert(i->n_ref >= 1);
if (i->n_ref <= 1)
return bus_track_remove_name_fully(track, name);
track_item_unref(i);
return 1;
}
_public_ unsigned sd_bus_track_count(sd_bus_track *track) {
if (!track) /* Let's consider a NULL object equivalent to an empty object */
return 0;
/* This signature really should have returned an int, so that we can propagate errors. But well, ... Also, note
* that this returns the number of names being watched, and multiple references to the same name are not
* counted. */
return hashmap_size(track->names);
}
_public_ const char* sd_bus_track_contains(sd_bus_track *track, const char *name) {
assert_return(name, NULL);
if (!track) /* Let's consider a NULL object equivalent to an empty object */
return NULL;
return hashmap_contains(track->names, name) ? name : NULL;
}
_public_ const char* sd_bus_track_first(sd_bus_track *track) {
const char *n = NULL;
if (!track)
return NULL;
track->modified = false;
track->iterator = ITERATOR_FIRST;
(void) hashmap_iterate(track->names, &track->iterator, NULL, (const void**) &n);
return n;
}
_public_ const char* sd_bus_track_next(sd_bus_track *track) {
const char *n = NULL;
if (!track)
return NULL;
if (track->modified)
return NULL;
(void) hashmap_iterate(track->names, &track->iterator, NULL, (const void**) &n);
return n;
}
_public_ int sd_bus_track_add_sender(sd_bus_track *track, sd_bus_message *m) {
const char *sender;
assert_return(track, -EINVAL);
assert_return(m, -EINVAL);
if (sd_bus_message_get_bus(m) != track->bus)
return -EINVAL;
sender = sd_bus_message_get_sender(m);
if (!sender)
return -EINVAL;
return sd_bus_track_add_name(track, sender);
}
_public_ int sd_bus_track_remove_sender(sd_bus_track *track, sd_bus_message *m) {
const char *sender;
assert_return(m, -EINVAL);
if (!track) /* Treat a NULL track object as an empty track object */
return 0;
if (sd_bus_message_get_bus(m) != track->bus)
return -EINVAL;
sender = sd_bus_message_get_sender(m);
if (!sender)
return -EINVAL;
return sd_bus_track_remove_name(track, sender);
}
_public_ sd_bus* sd_bus_track_get_bus(sd_bus_track *track) {
assert_return(track, NULL);
return track->bus;
}
void bus_track_dispatch(sd_bus_track *track) {
int r;
assert(track);
assert(track->handler);
bus_track_remove_from_queue(track);
sd_bus_track_ref(track);
r = track->handler(track, track->userdata);
if (r < 0)
log_debug_errno(r, "Failed to process track handler: %m");
else if (r == 0)
bus_track_add_to_queue(track);
sd_bus_track_unref(track);
}
void bus_track_close(sd_bus_track *track) {
assert(track);
/* Called whenever our bus connected is closed. If so, and our track object is non-empty, dispatch it
* immediately, as we are closing now, but first flush out all names. */
if (!track->in_list)
return; /* We already closed this one, don't close it again. */
/* Remember that this one is closed now */
LIST_REMOVE(tracks, track->bus->tracks, track);
track->in_list = false;
/* If there's no name in this one anyway, we don't have to dispatch */
if (hashmap_isempty(track->names))
return;
/* Let's flush out all names */
hashmap_clear(track->names);
/* Invoke handler */
if (track->handler)
bus_track_dispatch(track);
}
_public_ void *sd_bus_track_get_userdata(sd_bus_track *track) {
assert_return(track, NULL);
return track->userdata;
}
_public_ void *sd_bus_track_set_userdata(sd_bus_track *track, void *userdata) {
void *ret;
assert_return(track, NULL);
ret = track->userdata;
track->userdata = userdata;
return ret;
}
_public_ int sd_bus_track_set_destroy_callback(sd_bus_track *track, sd_bus_destroy_t callback) {
assert_return(track, -EINVAL);
track->destroy_callback = callback;
return 0;
}
_public_ int sd_bus_track_get_destroy_callback(sd_bus_track *track, sd_bus_destroy_t *ret) {
assert_return(track, -EINVAL);
if (ret)
*ret = track->destroy_callback;
return !!track->destroy_callback;
}
_public_ int sd_bus_track_set_recursive(sd_bus_track *track, int b) {
assert_return(track, -EINVAL);
if (track->recursive == !!b)
return 0;
if (!hashmap_isempty(track->names))
return -EBUSY;
track->recursive = b;
return 0;
}
_public_ int sd_bus_track_get_recursive(sd_bus_track *track) {
assert_return(track, -EINVAL);
return track->recursive;
}
_public_ int sd_bus_track_count_sender(sd_bus_track *track, sd_bus_message *m) {
const char *sender;
assert_return(m, -EINVAL);
if (!track) /* Let's consider a NULL object equivalent to an empty object */
return 0;
if (sd_bus_message_get_bus(m) != track->bus)
return -EINVAL;
sender = sd_bus_message_get_sender(m);
if (!sender)
return -EINVAL;
return sd_bus_track_count_name(track, sender);
}
_public_ int sd_bus_track_count_name(sd_bus_track *track, const char *name) {
struct track_item *i;
assert_return(service_name_is_valid(name), -EINVAL);
if (!track) /* Let's consider a NULL object equivalent to an empty object */
return 0;
i = hashmap_get(track->names, name);
if (!i)
return 0;
return i->n_ref;
}
| 13,899 | 27.024194 | 119 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/bus-type.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "sd-bus.h"
#include "bus-internal.h"
#include "bus-type.h"
bool bus_type_is_valid(char c) {
static const char valid[] = {
SD_BUS_TYPE_BYTE,
SD_BUS_TYPE_BOOLEAN,
SD_BUS_TYPE_INT16,
SD_BUS_TYPE_UINT16,
SD_BUS_TYPE_INT32,
SD_BUS_TYPE_UINT32,
SD_BUS_TYPE_INT64,
SD_BUS_TYPE_UINT64,
SD_BUS_TYPE_DOUBLE,
SD_BUS_TYPE_STRING,
SD_BUS_TYPE_OBJECT_PATH,
SD_BUS_TYPE_SIGNATURE,
SD_BUS_TYPE_ARRAY,
SD_BUS_TYPE_VARIANT,
SD_BUS_TYPE_STRUCT,
SD_BUS_TYPE_DICT_ENTRY,
SD_BUS_TYPE_UNIX_FD
};
return !!memchr(valid, c, sizeof(valid));
}
bool bus_type_is_basic(char c) {
static const char valid[] = {
SD_BUS_TYPE_BYTE,
SD_BUS_TYPE_BOOLEAN,
SD_BUS_TYPE_INT16,
SD_BUS_TYPE_UINT16,
SD_BUS_TYPE_INT32,
SD_BUS_TYPE_UINT32,
SD_BUS_TYPE_INT64,
SD_BUS_TYPE_UINT64,
SD_BUS_TYPE_DOUBLE,
SD_BUS_TYPE_STRING,
SD_BUS_TYPE_OBJECT_PATH,
SD_BUS_TYPE_SIGNATURE,
SD_BUS_TYPE_UNIX_FD
};
return !!memchr(valid, c, sizeof(valid));
}
bool bus_type_is_trivial(char c) {
static const char valid[] = {
SD_BUS_TYPE_BYTE,
SD_BUS_TYPE_BOOLEAN,
SD_BUS_TYPE_INT16,
SD_BUS_TYPE_UINT16,
SD_BUS_TYPE_INT32,
SD_BUS_TYPE_UINT32,
SD_BUS_TYPE_INT64,
SD_BUS_TYPE_UINT64,
SD_BUS_TYPE_DOUBLE
};
return !!memchr(valid, c, sizeof(valid));
}
bool bus_type_is_container(char c) {
static const char valid[] = {
SD_BUS_TYPE_ARRAY,
SD_BUS_TYPE_VARIANT,
SD_BUS_TYPE_STRUCT,
SD_BUS_TYPE_DICT_ENTRY
};
return !!memchr(valid, c, sizeof(valid));
}
int bus_type_get_alignment(char c) {
switch (c) {
case SD_BUS_TYPE_BYTE:
case SD_BUS_TYPE_SIGNATURE:
case SD_BUS_TYPE_VARIANT:
return 1;
case SD_BUS_TYPE_INT16:
case SD_BUS_TYPE_UINT16:
return 2;
case SD_BUS_TYPE_BOOLEAN:
case SD_BUS_TYPE_INT32:
case SD_BUS_TYPE_UINT32:
case SD_BUS_TYPE_STRING:
case SD_BUS_TYPE_OBJECT_PATH:
case SD_BUS_TYPE_ARRAY:
case SD_BUS_TYPE_UNIX_FD:
return 4;
case SD_BUS_TYPE_INT64:
case SD_BUS_TYPE_UINT64:
case SD_BUS_TYPE_DOUBLE:
case SD_BUS_TYPE_STRUCT:
case SD_BUS_TYPE_STRUCT_BEGIN:
case SD_BUS_TYPE_DICT_ENTRY:
case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
return 8;
}
return -EINVAL;
}
int bus_type_get_size(char c) {
switch (c) {
case SD_BUS_TYPE_BYTE:
return 1;
case SD_BUS_TYPE_INT16:
case SD_BUS_TYPE_UINT16:
return 2;
case SD_BUS_TYPE_BOOLEAN:
case SD_BUS_TYPE_INT32:
case SD_BUS_TYPE_UINT32:
case SD_BUS_TYPE_UNIX_FD:
return 4;
case SD_BUS_TYPE_INT64:
case SD_BUS_TYPE_UINT64:
case SD_BUS_TYPE_DOUBLE:
return 8;
}
return -EINVAL;
}
_public_ int sd_bus_interface_name_is_valid(const char *p) {
assert_return(p, -EINVAL);
return interface_name_is_valid(p);
}
_public_ int sd_bus_service_name_is_valid(const char *p) {
assert_return(p, -EINVAL);
return service_name_is_valid(p);
}
_public_ int sd_bus_member_name_is_valid(const char *p) {
assert_return(p, -EINVAL);
return member_name_is_valid(p);
}
_public_ int sd_bus_object_path_is_valid(const char *p) {
assert_return(p, -EINVAL);
return object_path_is_valid(p);
}
| 4,185 | 24.680982 | 60 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/fuzz-bus-match.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-match.h"
#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fuzz.h"
#include "memstream-util.h"
DEFINE_TRIVIAL_DESTRUCTOR(bus_match_donep, struct bus_match_node, bus_match_free);
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream m = {};
_cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
FILE *g = NULL;
int r;
if (outside_size_range(size, 0, 65536))
return 0;
/* We don't want to fill the logs with messages about parse errors.
* Disable most logging if not running standalone */
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
r = sd_bus_new(&bus);
assert_se(r >= 0);
_cleanup_(bus_match_donep) struct bus_match_node root = {
.type = BUS_MATCH_ROOT,
};
/* Note that we use the pointer to match_callback substructure, but the code
* uses container_of() to access outside of the passed-in type. */
sd_bus_slot slot = {
.type = BUS_MATCH_CALLBACK,
.match_callback = {},
};
if (getenv_bool("SYSTEMD_FUZZ_OUTPUT") <= 0)
assert_se(g = memstream_init(&m));
for (size_t offset = 0; offset < size; ) {
_cleanup_free_ char *line = NULL;
char *end;
end = memchr((char*) data + offset, '\n', size - offset);
line = memdup_suffix0((char*) data + offset,
end ? end - (char*) data - offset : size - offset);
if (!line)
return log_oom_debug();
offset = end ? (size_t) (end - (char*) data + 1) : size;
struct bus_match_component *components;
size_t n_components;
r = bus_match_parse(line, &components, &n_components);
if (IN_SET(r, -EINVAL, -ENOMEM)) {
log_debug_errno(r, "Failed to parse line: %m");
continue;
}
assert_se(r >= 0); /* We only expect EINVAL and ENOMEM errors, or success. */
CLEANUP_ARRAY(components, n_components, bus_match_parse_free);
log_debug("Parsed %zu components.", n_components);
_cleanup_free_ char *again = bus_match_to_string(components, n_components);
if (!again) {
log_oom();
break;
}
if (g)
fprintf(g, "%s\n", again);
r = bus_match_add(&root, components, n_components, &slot.match_callback);
if (r < 0) {
log_error_errno(r, "Failed to add match: %m");
break;
}
}
bus_match_dump(g ?: stdout, &root, 0); /* We do this even on failure, to check consistency after error. */
bus_match_free(&root);
return 0;
}
| 3,175 | 33.521739 | 114 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/fuzz-bus-message.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "bus-dump.h"
#include "bus-message.h"
#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fuzz.h"
#include "memstream-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(memstream_done) MemStream ms = {};
_cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ void *buffer = NULL;
FILE *g = NULL;
int r;
/* We don't want to fill the logs with messages about parse errors.
* Disable most logging if not running standalone */
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
r = sd_bus_new(&bus);
assert_se(r >= 0);
assert_se(buffer = memdup(data, size));
r = bus_message_from_malloc(bus, buffer, size, NULL, 0, NULL, &m);
if (r == -EBADMSG)
return 0;
assert_se(r >= 0);
TAKE_PTR(buffer);
if (getenv_bool("SYSTEMD_FUZZ_OUTPUT") <= 0)
assert_se(g = memstream_init(&ms));
sd_bus_message_dump(m, g ?: stdout, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
r = sd_bus_message_rewind(m, true);
assert_se(r >= 0);
return 0;
}
| 1,342 | 28.195652 | 77 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-address.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "bus-internal.h"
#include "log.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
static void test_one_address(sd_bus *b,
const char *host,
int result, const char *expected) {
int r;
r = bus_set_address_system_remote(b, host);
log_info("\"%s\" → %d, \"%s\"", host, r, strna(r >= 0 ? b->address : NULL));
assert_se(r == result);
if (r >= 0)
assert_se(streq_ptr(b->address, expected));
}
TEST(bus_set_address_system_remote) {
_cleanup_(sd_bus_unrefp) sd_bus *b = NULL;
assert_se(sd_bus_new(&b) >= 0);
if (!strv_isempty(saved_argv + 1)) {
STRV_FOREACH(a, saved_argv + 1)
test_one_address(b, *a, 0, NULL);
return;
};
test_one_address(b, "host",
0, "unixexec:path=ssh,argv1=-xT,argv2=--,argv3=host,argv4=systemd-stdio-bridge");
test_one_address(b, "host:123",
0, "unixexec:path=ssh,argv1=-xT,argv2=-p,argv3=123,argv4=--,argv5=host,argv6=systemd-stdio-bridge");
test_one_address(b, "host:123:123",
-EINVAL, NULL);
test_one_address(b, "host:",
-EINVAL, NULL);
test_one_address(b, "user@host",
0, "unixexec:path=ssh,argv1=-xT,argv2=--,argv3=user%40host,argv4=systemd-stdio-bridge");
test_one_address(b, "user@host@host",
-EINVAL, NULL);
test_one_address(b, "[::1]",
0, "unixexec:path=ssh,argv1=-xT,argv2=--,argv3=%3a%3a1,argv4=systemd-stdio-bridge");
test_one_address(b, "user@[::1]",
0, "unixexec:path=ssh,argv1=-xT,argv2=--,argv3=user%40%3a%3a1,argv4=systemd-stdio-bridge");
test_one_address(b, "user@[::1]:99",
0, "unixexec:path=ssh,argv1=-xT,argv2=-p,argv3=99,argv4=--,argv5=user%40%3a%3a1,argv6=systemd-stdio-bridge");
test_one_address(b, "user@[::1]:",
-EINVAL, NULL);
test_one_address(b, "user@[::1:",
-EINVAL, NULL);
test_one_address(b, "user@",
-EINVAL, NULL);
test_one_address(b, "user@@",
-EINVAL, NULL);
}
DEFINE_TEST_MAIN(LOG_INFO);
| 2,469 | 38.83871 | 134 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-benchmark.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sys/wait.h>
#include <unistd.h>
#include "sd-bus.h"
#include "alloc-util.h"
#include "bus-internal.h"
#include "bus-kernel.h"
#include "constants.h"
#include "fd-util.h"
#include "missing_resource.h"
#include "string-util.h"
#include "time-util.h"
#define MAX_SIZE (2*1024*1024)
static usec_t arg_loop_usec = 100 * USEC_PER_MSEC;
typedef enum Type {
TYPE_LEGACY,
TYPE_DIRECT,
} Type;
static void server(sd_bus *b, size_t *result) {
int r;
for (;;) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
r = sd_bus_process(b, &m);
assert_se(r >= 0);
if (r == 0)
assert_se(sd_bus_wait(b, USEC_INFINITY) >= 0);
if (!m)
continue;
if (sd_bus_message_is_method_call(m, "benchmark.server", "Ping"))
assert_se(sd_bus_reply_method_return(m, NULL) >= 0);
else if (sd_bus_message_is_method_call(m, "benchmark.server", "Work")) {
const void *p;
size_t sz;
/* Make sure the mmap is mapped */
assert_se(sd_bus_message_read_array(m, 'y', &p, &sz) > 0);
r = sd_bus_reply_method_return(m, NULL);
assert_se(r >= 0);
} else if (sd_bus_message_is_method_call(m, "benchmark.server", "Exit")) {
uint64_t res;
assert_se(sd_bus_message_read(m, "t", &res) > 0);
*result = res;
return;
} else if (!sd_bus_message_is_signal(m, NULL, NULL))
assert_not_reached();
}
}
static void transaction(sd_bus *b, size_t sz, const char *server_name) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
uint8_t *p;
assert_se(sd_bus_message_new_method_call(b, &m, server_name, "/", "benchmark.server", "Work") >= 0);
assert_se(sd_bus_message_append_array_space(m, 'y', sz, (void**) &p) >= 0);
memset(p, 0x80, sz);
assert_se(sd_bus_call(b, m, 0, NULL, &reply) >= 0);
}
static void client_bisect(const char *address, const char *server_name) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *x = NULL;
size_t lsize, rsize, csize;
sd_bus *b;
int r;
r = sd_bus_new(&b);
assert_se(r >= 0);
r = sd_bus_set_address(b, address);
assert_se(r >= 0);
r = sd_bus_start(b);
assert_se(r >= 0);
r = sd_bus_call_method(b, server_name, "/", "benchmark.server", "Ping", NULL, NULL, NULL);
assert_se(r >= 0);
lsize = 1;
rsize = MAX_SIZE;
printf("SIZE\tCOPY\tMEMFD\n");
for (;;) {
usec_t t;
unsigned n_copying, n_memfd;
csize = (lsize + rsize) / 2;
if (csize <= lsize)
break;
if (csize <= 0)
break;
printf("%zu\t", csize);
b->use_memfd = 0;
t = now(CLOCK_MONOTONIC);
for (n_copying = 0;; n_copying++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\t", (unsigned) ((n_copying * USEC_PER_SEC) / arg_loop_usec));
b->use_memfd = -1;
t = now(CLOCK_MONOTONIC);
for (n_memfd = 0;; n_memfd++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\n", (unsigned) ((n_memfd * USEC_PER_SEC) / arg_loop_usec));
if (n_copying == n_memfd)
break;
if (n_copying > n_memfd)
lsize = csize;
else
rsize = csize;
}
b->use_memfd = 1;
assert_se(sd_bus_message_new_method_call(b, &x, server_name, "/", "benchmark.server", "Exit") >= 0);
assert_se(sd_bus_message_append(x, "t", csize) >= 0);
assert_se(sd_bus_send(b, x, NULL) >= 0);
sd_bus_unref(b);
}
static void client_chart(Type type, const char *address, const char *server_name, int fd) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *x = NULL;
size_t csize;
sd_bus *b;
int r;
r = sd_bus_new(&b);
assert_se(r >= 0);
if (type == TYPE_DIRECT) {
r = sd_bus_set_fd(b, fd, fd);
assert_se(r >= 0);
} else {
r = sd_bus_set_address(b, address);
assert_se(r >= 0);
r = sd_bus_set_bus_client(b, true);
assert_se(r >= 0);
}
r = sd_bus_start(b);
assert_se(r >= 0);
r = sd_bus_call_method(b, server_name, "/", "benchmark.server", "Ping", NULL, NULL, NULL);
assert_se(r >= 0);
switch (type) {
case TYPE_LEGACY:
printf("SIZE\tLEGACY\n");
break;
case TYPE_DIRECT:
printf("SIZE\tDIRECT\n");
break;
}
for (csize = 1; csize <= MAX_SIZE; csize *= 2) {
usec_t t;
unsigned n_memfd;
printf("%zu\t", csize);
t = now(CLOCK_MONOTONIC);
for (n_memfd = 0;; n_memfd++) {
transaction(b, csize, server_name);
if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
break;
}
printf("%u\n", (unsigned) ((n_memfd * USEC_PER_SEC) / arg_loop_usec));
}
b->use_memfd = 1;
assert_se(sd_bus_message_new_method_call(b, &x, server_name, "/", "benchmark.server", "Exit") >= 0);
assert_se(sd_bus_message_append(x, "t", csize) >= 0);
assert_se(sd_bus_send(b, x, NULL) >= 0);
sd_bus_unref(b);
}
int main(int argc, char *argv[]) {
enum {
MODE_BISECT,
MODE_CHART,
} mode = MODE_BISECT;
Type type = TYPE_LEGACY;
int i, pair[2] = PIPE_EBADF;
_cleanup_free_ char *address = NULL, *server_name = NULL;
_cleanup_close_ int bus_ref = -EBADF;
const char *unique;
cpu_set_t cpuset;
size_t result;
sd_bus *b;
pid_t pid;
int r;
for (i = 1; i < argc; i++) {
if (streq(argv[i], "chart")) {
mode = MODE_CHART;
continue;
} else if (streq(argv[i], "legacy")) {
type = TYPE_LEGACY;
continue;
} else if (streq(argv[i], "direct")) {
type = TYPE_DIRECT;
continue;
}
assert_se(parse_sec(argv[i], &arg_loop_usec) >= 0);
}
assert_se(arg_loop_usec > 0);
if (type == TYPE_LEGACY) {
const char *e;
e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
assert_se(e);
address = strdup(e);
assert_se(address);
}
r = sd_bus_new(&b);
assert_se(r >= 0);
if (type == TYPE_DIRECT) {
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, pair) >= 0);
r = sd_bus_set_fd(b, pair[0], pair[0]);
assert_se(r >= 0);
r = sd_bus_set_server(b, true, SD_ID128_NULL);
assert_se(r >= 0);
} else {
r = sd_bus_set_address(b, address);
assert_se(r >= 0);
r = sd_bus_set_bus_client(b, true);
assert_se(r >= 0);
}
r = sd_bus_start(b);
assert_se(r >= 0);
if (type != TYPE_DIRECT) {
r = sd_bus_get_unique_name(b, &unique);
assert_se(r >= 0);
server_name = strdup(unique);
assert_se(server_name);
}
sync();
setpriority(PRIO_PROCESS, 0, -19);
pid = fork();
assert_se(pid >= 0);
if (pid == 0) {
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
safe_close(bus_ref);
sd_bus_unref(b);
switch (mode) {
case MODE_BISECT:
client_bisect(address, server_name);
break;
case MODE_CHART:
client_chart(type, address, server_name, pair[1]);
break;
}
_exit(EXIT_SUCCESS);
}
CPU_ZERO(&cpuset);
CPU_SET(1, &cpuset);
pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
server(b, &result);
if (mode == MODE_BISECT)
printf("Copying/memfd are equally fast at %zu bytes\n", result);
assert_se(waitpid(pid, NULL, 0) == pid);
safe_close(pair[1]);
sd_bus_unref(b);
return 0;
}
| 9,566 | 28.527778 | 108 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-creds.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "bus-dump.h"
#include "cgroup-util.h"
#include "tests.h"
int main(int argc, char *argv[]) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
int r;
test_setup_logging(LOG_DEBUG);
if (cg_unified() == -ENOMEDIUM)
return log_tests_skipped("/sys/fs/cgroup/ not available");
r = sd_bus_creds_new_from_pid(&creds, 0, _SD_BUS_CREDS_ALL);
log_full_errno(r < 0 ? LOG_ERR : LOG_DEBUG, r, "sd_bus_creds_new_from_pid: %m");
assert_se(r >= 0);
bus_creds_dump(creds, NULL, true);
creds = sd_bus_creds_unref(creds);
r = sd_bus_creds_new_from_pid(&creds, 1, _SD_BUS_CREDS_ALL);
if (r != -EACCES) {
assert_se(r >= 0);
putchar('\n');
bus_creds_dump(creds, NULL, true);
}
return 0;
}
| 931 | 25.628571 | 88 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-error.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "errno-list.h"
#include "errno-util.h"
#include "string-util.h"
#include "tests.h"
TEST(error) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL, second = SD_BUS_ERROR_NULL;
const sd_bus_error const_error = SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_EXISTS, "const error");
const sd_bus_error temporarily_const_error = {
.name = SD_BUS_ERROR_ACCESS_DENIED,
.message = "oh! no",
._need_free = -1,
};
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -EOPNOTSUPP);
assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(streq(error.message, "xxx"));
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(sd_bus_error_has_names_sentinel(&error, SD_BUS_ERROR_NOT_SUPPORTED, NULL));
assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_NOT_SUPPORTED, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND, SD_BUS_ERROR_NOT_SUPPORTED, NULL));
assert_se(!sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_get_errno(&error) == EOPNOTSUPP);
assert_se(sd_bus_error_is_set(&error));
sd_bus_error_free(&error);
/* Check with no error */
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_setf(&error, NULL, "yyy %i", -1) == 0);
assert_se(error.name == NULL);
assert_se(error.message == NULL);
assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(!sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_get_errno(&error) == 0);
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_setf(&error, SD_BUS_ERROR_FILE_NOT_FOUND, "yyy %i", -1) == -ENOENT);
assert_se(streq(error.name, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(streq(error.message, "yyy -1"));
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_get_errno(&error) == ENOENT);
assert_se(sd_bus_error_is_set(&error));
assert_se(!sd_bus_error_is_set(&second));
assert_se(second._need_free == 0);
assert_se(error._need_free > 0);
assert_se(sd_bus_error_copy(&second, &error) == -ENOENT);
assert_se(second._need_free > 0);
assert_se(streq(error.name, second.name));
assert_se(streq(error.message, second.message));
assert_se(sd_bus_error_get_errno(&second) == ENOENT);
assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_has_names(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
assert_se(sd_bus_error_is_set(&second));
sd_bus_error_free(&error);
sd_bus_error_free(&second);
assert_se(!sd_bus_error_is_set(&second));
assert_se(const_error._need_free == 0);
assert_se(sd_bus_error_copy(&second, &const_error) == -EEXIST);
assert_se(second._need_free == 0);
assert_se(streq(const_error.name, second.name));
assert_se(streq(const_error.message, second.message));
assert_se(sd_bus_error_get_errno(&second) == EEXIST);
assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_EXISTS));
assert_se(sd_bus_error_is_set(&second));
sd_bus_error_free(&second);
assert_se(!sd_bus_error_is_set(&second));
assert_se(temporarily_const_error._need_free < 0);
assert_se(sd_bus_error_copy(&second, &temporarily_const_error) == -EACCES);
assert_se(second._need_free > 0);
assert_se(streq(temporarily_const_error.name, second.name));
assert_se(streq(temporarily_const_error.message, second.message));
assert_se(sd_bus_error_get_errno(&second) == EACCES);
assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_ACCESS_DENIED));
assert_se(sd_bus_error_is_set(&second));
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_set_const(&error, "System.Error.EUCLEAN", "Hallo") == -EUCLEAN);
assert_se(streq(error.name, "System.Error.EUCLEAN"));
assert_se(streq(error.message, "Hallo"));
assert_se(sd_bus_error_has_name(&error, "System.Error.EUCLEAN"));
assert_se(sd_bus_error_get_errno(&error) == EUCLEAN);
assert_se(sd_bus_error_is_set(&error));
sd_bus_error_free(&error);
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_set_errno(&error, EBUSY) == -EBUSY);
assert_se(streq(error.name, "System.Error.EBUSY"));
assert_se(streq(error.message, STRERROR(EBUSY)));
assert_se(sd_bus_error_has_name(&error, "System.Error.EBUSY"));
assert_se(sd_bus_error_get_errno(&error) == EBUSY);
assert_se(sd_bus_error_is_set(&error));
sd_bus_error_free(&error);
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_set_errnof(&error, EIO, "Waldi %c", 'X') == -EIO);
assert_se(streq(error.name, SD_BUS_ERROR_IO_ERROR));
assert_se(streq(error.message, "Waldi X"));
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
assert_se(sd_bus_error_get_errno(&error) == EIO);
assert_se(sd_bus_error_is_set(&error));
sd_bus_error_free(&error);
/* Check with no error */
assert_se(!sd_bus_error_is_set(&error));
assert_se(sd_bus_error_set_errnof(&error, 0, "Waldi %c", 'X') == 0);
assert_se(error.name == NULL);
assert_se(error.message == NULL);
assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
assert_se(sd_bus_error_get_errno(&error) == 0);
assert_se(!sd_bus_error_is_set(&error));
}
extern const sd_bus_error_map __start_SYSTEMD_BUS_ERROR_MAP[];
extern const sd_bus_error_map __stop_SYSTEMD_BUS_ERROR_MAP[];
static int dump_mapping_table(void) {
const sd_bus_error_map *m;
printf("----- errno mappings ------\n");
m = ALIGN_PTR(__start_SYSTEMD_BUS_ERROR_MAP);
while (m < __stop_SYSTEMD_BUS_ERROR_MAP) {
if (m->code == BUS_ERROR_MAP_END_MARKER) {
m = ALIGN_PTR(m + 1);
continue;
}
printf("%s -> %i/%s\n", strna(m->name), m->code, strna(errno_to_name(m->code)));
m++;
}
printf("---------------------------\n");
return EXIT_SUCCESS;
}
TEST(errno_mapping_standard) {
assert_se(sd_bus_error_set(NULL, "System.Error.EUCLEAN", NULL) == -EUCLEAN);
assert_se(sd_bus_error_set(NULL, "System.Error.EBUSY", NULL) == -EBUSY);
assert_se(sd_bus_error_set(NULL, "System.Error.EINVAL", NULL) == -EINVAL);
assert_se(sd_bus_error_set(NULL, "System.Error.WHATSIT", NULL) == -EIO);
}
BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors[] = {
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error", 5),
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-2", 52),
SD_BUS_ERROR_MAP_END
};
BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors2[] = {
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-3", 33),
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-4", 44),
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-33", 333),
SD_BUS_ERROR_MAP_END
};
static const sd_bus_error_map test_errors3[] = {
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-88", 888),
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-99", 999),
SD_BUS_ERROR_MAP_END
};
static const sd_bus_error_map test_errors4[] = {
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-77", 777),
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-78", 778),
SD_BUS_ERROR_MAP_END
};
static const sd_bus_error_map test_errors_bad1[] = {
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", 0),
SD_BUS_ERROR_MAP_END
};
static const sd_bus_error_map test_errors_bad2[] = {
SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", -1),
SD_BUS_ERROR_MAP_END
};
TEST(errno_mapping_custom) {
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error", NULL) == -5);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-x", NULL) == -EIO);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-33", NULL) == -333);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -EIO);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -EIO);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -EIO);
assert_se(sd_bus_error_add_map(test_errors3) > 0);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -888);
assert_se(sd_bus_error_add_map(test_errors4) > 0);
assert_se(sd_bus_error_add_map(test_errors4) == 0);
assert_se(sd_bus_error_add_map(test_errors3) == 0);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -999);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -777);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-78", NULL) == -778);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-y", NULL) == -EIO);
assert_se(sd_bus_error_set(NULL, BUS_ERROR_NO_SUCH_UNIT, NULL) == -ENOENT);
assert_se(sd_bus_error_add_map(test_errors_bad1) == -EINVAL);
assert_se(sd_bus_error_add_map(test_errors_bad2) == -EINVAL);
}
TEST(sd_bus_error_set_errnof) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *str = NULL;
assert_se(sd_bus_error_set_errnof(NULL, 0, NULL) == 0);
assert_se(sd_bus_error_set_errnof(NULL, ENOANO, NULL) == -ENOANO);
assert_se(sd_bus_error_set_errnof(&error, 0, NULL) == 0);
assert_se(!bus_error_is_dirty(&error));
assert_se(sd_bus_error_set_errnof(&error, EACCES, NULL) == -EACCES);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_ACCESS_DENIED));
errno = EACCES;
assert_se(asprintf(&str, "%m") >= 0);
assert_se(streq(error.message, str));
assert_se(error._need_free == 0);
str = mfree(str);
sd_bus_error_free(&error);
assert_se(sd_bus_error_set_errnof(&error, ENOANO, NULL) == -ENOANO);
assert_se(sd_bus_error_has_name(&error, "System.Error.ENOANO"));
errno = ENOANO;
assert_se(asprintf(&str, "%m") >= 0);
assert_se(streq(error.message, str));
assert_se(error._need_free == 1);
str = mfree(str);
sd_bus_error_free(&error);
assert_se(sd_bus_error_set_errnof(&error, 100000, NULL) == -100000);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FAILED));
errno = 100000;
assert_se(asprintf(&str, "%m") >= 0);
assert_se(streq(error.message, str));
assert_se(error._need_free == 1);
str = mfree(str);
sd_bus_error_free(&error);
assert_se(sd_bus_error_set_errnof(NULL, 0, "hoge %s: %m", "foo") == 0);
assert_se(sd_bus_error_set_errnof(NULL, ENOANO, "hoge %s: %m", "foo") == -ENOANO);
assert_se(sd_bus_error_set_errnof(&error, 0, "hoge %s: %m", "foo") == 0);
assert_se(!bus_error_is_dirty(&error));
assert_se(sd_bus_error_set_errnof(&error, EACCES, "hoge %s: %m", "foo") == -EACCES);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_ACCESS_DENIED));
errno = EACCES;
assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
assert_se(streq(error.message, str));
assert_se(error._need_free == 1);
str = mfree(str);
sd_bus_error_free(&error);
assert_se(sd_bus_error_set_errnof(&error, ENOANO, "hoge %s: %m", "foo") == -ENOANO);
assert_se(sd_bus_error_has_name(&error, "System.Error.ENOANO"));
errno = ENOANO;
assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
assert_se(streq(error.message, str));
assert_se(error._need_free == 1);
str = mfree(str);
sd_bus_error_free(&error);
assert_se(sd_bus_error_set_errnof(&error, 100000, "hoge %s: %m", "foo") == -100000);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FAILED));
errno = 100000;
assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
assert_se(streq(error.message, str));
assert_se(error._need_free == 1);
}
DEFINE_TEST_MAIN_WITH_INTRO(LOG_INFO, dump_mapping_table);
| 13,417 | 44.484746 | 113 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-introspect.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "bus-introspect.h"
#include "log.h"
#include "tests.h"
#include "test-vtable-data.h"
static void test_manual_introspection_one(const sd_bus_vtable vtable[]) {
struct introspect intro = {};
_cleanup_free_ char *s = NULL;
log_info("/* %s */", __func__);
assert_se(introspect_begin(&intro, false) >= 0);
assert_se(introspect_write_interface(&intro, "org.foo", vtable) >= 0);
/* write again to check if output looks OK for a different interface */
assert_se(introspect_write_interface(&intro, "org.foo.bar", vtable) >= 0);
assert_se(introspect_finish(&intro, &s) == 0);
fputs(s, stdout);
fputs("\n", stdout);
}
TEST(manual_introspection) {
test_manual_introspection_one(test_vtable_1);
test_manual_introspection_one(test_vtable_2);
test_manual_introspection_one(test_vtable_deprecated);
test_manual_introspection_one((const sd_bus_vtable *) vtable_format_221);
}
DEFINE_TEST_MAIN(LOG_DEBUG);
| 1,067 | 30.411765 | 82 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-match.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "bus-match.h"
#include "bus-message.h"
#include "bus-slot.h"
#include "log.h"
#include "macro.h"
#include "memory-util.h"
#include "tests.h"
static bool mask[32];
static int filter(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
log_info("Ran %u", PTR_TO_UINT(userdata));
assert_se(PTR_TO_UINT(userdata) < ELEMENTSOF(mask));
mask[PTR_TO_UINT(userdata)] = true;
return 0;
}
static bool mask_contains(unsigned a[], unsigned n) {
unsigned i, j;
for (i = 0; i < ELEMENTSOF(mask); i++) {
bool found = false;
for (j = 0; j < n; j++)
if (a[j] == i) {
found = true;
break;
}
if (found != mask[i])
return false;
}
return true;
}
static int match_add(sd_bus_slot *slots, struct bus_match_node *root, const char *match, int value) {
struct bus_match_component *components;
size_t n_components;
sd_bus_slot *s;
int r;
s = slots + value;
r = bus_match_parse(match, &components, &n_components);
if (r < 0)
return r;
CLEANUP_ARRAY(components, n_components, bus_match_parse_free);
s->userdata = INT_TO_PTR(value);
s->match_callback.callback = filter;
return bus_match_add(root, components, n_components, &s->match_callback);
}
static void test_match_scope(const char *match, enum bus_match_scope scope) {
struct bus_match_component *components = NULL;
size_t n_components = 0;
CLEANUP_ARRAY(components, n_components, bus_match_parse_free);
assert_se(bus_match_parse(match, &components, &n_components) >= 0);
assert_se(bus_match_get_scope(components, n_components) == scope);
}
int main(int argc, char *argv[]) {
struct bus_match_node root = {
.type = BUS_MATCH_ROOT,
};
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
sd_bus_slot slots[19] = {};
int r;
test_setup_logging(LOG_INFO);
r = sd_bus_open_user(&bus);
if (r < 0)
r = sd_bus_open_system(&bus);
if (r < 0)
return log_tests_skipped("Failed to connect to bus");
assert_se(match_add(slots, &root, "arg2='wal\\'do',sender='foo',type='signal',interface='bar.x',", 1) >= 0);
assert_se(match_add(slots, &root, "arg2='wal\\'do2',sender='foo',type='signal',interface='bar.x',", 2) >= 0);
assert_se(match_add(slots, &root, "arg3='test',sender='foo',type='signal',interface='bar.x',", 3) >= 0);
assert_se(match_add(slots, &root, "arg3='test',sender='foo',type='method_call',interface='bar.x',", 4) >= 0);
assert_se(match_add(slots, &root, "", 5) >= 0);
assert_se(match_add(slots, &root, "interface='quux.x'", 6) >= 0);
assert_se(match_add(slots, &root, "interface='bar.x'", 7) >= 0);
assert_se(match_add(slots, &root, "member='waldo',path='/foo/bar'", 8) >= 0);
assert_se(match_add(slots, &root, "path='/foo/bar'", 9) >= 0);
assert_se(match_add(slots, &root, "path_namespace='/foo'", 10) >= 0);
assert_se(match_add(slots, &root, "path_namespace='/foo/quux'", 11) >= 0);
assert_se(match_add(slots, &root, "arg1='two'", 12) >= 0);
assert_se(match_add(slots, &root, "member='waldo',arg2path='/prefix/'", 13) >= 0);
assert_se(match_add(slots, &root, "member=waldo,path='/foo/bar',arg3namespace='prefix'", 14) >= 0);
assert_se(match_add(slots, &root, "arg4has='pi'", 15) >= 0);
assert_se(match_add(slots, &root, "arg4has='pa'", 16) >= 0);
assert_se(match_add(slots, &root, "arg4has='po'", 17) >= 0);
assert_se(match_add(slots, &root, "arg4='pi'", 18) >= 0);
bus_match_dump(stdout, &root, 0);
assert_se(sd_bus_message_new_signal(bus, &m, "/foo/bar", "bar.x", "waldo") >= 0);
assert_se(sd_bus_message_append(m, "ssssas", "one", "two", "/prefix/three", "prefix.four", 3, "pi", "pa", "po") >= 0);
assert_se(sd_bus_message_seal(m, 1, 0) >= 0);
zero(mask);
assert_se(bus_match_run(NULL, &root, m) == 0);
assert_se(mask_contains((unsigned[]) { 9, 8, 7, 5, 10, 12, 13, 14, 15, 16, 17 }, 11));
assert_se(bus_match_remove(&root, &slots[8].match_callback) >= 0);
assert_se(bus_match_remove(&root, &slots[13].match_callback) >= 0);
bus_match_dump(stdout, &root, 0);
zero(mask);
assert_se(bus_match_run(NULL, &root, m) == 0);
assert_se(mask_contains((unsigned[]) { 9, 5, 10, 12, 14, 7, 15, 16, 17 }, 9));
for (enum bus_match_node_type i = 0; i < _BUS_MATCH_NODE_TYPE_MAX; i++) {
char buf[32];
const char *x;
assert_se(x = bus_match_node_type_to_string(i, buf, sizeof(buf)));
if (i >= BUS_MATCH_MESSAGE_TYPE)
assert_se(bus_match_node_type_from_string(x, strlen(x)) == i);
}
bus_match_free(&root);
test_match_scope("interface='foobar'", BUS_MATCH_GENERIC);
test_match_scope("", BUS_MATCH_GENERIC);
test_match_scope("interface='org.freedesktop.DBus.Local'", BUS_MATCH_LOCAL);
test_match_scope("sender='org.freedesktop.DBus.Local'", BUS_MATCH_LOCAL);
test_match_scope("member='gurke',path='/org/freedesktop/DBus/Local'", BUS_MATCH_LOCAL);
test_match_scope("arg2='piep',sender='org.freedesktop.DBus',member='waldo'", BUS_MATCH_DRIVER);
return 0;
}
| 5,765 | 38.493151 | 126 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-queue-ref-cycle.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-bus.h"
#include "main-func.h"
#include "tests.h"
static int test_ref_unref(void) {
sd_bus_message *m = NULL;
sd_bus *bus = NULL;
int r;
/* This test will result in a memory leak in <= v240, but not on v241. Hence to be really useful it
* should be run through a leak tracker such as valgrind. */
r = sd_bus_open_system(&bus);
if (r < 0)
return log_tests_skipped("Failed to connect to bus");
/* Create a message and enqueue it (this shouldn't send it though as the connection setup is not complete yet) */
assert_se(sd_bus_message_new_method_call(bus, &m, "foo.bar", "/foo", "quux.quux", "waldo") >= 0);
assert_se(sd_bus_send(bus, m, NULL) >= 0);
/* Let's now unref the message first and the bus second. */
m = sd_bus_message_unref(m);
bus = sd_bus_unref(bus);
/* We should have a memory leak now on <= v240. Let's do this again, but destroy in the opposite
* order. On v240 that too should be a leak. */
r = sd_bus_open_system(&bus);
if (r < 0)
return log_tests_skipped("Failed to connect to bus");
assert_se(sd_bus_message_new_method_call(bus, &m, "foo.bar", "/foo", "quux.quux", "waldo") >= 0);
assert_se(sd_bus_send(bus, m, NULL) >= 0);
/* Let's now unref things in the opposite order */
bus = sd_bus_unref(bus);
m = sd_bus_message_unref(m);
return 0;
}
static int run(int argc, char *argv[]) {
int r;
test_setup_logging(LOG_INFO);
r = test_ref_unref();
if (r < 0)
return r;
return 0;
}
DEFINE_MAIN_FUNCTION(run);
| 1,769 | 30.052632 | 121 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-server.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <pthread.h>
#include <stdlib.h>
#include "sd-bus.h"
#include "bus-internal.h"
#include "log.h"
#include "macro.h"
#include "memory-util.h"
#include "string-util.h"
struct context {
int fds[2];
bool client_negotiate_unix_fds;
bool server_negotiate_unix_fds;
bool client_anonymous_auth;
bool server_anonymous_auth;
};
static int _server(struct context *c) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
sd_id128_t id;
bool quit = false;
int r;
assert_se(sd_id128_randomize(&id) >= 0);
assert_se(sd_bus_new(&bus) >= 0);
assert_se(sd_bus_set_fd(bus, c->fds[0], c->fds[0]) >= 0);
assert_se(sd_bus_set_server(bus, 1, id) >= 0);
assert_se(sd_bus_set_anonymous(bus, c->server_anonymous_auth) >= 0);
assert_se(sd_bus_negotiate_fds(bus, c->server_negotiate_unix_fds) >= 0);
assert_se(sd_bus_start(bus) >= 0);
while (!quit) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
r = sd_bus_process(bus, &m);
if (r < 0)
return log_error_errno(r, "Failed to process requests: %m");
if (r == 0) {
r = sd_bus_wait(bus, UINT64_MAX);
if (r < 0)
return log_error_errno(r, "Failed to wait: %m");
continue;
}
if (!m)
continue;
log_info("Got message! member=%s", strna(sd_bus_message_get_member(m)));
if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Exit")) {
assert_se((sd_bus_can_send(bus, 'h') >= 1) ==
(c->server_negotiate_unix_fds && c->client_negotiate_unix_fds));
r = sd_bus_message_new_method_return(m, &reply);
if (r < 0)
return log_error_errno(r, "Failed to allocate return: %m");
quit = true;
} else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
r = sd_bus_message_new_method_error(
m,
&reply,
&SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
if (r < 0)
return log_error_errno(r, "Failed to allocate return: %m");
}
if (reply) {
r = sd_bus_send(bus, reply, NULL);
if (r < 0)
return log_error_errno(r, "Failed to send reply: %m");
}
}
return 0;
}
static void* server(void *p) {
return INT_TO_PTR(_server(p));
}
static int client(struct context *c) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
_cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert_se(sd_bus_new(&bus) >= 0);
assert_se(sd_bus_set_fd(bus, c->fds[1], c->fds[1]) >= 0);
assert_se(sd_bus_negotiate_fds(bus, c->client_negotiate_unix_fds) >= 0);
assert_se(sd_bus_set_anonymous(bus, c->client_anonymous_auth) >= 0);
assert_se(sd_bus_start(bus) >= 0);
r = sd_bus_message_new_method_call(
bus,
&m,
"org.freedesktop.systemd.test",
"/",
"org.freedesktop.systemd.test",
"Exit");
if (r < 0)
return log_error_errno(r, "Failed to allocate method call: %m");
r = sd_bus_call(bus, m, 0, &error, &reply);
if (r < 0)
return log_error_errno(r, "Failed to issue method call: %s", bus_error_message(&error, r));
return 0;
}
static int test_one(bool client_negotiate_unix_fds, bool server_negotiate_unix_fds,
bool client_anonymous_auth, bool server_anonymous_auth) {
struct context c;
pthread_t s;
void *p;
int r, q;
zero(c);
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, c.fds) >= 0);
c.client_negotiate_unix_fds = client_negotiate_unix_fds;
c.server_negotiate_unix_fds = server_negotiate_unix_fds;
c.client_anonymous_auth = client_anonymous_auth;
c.server_anonymous_auth = server_anonymous_auth;
r = pthread_create(&s, NULL, server, &c);
if (r != 0)
return -r;
r = client(&c);
q = pthread_join(s, &p);
if (q != 0)
return -q;
if (r < 0)
return r;
if (PTR_TO_INT(p) < 0)
return PTR_TO_INT(p);
return 0;
}
int main(int argc, char *argv[]) {
int r;
r = test_one(true, true, false, false);
assert_se(r >= 0);
r = test_one(true, false, false, false);
assert_se(r >= 0);
r = test_one(false, true, false, false);
assert_se(r >= 0);
r = test_one(false, false, false, false);
assert_se(r >= 0);
r = test_one(true, true, true, true);
assert_se(r >= 0);
r = test_one(true, true, false, true);
assert_se(r >= 0);
r = test_one(true, true, true, false);
assert_se(r == -EPERM);
return EXIT_SUCCESS;
}
| 5,705 | 30.180328 | 114 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-signature.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "bus-internal.h"
#include "bus-signature.h"
#include "log.h"
#include "string-util.h"
int main(int argc, char *argv[]) {
char prefix[256];
int r;
assert_se(signature_is_single("y", false));
assert_se(signature_is_single("u", false));
assert_se(signature_is_single("v", false));
assert_se(signature_is_single("as", false));
assert_se(signature_is_single("(ss)", false));
assert_se(!signature_is_single("()", false));
assert_se(!signature_is_single("(()()()()())", false));
assert_se(!signature_is_single("(((())))", false));
assert_se(signature_is_single("((((s))))", false));
assert_se(signature_is_single("{ss}", true));
assert_se(signature_is_single("a{ss}", false));
assert_se(!signature_is_single("uu", false));
assert_se(!signature_is_single("", false));
assert_se(!signature_is_single("(", false));
assert_se(!signature_is_single(")", false));
assert_se(!signature_is_single("())", false));
assert_se(!signature_is_single("((())", false));
assert_se(!signature_is_single("{)", false));
assert_se(!signature_is_single("{}", true));
assert_se(!signature_is_single("{sss}", true));
assert_se(!signature_is_single("{s}", true));
assert_se(!signature_is_single("{ss}", false));
assert_se(!signature_is_single("{ass}", true));
assert_se(!signature_is_single("a}", true));
assert_se(signature_is_pair("yy"));
assert_se(signature_is_pair("ss"));
assert_se(signature_is_pair("sas"));
assert_se(signature_is_pair("sv"));
assert_se(signature_is_pair("sa(vs)"));
assert_se(!signature_is_pair(""));
assert_se(!signature_is_pair("va"));
assert_se(!signature_is_pair("sss"));
assert_se(!signature_is_pair("{s}ss"));
assert_se(signature_is_valid("ssa{ss}sssub", true));
assert_se(signature_is_valid("ssa{ss}sssub", false));
assert_se(signature_is_valid("{ss}", true));
assert_se(!signature_is_valid("{ss}", false));
assert_se(signature_is_valid("", true));
assert_se(signature_is_valid("", false));
assert_se(signature_is_valid("sssusa(uuubbba(uu)uuuu)a{u(uuuvas)}", false));
assert_se(!signature_is_valid("a", false));
assert_se(signature_is_valid("as", false));
assert_se(signature_is_valid("aas", false));
assert_se(signature_is_valid("aaas", false));
assert_se(signature_is_valid("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaad", false));
assert_se(signature_is_valid("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaas", false));
assert_se(!signature_is_valid("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaau", false));
assert_se(signature_is_valid("((((((((((((((((((((((((((((((((s))))))))))))))))))))))))))))))))", false));
assert_se(!signature_is_valid("((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))", false));
assert_se(namespace_complex_pattern("", ""));
assert_se(namespace_complex_pattern("foobar", "foobar"));
assert_se(namespace_complex_pattern("foobar.waldo", "foobar.waldo"));
assert_se(namespace_complex_pattern("foobar.", "foobar.waldo"));
assert_se(namespace_complex_pattern("foobar.waldo", "foobar."));
assert_se(!namespace_complex_pattern("foobar.waldo", "foobar"));
assert_se(!namespace_complex_pattern("foobar", "foobar.waldo"));
assert_se(!namespace_complex_pattern("", "foo"));
assert_se(!namespace_complex_pattern("foo", ""));
assert_se(!namespace_complex_pattern("foo.", ""));
assert_se(path_complex_pattern("", ""));
assert_se(!path_complex_pattern("", "/"));
assert_se(!path_complex_pattern("/", ""));
assert_se(path_complex_pattern("/", "/"));
assert_se(path_complex_pattern("/foobar/", "/"));
assert_se(!path_complex_pattern("/foobar/", "/foobar"));
assert_se(path_complex_pattern("/foobar", "/foobar"));
assert_se(!path_complex_pattern("/foobar", "/foobar/"));
assert_se(!path_complex_pattern("/foobar", "/foobar/waldo"));
assert_se(path_complex_pattern("/foobar/", "/foobar/waldo"));
assert_se(path_complex_pattern("/foobar/waldo", "/foobar/"));
assert_se(path_simple_pattern("/foo/", "/foo/bar/waldo"));
assert_se(namespace_simple_pattern("", ""));
assert_se(namespace_simple_pattern("", ".foobar"));
assert_se(namespace_simple_pattern("foobar", "foobar"));
assert_se(namespace_simple_pattern("foobar.waldo", "foobar.waldo"));
assert_se(namespace_simple_pattern("foobar", "foobar.waldo"));
assert_se(!namespace_simple_pattern("foobar.waldo", "foobar"));
assert_se(!namespace_simple_pattern("", "foo"));
assert_se(!namespace_simple_pattern("foo", ""));
assert_se(namespace_simple_pattern("foo.", "foo.bar.waldo"));
assert_se(streq(object_path_startswith("/foo/bar", "/foo"), "bar"));
assert_se(streq(object_path_startswith("/foo", "/foo"), ""));
assert_se(streq(object_path_startswith("/foo", "/"), "foo"));
assert_se(streq(object_path_startswith("/", "/"), ""));
assert_se(!object_path_startswith("/foo", "/bar"));
assert_se(!object_path_startswith("/", "/bar"));
assert_se(!object_path_startswith("/foo", ""));
assert_se(object_path_is_valid("/foo/bar"));
assert_se(object_path_is_valid("/foo"));
assert_se(object_path_is_valid("/"));
assert_se(object_path_is_valid("/foo5"));
assert_se(object_path_is_valid("/foo_5"));
assert_se(!object_path_is_valid(""));
assert_se(!object_path_is_valid("/foo/"));
assert_se(!object_path_is_valid("//"));
assert_se(!object_path_is_valid("//foo"));
assert_se(!object_path_is_valid("/foo//bar"));
assert_se(!object_path_is_valid("/foo/aaaäöä"));
OBJECT_PATH_FOREACH_PREFIX(prefix, "/") {
log_info("<%s>", prefix);
assert_not_reached();
}
r = 0;
OBJECT_PATH_FOREACH_PREFIX(prefix, "/xxx") {
log_info("<%s>", prefix);
assert_se(streq(prefix, "/"));
assert_se(r == 0);
r++;
}
assert_se(r == 1);
r = 0;
OBJECT_PATH_FOREACH_PREFIX(prefix, "/xxx/yyy/zzz") {
log_info("<%s>", prefix);
assert_se(r != 0 || streq(prefix, "/xxx/yyy"));
assert_se(r != 1 || streq(prefix, "/xxx"));
assert_se(r != 2 || streq(prefix, "/"));
r++;
}
assert_se(r == 3);
return 0;
}
| 6,826 | 45.128378 | 116 |
c
|
null |
systemd-main/src/libsystemd/sd-bus/test-bus-track.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <sys/socket.h>
#include "sd-bus.h"
#include "macro.h"
#include "tests.h"
static bool track_cb_called_x = false;
static bool track_cb_called_y = false;
static bool track_destroy_called_z = false;
static int track_cb_x(sd_bus_track *t, void *userdata) {
log_error("TRACK CB X");
assert_se(!track_cb_called_x);
track_cb_called_x = true;
/* This means b's name disappeared. Let's now disconnect, to make sure the track handling on disconnect works
* as it should. */
assert_se(shutdown(sd_bus_get_fd(sd_bus_track_get_bus(t)), SHUT_RDWR) >= 0);
return 1;
}
static int track_cb_y(sd_bus_track *t, void *userdata) {
log_error("TRACK CB Y");
assert_se(!track_cb_called_y);
track_cb_called_y = true;
/* We got disconnected, let's close everything */
assert_se(sd_event_exit(sd_bus_get_event(sd_bus_track_get_bus(t)), EXIT_SUCCESS) >= 0);
return 0;
}
static int track_cb_z(sd_bus_track *t, void *userdata) {
assert_not_reached();
}
static void track_destroy_z(void *userdata) {
track_destroy_called_z = true;
}
int main(int argc, char *argv[]) {
_cleanup_(sd_event_unrefp) sd_event *event = NULL;
_cleanup_(sd_bus_track_unrefp) sd_bus_track *x = NULL, *y = NULL, *z = NULL;
_cleanup_(sd_bus_unrefp) sd_bus *a = NULL, *b = NULL;
bool use_system_bus = false;
const char *unique;
int r;
test_setup_logging(LOG_INFO);
assert_se(sd_event_default(&event) >= 0);
r = sd_bus_open_user(&a);
if (IN_SET(r, -ECONNREFUSED, -ENOENT, -ENOMEDIUM)) {
r = sd_bus_open_system(&a);
if (IN_SET(r, -ECONNREFUSED, -ENOENT))
return log_tests_skipped("Failed to connect to bus");
use_system_bus = true;
}
assert_se(r >= 0);
assert_se(sd_bus_attach_event(a, event, SD_EVENT_PRIORITY_NORMAL) >= 0);
if (use_system_bus)
assert_se(sd_bus_open_system(&b) >= 0);
else
assert_se(sd_bus_open_user(&b) >= 0);
assert_se(sd_bus_attach_event(b, event, SD_EVENT_PRIORITY_NORMAL) >= 0);
/* Watch b's name from a */
assert_se(sd_bus_track_new(a, &x, track_cb_x, NULL) >= 0);
assert_se(sd_bus_get_unique_name(b, &unique) >= 0);
assert_se(sd_bus_track_add_name(x, unique) >= 0);
/* Watch's a's own name from a */
assert_se(sd_bus_track_new(a, &y, track_cb_y, NULL) >= 0);
assert_se(sd_bus_get_unique_name(a, &unique) >= 0);
assert_se(sd_bus_track_add_name(y, unique) >= 0);
/* Basic tests. */
assert_se(sd_bus_track_new(a, &z, track_cb_z, NULL) >= 0);
/* non-recursive case */
assert_se(sd_bus_track_set_recursive(z, false) >= 0);
assert_se(sd_bus_track_get_recursive(z) == 0);
assert_se(!sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 0);
assert_se(sd_bus_track_remove_name(z, unique) == 0);
assert_se(sd_bus_track_add_name(z, unique) >= 0);
assert_se(sd_bus_track_add_name(z, unique) >= 0);
assert_se(sd_bus_track_add_name(z, unique) >= 0);
assert_se(sd_bus_track_set_recursive(z, true) == -EBUSY);
assert_se(sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 1);
assert_se(sd_bus_track_remove_name(z, unique) == 1);
assert_se(!sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 0);
assert_se(sd_bus_track_remove_name(z, unique) == 0);
/* recursive case */
assert_se(sd_bus_track_set_recursive(z, true) >= 0);
assert_se(sd_bus_track_get_recursive(z) == 1);
assert_se(!sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 0);
assert_se(sd_bus_track_remove_name(z, unique) == 0);
assert_se(sd_bus_track_add_name(z, unique) >= 0);
assert_se(sd_bus_track_add_name(z, unique) >= 0);
assert_se(sd_bus_track_add_name(z, unique) >= 0);
assert_se(sd_bus_track_set_recursive(z, false) == -EBUSY);
assert_se(sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 3);
assert_se(sd_bus_track_remove_name(z, unique) == 1);
assert_se(sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 2);
assert_se(sd_bus_track_remove_name(z, unique) == 1);
assert_se(sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 1);
assert_se(sd_bus_track_remove_name(z, unique) == 1);
assert_se(!sd_bus_track_contains(z, unique));
assert_se(sd_bus_track_count_name(z, unique) == 0);
assert_se(sd_bus_track_remove_name(z, unique) == 0);
assert_se(sd_bus_track_set_destroy_callback(z, track_destroy_z) >= 0);
z = sd_bus_track_unref(z);
assert_se(track_destroy_called_z);
/* Now make b's name disappear */
sd_bus_close(b);
assert_se(sd_event_loop(event) >= 0);
assert_se(track_cb_called_x);
assert_se(track_cb_called_y);
return 0;
}
| 5,387 | 34.447368 | 117 |
c
|
null |
systemd-main/src/libsystemd/sd-device/device-enumerator-private.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "sd-device.h"
typedef enum MatchInitializedType {
MATCH_INITIALIZED_NO, /* only devices without a db entry */
MATCH_INITIALIZED_YES, /* only devices with a db entry */
MATCH_INITIALIZED_ALL, /* all devices */
MATCH_INITIALIZED_COMPAT, /* only devices that have no devnode/ifindex or have a db entry */
_MATCH_INITIALIZED_MAX,
_MATCH_INITIALIZED_INVALID = -EINVAL,
} MatchInitializedType;
int device_enumerator_scan_devices(sd_device_enumerator *enumerator);
int device_enumerator_scan_subsystems(sd_device_enumerator *enumerator);
int device_enumerator_scan_devices_and_subsystems(sd_device_enumerator *enumerator);
int device_enumerator_add_device(sd_device_enumerator *enumerator, sd_device *device);
int device_enumerator_add_parent_devices(sd_device_enumerator *enumerator, sd_device *device);
int device_enumerator_add_match_is_initialized(sd_device_enumerator *enumerator, MatchInitializedType type);
int device_enumerator_add_match_parent_incremental(sd_device_enumerator *enumerator, sd_device *parent);
int device_enumerator_add_prioritized_subsystem(sd_device_enumerator *enumerator, const char *subsystem);
sd_device *device_enumerator_get_first(sd_device_enumerator *enumerator);
sd_device *device_enumerator_get_next(sd_device_enumerator *enumerator);
sd_device **device_enumerator_get_devices(sd_device_enumerator *enumerator, size_t *ret_n_devices);
#define FOREACH_DEVICE_AND_SUBSYSTEM(enumerator, device) \
for (device = device_enumerator_get_first(enumerator); \
device; \
device = device_enumerator_get_next(enumerator))
| 1,777 | 52.878788 | 108 |
h
|
null |
systemd-main/src/libsystemd/sd-device/device-filter.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fnmatch.h>
#include "device-filter.h"
#include "path-util.h"
int update_match_strv(Hashmap **match_strv, const char *key, const char *value, bool clear_on_null) {
char **strv;
int r;
assert(match_strv);
assert(key);
strv = hashmap_get(*match_strv, key);
if (strv) {
if (!value) {
char **v;
if (strv_isempty(strv) || !clear_on_null)
return 0;
/* Accept all value. Clear previous assignment. */
v = new0(char*, 1);
if (!v)
return -ENOMEM;
strv_free_and_replace(strv, v);
} else {
if (strv_contains(strv, value))
return 0;
r = strv_extend(&strv, value);
if (r < 0)
return r;
}
r = hashmap_update(*match_strv, key, strv);
if (r < 0)
return r;
} else {
_cleanup_strv_free_ char **strv_alloc = NULL;
_cleanup_free_ char *key_alloc = NULL;
key_alloc = strdup(key);
if (!key_alloc)
return -ENOMEM;
strv_alloc = strv_new(value);
if (!strv_alloc)
return -ENOMEM;
r = hashmap_ensure_put(match_strv, &string_hash_ops_free_strv_free, key_alloc, strv_alloc);
if (r < 0)
return r;
TAKE_PTR(key_alloc);
TAKE_PTR(strv_alloc);
}
return 1;
}
static bool device_match_sysattr_value(sd_device *device, const char *sysattr, char * const *patterns) {
const char *value;
assert(device);
assert(sysattr);
if (sd_device_get_sysattr_value(device, sysattr, &value) < 0)
return false;
return strv_fnmatch_or_empty(patterns, value, 0);
}
bool device_match_sysattr(sd_device *device, Hashmap *match_sysattr, Hashmap *nomatch_sysattr) {
char * const *patterns;
const char *sysattr;
assert(device);
HASHMAP_FOREACH_KEY(patterns, sysattr, match_sysattr)
if (!device_match_sysattr_value(device, sysattr, patterns))
return false;
HASHMAP_FOREACH_KEY(patterns, sysattr, nomatch_sysattr)
if (device_match_sysattr_value(device, sysattr, patterns))
return false;
return true;
}
bool device_match_parent(sd_device *device, Set *match_parent, Set *nomatch_parent) {
const char *syspath_parent, *syspath;
assert(device);
if (sd_device_get_syspath(device, &syspath) < 0)
return false;
SET_FOREACH(syspath_parent, nomatch_parent)
if (path_startswith(syspath, syspath_parent))
return false;
if (set_isempty(match_parent))
return true;
SET_FOREACH(syspath_parent, match_parent)
if (path_startswith(syspath, syspath_parent))
return true;
return false;
}
| 3,402 | 28.336207 | 107 |
c
|
null |
systemd-main/src/libsystemd/sd-device/device-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-device.h"
#include "device-private.h"
#include "hashmap.h"
#include "set.h"
#include "time-util.h"
#define LATEST_UDEV_DATABASE_VERSION 1
struct sd_device {
unsigned n_ref;
/* The database version indicates the supported features by the udev database.
* This is saved and parsed in V field.
*
* 0: None of the following features are supported (systemd version <= 246).
* 1: The current tags (Q) and the database version (V) features are implemented (>= 247).
*/
unsigned database_version;
sd_device *parent;
OrderedHashmap *properties;
Iterator properties_iterator;
uint64_t properties_generation; /* changes whenever the properties are changed */
uint64_t properties_iterator_generation; /* generation when iteration was started */
/* the subset of the properties that should be written to the db */
OrderedHashmap *properties_db;
Hashmap *sysattr_values; /* cached sysattr values */
Set *sysattrs; /* names of sysattrs */
Iterator sysattrs_iterator;
Set *all_tags, *current_tags;
Iterator all_tags_iterator, current_tags_iterator;
uint64_t all_tags_iterator_generation, current_tags_iterator_generation; /* generation when iteration was started */
uint64_t tags_generation; /* changes whenever the tags are changed */
Set *devlinks;
Iterator devlinks_iterator;
uint64_t devlinks_generation; /* changes whenever the devlinks are changed */
uint64_t devlinks_iterator_generation; /* generation when iteration was started */
int devlink_priority;
Hashmap *children;
Iterator children_iterator;
bool children_enumerated;
int ifindex;
char *devtype;
char *devname;
dev_t devnum;
char **properties_strv; /* the properties hashmap as a strv */
char *properties_nulstr; /* the same as a nulstr */
size_t properties_nulstr_len;
char *syspath;
const char *devpath;
const char *sysnum;
char *sysname;
char *subsystem;
char *driver_subsystem; /* only set for the 'drivers' subsystem */
char *driver;
char *device_id;
usec_t usec_initialized;
mode_t devmode;
uid_t devuid;
gid_t devgid;
uint64_t diskseq; /* Block device sequence number, monothonically incremented by the kernel on create/attach */
/* only set when device is passed through netlink */
sd_device_action_t action;
uint64_t seqnum;
bool parent_set:1; /* no need to try to reload parent */
bool sysattrs_read:1; /* don't try to re-read sysattrs once read */
bool property_tags_outdated:1; /* need to update TAGS= or CURRENT_TAGS= property */
bool property_devlinks_outdated:1; /* need to update DEVLINKS= property */
bool properties_buf_outdated:1; /* need to reread hashmap */
bool subsystem_set:1; /* don't reread subsystem */
bool driver_set:1; /* don't reread driver */
bool uevent_loaded:1; /* don't reread uevent */
bool db_loaded; /* don't reread db */
bool is_initialized:1;
bool sealed:1; /* don't read more information from uevent/db */
bool db_persist:1; /* don't clean up the db when switching from initrd to real root */
};
int device_new_aux(sd_device **ret);
int device_add_property_aux(sd_device *device, const char *key, const char *value, bool db);
static inline int device_add_property_internal(sd_device *device, const char *key, const char *value) {
return device_add_property_aux(device, key, value, false);
}
int device_set_syspath(sd_device *device, const char *_syspath, bool verify);
int device_set_ifindex(sd_device *device, const char *ifindex);
int device_set_devmode(sd_device *device, const char *devmode);
int device_set_devname(sd_device *device, const char *devname);
int device_set_devtype(sd_device *device, const char *devtype);
int device_set_devnum(sd_device *device, const char *major, const char *minor);
int device_set_subsystem(sd_device *device, const char *subsystem);
int device_set_diskseq(sd_device *device, const char *str);
int device_set_drivers_subsystem(sd_device *device);
int device_set_driver(sd_device *device, const char *driver);
int device_set_usec_initialized(sd_device *device, usec_t when);
| 4,540 | 37.483051 | 124 |
h
|
null |
systemd-main/src/libsystemd/sd-device/device-monitor-private.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <errno.h>
#include "sd-device.h"
typedef enum MonitorNetlinkGroup {
MONITOR_GROUP_NONE,
MONITOR_GROUP_KERNEL,
MONITOR_GROUP_UDEV,
_MONITOR_NETLINK_GROUP_MAX,
_MONITOR_NETLINK_GROUP_INVALID = -EINVAL,
} MonitorNetlinkGroup;
int device_monitor_new_full(sd_device_monitor **ret, MonitorNetlinkGroup group, int fd);
int device_monitor_disconnect(sd_device_monitor *m);
int device_monitor_allow_unicast_sender(sd_device_monitor *m, sd_device_monitor *sender);
int device_monitor_enable_receiving(sd_device_monitor *m);
int device_monitor_get_fd(sd_device_monitor *m);
int device_monitor_send_device(sd_device_monitor *m, sd_device_monitor *destination, sd_device *device);
int device_monitor_receive_device(sd_device_monitor *m, sd_device **ret);
| 857 | 36.304348 | 104 |
h
|
null |
systemd-main/src/libsystemd/sd-device/device-private.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <dirent.h>
#include <inttypes.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "sd-device.h"
#include "macro.h"
int device_new_from_mode_and_devnum(sd_device **ret, mode_t mode, dev_t devnum);
int device_new_from_nulstr(sd_device **ret, char *nulstr, size_t len);
int device_new_from_strv(sd_device **ret, char **strv);
int device_opendir(sd_device *device, const char *subdir, DIR **ret);
int device_get_property_bool(sd_device *device, const char *key);
int device_get_property_int(sd_device *device, const char *key, int *ret);
int device_get_sysattr_int(sd_device *device, const char *sysattr, int *ret_value);
int device_get_sysattr_unsigned(sd_device *device, const char *sysattr, unsigned *ret_value);
int device_get_sysattr_bool(sd_device *device, const char *sysattr);
int device_get_device_id(sd_device *device, const char **ret);
int device_get_devlink_priority(sd_device *device, int *ret);
int device_get_devnode_mode(sd_device *device, mode_t *ret);
int device_get_devnode_uid(sd_device *device, uid_t *ret);
int device_get_devnode_gid(sd_device *device, gid_t *ret);
void device_clear_sysattr_cache(sd_device *device);
int device_cache_sysattr_value(sd_device *device, const char *key, char *value);
int device_get_cached_sysattr_value(sd_device *device, const char *key, const char **ret_value);
void device_seal(sd_device *device);
void device_set_is_initialized(sd_device *device);
void device_set_db_persist(sd_device *device);
void device_set_devlink_priority(sd_device *device, int priority);
int device_ensure_usec_initialized(sd_device *device, sd_device *device_old);
int device_add_devlink(sd_device *device, const char *devlink);
int device_remove_devlink(sd_device *device, const char *devlink);
bool device_has_devlink(sd_device *device, const char *devlink);
int device_add_property(sd_device *device, const char *property, const char *value);
int device_add_propertyf(sd_device *device, const char *key, const char *format, ...) _printf_(3, 4);
int device_add_tag(sd_device *device, const char *tag, bool both);
void device_remove_tag(sd_device *device, const char *tag);
void device_cleanup_tags(sd_device *device);
void device_cleanup_devlinks(sd_device *device);
uint64_t device_get_properties_generation(sd_device *device);
uint64_t device_get_tags_generation(sd_device *device);
uint64_t device_get_devlinks_generation(sd_device *device);
int device_properties_prepare(sd_device *device);
int device_get_properties_nulstr(sd_device *device, const char **ret_nulstr, size_t *ret_len);
int device_get_properties_strv(sd_device *device, char ***ret);
int device_clone_with_db(sd_device *device, sd_device **ret);
int device_tag_index(sd_device *dev, sd_device *dev_old, bool add);
int device_update_db(sd_device *device);
int device_delete_db(sd_device *device);
int device_read_db_internal_filename(sd_device *device, const char *filename); /* For fuzzer */
int device_read_db_internal(sd_device *device, bool force);
static inline int device_read_db(sd_device *device) {
return device_read_db_internal(device, false);
}
int device_read_uevent_file(sd_device *device);
int device_set_action(sd_device *device, sd_device_action_t a);
sd_device_action_t device_action_from_string(const char *s) _pure_;
const char *device_action_to_string(sd_device_action_t a) _const_;
void dump_device_action_table(void);
| 3,460 | 45.146667 | 101 |
h
|
null |
systemd-main/src/libsystemd/sd-device/device-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "device-private.h"
#include "device-util.h"
#include "devnum-util.h"
#include "fd-util.h"
#include "string-util.h"
#include "strv.h"
int devname_from_devnum(mode_t mode, dev_t devnum, char **ret) {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
_cleanup_free_ char *s = NULL;
const char *devname;
int r;
assert(ret);
if (devnum_is_zero(devnum))
return device_path_make_inaccessible(mode, ret);
r = device_new_from_mode_and_devnum(&dev, mode, devnum);
if (r < 0)
return r;
r = sd_device_get_devname(dev, &devname);
if (r < 0)
return r;
s = strdup(devname);
if (!s)
return -ENOMEM;
*ret = TAKE_PTR(s);
return 0;
}
int device_open_from_devnum(mode_t mode, dev_t devnum, int flags, char **ret) {
_cleanup_(sd_device_unrefp) sd_device *dev = NULL;
_cleanup_close_ int fd = -EBADF;
int r;
r = device_new_from_mode_and_devnum(&dev, mode, devnum);
if (r < 0)
return r;
fd = sd_device_open(dev, flags);
if (fd < 0)
return fd;
if (ret) {
const char *devname;
char *s;
r = sd_device_get_devname(dev, &devname);
if (r < 0)
return r;
s = strdup(devname);
if (!s)
return -ENOMEM;
*ret = s;
}
return TAKE_FD(fd);
}
static int add_string_field(
sd_device *device,
const char *field,
int (*func)(sd_device *dev, const char **s),
char ***strv) {
const char *s;
int r;
assert(device);
assert(field);
assert(func);
assert(strv);
r = func(device, &s);
if (r < 0 && r != -ENOENT)
log_device_debug_errno(device, r, "Failed to get device \"%s\" property, ignoring: %m", field);
if (r >= 0)
(void) strv_extend_assignment(strv, field, s);
return 0;
}
char** device_make_log_fields(sd_device *device) {
_cleanup_strv_free_ char **strv = NULL;
dev_t devnum;
int ifindex;
sd_device_action_t action;
uint64_t seqnum, diskseq;
int r;
assert(device);
(void) add_string_field(device, "SYSPATH", sd_device_get_syspath, &strv);
(void) add_string_field(device, "SUBSYSTEM", sd_device_get_subsystem, &strv);
(void) add_string_field(device, "DEVTYPE", sd_device_get_devtype, &strv);
(void) add_string_field(device, "DRIVER", sd_device_get_driver, &strv);
(void) add_string_field(device, "DEVPATH", sd_device_get_devpath, &strv);
(void) add_string_field(device, "DEVNAME", sd_device_get_devname, &strv);
(void) add_string_field(device, "SYSNAME", sd_device_get_sysname, &strv);
(void) add_string_field(device, "SYSNUM", sd_device_get_sysnum, &strv);
r = sd_device_get_devnum(device, &devnum);
if (r < 0 && r != -ENOENT)
log_device_debug_errno(device, r, "Failed to get device \"DEVNUM\" property, ignoring: %m");
if (r >= 0)
(void) strv_extendf(&strv, "DEVNUM="DEVNUM_FORMAT_STR, DEVNUM_FORMAT_VAL(devnum));
r = sd_device_get_ifindex(device, &ifindex);
if (r < 0 && r != -ENOENT)
log_device_debug_errno(device, r, "Failed to get device \"IFINDEX\" property, ignoring: %m");
if (r >= 0)
(void) strv_extendf(&strv, "IFINDEX=%i", ifindex);
r = sd_device_get_action(device, &action);
if (r < 0 && r != -ENOENT)
log_device_debug_errno(device, r, "Failed to get device \"ACTION\" property, ignoring: %m");
if (r >= 0)
(void) strv_extendf(&strv, "ACTION=%s", device_action_to_string(action));
r = sd_device_get_seqnum(device, &seqnum);
if (r < 0 && r != -ENOENT)
log_device_debug_errno(device, r, "Failed to get device \"SEQNUM\" property, ignoring: %m");
if (r >= 0)
(void) strv_extendf(&strv, "SEQNUM=%"PRIu64, seqnum);
r = sd_device_get_diskseq(device, &diskseq);
if (r < 0 && r != -ENOENT)
log_device_debug_errno(device, r, "Failed to get device \"DISKSEQ\" property, ignoring: %m");
if (r >= 0)
(void) strv_extendf(&strv, "DISKSEQ=%"PRIu64, diskseq);
return TAKE_PTR(strv);
}
| 4,659 | 31.816901 | 111 |
c
|
null |
systemd-main/src/libsystemd/sd-device/device-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "sd-device.h"
#include "log.h"
#include "macro.h"
#define device_unref_and_replace(a, b) \
unref_and_replace_full(a, b, sd_device_ref, sd_device_unref)
#define FOREACH_DEVICE_PROPERTY(device, key, value) \
for (const char *value, *key = sd_device_get_property_first(device, &(value)); \
key; \
key = sd_device_get_property_next(device, &(value)))
#define FOREACH_DEVICE_TAG(device, tag) \
for (const char *tag = sd_device_get_tag_first(device); \
tag; \
tag = sd_device_get_tag_next(device))
#define FOREACH_DEVICE_CURRENT_TAG(device, tag) \
for (const char *tag = sd_device_get_current_tag_first(device); \
tag; \
tag = sd_device_get_current_tag_next(device))
#define FOREACH_DEVICE_SYSATTR(device, attr) \
for (const char *attr = sd_device_get_sysattr_first(device); \
attr; \
attr = sd_device_get_sysattr_next(device))
#define FOREACH_DEVICE_DEVLINK(device, devlink) \
for (const char *devlink = sd_device_get_devlink_first(device); \
devlink; \
devlink = sd_device_get_devlink_next(device))
#define _FOREACH_DEVICE_CHILD(device, child, suffix_ptr) \
for (sd_device *child = sd_device_get_child_first(device, suffix_ptr); \
child; \
child = sd_device_get_child_next(device, suffix_ptr))
#define FOREACH_DEVICE_CHILD(device, child) \
_FOREACH_DEVICE_CHILD(device, child, NULL)
#define FOREACH_DEVICE_CHILD_WITH_SUFFIX(device, child, suffix) \
_FOREACH_DEVICE_CHILD(device, child, &suffix)
#define FOREACH_DEVICE(enumerator, device) \
for (sd_device *device = sd_device_enumerator_get_device_first(enumerator); \
device; \
device = sd_device_enumerator_get_device_next(enumerator))
#define FOREACH_SUBSYSTEM(enumerator, device) \
for (sd_device *device = sd_device_enumerator_get_subsystem_first(enumerator); \
device; \
device = sd_device_enumerator_get_subsystem_next(enumerator))
#define log_device_full_errno_zerook(device, level, error, ...) \
({ \
const char *_sysname = NULL; \
sd_device *_d = (device); \
int _level = (level), _e = (error); \
\
if (_d && _unlikely_(log_get_max_level() >= LOG_PRI(_level))) \
(void) sd_device_get_sysname(_d, &_sysname); \
log_object_internal(_level, _e, PROJECT_FILE, __LINE__, __func__, \
_sysname ? "DEVICE=" : NULL, _sysname, \
NULL, NULL, __VA_ARGS__); \
})
#define log_device_full_errno(device, level, error, ...) \
({ \
int _error = (error); \
ASSERT_NON_ZERO(_error); \
log_device_full_errno_zerook(device, level, _error, __VA_ARGS__); \
})
#define log_device_full(device, level, ...) (void) log_device_full_errno_zerook(device, level, 0, __VA_ARGS__)
#define log_device_debug(device, ...) log_device_full(device, LOG_DEBUG, __VA_ARGS__)
#define log_device_info(device, ...) log_device_full(device, LOG_INFO, __VA_ARGS__)
#define log_device_notice(device, ...) log_device_full(device, LOG_NOTICE, __VA_ARGS__)
#define log_device_warning(device, ...) log_device_full(device, LOG_WARNING, __VA_ARGS__)
#define log_device_error(device, ...) log_device_full(device, LOG_ERR, __VA_ARGS__)
#define log_device_debug_errno(device, error, ...) log_device_full_errno(device, LOG_DEBUG, error, __VA_ARGS__)
#define log_device_info_errno(device, error, ...) log_device_full_errno(device, LOG_INFO, error, __VA_ARGS__)
#define log_device_notice_errno(device, error, ...) log_device_full_errno(device, LOG_NOTICE, error, __VA_ARGS__)
#define log_device_warning_errno(device, error, ...) log_device_full_errno(device, LOG_WARNING, error, __VA_ARGS__)
#define log_device_error_errno(device, error, ...) log_device_full_errno(device, LOG_ERR, error, __VA_ARGS__)
int devname_from_devnum(mode_t mode, dev_t devnum, char **ret);
static inline int devname_from_stat_rdev(const struct stat *st, char **ret) {
assert(st);
return devname_from_devnum(st->st_mode, st->st_rdev, ret);
}
int device_open_from_devnum(mode_t mode, dev_t devnum, int flags, char **ret);
char** device_make_log_fields(sd_device *device);
| 5,513 | 52.019231 | 115 |
h
|
null |
systemd-main/src/libsystemd/sd-device/test-device-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "device-util.h"
#include "tests.h"
TEST(log_device_full) {
int r;
for (int level = LOG_ERR; level <= LOG_DEBUG; level++) {
log_device_full(NULL, level, "test level=%d: %m", level);
r = log_device_full_errno(NULL, level, EUCLEAN, "test level=%d errno=EUCLEAN: %m", level);
assert_se(r == -EUCLEAN);
r = log_device_full_errno(NULL, level, 0, "test level=%d errno=0: %m", level);
assert_se(r == 0);
r = log_device_full_errno(NULL, level, SYNTHETIC_ERRNO(ENODATA), "test level=%d errno=S(ENODATA): %m", level);
assert_se(r == -ENODATA);
}
}
DEFINE_TEST_MAIN(LOG_INFO);
| 766 | 30.958333 | 126 |
c
|
null |
systemd-main/src/libsystemd/sd-device/test-sd-device-monitor.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <stdbool.h>
#include <unistd.h>
#include "sd-device.h"
#include "sd-event.h"
#include "device-monitor-private.h"
#include "device-private.h"
#include "device-util.h"
#include "macro.h"
#include "path-util.h"
#include "stat-util.h"
#include "string-util.h"
#include "tests.h"
#include "virt.h"
static int monitor_handler(sd_device_monitor *m, sd_device *d, void *userdata) {
const char *s, *syspath = userdata;
assert_se(sd_device_get_syspath(d, &s) >= 0);
assert_se(streq(s, syspath));
return sd_event_exit(sd_device_monitor_get_event(m), 100);
}
static void test_receive_device_fail(void) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
_cleanup_(sd_device_unrefp) sd_device *loopback = NULL;
const char *syspath;
log_info("/* %s */", __func__);
/* Try to send device with invalid action and without seqnum. */
assert_se(sd_device_new_from_syspath(&loopback, "/sys/class/net/lo") >= 0);
assert_se(device_add_property(loopback, "ACTION", "hoge") >= 0);
assert_se(sd_device_get_syspath(loopback, &syspath) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
assert_se(device_monitor_send_device(monitor_server, monitor_client, loopback) >= 0);
assert_se(sd_event_run(sd_device_monitor_get_event(monitor_client), 0) >= 0);
}
static void test_send_receive_one(sd_device *device, bool subsystem_filter, bool tag_filter, bool use_bpf) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
const char *syspath, *subsystem, *devtype = NULL;
log_device_info(device, "/* %s(subsystem_filter=%s, tag_filter=%s, use_bpf=%s) */", __func__,
true_false(subsystem_filter), true_false(tag_filter), true_false(use_bpf));
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
if (subsystem_filter) {
assert_se(sd_device_get_subsystem(device, &subsystem) >= 0);
(void) sd_device_get_devtype(device, &devtype);
assert_se(sd_device_monitor_filter_add_match_subsystem_devtype(monitor_client, subsystem, devtype) >= 0);
}
if (tag_filter)
FOREACH_DEVICE_TAG(device, tag)
assert_se(sd_device_monitor_filter_add_match_tag(monitor_client, tag) >= 0);
if ((subsystem_filter || tag_filter) && use_bpf)
assert_se(sd_device_monitor_filter_update(monitor_client) >= 0);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_loop(sd_device_monitor_get_event(monitor_client)) == 100);
}
static void test_subsystem_filter(sd_device *device) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
const char *syspath, *subsystem;
log_device_info(device, "/* %s */", __func__);
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
assert_se(sd_device_get_subsystem(device, &subsystem) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_filter_add_match_subsystem_devtype(monitor_client, subsystem, NULL) >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
assert_se(sd_device_enumerator_new(&e) >= 0);
assert_se(sd_device_enumerator_add_match_subsystem(e, subsystem, false) >= 0);
FOREACH_DEVICE(e, d) {
const char *p, *s;
assert_se(sd_device_get_syspath(d, &p) >= 0);
assert_se(sd_device_get_subsystem(d, &s) >= 0);
assert_se(device_add_property(d, "ACTION", "add") >= 0);
assert_se(device_add_property(d, "SEQNUM", "10") >= 0);
log_device_debug(d, "Sending device subsystem:%s syspath:%s", s, p);
assert_se(device_monitor_send_device(monitor_server, monitor_client, d) >= 0);
}
log_device_info(device, "Sending device subsystem:%s syspath:%s", subsystem, syspath);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_loop(sd_device_monitor_get_event(monitor_client)) == 100);
}
static void test_tag_filter(sd_device *device) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
const char *syspath;
log_device_info(device, "/* %s */", __func__);
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_filter_add_match_tag(monitor_client, "TEST_SD_DEVICE_MONITOR") >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
assert_se(sd_device_enumerator_new(&e) >= 0);
FOREACH_DEVICE(e, d) {
const char *p;
assert_se(sd_device_get_syspath(d, &p) >= 0);
assert_se(device_add_property(d, "ACTION", "add") >= 0);
assert_se(device_add_property(d, "SEQNUM", "10") >= 0);
log_device_debug(d, "Sending device syspath:%s", p);
assert_se(device_monitor_send_device(monitor_server, monitor_client, d) >= 0);
}
log_device_info(device, "Sending device syspath:%s", syspath);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_loop(sd_device_monitor_get_event(monitor_client)) == 100);
}
static void test_sysattr_filter(sd_device *device, const char *sysattr) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
const char *syspath, *sysattr_value;
log_device_info(device, "/* %s(%s) */", __func__, sysattr);
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
assert_se(sd_device_get_sysattr_value(device, sysattr, &sysattr_value) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_filter_add_match_sysattr(monitor_client, sysattr, sysattr_value, true) >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
assert_se(sd_device_enumerator_new(&e) >= 0);
assert_se(sd_device_enumerator_add_match_sysattr(e, sysattr, sysattr_value, false) >= 0);
FOREACH_DEVICE(e, d) {
const char *p;
assert_se(sd_device_get_syspath(d, &p) >= 0);
assert_se(device_add_property(d, "ACTION", "add") >= 0);
assert_se(device_add_property(d, "SEQNUM", "10") >= 0);
log_device_debug(d, "Sending device syspath:%s", p);
assert_se(device_monitor_send_device(monitor_server, monitor_client, d) >= 0);
/* The sysattr filter is not implemented in BPF yet. So, sending multiple devices may fills up
* buffer and device_monitor_send_device() may return EAGAIN. Let's send one device here,
* which should be filtered out by the receiver. */
break;
}
log_device_info(device, "Sending device syspath:%s", syspath);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_loop(sd_device_monitor_get_event(monitor_client)) == 100);
}
static void test_parent_filter(sd_device *device) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
const char *syspath, *parent_syspath;
sd_device *parent;
int r;
log_device_info(device, "/* %s */", __func__);
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
r = sd_device_get_parent(device, &parent);
if (r < 0)
return (void) log_device_info(device, "Device does not have parent, skipping.");
assert_se(sd_device_get_syspath(parent, &parent_syspath) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_filter_add_match_parent(monitor_client, parent, true) >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
assert_se(sd_device_enumerator_new(&e) >= 0);
FOREACH_DEVICE(e, d) {
const char *p;
assert_se(sd_device_get_syspath(d, &p) >= 0);
if (path_startswith(p, parent_syspath))
continue;
assert_se(device_add_property(d, "ACTION", "add") >= 0);
assert_se(device_add_property(d, "SEQNUM", "10") >= 0);
log_device_debug(d, "Sending device syspath:%s", p);
assert_se(device_monitor_send_device(monitor_server, monitor_client, d) >= 0);
/* The parent filter is not implemented in BPF yet. So, sending multiple devices may fills up
* buffer and device_monitor_send_device() may return EAGAIN. Let's send one device here,
* which should be filtered out by the receiver. */
break;
}
log_device_info(device, "Sending device syspath:%s", syspath);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_loop(sd_device_monitor_get_event(monitor_client)) == 100);
}
static void test_sd_device_monitor_filter_remove(sd_device *device) {
_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor_server = NULL, *monitor_client = NULL;
const char *syspath;
log_device_info(device, "/* %s */", __func__);
assert_se(sd_device_get_syspath(device, &syspath) >= 0);
assert_se(device_monitor_new_full(&monitor_server, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_server, "sender") >= 0);
assert_se(sd_device_monitor_start(monitor_server, NULL, NULL) >= 0);
assert_se(device_monitor_new_full(&monitor_client, MONITOR_GROUP_NONE, -1) >= 0);
assert_se(sd_device_monitor_set_description(monitor_client, "receiver") >= 0);
assert_se(device_monitor_allow_unicast_sender(monitor_client, monitor_server) >= 0);
assert_se(sd_device_monitor_start(monitor_client, monitor_handler, (void *) syspath) >= 0);
assert_se(sd_device_monitor_filter_add_match_subsystem_devtype(monitor_client, "hoge", NULL) >= 0);
assert_se(sd_device_monitor_filter_update(monitor_client) >= 0);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_run(sd_device_monitor_get_event(monitor_client), 0) >= 0);
assert_se(sd_device_monitor_filter_remove(monitor_client) >= 0);
assert_se(device_monitor_send_device(monitor_server, monitor_client, device) >= 0);
assert_se(sd_event_loop(sd_device_monitor_get_event(monitor_client)) == 100);
}
int main(int argc, char *argv[]) {
_cleanup_(sd_device_unrefp) sd_device *loopback = NULL, *sda = NULL;
int r;
test_setup_logging(LOG_INFO);
if (getuid() != 0)
return log_tests_skipped("not root");
if (path_is_read_only_fs("/sys") > 0)
return log_tests_skipped("Running in container");
test_receive_device_fail();
assert_se(sd_device_new_from_syspath(&loopback, "/sys/class/net/lo") >= 0);
assert_se(device_add_property(loopback, "ACTION", "add") >= 0);
assert_se(device_add_property(loopback, "SEQNUM", "10") >= 0);
assert_se(device_add_tag(loopback, "TEST_SD_DEVICE_MONITOR", true) >= 0);
test_send_receive_one(loopback, false, false, false);
test_send_receive_one(loopback, true, false, false);
test_send_receive_one(loopback, false, true, false);
test_send_receive_one(loopback, true, true, false);
test_send_receive_one(loopback, true, false, true);
test_send_receive_one(loopback, false, true, true);
test_send_receive_one(loopback, true, true, true);
test_subsystem_filter(loopback);
test_tag_filter(loopback);
test_sysattr_filter(loopback, "ifindex");
test_sd_device_monitor_filter_remove(loopback);
r = sd_device_new_from_subsystem_sysname(&sda, "block", "sda");
if (r < 0) {
log_info_errno(r, "Failed to create sd_device for sda, skipping remaining tests: %m");
return 0;
}
assert_se(device_add_property(sda, "ACTION", "change") >= 0);
assert_se(device_add_property(sda, "SEQNUM", "11") >= 0);
test_send_receive_one(sda, false, false, false);
test_send_receive_one(sda, true, false, false);
test_send_receive_one(sda, false, true, false);
test_send_receive_one(sda, true, true, false);
test_send_receive_one(sda, true, false, true);
test_send_receive_one(sda, false, true, true);
test_send_receive_one(sda, true, true, true);
test_parent_filter(sda);
return 0;
}
| 16,761 | 47.585507 | 121 |
c
|
null |
systemd-main/src/libsystemd/sd-device/test-sd-device-thread.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include "sd-device.h"
#include "device-util.h"
#define handle_error_errno(error, msg) \
({ \
errno = abs(error); \
perror(msg); \
EXIT_FAILURE; \
})
static void* thread(void *p) {
sd_device **d = p;
*d = sd_device_unref(*d);
return NULL;
}
int main(int argc, char *argv[]) {
sd_device *loopback;
pthread_t t;
int r;
r = sd_device_new_from_syspath(&loopback, "/sys/class/net/lo");
if (r < 0)
return handle_error_errno(r, "Failed to create loopback device object");
FOREACH_DEVICE_PROPERTY(loopback, key, value)
printf("%s=%s\n", key, value);
r = pthread_create(&t, NULL, thread, &loopback);
if (r != 0)
return handle_error_errno(r, "Failed to create thread");
r = pthread_join(t, NULL);
if (r != 0)
return handle_error_errno(r, "Failed to wait thread finished");
if (loopback)
return handle_error_errno(r, "loopback device is not unref()ed");
return 0;
}
| 1,436 | 26.634615 | 88 |
c
|
null |
systemd-main/src/libsystemd/sd-event/event-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "sd-event.h"
int event_reset_time(
sd_event *e,
sd_event_source **s,
clockid_t clock,
uint64_t usec,
uint64_t accuracy,
sd_event_time_handler_t callback,
void *userdata,
int64_t priority,
const char *description,
bool force_reset);
int event_reset_time_relative(
sd_event *e,
sd_event_source **s,
clockid_t clock,
uint64_t usec,
uint64_t accuracy,
sd_event_time_handler_t callback,
void *userdata,
int64_t priority,
const char *description,
bool force_reset);
static inline int event_source_disable(sd_event_source *s) {
return sd_event_source_set_enabled(s, SD_EVENT_OFF);
}
int event_add_time_change(sd_event *e, sd_event_source **ret, sd_event_io_handler_t callback, void *userdata);
| 1,111 | 30.771429 | 110 |
h
|
null |
systemd-main/src/libsystemd/sd-hwdb/hwdb-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdint.h>
#include <sys/stat.h>
#include "constants.h"
#include "hashmap.h"
#include "sparse-endian.h"
#define HWDB_SIG { 'K', 'S', 'L', 'P', 'H', 'H', 'R', 'H' }
struct sd_hwdb {
unsigned n_ref;
FILE *f;
struct stat st;
union {
struct trie_header_f *head;
const char *map;
};
OrderedHashmap *properties;
Iterator properties_iterator;
bool properties_modified;
};
/* on-disk trie objects */
struct trie_header_f {
uint8_t signature[8];
/* version of tool which created the file */
le64_t tool_version;
le64_t file_size;
/* size of structures to allow them to grow */
le64_t header_size;
le64_t node_size;
le64_t child_entry_size;
le64_t value_entry_size;
/* offset of the root trie node */
le64_t nodes_root_off;
/* size of the nodes and string section */
le64_t nodes_len;
le64_t strings_len;
} _packed_;
struct trie_node_f {
/* prefix of lookup string, shared by all children */
le64_t prefix_off;
/* size of children entry array appended to the node */
uint8_t children_count;
uint8_t padding[7];
/* size of value entry array appended to the node */
le64_t values_count;
} _packed_;
/* array of child entries, follows directly the node record */
struct trie_child_entry_f {
/* index of the child node */
uint8_t c;
uint8_t padding[7];
/* offset of the child node */
le64_t child_off;
} _packed_;
/* array of value entries, follows directly the node record/child array */
struct trie_value_entry_f {
le64_t key_off;
le64_t value_off;
} _packed_;
/* v2 extends v1 with filename and line-number */
struct trie_value_entry2_f {
le64_t key_off;
le64_t value_off;
le64_t filename_off;
le32_t line_number;
le16_t file_priority;
le16_t padding;
} _packed_;
#define hwdb_bin_paths \
"/etc/systemd/hwdb/hwdb.bin\0" \
"/etc/udev/hwdb.bin\0" \
"/usr/lib/systemd/hwdb/hwdb.bin\0" \
_CONF_PATHS_SPLIT_USR_NULSTR("systemd/hwdb/hwdb.bin") \
UDEVLIBEXECDIR "/hwdb.bin\0"
| 2,410 | 25.494505 | 74 |
h
|
null |
systemd-main/src/libsystemd/sd-hwdb/sd-hwdb.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2008 Alan Jenkins <[email protected]>
***/
#include <errno.h>
#include <fnmatch.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include "sd-hwdb.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "hashmap.h"
#include "hwdb-internal.h"
#include "nulstr-util.h"
#include "string-util.h"
#include "time-util.h"
struct linebuf {
char bytes[LINE_MAX];
size_t size;
size_t len;
};
static void linebuf_init(struct linebuf *buf) {
buf->size = 0;
buf->len = 0;
}
static const char *linebuf_get(struct linebuf *buf) {
if (buf->len + 1 >= sizeof(buf->bytes))
return NULL;
buf->bytes[buf->len] = '\0';
return buf->bytes;
}
static bool linebuf_add(struct linebuf *buf, const char *s, size_t len) {
if (buf->len + len >= sizeof(buf->bytes))
return false;
memcpy(buf->bytes + buf->len, s, len);
buf->len += len;
return true;
}
static bool linebuf_add_char(struct linebuf *buf, char c) {
if (buf->len + 1 >= sizeof(buf->bytes))
return false;
buf->bytes[buf->len++] = c;
return true;
}
static void linebuf_rem(struct linebuf *buf, size_t count) {
assert(buf->len >= count);
buf->len -= count;
}
static void linebuf_rem_char(struct linebuf *buf) {
linebuf_rem(buf, 1);
}
static const struct trie_child_entry_f *trie_node_child(sd_hwdb *hwdb, const struct trie_node_f *node, size_t idx) {
const char *base = (const char *)node;
base += le64toh(hwdb->head->node_size);
base += idx * le64toh(hwdb->head->child_entry_size);
return (const struct trie_child_entry_f *)base;
}
static const struct trie_value_entry_f *trie_node_value(sd_hwdb *hwdb, const struct trie_node_f *node, size_t idx) {
const char *base = (const char *)node;
base += le64toh(hwdb->head->node_size);
base += node->children_count * le64toh(hwdb->head->child_entry_size);
base += idx * le64toh(hwdb->head->value_entry_size);
return (const struct trie_value_entry_f *)base;
}
static const struct trie_node_f *trie_node_from_off(sd_hwdb *hwdb, le64_t off) {
return (const struct trie_node_f *)(hwdb->map + le64toh(off));
}
static const char *trie_string(sd_hwdb *hwdb, le64_t off) {
return hwdb->map + le64toh(off);
}
static int trie_children_cmp_f(const void *v1, const void *v2) {
const struct trie_child_entry_f *n1 = v1;
const struct trie_child_entry_f *n2 = v2;
return n1->c - n2->c;
}
static const struct trie_node_f *node_lookup_f(sd_hwdb *hwdb, const struct trie_node_f *node, uint8_t c) {
struct trie_child_entry_f *child;
struct trie_child_entry_f search;
search.c = c;
child = bsearch(&search, (const char *)node + le64toh(hwdb->head->node_size), node->children_count,
le64toh(hwdb->head->child_entry_size), trie_children_cmp_f);
if (child)
return trie_node_from_off(hwdb, child->child_off);
return NULL;
}
static int hwdb_add_property(sd_hwdb *hwdb, const struct trie_value_entry_f *entry) {
const char *key;
int r;
assert(hwdb);
key = trie_string(hwdb, entry->key_off);
/*
* Silently ignore all properties which do not start with a
* space; future extensions might use additional prefixes.
*/
if (key[0] != ' ')
return 0;
key++;
if (le64toh(hwdb->head->value_entry_size) >= sizeof(struct trie_value_entry2_f)) {
const struct trie_value_entry2_f *old, *entry2;
entry2 = (const struct trie_value_entry2_f *)entry;
old = ordered_hashmap_get(hwdb->properties, key);
if (old) {
/* On duplicates, we order by filename priority and line-number.
*
* v2 of the format had 64 bits for the line number.
* v3 reuses top 32 bits of line_number to store the priority.
* We check the top bits — if they are zero we have v2 format.
* This means that v2 clients will print wrong line numbers with
* v3 data.
*
* For v3 data: we compare the priority (of the source file)
* and the line number.
*
* For v2 data: we rely on the fact that the filenames in the hwdb
* are added in the order of priority (higher later), because they
* are *processed* in the order of priority. So we compare the
* indices to determine which file had higher priority. Comparing
* the strings alphabetically would be useless, because those are
* full paths, and e.g. /usr/lib would sort after /etc, even
* though it has lower priority. This is not reliable because of
* suffix compression, but should work for the most common case of
* /usr/lib/udev/hwbd.d and /etc/udev/hwdb.d, and is better than
* not doing the comparison at all.
*/
bool lower;
if (entry2->file_priority == 0)
lower = entry2->filename_off < old->filename_off ||
(entry2->filename_off == old->filename_off && entry2->line_number < old->line_number);
else
lower = entry2->file_priority < old->file_priority ||
(entry2->file_priority == old->file_priority && entry2->line_number < old->line_number);
if (lower)
return 0;
}
}
r = ordered_hashmap_ensure_allocated(&hwdb->properties, &string_hash_ops);
if (r < 0)
return r;
r = ordered_hashmap_replace(hwdb->properties, key, (void *)entry);
if (r < 0)
return r;
hwdb->properties_modified = true;
return 0;
}
static int trie_fnmatch_f(sd_hwdb *hwdb, const struct trie_node_f *node, size_t p,
struct linebuf *buf, const char *search) {
size_t len;
size_t i;
const char *prefix;
int err;
prefix = trie_string(hwdb, node->prefix_off);
len = strlen(prefix + p);
linebuf_add(buf, prefix + p, len);
for (i = 0; i < node->children_count; i++) {
const struct trie_child_entry_f *child = trie_node_child(hwdb, node, i);
linebuf_add_char(buf, child->c);
err = trie_fnmatch_f(hwdb, trie_node_from_off(hwdb, child->child_off), 0, buf, search);
if (err < 0)
return err;
linebuf_rem_char(buf);
}
if (le64toh(node->values_count) && fnmatch(linebuf_get(buf), search, 0) == 0)
for (i = 0; i < le64toh(node->values_count); i++) {
err = hwdb_add_property(hwdb, trie_node_value(hwdb, node, i));
if (err < 0)
return err;
}
linebuf_rem(buf, len);
return 0;
}
static int trie_search_f(sd_hwdb *hwdb, const char *search) {
struct linebuf buf;
const struct trie_node_f *node;
size_t i = 0;
int err;
linebuf_init(&buf);
node = trie_node_from_off(hwdb, hwdb->head->nodes_root_off);
while (node) {
const struct trie_node_f *child;
size_t p = 0;
if (node->prefix_off) {
char c;
for (; (c = trie_string(hwdb, node->prefix_off)[p]); p++) {
if (IN_SET(c, '*', '?', '['))
return trie_fnmatch_f(hwdb, node, p, &buf, search + i + p);
if (c != search[i + p])
return 0;
}
i += p;
}
child = node_lookup_f(hwdb, node, '*');
if (child) {
linebuf_add_char(&buf, '*');
err = trie_fnmatch_f(hwdb, child, 0, &buf, search + i);
if (err < 0)
return err;
linebuf_rem_char(&buf);
}
child = node_lookup_f(hwdb, node, '?');
if (child) {
linebuf_add_char(&buf, '?');
err = trie_fnmatch_f(hwdb, child, 0, &buf, search + i);
if (err < 0)
return err;
linebuf_rem_char(&buf);
}
child = node_lookup_f(hwdb, node, '[');
if (child) {
linebuf_add_char(&buf, '[');
err = trie_fnmatch_f(hwdb, child, 0, &buf, search + i);
if (err < 0)
return err;
linebuf_rem_char(&buf);
}
if (search[i] == '\0') {
size_t n;
for (n = 0; n < le64toh(node->values_count); n++) {
err = hwdb_add_property(hwdb, trie_node_value(hwdb, node, n));
if (err < 0)
return err;
}
return 0;
}
child = node_lookup_f(hwdb, node, search[i]);
node = child;
i++;
}
return 0;
}
static int hwdb_new(const char *path, sd_hwdb **ret) {
_cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb = NULL;
const char sig[] = HWDB_SIG;
assert_return(ret, -EINVAL);
hwdb = new0(sd_hwdb, 1);
if (!hwdb)
return -ENOMEM;
hwdb->n_ref = 1;
/* Find hwdb.bin in the explicit path if provided, or iterate over hwdb_bin_paths otherwise */
if (!isempty(path)) {
log_debug("Trying to open \"%s\"...", path);
hwdb->f = fopen(path, "re");
if (!hwdb->f)
return log_debug_errno(errno, "Failed to open %s: %m", path);
} else {
NULSTR_FOREACH(p, hwdb_bin_paths) {
log_debug("Trying to open \"%s\"...", p);
hwdb->f = fopen(p, "re");
if (hwdb->f) {
path = p;
break;
}
if (errno != ENOENT)
return log_debug_errno(errno, "Failed to open %s: %m", p);
}
if (!hwdb->f)
return log_debug_errno(SYNTHETIC_ERRNO(ENOENT),
"hwdb.bin does not exist, please run 'systemd-hwdb update'");
}
if (fstat(fileno(hwdb->f), &hwdb->st) < 0)
return log_debug_errno(errno, "Failed to stat %s: %m", path);
if (hwdb->st.st_size < (off_t) offsetof(struct trie_header_f, strings_len) + 8)
return log_debug_errno(SYNTHETIC_ERRNO(EIO), "File %s is too short: %m", path);
if (file_offset_beyond_memory_size(hwdb->st.st_size))
return log_debug_errno(SYNTHETIC_ERRNO(EFBIG), "File %s is too long: %m", path);
hwdb->map = mmap(0, hwdb->st.st_size, PROT_READ, MAP_SHARED, fileno(hwdb->f), 0);
if (hwdb->map == MAP_FAILED)
return log_debug_errno(errno, "Failed to map %s: %m", path);
if (memcmp(hwdb->map, sig, sizeof(hwdb->head->signature)) != 0 ||
(size_t) hwdb->st.st_size != le64toh(hwdb->head->file_size))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
"Failed to recognize the format of %s", path);
log_debug("=== trie on-disk ===");
log_debug("tool version: %"PRIu64, le64toh(hwdb->head->tool_version));
log_debug("file size: %8"PRIi64" bytes", hwdb->st.st_size);
log_debug("header size %8"PRIu64" bytes", le64toh(hwdb->head->header_size));
log_debug("strings %8"PRIu64" bytes", le64toh(hwdb->head->strings_len));
log_debug("nodes %8"PRIu64" bytes", le64toh(hwdb->head->nodes_len));
*ret = TAKE_PTR(hwdb);
return 0;
}
_public_ int sd_hwdb_new_from_path(const char *path, sd_hwdb **ret) {
assert_return(!isempty(path), -EINVAL);
return hwdb_new(path, ret);
}
_public_ int sd_hwdb_new(sd_hwdb **ret) {
return hwdb_new(NULL, ret);
}
static sd_hwdb *hwdb_free(sd_hwdb *hwdb) {
assert(hwdb);
if (hwdb->map)
munmap((void *)hwdb->map, hwdb->st.st_size);
safe_fclose(hwdb->f);
ordered_hashmap_free(hwdb->properties);
return mfree(hwdb);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_hwdb, sd_hwdb, hwdb_free)
static int properties_prepare(sd_hwdb *hwdb, const char *modalias) {
assert(hwdb);
assert(modalias);
ordered_hashmap_clear(hwdb->properties);
hwdb->properties_modified = true;
return trie_search_f(hwdb, modalias);
}
_public_ int sd_hwdb_get(sd_hwdb *hwdb, const char *modalias, const char *key, const char **_value) {
const struct trie_value_entry_f *entry;
int r;
assert_return(hwdb, -EINVAL);
assert_return(hwdb->f, -EINVAL);
assert_return(modalias, -EINVAL);
assert_return(_value, -EINVAL);
r = properties_prepare(hwdb, modalias);
if (r < 0)
return r;
entry = ordered_hashmap_get(hwdb->properties, key);
if (!entry)
return -ENOENT;
*_value = trie_string(hwdb, entry->value_off);
return 0;
}
_public_ int sd_hwdb_seek(sd_hwdb *hwdb, const char *modalias) {
int r;
assert_return(hwdb, -EINVAL);
assert_return(hwdb->f, -EINVAL);
assert_return(modalias, -EINVAL);
r = properties_prepare(hwdb, modalias);
if (r < 0)
return r;
hwdb->properties_modified = false;
hwdb->properties_iterator = ITERATOR_FIRST;
return 0;
}
_public_ int sd_hwdb_enumerate(sd_hwdb *hwdb, const char **key, const char **value) {
const struct trie_value_entry_f *entry;
const void *k;
assert_return(hwdb, -EINVAL);
assert_return(key, -EINVAL);
assert_return(value, -EINVAL);
if (hwdb->properties_modified)
return -EAGAIN;
if (!ordered_hashmap_iterate(hwdb->properties, &hwdb->properties_iterator, (void **)&entry, &k))
return 0;
*key = k;
*value = trie_string(hwdb, entry->value_off);
return 1;
}
| 15,534 | 34.549199 | 128 |
c
|
null |
systemd-main/src/libsystemd/sd-id128/id128-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include "fd-util.h"
#include "fs-util.h"
#include "hexdecoct.h"
#include "id128-util.h"
#include "io-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "sync-util.h"
bool id128_is_valid(const char *s) {
size_t l;
assert(s);
l = strlen(s);
if (l == SD_ID128_STRING_MAX - 1)
/* Plain formatted 128-bit hex string */
return in_charset(s, HEXDIGITS);
if (l == SD_ID128_UUID_STRING_MAX - 1) {
/* Formatted UUID */
for (size_t i = 0; i < l; i++) {
char c = s[i];
if (IN_SET(i, 8, 13, 18, 23)) {
if (c != '-')
return false;
} else if (!ascii_ishex(c))
return false;
}
return true;
}
return false;
}
int id128_read_fd(int fd, Id128Flag f, sd_id128_t *ret) {
char buffer[SD_ID128_UUID_STRING_MAX + 1]; /* +1 is for trailing newline */
sd_id128_t id;
ssize_t l;
int r;
assert(fd >= 0);
/* Reads an 128-bit ID from a file, which may either be in plain format (32 hex digits), or in UUID format, both
* optionally followed by a newline and nothing else. ID files should really be newline terminated, but if they
* aren't that's OK too, following the rule of "Be conservative in what you send, be liberal in what you
* accept".
*
* This returns the following:
* -ENOMEDIUM: an empty string,
* -ENOPKG: "uninitialized" or "uninitialized\n",
* -EUCLEAN: other invalid strings. */
l = loop_read(fd, buffer, sizeof(buffer), false); /* we expect a short read of either 32/33 or 36/37 chars */
if (l < 0)
return (int) l;
if (l == 0) /* empty? */
return -ENOMEDIUM;
switch (l) {
case STRLEN("uninitialized"):
case STRLEN("uninitialized\n"):
return strneq(buffer, "uninitialized\n", l) ? -ENOPKG : -EINVAL;
case SD_ID128_STRING_MAX: /* plain UUID with trailing newline */
if (buffer[SD_ID128_STRING_MAX-1] != '\n')
return -EUCLEAN;
_fallthrough_;
case SD_ID128_STRING_MAX-1: /* plain UUID without trailing newline */
if (!FLAGS_SET(f, ID128_FORMAT_PLAIN))
return -EUCLEAN;
buffer[SD_ID128_STRING_MAX-1] = 0;
break;
case SD_ID128_UUID_STRING_MAX: /* RFC UUID with trailing newline */
if (buffer[SD_ID128_UUID_STRING_MAX-1] != '\n')
return -EUCLEAN;
_fallthrough_;
case SD_ID128_UUID_STRING_MAX-1: /* RFC UUID without trailing newline */
if (!FLAGS_SET(f, ID128_FORMAT_UUID))
return -EUCLEAN;
buffer[SD_ID128_UUID_STRING_MAX-1] = 0;
break;
default:
return -EUCLEAN;
}
r = sd_id128_from_string(buffer, &id);
if (r == -EINVAL)
return -EUCLEAN;
if (r < 0)
return r;
if (FLAGS_SET(f, ID128_REFUSE_NULL) && sd_id128_is_null(id))
return -ENOMEDIUM;
if (ret)
*ret = id;
return 0;
}
int id128_read_at(int dir_fd, const char *path, Id128Flag f, sd_id128_t *ret) {
_cleanup_close_ int fd = -EBADF;
assert(dir_fd >= 0 || dir_fd == AT_FDCWD);
assert(path);
fd = xopenat(dir_fd, path, O_RDONLY|O_CLOEXEC|O_NOCTTY, /* xopen_flags = */ 0, /* mode = */ 0);
if (fd < 0)
return fd;
return id128_read_fd(fd, f, ret);
}
int id128_write_fd(int fd, Id128Flag f, sd_id128_t id) {
char buffer[SD_ID128_UUID_STRING_MAX + 1]; /* +1 is for trailing newline */
size_t sz;
int r;
assert(fd >= 0);
assert(IN_SET((f & ID128_FORMAT_ANY), ID128_FORMAT_PLAIN, ID128_FORMAT_UUID));
if (FLAGS_SET(f, ID128_REFUSE_NULL) && sd_id128_is_null(id))
return -ENOMEDIUM;
if (FLAGS_SET(f, ID128_FORMAT_PLAIN)) {
assert_se(sd_id128_to_string(id, buffer));
sz = SD_ID128_STRING_MAX;
} else {
assert_se(sd_id128_to_uuid_string(id, buffer));
sz = SD_ID128_UUID_STRING_MAX;
}
buffer[sz - 1] = '\n';
r = loop_write(fd, buffer, sz, false);
if (r < 0)
return r;
if (FLAGS_SET(f, ID128_SYNC_ON_WRITE)) {
r = fsync_full(fd);
if (r < 0)
return r;
}
return 0;
}
int id128_write_at(int dir_fd, const char *path, Id128Flag f, sd_id128_t id) {
_cleanup_close_ int fd = -EBADF;
assert(dir_fd >= 0 || dir_fd == AT_FDCWD);
assert(path);
fd = xopenat(dir_fd, path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_TRUNC, /* xopen_flags = */ 0, 0444);
if (fd < 0)
return fd;
return id128_write_fd(fd, f, id);
}
void id128_hash_func(const sd_id128_t *p, struct siphash *state) {
siphash24_compress(p, sizeof(sd_id128_t), state);
}
int id128_compare_func(const sd_id128_t *a, const sd_id128_t *b) {
return memcmp(a, b, 16);
}
sd_id128_t id128_make_v4_uuid(sd_id128_t id) {
/* Stolen from generate_random_uuid() of drivers/char/random.c
* in the kernel sources */
/* Set UUID version to 4 --- truly random generation */
id.bytes[6] = (id.bytes[6] & 0x0F) | 0x40;
/* Set the UUID variant to DCE */
id.bytes[8] = (id.bytes[8] & 0x3F) | 0x80;
return id;
}
DEFINE_HASH_OPS(id128_hash_ops, sd_id128_t, id128_hash_func, id128_compare_func);
DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(id128_hash_ops_free, sd_id128_t, id128_hash_func, id128_compare_func, free);
int id128_get_product(sd_id128_t *ret) {
sd_id128_t uuid;
int r;
assert(ret);
/* Reads the systems product UUID from DMI or devicetree (where it is located on POWER). This is
* particularly relevant in VM environments, where VM managers typically place a VM uuid there. */
r = id128_read("/sys/class/dmi/id/product_uuid", ID128_FORMAT_UUID, &uuid);
if (r == -ENOENT)
r = id128_read("/proc/device-tree/vm,uuid", ID128_FORMAT_UUID, &uuid);
if (r < 0)
return r;
if (sd_id128_is_null(uuid) || sd_id128_is_allf(uuid))
return -EADDRNOTAVAIL; /* Recognizable error */
*ret = uuid;
return 0;
}
| 6,911 | 30.418182 | 120 |
c
|
null |
systemd-main/src/libsystemd/sd-id128/id128-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <fcntl.h>
#include <stdbool.h>
#include "sd-id128.h"
#include "hash-funcs.h"
#include "macro.h"
bool id128_is_valid(const char *s) _pure_;
typedef enum Id128Flag {
ID128_FORMAT_PLAIN = 1 << 0, /* formatted as 32 hex chars as-is */
ID128_FORMAT_UUID = 1 << 1, /* formatted as 36 character uuid string */
ID128_FORMAT_ANY = ID128_FORMAT_PLAIN | ID128_FORMAT_UUID,
ID128_SYNC_ON_WRITE = 1 << 2, /* Sync the file after write. Used only when writing an ID. */
ID128_REFUSE_NULL = 1 << 3, /* Refuse all zero ID with -ENOMEDIUM. */
} Id128Flag;
int id128_read_fd(int fd, Id128Flag f, sd_id128_t *ret);
int id128_read_at(int dir_fd, const char *path, Id128Flag f, sd_id128_t *ret);
static inline int id128_read(const char *path, Id128Flag f, sd_id128_t *ret) {
return id128_read_at(AT_FDCWD, path, f, ret);
}
int id128_write_fd(int fd, Id128Flag f, sd_id128_t id);
int id128_write_at(int dir_fd, const char *path, Id128Flag f, sd_id128_t id);
static inline int id128_write(const char *path, Id128Flag f, sd_id128_t id) {
return id128_write_at(AT_FDCWD, path, f, id);
}
int id128_get_machine(const char *root, sd_id128_t *ret);
int id128_get_machine_at(int rfd, sd_id128_t *ret);
void id128_hash_func(const sd_id128_t *p, struct siphash *state);
int id128_compare_func(const sd_id128_t *a, const sd_id128_t *b) _pure_;
extern const struct hash_ops id128_hash_ops;
extern const struct hash_ops id128_hash_ops_free;
sd_id128_t id128_make_v4_uuid(sd_id128_t id);
int id128_get_product(sd_id128_t *ret);
/* A helper to check for the three relevant cases of "machine ID not initialized" */
#define ERRNO_IS_MACHINE_ID_UNSET(r) \
IN_SET(abs(r), \
ENOENT, \
ENOMEDIUM, \
ENOPKG)
| 1,949 | 35.792453 | 100 |
h
|
null |
systemd-main/src/libsystemd/sd-id128/sd-id128.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "chase.h"
#include "fd-util.h"
#include "hexdecoct.h"
#include "hmac.h"
#include "id128-util.h"
#include "io-util.h"
#include "macro.h"
#include "missing_syscall.h"
#include "missing_threads.h"
#include "path-util.h"
#include "random-util.h"
#include "stat-util.h"
#include "user-util.h"
_public_ char *sd_id128_to_string(sd_id128_t id, char s[_SD_ARRAY_STATIC SD_ID128_STRING_MAX]) {
size_t k = 0;
assert_return(s, NULL);
for (size_t n = 0; n < sizeof(sd_id128_t); n++) {
s[k++] = hexchar(id.bytes[n] >> 4);
s[k++] = hexchar(id.bytes[n] & 0xF);
}
assert(k == SD_ID128_STRING_MAX - 1);
s[k] = 0;
return s;
}
_public_ char *sd_id128_to_uuid_string(sd_id128_t id, char s[_SD_ARRAY_STATIC SD_ID128_UUID_STRING_MAX]) {
size_t k = 0;
assert_return(s, NULL);
/* Similar to sd_id128_to_string() but formats the result as UUID instead of plain hex chars */
for (size_t n = 0; n < sizeof(sd_id128_t); n++) {
if (IN_SET(n, 4, 6, 8, 10))
s[k++] = '-';
s[k++] = hexchar(id.bytes[n] >> 4);
s[k++] = hexchar(id.bytes[n] & 0xF);
}
assert(k == SD_ID128_UUID_STRING_MAX - 1);
s[k] = 0;
return s;
}
_public_ int sd_id128_from_string(const char *s, sd_id128_t *ret) {
size_t n, i;
sd_id128_t t;
bool is_guid = false;
assert_return(s, -EINVAL);
for (n = 0, i = 0; n < sizeof(sd_id128_t);) {
int a, b;
if (s[i] == '-') {
/* Is this a GUID? Then be nice, and skip over
* the dashes */
if (i == 8)
is_guid = true;
else if (IN_SET(i, 13, 18, 23)) {
if (!is_guid)
return -EINVAL;
} else
return -EINVAL;
i++;
continue;
}
a = unhexchar(s[i++]);
if (a < 0)
return -EINVAL;
b = unhexchar(s[i++]);
if (b < 0)
return -EINVAL;
t.bytes[n++] = (a << 4) | b;
}
if (i != (is_guid ? SD_ID128_UUID_STRING_MAX : SD_ID128_STRING_MAX) - 1)
return -EINVAL;
if (s[i] != 0)
return -EINVAL;
if (ret)
*ret = t;
return 0;
}
_public_ int sd_id128_string_equal(const char *s, sd_id128_t id) {
sd_id128_t parsed;
int r;
if (!s)
return false;
/* Checks if the specified string matches a valid string representation of the specified 128 bit ID/uuid */
r = sd_id128_from_string(s, &parsed);
if (r < 0)
return r;
return sd_id128_equal(parsed, id);
}
_public_ int sd_id128_get_machine(sd_id128_t *ret) {
static thread_local sd_id128_t saved_machine_id = {};
int r;
if (sd_id128_is_null(saved_machine_id)) {
r = id128_read("/etc/machine-id", ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, &saved_machine_id);
if (r < 0)
return r;
}
if (ret)
*ret = saved_machine_id;
return 0;
}
int id128_get_machine_at(int rfd, sd_id128_t *ret) {
_cleanup_close_ int fd = -EBADF;
int r;
assert(rfd >= 0 || rfd == AT_FDCWD);
r = dir_fd_is_root_or_cwd(rfd);
if (r < 0)
return r;
if (r > 0)
return sd_id128_get_machine(ret);
fd = chase_and_openat(rfd, "/etc/machine-id", CHASE_AT_RESOLVE_IN_ROOT, O_RDONLY|O_CLOEXEC|O_NOCTTY, NULL);
if (fd < 0)
return fd;
return id128_read_fd(fd, ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, ret);
}
int id128_get_machine(const char *root, sd_id128_t *ret) {
_cleanup_close_ int fd = -EBADF;
if (empty_or_root(root))
return sd_id128_get_machine(ret);
fd = chase_and_open("/etc/machine-id", root, CHASE_PREFIX_ROOT, O_RDONLY|O_CLOEXEC|O_NOCTTY, NULL);
if (fd < 0)
return fd;
return id128_read_fd(fd, ID128_FORMAT_PLAIN | ID128_REFUSE_NULL, ret);
}
_public_ int sd_id128_get_boot(sd_id128_t *ret) {
static thread_local sd_id128_t saved_boot_id = {};
int r;
if (sd_id128_is_null(saved_boot_id)) {
r = id128_read("/proc/sys/kernel/random/boot_id", ID128_FORMAT_UUID | ID128_REFUSE_NULL, &saved_boot_id);
if (r == -ENOENT && proc_mounted() == 0)
return -ENOSYS;
if (r < 0)
return r;
}
if (ret)
*ret = saved_boot_id;
return 0;
}
static int get_invocation_from_keyring(sd_id128_t *ret) {
_cleanup_free_ char *description = NULL;
char *d, *p, *g, *u, *e;
unsigned long perms;
key_serial_t key;
size_t sz = 256;
uid_t uid;
gid_t gid;
int r, c;
#define MAX_PERMS ((unsigned long) (KEY_POS_VIEW|KEY_POS_READ|KEY_POS_SEARCH| \
KEY_USR_VIEW|KEY_USR_READ|KEY_USR_SEARCH))
assert(ret);
key = request_key("user", "invocation_id", NULL, 0);
if (key == -1) {
/* Keyring support not available? No invocation key stored? */
if (IN_SET(errno, ENOSYS, ENOKEY))
return -ENXIO;
return -errno;
}
for (;;) {
description = new(char, sz);
if (!description)
return -ENOMEM;
c = keyctl(KEYCTL_DESCRIBE, key, (unsigned long) description, sz, 0);
if (c < 0)
return -errno;
if ((size_t) c <= sz)
break;
sz = c;
free(description);
}
/* The kernel returns a final NUL in the string, verify that. */
assert(description[c-1] == 0);
/* Chop off the final description string */
d = strrchr(description, ';');
if (!d)
return -EUCLEAN;
*d = 0;
/* Look for the permissions */
p = strrchr(description, ';');
if (!p)
return -EUCLEAN;
errno = 0;
perms = strtoul(p + 1, &e, 16);
if (errno > 0)
return -errno;
if (e == p + 1) /* Read at least one character */
return -EUCLEAN;
if (e != d) /* Must reached the end */
return -EUCLEAN;
if ((perms & ~MAX_PERMS) != 0)
return -EPERM;
*p = 0;
/* Look for the group ID */
g = strrchr(description, ';');
if (!g)
return -EUCLEAN;
r = parse_gid(g + 1, &gid);
if (r < 0)
return r;
if (gid != 0)
return -EPERM;
*g = 0;
/* Look for the user ID */
u = strrchr(description, ';');
if (!u)
return -EUCLEAN;
r = parse_uid(u + 1, &uid);
if (r < 0)
return r;
if (uid != 0)
return -EPERM;
c = keyctl(KEYCTL_READ, key, (unsigned long) ret, sizeof(sd_id128_t), 0);
if (c < 0)
return -errno;
if (c != sizeof(sd_id128_t))
return -EUCLEAN;
return 0;
}
static int get_invocation_from_environment(sd_id128_t *ret) {
const char *e;
int r;
assert(ret);
e = secure_getenv("INVOCATION_ID");
if (!e)
return -ENXIO;
r = sd_id128_from_string(e, ret);
return r == -EINVAL ? -EUCLEAN : r;
}
_public_ int sd_id128_get_invocation(sd_id128_t *ret) {
static thread_local sd_id128_t saved_invocation_id = {};
int r;
if (sd_id128_is_null(saved_invocation_id)) {
/* We first check the environment. The environment variable is primarily relevant for user
* services, and sufficiently safe as long as no privilege boundary is involved. */
r = get_invocation_from_environment(&saved_invocation_id);
if (r == -ENXIO)
/* The kernel keyring is relevant for system services (as for user services we don't
* store the invocation ID in the keyring, as there'd be no trust benefit in that). */
r = get_invocation_from_keyring(&saved_invocation_id);
if (r < 0)
return r;
if (sd_id128_is_null(saved_invocation_id))
return -ENOMEDIUM;
}
if (ret)
*ret = saved_invocation_id;
return 0;
}
_public_ int sd_id128_randomize(sd_id128_t *ret) {
sd_id128_t t;
assert_return(ret, -EINVAL);
random_bytes(&t, sizeof(t));
/* Turn this into a valid v4 UUID, to be nice. Note that we
* only guarantee this for newly generated UUIDs, not for
* pre-existing ones. */
*ret = id128_make_v4_uuid(t);
return 0;
}
static int get_app_specific(sd_id128_t base, sd_id128_t app_id, sd_id128_t *ret) {
uint8_t hmac[SHA256_DIGEST_SIZE];
sd_id128_t result;
assert(ret);
hmac_sha256(&base, sizeof(base), &app_id, sizeof(app_id), hmac);
/* Take only the first half. */
memcpy(&result, hmac, MIN(sizeof(hmac), sizeof(result)));
*ret = id128_make_v4_uuid(result);
return 0;
}
_public_ int sd_id128_get_machine_app_specific(sd_id128_t app_id, sd_id128_t *ret) {
sd_id128_t id;
int r;
assert_return(ret, -EINVAL);
r = sd_id128_get_machine(&id);
if (r < 0)
return r;
return get_app_specific(id, app_id, ret);
}
_public_ int sd_id128_get_boot_app_specific(sd_id128_t app_id, sd_id128_t *ret) {
sd_id128_t id;
int r;
assert_return(ret, -EINVAL);
r = sd_id128_get_boot(&id);
if (r < 0)
return r;
return get_app_specific(id, app_id, ret);
}
| 10,646 | 26.944882 | 121 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/audit-type.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdio.h>
#include "alloc-util.h"
#include "macro.h"
const char *audit_type_to_string(int type);
int audit_type_from_string(const char *s);
/* This is inspired by DNS TYPEnnn formatting */
#define audit_type_name_alloca(type) \
({ \
const char *_s_; \
_s_ = audit_type_to_string(type); \
if (!_s_) { \
_s_ = newa(char, STRLEN("AUDIT") + DECIMAL_STR_MAX(int)); \
sprintf((char*) _s_, "AUDIT%04i", type); \
} \
_s_; \
})
| 951 | 40.391304 | 83 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/catalog.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <locale.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "catalog.h"
#include "conf-files.h"
#include "fd-util.h"
#include "fileio.h"
#include "hashmap.h"
#include "log.h"
#include "memory-util.h"
#include "mkdir.h"
#include "path-util.h"
#include "siphash24.h"
#include "sort-util.h"
#include "sparse-endian.h"
#include "strbuf.h"
#include "string-util.h"
#include "strv.h"
#include "tmpfile-util.h"
const char * const catalog_file_dirs[] = {
"/usr/local/lib/systemd/catalog/",
"/usr/lib/systemd/catalog/",
NULL
};
#define CATALOG_SIGNATURE { 'R', 'H', 'H', 'H', 'K', 'S', 'L', 'P' }
typedef struct CatalogHeader {
uint8_t signature[8]; /* "RHHHKSLP" */
le32_t compatible_flags;
le32_t incompatible_flags;
le64_t header_size;
le64_t n_items;
le64_t catalog_item_size;
} CatalogHeader;
typedef struct CatalogItem {
sd_id128_t id;
char language[32]; /* One byte is used for termination, so the maximum allowed
* length of the string is actually 31 bytes. */
le64_t offset;
} CatalogItem;
static void catalog_hash_func(const CatalogItem *i, struct siphash *state) {
siphash24_compress(&i->id, sizeof(i->id), state);
siphash24_compress_string(i->language, state);
}
static int catalog_compare_func(const CatalogItem *a, const CatalogItem *b) {
unsigned k;
int r;
for (k = 0; k < ELEMENTSOF(b->id.bytes); k++) {
r = CMP(a->id.bytes[k], b->id.bytes[k]);
if (r != 0)
return r;
}
return strcmp(a->language, b->language);
}
DEFINE_HASH_OPS(catalog_hash_ops, CatalogItem, catalog_hash_func, catalog_compare_func);
static bool next_header(const char **s) {
const char *e;
e = strchr(*s, '\n');
/* Unexpected end */
if (!e)
return false;
/* End of headers */
if (e == *s)
return false;
*s = e + 1;
return true;
}
static const char *skip_header(const char *s) {
while (next_header(&s))
;
return s;
}
static char *combine_entries(const char *one, const char *two) {
const char *b1, *b2;
size_t l1, l2, n;
char *dest, *p;
/* Find split point of headers to body */
b1 = skip_header(one);
b2 = skip_header(two);
l1 = strlen(one);
l2 = strlen(two);
dest = new(char, l1 + l2 + 1);
if (!dest) {
log_oom();
return NULL;
}
p = dest;
/* Headers from @one */
n = b1 - one;
p = mempcpy(p, one, n);
/* Headers from @two, these will only be found if not present above */
n = b2 - two;
p = mempcpy(p, two, n);
/* Body from @one */
n = l1 - (b1 - one);
if (n > 0)
p = mempcpy(p, b1, n);
/* Body from @two */
else {
n = l2 - (b2 - two);
p = mempcpy(p, b2, n);
}
assert(p - dest <= (ptrdiff_t)(l1 + l2));
p[0] = '\0';
return dest;
}
static int finish_item(
OrderedHashmap *h,
sd_id128_t id,
const char *language,
char *payload, size_t payload_size) {
_cleanup_free_ CatalogItem *i = NULL;
_cleanup_free_ char *combined = NULL;
char *prev;
int r;
assert(h);
assert(payload);
assert(payload_size > 0);
i = new0(CatalogItem, 1);
if (!i)
return log_oom();
i->id = id;
if (language) {
assert(strlen(language) > 1 && strlen(language) < 32);
strcpy(i->language, language);
}
prev = ordered_hashmap_get(h, i);
if (prev) {
/* Already have such an item, combine them */
combined = combine_entries(payload, prev);
if (!combined)
return log_oom();
r = ordered_hashmap_update(h, i, combined);
if (r < 0)
return log_error_errno(r, "Failed to update catalog item: %m");
TAKE_PTR(combined);
free(prev);
} else {
/* A new item */
combined = memdup(payload, payload_size + 1);
if (!combined)
return log_oom();
r = ordered_hashmap_put(h, i, combined);
if (r < 0)
return log_error_errno(r, "Failed to insert catalog item: %m");
TAKE_PTR(i);
TAKE_PTR(combined);
}
return 0;
}
int catalog_file_lang(const char* filename, char **lang) {
char *beg, *end, *_lang;
end = endswith(filename, ".catalog");
if (!end)
return 0;
beg = end - 1;
while (beg > filename && !IN_SET(*beg, '.', '/') && end - beg < 32)
beg--;
if (*beg != '.' || end <= beg + 1)
return 0;
_lang = strndup(beg + 1, end - beg - 1);
if (!_lang)
return -ENOMEM;
*lang = _lang;
return 1;
}
static int catalog_entry_lang(
const char* filename,
unsigned line,
const char* t,
const char* deflang,
char **ret) {
size_t c;
char *z;
c = strlen(t);
if (c < 2)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"[%s:%u] Language too short.", filename, line);
if (c > 31)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"[%s:%u] language too long.", filename, line);
if (deflang) {
if (streq(t, deflang)) {
log_warning("[%s:%u] language specified unnecessarily", filename, line);
return 0;
}
log_warning("[%s:%u] language differs from default for file", filename, line);
}
z = strdup(t);
if (!z)
return -ENOMEM;
*ret = z;
return 0;
}
int catalog_import_file(OrderedHashmap *h, const char *path) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *payload = NULL;
size_t payload_size = 0;
unsigned n = 0;
sd_id128_t id;
_cleanup_free_ char *deflang = NULL, *lang = NULL;
bool got_id = false, empty_line = true;
int r;
assert(h);
assert(path);
f = fopen(path, "re");
if (!f)
return log_error_errno(errno, "Failed to open file %s: %m", path);
r = catalog_file_lang(path, &deflang);
if (r < 0)
log_error_errno(r, "Failed to determine language for file %s: %m", path);
if (r == 1)
log_debug("File %s has language %s.", path, deflang);
for (;;) {
_cleanup_free_ char *line = NULL;
size_t line_len;
r = read_line(f, LONG_LINE_MAX, &line);
if (r < 0)
return log_error_errno(r, "Failed to read file %s: %m", path);
if (r == 0)
break;
n++;
if (isempty(line)) {
empty_line = true;
continue;
}
if (strchr(COMMENTS, line[0]))
continue;
if (empty_line &&
strlen(line) >= 2+1+32 &&
line[0] == '-' &&
line[1] == '-' &&
line[2] == ' ' &&
IN_SET(line[2+1+32], ' ', '\0')) {
bool with_language;
sd_id128_t jd;
/* New entry */
with_language = line[2+1+32] != '\0';
line[2+1+32] = '\0';
if (sd_id128_from_string(line + 2 + 1, &jd) >= 0) {
if (got_id) {
if (payload_size == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"[%s:%u] No payload text.",
path,
n);
r = finish_item(h, id, lang ?: deflang, payload, payload_size);
if (r < 0)
return r;
lang = mfree(lang);
payload_size = 0;
}
if (with_language) {
char *t;
t = strstrip(line + 2 + 1 + 32 + 1);
r = catalog_entry_lang(path, n, t, deflang, &lang);
if (r < 0)
return r;
}
got_id = true;
empty_line = false;
id = jd;
continue;
}
}
/* Payload */
if (!got_id)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"[%s:%u] Got payload before ID.",
path, n);
line_len = strlen(line);
if (!GREEDY_REALLOC(payload, payload_size + (empty_line ? 1 : 0) + line_len + 1 + 1))
return log_oom();
if (empty_line)
payload[payload_size++] = '\n';
memcpy(payload + payload_size, line, line_len);
payload_size += line_len;
payload[payload_size++] = '\n';
payload[payload_size] = '\0';
empty_line = false;
}
if (got_id) {
if (payload_size == 0)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"[%s:%u] No payload text.",
path, n);
r = finish_item(h, id, lang ?: deflang, payload, payload_size);
if (r < 0)
return r;
}
return 0;
}
static int64_t write_catalog(
const char *database,
struct strbuf *sb,
CatalogItem *items,
size_t n) {
_cleanup_fclose_ FILE *w = NULL;
_cleanup_free_ char *p = NULL;
CatalogHeader header;
size_t k;
int r;
r = mkdir_parents(database, 0755);
if (r < 0)
return log_error_errno(r, "Failed to create parent directories of %s: %m", database);
r = fopen_temporary(database, &w, &p);
if (r < 0)
return log_error_errno(r, "Failed to open database for writing: %s: %m",
database);
header = (CatalogHeader) {
.signature = CATALOG_SIGNATURE,
.header_size = htole64(CONST_ALIGN_TO(sizeof(CatalogHeader), 8)),
.catalog_item_size = htole64(sizeof(CatalogItem)),
.n_items = htole64(n),
};
r = -EIO;
k = fwrite(&header, 1, sizeof(header), w);
if (k != sizeof(header)) {
log_error("%s: failed to write header.", p);
goto error;
}
k = fwrite(items, 1, n * sizeof(CatalogItem), w);
if (k != n * sizeof(CatalogItem)) {
log_error("%s: failed to write database.", p);
goto error;
}
k = fwrite(sb->buf, 1, sb->len, w);
if (k != sb->len) {
log_error("%s: failed to write strings.", p);
goto error;
}
r = fflush_and_check(w);
if (r < 0) {
log_error_errno(r, "%s: failed to write database: %m", p);
goto error;
}
(void) fchmod(fileno(w), 0644);
if (rename(p, database) < 0) {
r = log_error_errno(errno, "rename (%s -> %s) failed: %m", p, database);
goto error;
}
return ftello(w);
error:
(void) unlink(p);
return r;
}
int catalog_update(const char* database, const char* root, const char* const* dirs) {
_cleanup_strv_free_ char **files = NULL;
_cleanup_(strbuf_freep) struct strbuf *sb = NULL;
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
_cleanup_free_ CatalogItem *items = NULL;
ssize_t offset;
char *payload;
CatalogItem *i;
unsigned n;
int r;
int64_t sz;
h = ordered_hashmap_new(&catalog_hash_ops);
sb = strbuf_new();
if (!h || !sb)
return log_oom();
r = conf_files_list_strv(&files, ".catalog", root, 0, dirs);
if (r < 0)
return log_error_errno(r, "Failed to get catalog files: %m");
STRV_FOREACH(f, files) {
log_debug("Reading file '%s'", *f);
r = catalog_import_file(h, *f);
if (r < 0)
return log_error_errno(r, "Failed to import file '%s': %m", *f);
}
if (ordered_hashmap_size(h) <= 0) {
log_info("No items in catalog.");
return 0;
} else
log_debug("Found %u items in catalog.", ordered_hashmap_size(h));
items = new(CatalogItem, ordered_hashmap_size(h));
if (!items)
return log_oom();
n = 0;
ORDERED_HASHMAP_FOREACH_KEY(payload, i, h) {
log_trace("Found " SD_ID128_FORMAT_STR ", language %s",
SD_ID128_FORMAT_VAL(i->id),
isempty(i->language) ? "C" : i->language);
offset = strbuf_add_string(sb, payload, strlen(payload));
if (offset < 0)
return log_oom();
i->offset = htole64((uint64_t) offset);
items[n++] = *i;
}
assert(n == ordered_hashmap_size(h));
typesafe_qsort(items, n, catalog_compare_func);
strbuf_complete(sb);
sz = write_catalog(database, sb, items, n);
if (sz < 0)
return log_error_errno(sz, "Failed to write %s: %m", database);
log_debug("%s: wrote %u items, with %zu bytes of strings, %"PRIi64" total size.",
database, n, sb->len, sz);
return 0;
}
static int open_mmap(const char *database, int *_fd, struct stat *_st, void **_p) {
_cleanup_close_ int fd = -EBADF;
const CatalogHeader *h;
struct stat st;
void *p;
assert(_fd);
assert(_st);
assert(_p);
fd = open(database, O_RDONLY|O_CLOEXEC);
if (fd < 0)
return -errno;
if (fstat(fd, &st) < 0)
return -errno;
if (st.st_size < (off_t) sizeof(CatalogHeader) || file_offset_beyond_memory_size(st.st_size))
return -EINVAL;
p = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (p == MAP_FAILED)
return -errno;
h = p;
if (memcmp(h->signature, (const uint8_t[]) CATALOG_SIGNATURE, sizeof(h->signature)) != 0 ||
le64toh(h->header_size) < sizeof(CatalogHeader) ||
le64toh(h->catalog_item_size) < sizeof(CatalogItem) ||
h->incompatible_flags != 0 ||
le64toh(h->n_items) <= 0 ||
st.st_size < (off_t) (le64toh(h->header_size) + le64toh(h->catalog_item_size) * le64toh(h->n_items))) {
munmap(p, st.st_size);
return -EBADMSG;
}
*_fd = TAKE_FD(fd);
*_st = st;
*_p = p;
return 0;
}
static const char *find_id(void *p, sd_id128_t id) {
CatalogItem *f = NULL, key = { .id = id };
const CatalogHeader *h = p;
const char *loc;
loc = setlocale(LC_MESSAGES, NULL);
if (!isempty(loc) && !STR_IN_SET(loc, "C", "POSIX")) {
size_t len;
len = strcspn(loc, ".@");
if (len > sizeof(key.language) - 1)
log_debug("LC_MESSAGES value too long, ignoring: \"%.*s\"", (int) len, loc);
else {
strncpy(key.language, loc, len);
key.language[len] = '\0';
f = bsearch(&key,
(const uint8_t*) p + le64toh(h->header_size),
le64toh(h->n_items),
le64toh(h->catalog_item_size),
(comparison_fn_t) catalog_compare_func);
if (!f) {
char *e;
e = strchr(key.language, '_');
if (e) {
*e = 0;
f = bsearch(&key,
(const uint8_t*) p + le64toh(h->header_size),
le64toh(h->n_items),
le64toh(h->catalog_item_size),
(comparison_fn_t) catalog_compare_func);
}
}
}
}
if (!f) {
zero(key.language);
f = bsearch(&key,
(const uint8_t*) p + le64toh(h->header_size),
le64toh(h->n_items),
le64toh(h->catalog_item_size),
(comparison_fn_t) catalog_compare_func);
}
if (!f)
return NULL;
return (const char*) p +
le64toh(h->header_size) +
le64toh(h->n_items) * le64toh(h->catalog_item_size) +
le64toh(f->offset);
}
int catalog_get(const char* database, sd_id128_t id, char **_text) {
_cleanup_close_ int fd = -EBADF;
void *p = NULL;
struct stat st = {};
char *text = NULL;
int r;
const char *s;
assert(_text);
r = open_mmap(database, &fd, &st, &p);
if (r < 0)
return r;
s = find_id(p, id);
if (!s) {
r = -ENOENT;
goto finish;
}
text = strdup(s);
if (!text) {
r = -ENOMEM;
goto finish;
}
*_text = text;
r = 0;
finish:
if (p)
munmap(p, st.st_size);
return r;
}
static char *find_header(const char *s, const char *header) {
for (;;) {
const char *v;
v = startswith(s, header);
if (v) {
v += strspn(v, WHITESPACE);
return strndup(v, strcspn(v, NEWLINE));
}
if (!next_header(&s))
return NULL;
}
}
static void dump_catalog_entry(FILE *f, sd_id128_t id, const char *s, bool oneline) {
if (oneline) {
_cleanup_free_ char *subject = NULL, *defined_by = NULL;
subject = find_header(s, "Subject:");
defined_by = find_header(s, "Defined-By:");
fprintf(f, SD_ID128_FORMAT_STR " %s: %s\n",
SD_ID128_FORMAT_VAL(id),
strna(defined_by), strna(subject));
} else
fprintf(f, "-- " SD_ID128_FORMAT_STR "\n%s\n",
SD_ID128_FORMAT_VAL(id), s);
}
int catalog_list(FILE *f, const char *database, bool oneline) {
_cleanup_close_ int fd = -EBADF;
void *p = NULL;
struct stat st;
const CatalogHeader *h;
const CatalogItem *items;
int r;
unsigned n;
sd_id128_t last_id;
bool last_id_set = false;
r = open_mmap(database, &fd, &st, &p);
if (r < 0)
return r;
h = p;
items = (const CatalogItem*) ((const uint8_t*) p + le64toh(h->header_size));
for (n = 0; n < le64toh(h->n_items); n++) {
const char *s;
if (last_id_set && sd_id128_equal(last_id, items[n].id))
continue;
assert_se(s = find_id(p, items[n].id));
dump_catalog_entry(f, items[n].id, s, oneline);
last_id_set = true;
last_id = items[n].id;
}
munmap(p, st.st_size);
return 0;
}
int catalog_list_items(FILE *f, const char *database, bool oneline, char **items) {
int r = 0;
STRV_FOREACH(item, items) {
sd_id128_t id;
int k;
_cleanup_free_ char *msg = NULL;
k = sd_id128_from_string(*item, &id);
if (k < 0) {
log_error_errno(k, "Failed to parse id128 '%s': %m", *item);
if (r == 0)
r = k;
continue;
}
k = catalog_get(database, id, &msg);
if (k < 0) {
log_full_errno(k == -ENOENT ? LOG_NOTICE : LOG_ERR, k,
"Failed to retrieve catalog entry for '%s': %m", *item);
if (r == 0)
r = k;
continue;
}
dump_catalog_entry(f, id, msg, oneline);
}
return r;
}
| 22,697 | 29.508065 | 115 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/catalog.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include <stdio.h>
#include "sd-id128.h"
#include "hashmap.h"
#include "strbuf.h"
int catalog_import_file(OrderedHashmap *h, const char *path);
int catalog_update(const char* database, const char* root, const char* const* dirs);
int catalog_get(const char* database, sd_id128_t id, char **data);
int catalog_list(FILE *f, const char* database, bool oneline);
int catalog_list_items(FILE *f, const char* database, bool oneline, char **items);
int catalog_file_lang(const char *filename, char **lang);
extern const char * const catalog_file_dirs[];
extern const struct hash_ops catalog_hash_ops;
| 681 | 33.1 | 84 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/fsprg.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
*
* fsprg v0.1 - (seekable) forward-secure pseudorandom generator
* Copyright © 2012 B. Poettering
* Contact: [email protected]
*
* This library 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.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
/*
* See "Practical Secure Logging: Seekable Sequential Key Generators"
* by G. A. Marson, B. Poettering for details:
*
* http://eprint.iacr.org/2013/397
*/
#include <string.h>
#include "fsprg.h"
#include "gcrypt-util.h"
#include "memory-util.h"
#define ISVALID_SECPAR(secpar) (((secpar) % 16 == 0) && ((secpar) >= 16) && ((secpar) <= 16384))
#define VALIDATE_SECPAR(secpar) assert(ISVALID_SECPAR(secpar));
#define RND_HASH GCRY_MD_SHA256
#define RND_GEN_P 0x01
#define RND_GEN_Q 0x02
#define RND_GEN_X 0x03
#pragma GCC diagnostic ignored "-Wpointer-arith"
/* TODO: remove void* arithmetic and this work-around */
/******************************************************************************/
static void mpi_export(void *buf, size_t buflen, const gcry_mpi_t x) {
unsigned len;
size_t nwritten;
assert(gcry_mpi_cmp_ui(x, 0) >= 0);
len = (gcry_mpi_get_nbits(x) + 7) / 8;
assert(len <= buflen);
memzero(buf, buflen);
gcry_mpi_print(GCRYMPI_FMT_USG, buf + (buflen - len), len, &nwritten, x);
assert(nwritten == len);
}
static gcry_mpi_t mpi_import(const void *buf, size_t buflen) {
gcry_mpi_t h;
_unused_ unsigned len;
assert_se(gcry_mpi_scan(&h, GCRYMPI_FMT_USG, buf, buflen, NULL) == 0);
len = (gcry_mpi_get_nbits(h) + 7) / 8;
assert(len <= buflen);
assert(gcry_mpi_cmp_ui(h, 0) >= 0);
return h;
}
static void uint64_export(void *buf, size_t buflen, uint64_t x) {
assert(buflen == 8);
((uint8_t*) buf)[0] = (x >> 56) & 0xff;
((uint8_t*) buf)[1] = (x >> 48) & 0xff;
((uint8_t*) buf)[2] = (x >> 40) & 0xff;
((uint8_t*) buf)[3] = (x >> 32) & 0xff;
((uint8_t*) buf)[4] = (x >> 24) & 0xff;
((uint8_t*) buf)[5] = (x >> 16) & 0xff;
((uint8_t*) buf)[6] = (x >> 8) & 0xff;
((uint8_t*) buf)[7] = (x >> 0) & 0xff;
}
_pure_ static uint64_t uint64_import(const void *buf, size_t buflen) {
assert(buflen == 8);
return
(uint64_t)(((uint8_t*) buf)[0]) << 56 |
(uint64_t)(((uint8_t*) buf)[1]) << 48 |
(uint64_t)(((uint8_t*) buf)[2]) << 40 |
(uint64_t)(((uint8_t*) buf)[3]) << 32 |
(uint64_t)(((uint8_t*) buf)[4]) << 24 |
(uint64_t)(((uint8_t*) buf)[5]) << 16 |
(uint64_t)(((uint8_t*) buf)[6]) << 8 |
(uint64_t)(((uint8_t*) buf)[7]) << 0;
}
/* deterministically generate from seed/idx a string of buflen pseudorandom bytes */
static void det_randomize(void *buf, size_t buflen, const void *seed, size_t seedlen, uint32_t idx) {
gcry_md_hd_t hd, hd2;
size_t olen, cpylen;
gcry_error_t err;
uint32_t ctr;
olen = gcry_md_get_algo_dlen(RND_HASH);
err = gcry_md_open(&hd, RND_HASH, 0);
assert_se(gcry_err_code(err) == GPG_ERR_NO_ERROR); /* This shouldn't happen */
gcry_md_write(hd, seed, seedlen);
gcry_md_putc(hd, (idx >> 24) & 0xff);
gcry_md_putc(hd, (idx >> 16) & 0xff);
gcry_md_putc(hd, (idx >> 8) & 0xff);
gcry_md_putc(hd, (idx >> 0) & 0xff);
for (ctr = 0; buflen; ctr++) {
err = gcry_md_copy(&hd2, hd);
assert_se(gcry_err_code(err) == GPG_ERR_NO_ERROR); /* This shouldn't happen */
gcry_md_putc(hd2, (ctr >> 24) & 0xff);
gcry_md_putc(hd2, (ctr >> 16) & 0xff);
gcry_md_putc(hd2, (ctr >> 8) & 0xff);
gcry_md_putc(hd2, (ctr >> 0) & 0xff);
gcry_md_final(hd2);
cpylen = (buflen < olen) ? buflen : olen;
memcpy(buf, gcry_md_read(hd2, RND_HASH), cpylen);
gcry_md_close(hd2);
buf += cpylen;
buflen -= cpylen;
}
gcry_md_close(hd);
}
/* deterministically generate from seed/idx a prime of length `bits' that is 3 (mod 4) */
static gcry_mpi_t genprime3mod4(int bits, const void *seed, size_t seedlen, uint32_t idx) {
size_t buflen = bits / 8;
uint8_t buf[buflen];
gcry_mpi_t p;
assert(bits % 8 == 0);
assert(buflen > 0);
det_randomize(buf, buflen, seed, seedlen, idx);
buf[0] |= 0xc0; /* set upper two bits, so that n=pq has maximum size */
buf[buflen - 1] |= 0x03; /* set lower two bits, to have result 3 (mod 4) */
p = mpi_import(buf, buflen);
while (gcry_prime_check(p, 0))
gcry_mpi_add_ui(p, p, 4);
return p;
}
/* deterministically generate from seed/idx a quadratic residue (mod n) */
static gcry_mpi_t gensquare(const gcry_mpi_t n, const void *seed, size_t seedlen, uint32_t idx, unsigned secpar) {
size_t buflen = secpar / 8;
uint8_t buf[buflen];
gcry_mpi_t x;
det_randomize(buf, buflen, seed, seedlen, idx);
buf[0] &= 0x7f; /* clear upper bit, so that we have x < n */
x = mpi_import(buf, buflen);
assert(gcry_mpi_cmp(x, n) < 0);
gcry_mpi_mulm(x, x, x, n);
return x;
}
/* compute 2^m (mod phi(p)), for a prime p */
static gcry_mpi_t twopowmodphi(uint64_t m, const gcry_mpi_t p) {
gcry_mpi_t phi, r;
int n;
phi = gcry_mpi_new(0);
gcry_mpi_sub_ui(phi, p, 1);
/* count number of used bits in m */
for (n = 0; (1ULL << n) <= m; n++)
;
r = gcry_mpi_new(0);
gcry_mpi_set_ui(r, 1);
while (n) { /* square and multiply algorithm for fast exponentiation */
n--;
gcry_mpi_mulm(r, r, r, phi);
if (m & ((uint64_t)1 << n)) {
gcry_mpi_add(r, r, r);
if (gcry_mpi_cmp(r, phi) >= 0)
gcry_mpi_sub(r, r, phi);
}
}
gcry_mpi_release(phi);
return r;
}
/* Decompose $x \in Z_n$ into $(xp,xq) \in Z_p \times Z_q$ using Chinese Remainder Theorem */
static void CRT_decompose(gcry_mpi_t *xp, gcry_mpi_t *xq, const gcry_mpi_t x, const gcry_mpi_t p, const gcry_mpi_t q) {
*xp = gcry_mpi_new(0);
*xq = gcry_mpi_new(0);
gcry_mpi_mod(*xp, x, p);
gcry_mpi_mod(*xq, x, q);
}
/* Compose $(xp,xq) \in Z_p \times Z_q$ into $x \in Z_n$ using Chinese Remainder Theorem */
static void CRT_compose(gcry_mpi_t *x, const gcry_mpi_t xp, const gcry_mpi_t xq, const gcry_mpi_t p, const gcry_mpi_t q) {
gcry_mpi_t a, u;
a = gcry_mpi_new(0);
u = gcry_mpi_new(0);
*x = gcry_mpi_new(0);
gcry_mpi_subm(a, xq, xp, q);
gcry_mpi_invm(u, p, q);
gcry_mpi_mulm(a, a, u, q); /* a = (xq - xp) / p (mod q) */
gcry_mpi_mul(*x, p, a);
gcry_mpi_add(*x, *x, xp); /* x = p * ((xq - xp) / p mod q) + xp */
gcry_mpi_release(a);
gcry_mpi_release(u);
}
/******************************************************************************/
size_t FSPRG_mskinbytes(unsigned _secpar) {
VALIDATE_SECPAR(_secpar);
return 2 + 2 * (_secpar / 2) / 8; /* to store header,p,q */
}
size_t FSPRG_mpkinbytes(unsigned _secpar) {
VALIDATE_SECPAR(_secpar);
return 2 + _secpar / 8; /* to store header,n */
}
size_t FSPRG_stateinbytes(unsigned _secpar) {
VALIDATE_SECPAR(_secpar);
return 2 + 2 * _secpar / 8 + 8; /* to store header,n,x,epoch */
}
static void store_secpar(void *buf, uint16_t secpar) {
secpar = secpar / 16 - 1;
((uint8_t*) buf)[0] = (secpar >> 8) & 0xff;
((uint8_t*) buf)[1] = (secpar >> 0) & 0xff;
}
static uint16_t read_secpar(const void *buf) {
uint16_t secpar;
secpar =
(uint16_t)(((uint8_t*) buf)[0]) << 8 |
(uint16_t)(((uint8_t*) buf)[1]) << 0;
return 16 * (secpar + 1);
}
void FSPRG_GenMK(void *msk, void *mpk, const void *seed, size_t seedlen, unsigned _secpar) {
uint8_t iseed[FSPRG_RECOMMENDED_SEEDLEN];
gcry_mpi_t n, p, q;
uint16_t secpar;
VALIDATE_SECPAR(_secpar);
secpar = _secpar;
initialize_libgcrypt(false);
if (!seed) {
gcry_randomize(iseed, FSPRG_RECOMMENDED_SEEDLEN, GCRY_STRONG_RANDOM);
seed = iseed;
seedlen = FSPRG_RECOMMENDED_SEEDLEN;
}
p = genprime3mod4(secpar / 2, seed, seedlen, RND_GEN_P);
q = genprime3mod4(secpar / 2, seed, seedlen, RND_GEN_Q);
if (msk) {
store_secpar(msk + 0, secpar);
mpi_export(msk + 2 + 0 * (secpar / 2) / 8, (secpar / 2) / 8, p);
mpi_export(msk + 2 + 1 * (secpar / 2) / 8, (secpar / 2) / 8, q);
}
if (mpk) {
n = gcry_mpi_new(0);
gcry_mpi_mul(n, p, q);
assert(gcry_mpi_get_nbits(n) == secpar);
store_secpar(mpk + 0, secpar);
mpi_export(mpk + 2, secpar / 8, n);
gcry_mpi_release(n);
}
gcry_mpi_release(p);
gcry_mpi_release(q);
}
void FSPRG_GenState0(void *state, const void *mpk, const void *seed, size_t seedlen) {
gcry_mpi_t n, x;
uint16_t secpar;
initialize_libgcrypt(false);
secpar = read_secpar(mpk + 0);
n = mpi_import(mpk + 2, secpar / 8);
x = gensquare(n, seed, seedlen, RND_GEN_X, secpar);
memcpy(state, mpk, 2 + secpar / 8);
mpi_export(state + 2 + 1 * secpar / 8, secpar / 8, x);
memzero(state + 2 + 2 * secpar / 8, 8);
gcry_mpi_release(n);
gcry_mpi_release(x);
}
void FSPRG_Evolve(void *state) {
gcry_mpi_t n, x;
uint16_t secpar;
uint64_t epoch;
initialize_libgcrypt(false);
secpar = read_secpar(state + 0);
n = mpi_import(state + 2 + 0 * secpar / 8, secpar / 8);
x = mpi_import(state + 2 + 1 * secpar / 8, secpar / 8);
epoch = uint64_import(state + 2 + 2 * secpar / 8, 8);
gcry_mpi_mulm(x, x, x, n);
epoch++;
mpi_export(state + 2 + 1 * secpar / 8, secpar / 8, x);
uint64_export(state + 2 + 2 * secpar / 8, 8, epoch);
gcry_mpi_release(n);
gcry_mpi_release(x);
}
uint64_t FSPRG_GetEpoch(const void *state) {
uint16_t secpar;
secpar = read_secpar(state + 0);
return uint64_import(state + 2 + 2 * secpar / 8, 8);
}
void FSPRG_Seek(void *state, uint64_t epoch, const void *msk, const void *seed, size_t seedlen) {
gcry_mpi_t p, q, n, x, xp, xq, kp, kq, xm;
uint16_t secpar;
initialize_libgcrypt(false);
secpar = read_secpar(msk + 0);
p = mpi_import(msk + 2 + 0 * (secpar / 2) / 8, (secpar / 2) / 8);
q = mpi_import(msk + 2 + 1 * (secpar / 2) / 8, (secpar / 2) / 8);
n = gcry_mpi_new(0);
gcry_mpi_mul(n, p, q);
x = gensquare(n, seed, seedlen, RND_GEN_X, secpar);
CRT_decompose(&xp, &xq, x, p, q); /* split (mod n) into (mod p) and (mod q) using CRT */
kp = twopowmodphi(epoch, p); /* compute 2^epoch (mod phi(p)) */
kq = twopowmodphi(epoch, q); /* compute 2^epoch (mod phi(q)) */
gcry_mpi_powm(xp, xp, kp, p); /* compute x^(2^epoch) (mod p) */
gcry_mpi_powm(xq, xq, kq, q); /* compute x^(2^epoch) (mod q) */
CRT_compose(&xm, xp, xq, p, q); /* combine (mod p) and (mod q) to (mod n) using CRT */
store_secpar(state + 0, secpar);
mpi_export(state + 2 + 0 * secpar / 8, secpar / 8, n);
mpi_export(state + 2 + 1 * secpar / 8, secpar / 8, xm);
uint64_export(state + 2 + 2 * secpar / 8, 8, epoch);
gcry_mpi_release(p);
gcry_mpi_release(q);
gcry_mpi_release(n);
gcry_mpi_release(x);
gcry_mpi_release(xp);
gcry_mpi_release(xq);
gcry_mpi_release(kp);
gcry_mpi_release(kq);
gcry_mpi_release(xm);
}
void FSPRG_GetKey(const void *state, void *key, size_t keylen, uint32_t idx) {
uint16_t secpar;
initialize_libgcrypt(false);
secpar = read_secpar(state + 0);
det_randomize(key, keylen, state + 2, 2 * secpar / 8 + 8, idx);
}
| 13,131 | 33.376963 | 122 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/fsprg.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/*
* fsprg v0.1 - (seekable) forward-secure pseudorandom generator
* Copyright © 2012 B. Poettering
* Contact: [email protected]
*
* This library 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.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
#include <inttypes.h>
#include <sys/types.h>
#include "macro.h"
#ifdef __cplusplus
extern "C" {
#endif
#define FSPRG_RECOMMENDED_SECPAR 1536
#define FSPRG_RECOMMENDED_SEEDLEN (96/8)
size_t FSPRG_mskinbytes(unsigned secpar) _const_;
size_t FSPRG_mpkinbytes(unsigned secpar) _const_;
size_t FSPRG_stateinbytes(unsigned secpar) _const_;
/* Setup msk and mpk. Providing seed != NULL makes this algorithm deterministic. */
void FSPRG_GenMK(void *msk, void *mpk, const void *seed, size_t seedlen, unsigned secpar);
/* Initialize state deterministically in dependence on seed. */
/* Note: in case one wants to run only one GenState0 per GenMK it is safe to use
the same seed for both GenMK and GenState0.
*/
void FSPRG_GenState0(void *state, const void *mpk, const void *seed, size_t seedlen);
void FSPRG_Evolve(void *state);
uint64_t FSPRG_GetEpoch(const void *state) _pure_;
/* Seek to any arbitrary state (by providing msk together with seed from GenState0). */
void FSPRG_Seek(void *state, uint64_t epoch, const void *msk, const void *seed, size_t seedlen);
void FSPRG_GetKey(const void *state, void *key, size_t keylen, uint32_t idx);
#ifdef __cplusplus
}
#endif
| 2,133 | 33.419355 | 96 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/journal-authenticate.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "journal-file.h"
int journal_file_append_tag(JournalFile *f);
int journal_file_maybe_append_tag(JournalFile *f, uint64_t realtime);
int journal_file_append_first_tag(JournalFile *f);
int journal_file_hmac_setup(JournalFile *f);
int journal_file_hmac_start(JournalFile *f);
int journal_file_hmac_put_header(JournalFile *f);
int journal_file_hmac_put_object(JournalFile *f, ObjectType type, Object *o, uint64_t p);
int journal_file_fss_load(JournalFile *f);
int journal_file_parse_verification_key(JournalFile *f, const char *key);
int journal_file_fsprg_evolve(JournalFile *f, uint64_t realtime);
int journal_file_fsprg_seek(JournalFile *f, uint64_t epoch);
bool journal_file_next_evolve_usec(JournalFile *f, usec_t *u);
| 819 | 33.166667 | 89 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/journal-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include <sys/types.h>
#include "sd-id128.h"
#include "sd-journal.h"
#include "hashmap.h"
#include "journal-def.h"
#include "journal-file.h"
#include "list.h"
#include "set.h"
#define JOURNAL_FILES_MAX 7168u
#define JOURNAL_LOG_RATELIMIT ((const RateLimit) { .interval = 60 * USEC_PER_SEC, .burst = 3 })
typedef struct Match Match;
typedef struct Location Location;
typedef struct Directory Directory;
typedef enum MatchType {
MATCH_DISCRETE,
MATCH_OR_TERM,
MATCH_AND_TERM
} MatchType;
struct Match {
MatchType type;
Match *parent;
LIST_FIELDS(Match, matches);
/* For concrete matches */
char *data;
size_t size;
uint64_t hash; /* old-style jenkins hash. New-style siphash is different per file, hence won't be cached here */
/* For terms */
LIST_HEAD(Match, matches);
};
struct Location {
LocationType type;
bool seqnum_set:1;
bool realtime_set:1;
bool monotonic_set:1;
bool xor_hash_set:1;
uint64_t seqnum;
sd_id128_t seqnum_id;
uint64_t realtime;
uint64_t monotonic;
sd_id128_t boot_id;
uint64_t xor_hash;
};
struct Directory {
char *path;
int wd;
bool is_root;
unsigned last_seen_generation;
};
struct sd_journal {
int toplevel_fd;
char *path;
char *prefix;
char *namespace;
OrderedHashmap *files;
IteratedCache *files_cache;
MMapCache *mmap;
Hashmap *newest_by_boot_id; /* key: boot_id, value: prioq, ordered by monotonic timestamp of last update */
Location current_location;
JournalFile *current_file;
uint64_t current_field;
Match *level0, *level1, *level2;
uint64_t origin_id;
int inotify_fd;
unsigned current_invalidate_counter, last_invalidate_counter;
usec_t last_process_usec;
unsigned generation;
/* Iterating through unique fields and their data values */
char *unique_field;
JournalFile *unique_file;
uint64_t unique_offset;
/* Iterating through known fields */
JournalFile *fields_file;
uint64_t fields_offset;
uint64_t fields_hash_table_index;
char *fields_buffer;
int flags;
bool on_network:1;
bool no_new_files:1;
bool no_inotify:1;
bool unique_file_lost:1; /* File we were iterating over got
removed, and there were no more
files, so sd_j_enumerate_unique
will return a value equal to 0. */
bool fields_file_lost:1;
bool has_runtime_files:1;
bool has_persistent_files:1;
size_t data_threshold;
Hashmap *directories_by_path;
Hashmap *directories_by_wd;
Hashmap *errors;
};
char *journal_make_match_string(sd_journal *j);
void journal_print_header(sd_journal *j);
#define JOURNAL_FOREACH_DATA_RETVAL(j, data, l, retval) \
for (sd_journal_restart_data(j); ((retval) = sd_journal_enumerate_data((j), &(data), &(l))) > 0; )
/* All errors that we might encounter while extracting a field that are not real errors,
* but only mean that the field is too large or we don't support the compression. */
static inline bool JOURNAL_ERRNO_IS_UNAVAILABLE_FIELD(int r) {
return IN_SET(abs(r),
ENOBUFS, /* Field or decompressed field too large */
E2BIG, /* Field too large for pointer width */
EPROTONOSUPPORT); /* Unsupported compression */
}
| 3,839 | 25.853147 | 120 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/journal-vacuum.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "sd-id128.h"
#include "alloc-util.h"
#include "dirent-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "fs-util.h"
#include "journal-def.h"
#include "journal-file.h"
#include "journal-internal.h"
#include "journal-vacuum.h"
#include "sort-util.h"
#include "string-util.h"
#include "time-util.h"
#include "xattr-util.h"
typedef struct vacuum_info {
uint64_t usage;
char *filename;
uint64_t realtime;
sd_id128_t seqnum_id;
uint64_t seqnum;
bool have_seqnum;
} vacuum_info;
static int vacuum_info_compare(const vacuum_info *a, const vacuum_info *b) {
int r;
if (a->have_seqnum && b->have_seqnum &&
sd_id128_equal(a->seqnum_id, b->seqnum_id))
return CMP(a->seqnum, b->seqnum);
r = CMP(a->realtime, b->realtime);
if (r != 0)
return r;
if (a->have_seqnum && b->have_seqnum)
return memcmp(&a->seqnum_id, &b->seqnum_id, 16);
return strcmp(a->filename, b->filename);
}
static void vacuum_info_array_free(vacuum_info *list, size_t n) {
if (!list)
return;
FOREACH_ARRAY(i, list, n)
free(i->filename);
free(list);
}
static void patch_realtime(
int fd,
const char *fn,
const struct stat *st,
unsigned long long *realtime) {
usec_t x;
/* The timestamp was determined by the file name, but let's see if the file might actually be older
* than the file name suggested... */
assert(fd >= 0);
assert(fn);
assert(st);
assert(realtime);
x = timespec_load(&st->st_ctim);
if (timestamp_is_set(x) && x < *realtime)
*realtime = x;
x = timespec_load(&st->st_atim);
if (timestamp_is_set(x) && x < *realtime)
*realtime = x;
x = timespec_load(&st->st_mtim);
if (timestamp_is_set(x) && x < *realtime)
*realtime = x;
/* Let's read the original creation time, if possible. Ideally we'd just query the creation time the
* FS might provide, but unfortunately there's currently no sane API to query it. Hence let's
* implement this manually... */
if (fd_getcrtime_at(fd, fn, AT_SYMLINK_FOLLOW, &x) >= 0 && x < *realtime)
*realtime = x;
}
static int journal_file_empty(int dir_fd, const char *name) {
_cleanup_close_ int fd = -EBADF;
struct stat st;
le64_t n_entries;
ssize_t n;
fd = openat(dir_fd, name, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK|O_NOATIME);
if (fd < 0) {
/* Maybe failed due to O_NOATIME and lack of privileges? */
fd = openat(dir_fd, name, O_RDONLY|O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK);
if (fd < 0)
return -errno;
}
if (fstat(fd, &st) < 0)
return -errno;
/* If an offline file doesn't even have a header we consider it empty */
if (st.st_size < (off_t) sizeof(Header))
return 1;
/* If the number of entries is empty, we consider it empty, too */
n = pread(fd, &n_entries, sizeof(n_entries), offsetof(Header, n_entries));
if (n < 0)
return -errno;
if (n != sizeof(n_entries))
return -EIO;
return le64toh(n_entries) <= 0;
}
int journal_directory_vacuum(
const char *directory,
uint64_t max_use,
uint64_t n_max_files,
usec_t max_retention_usec,
usec_t *oldest_usec,
bool verbose) {
uint64_t sum = 0, freed = 0, n_active_files = 0;
size_t n_list = 0, i;
_cleanup_closedir_ DIR *d = NULL;
vacuum_info *list = NULL;
usec_t retention_limit = 0;
int r;
CLEANUP_ARRAY(list, n_list, vacuum_info_array_free);
assert(directory);
if (max_use <= 0 && max_retention_usec <= 0 && n_max_files <= 0)
return 0;
if (max_retention_usec > 0)
retention_limit = usec_sub_unsigned(now(CLOCK_REALTIME), max_retention_usec);
d = opendir(directory);
if (!d)
return -errno;
FOREACH_DIRENT_ALL(de, d, return -errno) {
unsigned long long seqnum = 0, realtime;
_cleanup_free_ char *p = NULL;
sd_id128_t seqnum_id;
bool have_seqnum;
uint64_t size;
struct stat st;
size_t q;
if (fstatat(dirfd(d), de->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0) {
log_debug_errno(errno, "Failed to stat file %s while vacuuming, ignoring: %m", de->d_name);
continue;
}
if (!S_ISREG(st.st_mode))
continue;
size = 512UL * (uint64_t) st.st_blocks;
q = strlen(de->d_name);
if (endswith(de->d_name, ".journal")) {
/* Vacuum archived files. Active files are
* left around */
if (q < 1 + 32 + 1 + 16 + 1 + 16 + 8) {
n_active_files++;
sum += size;
continue;
}
if (de->d_name[q-8-16-1] != '-' ||
de->d_name[q-8-16-1-16-1] != '-' ||
de->d_name[q-8-16-1-16-1-32-1] != '@') {
n_active_files++;
sum += size;
continue;
}
p = strdup(de->d_name);
if (!p)
return -ENOMEM;
de->d_name[q-8-16-1-16-1] = 0;
if (sd_id128_from_string(de->d_name + q-8-16-1-16-1-32, &seqnum_id) < 0) {
n_active_files++;
sum += size;
continue;
}
if (sscanf(de->d_name + q-8-16-1-16, "%16llx-%16llx.journal", &seqnum, &realtime) != 2) {
n_active_files++;
sum += size;
continue;
}
have_seqnum = true;
} else if (endswith(de->d_name, ".journal~")) {
unsigned long long tmp;
/* seqnum_id won't be initialised before use below, so set to 0 */
seqnum_id = SD_ID128_NULL;
/* Vacuum corrupted files */
if (q < 1 + 16 + 1 + 16 + 8 + 1) {
n_active_files++;
sum += size;
continue;
}
if (de->d_name[q-1-8-16-1] != '-' ||
de->d_name[q-1-8-16-1-16-1] != '@') {
n_active_files++;
sum += size;
continue;
}
p = strdup(de->d_name);
if (!p)
return -ENOMEM;
if (sscanf(de->d_name + q-1-8-16-1-16, "%16llx-%16llx.journal~", &realtime, &tmp) != 2) {
n_active_files++;
sum += size;
continue;
}
have_seqnum = false;
} else {
/* We do not vacuum unknown files! */
log_debug("Not vacuuming unknown file %s.", de->d_name);
continue;
}
r = journal_file_empty(dirfd(d), p);
if (r < 0) {
log_debug_errno(r, "Failed check if %s is empty, ignoring: %m", p);
continue;
}
if (r > 0) {
/* Always vacuum empty non-online files. */
r = unlinkat_deallocate(dirfd(d), p, 0);
if (r >= 0) {
log_full(verbose ? LOG_INFO : LOG_DEBUG,
"Deleted empty archived journal %s/%s (%s).", directory, p, FORMAT_BYTES(size));
freed += size;
} else if (r != -ENOENT)
log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT,
"Failed to delete empty archived journal %s/%s: %m",
directory, p);
continue;
}
patch_realtime(dirfd(d), p, &st, &realtime);
if (!GREEDY_REALLOC(list, n_list + 1))
return -ENOMEM;
list[n_list++] = (vacuum_info) {
.filename = TAKE_PTR(p),
.usage = size,
.seqnum = seqnum,
.realtime = realtime,
.seqnum_id = seqnum_id,
.have_seqnum = have_seqnum,
};
sum += size;
}
typesafe_qsort(list, n_list, vacuum_info_compare);
for (i = 0; i < n_list; i++) {
uint64_t left;
left = n_active_files + n_list - i;
if ((max_retention_usec <= 0 || list[i].realtime >= retention_limit) &&
(max_use <= 0 || sum <= max_use) &&
(n_max_files <= 0 || left <= n_max_files))
break;
r = unlinkat_deallocate(dirfd(d), list[i].filename, 0);
if (r >= 0) {
log_full(verbose ? LOG_INFO : LOG_DEBUG, "Deleted archived journal %s/%s (%s).",
directory, list[i].filename, FORMAT_BYTES(list[i].usage));
freed += list[i].usage;
if (list[i].usage < sum)
sum -= list[i].usage;
else
sum = 0;
} else if (r != -ENOENT)
log_ratelimit_warning_errno(r, JOURNAL_LOG_RATELIMIT,
"Failed to delete archived journal %s/%s: %m",
directory, list[i].filename);
}
if (oldest_usec && i < n_list && (*oldest_usec == 0 || list[i].realtime < *oldest_usec))
*oldest_usec = list[i].realtime;
log_full(verbose ? LOG_INFO : LOG_DEBUG, "Vacuuming done, freed %s of archived journals from %s.",
FORMAT_BYTES(freed), directory);
return 0;
}
| 11,403 | 33.453172 | 121 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/lookup3.h
|
/* SPDX-License-Identifier: LicenseRef-lookup3-public-domain */
#pragma once
#include <inttypes.h>
#include <sys/types.h>
#include "macro.h"
uint32_t jenkins_hashword(const uint32_t *k, size_t length, uint32_t initval) _pure_;
void jenkins_hashword2(const uint32_t *k, size_t length, uint32_t *pc, uint32_t *pb);
uint32_t jenkins_hashlittle(const void *key, size_t length, uint32_t initval) _pure_;
void jenkins_hashlittle2(const void *key, size_t length, uint32_t *pc, uint32_t *pb);
uint32_t jenkins_hashbig(const void *key, size_t length, uint32_t initval) _pure_;
static inline uint64_t jenkins_hash64(const void *data, size_t length) {
uint32_t a = 0, b = 0;
jenkins_hashlittle2(data, length, &a, &b);
return ((uint64_t) a << 32ULL) | (uint64_t) b;
}
| 788 | 31.875 | 85 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/mmap-cache.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include <sys/stat.h>
/* One context per object type, plus one of the header, plus one "additional" one */
#define MMAP_CACHE_MAX_CONTEXTS 9
typedef struct MMapCache MMapCache;
typedef struct MMapFileDescriptor MMapFileDescriptor;
MMapCache* mmap_cache_new(void);
MMapCache* mmap_cache_ref(MMapCache *m);
MMapCache* mmap_cache_unref(MMapCache *m);
DEFINE_TRIVIAL_CLEANUP_FUNC(MMapCache*, mmap_cache_unref);
int mmap_cache_fd_get(
MMapFileDescriptor *f,
unsigned context,
bool keep_always,
uint64_t offset,
size_t size,
struct stat *st,
void **ret);
MMapFileDescriptor* mmap_cache_add_fd(MMapCache *m, int fd, int prot);
MMapCache* mmap_cache_fd_cache(MMapFileDescriptor *f);
void mmap_cache_fd_free(MMapFileDescriptor *f);
void mmap_cache_stats_log_debug(MMapCache *m);
bool mmap_cache_fd_got_sigbus(MMapFileDescriptor *f);
| 970 | 28.424242 | 84 |
h
|
null |
systemd-main/src/libsystemd/sd-journal/test-audit-type.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <stdio.h>
#include <linux/audit.h>
#include "audit-type.h"
#include "tests.h"
static void print_audit_label(int i) {
const char *name;
name = audit_type_name_alloca(i);
/* This is a separate function only because of alloca */
printf("%i → %s → %s\n", i, audit_type_to_string(i), name);
}
TEST(audit_type) {
int i;
for (i = 0; i <= AUDIT_KERNEL; i++)
print_audit_label(i);
}
DEFINE_TEST_MAIN(LOG_INFO);
| 531 | 20.28 | 67 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/test-catalog.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <locale.h>
#include <unistd.h>
#include "sd-messages.h"
#include "alloc-util.h"
#include "catalog.h"
#include "fd-util.h"
#include "fs-util.h"
#include "log.h"
#include "macro.h"
#include "path-util.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
#include "tmpfile-util.h"
static char** catalog_dirs = NULL;
static const char *no_catalog_dirs[] = {
"/bin/hopefully/with/no/catalog",
NULL
};
static OrderedHashmap* test_import(const char* contents, ssize_t size, int code) {
_cleanup_(unlink_tempfilep) char name[] = "/tmp/test-catalog.XXXXXX";
_cleanup_close_ int fd = -EBADF;
OrderedHashmap *h;
if (size < 0)
size = strlen(contents);
assert_se(h = ordered_hashmap_new(&catalog_hash_ops));
fd = mkostemp_safe(name);
assert_se(fd >= 0);
assert_se(write(fd, contents, size) == size);
assert_se(catalog_import_file(h, name) == code);
return h;
}
static void test_catalog_import_invalid(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
h = test_import("xxx", -1, -EINVAL);
assert_se(ordered_hashmap_isempty(h));
}
static void test_catalog_import_badid(void) {
_unused_ _cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededede\n" \
"Subject: message\n" \
"\n" \
"payload\n";
h = test_import(input, -1, -EINVAL);
}
static void test_catalog_import_one(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
char *payload;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
"Subject: message\n" \
"\n" \
"payload\n";
const char *expect =
"Subject: message\n" \
"\n" \
"payload\n";
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
ORDERED_HASHMAP_FOREACH(payload, h) {
printf("expect: %s\n", expect);
printf("actual: %s\n", payload);
assert_se(streq(expect, payload));
}
}
static void test_catalog_import_merge(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
char *payload;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
"Subject: message\n" \
"Defined-By: me\n" \
"\n" \
"payload\n" \
"\n" \
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
"Subject: override subject\n" \
"X-Header: hello\n" \
"\n" \
"override payload\n";
const char *combined =
"Subject: override subject\n" \
"X-Header: hello\n" \
"Subject: message\n" \
"Defined-By: me\n" \
"\n" \
"override payload\n";
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
ORDERED_HASHMAP_FOREACH(payload, h)
assert_se(streq(combined, payload));
}
static void test_catalog_import_merge_no_body(void) {
_cleanup_ordered_hashmap_free_free_free_ OrderedHashmap *h = NULL;
char *payload;
const char *input =
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
"Subject: message\n" \
"Defined-By: me\n" \
"\n" \
"payload\n" \
"\n" \
"-- 0027229ca0644181a76c4e92458afaff dededededededededededededededed\n" \
"Subject: override subject\n" \
"X-Header: hello\n" \
"\n";
const char *combined =
"Subject: override subject\n" \
"X-Header: hello\n" \
"Subject: message\n" \
"Defined-By: me\n" \
"\n" \
"payload\n";
h = test_import(input, -1, 0);
assert_se(ordered_hashmap_size(h) == 1);
ORDERED_HASHMAP_FOREACH(payload, h)
assert_se(streq(combined, payload));
}
static void test_catalog_update(const char *database) {
int r;
/* Test what happens if there are no files. */
r = catalog_update(database, NULL, NULL);
assert_se(r == 0);
/* Test what happens if there are no files in the directory. */
r = catalog_update(database, NULL, no_catalog_dirs);
assert_se(r == 0);
/* Make sure that we at least have some files loaded or the
* catalog_list below will fail. */
r = catalog_update(database, NULL, (const char * const *) catalog_dirs);
assert_se(r == 0);
}
static void test_catalog_file_lang(void) {
_cleanup_free_ char *lang = NULL, *lang2 = NULL, *lang3 = NULL, *lang4 = NULL;
assert_se(catalog_file_lang("systemd.de_DE.catalog", &lang) == 1);
assert_se(streq(lang, "de_DE"));
assert_se(catalog_file_lang("systemd..catalog", &lang2) == 0);
assert_se(lang2 == NULL);
assert_se(catalog_file_lang("systemd.fr.catalog", &lang2) == 1);
assert_se(streq(lang2, "fr"));
assert_se(catalog_file_lang("systemd.fr.catalog.gz", &lang3) == 0);
assert_se(lang3 == NULL);
assert_se(catalog_file_lang("systemd.01234567890123456789012345678901.catalog", &lang3) == 0);
assert_se(lang3 == NULL);
assert_se(catalog_file_lang("systemd.0123456789012345678901234567890.catalog", &lang3) == 1);
assert_se(streq(lang3, "0123456789012345678901234567890"));
assert_se(catalog_file_lang("/x/y/systemd.catalog", &lang4) == 0);
assert_se(lang4 == NULL);
assert_se(catalog_file_lang("/x/y/systemd.ru_RU.catalog", &lang4) == 1);
assert_se(streq(lang4, "ru_RU"));
}
int main(int argc, char *argv[]) {
_cleanup_(unlink_tempfilep) char database[] = "/tmp/test-catalog.XXXXXX";
_cleanup_close_ int fd = -EBADF;
_cleanup_free_ char *text = NULL;
int r;
setlocale(LC_ALL, "de_DE.UTF-8");
test_setup_logging(LOG_DEBUG);
/* If test-catalog is located at the build directory, then use catalogs in that.
* If it is not, e.g. installed by systemd-tests package, then use installed catalogs. */
catalog_dirs = STRV_MAKE(get_catalog_dir());
assert_se(access(catalog_dirs[0], F_OK) >= 0);
log_notice("Using catalog directory '%s'", catalog_dirs[0]);
test_catalog_file_lang();
test_catalog_import_invalid();
test_catalog_import_badid();
test_catalog_import_one();
test_catalog_import_merge();
test_catalog_import_merge_no_body();
assert_se((fd = mkostemp_safe(database)) >= 0);
test_catalog_update(database);
r = catalog_list(stdout, database, true);
assert_se(r >= 0);
r = catalog_list(stdout, database, false);
assert_se(r >= 0);
assert_se(catalog_get(database, SD_MESSAGE_COREDUMP, &text) >= 0);
printf(">>>%s<<<\n", text);
return 0;
}
| 6,897 | 28.228814 | 102 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/test-journal-enum.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <stdio.h>
#include "sd-journal.h"
#include "journal-internal.h"
#include "log.h"
#include "macro.h"
#include "tests.h"
int main(int argc, char *argv[]) {
unsigned n = 0;
_cleanup_(sd_journal_closep) sd_journal *j = NULL;
test_setup_logging(LOG_DEBUG);
assert_se(sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY) >= 0);
assert_se(sd_journal_add_match(j, "_TRANSPORT=syslog", 0) >= 0);
assert_se(sd_journal_add_match(j, "_UID=0", 0) >= 0);
SD_JOURNAL_FOREACH_BACKWARDS(j) {
const void *d;
size_t l;
assert_se(sd_journal_get_data(j, "MESSAGE", &d, &l) >= 0);
printf("%.*s\n", (int) l, (char*) d);
n++;
if (n >= 10)
break;
}
return 0;
}
| 888 | 22.394737 | 74 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/test-journal-file.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include "journal-file.h"
#include "tests.h"
#include "user-util.h"
static void test_journal_file_parse_uid_from_filename_simple(
const char *path,
uid_t expected_uid,
int expected_error) {
uid_t uid = UID_INVALID;
int r;
log_info("testing %s", path);
r = journal_file_parse_uid_from_filename(path, &uid);
assert_se(r == expected_error);
if (r < 0)
assert_se(uid == UID_INVALID);
else
assert_se(uid == expected_uid);
}
TEST(journal_file_parse_uid_from_filename) {
test_journal_file_parse_uid_from_filename_simple("/var/log/journal/", 0, -EISDIR);
/* The helper should return -EREMOTE for any filenames that don't look like an online or offline user
* journals. This includes archived and disposed journal files. */
test_journal_file_parse_uid_from_filename_simple("/etc/password", 0, -EREMOTE);
test_journal_file_parse_uid_from_filename_simple("system.journal", 0, -EREMOTE);
test_journal_file_parse_uid_from_filename_simple("[email protected]~", 0, -EREMOTE);
test_journal_file_parse_uid_from_filename_simple("[email protected]", 0, -EREMOTE);
test_journal_file_parse_uid_from_filename_simple("user-1000.journal", 1000, 0);
test_journal_file_parse_uid_from_filename_simple("user-foo.journal", 0, -EINVAL);
test_journal_file_parse_uid_from_filename_simple("user-65535.journal", 0, -ENXIO);
}
DEFINE_TEST_MAIN(LOG_INFO);
| 1,702 | 36.021739 | 126 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/test-journal-init.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <unistd.h>
#include "sd-journal.h"
#include "chattr-util.h"
#include "journal-internal.h"
#include "log.h"
#include "parse-util.h"
#include "process-util.h"
#include "rm-rf.h"
#include "tests.h"
int main(int argc, char *argv[]) {
sd_journal *j;
int r, i, I = 100;
char t[] = "/var/tmp/journal-stream-XXXXXX";
test_setup_logging(LOG_DEBUG);
if (argc >= 2) {
r = safe_atoi(argv[1], &I);
if (r < 0)
log_info("Could not parse loop count argument. Using default.");
}
log_info("Running %d loops", I);
assert_se(mkdtemp(t));
(void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL, NULL);
for (i = 0; i < I; i++) {
r = sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY);
assert_se(r == 0);
sd_journal_close(j);
r = sd_journal_open_directory(&j, t, 0);
assert_se(r == 0);
assert_se(sd_journal_seek_head(j) == 0);
assert_se(j->current_location.type == LOCATION_HEAD);
r = safe_fork("(journal-fork-test)", FORK_WAIT|FORK_LOG, NULL);
if (r == 0) {
assert_se(j);
assert_se(sd_journal_get_realtime_usec(j, NULL) == -ECHILD);
assert_se(sd_journal_seek_tail(j) == -ECHILD);
assert_se(j->current_location.type == LOCATION_HEAD);
sd_journal_close(j);
_exit(EXIT_SUCCESS);
}
assert_se(r >= 0);
sd_journal_close(j);
j = NULL;
r = sd_journal_open_directory(&j, t, SD_JOURNAL_LOCAL_ONLY);
assert_se(r == -EINVAL);
assert_se(j == NULL);
}
assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
return 0;
}
| 2,004 | 28.057971 | 88 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/test-journal-send.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include "sd-journal.h"
#include "fileio.h"
#include "journal-send.h"
#include "macro.h"
#include "memory-util.h"
#include "tests.h"
TEST(journal_print) {
assert_se(sd_journal_print(LOG_INFO, "XXX") == 0);
assert_se(sd_journal_print(LOG_INFO, "%s", "YYY") == 0);
assert_se(sd_journal_print(LOG_INFO, "X%4094sY", "ZZZ") == 0);
assert_se(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 3, "ZZZ") == 0);
assert_se(sd_journal_print(LOG_INFO, "X%*sY", (int) LONG_LINE_MAX - 8 - 2, "ZZZ") == -ENOBUFS);
}
TEST(journal_send) {
_cleanup_free_ char *huge = NULL;
#define HUGE_SIZE (4096*1024)
assert_se(huge = malloc(HUGE_SIZE));
/* utf-8 and non-utf-8, message-less and message-ful iovecs */
struct iovec graph1[] = {
{(char*) "GRAPH=graph", STRLEN("GRAPH=graph")}
};
struct iovec graph2[] = {
{(char*) "GRAPH=graph\n", STRLEN("GRAPH=graph\n")}
};
struct iovec message1[] = {
{(char*) "MESSAGE=graph", STRLEN("MESSAGE=graph")}
};
struct iovec message2[] = {
{(char*) "MESSAGE=graph\n", STRLEN("MESSAGE=graph\n")}
};
assert_se(sd_journal_print(LOG_INFO, "piepapo") == 0);
assert_se(sd_journal_send("MESSAGE=foobar",
"VALUE=%i", 7,
NULL) == 0);
errno = ENOENT;
assert_se(sd_journal_perror("Foobar") == 0);
assert_se(sd_journal_perror("") == 0);
memcpy(huge, "HUGE=", STRLEN("HUGE="));
memset(&huge[STRLEN("HUGE=")], 'x', HUGE_SIZE - STRLEN("HUGE=") - 1);
huge[HUGE_SIZE - 1] = '\0';
assert_se(sd_journal_send("MESSAGE=Huge field attached",
huge,
NULL) == 0);
assert_se(sd_journal_send("MESSAGE=uiui",
"VALUE=A",
"VALUE=B",
"VALUE=C",
"SINGLETON=1",
"OTHERVALUE=X",
"OTHERVALUE=Y",
"WITH_BINARY=this is a binary value \a",
NULL) == 0);
syslog(LOG_NOTICE, "Hello World!");
assert_se(sd_journal_print(LOG_NOTICE, "Hello World") == 0);
assert_se(sd_journal_send("MESSAGE=Hello World!",
"MESSAGE_ID=52fb62f99e2c49d89cfbf9d6de5e3555",
"PRIORITY=5",
"HOME=%s", getenv("HOME"),
"TERM=%s", getenv("TERM"),
"PAGE_SIZE=%li", sysconf(_SC_PAGESIZE),
"N_CPUS=%li", sysconf(_SC_NPROCESSORS_ONLN),
NULL) == 0);
assert_se(sd_journal_sendv(graph1, 1) == 0);
assert_se(sd_journal_sendv(graph2, 1) == 0);
assert_se(sd_journal_sendv(message1, 1) == 0);
assert_se(sd_journal_sendv(message2, 1) == 0);
/* test without location fields */
#undef sd_journal_sendv
assert_se(sd_journal_sendv(graph1, 1) == 0);
assert_se(sd_journal_sendv(graph2, 1) == 0);
assert_se(sd_journal_sendv(message1, 1) == 0);
assert_se(sd_journal_sendv(message2, 1) == 0);
/* The above syslog() opens a fd which is stored in libc, and the valgrind reports the fd is
* leaked when we do not call closelog(). */
closelog();
}
static int outro(void) {
/* Sleep a bit to make it easy for journald to collect metadata. */
sleep(1);
close_journal_fd();
return EXIT_SUCCESS;
}
DEFINE_TEST_MAIN_FULL(LOG_INFO, NULL, outro);
| 3,972 | 34.473214 | 103 |
c
|
null |
systemd-main/src/libsystemd/sd-journal/test-mmap-cache.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include "fd-util.h"
#include "macro.h"
#include "mmap-cache.h"
#include "tmpfile-util.h"
int main(int argc, char *argv[]) {
MMapFileDescriptor *fx;
int x, y, z, r;
char px[] = "/tmp/testmmapXXXXXXX", py[] = "/tmp/testmmapYXXXXXX", pz[] = "/tmp/testmmapZXXXXXX";
MMapCache *m;
void *p, *q;
assert_se(m = mmap_cache_new());
x = mkostemp_safe(px);
assert_se(x >= 0);
(void) unlink(px);
assert_se(fx = mmap_cache_add_fd(m, x, PROT_READ));
y = mkostemp_safe(py);
assert_se(y >= 0);
(void) unlink(py);
z = mkostemp_safe(pz);
assert_se(z >= 0);
(void) unlink(pz);
r = mmap_cache_fd_get(fx, 0, false, 1, 2, NULL, &p);
assert_se(r >= 0);
r = mmap_cache_fd_get(fx, 0, false, 2, 2, NULL, &q);
assert_se(r >= 0);
assert_se((uint8_t*) p + 1 == (uint8_t*) q);
r = mmap_cache_fd_get(fx, 1, false, 3, 2, NULL, &q);
assert_se(r >= 0);
assert_se((uint8_t*) p + 2 == (uint8_t*) q);
r = mmap_cache_fd_get(fx, 0, false, 16ULL*1024ULL*1024ULL, 2, NULL, &p);
assert_se(r >= 0);
r = mmap_cache_fd_get(fx, 1, false, 16ULL*1024ULL*1024ULL+1, 2, NULL, &q);
assert_se(r >= 0);
assert_se((uint8_t*) p + 1 == (uint8_t*) q);
mmap_cache_fd_free(fx);
mmap_cache_unref(m);
safe_close(x);
safe_close(y);
safe_close(z);
return 0;
}
| 1,626 | 23.651515 | 105 |
c
|
null |
systemd-main/src/libsystemd/sd-login/test-login.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <poll.h>
#include "sd-login.h"
#include "alloc-util.h"
#include "errno-list.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "missing_syscall.h"
#include "process-util.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"
#include "time-util.h"
#include "user-util.h"
static char* format_uids(char **buf, uid_t* uids, int count) {
int pos = 0, inc;
size_t size = (DECIMAL_STR_MAX(uid_t) + 1) * count + 1;
assert_se(*buf = malloc(size));
for (int k = 0; k < count; k++) {
sprintf(*buf + pos, "%s"UID_FMT"%n", k > 0 ? " " : "", uids[k], &inc);
pos += inc;
}
assert_se(pos < (ssize_t)size);
(*buf)[pos] = '\0';
return *buf;
}
static const char *e(int r) {
return r == 0 ? "OK" : errno_to_name(r);
}
TEST(login) {
_cleanup_close_pair_ int pair[2] = PIPE_EBADF;
_cleanup_free_ char *pp = NULL, *qq = NULL,
*display_session = NULL, *cgroup = NULL,
*display = NULL, *remote_user = NULL, *remote_host = NULL,
*type = NULL, *class = NULL, *state = NULL, *state2 = NULL,
*seat = NULL, *session = NULL,
*unit = NULL, *user_unit = NULL, *slice = NULL;
_cleanup_close_ int pidfd = -EBADF;
int r;
uid_t u, u2 = UID_INVALID;
char *t, **seats = NULL, **sessions = NULL;
r = sd_pid_get_unit(0, &unit);
log_info("sd_pid_get_unit(0, …) → %s / \"%s\"", e(r), strnull(unit));
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pid_get_user_unit(0, &user_unit);
log_info("sd_pid_get_user_unit(0, …) → %s / \"%s\"", e(r), strnull(user_unit));
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pid_get_slice(0, &slice);
log_info("sd_pid_get_slice(0, …) → %s / \"%s\"", e(r), strnull(slice));
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pid_get_owner_uid(0, &u2);
log_info("sd_pid_get_owner_uid(0, …) → %s / "UID_FMT, e(r), u2);
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pid_get_session(0, &session);
log_info("sd_pid_get_session(0, …) → %s / \"%s\"", e(r), strnull(session));
r = sd_pid_get_cgroup(0, &cgroup);
log_info("sd_pid_get_cgroup(0, …) → %s / \"%s\"", e(r), strnull(cgroup));
assert_se(IN_SET(r, 0, -ENOMEDIUM));
pidfd = pidfd_open(getpid_cached(), 0);
if (pidfd >= 0) {
_cleanup_free_ char *cgroup2 = NULL, *session2 = NULL,
*unit2 = NULL, *user_unit2 = NULL, *slice2 = NULL;
r = sd_pidfd_get_unit(pidfd, &unit2);
log_info("sd_pidfd_get_unit(pidfd, …) → %s / \"%s\"", e(r), strnull(unit2));
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pidfd_get_user_unit(pidfd, &user_unit2);
log_info("sd_pidfd_get_user_unit(pidfd, …) → %s / \"%s\"", e(r), strnull(user_unit2));
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pidfd_get_slice(pidfd, &slice2);
log_info("sd_pidfd_get_slice(pidfd, …) → %s / \"%s\"", e(r), strnull(slice2));
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pidfd_get_owner_uid(pidfd, &u2);
log_info("sd_pidfd_get_owner_uid(pidfd, …) → %s / "UID_FMT, e(r), u2);
assert_se(IN_SET(r, 0, -ENODATA));
r = sd_pidfd_get_session(pidfd, &session2);
log_info("sd_pidfd_get_session(pidfd, …) → %s / \"%s\"", e(r), strnull(session2));
r = sd_pidfd_get_cgroup(pidfd, &cgroup2);
log_info("sd_pidfd_get_cgroup(pidfd, …) → %s / \"%s\"", e(r), strnull(cgroup2));
assert_se(IN_SET(r, 0, -ENOMEDIUM));
}
r = sd_uid_get_display(u2, &display_session);
log_info("sd_uid_get_display("UID_FMT", …) → %s / \"%s\"", u2, e(r), strnull(display_session));
if (u2 == UID_INVALID)
assert_se(r == -EINVAL);
else
assert_se(IN_SET(r, 0, -ENODATA));
assert_se(socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == 0);
sd_peer_get_session(pair[0], &pp);
sd_peer_get_session(pair[1], &qq);
assert_se(streq_ptr(pp, qq));
r = sd_uid_get_sessions(u2, false, &sessions);
assert_se(t = strv_join(sessions, " "));
log_info("sd_uid_get_sessions("UID_FMT", …) → %s \"%s\"", u2, e(r), t);
if (u2 == UID_INVALID)
assert_se(r == -EINVAL);
else {
assert_se(r >= 0);
assert_se(r == (int) strv_length(sessions));
}
sessions = strv_free(sessions);
free(t);
assert_se(r == sd_uid_get_sessions(u2, false, NULL));
r = sd_uid_get_seats(u2, false, &seats);
assert_se(t = strv_join(seats, " "));
log_info("sd_uid_get_seats("UID_FMT", …) → %s \"%s\"", u2, e(r), t);
if (u2 == UID_INVALID)
assert_se(r == -EINVAL);
else {
assert_se(r >= 0);
assert_se(r == (int) strv_length(seats));
}
seats = strv_free(seats);
free(t);
assert_se(r == sd_uid_get_seats(u2, false, NULL));
if (session) {
r = sd_session_is_active(session);
if (r == -ENXIO)
log_notice("sd_session_is_active() failed with ENXIO, it seems logind is not running.");
else {
/* All those tests will fail with ENXIO, so let's skip them. */
assert_se(r >= 0);
log_info("sd_session_is_active(\"%s\") → %s", session, yes_no(r));
r = sd_session_is_remote(session);
assert_se(r >= 0);
log_info("sd_session_is_remote(\"%s\") → %s", session, yes_no(r));
r = sd_session_get_state(session, &state);
assert_se(r == 0);
log_info("sd_session_get_state(\"%s\") → \"%s\"", session, state);
assert_se(sd_session_get_uid(session, &u) >= 0);
log_info("sd_session_get_uid(\"%s\") → "UID_FMT, session, u);
assert_se(u == u2);
assert_se(sd_session_get_type(session, &type) >= 0);
log_info("sd_session_get_type(\"%s\") → \"%s\"", session, type);
assert_se(sd_session_get_class(session, &class) >= 0);
log_info("sd_session_get_class(\"%s\") → \"%s\"", session, class);
r = sd_session_get_display(session, &display);
assert_se(IN_SET(r, 0, -ENODATA));
log_info("sd_session_get_display(\"%s\") → \"%s\"", session, strna(display));
r = sd_session_get_remote_user(session, &remote_user);
assert_se(IN_SET(r, 0, -ENODATA));
log_info("sd_session_get_remote_user(\"%s\") → \"%s\"",
session, strna(remote_user));
r = sd_session_get_remote_host(session, &remote_host);
assert_se(IN_SET(r, 0, -ENODATA));
log_info("sd_session_get_remote_host(\"%s\") → \"%s\"",
session, strna(remote_host));
r = sd_session_get_seat(session, &seat);
if (r >= 0) {
assert_se(seat);
log_info("sd_session_get_seat(\"%s\") → \"%s\"", session, seat);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
r = sd_seat_can_multi_session(seat);
#pragma GCC diagnostic pop
assert_se(r == 1);
log_info("sd_session_can_multi_seat(\"%s\") → %s", seat, yes_no(r));
r = sd_seat_can_tty(seat);
assert_se(r >= 0);
log_info("sd_session_can_tty(\"%s\") → %s", seat, yes_no(r));
r = sd_seat_can_graphical(seat);
assert_se(r >= 0);
log_info("sd_session_can_graphical(\"%s\") → %s", seat, yes_no(r));
} else {
log_info_errno(r, "sd_session_get_seat(\"%s\"): %m", session);
assert_se(r == -ENODATA);
}
assert_se(sd_uid_get_state(u, &state2) == 0);
log_info("sd_uid_get_state("UID_FMT", …) → %s", u, state2);
}
}
if (seat) {
_cleanup_free_ char *session2 = NULL, *buf = NULL;
_cleanup_free_ uid_t *uids = NULL;
unsigned n;
assert_se(sd_uid_is_on_seat(u, 0, seat) > 0);
r = sd_seat_get_active(seat, &session2, &u2);
assert_se(r == 0);
log_info("sd_seat_get_active(\"%s\", …) → \"%s\", "UID_FMT, seat, session2, u2);
r = sd_uid_is_on_seat(u, 1, seat);
assert_se(IN_SET(r, 0, 1));
assert_se(!!r == streq(session, session2));
r = sd_seat_get_sessions(seat, &sessions, &uids, &n);
assert_se(r >= 0);
assert_se(r == (int) strv_length(sessions));
assert_se(t = strv_join(sessions, " "));
strv_free(sessions);
log_info("sd_seat_get_sessions(\"%s\", …) → %s, \"%s\", [%u] {%s}",
seat, e(r), t, n, format_uids(&buf, uids, n));
free(t);
assert_se(sd_seat_get_sessions(seat, NULL, NULL, NULL) == r);
}
r = sd_get_seats(&seats);
assert_se(r >= 0);
assert_se(r == (int) strv_length(seats));
assert_se(t = strv_join(seats, ", "));
strv_free(seats);
log_info("sd_get_seats(…) → [%i] \"%s\"", r, t);
t = mfree(t);
assert_se(sd_get_seats(NULL) == r);
r = sd_seat_get_active(NULL, &t, NULL);
assert_se(IN_SET(r, 0, -ENODATA, -ENXIO));
log_info("sd_seat_get_active(NULL, …) (active session on current seat) → %s / \"%s\"", e(r), strnull(t));
free(t);
r = sd_get_sessions(&sessions);
assert_se(r >= 0);
assert_se(r == (int) strv_length(sessions));
assert_se(t = strv_join(sessions, ", "));
strv_free(sessions);
log_info("sd_get_sessions(…) → [%i] \"%s\"", r, t);
free(t);
assert_se(sd_get_sessions(NULL) == r);
{
_cleanup_free_ uid_t *uids = NULL;
_cleanup_free_ char *buf = NULL;
r = sd_get_uids(&uids);
assert_se(r >= 0);
log_info("sd_get_uids(…) → [%i] {%s}", r, format_uids(&buf, uids, r));
assert_se(sd_get_uids(NULL) == r);
}
{
_cleanup_strv_free_ char **machines = NULL;
_cleanup_free_ char *buf = NULL;
r = sd_get_machine_names(&machines);
assert_se(r >= 0);
assert_se(r == (int) strv_length(machines));
assert_se(buf = strv_join(machines, " "));
log_info("sd_get_machines(…) → [%i] \"%s\"", r, buf);
assert_se(sd_get_machine_names(NULL) == r);
}
}
TEST(monitor) {
sd_login_monitor *m = NULL;
int r;
if (!streq_ptr(saved_argv[1], "-m"))
return;
assert_se(sd_login_monitor_new("session", &m) == 0);
for (unsigned n = 0; n < 5; n++) {
struct pollfd pollfd = {};
usec_t timeout, nw;
assert_se((pollfd.fd = sd_login_monitor_get_fd(m)) >= 0);
assert_se((pollfd.events = sd_login_monitor_get_events(m)) >= 0);
assert_se(sd_login_monitor_get_timeout(m, &timeout) >= 0);
nw = now(CLOCK_MONOTONIC);
r = poll(&pollfd, 1,
timeout == UINT64_MAX ? -1 :
timeout > nw ? (int) ((timeout - nw) / 1000) :
0);
assert_se(r >= 0);
sd_login_monitor_flush(m);
printf("Wake!\n");
}
sd_login_monitor_unref(m);
}
static int intro(void) {
log_info("/* Information printed is from the live system */");
return EXIT_SUCCESS;
}
DEFINE_TEST_MAIN_WITH_INTRO(LOG_INFO, intro);
| 12,855 | 37.376119 | 113 |
c
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <linux/netlink.h>
#include "sd-netlink.h"
#include "list.h"
#include "netlink-types.h"
#include "ordered-set.h"
#include "prioq.h"
#include "time-util.h"
#define NETLINK_DEFAULT_TIMEOUT_USEC ((usec_t) (25 * USEC_PER_SEC))
#define NETLINK_RQUEUE_MAX 64*1024
#define NETLINK_CONTAINER_DEPTH 32
struct reply_callback {
sd_netlink_message_handler_t callback;
usec_t timeout;
uint32_t serial;
unsigned prioq_idx;
};
struct match_callback {
sd_netlink_message_handler_t callback;
uint32_t *groups;
size_t n_groups;
uint16_t type;
uint8_t cmd; /* used by genl */
LIST_FIELDS(struct match_callback, match_callbacks);
};
typedef enum NetlinkSlotType {
NETLINK_REPLY_CALLBACK,
NETLINK_MATCH_CALLBACK,
_NETLINK_SLOT_INVALID = -EINVAL,
} NetlinkSlotType;
struct sd_netlink_slot {
unsigned n_ref;
NetlinkSlotType type:8;
bool floating;
sd_netlink *netlink;
void *userdata;
sd_netlink_destroy_t destroy_callback;
char *description;
LIST_FIELDS(sd_netlink_slot, slots);
union {
struct reply_callback reply_callback;
struct match_callback match_callback;
};
};
struct sd_netlink {
unsigned n_ref;
int fd;
union {
struct sockaddr sa;
struct sockaddr_nl nl;
} sockaddr;
int protocol;
Hashmap *broadcast_group_refs;
bool broadcast_group_dont_leave:1; /* until we can rely on 4.2 */
OrderedSet *rqueue;
Hashmap *rqueue_by_serial;
Hashmap *rqueue_partial_by_serial;
struct nlmsghdr *rbuffer;
bool processing:1;
uint32_t serial;
struct Prioq *reply_callbacks_prioq;
Hashmap *reply_callbacks;
LIST_HEAD(struct match_callback, match_callbacks);
LIST_HEAD(sd_netlink_slot, slots);
pid_t original_pid;
sd_event_source *io_event_source;
sd_event_source *time_event_source;
sd_event_source *exit_event_source;
sd_event *event;
Hashmap *genl_family_by_name;
Hashmap *genl_family_by_id;
};
struct netlink_attribute {
size_t offset; /* offset from hdr to attribute */
bool nested:1;
bool net_byteorder:1;
};
struct netlink_container {
const struct NLAPolicySet *policy_set; /* the policy set of the container */
size_t offset; /* offset from hdr to the start of the container */
struct netlink_attribute *attributes;
uint16_t max_attribute; /* the maximum attribute in container */
};
struct sd_netlink_message {
unsigned n_ref;
int protocol;
struct nlmsghdr *hdr;
struct netlink_container containers[NETLINK_CONTAINER_DEPTH];
unsigned n_containers; /* number of containers */
uint32_t multicast_group;
bool sealed:1;
sd_netlink_message *next; /* next in a chain of multi-part messages */
};
int message_new_empty(sd_netlink *nl, sd_netlink_message **ret);
int message_new_full(
sd_netlink *nl,
uint16_t nlmsg_type,
const NLAPolicySet *policy_set,
size_t header_size,
sd_netlink_message **ret);
int message_new(sd_netlink *nl, sd_netlink_message **ret, uint16_t type);
int message_new_synthetic_error(sd_netlink *nl, int error, uint32_t serial, sd_netlink_message **ret);
static inline uint32_t message_get_serial(sd_netlink_message *m) {
assert(m);
return ASSERT_PTR(m->hdr)->nlmsg_seq;
}
void message_seal(sd_netlink_message *m);
int netlink_open_family(sd_netlink **ret, int family);
bool netlink_pid_changed(sd_netlink *nl);
int socket_bind(sd_netlink *nl);
int socket_broadcast_group_ref(sd_netlink *nl, unsigned group);
int socket_broadcast_group_unref(sd_netlink *nl, unsigned group);
int socket_write_message(sd_netlink *nl, sd_netlink_message *m);
int socket_read_message(sd_netlink *nl);
int netlink_add_match_internal(
sd_netlink *nl,
sd_netlink_slot **ret_slot,
const uint32_t *groups,
size_t n_groups,
uint16_t type,
uint8_t cmd,
sd_netlink_message_handler_t callback,
sd_netlink_destroy_t destroy_callback,
void *userdata,
const char *description);
/* Make sure callbacks don't destroy the netlink connection */
#define NETLINK_DONT_DESTROY(nl) \
_cleanup_(sd_netlink_unrefp) _unused_ sd_netlink *_dont_destroy_##nl = sd_netlink_ref(nl)
/* nfnl */
/* TODO: to be exported later */
int sd_nfnl_socket_open(sd_netlink **ret);
int sd_nfnl_send_batch(
sd_netlink *nfnl,
sd_netlink_message **messages,
size_t msgcount,
uint32_t **ret_serials);
int sd_nfnl_call_batch(
sd_netlink *nfnl,
sd_netlink_message **messages,
size_t n_messages,
uint64_t usec,
sd_netlink_message ***ret_messages);
int sd_nfnl_message_new(
sd_netlink *nfnl,
sd_netlink_message **ret,
int nfproto,
uint16_t subsys,
uint16_t msg_type,
uint16_t flags);
int sd_nfnl_nft_message_new_table(sd_netlink *nfnl, sd_netlink_message **ret,
int nfproto, const char *table);
int sd_nfnl_nft_message_new_basechain(sd_netlink *nfnl, sd_netlink_message **ret,
int nfproto, const char *table, const char *chain,
const char *type, uint8_t hook, int prio);
int sd_nfnl_nft_message_new_rule(sd_netlink *nfnl, sd_netlink_message **ret,
int nfproto, const char *table, const char *chain);
int sd_nfnl_nft_message_new_set(sd_netlink *nfnl, sd_netlink_message **ret,
int nfproto, const char *table, const char *set_name,
uint32_t setid, uint32_t klen);
int sd_nfnl_nft_message_new_setelems(sd_netlink *nfnl, sd_netlink_message **ret,
int add, int nfproto, const char *table, const char *set_name);
int sd_nfnl_nft_message_append_setelem(sd_netlink_message *m,
uint32_t index,
const void *key, size_t key_len,
const void *data, size_t data_len,
uint32_t flags);
| 6,765 | 31.066351 | 102 |
h
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-message-nfnl.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <linux/netfilter/nfnetlink.h>
#include <linux/netfilter/nf_tables.h>
#include <linux/netfilter.h>
#include "sd-netlink.h"
#include "io-util.h"
#include "netlink-internal.h"
#include "netlink-types.h"
#include "netlink-util.h"
static bool nfproto_is_valid(int nfproto) {
return IN_SET(nfproto,
NFPROTO_UNSPEC,
NFPROTO_INET,
NFPROTO_IPV4,
NFPROTO_ARP,
NFPROTO_NETDEV,
NFPROTO_BRIDGE,
NFPROTO_IPV6,
NFPROTO_DECNET);
}
int sd_nfnl_message_new(sd_netlink *nfnl, sd_netlink_message **ret, int nfproto, uint16_t subsys, uint16_t msg_type, uint16_t flags) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert_return(nfnl, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(nfproto_is_valid(nfproto), -EINVAL);
assert_return(NFNL_MSG_TYPE(msg_type) == msg_type, -EINVAL);
r = message_new(nfnl, &m, subsys << 8 | msg_type);
if (r < 0)
return r;
m->hdr->nlmsg_flags |= flags;
*(struct nfgenmsg*) NLMSG_DATA(m->hdr) = (struct nfgenmsg) {
.nfgen_family = nfproto,
.version = NFNETLINK_V0,
};
*ret = TAKE_PTR(m);
return 0;
}
static int nfnl_message_set_res_id(sd_netlink_message *m, uint16_t res_id) {
struct nfgenmsg *nfgen;
assert(m);
assert(m->hdr);
nfgen = NLMSG_DATA(m->hdr);
nfgen->res_id = htobe16(res_id);
return 0;
}
static int nfnl_message_get_subsys(sd_netlink_message *m, uint16_t *ret) {
uint16_t t;
int r;
assert(m);
assert(ret);
r = sd_netlink_message_get_type(m, &t);
if (r < 0)
return r;
*ret = NFNL_SUBSYS_ID(t);
return 0;
}
static int nfnl_message_new_batch(sd_netlink *nfnl, sd_netlink_message **ret, uint16_t subsys, uint16_t msg_type) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert_return(nfnl, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(NFNL_MSG_TYPE(msg_type) == msg_type, -EINVAL);
r = sd_nfnl_message_new(nfnl, &m, NFPROTO_UNSPEC, NFNL_SUBSYS_NONE, msg_type, 0);
if (r < 0)
return r;
r = nfnl_message_set_res_id(m, subsys);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return 0;
}
int sd_nfnl_send_batch(
sd_netlink *nfnl,
sd_netlink_message **messages,
size_t n_messages,
uint32_t **ret_serials) {
/* iovs refs batch_begin and batch_end, hence, free iovs first, then free batch_begin and batch_end. */
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *batch_begin = NULL, *batch_end = NULL;
_cleanup_free_ struct iovec *iovs = NULL;
_cleanup_free_ uint32_t *serials = NULL;
uint16_t subsys;
ssize_t k;
size_t c = 0;
int r;
assert_return(nfnl, -EINVAL);
assert_return(!netlink_pid_changed(nfnl), -ECHILD);
assert_return(messages, -EINVAL);
assert_return(n_messages > 0, -EINVAL);
iovs = new(struct iovec, n_messages + 2);
if (!iovs)
return -ENOMEM;
if (ret_serials) {
serials = new(uint32_t, n_messages);
if (!serials)
return -ENOMEM;
}
r = nfnl_message_get_subsys(messages[0], &subsys);
if (r < 0)
return r;
r = nfnl_message_new_batch(nfnl, &batch_begin, subsys, NFNL_MSG_BATCH_BEGIN);
if (r < 0)
return r;
netlink_seal_message(nfnl, batch_begin);
iovs[c++] = IOVEC_MAKE(batch_begin->hdr, batch_begin->hdr->nlmsg_len);
for (size_t i = 0; i < n_messages; i++) {
uint16_t s;
r = nfnl_message_get_subsys(messages[i], &s);
if (r < 0)
return r;
if (s != subsys)
return -EINVAL;
netlink_seal_message(nfnl, messages[i]);
if (serials)
serials[i] = message_get_serial(messages[i]);
/* It seems that the kernel accepts an arbitrary number. Let's set the serial of the
* first message. */
nfnl_message_set_res_id(messages[i], message_get_serial(batch_begin));
iovs[c++] = IOVEC_MAKE(messages[i]->hdr, messages[i]->hdr->nlmsg_len);
}
r = nfnl_message_new_batch(nfnl, &batch_end, subsys, NFNL_MSG_BATCH_END);
if (r < 0)
return r;
netlink_seal_message(nfnl, batch_end);
iovs[c++] = IOVEC_MAKE(batch_end->hdr, batch_end->hdr->nlmsg_len);
assert(c == n_messages + 2);
k = writev(nfnl->fd, iovs, n_messages + 2);
if (k < 0)
return -errno;
if (ret_serials)
*ret_serials = TAKE_PTR(serials);
return 0;
}
int sd_nfnl_call_batch(
sd_netlink *nfnl,
sd_netlink_message **messages,
size_t n_messages,
uint64_t usec,
sd_netlink_message ***ret_messages) {
_cleanup_free_ sd_netlink_message **replies = NULL;
_cleanup_free_ uint32_t *serials = NULL;
int k, r;
assert_return(nfnl, -EINVAL);
assert_return(!netlink_pid_changed(nfnl), -ECHILD);
assert_return(messages, -EINVAL);
assert_return(n_messages > 0, -EINVAL);
if (ret_messages) {
replies = new0(sd_netlink_message*, n_messages);
if (!replies)
return -ENOMEM;
}
r = sd_nfnl_send_batch(nfnl, messages, n_messages, &serials);
if (r < 0)
return r;
for (size_t i = 0; i < n_messages; i++) {
k = sd_netlink_read(nfnl, serials[i], usec, ret_messages ? replies + i : NULL);
if (k < 0 && r >= 0)
r = k;
}
if (r < 0)
return r;
if (ret_messages)
*ret_messages = TAKE_PTR(replies);
return 0;
}
int sd_nfnl_nft_message_new_basechain(
sd_netlink *nfnl,
sd_netlink_message **ret,
int nfproto,
const char *table,
const char *chain,
const char *type,
uint8_t hook,
int prio) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
r = sd_nfnl_message_new(nfnl, &m, nfproto, NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWCHAIN, NLM_F_CREATE);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_CHAIN_TABLE, table);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_CHAIN_NAME, chain);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_CHAIN_TYPE, type);
if (r < 0)
return r;
r = sd_netlink_message_open_container(m, NFTA_CHAIN_HOOK);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, NFTA_HOOK_HOOKNUM, htobe32(hook));
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, NFTA_HOOK_PRIORITY, htobe32(prio));
if (r < 0)
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return 0;
}
int sd_nfnl_nft_message_new_table(
sd_netlink *nfnl,
sd_netlink_message **ret,
int nfproto,
const char *table) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
r = sd_nfnl_message_new(nfnl, &m, nfproto, NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWTABLE, NLM_F_CREATE | NLM_F_EXCL);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_TABLE_NAME, table);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return r;
}
int sd_nfnl_nft_message_new_rule(
sd_netlink *nfnl,
sd_netlink_message **ret,
int nfproto,
const char *table,
const char *chain) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
r = sd_nfnl_message_new(nfnl, &m, nfproto, NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWRULE, NLM_F_CREATE);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_RULE_TABLE, table);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_RULE_CHAIN, chain);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return r;
}
int sd_nfnl_nft_message_new_set(
sd_netlink *nfnl,
sd_netlink_message **ret,
int nfproto,
const char *table,
const char *set_name,
uint32_t set_id,
uint32_t klen) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
r = sd_nfnl_message_new(nfnl, &m, nfproto, NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWSET, NLM_F_CREATE);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_SET_TABLE, table);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_SET_NAME, set_name);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, NFTA_SET_ID, ++set_id);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, NFTA_SET_KEY_LEN, htobe32(klen));
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return r;
}
int sd_nfnl_nft_message_new_setelems(
sd_netlink *nfnl,
sd_netlink_message **ret,
int add, /* boolean */
int nfproto,
const char *table,
const char *set_name) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
if (add)
r = sd_nfnl_message_new(nfnl, &m, nfproto, NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWSETELEM, NLM_F_CREATE);
else
r = sd_nfnl_message_new(nfnl, &m, nfproto, NFNL_SUBSYS_NFTABLES, NFT_MSG_DELSETELEM, 0);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_SET_ELEM_LIST_TABLE, table);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NFTA_SET_ELEM_LIST_SET, set_name);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return r;
}
int sd_nfnl_nft_message_append_setelem(
sd_netlink_message *m,
uint32_t index,
const void *key,
size_t key_len,
const void *data,
size_t data_len,
uint32_t flags) {
int r;
r = sd_netlink_message_open_array(m, index);
if (r < 0)
return r;
r = sd_netlink_message_append_container_data(m, NFTA_SET_ELEM_KEY, NFTA_DATA_VALUE, key, key_len);
if (r < 0)
goto cancel;
if (data) {
r = sd_netlink_message_append_container_data(m, NFTA_SET_ELEM_DATA, NFTA_DATA_VALUE, data, data_len);
if (r < 0)
goto cancel;
}
if (flags != 0) {
r = sd_netlink_message_append_u32(m, NFTA_SET_ELEM_FLAGS, htobe32(flags));
if (r < 0)
goto cancel;
}
return sd_netlink_message_close_container(m); /* array */
cancel:
(void) sd_netlink_message_cancel_array(m);
return r;
}
int sd_nfnl_socket_open(sd_netlink **ret) {
return netlink_open_family(ret, NETLINK_NETFILTER);
}
| 12,470 | 28.622328 | 134 |
c
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-slot.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "sd-netlink.h"
#include "alloc-util.h"
#include "netlink-internal.h"
#include "netlink-slot.h"
#include "string-util.h"
int netlink_slot_allocate(
sd_netlink *nl,
bool floating,
NetlinkSlotType type,
size_t extra,
void *userdata,
const char *description,
sd_netlink_slot **ret) {
_cleanup_free_ sd_netlink_slot *slot = NULL;
assert(nl);
assert(ret);
slot = malloc0(offsetof(sd_netlink_slot, reply_callback) + extra);
if (!slot)
return -ENOMEM;
slot->n_ref = 1;
slot->netlink = nl;
slot->userdata = userdata;
slot->type = type;
slot->floating = floating;
if (description) {
slot->description = strdup(description);
if (!slot->description)
return -ENOMEM;
}
if (!floating)
sd_netlink_ref(nl);
LIST_PREPEND(slots, nl->slots, slot);
*ret = TAKE_PTR(slot);
return 0;
}
void netlink_slot_disconnect(sd_netlink_slot *slot, bool unref) {
sd_netlink *nl;
assert(slot);
nl = slot->netlink;
if (!nl)
return;
switch (slot->type) {
case NETLINK_REPLY_CALLBACK:
(void) hashmap_remove(nl->reply_callbacks, &slot->reply_callback.serial);
if (slot->reply_callback.timeout != 0)
prioq_remove(nl->reply_callbacks_prioq, &slot->reply_callback, &slot->reply_callback.prioq_idx);
break;
case NETLINK_MATCH_CALLBACK:
LIST_REMOVE(match_callbacks, nl->match_callbacks, &slot->match_callback);
for (size_t i = 0; i < slot->match_callback.n_groups; i++)
(void) socket_broadcast_group_unref(nl, slot->match_callback.groups[i]);
slot->match_callback.n_groups = 0;
slot->match_callback.groups = mfree(slot->match_callback.groups);
break;
default:
assert_not_reached();
}
slot->type = _NETLINK_SLOT_INVALID;
slot->netlink = NULL;
LIST_REMOVE(slots, nl->slots, slot);
if (!slot->floating)
sd_netlink_unref(nl);
else if (unref)
sd_netlink_slot_unref(slot);
}
static sd_netlink_slot* netlink_slot_free(sd_netlink_slot *slot) {
assert(slot);
netlink_slot_disconnect(slot, false);
if (slot->destroy_callback)
slot->destroy_callback(slot->userdata);
free(slot->description);
return mfree(slot);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(sd_netlink_slot, sd_netlink_slot, netlink_slot_free);
sd_netlink *sd_netlink_slot_get_netlink(sd_netlink_slot *slot) {
assert_return(slot, NULL);
return slot->netlink;
}
void *sd_netlink_slot_get_userdata(sd_netlink_slot *slot) {
assert_return(slot, NULL);
return slot->userdata;
}
void *sd_netlink_slot_set_userdata(sd_netlink_slot *slot, void *userdata) {
void *ret;
assert_return(slot, NULL);
ret = slot->userdata;
slot->userdata = userdata;
return ret;
}
int sd_netlink_slot_get_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t *callback) {
assert_return(slot, -EINVAL);
if (callback)
*callback = slot->destroy_callback;
return !!slot->destroy_callback;
}
int sd_netlink_slot_set_destroy_callback(sd_netlink_slot *slot, sd_netlink_destroy_t callback) {
assert_return(slot, -EINVAL);
slot->destroy_callback = callback;
return 0;
}
int sd_netlink_slot_get_floating(sd_netlink_slot *slot) {
assert_return(slot, -EINVAL);
return slot->floating;
}
int sd_netlink_slot_set_floating(sd_netlink_slot *slot, int b) {
assert_return(slot, -EINVAL);
if (slot->floating == !!b)
return 0;
if (!slot->netlink) /* Already disconnected */
return -ESTALE;
slot->floating = b;
if (b) {
sd_netlink_slot_ref(slot);
sd_netlink_unref(slot->netlink);
} else {
sd_netlink_ref(slot->netlink);
sd_netlink_slot_unref(slot);
}
return 1;
}
int sd_netlink_slot_get_description(sd_netlink_slot *slot, const char **description) {
assert_return(slot, -EINVAL);
if (description)
*description = slot->description;
return !!slot->description;
}
int sd_netlink_slot_set_description(sd_netlink_slot *slot, const char *description) {
assert_return(slot, -EINVAL);
return free_and_strdup(&slot->description, description);
}
| 4,926 | 25.068783 | 120 |
c
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-socket.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <malloc.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <unistd.h>
#include "sd-netlink.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "io-util.h"
#include "netlink-internal.h"
#include "netlink-types.h"
#include "socket-util.h"
static int broadcast_groups_get(sd_netlink *nl) {
_cleanup_free_ uint32_t *groups = NULL;
socklen_t len = 0, old_len;
int r;
assert(nl);
assert(nl->fd >= 0);
if (getsockopt(nl->fd, SOL_NETLINK, NETLINK_LIST_MEMBERSHIPS, NULL, &len) < 0) {
if (errno != ENOPROTOOPT)
return -errno;
nl->broadcast_group_dont_leave = true;
return 0;
}
if (len == 0)
return 0;
groups = new0(uint32_t, len);
if (!groups)
return -ENOMEM;
old_len = len;
if (getsockopt(nl->fd, SOL_NETLINK, NETLINK_LIST_MEMBERSHIPS, groups, &len) < 0)
return -errno;
if (old_len != len)
return -EIO;
for (unsigned i = 0; i < len; i++)
for (unsigned j = 0; j < sizeof(uint32_t) * 8; j++)
if (groups[i] & (1U << j)) {
unsigned group = i * sizeof(uint32_t) * 8 + j + 1;
r = hashmap_ensure_put(&nl->broadcast_group_refs, NULL, UINT_TO_PTR(group), UINT_TO_PTR(1));
if (r < 0)
return r;
}
return 0;
}
int socket_bind(sd_netlink *nl) {
socklen_t addrlen;
int r;
r = setsockopt_int(nl->fd, SOL_NETLINK, NETLINK_PKTINFO, true);
if (r < 0)
return r;
addrlen = sizeof(nl->sockaddr);
/* ignore EINVAL to allow binding an already bound socket */
if (bind(nl->fd, &nl->sockaddr.sa, addrlen) < 0 && errno != EINVAL)
return -errno;
if (getsockname(nl->fd, &nl->sockaddr.sa, &addrlen) < 0)
return -errno;
return broadcast_groups_get(nl);
}
static unsigned broadcast_group_get_ref(sd_netlink *nl, unsigned group) {
assert(nl);
return PTR_TO_UINT(hashmap_get(nl->broadcast_group_refs, UINT_TO_PTR(group)));
}
static int broadcast_group_set_ref(sd_netlink *nl, unsigned group, unsigned n_ref) {
int r;
assert(nl);
r = hashmap_ensure_allocated(&nl->broadcast_group_refs, NULL);
if (r < 0)
return r;
return hashmap_replace(nl->broadcast_group_refs, UINT_TO_PTR(group), UINT_TO_PTR(n_ref));
}
static int broadcast_group_join(sd_netlink *nl, unsigned group) {
assert(nl);
assert(nl->fd >= 0);
assert(group > 0);
/* group is "unsigned", but netlink(7) says the argument for NETLINK_ADD_MEMBERSHIP is "int" */
return setsockopt_int(nl->fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, group);
}
int socket_broadcast_group_ref(sd_netlink *nl, unsigned group) {
unsigned n_ref;
int r;
assert(nl);
n_ref = broadcast_group_get_ref(nl, group);
n_ref++;
r = broadcast_group_set_ref(nl, group, n_ref);
if (r < 0)
return r;
if (n_ref > 1)
/* already in the group */
return 0;
return broadcast_group_join(nl, group);
}
static int broadcast_group_leave(sd_netlink *nl, unsigned group) {
assert(nl);
assert(nl->fd >= 0);
assert(group > 0);
if (nl->broadcast_group_dont_leave)
return 0;
/* group is "unsigned", but netlink(7) says the argument for NETLINK_DROP_MEMBERSHIP is "int" */
return setsockopt_int(nl->fd, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP, group);
}
int socket_broadcast_group_unref(sd_netlink *nl, unsigned group) {
unsigned n_ref;
int r;
assert(nl);
n_ref = broadcast_group_get_ref(nl, group);
if (n_ref == 0)
return 0;
n_ref--;
r = broadcast_group_set_ref(nl, group, n_ref);
if (r < 0)
return r;
if (n_ref > 0)
/* still refs left */
return 0;
return broadcast_group_leave(nl, group);
}
/* returns the number of bytes sent, or a negative error code */
int socket_write_message(sd_netlink *nl, sd_netlink_message *m) {
union sockaddr_union addr = {
.nl.nl_family = AF_NETLINK,
};
ssize_t k;
assert(nl);
assert(m);
assert(m->hdr);
k = sendto(nl->fd, m->hdr, m->hdr->nlmsg_len, 0, &addr.sa, sizeof(addr));
if (k < 0)
return -errno;
return k;
}
static int socket_recv_message(int fd, void *buf, size_t buf_size, uint32_t *ret_mcast_group, bool peek) {
struct iovec iov = IOVEC_MAKE(buf, buf_size);
union sockaddr_union sender;
CMSG_BUFFER_TYPE(CMSG_SPACE(sizeof(struct nl_pktinfo))) control;
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_name = &sender,
.msg_namelen = sizeof(sender),
.msg_control = &control,
.msg_controllen = sizeof(control),
};
ssize_t n;
assert(fd >= 0);
assert(peek || (buf && buf_size > 0));
n = recvmsg_safe(fd, &msg, MSG_TRUNC | (peek ? MSG_PEEK : 0));
if (n < 0) {
if (n == -ENOBUFS)
return log_debug_errno(n, "sd-netlink: kernel receive buffer overrun");
if (ERRNO_IS_TRANSIENT(n)) {
if (ret_mcast_group)
*ret_mcast_group = 0;
return 0;
}
return (int) n;
}
if (sender.nl.nl_pid != 0) {
/* not from the kernel, ignore */
log_debug("sd-netlink: ignoring message from PID %"PRIu32, sender.nl.nl_pid);
if (peek) {
/* drop the message */
n = recvmsg_safe(fd, &msg, 0);
if (n < 0)
return (int) n;
}
if (ret_mcast_group)
*ret_mcast_group = 0;
return 0;
}
if (!peek && (size_t) n > buf_size) /* message did not fit in read buffer */
return -EIO;
if (ret_mcast_group) {
struct nl_pktinfo *pi;
pi = CMSG_FIND_DATA(&msg, SOL_NETLINK, NETLINK_PKTINFO, struct nl_pktinfo);
if (pi)
*ret_mcast_group = pi->group;
else
*ret_mcast_group = 0;
}
return (int) n;
}
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
netlink_message_hash_ops,
void, trivial_hash_func, trivial_compare_func,
sd_netlink_message, sd_netlink_message_unref);
static int netlink_queue_received_message(sd_netlink *nl, sd_netlink_message *m) {
uint32_t serial;
int r;
assert(nl);
assert(m);
if (ordered_set_size(nl->rqueue) >= NETLINK_RQUEUE_MAX)
return log_debug_errno(SYNTHETIC_ERRNO(ENOBUFS),
"sd-netlink: exhausted the read queue size (%d)", NETLINK_RQUEUE_MAX);
r = ordered_set_ensure_put(&nl->rqueue, &netlink_message_hash_ops, m);
if (r < 0)
return r;
sd_netlink_message_ref(m);
if (sd_netlink_message_is_broadcast(m))
return 0;
serial = message_get_serial(m);
if (serial == 0)
return 0;
if (sd_netlink_message_get_errno(m) < 0) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *old = NULL;
old = hashmap_remove(nl->rqueue_by_serial, UINT32_TO_PTR(serial));
if (old)
log_debug("sd-netlink: received error message with serial %"PRIu32", but another message with "
"the same serial is already stored in the read queue, replacing.", serial);
}
r = hashmap_ensure_put(&nl->rqueue_by_serial, &netlink_message_hash_ops, UINT32_TO_PTR(serial), m);
if (r == -EEXIST) {
if (!sd_netlink_message_is_error(m))
log_debug("sd-netlink: received message with serial %"PRIu32", but another message with "
"the same serial is already stored in the read queue, ignoring.", serial);
return 0;
}
if (r < 0) {
sd_netlink_message_unref(ordered_set_remove(nl->rqueue, m));
return r;
}
sd_netlink_message_ref(m);
return 0;
}
static int netlink_queue_partially_received_message(sd_netlink *nl, sd_netlink_message *m) {
uint32_t serial;
int r;
assert(nl);
assert(m);
assert(m->hdr->nlmsg_flags & NLM_F_MULTI);
if (hashmap_size(nl->rqueue_partial_by_serial) >= NETLINK_RQUEUE_MAX)
return log_debug_errno(SYNTHETIC_ERRNO(ENOBUFS),
"sd-netlink: exhausted the partial read queue size (%d)", NETLINK_RQUEUE_MAX);
serial = message_get_serial(m);
r = hashmap_ensure_put(&nl->rqueue_partial_by_serial, &netlink_message_hash_ops, UINT32_TO_PTR(serial), m);
if (r < 0)
return r;
sd_netlink_message_ref(m);
return 0;
}
static int parse_message_one(sd_netlink *nl, uint32_t group, const struct nlmsghdr *hdr, sd_netlink_message **ret) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
size_t size;
int r;
assert(nl);
assert(hdr);
assert(ret);
/* not broadcast and not for us */
if (group == 0 && hdr->nlmsg_pid != nl->sockaddr.nl.nl_pid)
goto finalize;
/* silently drop noop messages */
if (hdr->nlmsg_type == NLMSG_NOOP)
goto finalize;
/* check that we support this message type */
r = netlink_get_policy_set_and_header_size(nl, hdr->nlmsg_type, NULL, &size);
if (r == -EOPNOTSUPP) {
log_debug("sd-netlink: ignored message with unknown type: %i", hdr->nlmsg_type);
goto finalize;
}
if (r < 0)
return r;
/* check that the size matches the message type */
if (hdr->nlmsg_len < NLMSG_LENGTH(size)) {
log_debug("sd-netlink: message is shorter than expected, dropping.");
goto finalize;
}
r = message_new_empty(nl, &m);
if (r < 0)
return r;
m->multicast_group = group;
m->hdr = memdup(hdr, hdr->nlmsg_len);
if (!m->hdr)
return -ENOMEM;
/* seal and parse the top-level message */
r = sd_netlink_message_rewind(m, nl);
if (r < 0)
return r;
*ret = TAKE_PTR(m);
return 1;
finalize:
*ret = NULL;
return 0;
}
/* On success, the number of bytes received is returned and *ret points to the received message
* which has a valid header and the correct size.
* If nothing useful was received 0 is returned.
* On failure, a negative error code is returned.
*/
int socket_read_message(sd_netlink *nl) {
bool done = false;
uint32_t group;
size_t len;
int r;
assert(nl);
/* read nothing, just get the pending message size */
r = socket_recv_message(nl->fd, NULL, 0, NULL, true);
if (r <= 0)
return r;
len = (size_t) r;
/* make room for the pending message */
if (!greedy_realloc((void**) &nl->rbuffer, len, sizeof(uint8_t)))
return -ENOMEM;
/* read the pending message */
r = socket_recv_message(nl->fd, nl->rbuffer, MALLOC_SIZEOF_SAFE(nl->rbuffer), &group, false);
if (r <= 0)
return r;
len = (size_t) r;
if (!NLMSG_OK(nl->rbuffer, len)) {
log_debug("sd-netlink: received invalid message, discarding %zu bytes of incoming message", len);
return 0;
}
for (struct nlmsghdr *hdr = nl->rbuffer; NLMSG_OK(hdr, len); hdr = NLMSG_NEXT(hdr, len)) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
r = parse_message_one(nl, group, hdr, &m);
if (r < 0)
return r;
if (r == 0)
continue;
if (hdr->nlmsg_flags & NLM_F_MULTI) {
if (hdr->nlmsg_type == NLMSG_DONE) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *existing = NULL;
/* finished reading multi-part message */
existing = hashmap_remove(nl->rqueue_partial_by_serial, UINT32_TO_PTR(hdr->nlmsg_seq));
/* if we receive only NLMSG_DONE, put it into the receive queue. */
r = netlink_queue_received_message(nl, existing ?: m);
if (r < 0)
return r;
done = true;
} else {
sd_netlink_message *existing;
existing = hashmap_get(nl->rqueue_partial_by_serial, UINT32_TO_PTR(hdr->nlmsg_seq));
if (existing) {
/* This is the continuation of the previously read messages.
* Let's append this message at the end. */
while (existing->next)
existing = existing->next;
existing->next = TAKE_PTR(m);
} else {
/* This is the first message. Put it into the queue for partially
* received messages. */
r = netlink_queue_partially_received_message(nl, m);
if (r < 0)
return r;
}
}
} else {
r = netlink_queue_received_message(nl, m);
if (r < 0)
return r;
done = true;
}
}
if (len > 0)
log_debug("sd-netlink: discarding trailing %zu bytes of incoming message", len);
return done;
}
| 15,151 | 31.796537 | 124 |
c
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-types-genl.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <sys/socket.h>
#include <linux/batman_adv.h>
#include <linux/fou.h>
#include <linux/genetlink.h>
#include <linux/if.h>
#include <linux/if_macsec.h>
#include <linux/l2tp.h>
#include <linux/nl80211.h>
#include <linux/wireguard.h>
#include "missing_network.h"
#include "netlink-genl.h"
#include "netlink-types-internal.h"
/***************** genl ctrl type systems *****************/
static const NLAPolicy genl_ctrl_mcast_group_policies[] = {
[CTRL_ATTR_MCAST_GRP_NAME] = BUILD_POLICY(STRING),
[CTRL_ATTR_MCAST_GRP_ID] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(genl_ctrl_mcast_group);
static const NLAPolicy genl_ctrl_ops_policies[] = {
[CTRL_ATTR_OP_ID] = BUILD_POLICY(U32),
[CTRL_ATTR_OP_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(genl_ctrl_ops);
static const NLAPolicy genl_ctrl_policies[] = {
[CTRL_ATTR_FAMILY_ID] = BUILD_POLICY(U16),
[CTRL_ATTR_FAMILY_NAME] = BUILD_POLICY(STRING),
[CTRL_ATTR_VERSION] = BUILD_POLICY(U32),
[CTRL_ATTR_HDRSIZE] = BUILD_POLICY(U32),
[CTRL_ATTR_MAXATTR] = BUILD_POLICY(U32),
[CTRL_ATTR_OPS] = BUILD_POLICY_NESTED(genl_ctrl_ops),
[CTRL_ATTR_MCAST_GROUPS] = BUILD_POLICY_NESTED(genl_ctrl_mcast_group),
/*
[CTRL_ATTR_POLICY] = { .type = NETLINK_TYPE_NESTED, },
[CTRL_ATTR_OP_POLICY] = { .type = NETLINK_TYPE_NESTED, }
*/
[CTRL_ATTR_OP] = BUILD_POLICY(U32),
};
/***************** genl batadv type systems *****************/
static const NLAPolicy genl_batadv_policies[] = {
[BATADV_ATTR_VERSION] = BUILD_POLICY(STRING),
[BATADV_ATTR_ALGO_NAME] = BUILD_POLICY(STRING),
[BATADV_ATTR_MESH_IFINDEX] = BUILD_POLICY(U32),
[BATADV_ATTR_MESH_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ),
[BATADV_ATTR_MESH_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_HARD_IFINDEX] = BUILD_POLICY(U32),
[BATADV_ATTR_HARD_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ),
[BATADV_ATTR_HARD_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_ORIG_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_TPMETER_RESULT] = BUILD_POLICY(U8),
[BATADV_ATTR_TPMETER_TEST_TIME] = BUILD_POLICY(U32),
[BATADV_ATTR_TPMETER_BYTES] = BUILD_POLICY(U64),
[BATADV_ATTR_TPMETER_COOKIE] = BUILD_POLICY(U32),
[BATADV_ATTR_PAD] = BUILD_POLICY(UNSPEC),
[BATADV_ATTR_ACTIVE] = BUILD_POLICY(FLAG),
[BATADV_ATTR_TT_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_TT_TTVN] = BUILD_POLICY(U8),
[BATADV_ATTR_TT_LAST_TTVN] = BUILD_POLICY(U8),
[BATADV_ATTR_TT_CRC32] = BUILD_POLICY(U32),
[BATADV_ATTR_TT_VID] = BUILD_POLICY(U16),
[BATADV_ATTR_TT_FLAGS] = BUILD_POLICY(U32),
[BATADV_ATTR_FLAG_BEST] = BUILD_POLICY(FLAG),
[BATADV_ATTR_LAST_SEEN_MSECS] = BUILD_POLICY(U32),
[BATADV_ATTR_NEIGH_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_TQ] = BUILD_POLICY(U8),
[BATADV_ATTR_THROUGHPUT] = BUILD_POLICY(U32),
[BATADV_ATTR_BANDWIDTH_UP] = BUILD_POLICY(U32),
[BATADV_ATTR_BANDWIDTH_DOWN] = BUILD_POLICY(U32),
[BATADV_ATTR_ROUTER] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_BLA_OWN] = BUILD_POLICY(FLAG),
[BATADV_ATTR_BLA_ADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_BLA_VID] = BUILD_POLICY(U16),
[BATADV_ATTR_BLA_BACKBONE] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_BLA_CRC] = BUILD_POLICY(U16),
[BATADV_ATTR_DAT_CACHE_IP4ADDRESS] = BUILD_POLICY(U32),
[BATADV_ATTR_DAT_CACHE_HWADDRESS] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[BATADV_ATTR_DAT_CACHE_VID] = BUILD_POLICY(U16),
[BATADV_ATTR_MCAST_FLAGS] = BUILD_POLICY(U32),
[BATADV_ATTR_MCAST_FLAGS_PRIV] = BUILD_POLICY(U32),
[BATADV_ATTR_VLANID] = BUILD_POLICY(U16),
[BATADV_ATTR_AGGREGATED_OGMS_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_AP_ISOLATION_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_ISOLATION_MARK] = BUILD_POLICY(U32),
[BATADV_ATTR_ISOLATION_MASK] = BUILD_POLICY(U32),
[BATADV_ATTR_BONDING_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_FRAGMENTATION_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_GW_BANDWIDTH_DOWN] = BUILD_POLICY(U32),
[BATADV_ATTR_GW_BANDWIDTH_UP] = BUILD_POLICY(U32),
[BATADV_ATTR_GW_MODE] = BUILD_POLICY(U8),
[BATADV_ATTR_GW_SEL_CLASS] = BUILD_POLICY(U32),
[BATADV_ATTR_HOP_PENALTY] = BUILD_POLICY(U8),
[BATADV_ATTR_LOG_LEVEL] = BUILD_POLICY(U32),
[BATADV_ATTR_MULTICAST_FORCEFLOOD_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_MULTICAST_FANOUT] = BUILD_POLICY(U32),
[BATADV_ATTR_NETWORK_CODING_ENABLED] = BUILD_POLICY(U8),
[BATADV_ATTR_ORIG_INTERVAL] = BUILD_POLICY(U32),
[BATADV_ATTR_ELP_INTERVAL] = BUILD_POLICY(U32),
[BATADV_ATTR_THROUGHPUT_OVERRIDE] = BUILD_POLICY(U32),
};
/***************** genl fou type systems *****************/
static const NLAPolicy genl_fou_policies[] = {
[FOU_ATTR_PORT] = BUILD_POLICY(U16),
[FOU_ATTR_AF] = BUILD_POLICY(U8),
[FOU_ATTR_IPPROTO] = BUILD_POLICY(U8),
[FOU_ATTR_TYPE] = BUILD_POLICY(U8),
[FOU_ATTR_REMCSUM_NOPARTIAL] = BUILD_POLICY(FLAG),
[FOU_ATTR_LOCAL_V4] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[FOU_ATTR_PEER_V4] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[FOU_ATTR_LOCAL_V6] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[FOU_ATTR_PEER_V6] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[FOU_ATTR_PEER_PORT] = BUILD_POLICY(U16),
[FOU_ATTR_IFINDEX] = BUILD_POLICY(U32),
};
/***************** genl l2tp type systems *****************/
static const NLAPolicy genl_l2tp_policies[] = {
[L2TP_ATTR_PW_TYPE] = BUILD_POLICY(U16),
[L2TP_ATTR_ENCAP_TYPE] = BUILD_POLICY(U16),
[L2TP_ATTR_OFFSET] = BUILD_POLICY(U16),
[L2TP_ATTR_DATA_SEQ] = BUILD_POLICY(U16),
[L2TP_ATTR_L2SPEC_TYPE] = BUILD_POLICY(U8),
[L2TP_ATTR_L2SPEC_LEN] = BUILD_POLICY(U8),
[L2TP_ATTR_PROTO_VERSION] = BUILD_POLICY(U8),
[L2TP_ATTR_IFNAME] = BUILD_POLICY(STRING),
[L2TP_ATTR_CONN_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_PEER_CONN_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_SESSION_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_PEER_SESSION_ID] = BUILD_POLICY(U32),
[L2TP_ATTR_UDP_CSUM] = BUILD_POLICY(U8),
[L2TP_ATTR_VLAN_ID] = BUILD_POLICY(U16),
[L2TP_ATTR_RECV_SEQ] = BUILD_POLICY(U8),
[L2TP_ATTR_SEND_SEQ] = BUILD_POLICY(U8),
[L2TP_ATTR_LNS_MODE] = BUILD_POLICY(U8),
[L2TP_ATTR_USING_IPSEC] = BUILD_POLICY(U8),
[L2TP_ATTR_FD] = BUILD_POLICY(U32),
[L2TP_ATTR_IP_SADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[L2TP_ATTR_IP_DADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in_addr)),
[L2TP_ATTR_UDP_SPORT] = BUILD_POLICY(U16),
[L2TP_ATTR_UDP_DPORT] = BUILD_POLICY(U16),
[L2TP_ATTR_IP6_SADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[L2TP_ATTR_IP6_DADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[L2TP_ATTR_UDP_ZERO_CSUM6_TX] = BUILD_POLICY(FLAG),
[L2TP_ATTR_UDP_ZERO_CSUM6_RX] = BUILD_POLICY(FLAG),
};
/***************** genl macsec type systems *****************/
static const NLAPolicy genl_macsec_rxsc_policies[] = {
[MACSEC_RXSC_ATTR_SCI] = BUILD_POLICY(U64),
};
DEFINE_POLICY_SET(genl_macsec_rxsc);
static const NLAPolicy genl_macsec_sa_policies[] = {
[MACSEC_SA_ATTR_AN] = BUILD_POLICY(U8),
[MACSEC_SA_ATTR_ACTIVE] = BUILD_POLICY(U8),
[MACSEC_SA_ATTR_PN] = BUILD_POLICY(U32),
[MACSEC_SA_ATTR_KEYID] = BUILD_POLICY_WITH_SIZE(BINARY, MACSEC_KEYID_LEN),
[MACSEC_SA_ATTR_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, MACSEC_MAX_KEY_LEN),
};
DEFINE_POLICY_SET(genl_macsec_sa);
static const NLAPolicy genl_macsec_policies[] = {
[MACSEC_ATTR_IFINDEX] = BUILD_POLICY(U32),
[MACSEC_ATTR_RXSC_CONFIG] = BUILD_POLICY_NESTED(genl_macsec_rxsc),
[MACSEC_ATTR_SA_CONFIG] = BUILD_POLICY_NESTED(genl_macsec_sa),
};
/***************** genl NetLabel type systems *****************/
static const NLAPolicy genl_netlabel_policies[] = {
[NLBL_UNLABEL_A_IPV4ADDR] = BUILD_POLICY(IN_ADDR),
[NLBL_UNLABEL_A_IPV4MASK] = BUILD_POLICY(IN_ADDR),
[NLBL_UNLABEL_A_IPV6ADDR] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[NLBL_UNLABEL_A_IPV6MASK] = BUILD_POLICY_WITH_SIZE(IN_ADDR, sizeof(struct in6_addr)),
[NLBL_UNLABEL_A_IFACE] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ-1),
[NLBL_UNLABEL_A_SECCTX] = BUILD_POLICY(STRING),
};
/***************** genl nl80211 type systems *****************/
static const NLAPolicy genl_nl80211_policies[] = {
[NL80211_ATTR_WIPHY] = BUILD_POLICY(U32),
[NL80211_ATTR_WIPHY_NAME] = BUILD_POLICY(STRING),
[NL80211_ATTR_IFINDEX] = BUILD_POLICY(U32),
[NL80211_ATTR_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ-1),
[NL80211_ATTR_IFTYPE] = BUILD_POLICY(U32),
[NL80211_ATTR_MAC] = BUILD_POLICY_WITH_SIZE(ETHER_ADDR, ETH_ALEN),
[NL80211_ATTR_SSID] = BUILD_POLICY_WITH_SIZE(BINARY, IEEE80211_MAX_SSID_LEN),
[NL80211_ATTR_STATUS_CODE] = BUILD_POLICY(U16),
[NL80211_ATTR_4ADDR] = BUILD_POLICY(U8),
};
/***************** genl wireguard type systems *****************/
static const NLAPolicy genl_wireguard_allowedip_policies[] = {
[WGALLOWEDIP_A_FAMILY] = BUILD_POLICY(U16),
[WGALLOWEDIP_A_IPADDR] = BUILD_POLICY(IN_ADDR),
[WGALLOWEDIP_A_CIDR_MASK] = BUILD_POLICY(U8),
};
DEFINE_POLICY_SET(genl_wireguard_allowedip);
static const NLAPolicy genl_wireguard_peer_policies[] = {
[WGPEER_A_PUBLIC_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, WG_KEY_LEN),
[WGPEER_A_FLAGS] = BUILD_POLICY(U32),
[WGPEER_A_PRESHARED_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, WG_KEY_LEN),
[WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL] = BUILD_POLICY(U16),
[WGPEER_A_ENDPOINT] = BUILD_POLICY(SOCKADDR),
[WGPEER_A_ALLOWEDIPS] = BUILD_POLICY_NESTED(genl_wireguard_allowedip),
};
DEFINE_POLICY_SET(genl_wireguard_peer);
static const NLAPolicy genl_wireguard_policies[] = {
[WGDEVICE_A_IFINDEX] = BUILD_POLICY(U32),
[WGDEVICE_A_IFNAME] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ-1),
[WGDEVICE_A_FLAGS] = BUILD_POLICY(U32),
[WGDEVICE_A_PRIVATE_KEY] = BUILD_POLICY_WITH_SIZE(BINARY, WG_KEY_LEN),
[WGDEVICE_A_LISTEN_PORT] = BUILD_POLICY(U16),
[WGDEVICE_A_FWMARK] = BUILD_POLICY(U32),
[WGDEVICE_A_PEERS] = BUILD_POLICY_NESTED(genl_wireguard_peer),
};
/***************** genl families *****************/
static const NLAPolicySetUnionElement genl_policy_set_union_elements[] = {
BUILD_UNION_ELEMENT_BY_STRING(CTRL_GENL_NAME, genl_ctrl),
BUILD_UNION_ELEMENT_BY_STRING(BATADV_NL_NAME, genl_batadv),
BUILD_UNION_ELEMENT_BY_STRING(FOU_GENL_NAME, genl_fou),
BUILD_UNION_ELEMENT_BY_STRING(L2TP_GENL_NAME, genl_l2tp),
BUILD_UNION_ELEMENT_BY_STRING(MACSEC_GENL_NAME, genl_macsec),
BUILD_UNION_ELEMENT_BY_STRING(NETLBL_NLTYPE_UNLABELED_NAME, genl_netlabel),
BUILD_UNION_ELEMENT_BY_STRING(NL80211_GENL_NAME, genl_nl80211),
BUILD_UNION_ELEMENT_BY_STRING(WG_GENL_NAME, genl_wireguard),
};
/* This is the root type system union, so match_attribute is not necessary. */
DEFINE_POLICY_SET_UNION(genl, 0);
const NLAPolicySet *genl_get_policy_set_by_name(const char *name) {
return policy_set_union_get_policy_set_by_string(&genl_policy_set_union, name);
}
| 13,811 | 53.809524 | 99 |
c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.