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/sd-netlink/netlink-types-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "macro.h"
#include "netlink-types.h"
/* C.f. see 'struct nla_policy' at include/net/netlink.h. */
struct NLAPolicy {
NLAType type;
size_t size;
union {
const NLAPolicySet *policy_set;
const NLAPolicySetUnion *policy_set_union;
};
};
struct NLAPolicySet {
uint16_t count;
const NLAPolicy *policies;
};
typedef struct NLAPolicySetUnionElement {
union {
int family; /* used by NETLINK_TYPE_NESTED_UNION_BY_FAMILY */
const char *string; /* used by NETLINK_TYPE_NESTED_UNION_BY_STRING */
};
NLAPolicySet policy_set;
} NLAPolicySetUnionElement;
struct NLAPolicySetUnion {
size_t count;
const NLAPolicySetUnionElement *elements;
uint16_t match_attribute; /* used by NETLINK_TYPE_NESTED_UNION_BY_STRING */
};
#define BUILD_POLICY_WITH_SIZE(t, n) \
{ .type = NETLINK_TYPE_##t, .size = n }
#define BUILD_POLICY(t) \
BUILD_POLICY_WITH_SIZE(t, 0)
#define BUILD_POLICY_NESTED_WITH_SIZE(name, n) \
{ .type = NETLINK_TYPE_NESTED, .size = n, .policy_set = &name##_policy_set }
#define BUILD_POLICY_NESTED(name) \
BUILD_POLICY_NESTED_WITH_SIZE(name, 0)
#define _BUILD_POLICY_NESTED_UNION(name, by) \
{ .type = NETLINK_TYPE_NESTED_UNION_BY_##by, .policy_set_union = &name##_policy_set_union }
#define BUILD_POLICY_NESTED_UNION_BY_STRING(name) \
_BUILD_POLICY_NESTED_UNION(name, STRING)
#define BUILD_POLICY_NESTED_UNION_BY_FAMILY(name) \
_BUILD_POLICY_NESTED_UNION(name, FAMILY)
#define _BUILD_POLICY_SET(name) \
{ .count = ELEMENTSOF(name##_policies), .policies = name##_policies }
#define DEFINE_POLICY_SET(name) \
static const NLAPolicySet name##_policy_set = _BUILD_POLICY_SET(name)
# define BUILD_UNION_ELEMENT_BY_STRING(s, name) \
{ .string = s, .policy_set = _BUILD_POLICY_SET(name) }
# define BUILD_UNION_ELEMENT_BY_FAMILY(f, name) \
{ .family = f, .policy_set = _BUILD_POLICY_SET(name) }
#define DEFINE_POLICY_SET_UNION(name, attr) \
static const NLAPolicySetUnion name##_policy_set_union = { \
.count = ELEMENTSOF(name##_policy_set_union_elements), \
.elements = name##_policy_set_union_elements, \
.match_attribute = attr, \
}
| 2,722 | 39.641791 | 99 |
h
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-types-nfnl.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/if.h>
#include <linux/netfilter/nf_tables.h>
#include <linux/netfilter/nfnetlink.h>
#include "netlink-types-internal.h"
static const NLAPolicy nfnl_nft_table_policies[] = {
[NFTA_TABLE_NAME] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_TABLE_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(nfnl_nft_table);
static const NLAPolicy nfnl_nft_chain_hook_policies[] = {
[NFTA_HOOK_HOOKNUM] = BUILD_POLICY(U32),
[NFTA_HOOK_PRIORITY] = BUILD_POLICY(U32),
[NFTA_HOOK_DEV] = BUILD_POLICY_WITH_SIZE(STRING, IFNAMSIZ - 1),
};
DEFINE_POLICY_SET(nfnl_nft_chain_hook);
static const NLAPolicy nfnl_nft_chain_policies[] = {
[NFTA_CHAIN_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_CHAIN_NAME] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_CHAIN_HOOK] = BUILD_POLICY_NESTED(nfnl_nft_chain_hook),
[NFTA_CHAIN_TYPE] = BUILD_POLICY_WITH_SIZE(STRING, 16),
[NFTA_CHAIN_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(nfnl_nft_chain);
static const NLAPolicy nfnl_nft_expr_meta_policies[] = {
[NFTA_META_DREG] = BUILD_POLICY(U32),
[NFTA_META_KEY] = BUILD_POLICY(U32),
[NFTA_META_SREG] = BUILD_POLICY(U32),
};
static const NLAPolicy nfnl_nft_expr_payload_policies[] = {
[NFTA_PAYLOAD_DREG] = BUILD_POLICY(U32),
[NFTA_PAYLOAD_BASE] = BUILD_POLICY(U32),
[NFTA_PAYLOAD_OFFSET] = BUILD_POLICY(U32),
[NFTA_PAYLOAD_LEN] = BUILD_POLICY(U32),
};
static const NLAPolicy nfnl_nft_expr_nat_policies[] = {
[NFTA_NAT_TYPE] = BUILD_POLICY(U32),
[NFTA_NAT_FAMILY] = BUILD_POLICY(U32),
[NFTA_NAT_REG_ADDR_MIN] = BUILD_POLICY(U32),
[NFTA_NAT_REG_ADDR_MAX] = BUILD_POLICY(U32),
[NFTA_NAT_REG_PROTO_MIN] = BUILD_POLICY(U32),
[NFTA_NAT_REG_PROTO_MAX] = BUILD_POLICY(U32),
[NFTA_NAT_FLAGS] = BUILD_POLICY(U32),
};
static const NLAPolicy nfnl_nft_data_policies[] = {
[NFTA_DATA_VALUE] = { .type = NETLINK_TYPE_BINARY },
};
DEFINE_POLICY_SET(nfnl_nft_data);
static const NLAPolicy nfnl_nft_expr_bitwise_policies[] = {
[NFTA_BITWISE_SREG] = BUILD_POLICY(U32),
[NFTA_BITWISE_DREG] = BUILD_POLICY(U32),
[NFTA_BITWISE_LEN] = BUILD_POLICY(U32),
[NFTA_BITWISE_MASK] = BUILD_POLICY_NESTED(nfnl_nft_data),
[NFTA_BITWISE_XOR] = BUILD_POLICY_NESTED(nfnl_nft_data),
};
static const NLAPolicy nfnl_nft_expr_cmp_policies[] = {
[NFTA_CMP_SREG] = BUILD_POLICY(U32),
[NFTA_CMP_OP] = BUILD_POLICY(U32),
[NFTA_CMP_DATA] = BUILD_POLICY_NESTED(nfnl_nft_data),
};
static const NLAPolicy nfnl_nft_expr_fib_policies[] = {
[NFTA_FIB_DREG] = BUILD_POLICY(U32),
[NFTA_FIB_RESULT] = BUILD_POLICY(U32),
[NFTA_FIB_FLAGS] = BUILD_POLICY(U32),
};
static const NLAPolicy nfnl_nft_expr_lookup_policies[] = {
[NFTA_LOOKUP_SET] = { .type = NETLINK_TYPE_STRING },
[NFTA_LOOKUP_SREG] = BUILD_POLICY(U32),
[NFTA_LOOKUP_DREG] = BUILD_POLICY(U32),
[NFTA_LOOKUP_FLAGS] = BUILD_POLICY(U32),
};
static const NLAPolicy nfnl_nft_expr_masq_policies[] = {
[NFTA_MASQ_FLAGS] = BUILD_POLICY(U32),
[NFTA_MASQ_REG_PROTO_MIN] = BUILD_POLICY(U32),
[NFTA_MASQ_REG_PROTO_MAX] = BUILD_POLICY(U32),
};
static const NLAPolicySetUnionElement nfnl_expr_data_policy_set_union_elements[] = {
BUILD_UNION_ELEMENT_BY_STRING("bitwise", nfnl_nft_expr_bitwise),
BUILD_UNION_ELEMENT_BY_STRING("cmp", nfnl_nft_expr_cmp),
BUILD_UNION_ELEMENT_BY_STRING("fib", nfnl_nft_expr_fib),
BUILD_UNION_ELEMENT_BY_STRING("lookup", nfnl_nft_expr_lookup),
BUILD_UNION_ELEMENT_BY_STRING("masq", nfnl_nft_expr_masq),
BUILD_UNION_ELEMENT_BY_STRING("meta", nfnl_nft_expr_meta),
BUILD_UNION_ELEMENT_BY_STRING("nat", nfnl_nft_expr_nat),
BUILD_UNION_ELEMENT_BY_STRING("payload", nfnl_nft_expr_payload),
};
DEFINE_POLICY_SET_UNION(nfnl_expr_data, NFTA_EXPR_NAME);
static const NLAPolicy nfnl_nft_rule_expr_policies[] = {
[NFTA_EXPR_NAME] = BUILD_POLICY_WITH_SIZE(STRING, 16),
[NFTA_EXPR_DATA] = BUILD_POLICY_NESTED_UNION_BY_STRING(nfnl_expr_data),
};
DEFINE_POLICY_SET(nfnl_nft_rule_expr);
static const NLAPolicy nfnl_nft_rule_policies[] = {
[NFTA_RULE_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_RULE_CHAIN] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_RULE_EXPRESSIONS] = BUILD_POLICY_NESTED(nfnl_nft_rule_expr),
};
DEFINE_POLICY_SET(nfnl_nft_rule);
static const NLAPolicy nfnl_nft_set_policies[] = {
[NFTA_SET_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_NAME] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_FLAGS] = BUILD_POLICY(U32),
[NFTA_SET_KEY_TYPE] = BUILD_POLICY(U32),
[NFTA_SET_KEY_LEN] = BUILD_POLICY(U32),
[NFTA_SET_DATA_TYPE] = BUILD_POLICY(U32),
[NFTA_SET_DATA_LEN] = BUILD_POLICY(U32),
[NFTA_SET_POLICY] = BUILD_POLICY(U32),
[NFTA_SET_ID] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(nfnl_nft_set);
static const NLAPolicy nfnl_nft_setelem_policies[] = {
[NFTA_SET_ELEM_KEY] = BUILD_POLICY_NESTED(nfnl_nft_data),
[NFTA_SET_ELEM_DATA] = BUILD_POLICY_NESTED(nfnl_nft_data),
[NFTA_SET_ELEM_FLAGS] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(nfnl_nft_setelem);
static const NLAPolicy nfnl_nft_setelem_list_policies[] = {
[NFTA_SET_ELEM_LIST_TABLE] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_ELEM_LIST_SET] = BUILD_POLICY_WITH_SIZE(STRING, NFT_TABLE_MAXNAMELEN - 1),
[NFTA_SET_ELEM_LIST_ELEMENTS] = BUILD_POLICY_NESTED(nfnl_nft_setelem),
};
DEFINE_POLICY_SET(nfnl_nft_setelem_list);
static const NLAPolicy nfnl_subsys_nft_policies[] = {
[NFT_MSG_DELTABLE] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_table, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWTABLE] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_table, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWCHAIN] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_chain, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWRULE] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_rule, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWSET] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_set, sizeof(struct nfgenmsg)),
[NFT_MSG_NEWSETELEM] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_setelem_list, sizeof(struct nfgenmsg)),
[NFT_MSG_DELSETELEM] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_nft_setelem_list, sizeof(struct nfgenmsg)),
};
DEFINE_POLICY_SET(nfnl_subsys_nft);
static const NLAPolicy nfnl_msg_batch_policies[] = {
[NFNL_BATCH_GENID] = BUILD_POLICY(U32)
};
DEFINE_POLICY_SET(nfnl_msg_batch);
static const NLAPolicy nfnl_subsys_none_policies[] = {
[NFNL_MSG_BATCH_BEGIN] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_msg_batch, sizeof(struct nfgenmsg)),
[NFNL_MSG_BATCH_END] = BUILD_POLICY_NESTED_WITH_SIZE(nfnl_msg_batch, sizeof(struct nfgenmsg)),
};
DEFINE_POLICY_SET(nfnl_subsys_none);
static const NLAPolicy nfnl_policies[] = {
[NFNL_SUBSYS_NONE] = BUILD_POLICY_NESTED(nfnl_subsys_none),
[NFNL_SUBSYS_NFTABLES] = BUILD_POLICY_NESTED(nfnl_subsys_nft),
};
DEFINE_POLICY_SET(nfnl);
const NLAPolicy *nfnl_get_policy(uint16_t nlmsg_type) {
const NLAPolicySet *subsys;
subsys = policy_set_get_policy_set(&nfnl_policy_set, NFNL_SUBSYS_ID(nlmsg_type));
if (!subsys)
return NULL;
return policy_set_get_policy(subsys, NFNL_MSG_TYPE(nlmsg_type));
}
| 7,894 | 39.487179 | 109 |
c
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-types.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/netlink.h>
#include "netlink-genl.h"
#include "netlink-internal.h"
#include "netlink-types-internal.h"
static const NLAPolicy empty_policies[1] = {
/* fake array to avoid .types==NULL, which denotes invalid type-systems */
};
DEFINE_POLICY_SET(empty);
static const NLAPolicy error_policies[] = {
[NLMSGERR_ATTR_MSG] = BUILD_POLICY(STRING),
[NLMSGERR_ATTR_OFFS] = BUILD_POLICY(U32),
};
DEFINE_POLICY_SET(error);
static const NLAPolicy basic_policies[] = {
[NLMSG_DONE] = BUILD_POLICY_NESTED(empty),
[NLMSG_ERROR] = BUILD_POLICY_NESTED_WITH_SIZE(error, sizeof(struct nlmsgerr)),
};
DEFINE_POLICY_SET(basic);
NLAType policy_get_type(const NLAPolicy *policy) {
return ASSERT_PTR(policy)->type;
}
size_t policy_get_size(const NLAPolicy *policy) {
return ASSERT_PTR(policy)->size;
}
const NLAPolicySet *policy_get_policy_set(const NLAPolicy *policy) {
assert(policy);
assert(policy->type == NETLINK_TYPE_NESTED);
return ASSERT_PTR(policy->policy_set);
}
const NLAPolicySetUnion *policy_get_policy_set_union(const NLAPolicy *policy) {
assert(policy);
assert(IN_SET(policy->type, NETLINK_TYPE_NESTED_UNION_BY_STRING, NETLINK_TYPE_NESTED_UNION_BY_FAMILY));
return ASSERT_PTR(policy->policy_set_union);
}
int netlink_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t type,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size) {
const NLAPolicy *policy;
assert(nl);
if (IN_SET(type, NLMSG_DONE, NLMSG_ERROR))
policy = policy_set_get_policy(&basic_policy_set, type);
else
switch (nl->protocol) {
case NETLINK_ROUTE:
policy = rtnl_get_policy(type);
break;
case NETLINK_NETFILTER:
policy = nfnl_get_policy(type);
break;
case NETLINK_GENERIC:
return genl_get_policy_set_and_header_size(nl, type, ret_policy_set, ret_header_size);
default:
return -EOPNOTSUPP;
}
if (!policy)
return -EOPNOTSUPP;
if (policy_get_type(policy) != NETLINK_TYPE_NESTED)
return -EOPNOTSUPP;
if (ret_policy_set)
*ret_policy_set = policy_get_policy_set(policy);
if (ret_header_size)
*ret_header_size = policy_get_size(policy);
return 0;
}
const NLAPolicy *policy_set_get_policy(const NLAPolicySet *policy_set, uint16_t attr_type) {
const NLAPolicy *policy;
assert(policy_set);
assert(policy_set->policies);
if (attr_type >= policy_set->count)
return NULL;
policy = &policy_set->policies[attr_type];
if (policy->type == NETLINK_TYPE_UNSPEC)
return NULL;
return policy;
}
const NLAPolicySet *policy_set_get_policy_set(const NLAPolicySet *policy_set, uint16_t attr_type) {
const NLAPolicy *policy;
policy = policy_set_get_policy(policy_set, attr_type);
if (!policy)
return NULL;
return policy_get_policy_set(policy);
}
const NLAPolicySetUnion *policy_set_get_policy_set_union(const NLAPolicySet *policy_set, uint16_t attr_type) {
const NLAPolicy *policy;
policy = policy_set_get_policy(policy_set, attr_type);
if (!policy)
return NULL;
return policy_get_policy_set_union(policy);
}
uint16_t policy_set_union_get_match_attribute(const NLAPolicySetUnion *policy_set_union) {
assert(policy_set_union->match_attribute != 0);
return policy_set_union->match_attribute;
}
const NLAPolicySet *policy_set_union_get_policy_set_by_string(const NLAPolicySetUnion *policy_set_union, const char *string) {
assert(policy_set_union);
assert(policy_set_union->elements);
assert(string);
for (size_t i = 0; i < policy_set_union->count; i++)
if (streq(policy_set_union->elements[i].string, string))
return &policy_set_union->elements[i].policy_set;
return NULL;
}
const NLAPolicySet *policy_set_union_get_policy_set_by_family(const NLAPolicySetUnion *policy_set_union, int family) {
assert(policy_set_union);
assert(policy_set_union->elements);
for (size_t i = 0; i < policy_set_union->count; i++)
if (policy_set_union->elements[i].family == family)
return &policy_set_union->elements[i].policy_set;
return NULL;
}
| 4,786 | 30.084416 | 126 |
c
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-types.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <errno.h>
#include "sd-netlink.h"
typedef enum NLAType {
NETLINK_TYPE_UNSPEC, /* NLA_UNSPEC */
NETLINK_TYPE_BINARY, /* NLA_BINARY */
NETLINK_TYPE_FLAG, /* NLA_FLAG */
NETLINK_TYPE_U8, /* NLA_U8 */
NETLINK_TYPE_U16, /* NLA_U16 */
NETLINK_TYPE_U32, /* NLA_U32 */
NETLINK_TYPE_U64, /* NLA_U64 */
NETLINK_TYPE_S8, /* NLA_S8 */
NETLINK_TYPE_S16, /* NLA_S16 */
NETLINK_TYPE_S32, /* NLA_S32 */
NETLINK_TYPE_S64, /* NLA_S64 */
NETLINK_TYPE_STRING, /* NLA_STRING */
NETLINK_TYPE_BITFIELD32, /* NLA_BITFIELD32 */
NETLINK_TYPE_REJECT, /* NLA_REJECT */
NETLINK_TYPE_IN_ADDR,
NETLINK_TYPE_ETHER_ADDR,
NETLINK_TYPE_CACHE_INFO,
NETLINK_TYPE_SOCKADDR,
NETLINK_TYPE_NESTED, /* NLA_NESTED */
NETLINK_TYPE_NESTED_UNION_BY_STRING,
NETLINK_TYPE_NESTED_UNION_BY_FAMILY,
_NETLINK_TYPE_MAX,
_NETLINK_TYPE_INVALID = -EINVAL,
} NLAType;
typedef struct NLAPolicy NLAPolicy;
typedef struct NLAPolicySet NLAPolicySet;
typedef struct NLAPolicySetUnion NLAPolicySetUnion;
const NLAPolicy *rtnl_get_policy(uint16_t nlmsg_type);
const NLAPolicy *nfnl_get_policy(uint16_t nlmsg_type);
const NLAPolicySet *genl_get_policy_set_by_name(const char *name);
int genl_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t id,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size);
NLAType policy_get_type(const NLAPolicy *policy);
size_t policy_get_size(const NLAPolicy *policy);
const NLAPolicySet *policy_get_policy_set(const NLAPolicy *policy);
const NLAPolicySetUnion *policy_get_policy_set_union(const NLAPolicy *policy);
int netlink_get_policy_set_and_header_size(
sd_netlink *nl,
uint16_t type,
const NLAPolicySet **ret_policy_set,
size_t *ret_header_size);
const NLAPolicy *policy_set_get_policy(const NLAPolicySet *policy_set, uint16_t attr_type);
const NLAPolicySet *policy_set_get_policy_set(const NLAPolicySet *type_system, uint16_t attr_type);
const NLAPolicySetUnion *policy_set_get_policy_set_union(const NLAPolicySet *type_system, uint16_t attr_type);
uint16_t policy_set_union_get_match_attribute(const NLAPolicySetUnion *policy_set_union);
const NLAPolicySet *policy_set_union_get_policy_set_by_string(const NLAPolicySetUnion *type_system_union, const char *string);
const NLAPolicySet *policy_set_union_get_policy_set_by_family(const NLAPolicySetUnion *type_system_union, int family);
| 2,974 | 45.484375 | 126 |
h
|
null |
systemd-main/src/libsystemd/sd-netlink/netlink-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <linux/rtnetlink.h>
#include "sd-netlink.h"
#include "ether-addr-util.h"
#include "in-addr-util.h"
#include "ordered-set.h"
#include "socket-util.h"
/* See struct rtvia in rtnetlink.h */
typedef struct RouteVia {
uint16_t family;
union in_addr_union address;
} _packed_ RouteVia;
typedef struct MultipathRoute {
RouteVia gateway;
uint32_t weight;
int ifindex;
char *ifname;
} MultipathRoute;
MultipathRoute *multipath_route_free(MultipathRoute *m);
DEFINE_TRIVIAL_CLEANUP_FUNC(MultipathRoute*, multipath_route_free);
int multipath_route_dup(const MultipathRoute *m, MultipathRoute **ret);
int rtnl_set_link_name(sd_netlink **rtnl, int ifindex, const char *name, char* const* alternative_names);
static inline int rtnl_append_link_alternative_names(sd_netlink **rtnl, int ifindex, char* const *alternative_names) {
return rtnl_set_link_name(rtnl, ifindex, NULL, alternative_names);
}
int rtnl_set_link_properties(
sd_netlink **rtnl,
int ifindex,
const char *alias,
const struct hw_addr_data *hw_addr,
uint32_t txqueues,
uint32_t rxqueues,
uint32_t txqueuelen,
uint32_t mtu,
uint32_t gso_max_size,
size_t gso_max_segments);
int rtnl_get_link_alternative_names(sd_netlink **rtnl, int ifindex, char ***ret);
int rtnl_set_link_alternative_names(sd_netlink **rtnl, int ifindex, char* const *alternative_names);
int rtnl_set_link_alternative_names_by_ifname(sd_netlink **rtnl, const char *ifname, char* const *alternative_names);
int rtnl_delete_link_alternative_names(sd_netlink **rtnl, int ifindex, char* const *alternative_names);
int rtnl_resolve_link_alternative_name(sd_netlink **rtnl, const char *name, char **ret);
int rtnl_resolve_ifname(sd_netlink **rtnl, const char *name);
int rtnl_resolve_interface(sd_netlink **rtnl, const char *name);
int rtnl_resolve_interface_or_warn(sd_netlink **rtnl, const char *name);
int rtnl_get_link_info(
sd_netlink **rtnl,
int ifindex,
unsigned short *ret_iftype,
unsigned *ret_flags,
char **ret_kind,
struct hw_addr_data *ret_hw_addr,
struct hw_addr_data *ret_permanent_hw_addr);
int rtnl_log_parse_error(int r);
int rtnl_log_create_error(int r);
#define netlink_call_async(nl, ret_slot, message, callback, destroy_callback, userdata) \
({ \
int (*_callback_)(sd_netlink *, sd_netlink_message *, typeof(userdata)) = callback; \
void (*_destroy_)(typeof(userdata)) = destroy_callback; \
sd_netlink_call_async(nl, ret_slot, message, \
(sd_netlink_message_handler_t) _callback_, \
(sd_netlink_destroy_t) _destroy_, \
userdata, 0, __func__); \
})
#define netlink_add_match(nl, ret_slot, match, callback, destroy_callback, userdata, description) \
({ \
int (*_callback_)(sd_netlink *, sd_netlink_message *, typeof(userdata)) = callback; \
void (*_destroy_)(typeof(userdata)) = destroy_callback; \
sd_netlink_add_match(nl, ret_slot, match, \
(sd_netlink_message_handler_t) _callback_, \
(sd_netlink_destroy_t) _destroy_, \
userdata, description); \
})
#define genl_add_match(nl, ret_slot, family, group, cmd, callback, destroy_callback, userdata, description) \
({ \
int (*_callback_)(sd_netlink *, sd_netlink_message *, typeof(userdata)) = callback; \
void (*_destroy_)(typeof(userdata)) = destroy_callback; \
sd_genl_add_match(nl, ret_slot, family, group, cmd, \
(sd_netlink_message_handler_t) _callback_, \
(sd_netlink_destroy_t) _destroy_, \
userdata, description); \
})
int netlink_message_append_hw_addr(sd_netlink_message *m, unsigned short type, const struct hw_addr_data *data);
int netlink_message_append_in_addr_union(sd_netlink_message *m, unsigned short type, int family, const union in_addr_union *data);
int netlink_message_append_sockaddr_union(sd_netlink_message *m, unsigned short type, const union sockaddr_union *data);
int netlink_message_read_hw_addr(sd_netlink_message *m, unsigned short type, struct hw_addr_data *data);
int netlink_message_read_in_addr_union(sd_netlink_message *m, unsigned short type, int family, union in_addr_union *data);
void rtattr_append_attribute_internal(struct rtattr *rta, unsigned short type, const void *data, size_t data_length);
int rtattr_append_attribute(struct rtattr **rta, unsigned short type, const void *data, size_t data_length);
int rtattr_read_nexthop(const struct rtnexthop *rtnh, size_t size, int family, OrderedSet **ret);
void netlink_seal_message(sd_netlink *nl, sd_netlink_message *m);
/* TODO: to be exported later */
int sd_netlink_sendv(sd_netlink *nl, sd_netlink_message **messages, size_t msgcnt, uint32_t **ret_serial);
| 5,618 | 49.169643 | 130 |
h
|
null |
systemd-main/src/libsystemd/sd-network/network-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-network.h"
#include "alloc-util.h"
#include "network-util.h"
#include "string-table.h"
#include "strv.h"
bool network_is_online(void) {
_cleanup_free_ char *online_state = NULL;
LinkOnlineState state;
int r;
r = sd_network_get_online_state(&online_state);
if (r < 0)
state = _LINK_ONLINE_STATE_INVALID;
else
state = link_online_state_from_string(online_state);
if (state >= LINK_ONLINE_STATE_PARTIAL)
return true;
else if (state < 0) {
_cleanup_free_ char *carrier_state = NULL, *addr_state = NULL;
r = sd_network_get_carrier_state(&carrier_state);
if (r < 0) /* if we don't know anything, we consider the system online */
return true;
r = sd_network_get_address_state(&addr_state);
if (r < 0) /* if we don't know anything, we consider the system online */
return true;
/* we don't know the online state for certain, so make an educated guess */
if (STR_IN_SET(carrier_state, "degraded-carrier", "carrier") &&
STR_IN_SET(addr_state, "routable", "degraded"))
return true;
}
return false;
}
static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
[LINK_OPERSTATE_MISSING] = "missing",
[LINK_OPERSTATE_OFF] = "off",
[LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
[LINK_OPERSTATE_DORMANT] = "dormant",
[LINK_OPERSTATE_DEGRADED_CARRIER] = "degraded-carrier",
[LINK_OPERSTATE_CARRIER] = "carrier",
[LINK_OPERSTATE_DEGRADED] = "degraded",
[LINK_OPERSTATE_ENSLAVED] = "enslaved",
[LINK_OPERSTATE_ROUTABLE] = "routable",
};
DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
static const char* const link_carrier_state_table[_LINK_CARRIER_STATE_MAX] = {
[LINK_CARRIER_STATE_OFF] = "off",
[LINK_CARRIER_STATE_NO_CARRIER] = "no-carrier",
[LINK_CARRIER_STATE_DORMANT] = "dormant",
[LINK_CARRIER_STATE_DEGRADED_CARRIER] = "degraded-carrier",
[LINK_CARRIER_STATE_CARRIER] = "carrier",
[LINK_CARRIER_STATE_ENSLAVED] = "enslaved",
};
DEFINE_STRING_TABLE_LOOKUP(link_carrier_state, LinkCarrierState);
static const char* const link_required_address_family_table[_ADDRESS_FAMILY_MAX] = {
[ADDRESS_FAMILY_NO] = "any",
[ADDRESS_FAMILY_IPV4] = "ipv4",
[ADDRESS_FAMILY_IPV6] = "ipv6",
[ADDRESS_FAMILY_YES] = "both",
};
DEFINE_STRING_TABLE_LOOKUP(link_required_address_family, AddressFamily);
static const char* const link_address_state_table[_LINK_ADDRESS_STATE_MAX] = {
[LINK_ADDRESS_STATE_OFF] = "off",
[LINK_ADDRESS_STATE_DEGRADED] = "degraded",
[LINK_ADDRESS_STATE_ROUTABLE] = "routable",
};
DEFINE_STRING_TABLE_LOOKUP(link_address_state, LinkAddressState);
static const char *const link_online_state_table[_LINK_ONLINE_STATE_MAX] = {
[LINK_ONLINE_STATE_OFFLINE] = "offline",
[LINK_ONLINE_STATE_PARTIAL] = "partial",
[LINK_ONLINE_STATE_ONLINE] = "online",
};
DEFINE_STRING_TABLE_LOOKUP(link_online_state, LinkOnlineState);
int parse_operational_state_range(const char *str, LinkOperationalStateRange *out) {
LinkOperationalStateRange range = { _LINK_OPERSTATE_INVALID, _LINK_OPERSTATE_INVALID };
_cleanup_free_ const char *min = NULL;
const char *p;
assert(str);
assert(out);
p = strchr(str, ':');
if (p) {
min = strndup(str, p - str);
if (!isempty(p + 1)) {
range.max = link_operstate_from_string(p + 1);
if (range.max < 0)
return -EINVAL;
}
} else
min = strdup(str);
if (!min)
return -ENOMEM;
if (!isempty(min)) {
range.min = link_operstate_from_string(min);
if (range.min < 0)
return -EINVAL;
}
/* Fail on empty strings. */
if (range.min == _LINK_OPERSTATE_INVALID && range.max == _LINK_OPERSTATE_INVALID)
return -EINVAL;
if (range.min == _LINK_OPERSTATE_INVALID)
range.min = LINK_OPERSTATE_MISSING;
if (range.max == _LINK_OPERSTATE_INVALID)
range.max = LINK_OPERSTATE_ROUTABLE;
if (range.min > range.max)
return -EINVAL;
*out = range;
return 0;
}
int network_link_get_operational_state(int ifindex, LinkOperationalState *ret) {
_cleanup_free_ char *str = NULL;
LinkOperationalState s;
int r;
assert(ifindex > 0);
assert(ret);
r = sd_network_link_get_operational_state(ifindex, &str);
if (r < 0)
return r;
s = link_operstate_from_string(str);
if (s < 0)
return s;
*ret = s;
return 0;
}
| 5,294 | 32.512658 | 95 |
c
|
null |
systemd-main/src/libsystemd/sd-network/network-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <errno.h>
#include <stdbool.h>
#include "macro.h"
bool network_is_online(void);
typedef enum AddressFamily {
/* This is a bitmask, though it usually doesn't feel that way! */
ADDRESS_FAMILY_NO = 0,
ADDRESS_FAMILY_IPV4 = 1 << 0,
ADDRESS_FAMILY_IPV6 = 1 << 1,
ADDRESS_FAMILY_YES = ADDRESS_FAMILY_IPV4 | ADDRESS_FAMILY_IPV6,
_ADDRESS_FAMILY_MAX,
_ADDRESS_FAMILY_INVALID = -EINVAL,
} AddressFamily;
typedef enum LinkOperationalState {
LINK_OPERSTATE_MISSING,
LINK_OPERSTATE_OFF,
LINK_OPERSTATE_NO_CARRIER,
LINK_OPERSTATE_DORMANT,
LINK_OPERSTATE_DEGRADED_CARRIER,
LINK_OPERSTATE_CARRIER,
LINK_OPERSTATE_DEGRADED,
LINK_OPERSTATE_ENSLAVED,
LINK_OPERSTATE_ROUTABLE,
_LINK_OPERSTATE_MAX,
_LINK_OPERSTATE_INVALID = -EINVAL,
} LinkOperationalState;
typedef enum LinkCarrierState {
LINK_CARRIER_STATE_OFF = LINK_OPERSTATE_OFF,
LINK_CARRIER_STATE_NO_CARRIER = LINK_OPERSTATE_NO_CARRIER,
LINK_CARRIER_STATE_DORMANT = LINK_OPERSTATE_DORMANT,
LINK_CARRIER_STATE_DEGRADED_CARRIER = LINK_OPERSTATE_DEGRADED_CARRIER,
LINK_CARRIER_STATE_CARRIER = LINK_OPERSTATE_CARRIER,
LINK_CARRIER_STATE_ENSLAVED = LINK_OPERSTATE_ENSLAVED,
_LINK_CARRIER_STATE_MAX,
_LINK_CARRIER_STATE_INVALID = -EINVAL,
} LinkCarrierState;
typedef enum LinkAddressState {
LINK_ADDRESS_STATE_OFF,
LINK_ADDRESS_STATE_DEGRADED,
LINK_ADDRESS_STATE_ROUTABLE,
_LINK_ADDRESS_STATE_MAX,
_LINK_ADDRESS_STATE_INVALID = -EINVAL,
} LinkAddressState;
typedef enum LinkOnlineState {
LINK_ONLINE_STATE_OFFLINE,
LINK_ONLINE_STATE_PARTIAL,
LINK_ONLINE_STATE_ONLINE,
_LINK_ONLINE_STATE_MAX,
_LINK_ONLINE_STATE_INVALID = -EINVAL,
} LinkOnlineState;
const char* link_operstate_to_string(LinkOperationalState s) _const_;
LinkOperationalState link_operstate_from_string(const char *s) _pure_;
const char* link_carrier_state_to_string(LinkCarrierState s) _const_;
LinkCarrierState link_carrier_state_from_string(const char *s) _pure_;
const char* link_required_address_family_to_string(AddressFamily s) _const_;
AddressFamily link_required_address_family_from_string(const char *s) _pure_;
const char* link_address_state_to_string(LinkAddressState s) _const_;
LinkAddressState link_address_state_from_string(const char *s) _pure_;
const char* link_online_state_to_string(LinkOnlineState s) _const_;
LinkOnlineState link_online_state_from_string(const char *s) _pure_;
typedef struct LinkOperationalStateRange {
LinkOperationalState min;
LinkOperationalState max;
} LinkOperationalStateRange;
#define LINK_OPERSTATE_RANGE_DEFAULT (LinkOperationalStateRange) { LINK_OPERSTATE_DEGRADED, \
LINK_OPERSTATE_ROUTABLE }
int parse_operational_state_range(const char *str, LinkOperationalStateRange *out);
int network_link_get_operational_state(int ifindex, LinkOperationalState *ret);
| 3,249 | 36.356322 | 93 |
h
|
null |
systemd-main/src/libsystemd/sd-network/sd-network.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <poll.h>
#include <sys/inotify.h>
#include "sd-network.h"
#include "alloc-util.h"
#include "env-file.h"
#include "fd-util.h"
#include "fs-util.h"
#include "inotify-util.h"
#include "macro.h"
#include "parse-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "strv.h"
static int network_get_string(const char *field, char **ret) {
_cleanup_free_ char *s = NULL;
int r;
assert_return(ret, -EINVAL);
r = parse_env_file(NULL, "/run/systemd/netif/state", field, &s);
if (r < 0)
return r;
if (isempty(s))
return -ENODATA;
*ret = TAKE_PTR(s);
return 0;
}
int sd_network_get_operational_state(char **ret) {
return network_get_string("OPER_STATE", ret);
}
int sd_network_get_carrier_state(char **ret) {
return network_get_string("CARRIER_STATE", ret);
}
int sd_network_get_address_state(char **ret) {
return network_get_string("ADDRESS_STATE", ret);
}
int sd_network_get_ipv4_address_state(char **ret) {
return network_get_string("IPV4_ADDRESS_STATE", ret);
}
int sd_network_get_ipv6_address_state(char **ret) {
return network_get_string("IPV6_ADDRESS_STATE", ret);
}
int sd_network_get_online_state(char **ret) {
return network_get_string("ONLINE_STATE", ret);
}
static int network_get_strv(const char *key, char ***ret) {
_cleanup_strv_free_ char **a = NULL;
_cleanup_free_ char *s = NULL;
int r;
assert_return(ret, -EINVAL);
r = parse_env_file(NULL, "/run/systemd/netif/state", key, &s);
if (r < 0)
return r;
if (isempty(s))
return -ENODATA;
a = strv_split(s, NULL);
if (!a)
return -ENOMEM;
strv_uniq(a);
r = (int) strv_length(a);
*ret = TAKE_PTR(a);
return r;
}
int sd_network_get_dns(char ***ret) {
return network_get_strv("DNS", ret);
}
int sd_network_get_ntp(char ***ret) {
return network_get_strv("NTP", ret);
}
int sd_network_get_search_domains(char ***ret) {
return network_get_strv("DOMAINS", ret);
}
int sd_network_get_route_domains(char ***ret) {
return network_get_strv("ROUTE_DOMAINS", ret);
}
static int network_link_get_string(int ifindex, const char *field, char **ret) {
char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex)];
_cleanup_free_ char *s = NULL;
int r;
assert_return(ifindex > 0, -EINVAL);
assert_return(ret, -EINVAL);
xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
r = parse_env_file(NULL, path, field, &s);
if (r < 0)
return r;
if (isempty(s))
return -ENODATA;
*ret = TAKE_PTR(s);
return 0;
}
static int network_link_get_boolean(int ifindex, const char *key) {
_cleanup_free_ char *s = NULL;
int r;
r = network_link_get_string(ifindex, key, &s);
if (r < 0)
return r;
return parse_boolean(s);
}
static int network_link_get_strv(int ifindex, const char *key, char ***ret) {
_cleanup_strv_free_ char **a = NULL;
_cleanup_free_ char *s = NULL;
int r;
assert_return(ifindex > 0, -EINVAL);
assert_return(ret, -EINVAL);
r = network_link_get_string(ifindex, key, &s);
if (r < 0)
return r;
a = strv_split(s, NULL);
if (!a)
return -ENOMEM;
strv_uniq(a);
r = (int) strv_length(a);
*ret = TAKE_PTR(a);
return r;
}
int sd_network_link_get_setup_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "ADMIN_STATE", ret);
}
int sd_network_link_get_network_file(int ifindex, char **ret) {
return network_link_get_string(ifindex, "NETWORK_FILE", ret);
}
int sd_network_link_get_network_file_dropins(int ifindex, char ***ret) {
_cleanup_free_ char **sv = NULL, *joined = NULL;
int r;
assert_return(ifindex > 0, -EINVAL);
assert_return(ret, -EINVAL);
r = network_link_get_string(ifindex, "NETWORK_FILE_DROPINS", &joined);
if (r < 0)
return r;
r = strv_split_full(&sv, joined, ":", EXTRACT_CUNESCAPE);
if (r < 0)
return r;
*ret = TAKE_PTR(sv);
return 0;
}
int sd_network_link_get_operational_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "OPER_STATE", ret);
}
int sd_network_link_get_required_family_for_online(int ifindex, char **ret) {
return network_link_get_string(ifindex, "REQUIRED_FAMILY_FOR_ONLINE", ret);
}
int sd_network_link_get_carrier_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "CARRIER_STATE", ret);
}
int sd_network_link_get_address_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "ADDRESS_STATE", ret);
}
int sd_network_link_get_ipv4_address_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "IPV4_ADDRESS_STATE", ret);
}
int sd_network_link_get_ipv6_address_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "IPV6_ADDRESS_STATE", ret);
}
int sd_network_link_get_online_state(int ifindex, char **ret) {
return network_link_get_string(ifindex, "ONLINE_STATE", ret);
}
int sd_network_link_get_dhcp6_client_iaid_string(int ifindex, char **ret) {
return network_link_get_string(ifindex, "DHCP6_CLIENT_IAID", ret);
}
int sd_network_link_get_dhcp6_client_duid_string(int ifindex, char **ret) {
return network_link_get_string(ifindex, "DHCP6_CLIENT_DUID", ret);
}
int sd_network_link_get_required_for_online(int ifindex) {
return network_link_get_boolean(ifindex, "REQUIRED_FOR_ONLINE");
}
int sd_network_link_get_required_operstate_for_online(int ifindex, char **ret) {
return network_link_get_string(ifindex, "REQUIRED_OPER_STATE_FOR_ONLINE", ret);
}
int sd_network_link_get_activation_policy(int ifindex, char **ret) {
return network_link_get_string(ifindex, "ACTIVATION_POLICY", ret);
}
int sd_network_link_get_llmnr(int ifindex, char **ret) {
return network_link_get_string(ifindex, "LLMNR", ret);
}
int sd_network_link_get_mdns(int ifindex, char **ret) {
return network_link_get_string(ifindex, "MDNS", ret);
}
int sd_network_link_get_dns_over_tls(int ifindex, char **ret) {
return network_link_get_string(ifindex, "DNS_OVER_TLS", ret);
}
int sd_network_link_get_dnssec(int ifindex, char **ret) {
return network_link_get_string(ifindex, "DNSSEC", ret);
}
int sd_network_link_get_dnssec_negative_trust_anchors(int ifindex, char ***ret) {
return network_link_get_strv(ifindex, "DNSSEC_NTA", ret);
}
int sd_network_link_get_dns(int ifindex, char ***ret) {
return network_link_get_strv(ifindex, "DNS", ret);
}
int sd_network_link_get_ntp(int ifindex, char ***ret) {
return network_link_get_strv(ifindex, "NTP", ret);
}
int sd_network_link_get_sip(int ifindex, char ***ret) {
return network_link_get_strv(ifindex, "SIP", ret);
}
int sd_network_link_get_captive_portal(int ifindex, char **ret) {
return network_link_get_string(ifindex, "CAPTIVE_PORTAL", ret);
}
int sd_network_link_get_search_domains(int ifindex, char ***ret) {
return network_link_get_strv(ifindex, "DOMAINS", ret);
}
int sd_network_link_get_route_domains(int ifindex, char ***ret) {
return network_link_get_strv(ifindex, "ROUTE_DOMAINS", ret);
}
int sd_network_link_get_dns_default_route(int ifindex) {
return network_link_get_boolean(ifindex, "DNS_DEFAULT_ROUTE");
}
static int network_link_get_ifindexes(int ifindex, const char *key, int **ret) {
_cleanup_free_ int *ifis = NULL;
_cleanup_free_ char *s = NULL;
size_t c = 0;
int r;
assert_return(ifindex > 0, -EINVAL);
assert_return(ret, -EINVAL);
r = network_link_get_string(ifindex, key, &s);
if (r < 0)
return r;
for (const char *x = s;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&x, &word, NULL, 0);
if (r < 0)
return r;
if (r == 0)
break;
if (!GREEDY_REALLOC(ifis, c + 2))
return -ENOMEM;
r = ifis[c++] = parse_ifindex(word);
if (r < 0)
return r;
}
if (ifis)
ifis[c] = 0; /* Let's add a 0 ifindex to the end, to be nice */
*ret = TAKE_PTR(ifis);
return c;
}
int sd_network_link_get_carrier_bound_to(int ifindex, int **ret) {
return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_TO", ret);
}
int sd_network_link_get_carrier_bound_by(int ifindex, int **ret) {
return network_link_get_ifindexes(ifindex, "CARRIER_BOUND_BY", ret);
}
int sd_network_link_get_stat(int ifindex, struct stat *ret) {
char path[STRLEN("/run/systemd/netif/links/") + DECIMAL_STR_MAX(ifindex)];
struct stat st;
assert_return(ifindex > 0, -EINVAL);
xsprintf(path, "/run/systemd/netif/links/%i", ifindex);
if (stat(path, &st) < 0)
return -errno;
if (ret)
*ret = st;
return 0;
}
static int MONITOR_TO_FD(sd_network_monitor *m) {
return (int) (unsigned long) m - 1;
}
static sd_network_monitor* FD_TO_MONITOR(int fd) {
return (sd_network_monitor*) (unsigned long) (fd + 1);
}
static int monitor_add_inotify_watch(int fd) {
int wd;
wd = inotify_add_watch(fd, "/run/systemd/netif/links/", IN_MOVED_TO|IN_DELETE);
if (wd >= 0)
return wd;
else if (errno != ENOENT)
return -errno;
wd = inotify_add_watch(fd, "/run/systemd/netif/", IN_CREATE|IN_ISDIR);
if (wd >= 0)
return wd;
else if (errno != ENOENT)
return -errno;
wd = inotify_add_watch(fd, "/run/systemd/", IN_CREATE|IN_ISDIR);
if (wd < 0)
return -errno;
return wd;
}
int sd_network_monitor_new(sd_network_monitor **m, const char *category) {
_cleanup_close_ int fd = -EBADF;
int k;
bool good = false;
assert_return(m, -EINVAL);
fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
if (fd < 0)
return -errno;
if (!category || streq(category, "links")) {
k = monitor_add_inotify_watch(fd);
if (k < 0)
return k;
good = true;
}
if (!good)
return -EINVAL;
*m = FD_TO_MONITOR(TAKE_FD(fd));
return 0;
}
sd_network_monitor* sd_network_monitor_unref(sd_network_monitor *m) {
if (m)
(void) close_nointr(MONITOR_TO_FD(m));
return NULL;
}
int sd_network_monitor_flush(sd_network_monitor *m) {
union inotify_event_buffer buffer;
ssize_t l;
int fd;
assert_return(m, -EINVAL);
fd = MONITOR_TO_FD(m);
l = read(fd, &buffer, sizeof(buffer));
if (l < 0) {
if (ERRNO_IS_TRANSIENT(errno))
return 0;
return -errno;
}
FOREACH_INOTIFY_EVENT(e, buffer, l) {
if (e->mask & IN_ISDIR) {
int wd;
wd = monitor_add_inotify_watch(fd);
if (wd < 0)
return wd;
if (wd != e->wd) {
if (inotify_rm_watch(fd, e->wd) < 0)
return -errno;
}
}
}
return 0;
}
int sd_network_monitor_get_fd(sd_network_monitor *m) {
assert_return(m, -EINVAL);
return MONITOR_TO_FD(m);
}
int sd_network_monitor_get_events(sd_network_monitor *m) {
assert_return(m, -EINVAL);
/* For now we will only return POLLIN here, since we don't
* need anything else ever for inotify. However, let's have
* this API to keep our options open should we later on need
* it. */
return POLLIN;
}
int sd_network_monitor_get_timeout(sd_network_monitor *m, uint64_t *ret_usec) {
assert_return(m, -EINVAL);
assert_return(ret_usec, -EINVAL);
/* For now we will only return UINT64_MAX, since we don't
* need any timeout. However, let's have this API to keep our
* options open should we later on need it. */
*ret_usec = UINT64_MAX;
return 0;
}
| 12,943 | 26.956803 | 87 |
c
|
null |
systemd-main/src/libsystemd/sd-path/sd-path.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "sd-path.h"
#include "alloc-util.h"
#include "architecture.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "nulstr-util.h"
#include "path-lookup.h"
#include "path-util.h"
#include "string-util.h"
#include "strv.h"
#include "user-util.h"
static int from_environment(const char *envname, const char *fallback, const char **ret) {
assert(ret);
if (envname) {
const char *e;
e = secure_getenv(envname);
if (e && path_is_absolute(e)) {
*ret = e;
return 0;
}
}
if (fallback) {
*ret = fallback;
return 0;
}
return -ENXIO;
}
static int from_home_dir(const char *envname, const char *suffix, char **buffer, const char **ret) {
_cleanup_free_ char *h = NULL;
int r;
assert(suffix);
assert(buffer);
assert(ret);
if (envname) {
const char *e = NULL;
e = secure_getenv(envname);
if (e && path_is_absolute(e)) {
*ret = e;
return 0;
}
}
r = get_home_dir(&h);
if (r < 0)
return r;
if (!path_extend(&h, suffix))
return -ENOMEM;
*buffer = h;
*ret = TAKE_PTR(h);
return 0;
}
static int from_user_dir(const char *field, char **buffer, const char **ret) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *b = NULL;
_cleanup_free_ const char *fn = NULL;
const char *c = NULL;
size_t n;
int r;
assert(field);
assert(buffer);
assert(ret);
r = from_home_dir("XDG_CONFIG_HOME", ".config", &b, &c);
if (r < 0)
return r;
fn = path_join(c, "user-dirs.dirs");
if (!fn)
return -ENOMEM;
f = fopen(fn, "re");
if (!f) {
if (errno == ENOENT)
goto fallback;
return -errno;
}
/* This is an awful parse, but it follows closely what
* xdg-user-dirs does upstream */
n = strlen(field);
for (;;) {
_cleanup_free_ char *line = NULL;
char *l, *p, *e;
r = read_line(f, LONG_LINE_MAX, &line);
if (r < 0)
return r;
if (r == 0)
break;
l = strstrip(line);
if (!strneq(l, field, n))
continue;
p = l + n;
p += strspn(p, WHITESPACE);
if (*p != '=')
continue;
p++;
p += strspn(p, WHITESPACE);
if (*p != '"')
continue;
p++;
e = strrchr(p, '"');
if (!e)
continue;
*e = 0;
/* Three syntaxes permitted: relative to $HOME, $HOME itself, and absolute path */
if (startswith(p, "$HOME/")) {
_cleanup_free_ char *h = NULL;
r = get_home_dir(&h);
if (r < 0)
return r;
if (!path_extend(&h, p+5))
return -ENOMEM;
*buffer = h;
*ret = TAKE_PTR(h);
return 0;
} else if (streq(p, "$HOME")) {
r = get_home_dir(buffer);
if (r < 0)
return r;
*ret = *buffer;
return 0;
} else if (path_is_absolute(p)) {
char *copy;
copy = strdup(p);
if (!copy)
return -ENOMEM;
*buffer = copy;
*ret = copy;
return 0;
}
}
fallback:
/* The desktop directory defaults to $HOME/Desktop, the others to $HOME */
if (streq(field, "XDG_DESKTOP_DIR")) {
_cleanup_free_ char *h = NULL;
r = get_home_dir(&h);
if (r < 0)
return r;
if (!path_extend(&h, "Desktop"))
return -ENOMEM;
*buffer = h;
*ret = TAKE_PTR(h);
} else {
r = get_home_dir(buffer);
if (r < 0)
return r;
*ret = *buffer;
}
return 0;
}
static int get_path(uint64_t type, char **buffer, const char **ret) {
int r;
assert(buffer);
assert(ret);
switch (type) {
case SD_PATH_TEMPORARY:
return tmp_dir(ret);
case SD_PATH_TEMPORARY_LARGE:
return var_tmp_dir(ret);
case SD_PATH_SYSTEM_BINARIES:
*ret = "/usr/bin";
return 0;
case SD_PATH_SYSTEM_INCLUDE:
*ret = "/usr/include";
return 0;
case SD_PATH_SYSTEM_LIBRARY_PRIVATE:
*ret = "/usr/lib";
return 0;
case SD_PATH_SYSTEM_LIBRARY_ARCH:
*ret = LIBDIR;
return 0;
case SD_PATH_SYSTEM_SHARED:
*ret = "/usr/share";
return 0;
case SD_PATH_SYSTEM_CONFIGURATION_FACTORY:
*ret = "/usr/share/factory/etc";
return 0;
case SD_PATH_SYSTEM_STATE_FACTORY:
*ret = "/usr/share/factory/var";
return 0;
case SD_PATH_SYSTEM_CONFIGURATION:
*ret = "/etc";
return 0;
case SD_PATH_SYSTEM_RUNTIME:
*ret = "/run";
return 0;
case SD_PATH_SYSTEM_RUNTIME_LOGS:
*ret = "/run/log";
return 0;
case SD_PATH_SYSTEM_STATE_PRIVATE:
*ret = "/var/lib";
return 0;
case SD_PATH_SYSTEM_STATE_LOGS:
*ret = "/var/log";
return 0;
case SD_PATH_SYSTEM_STATE_CACHE:
*ret = "/var/cache";
return 0;
case SD_PATH_SYSTEM_STATE_SPOOL:
*ret = "/var/spool";
return 0;
case SD_PATH_USER_BINARIES:
return from_home_dir(NULL, ".local/bin", buffer, ret);
case SD_PATH_USER_LIBRARY_PRIVATE:
return from_home_dir(NULL, ".local/lib", buffer, ret);
case SD_PATH_USER_LIBRARY_ARCH:
return from_home_dir(NULL, ".local/lib/" LIB_ARCH_TUPLE, buffer, ret);
case SD_PATH_USER_SHARED:
return from_home_dir("XDG_DATA_HOME", ".local/share", buffer, ret);
case SD_PATH_USER_CONFIGURATION:
return from_home_dir("XDG_CONFIG_HOME", ".config", buffer, ret);
case SD_PATH_USER_RUNTIME:
return from_environment("XDG_RUNTIME_DIR", NULL, ret);
case SD_PATH_USER_STATE_CACHE:
return from_home_dir("XDG_CACHE_HOME", ".cache", buffer, ret);
case SD_PATH_USER_STATE_PRIVATE:
return from_home_dir("XDG_STATE_HOME", ".local/state", buffer, ret);
case SD_PATH_USER:
r = get_home_dir(buffer);
if (r < 0)
return r;
*ret = *buffer;
return 0;
case SD_PATH_USER_DOCUMENTS:
return from_user_dir("XDG_DOCUMENTS_DIR", buffer, ret);
case SD_PATH_USER_MUSIC:
return from_user_dir("XDG_MUSIC_DIR", buffer, ret);
case SD_PATH_USER_PICTURES:
return from_user_dir("XDG_PICTURES_DIR", buffer, ret);
case SD_PATH_USER_VIDEOS:
return from_user_dir("XDG_VIDEOS_DIR", buffer, ret);
case SD_PATH_USER_DOWNLOAD:
return from_user_dir("XDG_DOWNLOAD_DIR", buffer, ret);
case SD_PATH_USER_PUBLIC:
return from_user_dir("XDG_PUBLICSHARE_DIR", buffer, ret);
case SD_PATH_USER_TEMPLATES:
return from_user_dir("XDG_TEMPLATES_DIR", buffer, ret);
case SD_PATH_USER_DESKTOP:
return from_user_dir("XDG_DESKTOP_DIR", buffer, ret);
case SD_PATH_SYSTEMD_UTIL:
*ret = ROOTPREFIX_NOSLASH "/lib/systemd";
return 0;
case SD_PATH_SYSTEMD_SYSTEM_UNIT:
*ret = SYSTEM_DATA_UNIT_DIR;
return 0;
case SD_PATH_SYSTEMD_SYSTEM_PRESET:
*ret = ROOTPREFIX_NOSLASH "/lib/systemd/system-preset";
return 0;
case SD_PATH_SYSTEMD_USER_UNIT:
*ret = USER_DATA_UNIT_DIR;
return 0;
case SD_PATH_SYSTEMD_USER_PRESET:
*ret = ROOTPREFIX_NOSLASH "/lib/systemd/user-preset";
return 0;
case SD_PATH_SYSTEMD_SYSTEM_CONF:
*ret = SYSTEM_CONFIG_UNIT_DIR;
return 0;
case SD_PATH_SYSTEMD_USER_CONF:
*ret = USER_CONFIG_UNIT_DIR;
return 0;
case SD_PATH_SYSTEMD_SYSTEM_GENERATOR:
*ret = SYSTEM_GENERATOR_DIR;
return 0;
case SD_PATH_SYSTEMD_USER_GENERATOR:
*ret = USER_GENERATOR_DIR;
return 0;
case SD_PATH_SYSTEMD_SLEEP:
*ret = ROOTPREFIX_NOSLASH "/lib/systemd/system-sleep";
return 0;
case SD_PATH_SYSTEMD_SHUTDOWN:
*ret = ROOTPREFIX_NOSLASH "/lib/systemd/system-shutdown";
return 0;
case SD_PATH_TMPFILES:
*ret = "/usr/lib/tmpfiles.d";
return 0;
case SD_PATH_SYSUSERS:
*ret = ROOTPREFIX_NOSLASH "/lib/sysusers.d";
return 0;
case SD_PATH_SYSCTL:
*ret = ROOTPREFIX_NOSLASH "/lib/sysctl.d";
return 0;
case SD_PATH_BINFMT:
*ret = ROOTPREFIX_NOSLASH "/lib/binfmt.d";
return 0;
case SD_PATH_MODULES_LOAD:
*ret = ROOTPREFIX_NOSLASH "/lib/modules-load.d";
return 0;
case SD_PATH_CATALOG:
*ret = "/usr/lib/systemd/catalog";
return 0;
case SD_PATH_SYSTEMD_SYSTEM_ENVIRONMENT_GENERATOR:
*ret = SYSTEM_ENV_GENERATOR_DIR;
return 0;
case SD_PATH_SYSTEMD_USER_ENVIRONMENT_GENERATOR:
*ret = USER_ENV_GENERATOR_DIR;
return 0;
}
return -EOPNOTSUPP;
}
static int get_path_alloc(uint64_t type, const char *suffix, char **path) {
_cleanup_free_ char *buffer = NULL;
char *buffer2 = NULL;
const char *ret;
int r;
assert(path);
r = get_path(type, &buffer, &ret);
if (r < 0)
return r;
if (suffix) {
suffix += strspn(suffix, "/");
buffer2 = path_join(ret, suffix);
if (!buffer2)
return -ENOMEM;
} else if (!buffer) {
buffer = strdup(ret);
if (!buffer)
return -ENOMEM;
}
*path = buffer2 ?: TAKE_PTR(buffer);
return 0;
}
_public_ int sd_path_lookup(uint64_t type, const char *suffix, char **path) {
int r;
assert_return(path, -EINVAL);
r = get_path_alloc(type, suffix, path);
if (r != -EOPNOTSUPP)
return r;
/* Fall back to sd_path_lookup_strv */
_cleanup_strv_free_ char **l = NULL;
char *buffer;
r = sd_path_lookup_strv(type, suffix, &l);
if (r < 0)
return r;
buffer = strv_join(l, ":");
if (!buffer)
return -ENOMEM;
*path = buffer;
return 0;
}
static int search_from_environment(
char ***list,
const char *env_home,
const char *home_suffix,
const char *env_search,
bool env_search_sufficient,
const char *first, ...) {
_cleanup_strv_free_ char **l = NULL;
const char *e;
char *h = NULL;
int r;
assert(list);
if (env_search) {
e = secure_getenv(env_search);
if (e) {
l = strv_split(e, ":");
if (!l)
return -ENOMEM;
if (env_search_sufficient) {
*list = TAKE_PTR(l);
return 0;
}
}
}
if (!l && first) {
va_list ap;
va_start(ap, first);
l = strv_new_ap(first, ap);
va_end(ap);
if (!l)
return -ENOMEM;
}
if (env_home) {
e = secure_getenv(env_home);
if (e && path_is_absolute(e)) {
h = strdup(e);
if (!h)
return -ENOMEM;
}
}
if (!h && home_suffix) {
e = secure_getenv("HOME");
if (e && path_is_absolute(e)) {
h = path_join(e, home_suffix);
if (!h)
return -ENOMEM;
}
}
if (h) {
r = strv_consume_prepend(&l, h);
if (r < 0)
return -ENOMEM;
}
*list = TAKE_PTR(l);
return 0;
}
#if HAVE_SPLIT_BIN
# define ARRAY_SBIN_BIN(x) x "sbin", x "bin"
#else
# define ARRAY_SBIN_BIN(x) x "bin"
#endif
static int get_search(uint64_t type, char ***list) {
int r;
assert(list);
switch (type) {
case SD_PATH_SEARCH_BINARIES:
return search_from_environment(list,
NULL,
".local/bin",
"PATH",
true,
ARRAY_SBIN_BIN("/usr/local/"),
ARRAY_SBIN_BIN("/usr/"),
#if HAVE_SPLIT_USR
ARRAY_SBIN_BIN("/"),
#endif
NULL);
case SD_PATH_SEARCH_LIBRARY_PRIVATE:
return search_from_environment(list,
NULL,
".local/lib",
NULL,
false,
"/usr/local/lib",
"/usr/lib",
#if HAVE_SPLIT_USR
"/lib",
#endif
NULL);
case SD_PATH_SEARCH_LIBRARY_ARCH:
return search_from_environment(list,
NULL,
".local/lib/" LIB_ARCH_TUPLE,
"LD_LIBRARY_PATH",
true,
LIBDIR,
#if HAVE_SPLIT_USR
ROOTLIBDIR,
#endif
NULL);
case SD_PATH_SEARCH_SHARED:
return search_from_environment(list,
"XDG_DATA_HOME",
".local/share",
"XDG_DATA_DIRS",
false,
"/usr/local/share",
"/usr/share",
NULL);
case SD_PATH_SEARCH_CONFIGURATION_FACTORY:
return search_from_environment(list,
NULL,
NULL,
NULL,
false,
"/usr/local/share/factory/etc",
"/usr/share/factory/etc",
NULL);
case SD_PATH_SEARCH_STATE_FACTORY:
return search_from_environment(list,
NULL,
NULL,
NULL,
false,
"/usr/local/share/factory/var",
"/usr/share/factory/var",
NULL);
case SD_PATH_SEARCH_CONFIGURATION:
return search_from_environment(list,
"XDG_CONFIG_HOME",
".config",
"XDG_CONFIG_DIRS",
false,
"/etc",
NULL);
case SD_PATH_SEARCH_BINARIES_DEFAULT:
return strv_from_nulstr(list, DEFAULT_PATH_NULSTR);
case SD_PATH_SYSTEMD_SEARCH_SYSTEM_UNIT:
case SD_PATH_SYSTEMD_SEARCH_USER_UNIT: {
_cleanup_(lookup_paths_free) LookupPaths lp = {};
RuntimeScope scope = type == SD_PATH_SYSTEMD_SEARCH_SYSTEM_UNIT ?
RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER;
r = lookup_paths_init(&lp, scope, 0, NULL);
if (r < 0)
return r;
*list = TAKE_PTR(lp.search_path);
return 0;
}
case SD_PATH_SYSTEMD_SEARCH_SYSTEM_GENERATOR:
case SD_PATH_SYSTEMD_SEARCH_USER_GENERATOR: {
RuntimeScope scope = type == SD_PATH_SYSTEMD_SEARCH_SYSTEM_GENERATOR ?
RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER;
char **t;
t = generator_binary_paths(scope);
if (!t)
return -ENOMEM;
*list = t;
return 0;
}
case SD_PATH_SYSTEMD_SEARCH_SYSTEM_ENVIRONMENT_GENERATOR:
case SD_PATH_SYSTEMD_SEARCH_USER_ENVIRONMENT_GENERATOR: {
char **t;
t = env_generator_binary_paths(type == SD_PATH_SYSTEMD_SEARCH_SYSTEM_ENVIRONMENT_GENERATOR ?
RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER);
if (!t)
return -ENOMEM;
*list = t;
return 0;
}
case SD_PATH_SYSTEMD_SEARCH_NETWORK:
return strv_from_nulstr(list, NETWORK_DIRS_NULSTR);
}
return -EOPNOTSUPP;
}
_public_ int sd_path_lookup_strv(uint64_t type, const char *suffix, char ***paths) {
_cleanup_strv_free_ char **l = NULL, **n = NULL;
int r;
assert_return(paths, -EINVAL);
r = get_search(type, &l);
if (r == -EOPNOTSUPP) {
_cleanup_free_ char *t = NULL;
r = get_path_alloc(type, suffix, &t);
if (r < 0)
return r;
l = new(char*, 2);
if (!l)
return -ENOMEM;
l[0] = TAKE_PTR(t);
l[1] = NULL;
*paths = TAKE_PTR(l);
return 0;
} else if (r < 0)
return r;
if (!suffix) {
*paths = TAKE_PTR(l);
return 0;
}
n = new(char*, strv_length(l)+1);
if (!n)
return -ENOMEM;
char **j = n;
STRV_FOREACH(i, l) {
*j = path_join(*i, suffix);
if (!*j)
return -ENOMEM;
j++;
}
*j = NULL;
*paths = TAKE_PTR(n);
return 0;
}
| 21,040 | 28.67701 | 108 |
c
|
null |
systemd-main/src/libsystemd/sd-resolve/resolve-private.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-resolve.h"
int resolve_getaddrinfo_with_destroy_callback(
sd_resolve *resolve, sd_resolve_query **q,
const char *node, const char *service, const struct addrinfo *hints,
sd_resolve_getaddrinfo_handler_t callback,
sd_resolve_destroy_t destroy_callback, void *userdata);
int resolve_getnameinfo_with_destroy_callback(
sd_resolve *resolve, sd_resolve_query **q,
const struct sockaddr *sa, socklen_t salen, int flags, uint64_t get,
sd_resolve_getnameinfo_handler_t callback,
sd_resolve_destroy_t destroy_callback, void *userdata);
#define resolve_getaddrinfo(resolve, ret_query, node, service, hints, callback, destroy_callback, userdata) \
({ \
int (*_callback_)(sd_resolve_query*, int, const struct addrinfo*, typeof(userdata)) = callback; \
void (*_destroy_)(typeof(userdata)) = destroy_callback; \
resolve_getaddrinfo_with_destroy_callback( \
resolve, ret_query, \
node, service, hints, \
(sd_resolve_getaddrinfo_handler_t) _callback_, \
(sd_resolve_destroy_t) _destroy_, \
userdata); \
})
#define resolve_getnameinfo(resolve, ret_query, sa, salen, flags, get, callback, destroy_callback, userdata) \
({ \
int (*_callback_)(sd_resolve_query*, int, const char*, const char*, typeof(userdata)) = callback; \
void (*_destroy_)(typeof(userdata)) = destroy_callback; \
resolve_getaddrinfo_with_destroy_callback( \
resolve, ret_query, \
sa, salen, flags, get, \
(sd_resolve_getnameinfo_handler_t) _callback_, \
(sd_resolve_destroy_t) _destroy_, \
userdata); \
})
| 2,391 | 58.8 | 115 |
h
|
null |
systemd-main/src/libsystemd/sd-resolve/test-resolve.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <arpa/inet.h>
#include <errno.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <resolv.h>
#include <stdio.h>
#include "sd-resolve.h"
#include "alloc-util.h"
#include "macro.h"
#include "socket-util.h"
#include "string-util.h"
#include "time-util.h"
#define TEST_TIMEOUT_USEC (20*USEC_PER_SEC)
static int getaddrinfo_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
const struct addrinfo *i;
assert_se(q);
if (ret != 0) {
log_error("getaddrinfo error: %s %i", gai_strerror(ret), ret);
return 0;
}
for (i = ai; i; i = i->ai_next) {
_cleanup_free_ char *addr = NULL;
assert_se(sockaddr_pretty(i->ai_addr, i->ai_addrlen, false, true, &addr) == 0);
puts(addr);
}
printf("canonical name: %s\n", strna(ai->ai_canonname));
return 0;
}
static int getnameinfo_handler(sd_resolve_query *q, int ret, const char *host, const char *serv, void *userdata) {
assert_se(q);
if (ret != 0) {
log_error("getnameinfo error: %s %i", gai_strerror(ret), ret);
return 0;
}
printf("Host: %s — Serv: %s\n", strna(host), strna(serv));
return 0;
}
int main(int argc, char *argv[]) {
_cleanup_(sd_resolve_query_unrefp) sd_resolve_query *q1 = NULL, *q2 = NULL;
_cleanup_(sd_resolve_unrefp) sd_resolve *resolve = NULL;
int r;
struct addrinfo hints = {
.ai_family = AF_UNSPEC,
.ai_socktype = SOCK_STREAM,
.ai_flags = AI_CANONNAME,
};
union sockaddr_union sa = {
.in.sin_family = AF_INET,
.in.sin_port = htobe16(80),
};
assert_se(sd_resolve_default(&resolve) >= 0);
/* Test a floating resolver query */
r = sd_resolve_getaddrinfo(resolve, NULL, "redhat.com", "http", NULL, getaddrinfo_handler, NULL);
if (r < 0)
log_error_errno(r, "sd_resolve_getaddrinfo(): %m");
/* Make a name -> address query */
r = sd_resolve_getaddrinfo(resolve, &q1, argc >= 2 ? argv[1] : "www.heise.de", NULL, &hints, getaddrinfo_handler, NULL);
if (r < 0)
log_error_errno(r, "sd_resolve_getaddrinfo(): %m");
/* Make an address -> name query */
sa.in.sin_addr.s_addr = inet_addr(argc >= 3 ? argv[2] : "193.99.144.71");
r = sd_resolve_getnameinfo(resolve, &q2, &sa.sa, SOCKADDR_LEN(sa), 0, SD_RESOLVE_GET_BOTH, getnameinfo_handler, NULL);
if (r < 0)
log_error_errno(r, "sd_resolve_getnameinfo(): %m");
/* Wait until all queries are completed */
for (;;) {
r = sd_resolve_wait(resolve, TEST_TIMEOUT_USEC);
if (r == 0)
break;
if (r == -ETIMEDOUT) {
/* Let's catch timeouts here, so that we can run safely in a CI that has no reliable DNS. Note
* that we invoke exit() directly here, as the stuck NSS call will not allow us to exit
* cleanly. */
log_notice_errno(r, "sd_resolve_wait() timed out, but that's OK");
exit(EXIT_SUCCESS);
}
if (r < 0) {
log_error_errno(r, "sd_resolve_wait(): %m");
assert_not_reached();
}
}
return 0;
}
| 3,603 | 32.06422 | 128 |
c
|
null |
systemd-main/src/libudev/libudev-enumerate.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <dirent.h>
#include <errno.h>
#include <fnmatch.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include "libudev.h"
#include "sd-device.h"
#include "alloc-util.h"
#include "device-enumerator-private.h"
#include "device-util.h"
#include "libudev-device-internal.h"
#include "libudev-list-internal.h"
/**
* SECTION:libudev-enumerate
* @short_description: lookup and sort sys devices
*
* Lookup devices in the sys filesystem, filter devices by properties,
* and return a sorted list of devices.
*/
/**
* udev_enumerate:
*
* Opaque object representing one device lookup/sort context.
*/
struct udev_enumerate {
struct udev *udev;
unsigned n_ref;
struct udev_list *devices_list;
bool devices_uptodate:1;
sd_device_enumerator *enumerator;
};
/**
* udev_enumerate_new:
* @udev: udev library context
*
* Create an enumeration context to scan /sys.
*
* Returns: an enumeration context.
**/
_public_ struct udev_enumerate *udev_enumerate_new(struct udev *udev) {
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
_cleanup_(udev_list_freep) struct udev_list *list = NULL;
struct udev_enumerate *udev_enumerate;
int r;
r = sd_device_enumerator_new(&e);
if (r < 0)
return_with_errno(NULL, r);
r = sd_device_enumerator_allow_uninitialized(e);
if (r < 0)
return_with_errno(NULL, r);
list = udev_list_new(false);
if (!list)
return_with_errno(NULL, ENOMEM);
udev_enumerate = new(struct udev_enumerate, 1);
if (!udev_enumerate)
return_with_errno(NULL, ENOMEM);
*udev_enumerate = (struct udev_enumerate) {
.udev = udev,
.n_ref = 1,
.enumerator = TAKE_PTR(e),
.devices_list = TAKE_PTR(list),
};
return udev_enumerate;
}
static struct udev_enumerate *udev_enumerate_free(struct udev_enumerate *udev_enumerate) {
assert(udev_enumerate);
udev_list_free(udev_enumerate->devices_list);
sd_device_enumerator_unref(udev_enumerate->enumerator);
return mfree(udev_enumerate);
}
/**
* udev_enumerate_ref:
* @udev_enumerate: context
*
* Take a reference of an enumeration context.
*
* Returns: the passed enumeration context
**/
/**
* udev_enumerate_unref:
* @udev_enumerate: context
*
* Drop a reference of an enumeration context. If the refcount reaches zero,
* all resources of the enumeration context will be released.
*
* Returns: #NULL
**/
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(struct udev_enumerate, udev_enumerate, udev_enumerate_free);
/**
* udev_enumerate_get_udev:
* @udev_enumerate: context
*
* Get the udev library context.
*
* Returns: a pointer to the context.
*/
_public_ struct udev *udev_enumerate_get_udev(struct udev_enumerate *udev_enumerate) {
assert_return_errno(udev_enumerate, NULL, EINVAL);
return udev_enumerate->udev;
}
/**
* udev_enumerate_get_list_entry:
* @udev_enumerate: context
*
* Get the first entry of the sorted list of device paths.
*
* Returns: a udev_list_entry.
*/
_public_ struct udev_list_entry *udev_enumerate_get_list_entry(struct udev_enumerate *udev_enumerate) {
struct udev_list_entry *e;
assert_return_errno(udev_enumerate, NULL, EINVAL);
if (!udev_enumerate->devices_uptodate) {
sd_device *device;
udev_list_cleanup(udev_enumerate->devices_list);
FOREACH_DEVICE_AND_SUBSYSTEM(udev_enumerate->enumerator, device) {
const char *syspath;
int r;
r = sd_device_get_syspath(device, &syspath);
if (r < 0)
return_with_errno(NULL, r);
if (!udev_list_entry_add(udev_enumerate->devices_list, syspath, NULL))
return_with_errno(NULL, ENOMEM);
}
udev_enumerate->devices_uptodate = true;
}
e = udev_list_get_entry(udev_enumerate->devices_list);
if (!e)
return_with_errno(NULL, ENODATA);
return e;
}
/**
* udev_enumerate_add_match_subsystem:
* @udev_enumerate: context
* @subsystem: filter for a subsystem of the device to include in the list
*
* Match only devices belonging to a certain kernel subsystem.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!subsystem)
return 0;
r = sd_device_enumerator_add_match_subsystem(udev_enumerate->enumerator, subsystem, true);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_nomatch_subsystem:
* @udev_enumerate: context
* @subsystem: filter for a subsystem of the device to exclude from the list
*
* Match only devices not belonging to a certain kernel subsystem.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_nomatch_subsystem(struct udev_enumerate *udev_enumerate, const char *subsystem) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!subsystem)
return 0;
r = sd_device_enumerator_add_match_subsystem(udev_enumerate->enumerator, subsystem, false);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_match_sysattr:
* @udev_enumerate: context
* @sysattr: filter for a sys attribute at the device to include in the list
* @value: optional value of the sys attribute
*
* Match only devices with a certain /sys device attribute.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!sysattr)
return 0;
r = sd_device_enumerator_add_match_sysattr(udev_enumerate->enumerator, sysattr, value, true);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_nomatch_sysattr:
* @udev_enumerate: context
* @sysattr: filter for a sys attribute at the device to exclude from the list
* @value: optional value of the sys attribute
*
* Match only devices not having a certain /sys device attribute.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_nomatch_sysattr(struct udev_enumerate *udev_enumerate, const char *sysattr, const char *value) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!sysattr)
return 0;
r = sd_device_enumerator_add_match_sysattr(udev_enumerate->enumerator, sysattr, value, false);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_match_property:
* @udev_enumerate: context
* @property: filter for a property of the device to include in the list
* @value: value of the property
*
* Match only devices with a certain property.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_property(struct udev_enumerate *udev_enumerate, const char *property, const char *value) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!property)
return 0;
r = sd_device_enumerator_add_match_property(udev_enumerate->enumerator, property, value);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_match_tag:
* @udev_enumerate: context
* @tag: filter for a tag of the device to include in the list
*
* Match only devices with a certain tag.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_tag(struct udev_enumerate *udev_enumerate, const char *tag) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!tag)
return 0;
r = sd_device_enumerator_add_match_tag(udev_enumerate->enumerator, tag);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_match_parent:
* @udev_enumerate: context
* @parent: parent device where to start searching
*
* Return the devices on the subtree of one given device. The parent
* itself is included in the list.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_parent(struct udev_enumerate *udev_enumerate, struct udev_device *parent) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!parent)
return 0;
r = sd_device_enumerator_add_match_parent(udev_enumerate->enumerator, udev_device_get_sd_device(parent));
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_match_is_initialized:
* @udev_enumerate: context
*
* Match only devices which udev has set up already. This makes
* sure, that the device node permissions and context are properly set
* and that network devices are fully renamed.
*
* Usually, devices which are found in the kernel but not already
* handled by udev, have still pending events. Services should subscribe
* to monitor events and wait for these devices to become ready, instead
* of using uninitialized devices.
*
* For now, this will not affect devices which do not have a device node
* and are not network interfaces.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_is_initialized(struct udev_enumerate *udev_enumerate) {
int r;
assert_return(udev_enumerate, -EINVAL);
r = device_enumerator_add_match_is_initialized(udev_enumerate->enumerator, MATCH_INITIALIZED_COMPAT);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_match_sysname:
* @udev_enumerate: context
* @sysname: filter for the name of the device to include in the list
*
* Match only devices with a given /sys device name.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_match_sysname(struct udev_enumerate *udev_enumerate, const char *sysname) {
int r;
assert_return(udev_enumerate, -EINVAL);
if (!sysname)
return 0;
r = sd_device_enumerator_add_match_sysname(udev_enumerate->enumerator, sysname);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_add_syspath:
* @udev_enumerate: context
* @syspath: path of a device
*
* Add a device to the list of devices, to retrieve it back sorted in dependency order.
*
* Returns: 0 on success, otherwise a negative error value.
*/
_public_ int udev_enumerate_add_syspath(struct udev_enumerate *udev_enumerate, const char *syspath) {
_cleanup_(sd_device_unrefp) sd_device *device = NULL;
int r;
assert_return(udev_enumerate, -EINVAL);
if (!syspath)
return 0;
r = sd_device_new_from_syspath(&device, syspath);
if (r < 0)
return r;
r = device_enumerator_add_device(udev_enumerate->enumerator, device);
if (r < 0)
return r;
udev_enumerate->devices_uptodate = false;
return 0;
}
/**
* udev_enumerate_scan_devices:
* @udev_enumerate: udev enumeration context
*
* Scan /sys for all devices which match the given filters. No matches
* will return all currently available devices.
*
* Returns: 0 on success, otherwise a negative error value.
**/
_public_ int udev_enumerate_scan_devices(struct udev_enumerate *udev_enumerate) {
assert_return(udev_enumerate, -EINVAL);
return device_enumerator_scan_devices(udev_enumerate->enumerator);
}
/**
* udev_enumerate_scan_subsystems:
* @udev_enumerate: udev enumeration context
*
* Scan /sys for all kernel subsystems, including buses, classes, drivers.
*
* Returns: 0 on success, otherwise a negative error value.
**/
_public_ int udev_enumerate_scan_subsystems(struct udev_enumerate *udev_enumerate) {
assert_return(udev_enumerate, -EINVAL);
return device_enumerator_scan_subsystems(udev_enumerate->enumerator);
}
| 13,112 | 27.568627 | 128 |
c
|
null |
systemd-main/src/libudev/libudev-hwdb.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "sd-hwdb.h"
#include "alloc-util.h"
#include "hwdb-util.h"
#include "libudev-list-internal.h"
/**
* SECTION:libudev-hwdb
* @short_description: retrieve properties from the hardware database
*
* Libudev hardware database interface.
*/
/**
* udev_hwdb:
*
* Opaque object representing the hardware database.
*/
struct udev_hwdb {
unsigned n_ref;
sd_hwdb *hwdb;
struct udev_list *properties_list;
};
/**
* udev_hwdb_new:
* @udev: udev library context (unused)
*
* Create a hardware database context to query properties for devices.
*
* Returns: a hwdb context.
**/
_public_ struct udev_hwdb *udev_hwdb_new(struct udev *udev) {
_cleanup_(udev_list_freep) struct udev_list *list = NULL;
_cleanup_(sd_hwdb_unrefp) sd_hwdb *hwdb_internal = NULL;
struct udev_hwdb *hwdb;
int r;
r = sd_hwdb_new(&hwdb_internal);
if (r < 0)
return_with_errno(NULL, r);
list = udev_list_new(true);
if (!list)
return_with_errno(NULL, ENOMEM);
hwdb = new(struct udev_hwdb, 1);
if (!hwdb)
return_with_errno(NULL, ENOMEM);
*hwdb = (struct udev_hwdb) {
.n_ref = 1,
.hwdb = TAKE_PTR(hwdb_internal),
.properties_list = TAKE_PTR(list),
};
return hwdb;
}
static struct udev_hwdb *udev_hwdb_free(struct udev_hwdb *hwdb) {
assert(hwdb);
sd_hwdb_unref(hwdb->hwdb);
udev_list_free(hwdb->properties_list);
return mfree(hwdb);
}
/**
* udev_hwdb_ref:
* @hwdb: context
*
* Take a reference of a hwdb context.
*
* Returns: the passed enumeration context
**/
/**
* udev_hwdb_unref:
* @hwdb: context
*
* Drop a reference of a hwdb context. If the refcount reaches zero,
* all resources of the hwdb context will be released.
*
* Returns: #NULL
**/
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(struct udev_hwdb, udev_hwdb, udev_hwdb_free);
/**
* udev_hwdb_get_properties_list_entry:
* @hwdb: context
* @modalias: modalias string
* @flags: (unused)
*
* Lookup a matching device in the hardware database. The lookup key is a
* modalias string, whose formats are defined for the Linux kernel modules.
* Examples are: pci:v00008086d00001C2D*, usb:v04F2pB221*. The first entry
* of a list of retrieved properties is returned.
*
* Returns: a udev_list_entry.
*/
_public_ struct udev_list_entry *udev_hwdb_get_properties_list_entry(struct udev_hwdb *hwdb, const char *modalias, unsigned flags) {
const char *key, *value;
struct udev_list_entry *e;
assert_return_errno(hwdb, NULL, EINVAL);
assert_return_errno(modalias, NULL, EINVAL);
udev_list_cleanup(hwdb->properties_list);
SD_HWDB_FOREACH_PROPERTY(hwdb->hwdb, modalias, key, value)
if (!udev_list_entry_add(hwdb->properties_list, key, value))
return_with_errno(NULL, ENOMEM);
e = udev_list_get_entry(hwdb->properties_list);
if (!e)
return_with_errno(NULL, ENODATA);
return e;
}
| 3,190 | 24.733871 | 132 |
c
|
null |
systemd-main/src/libudev/libudev-list-internal.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "libudev.h"
#include "macro.h"
struct udev_list;
struct udev_list *udev_list_new(bool unique);
void udev_list_cleanup(struct udev_list *list);
struct udev_list *udev_list_free(struct udev_list *list);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_list *, udev_list_free);
struct udev_list_entry *udev_list_get_entry(struct udev_list *list);
struct udev_list_entry *udev_list_entry_add(struct udev_list *list, const char *name, const char *value);
| 517 | 29.470588 | 105 |
h
|
null |
systemd-main/src/libudev/libudev-list.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "hashmap.h"
#include "libudev-list-internal.h"
#include "list.h"
#include "sort-util.h"
/**
* SECTION:libudev-list
* @short_description: list operation
*
* Libudev list operations.
*/
/**
* udev_list_entry:
*
* Opaque object representing one entry in a list. An entry contains
* contains a name, and optionally a value.
*/
struct udev_list_entry {
struct udev_list *list;
char *name;
char *value;
LIST_FIELDS(struct udev_list_entry, entries);
};
struct udev_list {
Hashmap *unique_entries;
LIST_HEAD(struct udev_list_entry, entries);
bool unique:1;
bool uptodate:1;
};
static struct udev_list_entry *udev_list_entry_free(struct udev_list_entry *entry) {
if (!entry)
return NULL;
if (entry->list) {
if (entry->list->unique && entry->name)
hashmap_remove(entry->list->unique_entries, entry->name);
if (!entry->list->unique || entry->list->uptodate)
LIST_REMOVE(entries, entry->list->entries, entry);
}
free(entry->name);
free(entry->value);
return mfree(entry);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_list_entry *, udev_list_entry_free);
struct udev_list *udev_list_new(bool unique) {
struct udev_list *list;
list = new(struct udev_list, 1);
if (!list)
return NULL;
*list = (struct udev_list) {
.unique = unique,
};
return list;
}
struct udev_list_entry *udev_list_entry_add(struct udev_list *list, const char *_name, const char *_value) {
_cleanup_(udev_list_entry_freep) struct udev_list_entry *entry = NULL;
_cleanup_free_ char *name = NULL, *value = NULL;
assert(list);
assert(_name);
name = strdup(_name);
if (!name)
return NULL;
if (_value) {
value = strdup(_value);
if (!value)
return NULL;
}
entry = new(struct udev_list_entry, 1);
if (!entry)
return NULL;
*entry = (struct udev_list_entry) {
.name = TAKE_PTR(name),
.value = TAKE_PTR(value),
};
if (list->unique) {
udev_list_entry_free(hashmap_get(list->unique_entries, entry->name));
if (hashmap_ensure_put(&list->unique_entries, &string_hash_ops, entry->name, entry) < 0)
return NULL;
list->uptodate = false;
} else
LIST_APPEND(entries, list->entries, entry);
entry->list = list;
return TAKE_PTR(entry);
}
void udev_list_cleanup(struct udev_list *list) {
if (!list)
return;
if (list->unique) {
list->uptodate = false;
hashmap_clear_with_destructor(list->unique_entries, udev_list_entry_free);
} else
LIST_FOREACH(entries, i, list->entries)
udev_list_entry_free(i);
}
struct udev_list *udev_list_free(struct udev_list *list) {
if (!list)
return NULL;
udev_list_cleanup(list);
hashmap_free(list->unique_entries);
return mfree(list);
}
static int udev_list_entry_compare_func(struct udev_list_entry * const *a, struct udev_list_entry * const *b) {
return strcmp((*a)->name, (*b)->name);
}
struct udev_list_entry *udev_list_get_entry(struct udev_list *list) {
if (!list)
return NULL;
if (list->unique && !list->uptodate) {
size_t n;
LIST_HEAD_INIT(list->entries);
n = hashmap_size(list->unique_entries);
if (n == 0)
;
else if (n == 1)
LIST_PREPEND(entries, list->entries, hashmap_first(list->unique_entries));
else {
_cleanup_free_ struct udev_list_entry **buf = NULL;
struct udev_list_entry *entry, **p;
buf = new(struct udev_list_entry *, n);
if (!buf)
return NULL;
p = buf;
HASHMAP_FOREACH(entry, list->unique_entries)
*p++ = entry;
typesafe_qsort(buf, n, udev_list_entry_compare_func);
for (size_t j = n; j > 0; j--)
LIST_PREPEND(entries, list->entries, buf[j-1]);
}
list->uptodate = true;
}
return list->entries;
}
/**
* udev_list_entry_get_next:
* @list_entry: current entry
*
* Get the next entry from the list.
*
* Returns: udev_list_entry, #NULL if no more entries are available.
*/
_public_ struct udev_list_entry *udev_list_entry_get_next(struct udev_list_entry *list_entry) {
if (!list_entry)
return NULL;
if (list_entry->list->unique && !list_entry->list->uptodate)
return NULL;
return list_entry->entries_next;
}
/**
* udev_list_entry_get_by_name:
* @list_entry: current entry
* @name: name string to match
*
* Lookup an entry in the list with a certain name.
*
* Returns: udev_list_entry, #NULL if no matching entry is found.
*/
_public_ struct udev_list_entry *udev_list_entry_get_by_name(struct udev_list_entry *list_entry, const char *name) {
if (!list_entry)
return NULL;
if (!list_entry->list->unique || !list_entry->list->uptodate)
return NULL;
return hashmap_get(list_entry->list->unique_entries, name);
}
/**
* udev_list_entry_get_name:
* @list_entry: current entry
*
* Get the name of a list entry.
*
* Returns: the name string of this entry.
*/
_public_ const char *udev_list_entry_get_name(struct udev_list_entry *list_entry) {
if (!list_entry)
return NULL;
return list_entry->name;
}
/**
* udev_list_entry_get_value:
* @list_entry: current entry
*
* Get the value of list entry.
*
* Returns: the value string of this entry.
*/
_public_ const char *udev_list_entry_get_value(struct udev_list_entry *list_entry) {
if (!list_entry)
return NULL;
return list_entry->value;
}
| 6,502 | 26.555085 | 116 |
c
|
null |
systemd-main/src/libudev/libudev-queue.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2009 Alan Jenkins <[email protected]>
***/
#include <errno.h>
#include <unistd.h>
#include "libudev.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "io-util.h"
#include "udev-util.h"
/**
* SECTION:libudev-queue
* @short_description: access to currently active events
*
* This exports the current state of the udev processing queue.
*/
/**
* udev_queue:
*
* Opaque object representing the current event queue in the udev daemon.
*/
struct udev_queue {
struct udev *udev;
unsigned n_ref;
int fd;
};
/**
* udev_queue_new:
* @udev: udev library context
*
* The initial refcount is 1, and needs to be decremented to
* release the resources of the udev queue context.
*
* Returns: the udev queue context, or #NULL on error.
**/
_public_ struct udev_queue *udev_queue_new(struct udev *udev) {
struct udev_queue *udev_queue;
udev_queue = new(struct udev_queue, 1);
if (!udev_queue)
return_with_errno(NULL, ENOMEM);
*udev_queue = (struct udev_queue) {
.udev = udev,
.n_ref = 1,
.fd = -EBADF,
};
return udev_queue;
}
static struct udev_queue *udev_queue_free(struct udev_queue *udev_queue) {
assert(udev_queue);
safe_close(udev_queue->fd);
return mfree(udev_queue);
}
/**
* udev_queue_ref:
* @udev_queue: udev queue context
*
* Take a reference of a udev queue context.
*
* Returns: the same udev queue context.
**/
/**
* udev_queue_unref:
* @udev_queue: udev queue context
*
* Drop a reference of a udev queue context. If the refcount reaches zero,
* the resources of the queue context will be released.
*
* Returns: #NULL
**/
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(struct udev_queue, udev_queue, udev_queue_free);
/**
* udev_queue_get_udev:
* @udev_queue: udev queue context
*
* Retrieve the udev library context the queue context was created with.
*
* Returns: the udev library context.
**/
_public_ struct udev *udev_queue_get_udev(struct udev_queue *udev_queue) {
assert_return_errno(udev_queue, NULL, EINVAL);
return udev_queue->udev;
}
/**
* udev_queue_get_kernel_seqnum:
* @udev_queue: udev queue context
*
* This function is deprecated.
*
* Returns: 0.
**/
_public_ unsigned long long int udev_queue_get_kernel_seqnum(struct udev_queue *udev_queue) {
return 0;
}
/**
* udev_queue_get_udev_seqnum:
* @udev_queue: udev queue context
*
* This function is deprecated.
*
* Returns: 0.
**/
_public_ unsigned long long int udev_queue_get_udev_seqnum(struct udev_queue *udev_queue) {
return 0;
}
/**
* udev_queue_get_udev_is_active:
* @udev_queue: udev queue context
*
* Check if udev is active on the system.
*
* Returns: a flag indicating if udev is active.
**/
_public_ int udev_queue_get_udev_is_active(struct udev_queue *udev_queue) {
return access("/run/udev/control", F_OK) >= 0;
}
/**
* udev_queue_get_queue_is_empty:
* @udev_queue: udev queue context
*
* Check if udev is currently processing any events.
*
* Returns: a flag indicating if udev is currently handling events.
**/
_public_ int udev_queue_get_queue_is_empty(struct udev_queue *udev_queue) {
return udev_queue_is_empty() > 0;
}
/**
* udev_queue_get_seqnum_sequence_is_finished:
* @udev_queue: udev queue context
* @start: first event sequence number
* @end: last event sequence number
*
* This function is deprecated, and equivalent to udev_queue_get_queue_is_empty().
*
* Returns: a flag indicating if udev is currently handling events.
**/
_public_ int udev_queue_get_seqnum_sequence_is_finished(struct udev_queue *udev_queue,
unsigned long long int start, unsigned long long int end) {
return udev_queue_is_empty() > 0;
}
/**
* udev_queue_get_seqnum_is_finished:
* @udev_queue: udev queue context
* @seqnum: sequence number
*
* This function is deprecated, and equivalent to udev_queue_get_queue_is_empty().
*
* Returns: a flag indicating if udev is currently handling events.
**/
_public_ int udev_queue_get_seqnum_is_finished(struct udev_queue *udev_queue, unsigned long long int seqnum) {
return udev_queue_is_empty() > 0;
}
/**
* udev_queue_get_queued_list_entry:
* @udev_queue: udev queue context
*
* This function is deprecated.
*
* Returns: NULL.
**/
_public_ struct udev_list_entry *udev_queue_get_queued_list_entry(struct udev_queue *udev_queue) {
return_with_errno(NULL, ENODATA);
}
/**
* udev_queue_get_fd:
* @udev_queue: udev queue context
*
* Returns: a file descriptor to watch for a queue to become empty.
*/
_public_ int udev_queue_get_fd(struct udev_queue *udev_queue) {
int r;
assert_return(udev_queue, -EINVAL);
if (udev_queue->fd >= 0)
return udev_queue->fd;
r = udev_queue_init();
if (r < 0)
return r;
return udev_queue->fd = r;
}
/**
* udev_queue_flush:
* @udev_queue: udev queue context
*
* Returns: the result of clearing the watch for queue changes.
*/
_public_ int udev_queue_flush(struct udev_queue *udev_queue) {
int r;
assert_return(udev_queue, -EINVAL);
if (udev_queue->fd < 0)
return -EINVAL;
r = flush_fd(udev_queue->fd);
if (r < 0)
return r;
return 0;
}
| 5,518 | 23.100437 | 115 |
c
|
null |
systemd-main/src/libudev/libudev-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "device-nodes.h"
#include "libudev-util.h"
/**
* SECTION:libudev-util
* @short_description: utils
*
* Utilities useful when dealing with devices and device node names.
*/
/**
* udev_util_encode_string:
* @str: input string to be encoded
* @str_enc: output string to store the encoded input string
* @len: maximum size of the output string, which may be
* four times as long as the input string
*
* Encode all potentially unsafe characters of a string to the
* corresponding 2 char hex value prefixed by '\x'.
*
* Returns: 0 if the entire string was copied, non-zero otherwise.
**/
_public_ int udev_util_encode_string(const char *str, char *str_enc, size_t len) {
return encode_devnode_name(str, str_enc, len);
}
| 804 | 27.75 | 82 |
c
|
null |
systemd-main/src/libudev/libudev-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "libudev.h"
#include "macro.h"
/* Cleanup functions */
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev*, udev_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_device*, udev_device_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_enumerate*, udev_enumerate_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_monitor*, udev_monitor_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_hwdb*, udev_hwdb_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(struct udev_queue*, udev_queue_unref);
| 531 | 34.466667 | 74 |
h
|
null |
systemd-main/src/libudev/libudev.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <ctype.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "libudev.h"
#include "alloc-util.h"
#include "fd-util.h"
#include "string-util.h"
/**
* SECTION:libudev
* @short_description: libudev context
*/
/**
* udev:
*
* Opaque object representing the library context.
*/
struct udev {
unsigned n_ref;
void *userdata;
};
/**
* udev_get_userdata:
* @udev: udev library context
*
* Retrieve stored data pointer from library context. This might be useful
* to access from callbacks.
*
* Returns: stored userdata
**/
_public_ void *udev_get_userdata(struct udev *udev) {
assert_return(udev, NULL);
return udev->userdata;
}
/**
* udev_set_userdata:
* @udev: udev library context
* @userdata: data pointer
*
* Store custom @userdata in the library context.
**/
_public_ void udev_set_userdata(struct udev *udev, void *userdata) {
if (!udev)
return;
udev->userdata = userdata;
}
/**
* udev_new:
*
* Create udev library context. This only allocates the basic data structure.
*
* The initial refcount is 1, and needs to be decremented to
* release the resources of the udev library context.
*
* Returns: a new udev library context
**/
_public_ struct udev *udev_new(void) {
struct udev *udev;
udev = new(struct udev, 1);
if (!udev)
return_with_errno(NULL, ENOMEM);
*udev = (struct udev) {
.n_ref = 1,
};
return udev;
}
/**
* udev_ref:
* @udev: udev library context
*
* Take a reference of the udev library context.
*
* Returns: the passed udev library context
**/
DEFINE_PUBLIC_TRIVIAL_REF_FUNC(struct udev, udev);
/**
* udev_unref:
* @udev: udev library context
*
* Drop a reference of the udev library context. If the refcount
* reaches zero, the resources of the context will be released.
*
* Returns: the passed udev library context if it has still an active reference, or #NULL otherwise.
**/
_public_ struct udev *udev_unref(struct udev *udev) {
if (!udev)
return NULL;
assert(udev->n_ref > 0);
udev->n_ref--;
if (udev->n_ref > 0)
/* This is different from our convention, but let's keep backward
* compatibility. So, do not use DEFINE_PUBLIC_TRIVIAL_UNREF_FUNC()
* macro to define this function. */
return udev;
return mfree(udev);
}
/**
* udev_set_log_fn:
* @udev: udev library context
* @log_fn: function to be called for log messages
*
* This function is deprecated.
*
**/
_public_ void udev_set_log_fn(
struct udev *udev,
void (*log_fn)(struct udev *udev,
int priority, const char *file, int line, const char *fn,
const char *format, va_list args)) {
return;
}
/**
* udev_get_log_priority:
* @udev: udev library context
*
* This function is deprecated.
*
**/
_public_ int udev_get_log_priority(struct udev *udev) {
return log_get_max_level();
}
/**
* udev_set_log_priority:
* @udev: udev library context
* @priority: the new log priority
*
* This function is deprecated.
*
**/
_public_ void udev_set_log_priority(struct udev *udev, int priority) {
log_set_max_level(priority);
}
| 3,478 | 21.445161 | 100 |
c
|
null |
systemd-main/src/libudev/test-libudev.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <getopt.h>
#include <sys/epoll.h>
#include <unistd.h>
#include "alloc-util.h"
#include "devnum-util.h"
#include "fd-util.h"
#include "libudev-list-internal.h"
#include "libudev-util.h"
#include "log.h"
#include "main-func.h"
#include "stdio-util.h"
#include "string-util.h"
#include "tests.h"
#include "version.h"
static bool arg_monitor = false;
static void print_device(struct udev_device *device) {
const char *str;
dev_t devnum;
int count;
struct udev_list_entry *list_entry;
log_info("*** device: %p ***", device);
str = udev_device_get_action(device);
if (str)
log_info("action: '%s'", str);
str = udev_device_get_syspath(device);
log_info("syspath: '%s'", str);
str = udev_device_get_sysname(device);
log_info("sysname: '%s'", str);
str = udev_device_get_sysnum(device);
if (str)
log_info("sysnum: '%s'", str);
str = udev_device_get_devpath(device);
log_info("devpath: '%s'", str);
str = udev_device_get_subsystem(device);
if (str)
log_info("subsystem: '%s'", str);
str = udev_device_get_devtype(device);
if (str)
log_info("devtype: '%s'", str);
str = udev_device_get_driver(device);
if (str)
log_info("driver: '%s'", str);
str = udev_device_get_devnode(device);
if (str)
log_info("devname: '%s'", str);
devnum = udev_device_get_devnum(device);
if (major(devnum) > 0)
log_info("devnum: %u:%u", major(devnum), minor(devnum));
count = 0;
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device)) {
log_info("link: '%s'", udev_list_entry_get_name(list_entry));
count++;
}
if (count > 0)
log_info("found %i links", count);
count = 0;
udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device)) {
log_info("property: '%s=%s'",
udev_list_entry_get_name(list_entry),
udev_list_entry_get_value(list_entry));
count++;
}
if (count > 0)
log_info("found %i properties", count);
str = udev_device_get_property_value(device, "MAJOR");
if (str)
log_info("MAJOR: '%s'", str);
str = udev_device_get_sysattr_value(device, "dev");
if (str)
log_info("attr{dev}: '%s'", str);
}
static void test_device(struct udev *udev, const char *syspath) {
_cleanup_(udev_device_unrefp) struct udev_device *device = NULL;
log_info("/* %s, device %s */", __func__, syspath);
device = udev_device_new_from_syspath(udev, syspath);
if (device)
print_device(device);
else
log_warning_errno(errno, "udev_device_new_from_syspath: %m");
}
static void test_device_parents(struct udev *udev, const char *syspath) {
_cleanup_(udev_device_unrefp) struct udev_device *device = NULL;
struct udev_device *device_parent;
log_info("/* %s, device %s */", __func__, syspath);
device = udev_device_new_from_syspath(udev, syspath);
if (!device)
return;
log_info("looking at parents");
device_parent = device;
do {
print_device(device_parent);
device_parent = udev_device_get_parent(device_parent);
} while (device_parent != NULL);
log_info("looking at parents again");
device_parent = device;
do {
print_device(device_parent);
device_parent = udev_device_get_parent(device_parent);
} while (device_parent != NULL);
}
static void test_device_devnum(struct udev *udev) {
dev_t devnum = makedev(1, 3);
_cleanup_(udev_device_unrefp) struct udev_device *device;
log_info("/* %s, device " DEVNUM_FORMAT_STR " */", __func__, DEVNUM_FORMAT_VAL(devnum));
device = udev_device_new_from_devnum(udev, 'c', devnum);
if (device)
print_device(device);
else
log_warning_errno(errno, "udev_device_new_from_devnum: %m");
}
static void test_device_subsys_name(struct udev *udev, const char *subsys, const char *dev) {
_cleanup_(udev_device_unrefp) struct udev_device *device;
log_info("looking up device: '%s:%s'", subsys, dev);
device = udev_device_new_from_subsystem_sysname(udev, subsys, dev);
if (!device)
log_warning_errno(errno, "udev_device_new_from_subsystem_sysname: %m");
else
print_device(device);
}
static int enumerate_print_list(struct udev_enumerate *enumerate) {
struct udev_list_entry *list_entry;
int count = 0;
udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) {
struct udev_device *device;
device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),
udev_list_entry_get_name(list_entry));
if (device) {
log_info("device: '%s' (%s)",
udev_device_get_syspath(device),
udev_device_get_subsystem(device));
udev_device_unref(device);
count++;
}
}
log_info("found %i devices", count);
return count;
}
static void test_monitor(struct udev *udev) {
_cleanup_(udev_monitor_unrefp) struct udev_monitor *udev_monitor;
_cleanup_close_ int fd_ep = -EBADF;
int fd_udev;
struct epoll_event ep_udev = {
.events = EPOLLIN,
}, ep_stdin = {
.events = EPOLLIN,
.data.fd = STDIN_FILENO,
};
log_info("/* %s */", __func__);
fd_ep = epoll_create1(EPOLL_CLOEXEC);
assert_se(fd_ep >= 0);
udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
assert_se(udev_monitor != NULL);
fd_udev = udev_monitor_get_fd(udev_monitor);
ep_udev.data.fd = fd_udev;
assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "block", NULL) >= 0);
assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "tty", NULL) >= 0);
assert_se(udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", "usb_device") >= 0);
assert_se(udev_monitor_enable_receiving(udev_monitor) >= 0);
assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) >= 0);
assert_se(epoll_ctl(fd_ep, EPOLL_CTL_ADD, STDIN_FILENO, &ep_stdin) >= 0);
for (;;) {
int fdcount;
struct epoll_event ev[4];
struct udev_device *device;
int i;
printf("waiting for events from udev, press ENTER to exit\n");
fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
printf("epoll fd count: %i\n", fdcount);
for (i = 0; i < fdcount; i++) {
if (ev[i].data.fd == fd_udev && ev[i].events & EPOLLIN) {
device = udev_monitor_receive_device(udev_monitor);
if (!device) {
printf("no device from socket\n");
continue;
}
print_device(device);
udev_device_unref(device);
} else if (ev[i].data.fd == STDIN_FILENO && ev[i].events & EPOLLIN) {
printf("exiting loop\n");
return;
}
}
}
}
static void test_queue(struct udev *udev) {
struct udev_queue *udev_queue;
bool empty;
log_info("/* %s */", __func__);
assert_se(udev_queue = udev_queue_new(udev));
empty = udev_queue_get_queue_is_empty(udev_queue);
log_info("queue is %s", empty ? "empty" : "not empty");
udev_queue_unref(udev_queue);
}
static int test_enumerate(struct udev *udev, const char *subsystem) {
struct udev_enumerate *udev_enumerate;
int r;
log_info("/* %s */", __func__);
log_info("enumerate '%s'", subsystem == NULL ? "<all>" : subsystem);
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_add_match_subsystem(udev_enumerate, subsystem);
udev_enumerate_scan_devices(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
log_info("enumerate 'net' + duplicated scan + null + zero");
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_add_match_subsystem(udev_enumerate, "net");
udev_enumerate_scan_devices(udev_enumerate);
udev_enumerate_scan_devices(udev_enumerate);
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/null");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
udev_enumerate_add_syspath(udev_enumerate, "/sys/class/mem/zero");
udev_enumerate_scan_devices(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
log_info("enumerate 'block'");
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_add_match_subsystem(udev_enumerate,"block");
r = udev_enumerate_add_match_is_initialized(udev_enumerate);
if (r < 0) {
udev_enumerate_unref(udev_enumerate);
return r;
}
udev_enumerate_scan_devices(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
log_info("enumerate 'not block'");
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_add_nomatch_subsystem(udev_enumerate, "block");
udev_enumerate_scan_devices(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
log_info("enumerate 'pci, mem, vc'");
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_add_match_subsystem(udev_enumerate, "pci");
udev_enumerate_add_match_subsystem(udev_enumerate, "mem");
udev_enumerate_add_match_subsystem(udev_enumerate, "vc");
udev_enumerate_scan_devices(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
log_info("enumerate 'subsystem'");
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_scan_subsystems(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
log_info("enumerate 'property IF_FS_*=filesystem'");
udev_enumerate = udev_enumerate_new(udev);
if (!udev_enumerate)
return -1;
udev_enumerate_add_match_property(udev_enumerate, "ID_FS*", "filesystem");
udev_enumerate_scan_devices(udev_enumerate);
enumerate_print_list(udev_enumerate);
udev_enumerate_unref(udev_enumerate);
return 0;
}
static void test_hwdb(struct udev *udev, const char *modalias) {
struct udev_hwdb *hwdb;
struct udev_list_entry *entry;
log_info("/* %s */", __func__);
hwdb = udev_hwdb_new(udev);
if (!hwdb)
log_warning_errno(errno, "Failed to open hwdb: %m");
udev_list_entry_foreach(entry, udev_hwdb_get_properties_list_entry(hwdb, modalias, 0))
log_info("'%s'='%s'", udev_list_entry_get_name(entry), udev_list_entry_get_value(entry));
hwdb = udev_hwdb_unref(hwdb);
assert_se(hwdb == NULL);
}
static void test_list(void) {
_cleanup_(udev_list_freep) struct udev_list *list = NULL;
struct udev_list_entry *e;
/* empty list */
assert_se(list = udev_list_new(false));
assert_se(!udev_list_get_entry(list));
list = udev_list_free(list);
/* unique == false */
assert_se(list = udev_list_new(false));
assert_se(udev_list_entry_add(list, "aaa", "hoge"));
assert_se(udev_list_entry_add(list, "aaa", "hogehoge"));
assert_se(udev_list_entry_add(list, "bbb", "foo"));
e = udev_list_get_entry(list);
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hoge"));
e = udev_list_entry_get_next(e);
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
e = udev_list_entry_get_next(e);
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "bbb"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "foo"));
assert_se(!udev_list_entry_get_next(e));
assert_se(!udev_list_entry_get_by_name(e, "aaa"));
assert_se(!udev_list_entry_get_by_name(e, "bbb"));
assert_se(!udev_list_entry_get_by_name(e, "ccc"));
list = udev_list_free(list);
/* unique == true */
assert_se(list = udev_list_new(true));
assert_se(udev_list_entry_add(list, "aaa", "hoge"));
assert_se(udev_list_entry_add(list, "aaa", "hogehoge"));
assert_se(udev_list_entry_add(list, "bbb", "foo"));
e = udev_list_get_entry(list);
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
e = udev_list_entry_get_next(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "bbb"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "foo"));
assert_se(!udev_list_entry_get_next(e));
e = udev_list_entry_get_by_name(e, "bbb");
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "bbb"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "foo"));
e = udev_list_entry_get_by_name(e, "aaa");
assert_se(e);
assert_se(streq_ptr(udev_list_entry_get_name(e), "aaa"));
assert_se(streq_ptr(udev_list_entry_get_value(e), "hogehoge"));
assert_se(!udev_list_entry_get_by_name(e, "ccc"));
}
static int parse_args(int argc, char *argv[], const char **syspath, const char **subsystem) {
static const struct option options[] = {
{ "syspath", required_argument, NULL, 'p' },
{ "subsystem", required_argument, NULL, 's' },
{ "debug", no_argument, NULL, 'd' },
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'V' },
{ "monitor", no_argument, NULL, 'm' },
{}
};
int c;
while ((c = getopt_long(argc, argv, "p:s:dhVm", options, NULL)) >= 0)
switch (c) {
case 'p':
*syspath = optarg;
break;
case 's':
*subsystem = optarg;
break;
case 'd':
log_set_max_level(LOG_DEBUG);
break;
case 'h':
printf("--debug --syspath= --subsystem= --help\n");
return 0;
case 'V':
printf("%s\n", GIT_VERSION);
return 0;
case 'm':
arg_monitor = true;
break;
case '?':
return -EINVAL;
default:
assert_not_reached();
}
return 1;
}
static int run(int argc, char *argv[]) {
_cleanup_(udev_unrefp) struct udev *udev = NULL;
const char *syspath = "/devices/virtual/mem/null";
const char *subsystem = NULL;
int r;
test_setup_logging(LOG_INFO);
r = parse_args(argc, argv, &syspath, &subsystem);
if (r <= 0)
return r;
assert_se(udev = udev_new());
/* add sys path if needed */
if (!startswith(syspath, "/sys"))
syspath = strjoina("/sys/", syspath);
test_device(udev, syspath);
test_device_devnum(udev);
test_device_subsys_name(udev, "block", "sda");
test_device_subsys_name(udev, "subsystem", "pci");
test_device_subsys_name(udev, "drivers", "scsi:sd");
test_device_subsys_name(udev, "module", "printk");
test_device_parents(udev, syspath);
test_enumerate(udev, subsystem);
test_queue(udev);
test_hwdb(udev, "usb:v0D50p0011*");
if (arg_monitor)
test_monitor(udev);
test_list();
return 0;
}
DEFINE_MAIN_FUNCTION(run);
| 18,173 | 35.567404 | 107 |
c
|
null |
systemd-main/src/libudev/test-udev-device-thread.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include "libudev.h"
#define handle_error_errno(error, msg) \
({ \
errno = abs(error); \
perror(msg); \
EXIT_FAILURE; \
})
static void* thread(void *p) {
struct udev_device **d = p;
*d = udev_device_unref(*d);
return NULL;
}
int main(int argc, char *argv[]) {
struct udev_device *loopback;
struct udev_list_entry *entry, *e;
pthread_t t;
int r;
loopback = udev_device_new_from_syspath(NULL, "/sys/class/net/lo");
if (!loopback)
return handle_error_errno(errno, "Failed to create loopback device object");
entry = udev_device_get_properties_list_entry(loopback);
udev_list_entry_foreach(e, entry)
printf("%s=%s\n", udev_list_entry_get_name(e), udev_list_entry_get_value(e));
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,583 | 29.461538 | 93 |
c
|
null |
systemd-main/src/locale/localed-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <sys/stat.h>
#include "sd-bus.h"
#include "hashmap.h"
#include "locale-setup.h"
typedef struct X11Context {
char *layout;
char *model;
char *variant;
char *options;
} X11Context;
typedef struct VCContext {
char *keymap;
char *toggle;
} VCContext;
typedef struct Context {
sd_bus_message *locale_cache;
LocaleContext locale_context;
sd_bus_message *x11_cache;
struct stat x11_stat;
X11Context x11_from_xorg;
X11Context x11_from_vc;
sd_bus_message *vc_cache;
struct stat vc_stat;
VCContext vc;
Hashmap *polkit_registry;
} Context;
void x11_context_clear(X11Context *xc);
void x11_context_replace(X11Context *dest, X11Context *src);
bool x11_context_isempty(const X11Context *xc);
void x11_context_empty_to_null(X11Context *xc);
bool x11_context_is_safe(const X11Context *xc);
bool x11_context_equal(const X11Context *a, const X11Context *b);
int x11_context_copy(X11Context *dest, const X11Context *src);
int x11_context_verify_and_warn(const X11Context *xc, int log_level, sd_bus_error *error);
static inline int x11_context_verify(const X11Context *xc) {
return x11_context_verify_and_warn(xc, LOG_DEBUG, NULL);
}
X11Context *context_get_x11_context(Context *c);
void vc_context_clear(VCContext *vc);
void vc_context_replace(VCContext *dest, VCContext *src);
bool vc_context_isempty(const VCContext *vc);
void vc_context_empty_to_null(VCContext *vc);
bool vc_context_equal(const VCContext *a, const VCContext *b);
int vc_context_copy(VCContext *dest, const VCContext *src);
int vc_context_verify_and_warn(const VCContext *vc, int log_level, sd_bus_error *error);
static inline int vc_context_verify(const VCContext *vc) {
return vc_context_verify_and_warn(vc, LOG_DEBUG, NULL);
}
int find_converted_keymap(const X11Context *xc, char **ret);
int find_legacy_keymap(const X11Context *xc, char **ret);
int find_language_fallback(const char *lang, char **ret);
int locale_read_data(Context *c, sd_bus_message *m);
int vconsole_read_data(Context *c, sd_bus_message *m);
int x11_read_data(Context *c, sd_bus_message *m);
void context_clear(Context *c);
int vconsole_convert_to_x11(const VCContext *vc, X11Context *ret);
int vconsole_write_data(Context *c);
int x11_convert_to_vconsole(const X11Context *xc, VCContext *ret);
int x11_write_data(Context *c);
bool locale_gen_check_available(void);
int locale_gen_enable_locale(const char *locale);
int locale_gen_run(void);
| 2,596 | 31.061728 | 90 |
h
|
null |
systemd-main/src/locale/test-localed-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "localed-util.h"
#include "log.h"
#include "string-util.h"
#include "tests.h"
TEST(find_language_fallback) {
_cleanup_free_ char *ans = NULL, *ans2 = NULL;
assert_se(find_language_fallback("foobar", &ans) == 0);
assert_se(ans == NULL);
assert_se(find_language_fallback("csb", &ans) == 0);
assert_se(ans == NULL);
assert_se(find_language_fallback("csb_PL", &ans) == 1);
assert_se(streq(ans, "csb:pl"));
assert_se(find_language_fallback("szl_PL", &ans2) == 1);
assert_se(streq(ans2, "szl:pl"));
}
TEST(find_converted_keymap) {
_cleanup_free_ char *ans = NULL, *ans2 = NULL;
int r;
assert_se(find_converted_keymap(
&(X11Context) {
.layout = (char*) "pl",
.variant = (char*) "foobar",
}, &ans) == 0);
assert_se(ans == NULL);
r = find_converted_keymap(
&(X11Context) {
.layout = (char*) "pl",
}, &ans);
if (r == 0) {
log_info("Skipping rest of %s: keymaps are not installed", __func__);
return;
}
assert_se(r == 1);
assert_se(streq(ans, "pl"));
ans = mfree(ans);
assert_se(find_converted_keymap(
&(X11Context) {
.layout = (char*) "pl",
.variant = (char*) "dvorak",
}, &ans2) == 1);
assert_se(streq(ans2, "pl-dvorak"));
}
TEST(find_legacy_keymap) {
X11Context xc = {};
_cleanup_free_ char *ans = NULL, *ans2 = NULL;
xc.layout = (char*) "foobar";
assert_se(find_legacy_keymap(&xc, &ans) == 0);
assert_se(ans == NULL);
xc.layout = (char*) "pl";
assert_se(find_legacy_keymap(&xc, &ans) == 1);
assert_se(streq(ans, "pl2"));
xc.layout = (char*) "pl,ru";
assert_se(find_legacy_keymap(&xc, &ans2) == 1);
assert_se(streq(ans, "pl2"));
}
TEST(vconsole_convert_to_x11) {
_cleanup_(x11_context_clear) X11Context xc = {};
_cleanup_(vc_context_clear) VCContext vc = {};
int r;
log_info("/* test empty keymap */");
assert_se(vconsole_convert_to_x11(&vc, &xc) >= 0);
assert_se(x11_context_isempty(&xc));
log_info("/* test without variant, new mapping (es:) */");
assert_se(free_and_strdup(&vc.keymap, "es") >= 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) >= 0);
assert_se(streq(xc.layout, "es"));
assert_se(xc.variant == NULL);
x11_context_clear(&xc);
log_info("/* test with known variant, new mapping (es:dvorak) */");
assert_se(free_and_strdup(&vc.keymap, "es-dvorak") >= 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) >= 0);
assert_se(streq(xc.layout, "es"));
assert_se(streq(xc.variant, "dvorak"));
x11_context_clear(&xc);
log_info("/* test with old mapping (fr:latin9) */");
assert_se(free_and_strdup(&vc.keymap, "fr-latin9") >= 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) >= 0);
assert_se(streq(xc.layout, "fr"));
assert_se(streq(xc.variant, "latin9"));
x11_context_clear(&xc);
log_info("/* test with a compound mapping (ru,us) */");
assert_se(free_and_strdup(&vc.keymap, "ru") >= 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) >= 0);
assert_se(streq(xc.layout, "ru,us"));
assert_se(xc.variant == NULL);
x11_context_clear(&xc);
log_info("/* test with a simple mapping (us) */");
assert_se(free_and_strdup(&vc.keymap, "us") >= 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) >= 0);
assert_se(streq(xc.layout, "us"));
assert_se(xc.variant == NULL);
x11_context_clear(&xc);
/* "gh" has no mapping in kbd-model-map and kbd provides a converted keymap for this layout. */
log_info("/* test with a converted keymap (gh:) */");
assert_se(free_and_strdup(&vc.keymap, "gh") >= 0);
r = vconsole_convert_to_x11(&vc, &xc);
if (r == 0) {
log_info("Skipping rest of %s: keymaps are not installed", __func__);
return;
}
assert_se(r > 0);
assert_se(streq(xc.layout, "gh"));
assert_se(xc.variant == NULL);
x11_context_clear(&xc);
log_info("/* test with converted keymap and with a known variant (gh:ewe) */");
assert_se(free_and_strdup(&vc.keymap, "gh-ewe") >= 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) > 0);
assert_se(streq(xc.layout, "gh"));
assert_se(streq(xc.variant, "ewe"));
x11_context_clear(&xc);
log_info("/* test with converted keymap and with an unknown variant (gh:ewe) */");
assert_se(free_and_strdup(&vc.keymap, "gh-foobar") > 0);
assert_se(vconsole_convert_to_x11(&vc, &xc) > 0);
assert_se(streq(xc.layout, "gh"));
assert_se(xc.variant == NULL);
x11_context_clear(&xc);
}
TEST(x11_convert_to_vconsole) {
_cleanup_(x11_context_clear) X11Context xc = {};
_cleanup_(vc_context_clear) VCContext vc = {};
log_info("/* test empty layout (:) */");
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(vc_context_isempty(&vc));
log_info("/* test without variant, new mapping (es:) */");
assert_se(free_and_strdup(&xc.layout, "es") >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(streq(vc.keymap, "es"));
vc_context_clear(&vc);
log_info("/* test with unknown variant, new mapping (es:foobar) */");
assert_se(free_and_strdup(&xc.variant, "foobar") >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(streq(vc.keymap, "es"));
vc_context_clear(&vc);
log_info("/* test with known variant, new mapping (es:dvorak) */");
assert_se(free_and_strdup(&xc.variant, "dvorak") >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
if (vc_context_isempty(&vc)) {
log_info("Skipping rest of %s: keymaps are not installed", __func__);
return;
}
assert_se(streq(vc.keymap, "es-dvorak"));
vc_context_clear(&vc);
log_info("/* test with old mapping (fr:latin9) */");
assert_se(free_and_strdup(&xc.layout, "fr") >= 0);
assert_se(free_and_strdup(&xc.variant, "latin9") >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(streq(vc.keymap, "fr-latin9"));
vc_context_clear(&vc);
log_info("/* test with a compound mapping (us,ru:) */");
assert_se(free_and_strdup(&xc.layout, "us,ru") >= 0);
assert_se(free_and_strdup(&xc.variant, NULL) >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(streq(vc.keymap, "us"));
vc_context_clear(&vc);
log_info("/* test with a compound mapping (ru,us:) */");
assert_se(free_and_strdup(&xc.layout, "ru,us") >= 0);
assert_se(free_and_strdup(&xc.variant, NULL) >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(streq(vc.keymap, "ru"));
vc_context_clear(&vc);
/* https://bugzilla.redhat.com/show_bug.cgi?id=1333998 */
log_info("/* test with a simple new mapping (ru:) */");
assert_se(free_and_strdup(&xc.layout, "ru") >= 0);
assert_se(free_and_strdup(&xc.variant, NULL) >= 0);
assert_se(x11_convert_to_vconsole(&xc, &vc) >= 0);
assert_se(streq(vc.keymap, "ru"));
}
static int intro(void) {
_cleanup_free_ char *map = NULL;
assert_se(get_testdata_dir("test-keymap-util/kbd-model-map", &map) >= 0);
assert_se(setenv("SYSTEMD_KBD_MODEL_MAP", map, 1) == 0);
return EXIT_SUCCESS;
}
DEFINE_TEST_MAIN_WITH_INTRO(LOG_DEBUG, intro);
| 8,158 | 36.948837 | 103 |
c
|
null |
systemd-main/src/locale/xkbcommon-util.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "dlfcn-util.h"
#include "log.h"
#include "macro.h"
#include "string-util.h"
#include "xkbcommon-util.h"
#if HAVE_XKBCOMMON
static void *xkbcommon_dl = NULL;
struct xkb_context* (*sym_xkb_context_new)(enum xkb_context_flags flags);
void (*sym_xkb_context_unref)(struct xkb_context *context);
void (*sym_xkb_context_set_log_fn)(
struct xkb_context *context,
void (*log_fn)(
struct xkb_context *context,
enum xkb_log_level level,
const char *format,
va_list args));
struct xkb_keymap* (*sym_xkb_keymap_new_from_names)(
struct xkb_context *context,
const struct xkb_rule_names *names,
enum xkb_keymap_compile_flags flags);
void (*sym_xkb_keymap_unref)(struct xkb_keymap *keymap);
static int dlopen_xkbcommon(void) {
return dlopen_many_sym_or_warn(
&xkbcommon_dl, "libxkbcommon.so.0", LOG_DEBUG,
DLSYM_ARG(xkb_context_new),
DLSYM_ARG(xkb_context_unref),
DLSYM_ARG(xkb_context_set_log_fn),
DLSYM_ARG(xkb_keymap_new_from_names),
DLSYM_ARG(xkb_keymap_unref));
}
_printf_(3, 0)
static void log_xkb(struct xkb_context *ctx, enum xkb_log_level lvl, const char *format, va_list args) {
const char *fmt;
fmt = strjoina("libxkbcommon: ", format);
DISABLE_WARNING_FORMAT_NONLITERAL;
log_internalv(LOG_DEBUG, 0, PROJECT_FILE, __LINE__, __func__, fmt, args);
REENABLE_WARNING;
}
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(struct xkb_context *, sym_xkb_context_unref, NULL);
DEFINE_TRIVIAL_CLEANUP_FUNC_FULL(struct xkb_keymap *, sym_xkb_keymap_unref, NULL);
int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
_cleanup_(sym_xkb_context_unrefp) struct xkb_context *ctx = NULL;
_cleanup_(sym_xkb_keymap_unrefp) struct xkb_keymap *km = NULL;
const struct xkb_rule_names rmlvo = {
.model = model,
.layout = layout,
.variant = variant,
.options = options,
};
int r;
/* Compile keymap from RMLVO information to check out its validity */
r = dlopen_xkbcommon();
if (r < 0)
return r;
ctx = sym_xkb_context_new(XKB_CONTEXT_NO_ENVIRONMENT_NAMES);
if (!ctx)
return -ENOMEM;
sym_xkb_context_set_log_fn(ctx, log_xkb);
km = sym_xkb_keymap_new_from_names(ctx, &rmlvo, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (!km)
return -EINVAL;
return 0;
}
#endif
| 2,847 | 34.160494 | 104 |
c
|
null |
systemd-main/src/locale/xkbcommon-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#if HAVE_XKBCOMMON
#include <xkbcommon/xkbcommon.h>
extern struct xkb_context* (*sym_xkb_context_new)(enum xkb_context_flags flags);
extern void (*sym_xkb_context_unref)(struct xkb_context *context);
extern void (*sym_xkb_context_set_log_fn)(
struct xkb_context *context,
void (*log_fn)(
struct xkb_context *context,
enum xkb_log_level level,
const char *format,
va_list args));
extern struct xkb_keymap* (*sym_xkb_keymap_new_from_names)(
struct xkb_context *context,
const struct xkb_rule_names *names,
enum xkb_keymap_compile_flags flags);
extern void (*sym_xkb_keymap_unref)(struct xkb_keymap *keymap);
int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options);
#else
static inline int verify_xkb_rmlvo(const char *model, const char *layout, const char *variant, const char *options) {
return 0;
}
#endif
| 1,104 | 34.645161 | 117 |
h
|
null |
systemd-main/src/login/logind-action.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <unistd.h>
#include "sd-messages.h"
#include "alloc-util.h"
#include "bus-error.h"
#include "bus-util.h"
#include "conf-parser.h"
#include "format-util.h"
#include "logind-action.h"
#include "logind-dbus.h"
#include "logind-session-dbus.h"
#include "process-util.h"
#include "special.h"
#include "string-table.h"
#include "terminal-util.h"
#include "user-util.h"
static const HandleActionData handle_action_data_table[_HANDLE_ACTION_MAX] = {
[HANDLE_POWEROFF] = {
.handle = HANDLE_POWEROFF,
.target = SPECIAL_POWEROFF_TARGET,
.inhibit_what = INHIBIT_SHUTDOWN,
.polkit_action = "org.freedesktop.login1.power-off",
.polkit_action_multiple_sessions = "org.freedesktop.login1.power-off-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.power-off-ignore-inhibit",
.sleep_operation = _SLEEP_OPERATION_INVALID,
.message_id = SD_MESSAGE_SHUTDOWN_STR,
.message = "System is powering down",
.log_verb = "power-off",
},
[HANDLE_REBOOT] = {
.handle = HANDLE_REBOOT,
.target = SPECIAL_REBOOT_TARGET,
.inhibit_what = INHIBIT_SHUTDOWN,
.polkit_action = "org.freedesktop.login1.reboot",
.polkit_action_multiple_sessions = "org.freedesktop.login1.reboot-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.reboot-ignore-inhibit",
.sleep_operation = _SLEEP_OPERATION_INVALID,
.message_id = SD_MESSAGE_SHUTDOWN_STR,
.message = "System is rebooting",
.log_verb = "reboot",
},
[HANDLE_HALT] = {
.handle = HANDLE_HALT,
.target = SPECIAL_HALT_TARGET,
.inhibit_what = INHIBIT_SHUTDOWN,
.polkit_action = "org.freedesktop.login1.halt",
.polkit_action_multiple_sessions = "org.freedesktop.login1.halt-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.halt-ignore-inhibit",
.sleep_operation = _SLEEP_OPERATION_INVALID,
.message_id = SD_MESSAGE_SHUTDOWN_STR,
.message = "System is halting",
.log_verb = "halt",
},
[HANDLE_KEXEC] = {
.handle = HANDLE_KEXEC,
.target = SPECIAL_KEXEC_TARGET,
.inhibit_what = INHIBIT_SHUTDOWN,
.polkit_action = "org.freedesktop.login1.reboot",
.polkit_action_multiple_sessions = "org.freedesktop.login1.reboot-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.reboot-ignore-inhibit",
.sleep_operation = _SLEEP_OPERATION_INVALID,
.message_id = SD_MESSAGE_SHUTDOWN_STR,
.message = "System is rebooting with kexec",
.log_verb = "kexec",
},
[HANDLE_SOFT_REBOOT] = {
.handle = HANDLE_SOFT_REBOOT,
.target = SPECIAL_SOFT_REBOOT_TARGET,
.inhibit_what = INHIBIT_SHUTDOWN,
.polkit_action = "org.freedesktop.login1.reboot",
.polkit_action_multiple_sessions = "org.freedesktop.login1.reboot-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.reboot-ignore-inhibit",
.sleep_operation = _SLEEP_OPERATION_INVALID,
.message_id = SD_MESSAGE_SHUTDOWN_STR,
.message = "System userspace is rebooting",
.log_verb = "soft-reboot",
},
[HANDLE_SUSPEND] = {
.handle = HANDLE_SUSPEND,
.target = SPECIAL_SUSPEND_TARGET,
.inhibit_what = INHIBIT_SLEEP,
.polkit_action = "org.freedesktop.login1.suspend",
.polkit_action_multiple_sessions = "org.freedesktop.login1.suspend-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.suspend-ignore-inhibit",
.sleep_operation = SLEEP_SUSPEND,
},
[HANDLE_HIBERNATE] = {
.handle = HANDLE_HIBERNATE,
.target = SPECIAL_HIBERNATE_TARGET,
.inhibit_what = INHIBIT_SLEEP,
.polkit_action = "org.freedesktop.login1.hibernate",
.polkit_action_multiple_sessions = "org.freedesktop.login1.hibernate-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.hibernate-ignore-inhibit",
.sleep_operation = SLEEP_HIBERNATE,
},
[HANDLE_HYBRID_SLEEP] = {
.handle = HANDLE_HYBRID_SLEEP,
.target = SPECIAL_HYBRID_SLEEP_TARGET,
.inhibit_what = INHIBIT_SLEEP,
.polkit_action = "org.freedesktop.login1.hibernate",
.polkit_action_multiple_sessions = "org.freedesktop.login1.hibernate-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.hibernate-ignore-inhibit",
.sleep_operation = SLEEP_HYBRID_SLEEP,
},
[HANDLE_SUSPEND_THEN_HIBERNATE] = {
.handle = HANDLE_SUSPEND_THEN_HIBERNATE,
.target = SPECIAL_SUSPEND_THEN_HIBERNATE_TARGET,
.inhibit_what = INHIBIT_SLEEP,
.polkit_action = "org.freedesktop.login1.hibernate",
.polkit_action_multiple_sessions = "org.freedesktop.login1.hibernate-multiple-sessions",
.polkit_action_ignore_inhibit = "org.freedesktop.login1.hibernate-ignore-inhibit",
.sleep_operation = SLEEP_SUSPEND_THEN_HIBERNATE,
},
[HANDLE_FACTORY_RESET] = {
.handle = HANDLE_FACTORY_RESET,
.target = SPECIAL_FACTORY_RESET_TARGET,
.inhibit_what = _INHIBIT_WHAT_INVALID,
.sleep_operation = _SLEEP_OPERATION_INVALID,
.message_id = SD_MESSAGE_FACTORY_RESET_STR,
.message = "System is performing factory reset",
},
};
const HandleActionData* handle_action_lookup(HandleAction action) {
if (action < 0 || (size_t) action >= ELEMENTSOF(handle_action_data_table))
return NULL;
return &handle_action_data_table[action];
}
int manager_handle_action(
Manager *m,
InhibitWhat inhibit_key,
HandleAction handle,
bool ignore_inhibited,
bool is_edge) {
static const char * const message_table[_HANDLE_ACTION_MAX] = {
[HANDLE_POWEROFF] = "Powering off...",
[HANDLE_REBOOT] = "Rebooting...",
[HANDLE_HALT] = "Halting...",
[HANDLE_KEXEC] = "Rebooting via kexec...",
[HANDLE_SOFT_REBOOT] = "Rebooting userspace...",
[HANDLE_SUSPEND] = "Suspending...",
[HANDLE_HIBERNATE] = "Hibernating...",
[HANDLE_HYBRID_SLEEP] = "Hibernating and suspending...",
[HANDLE_SUSPEND_THEN_HIBERNATE] = "Suspending, then hibernating...",
[HANDLE_FACTORY_RESET] = "Performing factory reset...",
};
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
InhibitWhat inhibit_operation;
Inhibitor *offending = NULL;
bool supported;
int r;
assert(m);
/* If the key handling is turned off, don't do anything */
if (handle == HANDLE_IGNORE) {
log_debug("Handling of %s (%s) is disabled, taking no action.",
inhibit_key == 0 ? "idle timeout" : inhibit_what_to_string(inhibit_key),
is_edge ? "edge" : "level");
return 0;
}
if (inhibit_key == INHIBIT_HANDLE_LID_SWITCH) {
/* If the last system suspend or startup is too close,
* let's not suspend for now, to give USB docking
* stations some time to settle so that we can
* properly watch its displays. */
if (m->lid_switch_ignore_event_source) {
log_debug("Ignoring lid switch request, system startup or resume too close.");
return 0;
}
}
/* If the key handling is inhibited, don't do anything */
if (inhibit_key > 0) {
if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0, NULL)) {
log_debug("Refusing %s operation, %s is inhibited.",
handle_action_to_string(handle),
inhibit_what_to_string(inhibit_key));
return 0;
}
}
/* Locking is handled differently from the rest. */
if (handle == HANDLE_LOCK) {
if (!is_edge)
return 0;
log_info("Locking sessions...");
session_send_lock_all(m, true);
return 1;
}
if (handle == HANDLE_SUSPEND)
supported = can_sleep(SLEEP_SUSPEND) > 0;
else if (handle == HANDLE_HIBERNATE)
supported = can_sleep(SLEEP_HIBERNATE) > 0;
else if (handle == HANDLE_HYBRID_SLEEP)
supported = can_sleep(SLEEP_HYBRID_SLEEP) > 0;
else if (handle == HANDLE_SUSPEND_THEN_HIBERNATE)
supported = can_sleep(SLEEP_SUSPEND_THEN_HIBERNATE) > 0;
else if (handle == HANDLE_KEXEC)
supported = access(KEXEC, X_OK) >= 0;
else
supported = true;
if (!supported && IN_SET(handle, HANDLE_HIBERNATE, HANDLE_HYBRID_SLEEP, HANDLE_SUSPEND_THEN_HIBERNATE)) {
supported = can_sleep(SLEEP_SUSPEND) > 0;
if (supported) {
log_notice("Requested %s operation is not supported, using regular suspend instead.",
handle_action_to_string(handle));
handle = HANDLE_SUSPEND;
}
}
if (!supported)
return log_warning_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
"Requested %s operation not supported, ignoring.", handle_action_to_string(handle));
if (m->delayed_action)
return log_debug_errno(SYNTHETIC_ERRNO(EALREADY),
"Action already in progress (%s), ignoring requested %s operation.",
inhibit_what_to_string(m->delayed_action->inhibit_what),
handle_action_to_string(handle));
inhibit_operation = handle_action_lookup(handle)->inhibit_what;
/* If the actual operation is inhibited, warn and fail */
if (!ignore_inhibited &&
manager_is_inhibited(m, inhibit_operation, INHIBIT_BLOCK, NULL, false, false, 0, &offending)) {
_cleanup_free_ char *comm = NULL, *u = NULL;
(void) get_process_comm(offending->pid, &comm);
u = uid_to_name(offending->uid);
/* If this is just a recheck of the lid switch then don't warn about anything */
log_full(is_edge ? LOG_ERR : LOG_DEBUG,
"Refusing %s operation, %s is inhibited by UID "UID_FMT"/%s, PID "PID_FMT"/%s.",
handle_action_to_string(handle),
inhibit_what_to_string(inhibit_operation),
offending->uid, strna(u),
offending->pid, strna(comm));
return is_edge ? -EPERM : 0;
}
log_info("%s", message_table[handle]);
r = bus_manager_shutdown_or_sleep_now_or_later(m, handle_action_lookup(handle), &error);
if (r < 0)
return log_error_errno(r, "Failed to execute %s operation: %s",
handle_action_to_string(handle),
bus_error_message(&error, r));
return 1;
}
static const char* const handle_action_verb_table[_HANDLE_ACTION_MAX] = {
[HANDLE_IGNORE] = "do nothing",
[HANDLE_POWEROFF] = "power off",
[HANDLE_REBOOT] = "reboot",
[HANDLE_HALT] = "halt",
[HANDLE_KEXEC] = "kexec",
[HANDLE_SOFT_REBOOT] = "soft-reboot",
[HANDLE_SUSPEND] = "suspend",
[HANDLE_HIBERNATE] = "hibernate",
[HANDLE_HYBRID_SLEEP] = "enter hybrid sleep",
[HANDLE_SUSPEND_THEN_HIBERNATE] = "suspend and later hibernate",
[HANDLE_FACTORY_RESET] = "perform a factory reset",
[HANDLE_LOCK] = "be locked",
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(handle_action_verb, HandleAction);
static const char* const handle_action_table[_HANDLE_ACTION_MAX] = {
[HANDLE_IGNORE] = "ignore",
[HANDLE_POWEROFF] = "poweroff",
[HANDLE_REBOOT] = "reboot",
[HANDLE_HALT] = "halt",
[HANDLE_KEXEC] = "kexec",
[HANDLE_SOFT_REBOOT] = "soft-reboot",
[HANDLE_SUSPEND] = "suspend",
[HANDLE_HIBERNATE] = "hibernate",
[HANDLE_HYBRID_SLEEP] = "hybrid-sleep",
[HANDLE_SUSPEND_THEN_HIBERNATE] = "suspend-then-hibernate",
[HANDLE_FACTORY_RESET] = "factory-reset",
[HANDLE_LOCK] = "lock",
};
DEFINE_STRING_TABLE_LOOKUP(handle_action, HandleAction);
DEFINE_CONFIG_PARSE_ENUM(config_parse_handle_action, handle_action, HandleAction, "Failed to parse handle action setting");
| 15,655 | 51.013289 | 125 |
c
|
null |
systemd-main/src/login/logind-action.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
typedef enum HandleAction {
HANDLE_IGNORE,
HANDLE_POWEROFF,
HANDLE_REBOOT,
HANDLE_HALT,
HANDLE_KEXEC,
HANDLE_SOFT_REBOOT,
HANDLE_SUSPEND,
HANDLE_HIBERNATE,
HANDLE_HYBRID_SLEEP,
HANDLE_SUSPEND_THEN_HIBERNATE,
HANDLE_LOCK,
HANDLE_FACTORY_RESET,
_HANDLE_ACTION_MAX,
_HANDLE_ACTION_INVALID = -EINVAL,
} HandleAction;
typedef struct HandleActionData HandleActionData;
#include "logind-inhibit.h"
#include "logind.h"
#include "sleep-util.h"
static inline bool handle_action_valid(HandleAction a) {
return a >= 0 && a < _HANDLE_ACTION_MAX;
}
struct HandleActionData {
HandleAction handle;
const char *target;
InhibitWhat inhibit_what;
const char *polkit_action;
const char *polkit_action_multiple_sessions;
const char *polkit_action_ignore_inhibit;
SleepOperation sleep_operation;
const char* message_id;
const char* message;
const char* log_verb;
};
int manager_handle_action(
Manager *m,
InhibitWhat inhibit_key,
HandleAction handle,
bool ignore_inhibited,
bool is_edge);
const char* handle_action_verb_to_string(HandleAction h) _const_;
const char* handle_action_to_string(HandleAction h) _const_;
HandleAction handle_action_from_string(const char *s) _pure_;
const HandleActionData* handle_action_lookup(HandleAction handle);
CONFIG_PARSER_PROTOTYPE(config_parse_handle_action);
| 1,654 | 26.131148 | 66 |
h
|
null |
systemd-main/src/login/logind-brightness.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "bus-util.h"
#include "device-util.h"
#include "hash-funcs.h"
#include "logind-brightness.h"
#include "logind.h"
#include "process-util.h"
#include "stdio-util.h"
/* Brightness and LED devices tend to be very slow to write to (often being I2C and such). Writes to the
* sysfs attributes are synchronous, and hence will freeze our process on access. We can't really have that,
* hence we add some complexity: whenever we need to write to the brightness attribute, we do so in a forked
* off process, which terminates when it is done. Watching that process allows us to watch completion of the
* write operation.
*
* To make this even more complex: clients are likely to send us many write requests in a short time-frame
* (because they implement reactive brightness sliders on screen). Let's coalesce writes to make this
* efficient: whenever we get requests to change brightness while we are still writing to the brightness
* attribute, let's remember the request and restart a new one when the initial operation finished. When we
* get another request while one is ongoing and one is pending we'll replace the pending one with the new
* one.
*
* The bus messages are answered when the first write operation finishes that started either due to the
* request or due to a later request that overrode the requested one.
*
* Yes, this is complex, but I don't see an easier way if we want to be both efficient and still support
* completion notification. */
typedef struct BrightnessWriter {
Manager *manager;
sd_device *device;
char *path;
pid_t child;
uint32_t brightness;
bool again;
Set *current_messages;
Set *pending_messages;
sd_event_source* child_event_source;
} BrightnessWriter;
static BrightnessWriter* brightness_writer_free(BrightnessWriter *w) {
if (!w)
return NULL;
if (w->manager && w->path)
(void) hashmap_remove_value(w->manager->brightness_writers, w->path, w);
sd_device_unref(w->device);
free(w->path);
set_free(w->current_messages);
set_free(w->pending_messages);
w->child_event_source = sd_event_source_unref(w->child_event_source);
return mfree(w);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(BrightnessWriter*, brightness_writer_free);
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(
brightness_writer_hash_ops,
char,
string_hash_func,
string_compare_func,
BrightnessWriter,
brightness_writer_free);
static void brightness_writer_reply(BrightnessWriter *w, int error) {
int r;
assert(w);
for (;;) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
m = set_steal_first(w->current_messages);
if (!m)
break;
if (error == 0)
r = sd_bus_reply_method_return(m, NULL);
else
r = sd_bus_reply_method_errnof(m, error, "Failed to write to brightness device: %m");
if (r < 0)
log_warning_errno(r, "Failed to send method reply, ignoring: %m");
}
}
static int brightness_writer_fork(BrightnessWriter *w);
static int on_brightness_writer_exit(sd_event_source *s, const siginfo_t *si, void *userdata) {
BrightnessWriter *w = ASSERT_PTR(userdata);
int r;
assert(s);
assert(si);
assert(si->si_pid == w->child);
w->child = 0;
w->child_event_source = sd_event_source_unref(w->child_event_source);
brightness_writer_reply(w,
si->si_code == CLD_EXITED &&
si->si_status == EXIT_SUCCESS ? 0 : -EPROTO);
if (w->again) {
/* Another request to change the brightness has been queued. Act on it, but make the pending
* messages the current ones. */
w->again = false;
set_free(w->current_messages);
w->current_messages = TAKE_PTR(w->pending_messages);
r = brightness_writer_fork(w);
if (r >= 0)
return 0;
brightness_writer_reply(w, r);
}
brightness_writer_free(w);
return 0;
}
static int brightness_writer_fork(BrightnessWriter *w) {
int r;
assert(w);
assert(w->manager);
assert(w->child == 0);
assert(!w->child_event_source);
r = safe_fork("(sd-bright)", FORK_DEATHSIG|FORK_REARRANGE_STDIO|FORK_CLOSE_ALL_FDS|FORK_LOG|FORK_REOPEN_LOG, &w->child);
if (r < 0)
return r;
if (r == 0) {
char brs[DECIMAL_STR_MAX(uint32_t)+1];
/* Child */
xsprintf(brs, "%" PRIu32, w->brightness);
r = sd_device_set_sysattr_value(w->device, "brightness", brs);
if (r < 0) {
log_device_error_errno(w->device, r, "Failed to write brightness to device: %m");
_exit(EXIT_FAILURE);
}
_exit(EXIT_SUCCESS);
}
r = sd_event_add_child(w->manager->event, &w->child_event_source, w->child, WEXITED, on_brightness_writer_exit, w);
if (r < 0)
return log_error_errno(r, "Failed to watch brightness writer child " PID_FMT ": %m", w->child);
return 0;
}
static int set_add_message(Set **set, sd_bus_message *message) {
int r;
assert(set);
if (!message)
return 0;
r = sd_bus_message_get_expect_reply(message);
if (r <= 0)
return r;
r = set_ensure_put(set, &bus_message_hash_ops, message);
if (r <= 0)
return r;
sd_bus_message_ref(message);
return 1;
}
int manager_write_brightness(
Manager *m,
sd_device *device,
uint32_t brightness,
sd_bus_message *message) {
_cleanup_(brightness_writer_freep) BrightnessWriter *w = NULL;
BrightnessWriter *existing;
const char *path;
int r;
assert(m);
assert(device);
r = sd_device_get_syspath(device, &path);
if (r < 0)
return log_device_error_errno(device, r, "Failed to get sysfs path for brightness device: %m");
existing = hashmap_get(m->brightness_writers, path);
if (existing) {
/* There's already a writer for this device. Let's update it with the new brightness, and add
* our message to the set of message to reply when done. */
r = set_add_message(&existing->pending_messages, message);
if (r < 0)
return log_error_errno(r, "Failed to add message to set: %m");
/* We override any previously requested brightness here: we coalesce writes, and the newest
* requested brightness is the one we'll put into effect. */
existing->brightness = brightness;
existing->again = true; /* request another iteration of the writer when the current one is
* complete */
return 0;
}
w = new(BrightnessWriter, 1);
if (!w)
return log_oom();
*w = (BrightnessWriter) {
.device = sd_device_ref(device),
.path = strdup(path),
.brightness = brightness,
};
if (!w->path)
return log_oom();
r = hashmap_ensure_put(&m->brightness_writers, &brightness_writer_hash_ops, w->path, w);
if (r == -ENOMEM)
return log_oom();
if (r < 0)
return log_error_errno(r, "Failed to add brightness writer to hashmap: %m");
w->manager = m;
r = set_add_message(&w->current_messages, message);
if (r < 0)
return log_error_errno(r, "Failed to add message to set: %m");
r = brightness_writer_fork(w);
if (r < 0)
return r;
TAKE_PTR(w);
return 0;
}
| 8,374 | 32.366534 | 128 |
c
|
null |
systemd-main/src/login/logind-device.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <string.h>
#include "alloc-util.h"
#include "logind-device.h"
#include "logind-seat-dbus.h"
Device* device_new(Manager *m, const char *sysfs, bool master) {
Device *d;
assert(m);
assert(sysfs);
d = new0(Device, 1);
if (!d)
return NULL;
d->sysfs = strdup(sysfs);
if (!d->sysfs)
return mfree(d);
if (hashmap_put(m->devices, d->sysfs, d) < 0) {
free(d->sysfs);
return mfree(d);
}
d->manager = m;
d->master = master;
dual_timestamp_get(&d->timestamp);
return d;
}
static void device_detach(Device *d) {
Seat *s;
SessionDevice *sd;
assert(d);
if (!d->seat)
return;
while ((sd = d->session_devices))
session_device_free(sd);
s = d->seat;
LIST_REMOVE(devices, d->seat->devices, d);
d->seat = NULL;
if (!seat_has_master_device(s)) {
seat_add_to_gc_queue(s);
seat_send_changed(s, "CanGraphical", NULL);
}
}
void device_free(Device *d) {
assert(d);
device_detach(d);
hashmap_remove(d->manager->devices, d->sysfs);
free(d->sysfs);
free(d);
}
void device_attach(Device *d, Seat *s) {
bool had_master;
assert(d);
assert(s);
if (d->seat == s)
return;
if (d->seat)
device_detach(d);
d->seat = s;
had_master = seat_has_master_device(s);
/* We keep the device list sorted by the "master" flag. That is, master
* devices are at the front, other devices at the tail. As there is no
* way to easily add devices at the list-tail, we need to iterate the
* list to find the first non-master device when adding non-master
* devices. We assume there is only a few (normally 1) master devices
* per seat, so we iterate only a few times. */
if (d->master || !s->devices)
LIST_PREPEND(devices, s->devices, d);
else
LIST_FOREACH(devices, i, s->devices) {
if (!i->devices_next || !i->master) {
LIST_INSERT_AFTER(devices, s->devices, i, d);
break;
}
}
if (!had_master && d->master && s->started) {
seat_save(s);
seat_send_changed(s, "CanGraphical", NULL);
}
}
| 2,631 | 24.066667 | 79 |
c
|
null |
systemd-main/src/login/logind-device.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct Device Device;
#include "list.h"
#include "logind-seat.h"
#include "logind-session-device.h"
struct Device {
Manager *manager;
char *sysfs;
Seat *seat;
bool master;
dual_timestamp timestamp;
LIST_FIELDS(struct Device, devices);
LIST_HEAD(SessionDevice, session_devices);
};
Device* device_new(Manager *m, const char *sysfs, bool master);
void device_free(Device *d);
void device_attach(Device *d, Seat *s);
| 547 | 20.076923 | 63 |
h
|
null |
systemd-main/src/login/logind-inhibit.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "alloc-util.h"
#include "env-file.h"
#include "errno-list.h"
#include "errno-util.h"
#include "escape.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "fs-util.h"
#include "io-util.h"
#include "logind-dbus.h"
#include "logind-inhibit.h"
#include "missing_threads.h"
#include "mkdir-label.h"
#include "parse-util.h"
#include "path-util.h"
#include "string-table.h"
#include "string-util.h"
#include "tmpfile-util.h"
#include "user-util.h"
static void inhibitor_remove_fifo(Inhibitor *i);
int inhibitor_new(Inhibitor **ret, Manager *m, const char* id) {
_cleanup_(inhibitor_freep) Inhibitor *i = NULL;
int r;
assert(ret);
assert(m);
assert(id);
i = new(Inhibitor, 1);
if (!i)
return -ENOMEM;
*i = (Inhibitor) {
.manager = m,
.what = _INHIBIT_WHAT_INVALID,
.mode = _INHIBIT_MODE_INVALID,
.uid = UID_INVALID,
.fifo_fd = -EBADF,
};
i->state_file = path_join("/run/systemd/inhibit", id);
if (!i->state_file)
return -ENOMEM;
i->id = basename(i->state_file);
r = hashmap_put(m->inhibitors, i->id, i);
if (r < 0)
return r;
*ret = TAKE_PTR(i);
return 0;
}
Inhibitor* inhibitor_free(Inhibitor *i) {
if (!i)
return NULL;
free(i->who);
free(i->why);
sd_event_source_unref(i->event_source);
safe_close(i->fifo_fd);
hashmap_remove(i->manager->inhibitors, i->id);
/* Note that we don't remove neither the state file nor the fifo path here, since we want both to
* survive daemon restarts */
free(i->state_file);
free(i->fifo_path);
return mfree(i);
}
static int inhibitor_save(Inhibitor *i) {
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
assert(i);
r = mkdir_safe_label("/run/systemd/inhibit", 0755, 0, 0, MKDIR_WARN_MODE);
if (r < 0)
goto fail;
r = fopen_temporary(i->state_file, &f, &temp_path);
if (r < 0)
goto fail;
(void) fchmod(fileno(f), 0644);
fprintf(f,
"# This is private data. Do not parse.\n"
"WHAT=%s\n"
"MODE=%s\n"
"UID="UID_FMT"\n"
"PID="PID_FMT"\n",
inhibit_what_to_string(i->what),
inhibit_mode_to_string(i->mode),
i->uid,
i->pid);
if (i->who) {
_cleanup_free_ char *cc = NULL;
cc = cescape(i->who);
if (!cc) {
r = -ENOMEM;
goto fail;
}
fprintf(f, "WHO=%s\n", cc);
}
if (i->why) {
_cleanup_free_ char *cc = NULL;
cc = cescape(i->why);
if (!cc) {
r = -ENOMEM;
goto fail;
}
fprintf(f, "WHY=%s\n", cc);
}
if (i->fifo_path)
fprintf(f, "FIFO=%s\n", i->fifo_path);
r = fflush_and_check(f);
if (r < 0)
goto fail;
if (rename(temp_path, i->state_file) < 0) {
r = -errno;
goto fail;
}
temp_path = mfree(temp_path);
return 0;
fail:
(void) unlink(i->state_file);
return log_error_errno(r, "Failed to save inhibit data %s: %m", i->state_file);
}
static int bus_manager_send_inhibited_change(Inhibitor *i) {
const char *property;
assert(i);
property = i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited";
return manager_send_changed(i->manager, property, NULL);
}
int inhibitor_start(Inhibitor *i) {
assert(i);
if (i->started)
return 0;
dual_timestamp_get(&i->since);
log_debug("Inhibitor %s (%s) pid="PID_FMT" uid="UID_FMT" mode=%s started.",
strna(i->who), strna(i->why),
i->pid, i->uid,
inhibit_mode_to_string(i->mode));
i->started = true;
inhibitor_save(i);
bus_manager_send_inhibited_change(i);
return 0;
}
void inhibitor_stop(Inhibitor *i) {
assert(i);
if (i->started)
log_debug("Inhibitor %s (%s) pid="PID_FMT" uid="UID_FMT" mode=%s stopped.",
strna(i->who), strna(i->why),
i->pid, i->uid,
inhibit_mode_to_string(i->mode));
inhibitor_remove_fifo(i);
if (i->state_file)
(void) unlink(i->state_file);
i->started = false;
bus_manager_send_inhibited_change(i);
}
int inhibitor_load(Inhibitor *i) {
_cleanup_free_ char *what = NULL, *uid = NULL, *pid = NULL, *who = NULL, *why = NULL, *mode = NULL;
InhibitWhat w;
InhibitMode mm;
char *cc;
ssize_t l;
int r;
r = parse_env_file(NULL, i->state_file,
"WHAT", &what,
"UID", &uid,
"PID", &pid,
"WHO", &who,
"WHY", &why,
"MODE", &mode,
"FIFO", &i->fifo_path);
if (r < 0)
return log_error_errno(r, "Failed to read %s: %m", i->state_file);
w = what ? inhibit_what_from_string(what) : 0;
if (w >= 0)
i->what = w;
mm = mode ? inhibit_mode_from_string(mode) : INHIBIT_BLOCK;
if (mm >= 0)
i->mode = mm;
if (uid) {
r = parse_uid(uid, &i->uid);
if (r < 0)
log_debug_errno(r, "Failed to parse UID of inhibitor: %s", uid);
}
if (pid) {
r = parse_pid(pid, &i->pid);
if (r < 0)
log_debug_errno(r, "Failed to parse PID of inhibitor: %s", pid);
}
if (who) {
l = cunescape(who, 0, &cc);
if (l < 0)
return log_debug_errno(l, "Failed to unescape \"who\" of inhibitor: %m");
free_and_replace(i->who, cc);
}
if (why) {
l = cunescape(why, 0, &cc);
if (l < 0)
return log_debug_errno(l, "Failed to unescape \"why\" of inhibitor: %m");
free_and_replace(i->why, cc);
}
if (i->fifo_path) {
_cleanup_close_ int fd = -EBADF;
/* Let's re-open the FIFO on both sides, and close the writing side right away */
fd = inhibitor_create_fifo(i);
if (fd < 0)
return log_error_errno(fd, "Failed to reopen FIFO: %m");
}
return 0;
}
static int inhibitor_dispatch_fifo(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
Inhibitor *i = ASSERT_PTR(userdata);
assert(s);
assert(fd == i->fifo_fd);
inhibitor_stop(i);
inhibitor_free(i);
return 0;
}
int inhibitor_create_fifo(Inhibitor *i) {
int r;
assert(i);
/* Create FIFO */
if (!i->fifo_path) {
r = mkdir_safe_label("/run/systemd/inhibit", 0755, 0, 0, MKDIR_WARN_MODE);
if (r < 0)
return r;
i->fifo_path = strjoin("/run/systemd/inhibit/", i->id, ".ref");
if (!i->fifo_path)
return -ENOMEM;
if (mkfifo(i->fifo_path, 0600) < 0 && errno != EEXIST)
return -errno;
}
/* Open reading side */
if (i->fifo_fd < 0) {
i->fifo_fd = open(i->fifo_path, O_RDONLY|O_CLOEXEC|O_NONBLOCK);
if (i->fifo_fd < 0)
return -errno;
}
if (!i->event_source) {
r = sd_event_add_io(i->manager->event, &i->event_source, i->fifo_fd, 0, inhibitor_dispatch_fifo, i);
if (r < 0)
return r;
r = sd_event_source_set_priority(i->event_source, SD_EVENT_PRIORITY_IDLE-10);
if (r < 0)
return r;
(void) sd_event_source_set_description(i->event_source, "inhibitor-ref");
}
/* Open writing side */
return RET_NERRNO(open(i->fifo_path, O_WRONLY|O_CLOEXEC|O_NONBLOCK));
}
static void inhibitor_remove_fifo(Inhibitor *i) {
assert(i);
i->event_source = sd_event_source_unref(i->event_source);
i->fifo_fd = safe_close(i->fifo_fd);
if (i->fifo_path) {
(void) unlink(i->fifo_path);
i->fifo_path = mfree(i->fifo_path);
}
}
bool inhibitor_is_orphan(Inhibitor *i) {
assert(i);
if (!i->started)
return true;
if (!i->fifo_path)
return true;
if (i->fifo_fd < 0)
return true;
if (pipe_eof(i->fifo_fd) != 0)
return true;
return false;
}
InhibitWhat manager_inhibit_what(Manager *m, InhibitMode mm) {
Inhibitor *i;
InhibitWhat what = 0;
assert(m);
HASHMAP_FOREACH(i, m->inhibitors)
if (i->mode == mm && i->started)
what |= i->what;
return what;
}
static int pid_is_active(Manager *m, pid_t pid) {
Session *s;
int r;
/* Get client session. This is not what you are looking for these days.
* FIXME #6852 */
r = manager_get_session_by_pid(m, pid, &s);
if (r < 0)
return r;
/* If there's no session assigned to it, then it's globally
* active on all ttys */
if (r == 0)
return 1;
return session_is_active(s);
}
bool manager_is_inhibited(
Manager *m,
InhibitWhat w,
InhibitMode mm,
dual_timestamp *since,
bool ignore_inactive,
bool ignore_uid,
uid_t uid,
Inhibitor **offending) {
Inhibitor *i;
struct dual_timestamp ts = DUAL_TIMESTAMP_NULL;
bool inhibited = false;
assert(m);
assert(w > 0 && w < _INHIBIT_WHAT_MAX);
HASHMAP_FOREACH(i, m->inhibitors) {
if (!i->started)
continue;
if (!(i->what & w))
continue;
if (i->mode != mm)
continue;
if (ignore_inactive && pid_is_active(m, i->pid) <= 0)
continue;
if (ignore_uid && i->uid == uid)
continue;
if (!inhibited ||
i->since.monotonic < ts.monotonic)
ts = i->since;
inhibited = true;
if (offending)
*offending = i;
}
if (since)
*since = ts;
return inhibited;
}
const char *inhibit_what_to_string(InhibitWhat w) {
static thread_local char buffer[STRLEN(
"shutdown:"
"sleep:"
"idle:"
"handle-power-key:"
"handle-suspend-key:"
"handle-hibernate-key:"
"handle-lid-switch:"
"handle-reboot-key")+1];
char *p;
if (w < 0 || w >= _INHIBIT_WHAT_MAX)
return NULL;
p = buffer;
if (w & INHIBIT_SHUTDOWN)
p = stpcpy(p, "shutdown:");
if (w & INHIBIT_SLEEP)
p = stpcpy(p, "sleep:");
if (w & INHIBIT_IDLE)
p = stpcpy(p, "idle:");
if (w & INHIBIT_HANDLE_POWER_KEY)
p = stpcpy(p, "handle-power-key:");
if (w & INHIBIT_HANDLE_SUSPEND_KEY)
p = stpcpy(p, "handle-suspend-key:");
if (w & INHIBIT_HANDLE_HIBERNATE_KEY)
p = stpcpy(p, "handle-hibernate-key:");
if (w & INHIBIT_HANDLE_LID_SWITCH)
p = stpcpy(p, "handle-lid-switch:");
if (w & INHIBIT_HANDLE_REBOOT_KEY)
p = stpcpy(p, "handle-reboot-key:");
if (p > buffer)
*(p-1) = 0;
else
*p = 0;
return buffer;
}
int inhibit_what_from_string(const char *s) {
InhibitWhat what = 0;
for (const char *p = s;;) {
_cleanup_free_ char *word = NULL;
int r;
/* A sanity check that our return values fit in an int */
assert_cc((int) _INHIBIT_WHAT_MAX == _INHIBIT_WHAT_MAX);
r = extract_first_word(&p, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
return r;
if (r == 0)
return what;
if (streq(word, "shutdown"))
what |= INHIBIT_SHUTDOWN;
else if (streq(word, "sleep"))
what |= INHIBIT_SLEEP;
else if (streq(word, "idle"))
what |= INHIBIT_IDLE;
else if (streq(word, "handle-power-key"))
what |= INHIBIT_HANDLE_POWER_KEY;
else if (streq(word, "handle-suspend-key"))
what |= INHIBIT_HANDLE_SUSPEND_KEY;
else if (streq(word, "handle-hibernate-key"))
what |= INHIBIT_HANDLE_HIBERNATE_KEY;
else if (streq(word, "handle-lid-switch"))
what |= INHIBIT_HANDLE_LID_SWITCH;
else if (streq(word, "handle-reboot-key"))
what |= INHIBIT_HANDLE_REBOOT_KEY;
else
return _INHIBIT_WHAT_INVALID;
}
}
static const char* const inhibit_mode_table[_INHIBIT_MODE_MAX] = {
[INHIBIT_BLOCK] = "block",
[INHIBIT_DELAY] = "delay"
};
DEFINE_STRING_TABLE_LOOKUP(inhibit_mode, InhibitMode);
| 14,565 | 26.692015 | 116 |
c
|
null |
systemd-main/src/login/logind-polkit.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "bus-polkit.h"
#include "logind-polkit.h"
#include "missing_capability.h"
#include "user-util.h"
int check_polkit_chvt(sd_bus_message *message, Manager *manager, sd_bus_error *error) {
#if ENABLE_POLKIT
return bus_verify_polkit_async(
message,
CAP_SYS_ADMIN,
"org.freedesktop.login1.chvt",
NULL,
false,
UID_INVALID,
&manager->polkit_registry,
error);
#else
/* Allow chvt when polkit is not present. This allows a service to start a graphical session as a
* non-root user when polkit is not compiled in, more closely matching the default polkit policy */
return 1;
#endif
}
| 858 | 33.36 | 107 |
c
|
null |
systemd-main/src/login/logind-seat-dbus.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-get-properties.h"
#include "bus-label.h"
#include "bus-polkit.h"
#include "bus-util.h"
#include "logind-dbus.h"
#include "logind-polkit.h"
#include "logind-seat-dbus.h"
#include "logind-seat.h"
#include "logind-session-dbus.h"
#include "logind.h"
#include "missing_capability.h"
#include "strv.h"
#include "user-util.h"
static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_const_true, "b", true);
static BUS_DEFINE_PROPERTY_GET(property_get_can_tty, "b", Seat, seat_can_tty);
static BUS_DEFINE_PROPERTY_GET(property_get_can_graphical, "b", Seat, seat_can_graphical);
static int property_get_active_session(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
Seat *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
p = s->active ? session_bus_path(s->active) : strdup("/");
if (!p)
return -ENOMEM;
return sd_bus_message_append(reply, "(so)", s->active ? s->active->id : "", p);
}
static int property_get_sessions(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
r = sd_bus_message_open_container(reply, 'a', "(so)");
if (r < 0)
return r;
LIST_FOREACH(sessions_by_seat, session, s->sessions) {
_cleanup_free_ char *p = NULL;
p = session_bus_path(session);
if (!p)
return -ENOMEM;
r = sd_bus_message_append(reply, "(so)", session->id, p);
if (r < 0)
return r;
}
r = sd_bus_message_close_container(reply);
if (r < 0)
return r;
return 1;
}
static int property_get_idle_hint(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
return sd_bus_message_append(reply, "b", seat_get_idle_hint(s, NULL) > 0);
}
static int property_get_idle_since_hint(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
dual_timestamp t;
uint64_t u;
int r;
assert(bus);
assert(reply);
r = seat_get_idle_hint(s, &t);
if (r < 0)
return r;
u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
return sd_bus_message_append(reply, "t", u);
}
int bus_seat_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
int r;
assert(message);
r = bus_verify_polkit_async(
message,
CAP_KILL,
"org.freedesktop.login1.manage",
NULL,
false,
UID_INVALID,
&s->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = seat_stop_sessions(s, /* force = */ true);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
const char *name;
Session *session;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
session = hashmap_get(s->manager->sessions, name);
if (!session)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
if (session->seat != s)
return sd_bus_error_setf(error, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", name, s->id);
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = session_activate(session);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_switch_to(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
unsigned to;
int r;
assert(message);
r = sd_bus_message_read(message, "u", &to);
if (r < 0)
return r;
if (to <= 0)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid virtual terminal");
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = seat_switch_to(s, to);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_switch_to_next(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
int r;
assert(message);
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = seat_switch_to_next(s);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_switch_to_previous(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Seat *s = ASSERT_PTR(userdata);
int r;
assert(message);
r = check_polkit_chvt(message, s->manager, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = seat_switch_to_previous(s);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int seat_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
_cleanup_free_ char *e = NULL;
sd_bus_message *message;
Manager *m = ASSERT_PTR(userdata);
const char *p;
Seat *seat;
int r;
assert(bus);
assert(path);
assert(interface);
assert(found);
p = startswith(path, "/org/freedesktop/login1/seat/");
if (!p)
return 0;
e = bus_label_unescape(p);
if (!e)
return -ENOMEM;
message = sd_bus_get_current_message(bus);
r = manager_get_seat_from_creds(m, message, e, error, &seat);
if (r == -ENXIO) {
sd_bus_error_free(error);
return 0;
}
if (r < 0)
return r;
*found = seat;
return 1;
}
char *seat_bus_path(Seat *s) {
_cleanup_free_ char *t = NULL;
assert(s);
t = bus_label_escape(s->id);
if (!t)
return NULL;
return strjoin("/org/freedesktop/login1/seat/", t);
}
static int seat_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
sd_bus_message *message;
Manager *m = userdata;
Seat *seat;
int r;
assert(bus);
assert(path);
assert(nodes);
HASHMAP_FOREACH(seat, m->seats) {
char *p;
p = seat_bus_path(seat);
if (!p)
return -ENOMEM;
r = strv_consume(&l, p);
if (r < 0)
return r;
}
message = sd_bus_get_current_message(bus);
if (message) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
if (r >= 0) {
bool may_auto = false;
const char *name;
r = sd_bus_creds_get_session(creds, &name);
if (r >= 0) {
Session *session;
session = hashmap_get(m->sessions, name);
if (session && session->seat) {
r = strv_extend(&l, "/org/freedesktop/login1/seat/self");
if (r < 0)
return r;
may_auto = true;
}
}
if (!may_auto) {
uid_t uid;
r = sd_bus_creds_get_owner_uid(creds, &uid);
if (r >= 0) {
User *user;
user = hashmap_get(m->users, UID_TO_PTR(uid));
may_auto = user && user->display && user->display->seat;
}
}
if (may_auto) {
r = strv_extend(&l, "/org/freedesktop/login1/seat/auto");
if (r < 0)
return r;
}
}
}
*nodes = TAKE_PTR(l);
return 1;
}
int seat_send_signal(Seat *s, bool new_seat) {
_cleanup_free_ char *p = NULL;
assert(s);
p = seat_bus_path(s);
if (!p)
return -ENOMEM;
return sd_bus_emit_signal(
s->manager->bus,
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
new_seat ? "SeatNew" : "SeatRemoved",
"so", s->id, p);
}
int seat_send_changed(Seat *s, const char *properties, ...) {
_cleanup_free_ char *p = NULL;
char **l;
assert(s);
if (!s->started)
return 0;
p = seat_bus_path(s);
if (!p)
return -ENOMEM;
l = strv_from_stdarg_alloca(properties);
return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Seat", l);
}
static const sd_bus_vtable seat_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Seat, id), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("ActiveSession", "(so)", property_get_active_session, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("CanMultiSession", "b", property_get_const_true, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("CanTTY", "b", property_get_can_tty, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("CanGraphical", "b", property_get_can_graphical, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, 0),
SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_METHOD("Terminate", NULL, NULL, bus_seat_method_terminate, SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("ActivateSession",
SD_BUS_ARGS("s", session_id),
SD_BUS_NO_RESULT,
method_activate_session,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("SwitchTo",
SD_BUS_ARGS("u", vtnr),
SD_BUS_NO_RESULT,
method_switch_to,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD("SwitchToNext", NULL, NULL, method_switch_to_next, SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD("SwitchToPrevious", NULL, NULL, method_switch_to_previous, SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_VTABLE_END
};
const BusObjectImplementation seat_object = {
"/org/freedesktop/login1/seat",
"org.freedesktop.login1.Seat",
.fallback_vtables = BUS_FALLBACK_VTABLES({seat_vtable, seat_object_find}),
.node_enumerator = seat_node_enumerator,
};
| 13,685 | 29.893905 | 134 |
c
|
null |
systemd-main/src/login/logind-seat.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "sd-messages.h"
#include "alloc-util.h"
#include "devnode-acl.h"
#include "errno-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "format-util.h"
#include "fs-util.h"
#include "logind-seat-dbus.h"
#include "logind-seat.h"
#include "logind-session-dbus.h"
#include "mkdir-label.h"
#include "parse-util.h"
#include "path-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "terminal-util.h"
#include "tmpfile-util.h"
int seat_new(Seat** ret, Manager *m, const char *id) {
_cleanup_(seat_freep) Seat *s = NULL;
int r;
assert(ret);
assert(m);
assert(id);
if (!seat_name_is_valid(id))
return -EINVAL;
s = new(Seat, 1);
if (!s)
return -ENOMEM;
*s = (Seat) {
.manager = m,
};
s->state_file = path_join("/run/systemd/seats", id);
if (!s->state_file)
return -ENOMEM;
s->id = basename(s->state_file);
r = hashmap_put(m->seats, s->id, s);
if (r < 0)
return r;
*ret = TAKE_PTR(s);
return 0;
}
Seat* seat_free(Seat *s) {
if (!s)
return NULL;
if (s->in_gc_queue)
LIST_REMOVE(gc_queue, s->manager->seat_gc_queue, s);
while (s->sessions)
session_free(s->sessions);
assert(!s->active);
while (s->devices)
device_free(s->devices);
hashmap_remove(s->manager->seats, s->id);
free(s->positions);
free(s->state_file);
return mfree(s);
}
int seat_save(Seat *s) {
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
assert(s);
if (!s->started)
return 0;
r = mkdir_safe_label("/run/systemd/seats", 0755, 0, 0, MKDIR_WARN_MODE);
if (r < 0)
goto fail;
r = fopen_temporary(s->state_file, &f, &temp_path);
if (r < 0)
goto fail;
(void) fchmod(fileno(f), 0644);
fprintf(f,
"# This is private data. Do not parse.\n"
"IS_SEAT0=%i\n"
"CAN_MULTI_SESSION=1\n"
"CAN_TTY=%i\n"
"CAN_GRAPHICAL=%i\n",
seat_is_seat0(s),
seat_can_tty(s),
seat_can_graphical(s));
if (s->active) {
assert(s->active->user);
fprintf(f,
"ACTIVE=%s\n"
"ACTIVE_UID="UID_FMT"\n",
s->active->id,
s->active->user->user_record->uid);
}
if (s->sessions) {
fputs("SESSIONS=", f);
LIST_FOREACH(sessions_by_seat, i, s->sessions) {
fprintf(f,
"%s%c",
i->id,
i->sessions_by_seat_next ? ' ' : '\n');
}
fputs("UIDS=", f);
LIST_FOREACH(sessions_by_seat, i, s->sessions)
fprintf(f,
UID_FMT"%c",
i->user->user_record->uid,
i->sessions_by_seat_next ? ' ' : '\n');
}
r = fflush_and_check(f);
if (r < 0)
goto fail;
if (rename(temp_path, s->state_file) < 0) {
r = -errno;
goto fail;
}
temp_path = mfree(temp_path);
return 0;
fail:
(void) unlink(s->state_file);
return log_error_errno(r, "Failed to save seat data %s: %m", s->state_file);
}
int seat_load(Seat *s) {
assert(s);
/* There isn't actually anything to read here ... */
return 0;
}
static int vt_allocate(unsigned vtnr) {
char p[sizeof("/dev/tty") + DECIMAL_STR_MAX(unsigned)];
_cleanup_close_ int fd = -EBADF;
assert(vtnr >= 1);
xsprintf(p, "/dev/tty%u", vtnr);
fd = open_terminal(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
if (fd < 0)
return fd;
return 0;
}
int seat_preallocate_vts(Seat *s) {
int r = 0;
unsigned i;
assert(s);
assert(s->manager);
if (s->manager->n_autovts <= 0)
return 0;
if (!seat_has_vts(s))
return 0;
log_debug("Preallocating VTs...");
for (i = 1; i <= s->manager->n_autovts; i++) {
int q;
q = vt_allocate(i);
if (q < 0)
r = log_error_errno(q, "Failed to preallocate VT %u: %m", i);
}
return r;
}
int seat_apply_acls(Seat *s, Session *old_active) {
int r;
assert(s);
r = devnode_acl_all(s->id,
false,
!!old_active, old_active ? old_active->user->user_record->uid : 0,
!!s->active, s->active ? s->active->user->user_record->uid : 0);
if (r < 0)
return log_error_errno(r, "Failed to apply ACLs: %m");
return 0;
}
int seat_set_active(Seat *s, Session *session) {
Session *old_active;
assert(s);
assert(!session || session->seat == s);
if (session == s->active)
return 0;
old_active = s->active;
s->active = session;
if (old_active) {
session_device_pause_all(old_active);
session_send_changed(old_active, "Active", NULL);
}
(void) seat_apply_acls(s, old_active);
if (session && session->started) {
session_send_changed(session, "Active", NULL);
session_device_resume_all(session);
}
if (!session || session->started)
seat_send_changed(s, "ActiveSession", NULL);
seat_save(s);
if (session) {
session_save(session);
user_save(session->user);
}
if (old_active) {
session_save(old_active);
if (!session || session->user != old_active->user)
user_save(old_active->user);
}
return 0;
}
static Session* seat_get_position(Seat *s, unsigned pos) {
assert(s);
if (pos >= MALLOC_ELEMENTSOF(s->positions))
return NULL;
return s->positions[pos];
}
int seat_switch_to(Seat *s, unsigned num) {
Session *session;
/* Public session positions skip 0 (there is only F1-F12). Maybe it
* will get reassigned in the future, so return error for now. */
if (num == 0)
return -EINVAL;
session = seat_get_position(s, num);
if (!session) {
/* allow switching to unused VTs to trigger auto-activate */
if (seat_has_vts(s) && num < 64)
return chvt(num);
return -EINVAL;
}
return session_activate(session);
}
int seat_switch_to_next(Seat *s) {
unsigned start, i;
Session *session;
if (MALLOC_ELEMENTSOF(s->positions) == 0)
return -EINVAL;
start = 1;
if (s->active && s->active->position > 0)
start = s->active->position;
for (i = start + 1; i < MALLOC_ELEMENTSOF(s->positions); ++i) {
session = seat_get_position(s, i);
if (session)
return session_activate(session);
}
for (i = 1; i < start; ++i) {
session = seat_get_position(s, i);
if (session)
return session_activate(session);
}
return -EINVAL;
}
int seat_switch_to_previous(Seat *s) {
if (MALLOC_ELEMENTSOF(s->positions) == 0)
return -EINVAL;
size_t start = s->active && s->active->position > 0 ? s->active->position : 1;
for (size_t i = start - 1; i > 0; i--) {
Session *session = seat_get_position(s, i);
if (session)
return session_activate(session);
}
for (size_t i = MALLOC_ELEMENTSOF(s->positions) - 1; i > start; i--) {
Session *session = seat_get_position(s, i);
if (session)
return session_activate(session);
}
return -EINVAL;
}
int seat_active_vt_changed(Seat *s, unsigned vtnr) {
Session *new_active = NULL;
int r;
assert(s);
assert(vtnr >= 1);
if (!seat_has_vts(s))
return -EINVAL;
log_debug("VT changed to %u", vtnr);
/* we might have earlier closing sessions on the same VT, so try to
* find a running one first */
LIST_FOREACH(sessions_by_seat, i, s->sessions)
if (i->vtnr == vtnr && !i->stopping) {
new_active = i;
break;
}
if (!new_active)
/* no running one? then we can't decide which one is the
* active one, let the first one win */
LIST_FOREACH(sessions_by_seat, i, s->sessions)
if (i->vtnr == vtnr) {
new_active = i;
break;
}
r = seat_set_active(s, new_active);
manager_spawn_autovt(s->manager, vtnr);
return r;
}
int seat_read_active_vt(Seat *s) {
char t[64];
ssize_t k;
int vtnr;
assert(s);
if (!seat_has_vts(s))
return 0;
if (lseek(s->manager->console_active_fd, SEEK_SET, 0) < 0)
return log_error_errno(errno, "lseek on console_active_fd failed: %m");
errno = 0;
k = read(s->manager->console_active_fd, t, sizeof(t)-1);
if (k <= 0)
return log_error_errno(errno ?: EIO,
"Failed to read current console: %s", STRERROR_OR_EOF(errno));
t[k] = 0;
truncate_nl(t);
vtnr = vtnr_from_tty(t);
if (vtnr < 0) {
log_error_errno(vtnr, "Hm, /sys/class/tty/tty0/active is badly formatted: %m");
return -EIO;
}
return seat_active_vt_changed(s, vtnr);
}
int seat_start(Seat *s) {
assert(s);
if (s->started)
return 0;
log_struct(LOG_INFO,
"MESSAGE_ID=" SD_MESSAGE_SEAT_START_STR,
"SEAT_ID=%s", s->id,
LOG_MESSAGE("New seat %s.", s->id));
/* Initialize VT magic stuff */
seat_preallocate_vts(s);
/* Read current VT */
seat_read_active_vt(s);
s->started = true;
/* Save seat data */
seat_save(s);
seat_send_signal(s, true);
return 0;
}
int seat_stop(Seat *s, bool force) {
int r;
assert(s);
if (s->started)
log_struct(LOG_INFO,
"MESSAGE_ID=" SD_MESSAGE_SEAT_STOP_STR,
"SEAT_ID=%s", s->id,
LOG_MESSAGE("Removed seat %s.", s->id));
r = seat_stop_sessions(s, force);
(void) unlink(s->state_file);
seat_add_to_gc_queue(s);
if (s->started)
seat_send_signal(s, false);
s->started = false;
return r;
}
int seat_stop_sessions(Seat *s, bool force) {
int r = 0, k;
assert(s);
LIST_FOREACH(sessions_by_seat, session, s->sessions) {
k = session_stop(session, force);
if (k < 0)
r = k;
}
return r;
}
void seat_evict_position(Seat *s, Session *session) {
unsigned pos = session->position;
session->position = 0;
if (pos == 0)
return;
if (pos < MALLOC_ELEMENTSOF(s->positions) && s->positions[pos] == session) {
s->positions[pos] = NULL;
/* There might be another session claiming the same
* position (eg., during gdm->session transition), so let's look
* for it and set it on the free slot. */
LIST_FOREACH(sessions_by_seat, iter, s->sessions)
if (iter->position == pos && session_get_state(iter) != SESSION_CLOSING) {
s->positions[pos] = iter;
break;
}
}
}
void seat_claim_position(Seat *s, Session *session, unsigned pos) {
/* with VTs, the position is always the same as the VTnr */
if (seat_has_vts(s))
pos = session->vtnr;
if (!GREEDY_REALLOC0(s->positions, pos + 1))
return;
seat_evict_position(s, session);
session->position = pos;
if (pos > 0)
s->positions[pos] = session;
}
static void seat_assign_position(Seat *s, Session *session) {
unsigned pos;
if (session->position > 0)
return;
for (pos = 1; pos < MALLOC_ELEMENTSOF(s->positions); ++pos)
if (!s->positions[pos])
break;
seat_claim_position(s, session, pos);
}
int seat_attach_session(Seat *s, Session *session) {
assert(s);
assert(session);
assert(!session->seat);
if (!seat_has_vts(s) != !session->vtnr)
return -EINVAL;
session->seat = s;
LIST_PREPEND(sessions_by_seat, s->sessions, session);
seat_assign_position(s, session);
/* On seats with VTs, the VT logic defines which session is active. On
* seats without VTs, we automatically activate new sessions. */
if (!seat_has_vts(s))
seat_set_active(s, session);
return 0;
}
void seat_complete_switch(Seat *s) {
Session *session;
assert(s);
/* if no session-switch is pending or if it got canceled, do nothing */
if (!s->pending_switch)
return;
session = TAKE_PTR(s->pending_switch);
seat_set_active(s, session);
}
bool seat_has_vts(Seat *s) {
assert(s);
return seat_is_seat0(s) && s->manager->console_active_fd >= 0;
}
bool seat_is_seat0(Seat *s) {
assert(s);
return s->manager->seat0 == s;
}
bool seat_can_tty(Seat *s) {
assert(s);
return seat_has_vts(s);
}
bool seat_has_master_device(Seat *s) {
assert(s);
/* device list is ordered by "master" flag */
return !!s->devices && s->devices->master;
}
bool seat_can_graphical(Seat *s) {
assert(s);
return seat_has_master_device(s);
}
int seat_get_idle_hint(Seat *s, dual_timestamp *t) {
bool idle_hint = true;
dual_timestamp ts = DUAL_TIMESTAMP_NULL;
assert(s);
LIST_FOREACH(sessions_by_seat, session, s->sessions) {
dual_timestamp k;
int ih;
ih = session_get_idle_hint(session, &k);
if (ih < 0)
return ih;
if (!ih) {
if (!idle_hint) {
if (k.monotonic > ts.monotonic)
ts = k;
} else {
idle_hint = false;
ts = k;
}
} else if (idle_hint) {
if (k.monotonic > ts.monotonic)
ts = k;
}
}
if (t)
*t = ts;
return idle_hint;
}
bool seat_may_gc(Seat *s, bool drop_not_started) {
assert(s);
if (drop_not_started && !s->started)
return true;
if (seat_is_seat0(s))
return false;
return !seat_has_master_device(s);
}
void seat_add_to_gc_queue(Seat *s) {
assert(s);
if (s->in_gc_queue)
return;
LIST_PREPEND(gc_queue, s->manager->seat_gc_queue, s);
s->in_gc_queue = true;
}
static bool seat_name_valid_char(char c) {
return
ascii_isalpha(c) ||
ascii_isdigit(c) ||
IN_SET(c, '-', '_');
}
bool seat_name_is_valid(const char *name) {
const char *p;
assert(name);
if (!startswith(name, "seat"))
return false;
if (!name[4])
return false;
for (p = name; *p; p++)
if (!seat_name_valid_char(*p))
return false;
if (strlen(name) > 255)
return false;
return true;
}
| 17,081 | 24.457526 | 101 |
c
|
null |
systemd-main/src/login/logind-seat.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct Seat Seat;
#include "list.h"
#include "logind-session.h"
struct Seat {
Manager *manager;
char *id;
char *state_file;
LIST_HEAD(Device, devices);
Session *active;
Session *pending_switch;
LIST_HEAD(Session, sessions);
Session **positions;
bool in_gc_queue:1;
bool started:1;
LIST_FIELDS(Seat, gc_queue);
};
int seat_new(Seat **ret, Manager *m, const char *id);
Seat* seat_free(Seat *s);
DEFINE_TRIVIAL_CLEANUP_FUNC(Seat *, seat_free);
int seat_save(Seat *s);
int seat_load(Seat *s);
int seat_apply_acls(Seat *s, Session *old_active);
int seat_set_active(Seat *s, Session *session);
int seat_switch_to(Seat *s, unsigned num);
int seat_switch_to_next(Seat *s);
int seat_switch_to_previous(Seat *s);
int seat_active_vt_changed(Seat *s, unsigned vtnr);
int seat_read_active_vt(Seat *s);
int seat_preallocate_vts(Seat *s);
int seat_attach_session(Seat *s, Session *session);
void seat_complete_switch(Seat *s);
void seat_evict_position(Seat *s, Session *session);
void seat_claim_position(Seat *s, Session *session, unsigned pos);
bool seat_has_vts(Seat *s);
bool seat_is_seat0(Seat *s);
bool seat_can_tty(Seat *s);
bool seat_has_master_device(Seat *s);
bool seat_can_graphical(Seat *s);
int seat_get_idle_hint(Seat *s, dual_timestamp *t);
int seat_start(Seat *s);
int seat_stop(Seat *s, bool force);
int seat_stop_sessions(Seat *s, bool force);
bool seat_may_gc(Seat *s, bool drop_not_started);
void seat_add_to_gc_queue(Seat *s);
bool seat_name_is_valid(const char *name);
static inline bool SEAT_IS_SELF(const char *name) {
return isempty(name) || streq(name, "self");
}
static inline bool SEAT_IS_AUTO(const char *name) {
return streq_ptr(name, "auto");
}
| 1,856 | 23.76 | 66 |
h
|
null |
systemd-main/src/login/logind-session-dbus.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-bus.h"
#include "bus-object.h"
#include "logind-session.h"
extern const BusObjectImplementation session_object;
char *session_bus_path(Session *s);
int session_send_signal(Session *s, bool new_session);
int session_send_changed(Session *s, const char *properties, ...) _sentinel_;
int session_send_lock(Session *s, bool lock);
int session_send_lock_all(Manager *m, bool lock);
int session_send_create_reply(Session *s, sd_bus_error *error);
int bus_session_method_activate(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_session_method_lock(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_session_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_session_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error);
| 896 | 36.375 | 95 |
h
|
null |
systemd-main/src/login/logind-session-device.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <fcntl.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include "sd-device.h"
#include "sd-daemon.h"
#include "alloc-util.h"
#include "bus-util.h"
#include "daemon-util.h"
#include "fd-util.h"
#include "logind-session-dbus.h"
#include "logind-session-device.h"
#include "missing_drm.h"
#include "missing_input.h"
#include "parse-util.h"
enum SessionDeviceNotifications {
SESSION_DEVICE_RESUME,
SESSION_DEVICE_TRY_PAUSE,
SESSION_DEVICE_PAUSE,
SESSION_DEVICE_RELEASE,
};
static int session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
_cleanup_free_ char *path = NULL;
const char *t = NULL;
uint32_t major, minor;
int r;
assert(sd);
major = major(sd->dev);
minor = minor(sd->dev);
if (!sd->session->controller)
return 0;
path = session_bus_path(sd->session);
if (!path)
return -ENOMEM;
r = sd_bus_message_new_signal(
sd->session->manager->bus,
&m, path,
"org.freedesktop.login1.Session",
type == SESSION_DEVICE_RESUME ? "ResumeDevice" : "PauseDevice");
if (!m)
return r;
r = sd_bus_message_set_destination(m, sd->session->controller);
if (r < 0)
return r;
switch (type) {
case SESSION_DEVICE_RESUME:
r = sd_bus_message_append(m, "uuh", major, minor, sd->fd);
if (r < 0)
return r;
break;
case SESSION_DEVICE_TRY_PAUSE:
t = "pause";
break;
case SESSION_DEVICE_PAUSE:
t = "force";
break;
case SESSION_DEVICE_RELEASE:
t = "gone";
break;
default:
return -EINVAL;
}
if (t) {
r = sd_bus_message_append(m, "uus", major, minor, t);
if (r < 0)
return r;
}
return sd_bus_send(sd->session->manager->bus, m, NULL);
}
static void sd_eviocrevoke(int fd) {
static bool warned = false;
assert(fd >= 0);
if (ioctl(fd, EVIOCREVOKE, NULL) < 0) {
if (errno == EINVAL && !warned) {
log_warning_errno(errno, "Kernel does not support evdev-revocation: %m");
warned = true;
}
}
}
static int sd_drmsetmaster(int fd) {
assert(fd >= 0);
return RET_NERRNO(ioctl(fd, DRM_IOCTL_SET_MASTER, 0));
}
static int sd_drmdropmaster(int fd) {
assert(fd >= 0);
return RET_NERRNO(ioctl(fd, DRM_IOCTL_DROP_MASTER, 0));
}
static int session_device_open(SessionDevice *sd, bool active) {
int fd, r;
assert(sd);
assert(sd->type != DEVICE_TYPE_UNKNOWN);
assert(sd->node);
/* open device and try to get a udev_device from it */
fd = open(sd->node, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
if (fd < 0)
return -errno;
switch (sd->type) {
case DEVICE_TYPE_DRM:
if (active) {
/* Weird legacy DRM semantics might return an error even though we're master. No way to detect
* that so fail at all times and let caller retry in inactive state. */
r = sd_drmsetmaster(fd);
if (r < 0) {
(void) close_nointr(fd);
return r;
}
} else
/* DRM-Master is granted to the first user who opens a device automatically (ughh,
* racy!). Hence, we just drop DRM-Master in case we were the first. */
(void) sd_drmdropmaster(fd);
break;
case DEVICE_TYPE_EVDEV:
if (!active)
sd_eviocrevoke(fd);
break;
case DEVICE_TYPE_UNKNOWN:
default:
/* fallback for devices without synchronizations */
break;
}
return fd;
}
static int session_device_start(SessionDevice *sd) {
int r;
assert(sd);
assert(session_is_active(sd->session));
if (sd->active)
return 0;
switch (sd->type) {
case DEVICE_TYPE_DRM:
if (sd->fd < 0)
return log_error_errno(SYNTHETIC_ERRNO(EBADF),
"Failed to re-activate DRM fd, as the fd was lost (maybe logind restart went wrong?)");
/* Device is kept open. Simply call drmSetMaster() and hope there is no-one else. In case it fails, we
* keep the device paused. Maybe at some point we have a drmStealMaster(). */
r = sd_drmsetmaster(sd->fd);
if (r < 0)
return r;
break;
case DEVICE_TYPE_EVDEV:
/* Evdev devices are revoked while inactive. Reopen it and we are fine. */
r = session_device_open(sd, true);
if (r < 0)
return r;
/* For evdev devices, the file descriptor might be left uninitialized. This might happen while resuming
* into a session and logind has been restarted right before. */
close_and_replace(sd->fd, r);
break;
case DEVICE_TYPE_UNKNOWN:
default:
/* fallback for devices without synchronizations */
break;
}
sd->active = true;
return 0;
}
static void session_device_stop(SessionDevice *sd) {
assert(sd);
if (!sd->active)
return;
switch (sd->type) {
case DEVICE_TYPE_DRM:
if (sd->fd < 0) {
log_error("Failed to de-activate DRM fd, as the fd was lost (maybe logind restart went wrong?)");
return;
}
/* On DRM devices we simply drop DRM-Master but keep it open.
* This allows the user to keep resources allocated. The
* CAP_SYS_ADMIN restriction to DRM-Master prevents users from
* circumventing this. */
sd_drmdropmaster(sd->fd);
break;
case DEVICE_TYPE_EVDEV:
/* Revoke access on evdev file-descriptors during deactivation.
* This will basically prevent any operations on the fd and
* cannot be undone. Good side is: it needs no CAP_SYS_ADMIN
* protection this way. */
sd_eviocrevoke(sd->fd);
break;
case DEVICE_TYPE_UNKNOWN:
default:
/* fallback for devices without synchronization */
break;
}
sd->active = false;
}
static DeviceType detect_device_type(sd_device *dev) {
const char *sysname, *subsystem;
DeviceType type = DEVICE_TYPE_UNKNOWN;
if (sd_device_get_sysname(dev, &sysname) < 0 ||
sd_device_get_subsystem(dev, &subsystem) < 0)
return type;
if (streq(subsystem, "drm")) {
if (startswith(sysname, "card"))
type = DEVICE_TYPE_DRM;
} else if (streq(subsystem, "input")) {
if (startswith(sysname, "event"))
type = DEVICE_TYPE_EVDEV;
}
return type;
}
static int session_device_verify(SessionDevice *sd) {
_cleanup_(sd_device_unrefp) sd_device *p = NULL;
const char *sp, *node;
sd_device *dev;
int r;
r = sd_device_new_from_devnum(&p, 'c', sd->dev);
if (r < 0)
return r;
dev = p;
if (sd_device_get_syspath(dev, &sp) < 0 ||
sd_device_get_devname(dev, &node) < 0)
return -EINVAL;
/* detect device type so we can find the correct sysfs parent */
sd->type = detect_device_type(dev);
if (sd->type == DEVICE_TYPE_UNKNOWN)
return -ENODEV;
else if (sd->type == DEVICE_TYPE_EVDEV) {
/* for evdev devices we need the parent node as device */
if (sd_device_get_parent_with_subsystem_devtype(p, "input", NULL, &dev) < 0)
return -ENODEV;
if (sd_device_get_syspath(dev, &sp) < 0)
return -ENODEV;
} else if (sd->type != DEVICE_TYPE_DRM)
/* Prevent opening unsupported devices. Especially devices of
* subsystem "input" must be opened via the evdev node as
* we require EVIOCREVOKE. */
return -ENODEV;
/* search for an existing seat device and return it if available */
sd->device = hashmap_get(sd->session->manager->devices, sp);
if (!sd->device) {
/* The caller might have gotten the udev event before we were
* able to process it. Hence, fake the "add" event and let the
* logind-manager handle the new device. */
r = manager_process_seat_device(sd->session->manager, dev);
if (r < 0)
return r;
/* if it's still not available, then the device is invalid */
sd->device = hashmap_get(sd->session->manager->devices, sp);
if (!sd->device)
return -ENODEV;
}
if (sd->device->seat != sd->session->seat)
return -EPERM;
sd->node = strdup(node);
if (!sd->node)
return -ENOMEM;
return 0;
}
int session_device_new(Session *s, dev_t dev, bool open_device, SessionDevice **out) {
SessionDevice *sd;
int r;
assert(s);
assert(out);
if (!s->seat)
return -EPERM;
sd = new0(SessionDevice, 1);
if (!sd)
return -ENOMEM;
sd->session = s;
sd->dev = dev;
sd->fd = -EBADF;
sd->type = DEVICE_TYPE_UNKNOWN;
r = session_device_verify(sd);
if (r < 0)
goto error;
r = hashmap_put(s->devices, &sd->dev, sd);
if (r < 0)
goto error;
if (open_device) {
/* Open the device for the first time. We need a valid fd to pass back
* to the caller. If the session is not active, this _might_ immediately
* revoke access and thus invalidate the fd. But this is still needed
* to pass a valid fd back. */
sd->active = session_is_active(s);
r = session_device_open(sd, sd->active);
if (r < 0) {
/* EINVAL _may_ mean a master is active; retry inactive */
if (sd->active && r == -EINVAL) {
sd->active = false;
r = session_device_open(sd, false);
}
if (r < 0)
goto error;
}
sd->fd = r;
}
LIST_PREPEND(sd_by_device, sd->device->session_devices, sd);
*out = sd;
return 0;
error:
hashmap_remove(s->devices, &sd->dev);
free(sd->node);
free(sd);
return r;
}
SessionDevice *session_device_free(SessionDevice *sd) {
if (!sd)
return NULL;
/* Make sure to remove the pushed fd. */
if (sd->pushed_fd)
(void) notify_remove_fd_warnf("session-%s-device-%u-%u", sd->session->id, major(sd->dev), minor(sd->dev));
session_device_stop(sd);
session_device_notify(sd, SESSION_DEVICE_RELEASE);
safe_close(sd->fd);
LIST_REMOVE(sd_by_device, sd->device->session_devices, sd);
hashmap_remove(sd->session->devices, &sd->dev);
free(sd->node);
return mfree(sd);
}
void session_device_complete_pause(SessionDevice *sd) {
SessionDevice *iter;
if (!sd->active)
return;
session_device_stop(sd);
/* if not all devices are paused, wait for further completion events */
HASHMAP_FOREACH(iter, sd->session->devices)
if (iter->active)
return;
/* complete any pending session switch */
seat_complete_switch(sd->session->seat);
}
void session_device_resume_all(Session *s) {
SessionDevice *sd;
assert(s);
HASHMAP_FOREACH(sd, s->devices) {
if (sd->active)
continue;
if (session_device_start(sd) < 0)
continue;
if (session_device_save(sd) < 0)
continue;
session_device_notify(sd, SESSION_DEVICE_RESUME);
}
}
void session_device_pause_all(Session *s) {
SessionDevice *sd;
assert(s);
HASHMAP_FOREACH(sd, s->devices) {
if (!sd->active)
continue;
session_device_stop(sd);
session_device_notify(sd, SESSION_DEVICE_PAUSE);
}
}
unsigned session_device_try_pause_all(Session *s) {
unsigned num_pending = 0;
SessionDevice *sd;
assert(s);
HASHMAP_FOREACH(sd, s->devices) {
if (!sd->active)
continue;
session_device_notify(sd, SESSION_DEVICE_TRY_PAUSE);
num_pending++;
}
return num_pending;
}
int session_device_save(SessionDevice *sd) {
const char *id;
int r;
assert(sd);
/* Store device fd in PID1. It will send it back to us on restart so revocation will continue to work. To make
* things simple, send fds for all type of devices even if they don't support the revocation mechanism so we
* don't have to handle them differently later.
*
* Note: for device supporting revocation, PID1 will drop a stored fd automatically if the corresponding device
* is revoked. */
if (sd->pushed_fd)
return 0;
/* Session ID does not contain separators. */
id = sd->session->id;
assert(*(id + strcspn(id, "-\n")) == '\0');
r = notify_push_fdf(sd->fd, "session-%s-device-%u-%u", id, major(sd->dev), minor(sd->dev));
if (r < 0)
return r;
sd->pushed_fd = true;
return 1;
}
void session_device_attach_fd(SessionDevice *sd, int fd, bool active) {
assert(fd >= 0);
assert(sd);
assert(sd->fd < 0);
assert(!sd->active);
sd->fd = fd;
sd->pushed_fd = true;
sd->active = active;
}
| 15,248 | 29.316103 | 134 |
c
|
null |
systemd-main/src/login/logind-session-device.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef enum DeviceType DeviceType;
typedef struct SessionDevice SessionDevice;
#include "list.h"
#include "logind.h"
enum DeviceType {
DEVICE_TYPE_UNKNOWN,
DEVICE_TYPE_DRM,
DEVICE_TYPE_EVDEV,
};
struct SessionDevice {
Session *session;
Device *device;
dev_t dev;
char *node;
int fd;
DeviceType type:3;
bool active:1;
bool pushed_fd:1;
LIST_FIELDS(struct SessionDevice, sd_by_device);
};
int session_device_new(Session *s, dev_t dev, bool open_device, SessionDevice **out);
SessionDevice *session_device_free(SessionDevice *sd);
DEFINE_TRIVIAL_CLEANUP_FUNC(SessionDevice*, session_device_free);
void session_device_complete_pause(SessionDevice *sd);
void session_device_resume_all(Session *s);
void session_device_pause_all(Session *s);
unsigned session_device_try_pause_all(Session *s);
int session_device_save(SessionDevice *sd);
void session_device_attach_fd(SessionDevice *sd, int fd, bool active);
| 1,071 | 24.52381 | 85 |
h
|
null |
systemd-main/src/login/logind-session.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct Session Session;
typedef enum KillWho KillWho;
#include "list.h"
#include "login-util.h"
#include "logind-user.h"
#include "string-util.h"
typedef enum SessionState {
SESSION_OPENING, /* Session scope is being created */
SESSION_ONLINE, /* Logged in */
SESSION_ACTIVE, /* Logged in and in the fg */
SESSION_CLOSING, /* Logged out, but scope is still there */
_SESSION_STATE_MAX,
_SESSION_STATE_INVALID = -EINVAL,
} SessionState;
typedef enum SessionClass {
SESSION_USER,
SESSION_GREETER,
SESSION_LOCK_SCREEN,
SESSION_BACKGROUND,
_SESSION_CLASS_MAX,
_SESSION_CLASS_INVALID = -EINVAL,
} SessionClass;
typedef enum SessionType {
SESSION_UNSPECIFIED,
SESSION_TTY,
SESSION_X11,
SESSION_WAYLAND,
SESSION_MIR,
SESSION_WEB,
_SESSION_TYPE_MAX,
_SESSION_TYPE_INVALID = -EINVAL,
} SessionType;
#define SESSION_TYPE_IS_GRAPHICAL(type) IN_SET(type, SESSION_X11, SESSION_WAYLAND, SESSION_MIR)
enum KillWho {
KILL_LEADER,
KILL_ALL,
_KILL_WHO_MAX,
_KILL_WHO_INVALID = -EINVAL,
};
typedef enum TTYValidity {
TTY_FROM_PAM,
TTY_FROM_UTMP,
TTY_UTMP_INCONSISTENT, /* may happen on ssh sessions with multiplexed TTYs */
_TTY_VALIDITY_MAX,
_TTY_VALIDITY_INVALID = -EINVAL,
} TTYValidity;
struct Session {
Manager *manager;
const char *id;
unsigned position;
SessionType type;
SessionType original_type;
SessionClass class;
char *state_file;
User *user;
dual_timestamp timestamp;
char *display;
char *tty;
TTYValidity tty_validity;
bool remote;
char *remote_user;
char *remote_host;
char *service;
char *desktop;
char *scope;
char *scope_job;
Seat *seat;
unsigned vtnr;
int vtfd;
pid_t leader;
uint32_t audit_id;
int fifo_fd;
char *fifo_path;
sd_event_source *fifo_event_source;
bool idle_hint;
dual_timestamp idle_hint_timestamp;
bool locked_hint;
bool in_gc_queue:1;
bool started:1;
bool stopping:1;
bool was_active:1;
sd_bus_message *create_message;
/* Set up when a client requested to release the session via the bus */
sd_event_source *timer_event_source;
char *controller;
Hashmap *devices;
sd_bus_track *track;
sd_event_source *stop_on_idle_event_source;
LIST_FIELDS(Session, sessions_by_user);
LIST_FIELDS(Session, sessions_by_seat);
LIST_FIELDS(Session, gc_queue);
};
int session_new(Session **ret, Manager *m, const char *id);
Session* session_free(Session *s);
DEFINE_TRIVIAL_CLEANUP_FUNC(Session *, session_free);
void session_set_user(Session *s, User *u);
int session_set_leader(Session *s, pid_t pid);
bool session_may_gc(Session *s, bool drop_not_started);
void session_add_to_gc_queue(Session *s);
int session_activate(Session *s);
bool session_is_active(Session *s);
int session_get_idle_hint(Session *s, dual_timestamp *t);
int session_set_idle_hint(Session *s, bool b);
int session_get_locked_hint(Session *s);
void session_set_locked_hint(Session *s, bool b);
void session_set_type(Session *s, SessionType t);
int session_set_display(Session *s, const char *display);
int session_set_tty(Session *s, const char *tty);
int session_create_fifo(Session *s);
int session_start(Session *s, sd_bus_message *properties, sd_bus_error *error);
int session_stop(Session *s, bool force);
int session_finalize(Session *s);
int session_release(Session *s);
int session_save(Session *s);
int session_load(Session *s);
int session_kill(Session *s, KillWho who, int signo);
SessionState session_get_state(Session *u);
const char* session_state_to_string(SessionState t) _const_;
SessionState session_state_from_string(const char *s) _pure_;
const char* session_type_to_string(SessionType t) _const_;
SessionType session_type_from_string(const char *s) _pure_;
const char* session_class_to_string(SessionClass t) _const_;
SessionClass session_class_from_string(const char *s) _pure_;
const char *kill_who_to_string(KillWho k) _const_;
KillWho kill_who_from_string(const char *s) _pure_;
const char* tty_validity_to_string(TTYValidity t) _const_;
TTYValidity tty_validity_from_string(const char *s) _pure_;
void session_leave_vt(Session *s);
bool session_is_controller(Session *s, const char *sender);
int session_set_controller(Session *s, const char *sender, bool force, bool prepare);
void session_drop_controller(Session *s);
static inline bool SESSION_IS_SELF(const char *name) {
return isempty(name) || streq(name, "self");
}
static inline bool SESSION_IS_AUTO(const char *name) {
return streq_ptr(name, "auto");
}
| 5,027 | 26.47541 | 95 |
h
|
null |
systemd-main/src/login/logind-user-dbus.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "alloc-util.h"
#include "bus-get-properties.h"
#include "bus-polkit.h"
#include "bus-util.h"
#include "format-util.h"
#include "logind-dbus.h"
#include "logind-session-dbus.h"
#include "logind-user-dbus.h"
#include "logind-user.h"
#include "logind.h"
#include "missing_capability.h"
#include "signal-util.h"
#include "strv.h"
#include "user-util.h"
static int property_get_uid(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
return sd_bus_message_append(reply, "u", (uint32_t) u->user_record->uid);
}
static int property_get_gid(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
return sd_bus_message_append(reply, "u", (uint32_t) u->user_record->gid);
}
static int property_get_name(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
return sd_bus_message_append(reply, "s", u->user_record->user_name);
}
static BUS_DEFINE_PROPERTY_GET2(property_get_state, "s", User, user_get_state, user_state_to_string);
static int property_get_display(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
_cleanup_free_ char *p = NULL;
User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
p = u->display ? session_bus_path(u->display) : strdup("/");
if (!p)
return -ENOMEM;
return sd_bus_message_append(reply, "(so)", u->display ? u->display->id : "", p);
}
static int property_get_sessions(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
r = sd_bus_message_open_container(reply, 'a', "(so)");
if (r < 0)
return r;
LIST_FOREACH(sessions_by_user, session, u->sessions) {
_cleanup_free_ char *p = NULL;
p = session_bus_path(session);
if (!p)
return -ENOMEM;
r = sd_bus_message_append(reply, "(so)", session->id, p);
if (r < 0)
return r;
}
return sd_bus_message_close_container(reply);
}
static int property_get_idle_hint(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
assert(bus);
assert(reply);
return sd_bus_message_append(reply, "b", user_get_idle_hint(u, NULL) > 0);
}
static int property_get_idle_since_hint(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
dual_timestamp t = DUAL_TIMESTAMP_NULL;
uint64_t k;
assert(bus);
assert(reply);
(void) user_get_idle_hint(u, &t);
k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
return sd_bus_message_append(reply, "t", k);
}
static int property_get_linger(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
int r;
assert(bus);
assert(reply);
r = user_check_linger_file(u);
return sd_bus_message_append(reply, "b", r > 0);
}
int bus_user_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
int r;
assert(message);
r = bus_verify_polkit_async(
message,
CAP_KILL,
"org.freedesktop.login1.manage",
NULL,
false,
u->user_record->uid,
&u->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = user_stop(u, /* force = */ true);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
int bus_user_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error) {
User *u = ASSERT_PTR(userdata);
int32_t signo;
int r;
assert(message);
r = bus_verify_polkit_async(
message,
CAP_KILL,
"org.freedesktop.login1.manage",
NULL,
false,
u->user_record->uid,
&u->manager->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = sd_bus_message_read(message, "i", &signo);
if (r < 0)
return r;
if (!SIGNAL_VALID(signo))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
r = user_kill(u, signo);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int user_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
uid_t uid;
User *user;
int r;
assert(bus);
assert(path);
assert(interface);
assert(found);
if (streq(path, "/org/freedesktop/login1/user/self")) {
sd_bus_message *message;
message = sd_bus_get_current_message(bus);
r = manager_get_user_from_creds(m, message, UID_INVALID, error, &user);
if (r == -ENXIO) {
sd_bus_error_free(error);
return 0;
}
if (r < 0)
return r;
} else {
const char *p;
p = startswith(path, "/org/freedesktop/login1/user/_");
if (!p)
return 0;
r = parse_uid(p, &uid);
if (r < 0)
return 0;
user = hashmap_get(m->users, UID_TO_PTR(uid));
if (!user)
return 0;
}
*found = user;
return 1;
}
char *user_bus_path(User *u) {
char *s;
assert(u);
if (asprintf(&s, "/org/freedesktop/login1/user/_"UID_FMT, u->user_record->uid) < 0)
return NULL;
return s;
}
static int user_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
sd_bus_message *message;
Manager *m = userdata;
User *user;
int r;
assert(bus);
assert(path);
assert(nodes);
HASHMAP_FOREACH(user, m->users) {
char *p;
p = user_bus_path(user);
if (!p)
return -ENOMEM;
r = strv_consume(&l, p);
if (r < 0)
return r;
}
message = sd_bus_get_current_message(bus);
if (message) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
if (r >= 0) {
uid_t uid;
r = sd_bus_creds_get_owner_uid(creds, &uid);
if (r >= 0) {
user = hashmap_get(m->users, UID_TO_PTR(uid));
if (user) {
r = strv_extend(&l, "/org/freedesktop/login1/user/self");
if (r < 0)
return r;
}
}
}
}
*nodes = TAKE_PTR(l);
return 1;
}
static const sd_bus_vtable user_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("UID", "u", property_get_uid, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("GID", "u", property_get_gid, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("Name", "s", property_get_name, 0, SD_BUS_VTABLE_PROPERTY_CONST),
BUS_PROPERTY_DUAL_TIMESTAMP("Timestamp", offsetof(User, timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("RuntimePath", "s", NULL, offsetof(User, runtime_path), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("Service", "s", NULL, offsetof(User, service), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("Slice", "s", NULL, offsetof(User, slice), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("Display", "(so)", property_get_display, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, 0),
SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_PROPERTY("Linger", "b", property_get_linger, 0, 0),
SD_BUS_METHOD("Terminate", NULL, NULL, bus_user_method_terminate, SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_METHOD_WITH_ARGS("Kill",
SD_BUS_ARGS("i", signal_number),
SD_BUS_NO_RESULT,
bus_user_method_kill,
SD_BUS_VTABLE_UNPRIVILEGED),
SD_BUS_VTABLE_END
};
const BusObjectImplementation user_object = {
"/org/freedesktop/login1/user",
"org.freedesktop.login1.User",
.fallback_vtables = BUS_FALLBACK_VTABLES({user_vtable, user_object_find}),
.node_enumerator = user_node_enumerator,
};
int user_send_signal(User *u, bool new_user) {
_cleanup_free_ char *p = NULL;
assert(u);
p = user_bus_path(u);
if (!p)
return -ENOMEM;
return sd_bus_emit_signal(
u->manager->bus,
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
new_user ? "UserNew" : "UserRemoved",
"uo", (uint32_t) u->user_record->uid, p);
}
int user_send_changed(User *u, const char *properties, ...) {
_cleanup_free_ char *p = NULL;
char **l;
assert(u);
if (!u->started)
return 0;
p = user_bus_path(u);
if (!p)
return -ENOMEM;
l = strv_from_stdarg_alloca(properties);
return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
}
| 12,816 | 29.372038 | 134 |
c
|
null |
systemd-main/src/login/logind-user.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct User User;
#include "conf-parser.h"
#include "list.h"
#include "logind.h"
#include "user-record.h"
typedef enum UserState {
USER_OFFLINE, /* Not logged in at all */
USER_OPENING, /* Is logging in */
USER_LINGERING, /* Lingering has been enabled by the admin for this user */
USER_ONLINE, /* User logged in */
USER_ACTIVE, /* User logged in and has a session in the fg */
USER_CLOSING, /* User logged out, but processes still remain and lingering is not enabled */
_USER_STATE_MAX,
_USER_STATE_INVALID = -EINVAL,
} UserState;
struct User {
Manager *manager;
UserRecord *user_record;
char *state_file;
char *runtime_path;
char *slice; /* user-UID.slice */
char *service; /* [email protected] */
char *runtime_dir_service; /* [email protected] */
char *service_job;
Session *display;
dual_timestamp timestamp; /* When this User object was 'started' the first time */
usec_t last_session_timestamp; /* When the number of sessions of this user went from 1 to 0 the last time */
/* Set up when the last session of the user logs out */
sd_event_source *timer_event_source;
bool in_gc_queue:1;
bool started:1; /* Whenever the user being started, has been started or is being stopped again. */
bool stopping:1; /* Whenever the user is being stopped or has been stopped. */
LIST_HEAD(Session, sessions);
LIST_FIELDS(User, gc_queue);
};
int user_new(User **out, Manager *m, UserRecord *ur);
User *user_free(User *u);
DEFINE_TRIVIAL_CLEANUP_FUNC(User *, user_free);
bool user_may_gc(User *u, bool drop_not_started);
void user_add_to_gc_queue(User *u);
int user_start(User *u);
int user_stop(User *u, bool force);
int user_finalize(User *u);
UserState user_get_state(User *u);
int user_get_idle_hint(User *u, dual_timestamp *t);
int user_save(User *u);
int user_load(User *u);
int user_kill(User *u, int signo);
int user_check_linger_file(User *u);
void user_elect_display(User *u);
void user_update_last_session_timer(User *u);
const char* user_state_to_string(UserState s) _const_;
UserState user_state_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_compat_user_tasks_max);
| 2,480 | 31.644737 | 116 |
h
|
null |
systemd-main/src/login/logind-utmp.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <unistd.h>
#include "sd-messages.h"
#include "alloc-util.h"
#include "audit-util.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "bus-util.h"
#include "event-util.h"
#include "format-util.h"
#include "logind.h"
#include "path-util.h"
#include "special.h"
#include "strv.h"
#include "unit-name.h"
#include "user-util.h"
#include "utmp-wtmp.h"
_const_ static usec_t when_wall(usec_t n, usec_t elapse) {
static const int wall_timers[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
25, 40, 55, 70, 100, 130, 150, 180,
};
/* If the time is already passed, then don't announce */
if (n >= elapse)
return 0;
usec_t left = elapse - n;
for (unsigned i = 1; i < ELEMENTSOF(wall_timers); i++)
if (wall_timers[i] * USEC_PER_MINUTE >= left)
return left - wall_timers[i-1] * USEC_PER_MINUTE;
return left % USEC_PER_HOUR;
}
bool logind_wall_tty_filter(const char *tty, bool is_local, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
assert(m->scheduled_shutdown_action);
const char *p = path_startswith(tty, "/dev/");
if (!p)
return true;
/* Do not send information about events which do not destroy local sessions to local terminals. We
* can assume that if the system enters sleep or hibernation, this will be visible in an obvious way
* for any local user. And once the systems exits sleep or hibernation, the notification would be
* just noise, in particular for auto-suspend. */
if (is_local &&
IN_SET(m->scheduled_shutdown_action->handle,
HANDLE_SUSPEND,
HANDLE_HIBERNATE,
HANDLE_HYBRID_SLEEP,
HANDLE_SUSPEND_THEN_HIBERNATE))
return false;
return !streq_ptr(p, m->scheduled_shutdown_tty);
}
static int warn_wall(Manager *m, usec_t n) {
assert(m);
if (!m->scheduled_shutdown_action)
return 0;
bool left = m->scheduled_shutdown_timeout > n;
_cleanup_free_ char *l = NULL;
if (asprintf(&l, "%s%sThe system will %s %s%s!",
strempty(m->wall_message),
isempty(m->wall_message) ? "" : "\n",
handle_action_verb_to_string(m->scheduled_shutdown_action->handle),
left ? "at " : "now",
left ? FORMAT_TIMESTAMP(m->scheduled_shutdown_timeout) : "") < 0) {
log_oom();
return 1; /* We're out-of-memory for now, but let's try to print the message later */
}
_cleanup_free_ char *username = uid_to_name(m->scheduled_shutdown_uid);
int level = left ? LOG_INFO : LOG_NOTICE;
log_struct(level,
LOG_MESSAGE("%s", l),
"ACTION=%s", handle_action_to_string(m->scheduled_shutdown_action->handle),
"MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_SCHEDULED_STR,
username ? "OPERATOR=%s" : NULL, username);
if (m->enable_wall_messages)
utmp_wall(l, username, m->scheduled_shutdown_tty, logind_wall_tty_filter, m);
return 1;
}
static int wall_message_timeout_handler(
sd_event_source *s,
uint64_t usec,
void *userdata) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(s == m->wall_message_timeout_source);
usec_t n = now(CLOCK_REALTIME);
r = warn_wall(m, n);
if (r == 0)
return 0;
usec_t next = when_wall(n, m->scheduled_shutdown_timeout);
if (next > 0) {
r = sd_event_source_set_time(s, n + next);
if (r < 0)
return log_error_errno(r, "sd_event_source_set_time() failed. %m");
r = sd_event_source_set_enabled(s, SD_EVENT_ONESHOT);
if (r < 0)
return log_error_errno(r, "sd_event_source_set_enabled() failed. %m");
}
return 0;
}
int manager_setup_wall_message_timer(Manager *m) {
int r;
assert(m);
usec_t n = now(CLOCK_REALTIME);
usec_t elapse = m->scheduled_shutdown_timeout;
/* wall message handling */
if (!m->scheduled_shutdown_action)
return 0;
if (elapse > 0 && elapse < n)
return 0;
/* Warn immediately if less than 15 minutes are left */
if (elapse == 0 || elapse - n < 15 * USEC_PER_MINUTE) {
r = warn_wall(m, n);
if (r == 0)
return 0;
}
elapse = when_wall(n, elapse);
if (elapse == 0)
return 0;
r = event_reset_time(m->event, &m->wall_message_timeout_source,
CLOCK_REALTIME,
n + elapse, 0,
wall_message_timeout_handler, m,
0, "wall-message-timer", true);
if (r < 0) {
m->wall_message_timeout_source = sd_event_source_unref(m->wall_message_timeout_source);
return log_error_errno(r, "Failed to set up wall message timer: %m");
}
return 0;
}
| 5,472 | 30.819767 | 108 |
c
|
null |
systemd-main/src/login/logind.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include <sys/stat.h>
#include "sd-bus.h"
#include "sd-device.h"
#include "sd-event.h"
#include "conf-parser.h"
#include "hashmap.h"
#include "list.h"
#include "set.h"
#include "time-util.h"
#include "user-record.h"
typedef struct Manager Manager;
#include "logind-action.h"
#include "logind-button.h"
#include "logind-device.h"
#include "logind-inhibit.h"
struct Manager {
sd_event *event;
sd_bus *bus;
Hashmap *devices;
Hashmap *seats;
Hashmap *sessions;
Hashmap *sessions_by_leader;
Hashmap *users; /* indexed by UID */
Hashmap *inhibitors;
Hashmap *buttons;
Hashmap *brightness_writers;
LIST_HEAD(Seat, seat_gc_queue);
LIST_HEAD(Session, session_gc_queue);
LIST_HEAD(User, user_gc_queue);
sd_device_monitor *device_seat_monitor, *device_monitor, *device_vcsa_monitor, *device_button_monitor;
sd_event_source *console_active_event_source;
#if ENABLE_UTMP
sd_event_source *utmp_event_source;
#endif
int console_active_fd;
unsigned n_autovts;
unsigned reserve_vt;
int reserve_vt_fd;
Seat *seat0;
char **kill_only_users, **kill_exclude_users;
bool kill_user_processes;
uint64_t session_counter;
uint64_t inhibit_counter;
Hashmap *session_units;
Hashmap *user_units;
usec_t inhibit_delay_max;
usec_t user_stop_delay;
/* If a shutdown/suspend was delayed due to an inhibitor this contains the action we are supposed to
* start after the delay is over */
const HandleActionData *delayed_action;
/* If a shutdown/suspend is currently executed, then this is the job of it */
char *action_job;
sd_event_source *inhibit_timeout_source;
const HandleActionData *scheduled_shutdown_action;
usec_t scheduled_shutdown_timeout;
sd_event_source *scheduled_shutdown_timeout_source;
uid_t scheduled_shutdown_uid;
char *scheduled_shutdown_tty;
sd_event_source *nologin_timeout_source;
bool unlink_nologin;
char *wall_message;
bool enable_wall_messages;
sd_event_source *wall_message_timeout_source;
bool shutdown_dry_run;
sd_event_source *idle_action_event_source;
usec_t idle_action_usec;
usec_t idle_action_not_before_usec;
HandleAction idle_action;
bool was_idle;
usec_t stop_idle_session_usec;
HandleAction handle_power_key;
HandleAction handle_power_key_long_press;
HandleAction handle_reboot_key;
HandleAction handle_reboot_key_long_press;
HandleAction handle_suspend_key;
HandleAction handle_suspend_key_long_press;
HandleAction handle_hibernate_key;
HandleAction handle_hibernate_key_long_press;
HandleAction handle_lid_switch;
HandleAction handle_lid_switch_ep;
HandleAction handle_lid_switch_docked;
bool power_key_ignore_inhibited;
bool suspend_key_ignore_inhibited;
bool hibernate_key_ignore_inhibited;
bool lid_switch_ignore_inhibited;
bool reboot_key_ignore_inhibited;
bool remove_ipc;
Hashmap *polkit_registry;
usec_t holdoff_timeout_usec;
sd_event_source *lid_switch_ignore_event_source;
sd_event_source *power_key_long_press_event_source;
sd_event_source *reboot_key_long_press_event_source;
sd_event_source *suspend_key_long_press_event_source;
sd_event_source *hibernate_key_long_press_event_source;
uint64_t runtime_dir_size;
uint64_t runtime_dir_inodes;
uint64_t sessions_max;
uint64_t inhibitors_max;
char **efi_boot_loader_entries;
bool efi_boot_loader_entries_set;
char *efi_loader_entry_one_shot;
struct stat efi_loader_entry_one_shot_stat;
};
void manager_reset_config(Manager *m);
int manager_parse_config_file(Manager *m);
int manager_add_device(Manager *m, const char *sysfs, bool master, Device **ret_device);
int manager_add_button(Manager *m, const char *name, Button **ret_button);
int manager_add_seat(Manager *m, const char *id, Seat **ret_seat);
int manager_add_session(Manager *m, const char *id, Session **ret_session);
int manager_add_user(Manager *m, UserRecord *ur, User **ret_user);
int manager_add_user_by_name(Manager *m, const char *name, User **ret_user);
int manager_add_user_by_uid(Manager *m, uid_t uid, User **ret_user);
int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **ret_inhibitor);
int manager_process_seat_device(Manager *m, sd_device *d);
int manager_process_button_device(Manager *m, sd_device *d);
int manager_spawn_autovt(Manager *m, unsigned vtnr);
bool manager_shall_kill(Manager *m, const char *user);
int manager_get_idle_hint(Manager *m, dual_timestamp *t);
int manager_get_user_by_pid(Manager *m, pid_t pid, User **user);
int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session);
bool manager_is_lid_closed(Manager *m);
bool manager_is_docked_or_external_displays(Manager *m);
bool manager_is_on_external_power(void);
bool manager_all_buttons_ignored(Manager *m);
int manager_read_utmp(Manager *m);
void manager_connect_utmp(Manager *m);
void manager_reconnect_utmp(Manager *m);
/* gperf lookup function */
const struct ConfigPerfItem* logind_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
int manager_set_lid_switch_ignore(Manager *m, usec_t until);
CONFIG_PARSER_PROTOTYPE(config_parse_n_autovts);
CONFIG_PARSER_PROTOTYPE(config_parse_tmpfs_size);
int manager_setup_wall_message_timer(Manager *m);
bool logind_wall_tty_filter(const char *tty, bool is_local, void *userdata);
int manager_read_efi_boot_loader_entries(Manager *m);
| 5,926 | 30.359788 | 110 |
h
|
null |
systemd-main/src/login/test-inhibit.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <unistd.h>
#include <fcntl.h>
#include "sd-bus.h"
#include "bus-locator.h"
#include "bus-util.h"
#include "fd-util.h"
#include "macro.h"
static int inhibit(sd_bus *bus, const char *what) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
const char *who = "Test Tool", *reason = "Just because!", *mode = "block";
int fd;
int r;
r = bus_call_method(bus, bus_login_mgr, "Inhibit", &error, &reply, "ssss", what, who, reason, mode);
assert_se(r >= 0);
r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_UNIX_FD, &fd);
assert_se(r >= 0);
assert_se(fd >= 0);
return fcntl(fd, F_DUPFD_CLOEXEC, 3);
}
static void print_inhibitors(sd_bus *bus) {
_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
const char *what, *who, *why, *mode;
uint32_t uid, pid;
unsigned n = 0;
int r;
r = bus_call_method(bus, bus_login_mgr, "ListInhibitors", &error, &reply, NULL);
assert_se(r >= 0);
r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
assert_se(r >= 0);
while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
printf("what=<%s> who=<%s> why=<%s> mode=<%s> uid=<%"PRIu32"> pid=<%"PRIu32">\n",
what, who, why, mode, uid, pid);
n++;
}
assert_se(r >= 0);
printf("%u inhibitors\n", n);
}
int main(int argc, char *argv[]) {
_cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
int fd1, fd2;
int r;
r = sd_bus_open_system(&bus);
assert_se(r >= 0);
print_inhibitors(bus);
fd1 = inhibit(bus, "sleep");
assert_se(fd1 >= 0);
print_inhibitors(bus);
fd2 = inhibit(bus, "idle:shutdown");
assert_se(fd2 >= 0);
print_inhibitors(bus);
safe_close(fd1);
sleep(1);
print_inhibitors(bus);
safe_close(fd2);
sleep(1);
print_inhibitors(bus);
return 0;
}
| 2,317 | 26.927711 | 108 |
c
|
null |
systemd-main/src/login/test-login-tables.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "logind-action.h"
#include "logind-session.h"
#include "test-tables.h"
int main(int argc, char **argv) {
test_table(handle_action, HANDLE_ACTION);
test_table(inhibit_mode, INHIBIT_MODE);
test_table(kill_who, KILL_WHO);
test_table(session_class, SESSION_CLASS);
test_table(session_state, SESSION_STATE);
test_table(session_type, SESSION_TYPE);
test_table(user_state, USER_STATE);
return EXIT_SUCCESS;
}
| 527 | 28.333333 | 49 |
c
|
null |
systemd-main/src/login/test-session-properties.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/* Usage:
* ./test-session-properties <SESSION-OBJECT-PATH> [<TTY>]
* e.g.,
* ./test-session-properties /org/freedesktop/login1/session/_32 /dev/tty2
*/
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-locator.h"
#include "path-util.h"
#include "string-util.h"
#include "terminal-util.h"
#include "tests.h"
static const char *arg_tty = NULL;
static BusLocator session;
/* Tests org.freedesktop.logind.Session SetType */
TEST(set_type) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus* bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
const char* types[] = {"tty", "x11", "wayland", "mir", "web"};
_cleanup_free_ char *type = NULL, *type2 = NULL;
assert_se(sd_bus_open_system(&bus) >= 0);
/* Default type is set */
assert_se(bus_get_property_string(bus, &session, "Type", NULL, &type) >= 0);
assert_se(streq(type, "tty"));
/* Type can only be set by the session controller (which we're not ATM) */
assert_se(bus_call_method(bus, &session, "SetType", &error, NULL, "s", "x11") < 0);
assert_se(sd_bus_error_has_name(&error, BUS_ERROR_NOT_IN_CONTROL));
assert_se(bus_call_method(bus, &session, "TakeControl", NULL, NULL, "b", true) >= 0);
/* All defined session types can be set */
for (size_t i = 0; i < ELEMENTSOF(types); i++) {
type = mfree(type);
assert_se(bus_call_method(bus, &session, "SetType", NULL, NULL, "s", types[i]) >= 0);
assert_se(bus_get_property_string(bus, &session, "Type", NULL, &type) >= 0);
assert_se(streq(type, types[i]));
}
/* An unknown type is rejected */
sd_bus_error_free(&error);
assert_se(bus_call_method(bus, &session, "SetType", &error, NULL, "s", "hello") < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_INVALID_ARGS));
assert_se(bus_get_property_string(bus, &session, "Type", NULL, &type2) >= 0);
/* Type is reset to the original value when we release control of the session */
assert_se(!streq(type, "tty"));
assert_se(bus_call_method(bus, &session, "ReleaseControl", NULL, NULL, NULL) >= 0);
type = mfree(type);
assert_se(bus_get_property_string(bus, &session, "Type", NULL, &type) >= 0);
assert_se(streq(type, "tty"));
}
/* Tests org.freedesktop.logind.Session SetDisplay */
TEST(set_display) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus* bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *display = NULL;
assert_se(sd_bus_open_system(&bus) >= 0);
/* Display is unset by default */
assert_se(bus_get_property_string(bus, &session, "Display", NULL, &display) >= 0);
assert_se(isempty(display));
/* Display can only be set by the session controller (which we're not ATM) */
assert_se(bus_call_method(bus, &session, "SetDisplay", &error, NULL, "s", ":0") < 0);
assert_se(sd_bus_error_has_name(&error, BUS_ERROR_NOT_IN_CONTROL));
assert_se(bus_call_method(bus, &session, "TakeControl", NULL, NULL, "b", true) >= 0);
/* Display can only be set on a graphical session */
assert_se(bus_call_method(bus, &session, "SetType", NULL, NULL, "s", "tty") >= 0);
sd_bus_error_free(&error);
assert_se(bus_call_method(bus, &session, "SetDisplay", &error, NULL, "s", ":0") < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(bus_call_method(bus, &session, "SetType", NULL, NULL, "s", "x11") >= 0);
/* Non-empty display can be set */
assert_se(bus_call_method(bus, &session, "SetDisplay", NULL, NULL, "s", ":0") >= 0);
display = mfree(display);
assert_se(bus_get_property_string(bus, &session, "Display", NULL, &display) >= 0);
assert_se(streq(display, ":0"));
/* Empty display can be set too */
assert_se(bus_call_method(bus, &session, "SetDisplay", NULL, NULL, "s", "") >= 0);
display = mfree(display);
assert_se(bus_get_property_string(bus, &session, "Display", NULL, &display) >= 0);
assert_se(isempty(display));
}
/* Tests org.freedesktop.logind.Session SetTTY */
TEST(set_tty) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus* bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *tty = NULL;
int fd;
if (!arg_tty)
return;
fd = open(arg_tty, O_RDWR|O_CLOEXEC|O_NOCTTY);
assert_se(fd >= 0);
assert_se(sd_bus_open_system(&bus) >= 0);
/* tty can only be set by the session controller (which we're not ATM) */
assert_se(bus_call_method(bus, &session, "SetTTY", &error, NULL, "h", fd) < 0);
assert_se(sd_bus_error_has_name(&error, BUS_ERROR_NOT_IN_CONTROL));
assert_se(bus_call_method(bus, &session, "TakeControl", NULL, NULL, "b", true) >= 0);
/* tty can be set */
assert_se(bus_call_method(bus, &session, "SetTTY", NULL, NULL, "h", fd) >= 0);
tty = mfree(tty);
assert_se(bus_get_property_string(bus, &session, "TTY", NULL, &tty) >= 0);
assert_se(streq(tty, "tty2"));
}
/* Tests org.freedesktop.logind.Session SetIdleHint */
TEST(set_idle_hint) {
_cleanup_(sd_bus_flush_close_unrefp) sd_bus* bus = NULL;
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
int idle_hint;
time_t stamp, idle_since1, idle_since2;
assert_se(sd_bus_open_system(&bus) >= 0);
/* Idle hint is not set by default */
assert_se(bus_get_property_trivial(bus, &session, "IdleHint", NULL, 'b', &idle_hint) >= 0);
assert_se(!idle_hint);
assert_se(bus_call_method(bus, &session, "TakeControl", NULL, NULL, "b", true) >= 0);
/* Idle hint can only be set on a graphical session */
assert_se(bus_call_method(bus, &session, "SetType", NULL, NULL, "s", "tty") >= 0);
assert_se(bus_call_method(bus, &session, "SetIdleHint", &error, NULL, "b", true) < 0);
assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
assert_se(bus_call_method(bus, &session, "SetType", NULL, NULL, "s", "x11") >= 0);
stamp = now(CLOCK_MONOTONIC);
/* Idle hint can be set */
assert_se(bus_call_method(bus, &session, "SetIdleHint", NULL, NULL, "b", true) >= 0);
assert_se(bus_get_property_trivial(bus, &session, "IdleHint", NULL, 'b', &idle_hint) >= 0);
assert_se(idle_hint);
assert_se(bus_get_property_trivial(bus, &session, "IdleSinceHintMonotonic", NULL, 't', &idle_since1) >= 0);
assert_se(idle_since1 >= stamp);
/* Repeated setting doesn't change anything */
assert_se(bus_call_method(bus, &session, "SetIdleHint", NULL, NULL, "b", true) >= 0);
assert_se(bus_get_property_trivial(bus, &session, "IdleHint", NULL, 'b', &idle_hint) >= 0);
assert_se(idle_hint);
assert_se(bus_get_property_trivial(bus, &session, "IdleSinceHintMonotonic", NULL, 't', &idle_since2) >= 0);
assert_se(idle_since2 == idle_since1);
/* Idle hint can be unset */
assert_se(bus_call_method(bus, &session, "SetIdleHint", NULL, NULL, "b", false) >= 0);
assert_se(bus_get_property_trivial(bus, &session, "IdleHint", NULL, 'b', &idle_hint) >= 0);
assert_se(!idle_hint);
}
static int intro(void) {
if (saved_argc <= 1)
return EXIT_FAILURE;
session = (BusLocator) {
.destination = "org.freedesktop.login1",
.path = saved_argv[1],
.interface = "org.freedesktop.login1.Session",
};
if (saved_argc > 2)
arg_tty = saved_argv[2];
return EXIT_SUCCESS;
}
DEFINE_TEST_MAIN_WITH_INTRO(LOG_DEBUG, intro);
| 8,108 | 40.798969 | 115 |
c
|
null |
systemd-main/src/machine/image-dbus.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "bus-object.h"
#include "machined.h"
extern const BusObjectImplementation image_object;
char *image_bus_path(const char *name);
int bus_image_method_remove(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_rename(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_clone(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_mark_read_only(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_set_limit(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_get_hostname(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_get_machine_id(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_get_machine_info(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_image_method_get_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error);
| 1,064 | 52.25 | 100 |
h
|
null |
systemd-main/src/machine/machine-dbus.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-bus.h"
#include "bus-util.h"
#include "machine.h"
typedef enum {
MACHINE_COPY_REPLACE = 1 << 0, /* Public API via DBUS, do not change */
_MACHINE_COPY_FLAGS_MASK_PUBLIC = MACHINE_COPY_REPLACE,
} MachineCopyFlags;
extern const BusObjectImplementation machine_object;
char *machine_bus_path(Machine *s);
int bus_machine_method_unregister(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_terminate(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_kill(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_get_addresses(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_get_os_release(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_open_pty(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_open_login(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_open_shell(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_bind_mount(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_copy(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_open_root_directory(sd_bus_message *message, void *userdata, sd_bus_error *error);
int bus_machine_method_get_uid_shift(sd_bus_message *message, void *userdata, sd_bus_error *error);
int machine_send_signal(Machine *m, bool new_machine);
int machine_send_create_reply(Machine *m, sd_bus_error *error);
| 1,687 | 50.151515 | 105 |
h
|
null |
systemd-main/src/machine/machine.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
typedef struct Machine Machine;
typedef enum KillWho KillWho;
#include "list.h"
#include "machined.h"
#include "operation.h"
#include "time-util.h"
typedef enum MachineState {
MACHINE_OPENING, /* Machine is being registered */
MACHINE_RUNNING, /* Machine is running */
MACHINE_CLOSING, /* Machine is terminating */
_MACHINE_STATE_MAX,
_MACHINE_STATE_INVALID = -EINVAL,
} MachineState;
typedef enum MachineClass {
MACHINE_CONTAINER,
MACHINE_VM,
MACHINE_HOST,
_MACHINE_CLASS_MAX,
_MACHINE_CLASS_INVALID = -EINVAL,
} MachineClass;
enum KillWho {
KILL_LEADER,
KILL_ALL,
_KILL_WHO_MAX,
_KILL_WHO_INVALID = -EINVAL,
};
struct Machine {
Manager *manager;
char *name;
sd_id128_t id;
MachineClass class;
char *state_file;
char *service;
char *root_directory;
char *unit;
char *scope_job;
pid_t leader;
dual_timestamp timestamp;
bool in_gc_queue:1;
bool started:1;
bool stopping:1;
bool referenced:1;
sd_bus_message *create_message;
int *netif;
size_t n_netif;
LIST_HEAD(Operation, operations);
LIST_FIELDS(Machine, gc_queue);
};
int machine_new(Manager *manager, MachineClass class, const char *name, Machine **ret);
Machine* machine_free(Machine *m);
bool machine_may_gc(Machine *m, bool drop_not_started);
void machine_add_to_gc_queue(Machine *m);
int machine_start(Machine *m, sd_bus_message *properties, sd_bus_error *error);
int machine_stop(Machine *m);
int machine_finalize(Machine *m);
int machine_save(Machine *m);
int machine_load(Machine *m);
int machine_kill(Machine *m, KillWho who, int signo);
void machine_release_unit(Machine *m);
MachineState machine_get_state(Machine *u);
const char* machine_class_to_string(MachineClass t) _const_;
MachineClass machine_class_from_string(const char *s) _pure_;
const char* machine_state_to_string(MachineState t) _const_;
MachineState machine_state_from_string(const char *s) _pure_;
const char *kill_who_to_string(KillWho k) _const_;
KillWho kill_who_from_string(const char *s) _pure_;
int machine_openpt(Machine *m, int flags, char **ret_slave);
int machine_open_terminal(Machine *m, const char *path, int mode);
int machine_get_uid_shift(Machine *m, uid_t *ret);
int machine_owns_uid(Machine *m, uid_t host_uid, uid_t *ret_internal_uid);
int machine_owns_gid(Machine *m, gid_t host_gid, gid_t *ret_internal_gid);
int machine_translate_uid(Machine *m, uid_t internal_uid, uid_t *ret_host_uid);
int machine_translate_gid(Machine *m, gid_t internal_gid, gid_t *ret_host_gid);
| 2,790 | 26.097087 | 87 |
h
|
null |
systemd-main/src/machine/machined-core.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "machined.h"
#include "nscd-flush.h"
#include "strv.h"
#include "user-util.h"
#if ENABLE_NSCD
static int on_nscd_cache_flush_event(sd_event_source *s, void *userdata) {
/* Let's ask glibc's nscd daemon to flush its caches. We request this for the three database machines may show
* up in: the hosts database (for resolvable machine names) and the user and group databases (for the user ns
* ranges). */
(void) nscd_flush_cache(STRV_MAKE("passwd", "group", "hosts"));
return 0;
}
int manager_enqueue_nscd_cache_flush(Manager *m) {
int r;
assert(m);
if (!m->nscd_cache_flush_event) {
r = sd_event_add_defer(m->event, &m->nscd_cache_flush_event, on_nscd_cache_flush_event, m);
if (r < 0)
return log_error_errno(r, "Failed to allocate NSCD cache flush event: %m");
sd_event_source_set_description(m->nscd_cache_flush_event, "nscd-cache-flush");
}
r = sd_event_source_set_enabled(m->nscd_cache_flush_event, SD_EVENT_ONESHOT);
if (r < 0) {
m->nscd_cache_flush_event = sd_event_source_unref(m->nscd_cache_flush_event);
return log_error_errno(r, "Failed to enable NSCD cache flush event: %m");
}
return 0;
}
#endif
int manager_find_machine_for_uid(Manager *m, uid_t uid, Machine **ret_machine, uid_t *ret_internal_uid) {
Machine *machine;
int r;
assert(m);
assert(uid_is_valid(uid));
/* Finds the machine for the specified host UID and returns it along with the UID translated into the
* internal UID inside the machine */
HASHMAP_FOREACH(machine, m->machines) {
uid_t converted;
r = machine_owns_uid(machine, uid, &converted);
if (r < 0)
return r;
if (r) {
if (ret_machine)
*ret_machine = machine;
if (ret_internal_uid)
*ret_internal_uid = converted;
return true;
}
}
if (ret_machine)
*ret_machine = NULL;
if (ret_internal_uid)
*ret_internal_uid = UID_INVALID;
return false;
}
int manager_find_machine_for_gid(Manager *m, gid_t gid, Machine **ret_machine, gid_t *ret_internal_gid) {
Machine *machine;
int r;
assert(m);
assert(gid_is_valid(gid));
HASHMAP_FOREACH(machine, m->machines) {
gid_t converted;
r = machine_owns_gid(machine, gid, &converted);
if (r < 0)
return r;
if (r) {
if (ret_machine)
*ret_machine = machine;
if (ret_internal_gid)
*ret_internal_gid = converted;
return true;
}
}
if (ret_machine)
*ret_machine = NULL;
if (ret_internal_gid)
*ret_internal_gid = GID_INVALID;
return false;
}
| 3,293 | 29.785047 | 118 |
c
|
null |
systemd-main/src/machine/machined.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "alloc-util.h"
#include "bus-error.h"
#include "bus-locator.h"
#include "bus-log-control-api.h"
#include "bus-polkit.h"
#include "cgroup-util.h"
#include "common-signal.h"
#include "daemon-util.h"
#include "dirent-util.h"
#include "discover-image.h"
#include "fd-util.h"
#include "format-util.h"
#include "hostname-util.h"
#include "machined-varlink.h"
#include "machined.h"
#include "main-func.h"
#include "mkdir-label.h"
#include "process-util.h"
#include "service-util.h"
#include "signal-util.h"
#include "special.h"
static Manager* manager_unref(Manager *m);
DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_unref);
DEFINE_PRIVATE_HASH_OPS_WITH_VALUE_DESTRUCTOR(machine_hash_ops, char, string_hash_func, string_compare_func, Machine, machine_free);
static int manager_new(Manager **ret) {
_cleanup_(manager_unrefp) Manager *m = NULL;
int r;
assert(ret);
m = new0(Manager, 1);
if (!m)
return -ENOMEM;
m->machines = hashmap_new(&machine_hash_ops);
m->machine_units = hashmap_new(&string_hash_ops);
m->machine_leaders = hashmap_new(NULL);
if (!m->machines || !m->machine_units || !m->machine_leaders)
return -ENOMEM;
r = sd_event_default(&m->event);
if (r < 0)
return r;
r = sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
if (r < 0)
return r;
r = sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
if (r < 0)
return r;
r = sd_event_add_signal(m->event, NULL, SIGRTMIN+18, sigrtmin18_handler, NULL);
if (r < 0)
return r;
r = sd_event_add_memory_pressure(m->event, NULL, NULL, NULL);
if (r < 0)
log_full_errno(ERRNO_IS_NOT_SUPPORTED(r) || ERRNO_IS_PRIVILEGE(r) || r == -EHOSTDOWN ? LOG_DEBUG : LOG_NOTICE, r,
"Unable to create memory pressure event source, ignoring: %m");
(void) sd_event_set_watchdog(m->event, true);
*ret = TAKE_PTR(m);
return 0;
}
static Manager* manager_unref(Manager *m) {
if (!m)
return NULL;
while (m->operations)
operation_free(m->operations);
assert(m->n_operations == 0);
hashmap_free(m->machines); /* This will free all machines, so that the machine_units/machine_leaders is empty */
hashmap_free(m->machine_units);
hashmap_free(m->machine_leaders);
hashmap_free(m->image_cache);
sd_event_source_unref(m->image_cache_defer_event);
#if ENABLE_NSCD
sd_event_source_unref(m->nscd_cache_flush_event);
#endif
bus_verify_polkit_async_registry_free(m->polkit_registry);
manager_varlink_done(m);
sd_bus_flush_close_unref(m->bus);
sd_event_unref(m->event);
return mfree(m);
}
static int manager_add_host_machine(Manager *m) {
_cleanup_free_ char *rd = NULL, *unit = NULL;
sd_id128_t mid;
Machine *t;
int r;
if (m->host_machine)
return 0;
r = sd_id128_get_machine(&mid);
if (r < 0)
return log_error_errno(r, "Failed to get machine ID: %m");
rd = strdup("/");
if (!rd)
return log_oom();
unit = strdup(SPECIAL_ROOT_SLICE);
if (!unit)
return log_oom();
r = machine_new(m, MACHINE_HOST, ".host", &t);
if (r < 0)
return log_error_errno(r, "Failed to create machine: %m");
t->leader = 1;
t->id = mid;
t->root_directory = TAKE_PTR(rd);
t->unit = TAKE_PTR(unit);
dual_timestamp_from_boottime(&t->timestamp, 0);
m->host_machine = t;
return 0;
}
static int manager_enumerate_machines(Manager *m) {
_cleanup_closedir_ DIR *d = NULL;
int r;
assert(m);
r = manager_add_host_machine(m);
if (r < 0)
return r;
/* Read in machine data stored on disk */
d = opendir("/run/systemd/machines");
if (!d) {
if (errno == ENOENT)
return 0;
return log_error_errno(errno, "Failed to open /run/systemd/machines: %m");
}
FOREACH_DIRENT(de, d, return -errno) {
struct Machine *machine;
int k;
if (!dirent_is_file(de))
continue;
/* Ignore symlinks that map the unit name to the machine */
if (startswith(de->d_name, "unit:"))
continue;
if (!hostname_is_valid(de->d_name, 0))
continue;
k = manager_add_machine(m, de->d_name, &machine);
if (k < 0) {
r = log_error_errno(k, "Failed to add machine by file name %s: %m", de->d_name);
continue;
}
machine_add_to_gc_queue(machine);
k = machine_load(machine);
if (k < 0)
r = k;
}
return r;
}
static int manager_connect_bus(Manager *m) {
int r;
assert(m);
assert(!m->bus);
r = sd_bus_default_system(&m->bus);
if (r < 0)
return log_error_errno(r, "Failed to connect to system bus: %m");
r = bus_add_implementation(m->bus, &manager_object, m);
if (r < 0)
return r;
r = bus_match_signal_async(m->bus, NULL, bus_systemd_mgr, "JobRemoved", match_job_removed, NULL, m);
if (r < 0)
return log_error_errno(r, "Failed to add match for JobRemoved: %m");
r = bus_match_signal_async(m->bus, NULL, bus_systemd_mgr, "UnitRemoved", match_unit_removed, NULL, m);
if (r < 0)
return log_error_errno(r, "Failed to request match for UnitRemoved: %m");
r = sd_bus_match_signal_async(
m->bus,
NULL,
"org.freedesktop.systemd1",
NULL,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
match_properties_changed, NULL, m);
if (r < 0)
return log_error_errno(r, "Failed to request match for PropertiesChanged: %m");
r = bus_match_signal_async(m->bus, NULL, bus_systemd_mgr, "Reloading", match_reloading, NULL, m);
if (r < 0)
return log_error_errno(r, "Failed to request match for Reloading: %m");
r = bus_call_method_async(m->bus, NULL, bus_systemd_mgr, "Subscribe", NULL, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to enable subscription: %m");
r = bus_log_control_api_register(m->bus);
if (r < 0)
return r;
r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.machine1", 0, NULL, NULL);
if (r < 0)
return log_error_errno(r, "Failed to request name: %m");
r = sd_bus_attach_event(m->bus, m->event, 0);
if (r < 0)
return log_error_errno(r, "Failed to attach bus to event loop: %m");
return 0;
}
static void manager_gc(Manager *m, bool drop_not_started) {
Machine *machine;
assert(m);
while ((machine = m->machine_gc_queue)) {
LIST_REMOVE(gc_queue, m->machine_gc_queue, machine);
machine->in_gc_queue = false;
/* First, if we are not closing yet, initiate stopping */
if (machine_may_gc(machine, drop_not_started) &&
machine_get_state(machine) != MACHINE_CLOSING)
machine_stop(machine);
/* Now, the stop probably made this referenced
* again, but if it didn't, then it's time to let it
* go entirely. */
if (machine_may_gc(machine, drop_not_started)) {
machine_finalize(machine);
machine_free(machine);
}
}
}
static int manager_startup(Manager *m) {
Machine *machine;
int r;
assert(m);
/* Connect to the bus */
r = manager_connect_bus(m);
if (r < 0)
return r;
/* Set up Varlink service */
r = manager_varlink_init(m);
if (r < 0)
return r;
/* Deserialize state */
manager_enumerate_machines(m);
/* Remove stale objects before we start them */
manager_gc(m, false);
/* And start everything */
HASHMAP_FOREACH(machine, m->machines)
machine_start(machine, NULL, NULL);
return 0;
}
static bool check_idle(void *userdata) {
Manager *m = userdata;
if (m->operations)
return false;
if (varlink_server_current_connections(m->varlink_server) > 0)
return false;
manager_gc(m, true);
return hashmap_isempty(m->machines);
}
static int manager_run(Manager *m) {
assert(m);
return bus_event_loop_with_idle(
m->event,
m->bus,
"org.freedesktop.machine1",
DEFAULT_EXIT_USEC,
check_idle, m);
}
static int run(int argc, char *argv[]) {
_cleanup_(manager_unrefp) Manager *m = NULL;
int r;
log_set_facility(LOG_AUTH);
log_setup();
r = service_parse_argv("systemd-machined.service",
"Manage registrations of local VMs and containers.",
BUS_IMPLEMENTATIONS(&manager_object,
&log_control_object),
argc, argv);
if (r <= 0)
return r;
umask(0022);
/* Always create the directories people can create inotify watches in. Note that some applications might check
* for the existence of /run/systemd/machines/ to determine whether machined is available, so please always
* make sure this check stays in. */
(void) mkdir_label("/run/systemd/machines", 0755);
assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, SIGTERM, SIGINT, SIGRTMIN+18, -1) >= 0);
r = manager_new(&m);
if (r < 0)
return log_error_errno(r, "Failed to allocate manager object: %m");
r = manager_startup(m);
if (r < 0)
return log_error_errno(r, "Failed to fully start up daemon: %m");
log_debug("systemd-machined running as pid "PID_FMT, getpid_cached());
r = sd_notify(false, NOTIFY_READY);
if (r < 0)
log_warning_errno(r, "Failed to send readiness notification, ignoring: %m");
r = manager_run(m);
(void) sd_notify(false, NOTIFY_STOPPING);
log_debug("systemd-machined stopped as pid "PID_FMT, getpid_cached());
return r;
}
DEFINE_MAIN_FUNCTION(run);
| 11,360 | 29.296 | 132 |
c
|
null |
systemd-main/src/machine/machined.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "sd-bus.h"
#include "sd-event.h"
typedef struct Manager Manager;
#include "hashmap.h"
#include "image-dbus.h"
#include "list.h"
#include "machine-dbus.h"
#include "machine.h"
#include "operation.h"
#include "varlink.h"
struct Manager {
sd_event *event;
sd_bus *bus;
Hashmap *machines;
Hashmap *machine_units;
Hashmap *machine_leaders;
Hashmap *polkit_registry;
Hashmap *image_cache;
sd_event_source *image_cache_defer_event;
LIST_HEAD(Machine, machine_gc_queue);
Machine *host_machine;
LIST_HEAD(Operation, operations);
unsigned n_operations;
#if ENABLE_NSCD
sd_event_source *nscd_cache_flush_event;
#endif
VarlinkServer *varlink_server;
};
int manager_add_machine(Manager *m, const char *name, Machine **_machine);
int manager_get_machine_by_pid(Manager *m, pid_t pid, Machine **machine);
extern const BusObjectImplementation manager_object;
int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error);
int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error);
int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error);
int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error);
int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job);
int manager_kill_unit(Manager *manager, const char *unit, int signo, sd_bus_error *error);
int manager_unref_unit(Manager *m, const char *unit, sd_bus_error *error);
int manager_unit_is_active(Manager *manager, const char *unit);
int manager_job_is_active(Manager *manager, const char *path);
#if ENABLE_NSCD
int manager_enqueue_nscd_cache_flush(Manager *m);
#else
static inline void manager_enqueue_nscd_cache_flush(Manager *m) {}
#endif
int manager_find_machine_for_uid(Manager *m, uid_t host_uid, Machine **ret_machine, uid_t *ret_internal_uid);
int manager_find_machine_for_gid(Manager *m, gid_t host_gid, Machine **ret_machine, gid_t *ret_internal_gid);
| 2,163 | 29.914286 | 109 |
h
|
null |
systemd-main/src/machine/operation.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <sys/wait.h>
#include <unistd.h>
#include "alloc-util.h"
#include "fd-util.h"
#include "operation.h"
#include "process-util.h"
static int operation_done(sd_event_source *s, const siginfo_t *si, void *userdata) {
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
Operation *o = ASSERT_PTR(userdata);
int r;
assert(si);
log_debug("Operation " PID_FMT " is now complete with code=%s status=%i",
o->pid,
sigchld_code_to_string(si->si_code), si->si_status);
o->pid = 0;
if (si->si_code != CLD_EXITED) {
r = sd_bus_error_set(&error, SD_BUS_ERROR_FAILED, "Child died abnormally.");
goto fail;
}
if (si->si_status == EXIT_SUCCESS)
r = 0;
else if (read(o->errno_fd, &r, sizeof(r)) != sizeof(r)) { /* Try to acquire error code for failed operation */
r = sd_bus_error_set(&error, SD_BUS_ERROR_FAILED, "Child failed.");
goto fail;
}
if (o->done) {
/* A completion routine is set for this operation, call it. */
r = o->done(o, r, &error);
if (r < 0) {
if (!sd_bus_error_is_set(&error))
sd_bus_error_set_errno(&error, r);
goto fail;
}
} else {
/* The default operation when done is to simply return an error on failure or an empty success
* message on success. */
if (r < 0) {
sd_bus_error_set_errno(&error, r);
goto fail;
}
r = sd_bus_reply_method_return(o->message, NULL);
if (r < 0)
log_error_errno(r, "Failed to reply to message: %m");
}
operation_free(o);
return 0;
fail:
r = sd_bus_reply_method_error(o->message, &error);
if (r < 0)
log_error_errno(r, "Failed to reply to message: %m");
operation_free(o);
return 0;
}
int operation_new(Manager *manager, Machine *machine, pid_t child, sd_bus_message *message, int errno_fd, Operation **ret) {
Operation *o;
int r;
assert(manager);
assert(child > 1);
assert(message);
assert(errno_fd >= 0);
o = new0(Operation, 1);
if (!o)
return -ENOMEM;
o->extra_fd = -EBADF;
r = sd_event_add_child(manager->event, &o->event_source, child, WEXITED, operation_done, o);
if (r < 0) {
free(o);
return r;
}
o->pid = child;
o->message = sd_bus_message_ref(message);
o->errno_fd = errno_fd;
LIST_PREPEND(operations, manager->operations, o);
manager->n_operations++;
o->manager = manager;
if (machine) {
LIST_PREPEND(operations_by_machine, machine->operations, o);
o->machine = machine;
}
log_debug("Started new operation " PID_FMT ".", child);
/* At this point we took ownership of both the child and the errno file descriptor! */
if (ret)
*ret = o;
return 0;
}
Operation *operation_free(Operation *o) {
if (!o)
return NULL;
sd_event_source_unref(o->event_source);
safe_close(o->errno_fd);
safe_close(o->extra_fd);
if (o->pid > 1)
(void) sigkill_wait(o->pid);
sd_bus_message_unref(o->message);
if (o->manager) {
LIST_REMOVE(operations, o->manager->operations, o);
o->manager->n_operations--;
}
if (o->machine)
LIST_REMOVE(operations_by_machine, o->machine->operations, o);
return mfree(o);
}
| 3,978 | 27.625899 | 124 |
c
|
null |
systemd-main/src/machine/operation.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <sys/types.h>
#include "sd-bus.h"
#include "sd-event.h"
#include "list.h"
typedef struct Operation Operation;
#include "machined.h"
#define OPERATIONS_MAX 64
struct Operation {
Manager *manager;
Machine *machine;
pid_t pid;
sd_bus_message *message;
int errno_fd;
int extra_fd;
sd_event_source *event_source;
int (*done)(Operation *o, int ret, sd_bus_error *error);
LIST_FIELDS(Operation, operations);
LIST_FIELDS(Operation, operations_by_machine);
};
int operation_new(Manager *manager, Machine *machine, pid_t child, sd_bus_message *message, int errno_fd, Operation **ret);
Operation *operation_free(Operation *o);
| 775 | 23.25 | 123 |
h
|
null |
systemd-main/src/modules-load/modules-load.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include <getopt.h>
#include <limits.h>
#include <sys/stat.h>
#include "build.h"
#include "conf-files.h"
#include "constants.h"
#include "fd-util.h"
#include "fileio.h"
#include "log.h"
#include "main-func.h"
#include "module-util.h"
#include "pretty-print.h"
#include "proc-cmdline.h"
#include "string-util.h"
#include "strv.h"
static char **arg_proc_cmdline_modules = NULL;
static const char conf_file_dirs[] = CONF_PATHS_NULSTR("modules-load.d");
STATIC_DESTRUCTOR_REGISTER(arg_proc_cmdline_modules, strv_freep);
static void systemd_kmod_log(void *data, int priority, const char *file, int line,
const char *fn, const char *format, va_list args) {
DISABLE_WARNING_FORMAT_NONLITERAL;
log_internalv(priority, 0, file, line, fn, format, args);
REENABLE_WARNING;
}
static int add_modules(const char *p) {
_cleanup_strv_free_ char **k = NULL;
k = strv_split(p, ",");
if (!k)
return log_oom();
if (strv_extend_strv(&arg_proc_cmdline_modules, k, true) < 0)
return log_oom();
return 0;
}
static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
int r;
if (proc_cmdline_key_streq(key, "modules_load")) {
if (proc_cmdline_value_missing(key, value))
return 0;
r = add_modules(value);
if (r < 0)
return r;
}
return 0;
}
static int apply_file(struct kmod_ctx *ctx, const char *path, bool ignore_enoent) {
_cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *pp = NULL;
int r;
assert(ctx);
assert(path);
r = search_and_fopen_nulstr(path, "re", NULL, conf_file_dirs, &f, &pp);
if (r < 0) {
if (ignore_enoent && r == -ENOENT)
return 0;
return log_error_errno(r, "Failed to open %s: %m", path);
}
log_debug("apply: %s", pp);
for (;;) {
_cleanup_free_ char *line = NULL;
char *l;
int k;
k = read_line(f, LONG_LINE_MAX, &line);
if (k < 0)
return log_error_errno(k, "Failed to read file '%s': %m", pp);
if (k == 0)
break;
l = strstrip(line);
if (isempty(l))
continue;
if (strchr(COMMENTS, *l))
continue;
k = module_load_and_warn(ctx, l, true);
if (k == -ENOENT)
continue;
if (k < 0 && r >= 0)
r = k;
}
return r;
}
static int help(void) {
_cleanup_free_ char *link = NULL;
int r;
r = terminal_urlify_man("systemd-modules-load.service", "8", &link);
if (r < 0)
return log_oom();
printf("%s [OPTIONS...] [CONFIGURATION FILE...]\n\n"
"Loads statically configured kernel modules.\n\n"
" -h --help Show this help\n"
" --version Show package version\n"
"\nSee the %s for details.\n",
program_invocation_short_name,
link);
return 0;
}
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_VERSION = 0x100,
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{}
};
int c;
assert(argc >= 0);
assert(argv);
while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
switch (c) {
case 'h':
return help();
case ARG_VERSION:
return version();
case '?':
return -EINVAL;
default:
assert_not_reached();
}
return 1;
}
static int run(int argc, char *argv[]) {
_cleanup_(kmod_unrefp) struct kmod_ctx *ctx = NULL;
int r, k;
r = parse_argv(argc, argv);
if (r <= 0)
return r;
log_setup();
umask(0022);
r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
if (r < 0)
log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
ctx = kmod_new(NULL, NULL);
if (!ctx) {
log_error("Failed to allocate memory for kmod.");
return -ENOMEM;
}
kmod_load_resources(ctx);
kmod_set_log_fn(ctx, systemd_kmod_log, NULL);
r = 0;
if (argc > optind) {
for (int i = optind; i < argc; i++) {
k = apply_file(ctx, argv[i], false);
if (k < 0 && r == 0)
r = k;
}
} else {
_cleanup_strv_free_ char **files = NULL;
STRV_FOREACH(i, arg_proc_cmdline_modules) {
k = module_load_and_warn(ctx, *i, true);
if (k == -ENOENT)
continue;
if (k < 0 && r == 0)
r = k;
}
k = conf_files_list_nulstr(&files, ".conf", NULL, 0, conf_file_dirs);
if (k < 0) {
log_error_errno(k, "Failed to enumerate modules-load.d files: %m");
if (r == 0)
r = k;
return r;
}
STRV_FOREACH(fn, files) {
k = apply_file(ctx, *fn, true);
if (k < 0 && r == 0)
r = k;
}
}
return r;
}
DEFINE_MAIN_FUNCTION(run);
| 6,232 | 26.702222 | 92 |
c
|
null |
systemd-main/src/network/fuzz-netdev-parser.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "fd-util.h"
#include "fs-util.h"
#include "fuzz.h"
#include "networkd-manager.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(manager_freep) Manager *manager = NULL;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(unlink_tempfilep) char netdev_config[] = "/tmp/fuzz-networkd.XXXXXX";
if (outside_size_range(size, 0, 65536))
return 0;
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
assert_se(fmkostemp_safe(netdev_config, "r+", &f) == 0);
if (size != 0)
assert_se(fwrite(data, size, 1, f) == 1);
fflush(f);
assert_se(manager_new(&manager, /* test_mode = */ true) >= 0);
(void) netdev_load_one(manager, netdev_config);
return 0;
}
| 894 | 29.862069 | 87 |
c
|
null |
systemd-main/src/network/fuzz-network-parser.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "fd-util.h"
#include "fs-util.h"
#include "fuzz.h"
#include "networkd-manager.h"
#include "tmpfile-util.h"
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(manager_freep) Manager *manager = NULL;
_cleanup_fclose_ FILE *f = NULL;
_cleanup_(unlink_tempfilep) char network_config[] = "/tmp/fuzz-networkd.XXXXXX";
if (outside_size_range(size, 0, 65536))
return 0;
if (!getenv("SYSTEMD_LOG_LEVEL"))
log_set_max_level(LOG_CRIT);
assert_se(fmkostemp_safe(network_config, "r+", &f) == 0);
if (size != 0)
assert_se(fwrite(data, size, 1, f) == 1);
fflush(f);
assert_se(manager_new(&manager, /* test_mode = */ true) >= 0);
(void) network_load_one(manager, &manager->networks, network_config);
return 0;
}
| 918 | 30.689655 | 88 |
c
|
null |
systemd-main/src/network/networkd-address-generation.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
#include "in-addr-util.h"
#include "set.h"
typedef struct Link Link;
int dhcp_pd_generate_addresses(Link *link, const struct in6_addr *prefix, Set **ret);
int ndisc_generate_addresses(Link *link, const struct in6_addr *prefix, uint8_t prefixlen, Set **ret);
int radv_generate_addresses(Link *link, Set *tokens, const struct in6_addr *prefix, uint8_t prefixlen, Set **ret);
CONFIG_PARSER_PROTOTYPE(config_parse_address_generation_type);
| 527 | 34.2 | 114 |
h
|
null |
systemd-main/src/network/networkd-address-label.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <linux/if_addrlabel.h>
#include "alloc-util.h"
#include "netlink-util.h"
#include "networkd-address-label.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "networkd-queue.h"
#include "parse-util.h"
AddressLabel *address_label_free(AddressLabel *label) {
if (!label)
return NULL;
if (label->network) {
assert(label->section);
hashmap_remove(label->network->address_labels_by_section, label->section);
}
config_section_free(label->section);
return mfree(label);
}
DEFINE_SECTION_CLEANUP_FUNCTIONS(AddressLabel, address_label_free);
static int address_label_new_static(Network *network, const char *filename, unsigned section_line, AddressLabel **ret) {
_cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(address_label_freep) AddressLabel *label = NULL;
int r;
assert(network);
assert(ret);
assert(filename);
assert(section_line > 0);
r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
label = hashmap_get(network->address_labels_by_section, n);
if (label) {
*ret = TAKE_PTR(label);
return 0;
}
label = new(AddressLabel, 1);
if (!label)
return -ENOMEM;
*label = (AddressLabel) {
.network = network,
.section = TAKE_PTR(n),
.label = UINT32_MAX,
};
r = hashmap_ensure_put(&network->address_labels_by_section, &config_section_hash_ops, label->section, label);
if (r < 0)
return r;
*ret = TAKE_PTR(label);
return 0;
}
static int address_label_configure_handler(
sd_netlink *rtnl,
sd_netlink_message *m,
Request *req,
Link *link,
void *userdata) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -EEXIST) {
log_link_message_warning_errno(link, m, r, "Could not set address label");
link_enter_failed(link);
return 1;
}
if (link->static_address_label_messages == 0) {
log_link_debug(link, "Addresses label set");
link->static_address_labels_configured = true;
link_check_ready(link);
}
return 1;
}
static int address_label_configure(AddressLabel *label, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(label);
assert(link);
assert(link->ifindex > 0);
assert(link->manager);
assert(link->manager->rtnl);
assert(req);
r = sd_rtnl_message_new_addrlabel(link->manager->rtnl, &m, RTM_NEWADDRLABEL,
link->ifindex, AF_INET6);
if (r < 0)
return r;
r = sd_rtnl_message_addrlabel_set_prefixlen(m, label->prefixlen);
if (r < 0)
return r;
r = sd_netlink_message_append_u32(m, IFAL_LABEL, label->label);
if (r < 0)
return r;
r = sd_netlink_message_append_in6_addr(m, IFA_ADDRESS, &label->prefix);
if (r < 0)
return r;
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static int address_label_process_request(Request *req, Link *link, void *userdata) {
AddressLabel *label = ASSERT_PTR(userdata);
int r;
assert(req);
assert(link);
if (!link_is_ready_to_configure(link, false))
return 0;
r = address_label_configure(label, link, req);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure address label: %m");
return 1;
}
int link_request_static_address_labels(Link *link) {
AddressLabel *label;
int r;
assert(link);
assert(link->network);
link->static_address_labels_configured = false;
HASHMAP_FOREACH(label, link->network->address_labels_by_section) {
r = link_queue_request_full(link, REQUEST_TYPE_ADDRESS_LABEL,
label, NULL, trivial_hash_func, trivial_compare_func,
address_label_process_request,
&link->static_address_label_messages,
address_label_configure_handler, NULL);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to request address label: %m");
}
if (link->static_address_label_messages == 0) {
link->static_address_labels_configured = true;
link_check_ready(link);
} else {
log_link_debug(link, "Setting address labels.");
link_set_state(link, LINK_STATE_CONFIGURING);
}
return 0;
}
static int address_label_section_verify(AddressLabel *label) {
assert(label);
assert(label->section);
if (section_is_invalid(label->section))
return -EINVAL;
if (!label->prefix_set)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: [IPv6AddressLabel] section without Prefix= setting specified. "
"Ignoring [IPv6AddressLabel] section from line %u.",
label->section->filename, label->section->line);
if (label->label == UINT32_MAX)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: [IPv6AddressLabel] section without Label= setting specified. "
"Ignoring [IPv6AddressLabel] section from line %u.",
label->section->filename, label->section->line);
return 0;
}
void network_drop_invalid_address_labels(Network *network) {
AddressLabel *label;
assert(network);
HASHMAP_FOREACH(label, network->address_labels_by_section)
if (address_label_section_verify(label) < 0)
address_label_free(label);
}
int config_parse_address_label_prefix(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(address_label_free_or_set_invalidp) AddressLabel *n = NULL;
Network *network = userdata;
unsigned char prefixlen;
union in_addr_union a;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = address_label_new_static(network, filename, section_line, &n);
if (r < 0)
return log_oom();
r = in_addr_prefix_from_string(rvalue, AF_INET6, &a, &prefixlen);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Invalid prefix for address label, ignoring assignment: %s", rvalue);
return 0;
}
if (in6_addr_is_ipv4_mapped_address(&a.in6) && prefixlen > 96) {
/* See ip6addrlbl_alloc() in net/ipv6/addrlabel.c of kernel. */
log_syntax(unit, LOG_WARNING, filename, line, 0,
"The prefix length of IPv4 mapped address for address label must be equal to or smaller than 96, "
"ignoring assignment: %s", rvalue);
return 0;
}
n->prefix = a.in6;
n->prefixlen = prefixlen;
n->prefix_set = true;
TAKE_PTR(n);
return 0;
}
int config_parse_address_label(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(address_label_free_or_set_invalidp) AddressLabel *n = NULL;
Network *network = userdata;
uint32_t k;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = address_label_new_static(network, filename, section_line, &n);
if (r < 0)
return log_oom();
r = safe_atou32(rvalue, &k);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse address label, ignoring: %s", rvalue);
return 0;
}
if (k == UINT_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0, "Address label is invalid, ignoring: %s", rvalue);
return 0;
}
n->label = k;
TAKE_PTR(n);
return 0;
}
| 9,517 | 30.832776 | 125 |
c
|
null |
systemd-main/src/network/networkd-address-label.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include "conf-parser.h"
#include "in-addr-util.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Network Network;
typedef struct AddressLabel {
Network *network;
ConfigSection *section;
uint32_t label;
struct in6_addr prefix;
unsigned char prefixlen;
bool prefix_set;
} AddressLabel;
AddressLabel *address_label_free(AddressLabel *label);
void network_drop_invalid_address_labels(Network *network);
int link_request_static_address_labels(Link *link);
CONFIG_PARSER_PROTOTYPE(config_parse_address_label);
CONFIG_PARSER_PROTOTYPE(config_parse_address_label_prefix);
| 727 | 22.483871 | 59 |
h
|
null |
systemd-main/src/network/networkd-address-pool.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "networkd-address-pool.h"
#include "networkd-address.h"
#include "networkd-manager.h"
#include "set.h"
#include "string-util.h"
#define RANDOM_PREFIX_TRIAL_MAX 1024
static int address_pool_new(
Manager *m,
int family,
const union in_addr_union *u,
unsigned prefixlen) {
_cleanup_free_ AddressPool *p = NULL;
int r;
assert(m);
assert(u);
p = new(AddressPool, 1);
if (!p)
return -ENOMEM;
*p = (AddressPool) {
.manager = m,
.family = family,
.prefixlen = prefixlen,
.in_addr = *u,
};
r = ordered_set_ensure_put(&m->address_pools, NULL, p);
if (r < 0)
return r;
TAKE_PTR(p);
return 0;
}
static int address_pool_new_from_string(
Manager *m,
int family,
const char *p,
unsigned prefixlen) {
union in_addr_union u;
int r;
assert(m);
assert(p);
r = in_addr_from_string(family, p, &u);
if (r < 0)
return r;
return address_pool_new(m, family, &u, prefixlen);
}
int address_pool_setup_default(Manager *m) {
int r;
assert(m);
/* Add in the well-known private address ranges. */
r = address_pool_new_from_string(m, AF_INET6, "fd00::", 8);
if (r < 0)
return r;
r = address_pool_new_from_string(m, AF_INET, "192.168.0.0", 16);
if (r < 0)
return r;
r = address_pool_new_from_string(m, AF_INET, "172.16.0.0", 12);
if (r < 0)
return r;
r = address_pool_new_from_string(m, AF_INET, "10.0.0.0", 8);
if (r < 0)
return r;
return 0;
}
static bool address_pool_prefix_is_taken(
AddressPool *p,
const union in_addr_union *u,
unsigned prefixlen) {
Link *l;
Network *n;
assert(p);
assert(u);
HASHMAP_FOREACH(l, p->manager->links_by_index) {
Address *a;
/* Don't clash with assigned addresses */
SET_FOREACH(a, l->addresses) {
if (a->family != p->family)
continue;
if (in_addr_prefix_intersect(p->family, u, prefixlen, &a->in_addr, a->prefixlen))
return true;
}
}
/* And don't clash with configured but un-assigned addresses either */
ORDERED_HASHMAP_FOREACH(n, p->manager->networks) {
Address *a;
ORDERED_HASHMAP_FOREACH(a, n->addresses_by_section) {
if (a->family != p->family)
continue;
if (in_addr_prefix_intersect(p->family, u, prefixlen, &a->in_addr, a->prefixlen))
return true;
}
}
return false;
}
static int address_pool_acquire_one(AddressPool *p, int family, unsigned prefixlen, union in_addr_union *found) {
union in_addr_union u;
int r;
assert(p);
assert(prefixlen > 0);
assert(found);
if (p->family != family)
return 0;
if (p->prefixlen >= prefixlen)
return 0;
u = p->in_addr;
for (unsigned i = 0; i < RANDOM_PREFIX_TRIAL_MAX; i++) {
r = in_addr_random_prefix(p->family, &u, p->prefixlen, prefixlen);
if (r <= 0)
return r;
if (!address_pool_prefix_is_taken(p, &u, prefixlen)) {
log_debug("Found range %s", IN_ADDR_PREFIX_TO_STRING(p->family, &u, prefixlen));
*found = u;
return 1;
}
}
return 0;
}
int address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
AddressPool *p;
int r;
assert(m);
assert(IN_SET(family, AF_INET, AF_INET6));
assert(prefixlen > 0);
assert(found);
ORDERED_SET_FOREACH(p, m->address_pools) {
r = address_pool_acquire_one(p, family, prefixlen, found);
if (r != 0)
return r;
}
return 0;
}
| 4,585 | 25.056818 | 113 |
c
|
null |
systemd-main/src/network/networkd-address.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include "sd-ipv4acd.h"
#include "conf-parser.h"
#include "in-addr-util.h"
#include "networkd-link.h"
#include "networkd-util.h"
#include "time-util.h"
typedef struct Address Address;
typedef struct Manager Manager;
typedef struct Network Network;
typedef struct Request Request;
typedef int (*address_ready_callback_t)(Address *address);
typedef int (*address_netlink_handler_t)(
sd_netlink *rtnl,
sd_netlink_message *m,
Request *req,
Link *link,
Address *address);
struct Address {
Link *link;
Network *network;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
union in_addr_union provider; /* DHCP server or router address */
int family;
unsigned char prefixlen;
unsigned char scope;
uint32_t flags;
uint32_t route_metric; /* route metric for prefix route */
char *label, *netlabel;
int set_broadcast;
struct in_addr broadcast;
union in_addr_union in_addr;
union in_addr_union in_addr_peer;
/* These are absolute points in time, and NOT timespans/durations.
* Must be specified with clock_boottime_or_monotonic(). */
usec_t lifetime_valid_usec;
usec_t lifetime_preferred_usec;
bool scope_set:1;
bool ip_masquerade_done:1;
bool requested_as_null:1;
/* duplicate_address_detection is only used by static or IPv4 dynamic addresses.
* To control DAD for IPv6 dynamic addresses, set IFA_F_NODAD to flags. */
AddressFamily duplicate_address_detection;
sd_ipv4acd *acd;
bool acd_bound;
/* Called when address become ready */
address_ready_callback_t callback;
};
const char* format_lifetime(char *buf, size_t l, usec_t lifetime_usec) _warn_unused_result_;
/* 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 FORMAT_LIFETIME(lifetime) \
format_lifetime((char[FORMAT_TIMESPAN_MAX+STRLEN("for ")]){}, FORMAT_TIMESPAN_MAX+STRLEN("for "), lifetime)
int address_flags_to_string_alloc(uint32_t flags, int family, char **ret);
int address_new(Address **ret);
Address* address_free(Address *address);
int address_get(Link *link, const Address *in, Address **ret);
int address_configure_handler_internal(sd_netlink *rtnl, sd_netlink_message *m, Link *link, const char *error_msg);
int address_remove(Address *address);
int address_remove_and_drop(Address *address);
int address_dup(const Address *src, Address **ret);
bool address_is_ready(const Address *a);
bool link_check_addresses_ready(Link *link, NetworkConfigSource source);
void address_set_broadcast(Address *a, Link *link);
DEFINE_SECTION_CLEANUP_FUNCTIONS(Address, address_free);
int link_drop_managed_addresses(Link *link);
int link_drop_foreign_addresses(Link *link);
int link_drop_ipv6ll_addresses(Link *link);
void link_foreignize_addresses(Link *link);
bool link_address_is_dynamic(const Link *link, const Address *address);
int link_get_address(Link *link, int family, const union in_addr_union *address, unsigned char prefixlen, Address **ret);
static inline int link_get_ipv6_address(Link *link, const struct in6_addr *address, unsigned char prefixlen, Address **ret) {
assert(address);
return link_get_address(link, AF_INET6, &(union in_addr_union) { .in6 = *address }, prefixlen, ret);
}
static inline int link_get_ipv4_address(Link *link, const struct in_addr *address, unsigned char prefixlen, Address **ret) {
assert(address);
return link_get_address(link, AF_INET, &(union in_addr_union) { .in = *address }, prefixlen, ret);
}
int manager_get_address(Manager *manager, int family, const union in_addr_union *address, unsigned char prefixlen, Address **ret);
bool manager_has_address(Manager *manager, int family, const union in_addr_union *address, bool check_ready);
void address_cancel_request(Address *address);
int link_request_address(
Link *link,
Address *address,
bool consume_object,
unsigned *message_counter,
address_netlink_handler_t netlink_handler,
Request **ret);
int link_request_static_address(Link *link, Address *address, bool consume);
int link_request_static_addresses(Link *link);
int manager_rtnl_process_address(sd_netlink *nl, sd_netlink_message *message, Manager *m);
int network_drop_invalid_addresses(Network *network);
int address_compare_func(const Address *a1, const Address *a2);
int address_equal(const Address *a1, const Address *a2);
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(Address, address);
void link_mark_addresses(Link *link, NetworkConfigSource source);
CONFIG_PARSER_PROTOTYPE(config_parse_address);
CONFIG_PARSER_PROTOTYPE(config_parse_broadcast);
CONFIG_PARSER_PROTOTYPE(config_parse_label);
CONFIG_PARSER_PROTOTYPE(config_parse_lifetime);
CONFIG_PARSER_PROTOTYPE(config_parse_address_flags);
CONFIG_PARSER_PROTOTYPE(config_parse_address_scope);
CONFIG_PARSER_PROTOTYPE(config_parse_address_route_metric);
CONFIG_PARSER_PROTOTYPE(config_parse_duplicate_address_detection);
CONFIG_PARSER_PROTOTYPE(config_parse_address_netlabel);
| 5,521 | 39.014493 | 130 |
h
|
null |
systemd-main/src/network/networkd-bridge-fdb.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <net/ethernet.h>
#include <net/if.h>
#include "alloc-util.h"
#include "bridge.h"
#include "netlink-util.h"
#include "networkd-bridge-fdb.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "networkd-queue.h"
#include "networkd-util.h"
#include "parse-util.h"
#include "string-table.h"
#include "vlan-util.h"
#include "vxlan.h"
#define STATIC_BRIDGE_FDB_ENTRIES_PER_NETWORK_MAX 1024U
/* remove and FDB entry. */
BridgeFDB *bridge_fdb_free(BridgeFDB *fdb) {
if (!fdb)
return NULL;
if (fdb->network) {
assert(fdb->section);
hashmap_remove(fdb->network->bridge_fdb_entries_by_section, fdb->section);
}
config_section_free(fdb->section);
free(fdb->outgoing_ifname);
return mfree(fdb);
}
DEFINE_SECTION_CLEANUP_FUNCTIONS(BridgeFDB, bridge_fdb_free);
/* create a new FDB entry or get an existing one. */
static int bridge_fdb_new_static(
Network *network,
const char *filename,
unsigned section_line,
BridgeFDB **ret) {
_cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(bridge_fdb_freep) BridgeFDB *fdb = NULL;
int r;
assert(network);
assert(ret);
assert(filename);
assert(section_line > 0);
r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
/* search entry in hashmap first. */
fdb = hashmap_get(network->bridge_fdb_entries_by_section, n);
if (fdb) {
*ret = TAKE_PTR(fdb);
return 0;
}
if (hashmap_size(network->bridge_fdb_entries_by_section) >= STATIC_BRIDGE_FDB_ENTRIES_PER_NETWORK_MAX)
return -E2BIG;
/* allocate space for and FDB entry. */
fdb = new(BridgeFDB, 1);
if (!fdb)
return -ENOMEM;
/* init FDB structure. */
*fdb = (BridgeFDB) {
.network = network,
.section = TAKE_PTR(n),
.vni = VXLAN_VID_MAX + 1,
.ntf_flags = NEIGHBOR_CACHE_ENTRY_FLAGS_SELF,
};
r = hashmap_ensure_put(&network->bridge_fdb_entries_by_section, &config_section_hash_ops, fdb->section, fdb);
if (r < 0)
return r;
/* return allocated FDB structure. */
*ret = TAKE_PTR(fdb);
return 0;
}
static int bridge_fdb_configure_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -EEXIST) {
log_link_message_warning_errno(link, m, r, "Could not add bridge FDB entry");
link_enter_failed(link);
return 0;
}
if (link->static_bridge_fdb_messages == 0) {
log_link_debug(link, "Bridge FDB entries set");
link->static_bridge_fdb_configured = true;
link_check_ready(link);
}
return 0;
}
/* send a request to the kernel to add a FDB entry in its static MAC table. */
static int bridge_fdb_configure_message(const BridgeFDB *fdb, Link *link, sd_netlink_message *req) {
int r;
assert(fdb);
assert(link);
r = sd_rtnl_message_neigh_set_flags(req, fdb->ntf_flags);
if (r < 0)
return r;
/* only NUD_PERMANENT state supported. */
r = sd_rtnl_message_neigh_set_state(req, NUD_NOARP | NUD_PERMANENT);
if (r < 0)
return r;
r = sd_netlink_message_append_data(req, NDA_LLADDR, &fdb->mac_addr, sizeof(fdb->mac_addr));
if (r < 0)
return r;
/* VLAN Id is optional. We'll add VLAN Id only if it's specified. */
if (fdb->vlan_id > 0) {
r = sd_netlink_message_append_u16(req, NDA_VLAN, fdb->vlan_id);
if (r < 0)
return r;
}
if (fdb->outgoing_ifindex > 0) {
r = sd_netlink_message_append_u32(req, NDA_IFINDEX, fdb->outgoing_ifindex);
if (r < 0)
return r;
}
if (in_addr_is_set(fdb->family, &fdb->destination_addr)) {
r = netlink_message_append_in_addr_union(req, NDA_DST, fdb->family, &fdb->destination_addr);
if (r < 0)
return r;
}
if (fdb->vni <= VXLAN_VID_MAX) {
r = sd_netlink_message_append_u32(req, NDA_VNI, fdb->vni);
if (r < 0)
return r;
}
return 0;
}
static int bridge_fdb_configure(BridgeFDB *fdb, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(fdb);
assert(link);
assert(link->manager);
assert(req);
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &m, RTM_NEWNEIGH, link->ifindex, AF_BRIDGE);
if (r < 0)
return r;
r = bridge_fdb_configure_message(fdb, link, m);
if (r < 0)
return r;
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static bool bridge_fdb_is_ready_to_configure(BridgeFDB *fdb, Link *link) {
Link *out = NULL;
assert(fdb);
assert(link);
assert(link->manager);
if (!link_is_ready_to_configure(link, false))
return false;
if (fdb->outgoing_ifname) {
if (link_get_by_name(link->manager, fdb->outgoing_ifname, &out) < 0)
return false;
fdb->outgoing_ifindex = out->ifindex;
} else if (fdb->outgoing_ifindex > 0) {
if (link_get_by_index(link->manager, fdb->outgoing_ifindex, &out) < 0)
return false;
}
if (out && !link_is_ready_to_configure(out, false))
return false;
return true;
}
static int bridge_fdb_process_request(Request *req, Link *link, void *userdata) {
BridgeFDB *fdb = ASSERT_PTR(userdata);
int r;
assert(req);
assert(link);
if (!bridge_fdb_is_ready_to_configure(fdb, link))
return 0;
r = bridge_fdb_configure(fdb, link, req);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure bridge FDB: %m");
return 1;
}
int link_request_static_bridge_fdb(Link *link) {
BridgeFDB *fdb;
int r;
assert(link);
assert(link->network);
link->static_bridge_fdb_configured = false;
HASHMAP_FOREACH(fdb, link->network->bridge_fdb_entries_by_section) {
r = link_queue_request_full(link, REQUEST_TYPE_BRIDGE_FDB,
fdb, NULL,
trivial_hash_func,
trivial_compare_func,
bridge_fdb_process_request,
&link->static_bridge_fdb_messages,
bridge_fdb_configure_handler,
NULL);
if (r < 0)
return log_link_error_errno(link, r, "Failed to request static bridge FDB entry: %m");
}
if (link->static_bridge_fdb_messages == 0) {
link->static_bridge_fdb_configured = true;
link_check_ready(link);
} else {
log_link_debug(link, "Setting bridge FDB entries");
link_set_state(link, LINK_STATE_CONFIGURING);
}
return 0;
}
void network_drop_invalid_bridge_fdb_entries(Network *network) {
BridgeFDB *fdb;
assert(network);
HASHMAP_FOREACH(fdb, network->bridge_fdb_entries_by_section)
if (section_is_invalid(fdb->section))
bridge_fdb_free(fdb);
}
/* parse the HW address from config files. */
int config_parse_fdb_hwaddr(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(bridge_fdb_free_or_set_invalidp) BridgeFDB *fdb = NULL;
Network *network = userdata;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = bridge_fdb_new_static(network, filename, section_line, &fdb);
if (r < 0)
return log_oom();
r = parse_ether_addr(rvalue, &fdb->mac_addr);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Not a valid MAC address, ignoring assignment: %s", rvalue);
return 0;
}
TAKE_PTR(fdb);
return 0;
}
/* parse the VLAN Id from config files. */
int config_parse_fdb_vlan_id(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(bridge_fdb_free_or_set_invalidp) BridgeFDB *fdb = NULL;
Network *network = userdata;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = bridge_fdb_new_static(network, filename, section_line, &fdb);
if (r < 0)
return log_oom();
r = config_parse_vlanid(unit, filename, line, section,
section_line, lvalue, ltype,
rvalue, &fdb->vlan_id, userdata);
if (r < 0)
return r;
TAKE_PTR(fdb);
return 0;
}
int config_parse_fdb_destination(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(bridge_fdb_free_or_set_invalidp) BridgeFDB *fdb = NULL;
Network *network = userdata;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = bridge_fdb_new_static(network, filename, section_line, &fdb);
if (r < 0)
return log_oom();
r = in_addr_from_string_auto(rvalue, &fdb->family, &fdb->destination_addr);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"FDB destination IP address is invalid, ignoring assignment: %s",
rvalue);
return 0;
}
TAKE_PTR(fdb);
return 0;
}
int config_parse_fdb_vxlan_vni(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(bridge_fdb_free_or_set_invalidp) BridgeFDB *fdb = NULL;
Network *network = userdata;
uint32_t vni;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = bridge_fdb_new_static(network, filename, section_line, &fdb);
if (r < 0)
return log_oom();
r = safe_atou32(rvalue, &vni);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse VXLAN Network Identifier (VNI), ignoring assignment: %s",
rvalue);
return 0;
}
if (vni > VXLAN_VID_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"FDB invalid VXLAN Network Identifier (VNI), ignoring assignment: %s",
rvalue);
return 0;
}
fdb->vni = vni;
TAKE_PTR(fdb);
return 0;
}
static const char* const ntf_flags_table[_NEIGHBOR_CACHE_ENTRY_FLAGS_MAX] = {
[NEIGHBOR_CACHE_ENTRY_FLAGS_USE] = "use",
[NEIGHBOR_CACHE_ENTRY_FLAGS_SELF] = "self",
[NEIGHBOR_CACHE_ENTRY_FLAGS_MASTER] = "master",
[NEIGHBOR_CACHE_ENTRY_FLAGS_ROUTER] = "router",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(ntf_flags, NeighborCacheEntryFlags);
int config_parse_fdb_ntf_flags(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(bridge_fdb_free_or_set_invalidp) BridgeFDB *fdb = NULL;
Network *network = userdata;
NeighborCacheEntryFlags f;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = bridge_fdb_new_static(network, filename, section_line, &fdb);
if (r < 0)
return log_oom();
f = ntf_flags_from_string(rvalue);
if (f < 0) {
log_syntax(unit, LOG_WARNING, filename, line, f,
"FDB failed to parse AssociatedWith=, ignoring assignment: %s",
rvalue);
return 0;
}
fdb->ntf_flags = f;
TAKE_PTR(fdb);
return 0;
}
int config_parse_fdb_interface(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(bridge_fdb_free_or_set_invalidp) BridgeFDB *fdb = NULL;
Network *network = userdata;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
assert(data);
r = bridge_fdb_new_static(network, filename, section_line, &fdb);
if (r < 0)
return log_oom();
if (isempty(rvalue)) {
fdb->outgoing_ifname = mfree(fdb->outgoing_ifname);
fdb->outgoing_ifindex = 0;
TAKE_PTR(fdb);
return 0;
}
r = parse_ifindex(rvalue);
if (r > 0) {
fdb->outgoing_ifname = mfree(fdb->outgoing_ifname);
fdb->outgoing_ifindex = r;
TAKE_PTR(fdb);
return 0;
}
if (!ifname_valid_full(rvalue, IFNAME_VALID_ALTERNATIVE)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid interface name in %s=, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
r = free_and_strdup(&fdb->outgoing_ifname, rvalue);
if (r < 0)
return log_oom();
fdb->outgoing_ifindex = 0;
TAKE_PTR(fdb);
return 0;
}
| 16,170 | 29.169776 | 125 |
c
|
null |
systemd-main/src/network/networkd-bridge-fdb.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2014 Intel Corporation. All rights reserved.
***/
#include <inttypes.h>
#include <linux/neighbour.h>
#include "conf-parser.h"
#include "ether-addr-util.h"
#include "in-addr-util.h"
typedef struct Link Link;
typedef struct Network Network;
typedef enum NeighborCacheEntryFlags {
NEIGHBOR_CACHE_ENTRY_FLAGS_USE = NTF_USE,
NEIGHBOR_CACHE_ENTRY_FLAGS_SELF = NTF_SELF,
NEIGHBOR_CACHE_ENTRY_FLAGS_MASTER = NTF_MASTER,
NEIGHBOR_CACHE_ENTRY_FLAGS_ROUTER = NTF_ROUTER,
_NEIGHBOR_CACHE_ENTRY_FLAGS_MAX,
_NEIGHBOR_CACHE_ENTRY_FLAGS_INVALID = -EINVAL,
} NeighborCacheEntryFlags;
typedef struct BridgeFDB {
Network *network;
ConfigSection *section;
uint32_t vni;
int family;
uint16_t vlan_id;
struct ether_addr mac_addr;
union in_addr_union destination_addr;
NeighborCacheEntryFlags ntf_flags;
char *outgoing_ifname;
int outgoing_ifindex;
} BridgeFDB;
BridgeFDB *bridge_fdb_free(BridgeFDB *fdb);
void network_drop_invalid_bridge_fdb_entries(Network *network);
int link_request_static_bridge_fdb(Link *link);
CONFIG_PARSER_PROTOTYPE(config_parse_fdb_hwaddr);
CONFIG_PARSER_PROTOTYPE(config_parse_fdb_vlan_id);
CONFIG_PARSER_PROTOTYPE(config_parse_fdb_destination);
CONFIG_PARSER_PROTOTYPE(config_parse_fdb_vxlan_vni);
CONFIG_PARSER_PROTOTYPE(config_parse_fdb_ntf_flags);
CONFIG_PARSER_PROTOTYPE(config_parse_fdb_interface);
| 1,532 | 26.872727 | 63 |
h
|
null |
systemd-main/src/network/networkd-bridge-mdb.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include "conf-parser.h"
#include "in-addr-util.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Network Network;
typedef struct BridgeMDB {
Network *network;
ConfigSection *section;
int family;
union in_addr_union group_addr;
uint16_t vlan_id;
} BridgeMDB;
BridgeMDB *bridge_mdb_free(BridgeMDB *mdb);
void network_drop_invalid_bridge_mdb_entries(Network *network);
int link_request_static_bridge_mdb(Link *link);
CONFIG_PARSER_PROTOTYPE(config_parse_mdb_group_address);
CONFIG_PARSER_PROTOTYPE(config_parse_mdb_vlan_id);
| 677 | 21.6 | 63 |
h
|
null |
systemd-main/src/network/networkd-bridge-vlan.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2016 BISDN GmbH. All rights reserved.
***/
#include <inttypes.h>
#include "sd-netlink.h"
#include "conf-parser.h"
#define BRIDGE_VLAN_BITMAP_MAX 4096
#define BRIDGE_VLAN_BITMAP_LEN (BRIDGE_VLAN_BITMAP_MAX / 32)
typedef struct Link Link;
typedef struct Network Network;
void network_adjust_bridge_vlan(Network *network);
int bridge_vlan_append_info(
const Link * link,
sd_netlink_message *req,
uint16_t pvid,
const uint32_t *br_vid_bitmap,
const uint32_t *br_untagged_bitmap);
CONFIG_PARSER_PROTOTYPE(config_parse_brvlan_pvid);
CONFIG_PARSER_PROTOTYPE(config_parse_brvlan_vlan);
CONFIG_PARSER_PROTOTYPE(config_parse_brvlan_untagged);
| 803 | 24.125 | 60 |
h
|
null |
systemd-main/src/network/networkd-can.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <linux/can/netlink.h>
#include "networkd-can.h"
#include "networkd-link.h"
#include "networkd-network.h"
#include "networkd-setlink.h"
#include "parse-util.h"
#include "string-util.h"
#define CAN_TERMINATION_DEFAULT_OHM_VALUE 120
int can_set_netlink_message(Link *link, sd_netlink_message *m) {
int r;
assert(link);
assert(link->network);
assert(m);
r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
if (r < 0)
return r;
r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
if (r < 0)
return r;
r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
if (r < 0)
return r;
if (link->network->can_bitrate > 0) {
struct can_bittiming bt = {
.bitrate = link->network->can_bitrate,
.sample_point = link->network->can_sample_point,
.sjw = link->network->can_sync_jump_width,
};
log_link_debug(link, "Setting bitrate = %u bit/s", bt.bitrate);
if (link->network->can_sample_point > 0)
log_link_debug(link, "Setting sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10);
else
log_link_debug(link, "Using default sample point");
r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return r;
} else if (link->network->can_time_quanta_ns > 0) {
struct can_bittiming bt = {
.tq = link->network->can_time_quanta_ns,
.prop_seg = link->network->can_propagation_segment,
.phase_seg1 = link->network->can_phase_buffer_segment_1,
.phase_seg2 = link->network->can_phase_buffer_segment_2,
.sjw = link->network->can_sync_jump_width,
};
log_link_debug(link, "Setting time quanta = %"PRIu32" nsec", bt.tq);
r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return r;
}
if (link->network->can_data_bitrate > 0) {
struct can_bittiming bt = {
.bitrate = link->network->can_data_bitrate,
.sample_point = link->network->can_data_sample_point,
.sjw = link->network->can_data_sync_jump_width,
};
log_link_debug(link, "Setting data bitrate = %u bit/s", bt.bitrate);
if (link->network->can_data_sample_point > 0)
log_link_debug(link, "Setting data sample point = %u.%u%%", bt.sample_point / 10, bt.sample_point % 10);
else
log_link_debug(link, "Using default data sample point");
r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return r;
} else if (link->network->can_data_time_quanta_ns > 0) {
struct can_bittiming bt = {
.tq = link->network->can_data_time_quanta_ns,
.prop_seg = link->network->can_data_propagation_segment,
.phase_seg1 = link->network->can_data_phase_buffer_segment_1,
.phase_seg2 = link->network->can_data_phase_buffer_segment_2,
.sjw = link->network->can_data_sync_jump_width,
};
log_link_debug(link, "Setting data time quanta = %"PRIu32" nsec", bt.tq);
r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
if (r < 0)
return r;
}
if (link->network->can_restart_us > 0) {
uint64_t restart_ms;
if (link->network->can_restart_us == USEC_INFINITY)
restart_ms = 0;
else
restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);
log_link_debug(link, "Setting restart = %s", FORMAT_TIMESPAN(restart_ms * 1000, MSEC_PER_SEC));
r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
if (r < 0)
return r;
}
if (link->network->can_control_mode_mask != 0) {
struct can_ctrlmode cm = {
.mask = link->network->can_control_mode_mask,
.flags = link->network->can_control_mode_flags,
};
r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));
if (r < 0)
return r;
}
if (link->network->can_termination_set) {
log_link_debug(link, "Setting can-termination to '%u'.", link->network->can_termination);
r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION, link->network->can_termination);
if (r < 0)
return r;
}
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
r = sd_netlink_message_close_container(m);
if (r < 0)
return r;
return 0;
}
int config_parse_can_bitrate(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint32_t *br = ASSERT_PTR(data);
uint64_t sz;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = parse_size(rvalue, 1000, &sz);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse can bitrate '%s', ignoring: %m", rvalue);
return 0;
}
/* Linux uses __u32 for bitrates, so the value should not exceed that. */
if (sz <= 0 || sz > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Bit rate out of permitted range 1...4294967295");
return 0;
}
*br = (uint32_t) sz;
return 0;
}
int config_parse_can_time_quanta(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
nsec_t val, *tq = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = parse_nsec(rvalue, &val);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse can time quanta '%s', ignoring: %m", rvalue);
return 0;
}
/* Linux uses __u32 for bitrates, so the value should not exceed that. */
if (val <= 0 || val > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Time quanta out of permitted range 1...4294967295");
return 0;
}
*tq = val;
return 0;
}
int config_parse_can_restart_usec(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
usec_t usec, *restart_usec = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
r = parse_sec(rvalue, &usec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse CAN restart sec '%s', ignoring: %m", rvalue);
return 0;
}
if (usec != USEC_INFINITY &&
DIV_ROUND_UP(usec, USEC_PER_MSEC) > UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"CAN RestartSec= must be in the range 0...%"PRIu32"ms, ignoring: %s", UINT32_MAX, rvalue);
return 0;
}
*restart_usec = usec;
return 0;
}
int config_parse_can_control_mode(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Network *network = ASSERT_PTR(userdata);
uint32_t mask = ltype;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(mask != 0);
if (isempty(rvalue)) {
network->can_control_mode_mask &= ~mask;
network->can_control_mode_flags &= ~mask;
return 0;
}
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse CAN control mode '%s', ignoring: %s", lvalue, rvalue);
return 0;
}
network->can_control_mode_mask |= mask;
SET_FLAG(network->can_control_mode_flags, mask, r);
return 0;
}
int config_parse_can_termination(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Network *network = userdata;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
if (isempty(rvalue)) {
network->can_termination_set = false;
return 0;
}
/* Note that 0 termination ohm value means no termination resistor, and there is no conflict
* between parse_boolean() and safe_atou16() when Termination=0. However, Termination=1 must be
* treated as 1 ohm, instead of true (and then the default ohm value). So, we need to parse the
* string with safe_atou16() at first. */
r = safe_atou16(rvalue, &network->can_termination);
if (r < 0) {
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse CAN termination value, ignoring: %s", rvalue);
return 0;
}
network->can_termination = r ? CAN_TERMINATION_DEFAULT_OHM_VALUE : 0;
}
network->can_termination_set = true;
return 0;
}
| 11,682 | 33.667656 | 128 |
c
|
null |
systemd-main/src/network/networkd-can.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <linux/can/netlink.h>
#include "sd-netlink.h"
#include "conf-parser.h"
typedef struct Link Link;
int can_set_netlink_message(Link *link, sd_netlink_message *m);
CONFIG_PARSER_PROTOTYPE(config_parse_can_bitrate);
CONFIG_PARSER_PROTOTYPE(config_parse_can_time_quanta);
CONFIG_PARSER_PROTOTYPE(config_parse_can_restart_usec);
CONFIG_PARSER_PROTOTYPE(config_parse_can_control_mode);
CONFIG_PARSER_PROTOTYPE(config_parse_can_termination);
| 511 | 25.947368 | 63 |
h
|
null |
systemd-main/src/network/networkd-conf.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/***
Copyright © 2014 Vinay Kulkarni <[email protected]>
***/
#include "conf-parser.h"
#include "constants.h"
#include "networkd-conf.h"
#include "networkd-manager.h"
#include "networkd-speed-meter.h"
int manager_parse_config_file(Manager *m) {
int r;
assert(m);
r = config_parse_config_file("networkd.conf",
"Network\0"
"DHCPv4\0"
"DHCPv6\0"
"DHCP\0",
config_item_perf_lookup, networkd_gperf_lookup,
CONFIG_PARSE_WARN,
m);
if (r < 0)
return r;
if (m->use_speed_meter && m->speed_meter_interval_usec < SPEED_METER_MINIMUM_TIME_INTERVAL) {
log_warning("SpeedMeterIntervalSec= is too small, using %s.",
FORMAT_TIMESPAN(SPEED_METER_MINIMUM_TIME_INTERVAL, USEC_PER_SEC));
m->speed_meter_interval_usec = SPEED_METER_MINIMUM_TIME_INTERVAL;
}
return 0;
}
| 1,200 | 32.361111 | 101 |
c
|
null |
systemd-main/src/network/networkd-dhcp-common.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <netinet/in.h>
#include "conf-parser.h"
#include "dhcp-identifier.h"
#include "in-addr-util.h"
#include "set.h"
#include "time-util.h"
/* Special values for *_uplink_index. */
#define UPLINK_INDEX_AUTO 0 /* uplink will be selected automatically */
#define UPLINK_INDEX_NONE -1 /* uplink will not be selected automatically */
#define UPLINK_INDEX_SELF -2 /* the interface itself is uplink */
#define DHCP_ROUTE_METRIC 1024
#define IPV6RA_ROUTE_METRIC_HIGH 512
#define IPV6RA_ROUTE_METRIC_MEDIUM 1024
#define IPV6RA_ROUTE_METRIC_LOW 2048
#define DHCP6PD_ROUTE_METRIC 256
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Network Network;
typedef enum DHCPUseDomains {
DHCP_USE_DOMAINS_NO,
DHCP_USE_DOMAINS_YES,
DHCP_USE_DOMAINS_ROUTE,
_DHCP_USE_DOMAINS_MAX,
_DHCP_USE_DOMAINS_INVALID = -EINVAL,
} DHCPUseDomains;
typedef enum DHCPOptionDataType {
DHCP_OPTION_DATA_UINT8,
DHCP_OPTION_DATA_UINT16,
DHCP_OPTION_DATA_UINT32,
DHCP_OPTION_DATA_STRING,
DHCP_OPTION_DATA_IPV4ADDRESS,
DHCP_OPTION_DATA_IPV6ADDRESS,
_DHCP_OPTION_DATA_MAX,
_DHCP_OPTION_DATA_INVALID,
} DHCPOptionDataType;
typedef struct DUID {
/* Value of Type in [DHCP] section */
DUIDType type;
uint8_t raw_data_len;
uint8_t raw_data[MAX_DUID_LEN];
usec_t llt_time;
bool set;
} DUID;
uint32_t link_get_dhcp4_route_table(Link *link);
uint32_t link_get_ipv6_accept_ra_route_table(Link *link);
bool link_dhcp_enabled(Link *link, int family);
static inline bool link_dhcp4_enabled(Link *link) {
return link_dhcp_enabled(link, AF_INET);
}
static inline bool link_dhcp6_enabled(Link *link) {
return link_dhcp_enabled(link, AF_INET6);
}
void network_adjust_dhcp(Network *network);
const DUID *link_get_duid(Link *link, int family);
static inline const DUID *link_get_dhcp4_duid(Link *link) {
return link_get_duid(link, AF_INET);
}
static inline const DUID *link_get_dhcp6_duid(Link *link) {
return link_get_duid(link, AF_INET6);
}
int dhcp_configure_duid(Link *link, const DUID *duid);
int manager_request_product_uuid(Manager *m);
bool address_is_filtered(int family, const union in_addr_union *address, uint8_t prefixlen, Set *allow_list, Set *deny_list);
static inline bool in4_address_is_filtered(const struct in_addr *address, Set *allow_list, Set *deny_list) {
return address_is_filtered(AF_INET, &(union in_addr_union) { .in = *address }, 32, allow_list, deny_list);
}
static inline bool in6_prefix_is_filtered(const struct in6_addr *prefix, uint8_t prefixlen, Set *allow_list, Set *deny_list) {
return address_is_filtered(AF_INET6, &(union in_addr_union) { .in6 = *prefix }, prefixlen, allow_list, deny_list);
}
int link_get_captive_portal(Link *link, const char **ret);
const char* dhcp_use_domains_to_string(DHCPUseDomains p) _const_;
DHCPUseDomains dhcp_use_domains_from_string(const char *s) _pure_;
const char *dhcp_option_data_type_to_string(DHCPOptionDataType d) _const_;
DHCPOptionDataType dhcp_option_data_type_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_route_metric);
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_accept_ra_route_metric);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_use_dns);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_use_domains);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_use_ntp);
CONFIG_PARSER_PROTOTYPE(config_parse_iaid);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_or_ra_route_table);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_user_or_vendor_class);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_send_option);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_request_options);
CONFIG_PARSER_PROTOTYPE(config_parse_duid_type);
CONFIG_PARSER_PROTOTYPE(config_parse_manager_duid_type);
CONFIG_PARSER_PROTOTYPE(config_parse_network_duid_type);
CONFIG_PARSER_PROTOTYPE(config_parse_duid_rawdata);
CONFIG_PARSER_PROTOTYPE(config_parse_manager_duid_rawdata);
CONFIG_PARSER_PROTOTYPE(config_parse_network_duid_rawdata);
CONFIG_PARSER_PROTOTYPE(config_parse_uplink);
| 4,228 | 36.096491 | 126 |
h
|
null |
systemd-main/src/network/networkd-dhcp-prefix-delegation.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "sd-dhcp-lease.h"
#include "sd-dhcp6-lease.h"
#include "conf-parser.h"
typedef struct Link Link;
bool link_dhcp_pd_is_enabled(Link *link);
bool dhcp_pd_is_uplink(Link *link, Link *target, bool accept_auto);
int dhcp_pd_find_uplink(Link *link, Link **ret);
bool dhcp4_lease_has_pd_prefix(sd_dhcp_lease *lease);
bool dhcp6_lease_has_pd_prefix(sd_dhcp6_lease *lease);
int dhcp_pd_remove(Link *link, bool only_marked);
int dhcp_request_prefix_delegation(Link *link);
int dhcp4_pd_prefix_acquired(Link *uplink);
int dhcp6_pd_prefix_acquired(Link *uplink);
void dhcp_pd_prefix_lost(Link *uplink);
void dhcp4_pd_prefix_lost(Link *uplink);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_pd_subnet_id);
| 787 | 29.307692 | 67 |
h
|
null |
systemd-main/src/network/networkd-dhcp-server-bus.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-util.h"
#include "dhcp-server-internal.h"
#include "networkd-dhcp-server-bus.h"
#include "networkd-link-bus.h"
#include "networkd-manager.h"
#include "strv.h"
static int property_get_leases(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
Link *l = ASSERT_PTR(userdata);
sd_dhcp_server *s;
DHCPLease *lease;
int r;
assert(reply);
s = l->dhcp_server;
if (!s)
return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Link %s has no DHCP server.", l->ifname);
if (sd_dhcp_server_is_in_relay_mode(s))
return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Link %s has DHCP relay agent active.", l->ifname);
r = sd_bus_message_open_container(reply, 'a', "(uayayayayt)");
if (r < 0)
return r;
HASHMAP_FOREACH(lease, s->bound_leases_by_client_id) {
r = sd_bus_message_open_container(reply, 'r', "uayayayayt");
if (r < 0)
return r;
r = sd_bus_message_append(reply, "u", (uint32_t)AF_INET);
if (r < 0)
return r;
r = sd_bus_message_append_array(reply, 'y', lease->client_id.data, lease->client_id.length);
if (r < 0)
return r;
r = sd_bus_message_append_array(reply, 'y', &lease->address, sizeof(lease->address));
if (r < 0)
return r;
r = sd_bus_message_append_array(reply, 'y', &lease->gateway, sizeof(lease->gateway));
if (r < 0)
return r;
r = sd_bus_message_append_array(reply, 'y', &lease->chaddr, sizeof(lease->chaddr));
if (r < 0)
return r;
r = sd_bus_message_append_basic(reply, 't', &lease->expiration);
if (r < 0)
return r;
r = sd_bus_message_close_container(reply);
if (r < 0)
return r;
}
return sd_bus_message_close_container(reply);
}
static int dhcp_server_emit_changed(Link *link, const char *property, ...) {
_cleanup_free_ char *path = NULL;
char **l;
assert(link);
if (sd_bus_is_ready(link->manager->bus) <= 0)
return 0;
path = link_bus_path(link);
if (!path)
return log_oom();
l = strv_from_stdarg_alloca(property);
return sd_bus_emit_properties_changed_strv(
link->manager->bus,
path,
"org.freedesktop.network1.DHCPServer",
l);
}
void dhcp_server_callback(sd_dhcp_server *s, uint64_t event, void *data) {
Link *l = ASSERT_PTR(data);
if (event & SD_DHCP_SERVER_EVENT_LEASE_CHANGED)
(void) dhcp_server_emit_changed(l, "Leases", NULL);
}
static const sd_bus_vtable dhcp_server_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("Leases", "a(uayayayayt)", property_get_leases, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_VTABLE_END
};
const BusObjectImplementation dhcp_server_object = {
"/org/freedesktop/network1/link",
"org.freedesktop.network1.DHCPServer",
.fallback_vtables = BUS_FALLBACK_VTABLES({dhcp_server_vtable, link_object_find}),
.node_enumerator = link_node_enumerator,
};
| 3,834 | 31.5 | 127 |
c
|
null |
systemd-main/src/network/networkd-dhcp-server-static-lease.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include "conf-parser.h"
#include "in-addr-util.h"
typedef struct Network Network;
typedef struct ConfigSection ConfigSection;
typedef struct DHCPStaticLease {
Network *network;
ConfigSection *section;
struct in_addr address;
uint8_t *client_id;
size_t client_id_size;
} DHCPStaticLease;
DHCPStaticLease *dhcp_static_lease_free(DHCPStaticLease *lease);
void network_drop_invalid_static_leases(Network *network);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_static_lease_address);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_static_lease_hwaddr);
| 673 | 23.962963 | 64 |
h
|
null |
systemd-main/src/network/networkd-dhcp4.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
typedef struct Link Link;
typedef struct Network Network;
typedef enum DHCPClientIdentifier {
DHCP_CLIENT_ID_MAC,
DHCP_CLIENT_ID_DUID,
/* The following option may not be good for RFC regarding DHCP (3315 and 4361).
* But some setups require this. E.g., Sky Broadband, the second largest provider in the UK
* requires the client id to be set to a custom string, reported at
* https://github.com/systemd/systemd/issues/7828 */
DHCP_CLIENT_ID_DUID_ONLY,
_DHCP_CLIENT_ID_MAX,
_DHCP_CLIENT_ID_INVALID = -EINVAL,
} DHCPClientIdentifier;
void network_adjust_dhcp4(Network *network);
int dhcp4_update_mac(Link *link);
int dhcp4_start(Link *link);
int dhcp4_lease_lost(Link *link);
int dhcp4_check_ready(Link *link);
int link_request_dhcp4_client(Link *link);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_client_identifier);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_max_attempts);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_ip_service_type);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_socket_priority);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_mud_url);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_fallback_lease_lifetime);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_label);
| 1,328 | 35.916667 | 99 |
h
|
null |
systemd-main/src/network/networkd-dhcp6.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
#include "macro.h"
typedef enum DHCP6ClientStartMode {
DHCP6_CLIENT_START_MODE_NO,
DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST,
DHCP6_CLIENT_START_MODE_SOLICIT,
_DHCP6_CLIENT_START_MODE_MAX,
_DHCP6_CLIENT_START_MODE_INVALID = -EINVAL,
} DHCP6ClientStartMode;
typedef struct Link Link;
bool link_dhcp6_with_address_enabled(Link *link);
int dhcp6_check_ready(Link *link);
int dhcp6_update_mac(Link *link);
int dhcp6_start(Link *link);
int dhcp6_start_on_ra(Link *link, bool information_request);
int link_request_dhcp6_client(Link *link);
int link_serialize_dhcp6_client(Link *link, FILE *f);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp6_pd_prefix_hint);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp6_mud_url);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp6_client_start_mode);
const char* dhcp6_client_start_mode_to_string(DHCP6ClientStartMode i) _const_;
DHCP6ClientStartMode dhcp6_client_start_mode_from_string(const char *s) _pure_;
| 1,061 | 31.181818 | 79 |
h
|
null |
systemd-main/src/network/networkd-ipv4acd.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h> /* IFF_LOOPBACK */
#include <net/if_arp.h> /* ARPHRD_ETHER */
#include "sd-dhcp-client.h"
#include "sd-ipv4acd.h"
#include "ipvlan.h"
#include "networkd-address.h"
#include "networkd-dhcp4.h"
#include "networkd-ipv4acd.h"
#include "networkd-link.h"
#include "networkd-manager.h"
bool link_ipv4acd_supported(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return false;
/* ARPHRD_INFINIBAND seems to potentially support IPv4ACD.
* But currently sd-ipv4acd only supports ARPHRD_ETHER. */
if (link->iftype != ARPHRD_ETHER)
return false;
if (link->hw_addr.length != ETH_ALEN)
return false;
if (ether_addr_is_null(&link->hw_addr.ether))
return false;
if (streq_ptr(link->kind, "vrf"))
return false;
/* L3 or L3S mode do not support ARP. */
if (IN_SET(link_get_ipvlan_mode(link), NETDEV_IPVLAN_MODE_L3, NETDEV_IPVLAN_MODE_L3S))
return false;
return true;
}
static bool address_ipv4acd_enabled(Address *address) {
assert(address);
assert(address->link);
if (address->family != AF_INET)
return false;
if (!FLAGS_SET(address->duplicate_address_detection, ADDRESS_FAMILY_IPV4))
return false;
/* Currently, only static and DHCP4 addresses are supported. */
if (!IN_SET(address->source, NETWORK_CONFIG_SOURCE_STATIC, NETWORK_CONFIG_SOURCE_DHCP4))
return false;
if (!link_ipv4acd_supported(address->link))
return false;
return true;
}
bool ipv4acd_bound(const Address *address) {
assert(address);
if (!address->acd)
return true;
return address->acd_bound;
}
static int static_ipv4acd_address_remove(Link *link, Address *address, bool on_conflict) {
int r;
assert(link);
assert(address);
if (!address_exists(address))
return 0; /* Not assigned. */
if (on_conflict)
log_link_warning(link, "Dropping address "IPV4_ADDRESS_FMT_STR", as an address conflict was detected.",
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
else
log_link_debug(link, "Removing address "IPV4_ADDRESS_FMT_STR", as the ACD client is stopped.",
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
r = address_remove(address);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to remove address "IPV4_ADDRESS_FMT_STR": %m",
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
return 0;
}
static int dhcp4_address_on_conflict(Link *link, Address *address) {
int r;
assert(link);
assert(link->dhcp_client);
r = sd_dhcp_client_send_decline(link->dhcp_client);
if (r < 0)
log_link_warning_errno(link, r, "Failed to send DHCP DECLINE, ignoring: %m");
if (!link->dhcp_lease)
/* Unlikely, but during probing the address, the lease may be lost. */
return 0;
log_link_warning(link, "Dropping DHCPv4 lease, as an address conflict was detected.");
r = dhcp4_lease_lost(link);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to drop DHCPv4 lease: %m");
/* It is not necessary to call address_remove() here, as dhcp4_lease_lost() removes it. */
return 0;
}
static void on_acd(sd_ipv4acd *acd, int event, void *userdata) {
Address *address = ASSERT_PTR(userdata);
Link *link;
int r;
assert(acd);
assert(address->acd == acd);
assert(address->link);
assert(address->family == AF_INET);
assert(IN_SET(address->source, NETWORK_CONFIG_SOURCE_STATIC, NETWORK_CONFIG_SOURCE_DHCP4));
link = address->link;
switch (event) {
case SD_IPV4ACD_EVENT_STOP:
address->acd_bound = false;
if (address->source == NETWORK_CONFIG_SOURCE_STATIC) {
r = static_ipv4acd_address_remove(link, address, /* on_conflict = */ false);
if (r < 0)
link_enter_failed(link);
}
/* We have nothing to do for DHCPv4 lease here, as the dhcp client is already stopped
* when stopping the ipv4acd client. See link_stop_engines(). */
break;
case SD_IPV4ACD_EVENT_BIND:
address->acd_bound = true;
log_link_debug(link, "Successfully claimed address "IPV4_ADDRESS_FMT_STR,
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
break;
case SD_IPV4ACD_EVENT_CONFLICT:
address->acd_bound = false;
log_link_warning(link, "Dropping address "IPV4_ADDRESS_FMT_STR", as an address conflict was detected.",
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
if (address->source == NETWORK_CONFIG_SOURCE_STATIC)
r = static_ipv4acd_address_remove(link, address, /* on_conflict = */ true);
else
r = dhcp4_address_on_conflict(link, address);
if (r < 0)
link_enter_failed(link);
break;
default:
assert_not_reached();
}
}
static int ipv4acd_check_mac(sd_ipv4acd *acd, const struct ether_addr *mac, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
struct hw_addr_data hw_addr;
assert(mac);
hw_addr = (struct hw_addr_data) {
.length = ETH_ALEN,
.ether = *mac,
};
return link_get_by_hw_addr(m, &hw_addr, NULL) >= 0;
}
static int address_ipv4acd_start(Address *address) {
assert(address);
assert(address->link);
if (!address->acd)
return 0;
if (sd_ipv4acd_is_running(address->acd))
return 0;
if (!link_has_carrier(address->link))
return 0;
return sd_ipv4acd_start(address->acd, true);
}
int ipv4acd_configure(Address *address) {
Link *link;
int r;
assert(address);
link = ASSERT_PTR(address->link);
if (!address_ipv4acd_enabled(address)) {
address->acd = sd_ipv4acd_unref(address->acd);
address->acd_bound = false;
return 0;
}
if (address->acd)
return address_ipv4acd_start(address);
log_link_debug(link, "Configuring IPv4ACD for address "IPV4_ADDRESS_FMT_STR,
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
r = sd_ipv4acd_new(&address->acd);
if (r < 0)
return r;
r = sd_ipv4acd_attach_event(address->acd, link->manager->event, 0);
if (r < 0)
return r;
r = sd_ipv4acd_set_ifindex(address->acd, link->ifindex);
if (r < 0)
return r;
r = sd_ipv4acd_set_mac(address->acd, &link->hw_addr.ether);
if (r < 0)
return r;
r = sd_ipv4acd_set_address(address->acd, &address->in_addr.in);
if (r < 0)
return r;
r = sd_ipv4acd_set_callback(address->acd, on_acd, address);
if (r < 0)
return r;
r = sd_ipv4acd_set_check_mac_callback(address->acd, ipv4acd_check_mac, link->manager);
if (r < 0)
return r;
return address_ipv4acd_start(address);
}
int ipv4acd_update_mac(Link *link) {
Address *address;
int k, r = 0;
assert(link);
if (link->hw_addr.length != ETH_ALEN)
return 0;
if (ether_addr_is_null(&link->hw_addr.ether))
return 0;
SET_FOREACH(address, link->addresses) {
if (!address->acd)
continue;
k = sd_ipv4acd_set_mac(address->acd, &link->hw_addr.ether);
if (k < 0)
r = k;
}
if (r < 0)
link_enter_failed(link);
return r;
}
int ipv4acd_start(Link *link) {
Address *address;
int r;
assert(link);
SET_FOREACH(address, link->addresses) {
r = address_ipv4acd_start(address);
if (r < 0)
return r;
}
return 0;
}
int ipv4acd_stop(Link *link) {
Address *address;
int k, r = 0;
assert(link);
SET_FOREACH(address, link->addresses) {
if (!address->acd)
continue;
k = sd_ipv4acd_stop(address->acd);
if (k < 0)
r = k;
}
return r;
}
int ipv4acd_set_ifname(Link *link) {
Address *address;
int r;
assert(link);
SET_FOREACH(address, link->addresses) {
if (!address->acd)
continue;
r = sd_ipv4acd_set_ifname(address->acd, link->ifname);
if (r < 0)
return r;
}
return 0;
}
| 9,480 | 27.905488 | 119 |
c
|
null |
systemd-main/src/network/networkd-ipv4ll.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <linux/if.h>
#include "netif-util.h"
#include "networkd-address.h"
#include "networkd-ipv4acd.h"
#include "networkd-ipv4ll.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-queue.h"
#include "parse-util.h"
bool link_ipv4ll_enabled(Link *link) {
assert(link);
if (!link_ipv4acd_supported(link))
return false;
if (!link->network)
return false;
if (link->network->bond)
return false;
return link->network->link_local & ADDRESS_FAMILY_IPV4;
}
static int address_new_from_ipv4ll(Link *link, Address **ret) {
_cleanup_(address_freep) Address *address = NULL;
struct in_addr addr;
int r;
assert(link);
assert(link->ipv4ll);
assert(ret);
r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
if (r < 0)
return r;
r = address_new(&address);
if (r < 0)
return -ENOMEM;
address->source = NETWORK_CONFIG_SOURCE_IPV4LL;
address->family = AF_INET;
address->in_addr.in = addr;
address->prefixlen = 16;
address->scope = RT_SCOPE_LINK;
address->route_metric = IPV4LL_ROUTE_METRIC;
address_set_broadcast(address, link);
*ret = TAKE_PTR(address);
return 0;
}
static int ipv4ll_address_lost(Link *link) {
_cleanup_(address_freep) Address *address = NULL;
Address *existing;
int r;
assert(link);
link->ipv4ll_address_configured = false;
r = address_new_from_ipv4ll(link, &address);
if (r == -ENOENT)
return 0;
if (r < 0)
return r;
if (address_get(link, address, &existing) < 0)
return 0;
if (existing->source != NETWORK_CONFIG_SOURCE_IPV4LL)
return 0;
if (!address_exists(existing))
return 0;
log_link_debug(link, "IPv4 link-local release "IPV4_ADDRESS_FMT_STR,
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
return address_remove(existing);
}
static int ipv4ll_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Address *address) {
int r;
assert(link);
assert(!link->ipv4ll_address_configured);
r = address_configure_handler_internal(rtnl, m, link, "Could not set ipv4ll address");
if (r <= 0)
return r;
link->ipv4ll_address_configured = true;
link_check_ready(link);
return 1;
}
static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
_cleanup_(address_freep) Address *address = NULL;
int r;
assert(ll);
assert(link);
link->ipv4ll_address_configured = false;
r = address_new_from_ipv4ll(link, &address);
if (r == -ENOENT)
return 0;
if (r < 0)
return r;
log_link_debug(link, "IPv4 link-local claim "IPV4_ADDRESS_FMT_STR,
IPV4_ADDRESS_FMT_VAL(address->in_addr.in));
return link_request_address(link, TAKE_PTR(address), true, NULL, ipv4ll_address_handler, NULL);
}
static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata) {
Link *link = ASSERT_PTR(userdata);
int r;
assert(link->network);
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
return;
switch (event) {
case SD_IPV4LL_EVENT_STOP:
r = ipv4ll_address_lost(link);
if (r < 0) {
link_enter_failed(link);
return;
}
break;
case SD_IPV4LL_EVENT_CONFLICT:
r = ipv4ll_address_lost(link);
if (r < 0) {
link_enter_failed(link);
return;
}
r = sd_ipv4ll_restart(ll);
if (r < 0) {
log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
link_enter_failed(link);
}
break;
case SD_IPV4LL_EVENT_BIND:
r = ipv4ll_address_claimed(ll, link);
if (r < 0) {
log_link_error(link, "Failed to configure ipv4ll address: %m");
link_enter_failed(link);
return;
}
break;
default:
log_link_warning(link, "IPv4 link-local unknown event: %d", event);
break;
}
}
static int ipv4ll_check_mac(sd_ipv4ll *ll, const struct ether_addr *mac, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
struct hw_addr_data hw_addr;
assert(mac);
hw_addr = (struct hw_addr_data) {
.length = ETH_ALEN,
.ether = *mac,
};
return link_get_by_hw_addr(m, &hw_addr, NULL) >= 0;
}
int ipv4ll_configure(Link *link) {
uint64_t seed;
int r;
assert(link);
if (!link_ipv4ll_enabled(link))
return 0;
if (link->ipv4ll)
return -EBUSY;
r = sd_ipv4ll_new(&link->ipv4ll);
if (r < 0)
return r;
r = sd_ipv4ll_attach_event(link->ipv4ll, link->manager->event, 0);
if (r < 0)
return r;
if (link->dev &&
net_get_unique_predictable_data(link->dev, true, &seed) >= 0) {
r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
if (r < 0)
return r;
}
r = sd_ipv4ll_set_mac(link->ipv4ll, &link->hw_addr.ether);
if (r < 0)
return r;
r = sd_ipv4ll_set_ifindex(link->ipv4ll, link->ifindex);
if (r < 0)
return r;
r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
if (r < 0)
return r;
return sd_ipv4ll_set_check_mac_callback(link->ipv4ll, ipv4ll_check_mac, link->manager);
}
int ipv4ll_update_mac(Link *link) {
assert(link);
if (link->hw_addr.length != ETH_ALEN)
return 0;
if (ether_addr_is_null(&link->hw_addr.ether))
return 0;
if (!link->ipv4ll)
return 0;
return sd_ipv4ll_set_mac(link->ipv4ll, &link->hw_addr.ether);
}
int config_parse_ipv4ll(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
AddressFamily *link_local = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
/* Note that this is mostly like
* config_parse_address_family(), except that it
* applies only to IPv4 */
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse %s=%s, ignoring assignment. "
"Note that the setting %s= is deprecated, please use LinkLocalAddressing= instead.",
lvalue, rvalue, lvalue);
return 0;
}
SET_FLAG(*link_local, ADDRESS_FAMILY_IPV4, r);
log_syntax(unit, LOG_WARNING, filename, line, 0,
"%s=%s is deprecated, please use LinkLocalAddressing=%s instead.",
lvalue, rvalue, address_family_to_string(*link_local));
return 0;
}
int config_parse_ipv4ll_address(
const char* unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
union in_addr_union a;
struct in_addr *ipv4ll_address = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*ipv4ll_address = (struct in_addr) {};
return 0;
}
r = in_addr_from_string(AF_INET, rvalue, &a);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
if (!in4_addr_is_link_local_dynamic(&a.in)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Specified address cannot be used as an IPv4 link local address, ignoring assignment: %s",
rvalue);
return 0;
}
*ipv4ll_address = a.in;
return 0;
}
| 9,489 | 28.563863 | 120 |
c
|
null |
systemd-main/src/network/networkd-ipv6-proxy-ndp.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <netinet/in.h>
#include <linux/if.h>
#include "netlink-util.h"
#include "networkd-ipv6-proxy-ndp.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "networkd-queue.h"
#include "socket-util.h"
#include "string-util.h"
void network_adjust_ipv6_proxy_ndp(Network *network) {
assert(network);
if (set_isempty(network->ipv6_proxy_ndp_addresses))
return;
if (!socket_ipv6_is_supported()) {
log_once(LOG_WARNING,
"%s: IPv6 proxy NDP addresses are set, but IPv6 is not supported by kernel, "
"Ignoring IPv6 proxy NDP addresses.", network->filename);
network->ipv6_proxy_ndp_addresses = set_free_free(network->ipv6_proxy_ndp_addresses);
}
}
static int ipv6_proxy_ndp_address_configure_handler(
sd_netlink *rtnl,
sd_netlink_message *m,
Request *req,
Link *link,
struct in6_addr *address) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0)
log_link_message_warning_errno(link, m, r, "Could not add IPv6 proxy ndp address entry, ignoring");
if (link->static_ipv6_proxy_ndp_messages == 0) {
log_link_debug(link, "IPv6 proxy NDP addresses set.");
link->static_ipv6_proxy_ndp_configured = true;
link_check_ready(link);
}
return 1;
}
/* send a request to the kernel to add an IPv6 Proxy entry to the neighbour table */
static int ipv6_proxy_ndp_address_configure(const struct in6_addr *address, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(address);
assert(link);
assert(link->manager);
assert(link->manager->rtnl);
assert(req);
/* create new netlink message */
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &m, RTM_NEWNEIGH, link->ifindex, AF_INET6);
if (r < 0)
return r;
r = sd_rtnl_message_neigh_set_flags(m, NTF_PROXY);
if (r < 0)
return r;
r = sd_netlink_message_append_in6_addr(m, NDA_DST, address);
if (r < 0)
return r;
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static int ipv6_proxy_ndp_address_process_request(Request *req, Link *link, struct in6_addr *address) {
int r;
assert(req);
assert(link);
assert(address);
if (!link_is_ready_to_configure(link, false))
return 0;
r = ipv6_proxy_ndp_address_configure(address, link, req);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure IPv6 proxy NDP address: %m");
return 1;
}
int link_request_static_ipv6_proxy_ndp_addresses(Link *link) {
struct in6_addr *address;
int r;
assert(link);
assert(link->network);
link->static_ipv6_proxy_ndp_configured = false;
SET_FOREACH(address, link->network->ipv6_proxy_ndp_addresses) {
r = link_queue_request_safe(link, REQUEST_TYPE_IPV6_PROXY_NDP,
address, NULL,
in6_addr_hash_func,
in6_addr_compare_func,
ipv6_proxy_ndp_address_process_request,
&link->static_ipv6_proxy_ndp_messages,
ipv6_proxy_ndp_address_configure_handler,
NULL);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to request IPv6 proxy NDP address: %m");
}
if (link->static_ipv6_proxy_ndp_messages == 0) {
link->static_ipv6_proxy_ndp_configured = true;
link_check_ready(link);
} else {
log_link_debug(link, "Setting IPv6 proxy NDP addresses.");
link_set_state(link, LINK_STATE_CONFIGURING);
}
return 0;
}
int config_parse_ipv6_proxy_ndp_address(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_free_ struct in6_addr *address = NULL;
Network *network = ASSERT_PTR(userdata);
union in_addr_union buffer;
int r;
assert(filename);
assert(rvalue);
if (isempty(rvalue)) {
network->ipv6_proxy_ndp_addresses = set_free_free(network->ipv6_proxy_ndp_addresses);
return 0;
}
r = in_addr_from_string(AF_INET6, rvalue, &buffer);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse IPv6 proxy NDP address, ignoring: %s", rvalue);
return 0;
}
if (in_addr_is_null(AF_INET6, &buffer)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"IPv6 proxy NDP address cannot be the ANY address, ignoring: %s", rvalue);
return 0;
}
address = newdup(struct in6_addr, &buffer.in6, 1);
if (!address)
return log_oom();
r = set_ensure_put(&network->ipv6_proxy_ndp_addresses, &in6_addr_hash_ops, address);
if (r < 0)
return log_oom();
if (r > 0)
TAKE_PTR(address);
return 0;
}
| 5,981 | 32.049724 | 115 |
c
|
null |
systemd-main/src/network/networkd-ipv6ll.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <linux/if.h>
#include <linux/if_arp.h>
#include "in-addr-util.h"
#include "networkd-address.h"
#include "networkd-ipv6ll.h"
#include "networkd-link.h"
#include "networkd-network.h"
#include "networkd-util.h"
#include "socket-util.h"
#include "string-table.h"
#include "strv.h"
#include "sysctl-util.h"
bool link_ipv6ll_enabled(Link *link) {
assert(link);
if (!socket_ipv6_is_supported())
return false;
if (link->flags & IFF_LOOPBACK)
return false;
if (!link->network)
return false;
if (link->iftype == ARPHRD_CAN)
return false;
if (STRPTR_IN_SET(link->kind, "vrf", "wireguard", "ipip", "gre", "sit", "vti", "nlmon"))
return false;
if (link->network->bond)
return false;
return link->network->link_local & ADDRESS_FAMILY_IPV6;
}
bool link_may_have_ipv6ll(Link *link, bool check_multicast) {
assert(link);
/*
* This is equivalent to link_ipv6ll_enabled() for non-WireGuard interfaces.
*
* For WireGuard interface, the kernel does not assign any IPv6LL addresses, but we can assign
* it manually. It is necessary to set an IPv6LL address manually to run NDisc or RADV on
* WireGuard interface. Note, also Multicast=yes must be set. See #17380.
*
* TODO: May be better to introduce GenerateIPv6LinkLocalAddress= setting, and use algorithms
* used in networkd-address-generation.c
*/
if (link_ipv6ll_enabled(link))
return true;
/* IPv6LL address can be manually assigned on WireGuard interface. */
if (streq_ptr(link->kind, "wireguard")) {
Address *a;
if (!link->network)
return false;
if (check_multicast && !FLAGS_SET(link->flags, IFF_MULTICAST) && link->network->multicast <= 0)
return false;
ORDERED_HASHMAP_FOREACH(a, link->network->addresses_by_section) {
if (a->family != AF_INET6)
continue;
if (in6_addr_is_set(&a->in_addr_peer.in6))
continue;
if (in6_addr_is_link_local(&a->in_addr.in6))
return true;
}
}
return false;
}
IPv6LinkLocalAddressGenMode link_get_ipv6ll_addrgen_mode(Link *link) {
assert(link);
if (!link_ipv6ll_enabled(link))
return IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_NONE;
if (link->network->ipv6ll_address_gen_mode >= 0)
return link->network->ipv6ll_address_gen_mode;
if (in6_addr_is_set(&link->network->ipv6ll_stable_secret))
return IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_STABLE_PRIVACY;
return IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_EUI64;
}
int ipv6ll_addrgen_mode_fill_message(sd_netlink_message *message, IPv6LinkLocalAddressGenMode mode) {
int r;
assert(message);
assert(mode >= 0 && mode < _IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_MAX);
r = sd_netlink_message_open_container(message, IFLA_AF_SPEC);
if (r < 0)
return r;
r = sd_netlink_message_open_container(message, AF_INET6);
if (r < 0)
return r;
r = sd_netlink_message_append_u8(message, IFLA_INET6_ADDR_GEN_MODE, mode);
if (r < 0)
return r;
r = sd_netlink_message_close_container(message);
if (r < 0)
return r;
r = sd_netlink_message_close_container(message);
if (r < 0)
return r;
return 0;
}
int link_update_ipv6ll_addrgen_mode(Link *link, sd_netlink_message *message) {
uint8_t mode;
int family, r;
assert(link);
assert(message);
r = sd_rtnl_message_get_family(message, &family);
if (r < 0)
return r;
if (family != AF_UNSPEC)
return 0;
r = sd_netlink_message_enter_container(message, IFLA_AF_SPEC);
if (r == -ENODATA)
return 0;
if (r < 0)
return r;
r = sd_netlink_message_enter_container(message, AF_INET6);
if (r == -ENODATA)
return sd_netlink_message_exit_container(message);
if (r < 0)
return r;
mode = (uint8_t) link->ipv6ll_address_gen_mode;
r = sd_netlink_message_read_u8(message, IFLA_INET6_ADDR_GEN_MODE, &mode);
if (r < 0 && r != -ENODATA)
return r;
r = sd_netlink_message_exit_container(message);
if (r < 0)
return r;
r = sd_netlink_message_exit_container(message);
if (r < 0)
return r;
if (mode == (uint8_t) link->ipv6ll_address_gen_mode)
return 0;
if (mode >= _IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_MAX) {
log_link_debug(link, "Received invalid IPv6 link-local address generation mode (%u), ignoring.", mode);
return 0;
}
if (link->ipv6ll_address_gen_mode < 0)
log_link_debug(link, "Saved IPv6 link-local address generation mode: %s",
ipv6_link_local_address_gen_mode_to_string(mode));
else
log_link_debug(link, "IPv6 link-local address generation mode is changed: %s -> %s",
ipv6_link_local_address_gen_mode_to_string(link->ipv6ll_address_gen_mode),
ipv6_link_local_address_gen_mode_to_string(mode));
link->ipv6ll_address_gen_mode = mode;
return 0;
}
#define STABLE_SECRET_APP_ID_1 SD_ID128_MAKE(aa,05,1d,94,43,68,45,07,b9,73,f1,e8,e4,b7,34,52)
#define STABLE_SECRET_APP_ID_2 SD_ID128_MAKE(52,c4,40,a0,9f,2f,48,58,a9,3a,f6,29,25,ba,7a,7d)
int link_set_ipv6ll_stable_secret(Link *link) {
struct in6_addr a;
int r;
assert(link);
assert(link->network);
if (link->network->ipv6ll_address_gen_mode != IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_STABLE_PRIVACY)
return 0;
if (in6_addr_is_set(&link->network->ipv6ll_stable_secret))
a = link->network->ipv6ll_stable_secret;
else {
sd_id128_t key;
le64_t v;
/* Generate a stable secret address from machine-ID and the interface name. */
r = sd_id128_get_machine_app_specific(STABLE_SECRET_APP_ID_1, &key);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to generate key: %m");
v = htole64(siphash24_string(link->ifname, key.bytes));
memcpy(a.s6_addr, &v, sizeof(v));
r = sd_id128_get_machine_app_specific(STABLE_SECRET_APP_ID_2, &key);
if (r < 0)
return log_link_debug_errno(link, r, "Failed to generate key: %m");
v = htole64(siphash24_string(link->ifname, key.bytes));
assert_cc(sizeof(v) * 2 == sizeof(a.s6_addr));
memcpy(a.s6_addr + sizeof(v), &v, sizeof(v));
}
return sysctl_write_ip_property(AF_INET6, link->ifname, "stable_secret",
IN6_ADDR_TO_STRING(&a));
}
int link_set_ipv6ll_addrgen_mode(Link *link, IPv6LinkLocalAddressGenMode mode) {
assert(link);
assert(mode >= 0 && mode < _IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_MAX);
if (mode == link->ipv6ll_address_gen_mode)
return 0;
return sysctl_write_ip_property_uint32(AF_INET6, link->ifname, "addr_gen_mode", mode);
}
static const char* const ipv6_link_local_address_gen_mode_table[_IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_MAX] = {
[IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_EUI64] = "eui64",
[IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_NONE] = "none",
[IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_STABLE_PRIVACY] = "stable-privacy",
[IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_RANDOM] = "random",
};
DEFINE_STRING_TABLE_LOOKUP(ipv6_link_local_address_gen_mode, IPv6LinkLocalAddressGenMode);
DEFINE_CONFIG_PARSE_ENUM(
config_parse_ipv6_link_local_address_gen_mode,
ipv6_link_local_address_gen_mode,
IPv6LinkLocalAddressGenMode,
"Failed to parse IPv6 link-local address generation mode");
| 8,576 | 33.584677 | 119 |
c
|
null |
systemd-main/src/network/networkd-ipv6ll.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <errno.h>
#include <linux/if_link.h>
#include <stdbool.h>
#include "sd-netlink.h"
#include "conf-parser.h"
#include "macro.h"
typedef struct Link Link;
typedef enum IPv6LinkLocalAddressGenMode {
IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_EUI64 = IN6_ADDR_GEN_MODE_EUI64,
IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_NONE = IN6_ADDR_GEN_MODE_NONE,
IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_STABLE_PRIVACY = IN6_ADDR_GEN_MODE_STABLE_PRIVACY,
IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_RANDOM = IN6_ADDR_GEN_MODE_RANDOM,
_IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_MAX,
_IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_INVALID = -EINVAL,
} IPv6LinkLocalAddressGenMode;
bool link_ipv6ll_enabled(Link *link);
bool link_may_have_ipv6ll(Link *link, bool check_multicast);
IPv6LinkLocalAddressGenMode link_get_ipv6ll_addrgen_mode(Link *link);
int ipv6ll_addrgen_mode_fill_message(sd_netlink_message *message, IPv6LinkLocalAddressGenMode mode);
int link_update_ipv6ll_addrgen_mode(Link *link, sd_netlink_message *message);
int link_set_ipv6ll_stable_secret(Link *link);
int link_set_ipv6ll_addrgen_mode(Link *link, IPv6LinkLocalAddressGenMode mode);
const char* ipv6_link_local_address_gen_mode_to_string(IPv6LinkLocalAddressGenMode s) _const_;
IPv6LinkLocalAddressGenMode ipv6_link_local_address_gen_mode_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_link_local_address_gen_mode);
| 1,499 | 38.473684 | 100 |
h
|
null |
systemd-main/src/network/networkd-link.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <endian.h>
#include <linux/nl80211.h>
#include "sd-bus.h"
#include "sd-device.h"
#include "sd-dhcp-client.h"
#include "sd-dhcp-server.h"
#include "sd-dhcp6-client.h"
#include "sd-ipv4acd.h"
#include "sd-ipv4ll.h"
#include "sd-lldp-rx.h"
#include "sd-lldp-tx.h"
#include "sd-ndisc.h"
#include "sd-radv.h"
#include "sd-netlink.h"
#include "ether-addr-util.h"
#include "log-link.h"
#include "netif-util.h"
#include "network-util.h"
#include "networkd-ipv6ll.h"
#include "networkd-util.h"
#include "ordered-set.h"
#include "resolve-util.h"
#include "set.h"
typedef enum LinkState {
LINK_STATE_PENDING, /* udev has not initialized the link */
LINK_STATE_INITIALIZED, /* udev has initialized the link */
LINK_STATE_CONFIGURING, /* configuring addresses, routes, etc. */
LINK_STATE_CONFIGURED, /* everything is configured */
LINK_STATE_UNMANAGED, /* Unmanaged=yes is set */
LINK_STATE_FAILED, /* at least one configuration process failed */
LINK_STATE_LINGER, /* RTM_DELLINK for the link has been received */
_LINK_STATE_MAX,
_LINK_STATE_INVALID = -EINVAL,
} LinkState;
typedef struct Manager Manager;
typedef struct Network Network;
typedef struct NetDev NetDev;
typedef struct DUID DUID;
typedef struct Link {
Manager *manager;
unsigned n_ref;
int ifindex;
int master_ifindex;
int dsa_master_ifindex;
int sr_iov_phys_port_ifindex;
Set *sr_iov_virt_port_ifindices;
char *ifname;
char **alternative_names;
char *kind;
unsigned short iftype;
char *state_file;
struct hw_addr_data hw_addr;
struct hw_addr_data bcast_addr;
struct hw_addr_data permanent_hw_addr;
struct hw_addr_data requested_hw_addr;
struct in6_addr ipv6ll_address;
uint32_t mtu;
uint32_t min_mtu;
uint32_t max_mtu;
uint32_t original_mtu;
sd_device *dev;
char *driver;
/* to prevent multiple ethtool calls */
bool ethtool_driver_read;
bool ethtool_permanent_hw_addr_read;
/* link-local addressing */
IPv6LinkLocalAddressGenMode ipv6ll_address_gen_mode;
/* wlan */
enum nl80211_iftype wlan_iftype;
char *ssid;
char *previous_ssid;
struct ether_addr bssid;
unsigned flags;
uint8_t kernel_operstate;
sd_event_source *carrier_lost_timer;
Network *network;
NetDev *netdev;
LinkState state;
LinkOperationalState operstate;
LinkCarrierState carrier_state;
LinkAddressState address_state;
LinkAddressState ipv4_address_state;
LinkAddressState ipv6_address_state;
LinkOnlineState online_state;
unsigned static_address_messages;
unsigned static_address_label_messages;
unsigned static_bridge_fdb_messages;
unsigned static_bridge_mdb_messages;
unsigned static_ipv6_proxy_ndp_messages;
unsigned static_neighbor_messages;
unsigned static_nexthop_messages;
unsigned static_route_messages;
unsigned static_routing_policy_rule_messages;
unsigned tc_messages;
unsigned sr_iov_messages;
unsigned set_link_messages;
unsigned set_flags_messages;
unsigned create_stacked_netdev_messages;
Set *addresses;
Set *neighbors;
Set *routes;
Set *nexthops;
Set *qdiscs;
Set *tclasses;
sd_dhcp_client *dhcp_client;
sd_dhcp_lease *dhcp_lease;
char *lease_file;
unsigned dhcp4_messages;
bool dhcp4_configured:1;
char *dhcp4_6rd_tunnel_name;
sd_ipv4ll *ipv4ll;
bool ipv4ll_address_configured:1;
bool static_addresses_configured:1;
bool static_address_labels_configured:1;
bool static_bridge_fdb_configured:1;
bool static_bridge_mdb_configured:1;
bool static_ipv6_proxy_ndp_configured:1;
bool static_neighbors_configured:1;
bool static_nexthops_configured:1;
bool static_routes_configured:1;
bool static_routing_policy_rules_configured:1;
bool tc_configured:1;
bool sr_iov_configured:1;
bool activated:1;
bool master_set:1;
bool stacked_netdevs_created:1;
sd_dhcp_server *dhcp_server;
sd_ndisc *ndisc;
sd_event_source *ndisc_expire;
Set *ndisc_rdnss;
Set *ndisc_dnssl;
Set *ndisc_captive_portals;
unsigned ndisc_messages;
bool ndisc_configured:1;
sd_radv *radv;
sd_dhcp6_client *dhcp6_client;
sd_dhcp6_lease *dhcp6_lease;
unsigned dhcp6_messages;
bool dhcp6_configured;
Set *dhcp_pd_prefixes;
unsigned dhcp_pd_messages;
bool dhcp_pd_configured;
/* This is about LLDP reception */
sd_lldp_rx *lldp_rx;
char *lldp_file;
/* This is about LLDP transmission */
sd_lldp_tx *lldp_tx;
Hashmap *bound_by_links;
Hashmap *bound_to_links;
Set *slaves;
/* For speed meter */
struct rtnl_link_stats64 stats_old, stats_new;
bool stats_updated;
/* All kinds of DNS configuration the user configured via D-Bus */
struct in_addr_full **dns;
unsigned n_dns;
OrderedSet *search_domains, *route_domains;
int dns_default_route;
ResolveSupport llmnr;
ResolveSupport mdns;
DnssecMode dnssec_mode;
DnsOverTlsMode dns_over_tls_mode;
Set *dnssec_negative_trust_anchors;
/* Similar, but NTP server configuration */
char **ntp;
} Link;
typedef int (*link_netlink_message_handler_t)(sd_netlink*, sd_netlink_message*, Link*);
bool link_is_ready_to_configure(Link *link, bool allow_unmanaged);
void link_ntp_settings_clear(Link *link);
void link_dns_settings_clear(Link *link);
Link *link_unref(Link *link);
Link *link_ref(Link *link);
DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_unref);
DEFINE_TRIVIAL_DESTRUCTOR(link_netlink_destroy_callback, Link, link_unref);
int link_get_by_index(Manager *m, int ifindex, Link **ret);
int link_get_by_name(Manager *m, const char *ifname, Link **ret);
int link_get_by_hw_addr(Manager *m, const struct hw_addr_data *hw_addr, Link **ret);
int link_get_master(Link *link, Link **ret);
int link_getlink_handler_internal(sd_netlink *rtnl, sd_netlink_message *m, Link *link, const char *error_msg);
int link_call_getlink(Link *link, link_netlink_message_handler_t callback);
int link_handle_bound_to_list(Link *link);
void link_enter_failed(Link *link);
void link_set_state(Link *link, LinkState state);
void link_check_ready(Link *link);
void link_update_operstate(Link *link, bool also_update_bond_master);
static inline bool link_has_carrier(Link *link) {
assert(link);
return netif_has_carrier(link->kernel_operstate, link->flags);
}
bool link_ipv6_enabled(Link *link);
int link_ipv6ll_gained(Link *link);
int link_stop_engines(Link *link, bool may_keep_dhcp);
const char* link_state_to_string(LinkState s) _const_;
LinkState link_state_from_string(const char *s) _pure_;
int link_reconfigure_impl(Link *link, bool force);
int link_reconfigure(Link *link, bool force);
int manager_udev_process_link(Manager *m, sd_device *device, sd_device_action_t action);
int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
int link_flags_to_string_alloc(uint32_t flags, char **ret);
const char *kernel_operstate_to_string(int t) _const_;
| 7,716 | 29.868 | 110 |
h
|
null |
systemd-main/src/network/networkd-lldp-rx.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <net/if_arp.h>
#include <unistd.h>
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "networkd-link.h"
#include "networkd-lldp-rx.h"
#include "networkd-lldp-tx.h"
#include "networkd-manager.h"
#include "networkd-network.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "tmpfile-util.h"
DEFINE_CONFIG_PARSE_ENUM(config_parse_lldp_mode, lldp_mode, LLDPMode, "Failed to parse LLDP= setting.");
static const char* const lldp_mode_table[_LLDP_MODE_MAX] = {
[LLDP_MODE_NO] = "no",
[LLDP_MODE_YES] = "yes",
[LLDP_MODE_ROUTERS_ONLY] = "routers-only",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(lldp_mode, LLDPMode, LLDP_MODE_YES);
static bool link_lldp_rx_enabled(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return false;
if (link->iftype != ARPHRD_ETHER)
return false;
if (!link->network)
return false;
/* LLDP should be handled on bridge and bond slaves as those have a direct connection to their peers,
* not on the bridge/bond master. Linux doesn't even (by default) forward lldp packets to the bridge
* master. */
if (link->kind && STR_IN_SET(link->kind, "bridge", "bond"))
return false;
return link->network->lldp_mode != LLDP_MODE_NO;
}
static void lldp_rx_handler(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata) {
Link *link = ASSERT_PTR(userdata);
int r;
(void) link_lldp_save(link);
if (link->lldp_tx && event == SD_LLDP_RX_EVENT_ADDED) {
/* If we received information about a new neighbor, restart the LLDP "fast" logic */
log_link_debug(link, "Received LLDP datagram from previously unknown neighbor, restarting 'fast' LLDP transmission.");
(void) sd_lldp_tx_stop(link->lldp_tx);
r = sd_lldp_tx_start(link->lldp_tx);
if (r < 0)
log_link_warning_errno(link, r, "Failed to restart LLDP transmission: %m");
}
}
int link_lldp_rx_configure(Link *link) {
int r;
if (!link_lldp_rx_enabled(link))
return 0;
if (link->lldp_rx)
return -EBUSY;
r = sd_lldp_rx_new(&link->lldp_rx);
if (r < 0)
return r;
r = sd_lldp_rx_attach_event(link->lldp_rx, link->manager->event, 0);
if (r < 0)
return r;
r = sd_lldp_rx_set_ifindex(link->lldp_rx, link->ifindex);
if (r < 0)
return r;
r = sd_lldp_rx_match_capabilities(link->lldp_rx,
link->network->lldp_mode == LLDP_MODE_ROUTERS_ONLY ?
SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS :
SD_LLDP_SYSTEM_CAPABILITIES_ALL);
if (r < 0)
return r;
r = sd_lldp_rx_set_filter_address(link->lldp_rx, &link->hw_addr.ether);
if (r < 0)
return r;
r = sd_lldp_rx_set_callback(link->lldp_rx, lldp_rx_handler, link);
if (r < 0)
return r;
return 0;
}
int link_lldp_save(Link *link) {
_cleanup_(unlink_and_freep) char *temp_path = NULL;
_cleanup_fclose_ FILE *f = NULL;
sd_lldp_neighbor **l = NULL;
int n = 0, r, i;
assert(link);
if (isempty(link->lldp_file))
return 0; /* Do not update state file when running in test mode. */
if (!link->lldp_rx) {
(void) unlink(link->lldp_file);
return 0;
}
r = sd_lldp_rx_get_neighbors(link->lldp_rx, &l);
if (r < 0)
return r;
if (r == 0) {
(void) unlink(link->lldp_file);
return 0;
}
n = r;
r = fopen_temporary(link->lldp_file, &f, &temp_path);
if (r < 0)
goto finish;
(void) fchmod(fileno(f), 0644);
for (i = 0; i < n; i++) {
const void *p;
le64_t u;
size_t sz;
r = sd_lldp_neighbor_get_raw(l[i], &p, &sz);
if (r < 0)
goto finish;
u = htole64(sz);
(void) fwrite(&u, 1, sizeof(u), f);
(void) fwrite(p, 1, sz, f);
}
r = fflush_and_check(f);
if (r < 0)
goto finish;
r = conservative_rename(temp_path, link->lldp_file);
if (r < 0)
goto finish;
finish:
if (r < 0)
log_link_error_errno(link, r, "Failed to save LLDP data to %s: %m", link->lldp_file);
if (l) {
for (i = 0; i < n; i++)
sd_lldp_neighbor_unref(l[i]);
free(l);
}
return r;
}
| 5,062 | 28.097701 | 134 |
c
|
null |
systemd-main/src/network/networkd-lldp-rx.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
typedef struct Link Link;
typedef enum LLDPMode {
LLDP_MODE_NO = 0,
LLDP_MODE_YES = 1,
LLDP_MODE_ROUTERS_ONLY = 2,
_LLDP_MODE_MAX,
_LLDP_MODE_INVALID = -EINVAL,
} LLDPMode;
int link_lldp_rx_configure(Link *link);
int link_lldp_save(Link *link);
const char* lldp_mode_to_string(LLDPMode m) _const_;
LLDPMode lldp_mode_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_lldp_mode);
| 534 | 22.26087 | 53 |
h
|
null |
systemd-main/src/network/networkd-lldp-tx.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <net/if.h>
#include <net/if_arp.h>
#include "sd-lldp-tx.h"
#include "networkd-link.h"
#include "networkd-lldp-tx.h"
#include "networkd-manager.h"
#include "parse-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
static bool link_lldp_tx_enabled(Link *link) {
assert(link);
if (link->flags & IFF_LOOPBACK)
return false;
if (link->iftype != ARPHRD_ETHER)
return false;
if (!link->network)
return false;
if (link->kind && STR_IN_SET(link->kind, "bridge", "bond"))
return false;
return link->network->lldp_multicast_mode >= 0 &&
link->network->lldp_multicast_mode < _SD_LLDP_MULTICAST_MODE_MAX;
}
int link_lldp_tx_configure(Link *link) {
int r;
assert(link);
if (!link_lldp_tx_enabled(link))
return 0;
if (link->lldp_tx)
return -EBUSY;
r = sd_lldp_tx_new(&link->lldp_tx);
if (r < 0)
return r;
r = sd_lldp_tx_attach_event(link->lldp_tx, link->manager->event, 0);
if (r < 0)
return r;
r = sd_lldp_tx_set_ifindex(link->lldp_tx, link->ifindex);
if (r < 0)
return r;
r = sd_lldp_tx_set_hwaddr(link->lldp_tx, &link->hw_addr.ether);
if (r < 0)
return r;
assert(link->network);
r = sd_lldp_tx_set_multicast_mode(link->lldp_tx, link->network->lldp_multicast_mode);
if (r < 0)
return r;
r = sd_lldp_tx_set_capabilities(link->lldp_tx,
SD_LLDP_SYSTEM_CAPABILITIES_STATION |
SD_LLDP_SYSTEM_CAPABILITIES_BRIDGE |
SD_LLDP_SYSTEM_CAPABILITIES_ROUTER,
(link->network->ip_forward != ADDRESS_FAMILY_NO) ?
SD_LLDP_SYSTEM_CAPABILITIES_ROUTER :
SD_LLDP_SYSTEM_CAPABILITIES_STATION);
if (r < 0)
return r;
r = sd_lldp_tx_set_port_description(link->lldp_tx, link->network->description);
if (r < 0)
return r;
r = sd_lldp_tx_set_mud_url(link->lldp_tx, link->network->lldp_mudurl);
if (r < 0)
return r;
return 0;
}
static const char * const lldp_multicast_mode_table[_SD_LLDP_MULTICAST_MODE_MAX] = {
[SD_LLDP_MULTICAST_MODE_NEAREST_BRIDGE] = "nearest-bridge",
[SD_LLDP_MULTICAST_MODE_NON_TPMR_BRIDGE] = "non-tpmr-bridge",
[SD_LLDP_MULTICAST_MODE_CUSTOMER_BRIDGE] = "customer-bridge",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(lldp_multicast_mode, sd_lldp_multicast_mode_t);
int config_parse_lldp_multicast_mode(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
sd_lldp_multicast_mode_t m, *mode = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*mode = _SD_LLDP_MULTICAST_MODE_INVALID;
return 0;
}
r = parse_boolean(rvalue);
if (r >= 0) {
*mode = r == 0 ? _SD_LLDP_MULTICAST_MODE_INVALID : SD_LLDP_MULTICAST_MODE_NEAREST_BRIDGE;
return 0;
}
m = lldp_multicast_mode_from_string(rvalue);
if (m < 0) {
log_syntax(unit, LOG_WARNING, filename, line, m,
"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
*mode = m;
return 0;
}
| 4,079 | 28.565217 | 105 |
c
|
null |
systemd-main/src/network/networkd-manager.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-bus.h"
#include "sd-device.h"
#include "sd-event.h"
#include "sd-id128.h"
#include "sd-netlink.h"
#include "sd-resolve.h"
#include "dhcp-identifier.h"
#include "firewall-util.h"
#include "hashmap.h"
#include "networkd-link.h"
#include "networkd-network.h"
#include "networkd-sysctl.h"
#include "ordered-set.h"
#include "set.h"
#include "time-util.h"
struct Manager {
sd_netlink *rtnl;
/* lazy initialized */
sd_netlink *genl;
sd_event *event;
sd_resolve *resolve;
sd_bus *bus;
sd_device_monitor *device_monitor;
Hashmap *polkit_registry;
int ethtool_fd;
KeepConfiguration keep_configuration;
IPv6PrivacyExtensions ipv6_privacy_extensions;
bool test_mode;
bool enumerating;
bool dirty;
bool restarting;
bool manage_foreign_routes;
bool manage_foreign_rules;
Set *dirty_links;
Set *new_wlan_ifindices;
char *state_file;
LinkOperationalState operational_state;
LinkCarrierState carrier_state;
LinkAddressState address_state;
LinkAddressState ipv4_address_state;
LinkAddressState ipv6_address_state;
LinkOnlineState online_state;
Hashmap *links_by_index;
Hashmap *links_by_name;
Hashmap *links_by_hw_addr;
Hashmap *links_by_dhcp_pd_subnet_prefix;
Hashmap *netdevs;
OrderedHashmap *networks;
OrderedSet *address_pools;
Set *dhcp_pd_subnet_ids;
DUID dhcp_duid;
DUID dhcp6_duid;
DUID duid_product_uuid;
bool has_product_uuid;
bool product_uuid_requested;
char* dynamic_hostname;
char* dynamic_timezone;
Set *rules;
/* Manage nexthops by id. */
Hashmap *nexthops_by_id;
/* Manager stores nexthops without RTA_OIF attribute. */
Set *nexthops;
/* Manager stores routes without RTA_OIF attribute. */
unsigned route_remove_messages;
Set *routes;
Set *routes_foreign;
/* Route table name */
Hashmap *route_table_numbers_by_name;
Hashmap *route_table_names_by_number;
/* Wiphy */
Hashmap *wiphy_by_index;
Hashmap *wiphy_by_name;
/* For link speed meter */
bool use_speed_meter;
sd_event_source *speed_meter_event_source;
usec_t speed_meter_interval_usec;
usec_t speed_meter_usec_new;
usec_t speed_meter_usec_old;
bool bridge_mdb_on_master_not_supported;
FirewallContext *fw_ctx;
OrderedSet *request_queue;
Hashmap *tuntap_fds_by_name;
};
int manager_new(Manager **ret, bool test_mode);
Manager* manager_free(Manager *m);
int manager_setup(Manager *m);
int manager_start(Manager *m);
int manager_load_config(Manager *m);
int manager_enumerate(Manager *m);
int manager_set_hostname(Manager *m, const char *hostname);
int manager_set_timezone(Manager *m, const char *timezone);
int manager_reload(Manager *m);
DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
| 3,177 | 24.629032 | 64 |
h
|
null |
systemd-main/src/network/networkd-ndisc.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "conf-parser.h"
#include "time-util.h"
typedef struct Link Link;
typedef struct Network Network;
typedef enum IPv6AcceptRAStartDHCP6Client {
IPV6_ACCEPT_RA_START_DHCP6_CLIENT_NO,
IPV6_ACCEPT_RA_START_DHCP6_CLIENT_ALWAYS,
IPV6_ACCEPT_RA_START_DHCP6_CLIENT_YES,
_IPV6_ACCEPT_RA_START_DHCP6_CLIENT_MAX,
_IPV6_ACCEPT_RA_START_DHCP6_CLIENT_INVALID = -EINVAL,
} IPv6AcceptRAStartDHCP6Client;
typedef struct NDiscRDNSS {
struct in6_addr router;
/* This is an absolute point in time, and NOT a timespan/duration.
* Must be specified with CLOCK_BOOTTIME. */
usec_t lifetime_usec;
struct in6_addr address;
} NDiscRDNSS;
typedef struct NDiscDNSSL {
struct in6_addr router;
/* This is an absolute point in time, and NOT a timespan/duration.
* Must be specified with CLOCK_BOOTTIME. */
usec_t lifetime_usec;
/* The domain name follows immediately. */
} NDiscDNSSL;
typedef struct NDiscCaptivePortal {
struct in6_addr router;
/* This is an absolute point in time, and NOT a timespan/duration.
* Must be specified with CLOCK_BOOTTIME. */
usec_t lifetime_usec;
char *captive_portal;
} NDiscCaptivePortal;
static inline char* NDISC_DNSSL_DOMAIN(const NDiscDNSSL *n) {
return ((char*) n) + ALIGN(sizeof(NDiscDNSSL));
}
bool link_ipv6_accept_ra_enabled(Link *link);
void network_adjust_ipv6_accept_ra(Network *network);
int ndisc_start(Link *link);
int ndisc_stop(Link *link);
void ndisc_flush(Link *link);
int link_request_ndisc(Link *link);
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_accept_ra_start_dhcp6_client);
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_accept_ra_use_domains);
| 1,817 | 30.344828 | 74 |
h
|
null |
systemd-main/src/network/networkd-neighbor.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "hashmap.h"
#include "netlink-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-neighbor.h"
#include "networkd-network.h"
#include "networkd-queue.h"
#include "set.h"
Neighbor *neighbor_free(Neighbor *neighbor) {
if (!neighbor)
return NULL;
if (neighbor->network) {
assert(neighbor->section);
hashmap_remove(neighbor->network->neighbors_by_section, neighbor->section);
}
config_section_free(neighbor->section);
if (neighbor->link)
set_remove(neighbor->link->neighbors, neighbor);
return mfree(neighbor);
}
DEFINE_SECTION_CLEANUP_FUNCTIONS(Neighbor, neighbor_free);
static int neighbor_new_static(Network *network, const char *filename, unsigned section_line, Neighbor **ret) {
_cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(neighbor_freep) Neighbor *neighbor = NULL;
int r;
assert(network);
assert(ret);
assert(filename);
assert(section_line > 0);
r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
neighbor = hashmap_get(network->neighbors_by_section, n);
if (neighbor) {
*ret = TAKE_PTR(neighbor);
return 0;
}
neighbor = new(Neighbor, 1);
if (!neighbor)
return -ENOMEM;
*neighbor = (Neighbor) {
.network = network,
.family = AF_UNSPEC,
.section = TAKE_PTR(n),
.source = NETWORK_CONFIG_SOURCE_STATIC,
};
r = hashmap_ensure_put(&network->neighbors_by_section, &config_section_hash_ops, neighbor->section, neighbor);
if (r < 0)
return r;
*ret = TAKE_PTR(neighbor);
return 0;
}
static int neighbor_dup(const Neighbor *neighbor, Neighbor **ret) {
_cleanup_(neighbor_freep) Neighbor *dest = NULL;
assert(neighbor);
assert(ret);
dest = newdup(Neighbor, neighbor, 1);
if (!dest)
return -ENOMEM;
/* Unset all pointers */
dest->link = NULL;
dest->network = NULL;
dest->section = NULL;
*ret = TAKE_PTR(dest);
return 0;
}
static void neighbor_hash_func(const Neighbor *neighbor, struct siphash *state) {
assert(neighbor);
siphash24_compress(&neighbor->family, sizeof(neighbor->family), state);
switch (neighbor->family) {
case AF_INET:
case AF_INET6:
/* Equality of neighbors are given by the pair (addr,lladdr) */
siphash24_compress(&neighbor->in_addr, FAMILY_ADDRESS_SIZE(neighbor->family), state);
break;
default:
/* treat any other address family as AF_UNSPEC */
break;
}
hw_addr_hash_func(&neighbor->ll_addr, state);
}
static int neighbor_compare_func(const Neighbor *a, const Neighbor *b) {
int r;
r = CMP(a->family, b->family);
if (r != 0)
return r;
switch (a->family) {
case AF_INET:
case AF_INET6:
r = memcmp(&a->in_addr, &b->in_addr, FAMILY_ADDRESS_SIZE(a->family));
if (r != 0)
return r;
}
return hw_addr_compare(&a->ll_addr, &b->ll_addr);
}
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(neighbor_hash_ops, Neighbor, neighbor_hash_func, neighbor_compare_func, neighbor_free);
static int neighbor_get(Link *link, const Neighbor *in, Neighbor **ret) {
Neighbor *existing;
assert(link);
assert(in);
existing = set_get(link->neighbors, in);
if (!existing)
return -ENOENT;
if (ret)
*ret = existing;
return 0;
}
static int neighbor_add(Link *link, Neighbor *neighbor) {
int r;
assert(link);
assert(neighbor);
r = set_ensure_put(&link->neighbors, &neighbor_hash_ops, neighbor);
if (r < 0)
return r;
if (r == 0)
return -EEXIST;
neighbor->link = link;
return 0;
}
static void log_neighbor_debug(const Neighbor *neighbor, const char *str, const Link *link) {
_cleanup_free_ char *state = NULL;
assert(neighbor);
assert(str);
if (!DEBUG_LOGGING)
return;
(void) network_config_state_to_string_alloc(neighbor->state, &state);
log_link_debug(link,
"%s %s neighbor (%s): lladdr: %s, dst: %s",
str, strna(network_config_source_to_string(neighbor->source)), strna(state),
HW_ADDR_TO_STR(&neighbor->ll_addr),
IN_ADDR_TO_STRING(neighbor->family, &neighbor->in_addr));
}
static int neighbor_configure_message(Neighbor *neighbor, Link *link, sd_netlink_message *req) {
int r;
r = sd_rtnl_message_neigh_set_state(req, NUD_PERMANENT);
if (r < 0)
return r;
r = netlink_message_append_hw_addr(req, NDA_LLADDR, &neighbor->ll_addr);
if (r < 0)
return r;
r = netlink_message_append_in_addr_union(req, NDA_DST, neighbor->family, &neighbor->in_addr);
if (r < 0)
return r;
return 0;
}
static int neighbor_configure(Neighbor *neighbor, Link *link, Request *req) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(neighbor);
assert(link);
assert(link->ifindex > 0);
assert(link->manager);
assert(link->manager->rtnl);
assert(req);
log_neighbor_debug(neighbor, "Configuring", link);
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &m, RTM_NEWNEIGH,
link->ifindex, neighbor->family);
if (r < 0)
return r;
r = neighbor_configure_message(neighbor, link, m);
if (r < 0)
return r;
return request_call_netlink_async(link->manager->rtnl, m, req);
}
static int neighbor_process_request(Request *req, Link *link, Neighbor *neighbor) {
int r;
assert(req);
assert(link);
assert(neighbor);
if (!link_is_ready_to_configure(link, false))
return 0;
r = neighbor_configure(neighbor, link, req);
if (r < 0)
return log_link_warning_errno(link, r, "Failed to configure neighbor: %m");
neighbor_enter_configuring(neighbor);
return 1;
}
static int static_neighbor_configure_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Neighbor *neighbor) {
int r;
assert(m);
assert(link);
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -EEXIST) {
log_link_message_warning_errno(link, m, r, "Could not set neighbor");
link_enter_failed(link);
return 1;
}
if (link->static_neighbor_messages == 0) {
log_link_debug(link, "Neighbors set");
link->static_neighbors_configured = true;
link_check_ready(link);
}
return 1;
}
static int link_request_neighbor(Link *link, const Neighbor *neighbor) {
Neighbor *existing;
int r;
assert(link);
assert(neighbor);
assert(neighbor->source != NETWORK_CONFIG_SOURCE_FOREIGN);
if (neighbor_get(link, neighbor, &existing) < 0) {
_cleanup_(neighbor_freep) Neighbor *tmp = NULL;
r = neighbor_dup(neighbor, &tmp);
if (r < 0)
return r;
r = neighbor_add(link, tmp);
if (r < 0)
return r;
existing = TAKE_PTR(tmp);
} else
existing->source = neighbor->source;
log_neighbor_debug(existing, "Requesting", link);
r = link_queue_request_safe(link, REQUEST_TYPE_NEIGHBOR,
existing, NULL,
neighbor_hash_func,
neighbor_compare_func,
neighbor_process_request,
&link->static_neighbor_messages,
static_neighbor_configure_handler,
NULL);
if (r <= 0)
return r;
neighbor_enter_requesting(existing);
return 1;
}
int link_request_static_neighbors(Link *link) {
Neighbor *neighbor;
int r;
assert(link);
assert(link->network);
assert(link->state != _LINK_STATE_INVALID);
link->static_neighbors_configured = false;
HASHMAP_FOREACH(neighbor, link->network->neighbors_by_section) {
r = link_request_neighbor(link, neighbor);
if (r < 0)
return log_link_warning_errno(link, r, "Could not request neighbor: %m");
}
if (link->static_neighbor_messages == 0) {
link->static_neighbors_configured = true;
link_check_ready(link);
} else {
log_link_debug(link, "Requesting neighbors");
link_set_state(link, LINK_STATE_CONFIGURING);
}
return 0;
}
static int neighbor_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
int r;
assert(m);
assert(link);
if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
return 1;
r = sd_netlink_message_get_errno(m);
if (r < 0 && r != -ESRCH)
/* Neighbor may not exist because it already got deleted, ignore that. */
log_link_message_warning_errno(link, m, r, "Could not remove neighbor");
return 1;
}
static int neighbor_remove(Neighbor *neighbor) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
Link *link;
int r;
assert(neighbor);
assert(neighbor->link);
assert(neighbor->link->manager);
assert(neighbor->link->manager->rtnl);
link = neighbor->link;
log_neighbor_debug(neighbor, "Removing", link);
r = sd_rtnl_message_new_neigh(link->manager->rtnl, &req, RTM_DELNEIGH,
link->ifindex, neighbor->family);
if (r < 0)
return log_link_error_errno(link, r, "Could not allocate RTM_DELNEIGH message: %m");
r = netlink_message_append_in_addr_union(req, NDA_DST, neighbor->family, &neighbor->in_addr);
if (r < 0)
return log_link_error_errno(link, r, "Could not append NDA_DST attribute: %m");
r = netlink_call_async(link->manager->rtnl, NULL, req, neighbor_remove_handler,
link_netlink_destroy_callback, link);
if (r < 0)
return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
link_ref(link);
neighbor_enter_removing(neighbor);
return 0;
}
int link_drop_foreign_neighbors(Link *link) {
Neighbor *neighbor;
int k, r = 0;
assert(link);
assert(link->network);
/* First, mark all neighbors. */
SET_FOREACH(neighbor, link->neighbors) {
/* Do not remove neighbors we configured. */
if (neighbor->source != NETWORK_CONFIG_SOURCE_FOREIGN)
continue;
/* Ignore neighbors not assigned yet or already removing. */
if (!neighbor_exists(neighbor))
continue;
neighbor_mark(neighbor);
}
/* Next, unmark requested neighbors. They will be configured later. */
HASHMAP_FOREACH(neighbor, link->network->neighbors_by_section) {
Neighbor *existing;
if (neighbor_get(link, neighbor, &existing) >= 0)
neighbor_unmark(existing);
}
SET_FOREACH(neighbor, link->neighbors) {
if (!neighbor_is_marked(neighbor))
continue;
k = neighbor_remove(neighbor);
if (k < 0 && r >= 0)
r = k;
}
return r;
}
int link_drop_managed_neighbors(Link *link) {
Neighbor *neighbor;
int k, r = 0;
assert(link);
SET_FOREACH(neighbor, link->neighbors) {
/* Do not touch nexthops managed by kernel or other tools. */
if (neighbor->source == NETWORK_CONFIG_SOURCE_FOREIGN)
continue;
/* Ignore neighbors not assigned yet or already removing. */
if (!neighbor_exists(neighbor))
continue;
k = neighbor_remove(neighbor);
if (k < 0 && r >= 0)
r = k;
}
return r;
}
void link_foreignize_neighbors(Link *link) {
Neighbor *neighbor;
assert(link);
SET_FOREACH(neighbor, link->neighbors)
neighbor->source = NETWORK_CONFIG_SOURCE_FOREIGN;
}
int manager_rtnl_process_neighbor(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
_cleanup_(neighbor_freep) Neighbor *tmp = NULL;
Neighbor *neighbor = NULL;
uint16_t type, state;
int ifindex, r;
Link *link;
assert(rtnl);
assert(message);
assert(m);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "rtnl: failed to receive neighbor message, ignoring");
return 0;
}
r = sd_netlink_message_get_type(message, &type);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
return 0;
} else if (!IN_SET(type, RTM_NEWNEIGH, RTM_DELNEIGH)) {
log_warning("rtnl: received unexpected message type %u when processing neighbor, ignoring.", type);
return 0;
}
r = sd_rtnl_message_neigh_get_state(message, &state);
if (r < 0) {
log_warning_errno(r, "rtnl: received neighbor message with invalid state, ignoring: %m");
return 0;
} else if (!FLAGS_SET(state, NUD_PERMANENT)) {
log_debug("rtnl: received non-static neighbor, ignoring.");
return 0;
}
r = sd_rtnl_message_neigh_get_ifindex(message, &ifindex);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get ifindex from message, ignoring: %m");
return 0;
} else if (ifindex <= 0) {
log_warning("rtnl: received neighbor message with invalid ifindex %d, ignoring.", ifindex);
return 0;
}
r = link_get_by_index(m, ifindex, &link);
if (r < 0 || !link) {
/* when enumerating we might be out of sync, but we will get the neighbor again. Also,
* kernel sends messages about neighbors after a link is removed. So, just ignore it. */
log_debug("rtnl: received neighbor for link '%d' we don't know about, ignoring.", ifindex);
return 0;
}
tmp = new0(Neighbor, 1);
r = sd_rtnl_message_neigh_get_family(message, &tmp->family);
if (r < 0) {
log_link_warning(link, "rtnl: received neighbor message without family, ignoring.");
return 0;
} else if (!IN_SET(tmp->family, AF_INET, AF_INET6)) {
log_link_debug(link, "rtnl: received neighbor message with invalid family '%i', ignoring.", tmp->family);
return 0;
}
r = netlink_message_read_in_addr_union(message, NDA_DST, tmp->family, &tmp->in_addr);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received neighbor message without valid address, ignoring: %m");
return 0;
}
r = netlink_message_read_hw_addr(message, NDA_LLADDR, &tmp->ll_addr);
if (r < 0) {
log_link_warning_errno(link, r, "rtnl: received neighbor message without valid link layer address, ignoring: %m");
return 0;
}
(void) neighbor_get(link, tmp, &neighbor);
switch (type) {
case RTM_NEWNEIGH:
if (neighbor) {
neighbor_enter_configured(neighbor);
log_neighbor_debug(neighbor, "Received remembered", link);
} else {
neighbor_enter_configured(tmp);
log_neighbor_debug(tmp, "Remembering", link);
r = neighbor_add(link, tmp);
if (r < 0) {
log_link_warning_errno(link, r, "Failed to remember foreign neighbor, ignoring: %m");
return 0;
}
TAKE_PTR(tmp);
}
break;
case RTM_DELNEIGH:
if (neighbor) {
neighbor_enter_removed(neighbor);
if (neighbor->state == 0) {
log_neighbor_debug(neighbor, "Forgetting", link);
neighbor_free(neighbor);
} else
log_neighbor_debug(neighbor, "Removed", link);
} else
log_neighbor_debug(tmp, "Kernel removed unknown", link);
break;
default:
assert_not_reached();
}
return 1;
}
static int neighbor_section_verify(Neighbor *neighbor) {
if (section_is_invalid(neighbor->section))
return -EINVAL;
if (neighbor->family == AF_UNSPEC)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Neighbor section without Address= configured. "
"Ignoring [Neighbor] section from line %u.",
neighbor->section->filename, neighbor->section->line);
if (neighbor->ll_addr.length == 0)
return log_warning_errno(SYNTHETIC_ERRNO(EINVAL),
"%s: Neighbor section without LinkLayerAddress= configured. "
"Ignoring [Neighbor] section from line %u.",
neighbor->section->filename, neighbor->section->line);
return 0;
}
void network_drop_invalid_neighbors(Network *network) {
Neighbor *neighbor;
assert(network);
HASHMAP_FOREACH(neighbor, network->neighbors_by_section)
if (neighbor_section_verify(neighbor) < 0)
neighbor_free(neighbor);
}
int config_parse_neighbor_address(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = neighbor_new_static(network, filename, section_line, &n);
if (r < 0)
return log_oom();
if (isempty(rvalue)) {
n->family = AF_UNSPEC;
n->in_addr = IN_ADDR_NULL;
TAKE_PTR(n);
return 0;
}
r = in_addr_from_string_auto(rvalue, &n->family, &n->in_addr);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Neighbor Address is invalid, ignoring assignment: %s", rvalue);
return 0;
}
TAKE_PTR(n);
return 0;
}
int config_parse_neighbor_lladdr(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_(neighbor_free_or_set_invalidp) Neighbor *n = NULL;
Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = neighbor_new_static(network, filename, section_line, &n);
if (r < 0)
return log_oom();
if (isempty(rvalue)) {
n->ll_addr = HW_ADDR_NULL;
TAKE_PTR(n);
return 0;
}
r = parse_hw_addr(rvalue, &n->ll_addr);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Neighbor %s= is invalid, ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(n);
return 0;
}
| 21,834 | 31.016129 | 133 |
c
|
null |
systemd-main/src/network/networkd-neighbor.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <stdbool.h>
#include "sd-netlink.h"
#include "conf-parser.h"
#include "ether-addr-util.h"
#include "in-addr-util.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Network Network;
typedef struct Neighbor {
Network *network;
Link *link;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
int family;
union in_addr_union in_addr;
struct hw_addr_data ll_addr;
} Neighbor;
Neighbor *neighbor_free(Neighbor *neighbor);
void network_drop_invalid_neighbors(Network *network);
int link_drop_managed_neighbors(Link *link);
int link_drop_foreign_neighbors(Link *link);
void link_foreignize_neighbors(Link *link);
int link_request_static_neighbors(Link *link);
int manager_rtnl_process_neighbor(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(Neighbor, neighbor);
CONFIG_PARSER_PROTOTYPE(config_parse_neighbor_address);
CONFIG_PARSER_PROTOTYPE(config_parse_neighbor_lladdr);
| 1,142 | 24.4 | 93 |
h
|
null |
systemd-main/src/network/networkd-netlabel.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "escape.h"
#include "netlink-util.h"
#include "networkd-address.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-netlabel.h"
#include "networkd-network.h"
static int netlabel_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
int r;
assert_se(rtnl);
assert_se(m);
assert_se(link);
r = sd_netlink_message_get_errno(m);
if (r < 0) {
log_link_message_warning_errno(link, m, r, "NetLabel operation failed, ignoring");
return 1;
}
log_link_debug(link, "NetLabel operation successful");
return 1;
}
static int netlabel_command(uint16_t command, const char *label, const Address *address) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
int r;
assert(command != NLBL_UNLABEL_C_UNSPEC && command < __NLBL_UNLABEL_C_MAX);
assert(address);
assert(address->link);
assert(address->link->ifname);
assert(address->link->manager);
assert(address->link->manager->genl);
assert(IN_SET(address->family, AF_INET, AF_INET6));
r = sd_genl_message_new(address->link->manager->genl, NETLBL_NLTYPE_UNLABELED_NAME, command, &m);
if (r < 0)
return r;
r = sd_netlink_message_append_string(m, NLBL_UNLABEL_A_IFACE, address->link->ifname);
if (r < 0)
return r;
if (command == NLBL_UNLABEL_C_STATICADD) {
assert(label);
r = sd_netlink_message_append_string(m, NLBL_UNLABEL_A_SECCTX, label);
if (r < 0)
return r;
}
union in_addr_union netmask, masked_addr;
r = in_addr_prefixlen_to_netmask(address->family, &netmask, address->prefixlen);
if (r < 0)
return r;
/*
* When adding rules, kernel adds the address to its hash table _applying also the netmask_, but on
* removal, an exact match is required _without netmask applied_, so apply the mask on both
* operations.
*/
masked_addr = address->in_addr;
r = in_addr_mask(address->family, &masked_addr, address->prefixlen);
if (r < 0)
return r;
if (address->family == AF_INET) {
r = sd_netlink_message_append_in_addr(m, NLBL_UNLABEL_A_IPV4ADDR, &masked_addr.in);
if (r < 0)
return r;
r = sd_netlink_message_append_in_addr(m, NLBL_UNLABEL_A_IPV4MASK, &netmask.in);
} else if (address->family == AF_INET6) {
r = sd_netlink_message_append_in6_addr(m, NLBL_UNLABEL_A_IPV6ADDR, &masked_addr.in6);
if (r < 0)
return r;
r = sd_netlink_message_append_in6_addr(m, NLBL_UNLABEL_A_IPV6MASK, &netmask.in6);
}
if (r < 0)
return r;
r = netlink_call_async(address->link->manager->genl, NULL, m, netlabel_handler, link_netlink_destroy_callback,
address->link);
if (r < 0)
return r;
link_ref(address->link);
return 0;
}
void address_add_netlabel(const Address *address) {
int r;
assert(address);
if (!address->netlabel)
return;
r = netlabel_command(NLBL_UNLABEL_C_STATICADD, address->netlabel, address);
if (r < 0)
log_link_warning_errno(address->link, r, "Adding NetLabel %s for IP address %s failed, ignoring", address->netlabel,
IN_ADDR_PREFIX_TO_STRING(address->family, &address->in_addr, address->prefixlen));
else
log_link_debug(address->link, "Adding NetLabel %s for IP address %s", address->netlabel,
IN_ADDR_PREFIX_TO_STRING(address->family, &address->in_addr, address->prefixlen));
}
void address_del_netlabel(const Address *address) {
int r;
assert(address);
if (!address->netlabel)
return;
r = netlabel_command(NLBL_UNLABEL_C_STATICREMOVE, address->netlabel, address);
if (r < 0)
log_link_warning_errno(address->link, r, "Deleting NetLabel %s for IP address %s failed, ignoring", address->netlabel,
IN_ADDR_PREFIX_TO_STRING(address->family, &address->in_addr, address->prefixlen));
else
log_link_debug(address->link, "Deleting NetLabel %s for IP address %s", address->netlabel,
IN_ADDR_PREFIX_TO_STRING(address->family, &address->in_addr, address->prefixlen));
}
| 4,775 | 36.023256 | 134 |
c
|
null |
systemd-main/src/network/networkd-network-bus.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "alloc-util.h"
#include "ether-addr-util.h"
#include "networkd-manager.h"
#include "networkd-network-bus.h"
#include "path-util.h"
#include "string-util.h"
#include "strv.h"
static int property_get_hw_addrs(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
const struct hw_addr_data *p;
Set *s;
int r;
assert(bus);
assert(reply);
assert(userdata);
s = *(Set **) userdata;
r = sd_bus_message_open_container(reply, 'a', "s");
if (r < 0)
return r;
SET_FOREACH(p, s) {
r = sd_bus_message_append(reply, "s", HW_ADDR_TO_STR(p));
if (r < 0)
return r;
}
return sd_bus_message_close_container(reply);
}
static const sd_bus_vtable network_vtable[] = {
SD_BUS_VTABLE_START(0),
SD_BUS_PROPERTY("Description", "s", NULL, offsetof(Network, description), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("SourcePath", "s", NULL, offsetof(Network, filename), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("MatchMAC", "as", property_get_hw_addrs, offsetof(Network, match.hw_addr), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("MatchPath", "as", NULL, offsetof(Network, match.path), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("MatchDriver", "as", NULL, offsetof(Network, match.driver), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("MatchType", "as", NULL, offsetof(Network, match.iftype), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("MatchName", "as", NULL, offsetof(Network, match.ifname), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_VTABLE_END
};
static char *network_bus_path(Network *network) {
_cleanup_free_ char *name = NULL, *networkname= NULL;
char *d, *path;
int r;
assert(network);
assert(network->filename);
name = strdup(network->filename);
if (!name)
return NULL;
r = path_extract_filename(name, &networkname);
if (r < 0)
return NULL;
d = strrchr(networkname, '.');
if (!d)
return NULL;
assert(streq(d, ".network"));
*d = '\0';
r = sd_bus_path_encode("/org/freedesktop/network1/network", networkname, &path);
if (r < 0)
return NULL;
return path;
}
int network_node_enumerator(sd_bus *bus, const char *path, void *userdata, char ***nodes, sd_bus_error *error) {
_cleanup_strv_free_ char **l = NULL;
Manager *m = ASSERT_PTR(userdata);
Network *network;
int r;
assert(bus);
assert(path);
assert(nodes);
ORDERED_HASHMAP_FOREACH(network, m->networks) {
char *p;
p = network_bus_path(network);
if (!p)
return -ENOMEM;
r = strv_consume(&l, p);
if (r < 0)
return r;
}
*nodes = TAKE_PTR(l);
return 1;
}
int network_object_find(sd_bus *bus, const char *path, const char *interface, void *userdata, void **found, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
Network *network;
_cleanup_free_ char *name = NULL;
int r;
assert(bus);
assert(path);
assert(interface);
assert(found);
r = sd_bus_path_decode(path, "/org/freedesktop/network1/network", &name);
if (r < 0)
return 0;
r = network_get_by_name(m, name, &network);
if (r < 0)
return 0;
*found = network;
return 1;
}
const BusObjectImplementation network_object = {
"/org/freedesktop/network1/network",
"org.freedesktop.network1.Network",
.fallback_vtables = BUS_FALLBACK_VTABLES({network_vtable, network_object_find}),
.node_enumerator = network_node_enumerator,
};
| 4,237 | 28.227586 | 130 |
c
|
null |
systemd-main/src/network/networkd-network.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <linux/nl80211.h>
#include "sd-bus.h"
#include "sd-device.h"
#include "sd-lldp-tx.h"
#include "bridge.h"
#include "condition.h"
#include "conf-parser.h"
#include "hashmap.h"
#include "ipoib.h"
#include "net-condition.h"
#include "netdev.h"
#include "networkd-bridge-vlan.h"
#include "networkd-dhcp-common.h"
#include "networkd-dhcp4.h"
#include "networkd-dhcp6.h"
#include "networkd-ipv6ll.h"
#include "networkd-lldp-rx.h"
#include "networkd-ndisc.h"
#include "networkd-radv.h"
#include "networkd-sysctl.h"
#include "networkd-util.h"
#include "ordered-set.h"
#include "resolve-util.h"
#include "socket-netlink.h"
typedef enum KeepConfiguration {
KEEP_CONFIGURATION_NO = 0,
KEEP_CONFIGURATION_DHCP_ON_START = 1 << 0,
KEEP_CONFIGURATION_DHCP_ON_STOP = 1 << 1,
KEEP_CONFIGURATION_DHCP = KEEP_CONFIGURATION_DHCP_ON_START | KEEP_CONFIGURATION_DHCP_ON_STOP,
KEEP_CONFIGURATION_STATIC = 1 << 2,
KEEP_CONFIGURATION_YES = KEEP_CONFIGURATION_DHCP | KEEP_CONFIGURATION_STATIC,
_KEEP_CONFIGURATION_MAX,
_KEEP_CONFIGURATION_INVALID = -EINVAL,
} KeepConfiguration;
typedef enum ActivationPolicy {
ACTIVATION_POLICY_UP,
ACTIVATION_POLICY_ALWAYS_UP,
ACTIVATION_POLICY_MANUAL,
ACTIVATION_POLICY_ALWAYS_DOWN,
ACTIVATION_POLICY_DOWN,
ACTIVATION_POLICY_BOUND,
_ACTIVATION_POLICY_MAX,
_ACTIVATION_POLICY_INVALID = -EINVAL,
} ActivationPolicy;
typedef struct Manager Manager;
typedef struct NetworkDHCPServerEmitAddress {
bool emit;
struct in_addr *addresses;
size_t n_addresses;
} NetworkDHCPServerEmitAddress;
struct Network {
Manager *manager;
unsigned n_ref;
char *name;
char *filename;
char **dropins;
Hashmap *stats_by_path;
char *description;
/* [Match] section */
NetMatch match;
LIST_HEAD(Condition, conditions);
/* Master or stacked netdevs */
bool keep_master;
NetDev *batadv;
NetDev *bridge;
NetDev *bond;
NetDev *vrf;
NetDev *xfrm;
Hashmap *stacked_netdevs;
char *batadv_name;
char *bridge_name;
char *bond_name;
char *vrf_name;
Hashmap *stacked_netdev_names;
/* [Link] section */
struct hw_addr_data hw_addr;
uint32_t mtu;
int32_t group;
int arp;
int multicast;
int allmulticast;
int promiscuous;
bool unmanaged;
int required_for_online; /* Is this network required to be considered online? */
LinkOperationalStateRange required_operstate_for_online;
AddressFamily required_family_for_online;
ActivationPolicy activation_policy;
/* misc settings */
bool configure_without_carrier;
bool ignore_carrier_loss_set;
usec_t ignore_carrier_loss_usec; /* timespan */
KeepConfiguration keep_configuration;
char **bind_carrier;
bool default_route_on_device;
AddressFamily ip_masquerade;
/* DHCP Client Support */
AddressFamily dhcp;
DHCPClientIdentifier dhcp_client_identifier;
DUID dhcp_duid;
uint32_t dhcp_iaid;
bool dhcp_iaid_set;
char *dhcp_vendor_class_identifier;
char *dhcp_mudurl;
char **dhcp_user_class;
char *dhcp_hostname;
char *dhcp_label;
uint64_t dhcp_max_attempts;
uint32_t dhcp_route_metric;
bool dhcp_route_metric_set;
uint32_t dhcp_route_table;
bool dhcp_route_table_set;
uint32_t dhcp_fallback_lease_lifetime;
uint32_t dhcp_route_mtu;
uint16_t dhcp_client_port;
int dhcp_critical;
int dhcp_ip_service_type;
int dhcp_socket_priority;
bool dhcp_socket_priority_set;
bool dhcp_anonymize;
bool dhcp_send_hostname;
int dhcp_broadcast;
bool dhcp_use_dns;
bool dhcp_use_dns_set;
bool dhcp_routes_to_dns;
bool dhcp_use_ntp;
bool dhcp_use_ntp_set;
bool dhcp_routes_to_ntp;
bool dhcp_use_sip;
bool dhcp_use_captive_portal;
bool dhcp_use_mtu;
bool dhcp_use_routes;
int dhcp_use_gateway;
bool dhcp_quickack;
bool dhcp_use_timezone;
bool dhcp_use_hostname;
bool dhcp_use_6rd;
bool dhcp_send_release;
bool dhcp_send_decline;
DHCPUseDomains dhcp_use_domains;
bool dhcp_use_domains_set;
Set *dhcp_deny_listed_ip;
Set *dhcp_allow_listed_ip;
Set *dhcp_request_options;
OrderedHashmap *dhcp_client_send_options;
OrderedHashmap *dhcp_client_send_vendor_options;
char *dhcp_netlabel;
/* DHCPv6 Client support */
bool dhcp6_use_address;
bool dhcp6_use_pd_prefix;
bool dhcp6_use_dns;
bool dhcp6_use_dns_set;
bool dhcp6_use_hostname;
bool dhcp6_use_ntp;
bool dhcp6_use_ntp_set;
bool dhcp6_use_captive_portal;
bool dhcp6_use_rapid_commit;
DHCPUseDomains dhcp6_use_domains;
bool dhcp6_use_domains_set;
uint32_t dhcp6_iaid;
bool dhcp6_iaid_set;
bool dhcp6_iaid_set_explicitly;
DUID dhcp6_duid;
uint8_t dhcp6_pd_prefix_length;
struct in6_addr dhcp6_pd_prefix_hint;
char *dhcp6_mudurl;
char **dhcp6_user_class;
char **dhcp6_vendor_class;
DHCP6ClientStartMode dhcp6_client_start_mode;
OrderedHashmap *dhcp6_client_send_options;
OrderedHashmap *dhcp6_client_send_vendor_options;
Set *dhcp6_request_options;
char *dhcp6_netlabel;
bool dhcp6_send_release;
/* DHCP Server Support */
bool dhcp_server;
bool dhcp_server_bind_to_interface;
unsigned char dhcp_server_address_prefixlen;
struct in_addr dhcp_server_address;
int dhcp_server_uplink_index;
char *dhcp_server_uplink_name;
struct in_addr dhcp_server_relay_target;
char *dhcp_server_relay_agent_circuit_id;
char *dhcp_server_relay_agent_remote_id;
NetworkDHCPServerEmitAddress dhcp_server_emit[_SD_DHCP_LEASE_SERVER_TYPE_MAX];
bool dhcp_server_emit_router;
struct in_addr dhcp_server_router;
bool dhcp_server_emit_timezone;
char *dhcp_server_timezone;
usec_t dhcp_server_default_lease_time_usec, dhcp_server_max_lease_time_usec;
uint32_t dhcp_server_pool_offset;
uint32_t dhcp_server_pool_size;
OrderedHashmap *dhcp_server_send_options;
OrderedHashmap *dhcp_server_send_vendor_options;
struct in_addr dhcp_server_boot_server_address;
char *dhcp_server_boot_server_name;
char *dhcp_server_boot_filename;
/* link-local addressing support */
AddressFamily link_local;
IPv6LinkLocalAddressGenMode ipv6ll_address_gen_mode;
struct in6_addr ipv6ll_stable_secret;
struct in_addr ipv4ll_start_address;
bool ipv4ll_route;
/* IPv6 RA support */
RADVPrefixDelegation router_prefix_delegation;
usec_t router_lifetime_usec;
uint8_t router_preference;
bool router_managed;
bool router_other_information;
bool router_emit_dns;
bool router_emit_domains;
usec_t router_dns_lifetime_usec;
struct in6_addr *router_dns;
unsigned n_router_dns;
OrderedSet *router_search_domains;
int router_uplink_index;
char *router_uplink_name;
/* DHCP Prefix Delegation support */
int dhcp_pd;
bool dhcp_pd_announce;
bool dhcp_pd_assign;
bool dhcp_pd_manage_temporary_address;
int64_t dhcp_pd_subnet_id;
uint32_t dhcp_pd_route_metric;
Set *dhcp_pd_tokens;
int dhcp_pd_uplink_index;
char *dhcp_pd_uplink_name;
char *dhcp_pd_netlabel;
/* Bridge Support */
int use_bpdu;
int hairpin;
int isolated;
int fast_leave;
int allow_port_to_be_root;
int unicast_flood;
int multicast_flood;
int multicast_to_unicast;
int neighbor_suppression;
int learning;
int bridge_proxy_arp;
int bridge_proxy_arp_wifi;
uint32_t cost;
uint16_t priority;
MulticastRouter multicast_router;
/* Bridge VLAN */
bool use_br_vlan;
uint16_t pvid;
uint32_t br_vid_bitmap[BRIDGE_VLAN_BITMAP_LEN];
uint32_t br_untagged_bitmap[BRIDGE_VLAN_BITMAP_LEN];
/* CAN support */
uint32_t can_bitrate;
unsigned can_sample_point;
nsec_t can_time_quanta_ns;
uint32_t can_propagation_segment;
uint32_t can_phase_buffer_segment_1;
uint32_t can_phase_buffer_segment_2;
uint32_t can_sync_jump_width;
uint32_t can_data_bitrate;
unsigned can_data_sample_point;
nsec_t can_data_time_quanta_ns;
uint32_t can_data_propagation_segment;
uint32_t can_data_phase_buffer_segment_1;
uint32_t can_data_phase_buffer_segment_2;
uint32_t can_data_sync_jump_width;
usec_t can_restart_us;
uint32_t can_control_mode_mask;
uint32_t can_control_mode_flags;
uint16_t can_termination;
bool can_termination_set;
/* IPoIB support */
IPoIBMode ipoib_mode;
int ipoib_umcast;
/* sysctl settings */
AddressFamily ip_forward;
int ipv4_accept_local;
int ipv4_route_localnet;
int ipv6_dad_transmits;
int ipv6_hop_limit;
int proxy_arp;
uint32_t ipv6_mtu;
IPv6PrivacyExtensions ipv6_privacy_extensions;
int ipv6_proxy_ndp;
Set *ipv6_proxy_ndp_addresses;
/* IPv6 accept RA */
int ipv6_accept_ra;
bool ipv6_accept_ra_use_dns;
bool ipv6_accept_ra_use_gateway;
bool ipv6_accept_ra_use_route_prefix;
bool ipv6_accept_ra_use_autonomous_prefix;
bool ipv6_accept_ra_use_onlink_prefix;
bool ipv6_accept_ra_use_mtu;
bool ipv6_accept_ra_quickack;
bool ipv6_accept_ra_use_captive_portal;
bool active_slave;
bool primary_slave;
DHCPUseDomains ipv6_accept_ra_use_domains;
IPv6AcceptRAStartDHCP6Client ipv6_accept_ra_start_dhcp6_client;
uint32_t ipv6_accept_ra_route_table;
bool ipv6_accept_ra_route_table_set;
uint32_t ipv6_accept_ra_route_metric_high;
uint32_t ipv6_accept_ra_route_metric_medium;
uint32_t ipv6_accept_ra_route_metric_low;
bool ipv6_accept_ra_route_metric_set;
Set *ndisc_deny_listed_router;
Set *ndisc_allow_listed_router;
Set *ndisc_deny_listed_prefix;
Set *ndisc_allow_listed_prefix;
Set *ndisc_deny_listed_route_prefix;
Set *ndisc_allow_listed_route_prefix;
Set *ndisc_tokens;
char *ndisc_netlabel;
/* LLDP support */
LLDPMode lldp_mode; /* LLDP reception */
sd_lldp_multicast_mode_t lldp_multicast_mode; /* LLDP transmission */
char *lldp_mudurl; /* LLDP MUD URL */
OrderedHashmap *addresses_by_section;
Hashmap *routes_by_section;
Hashmap *nexthops_by_section;
Hashmap *bridge_fdb_entries_by_section;
Hashmap *bridge_mdb_entries_by_section;
Hashmap *neighbors_by_section;
Hashmap *address_labels_by_section;
Hashmap *prefixes_by_section;
Hashmap *route_prefixes_by_section;
Hashmap *rules_by_section;
Hashmap *dhcp_static_leases_by_section;
Hashmap *qdiscs_by_section;
Hashmap *tclasses_by_section;
OrderedHashmap *sr_iov_by_section;
/* All kinds of DNS configuration */
struct in_addr_full **dns;
unsigned n_dns;
OrderedSet *search_domains, *route_domains;
int dns_default_route;
ResolveSupport llmnr;
ResolveSupport mdns;
DnssecMode dnssec_mode;
DnsOverTlsMode dns_over_tls_mode;
Set *dnssec_negative_trust_anchors;
/* NTP */
char **ntp;
};
Network *network_ref(Network *network);
Network *network_unref(Network *network);
DEFINE_TRIVIAL_CLEANUP_FUNC(Network*, network_unref);
int network_load(Manager *manager, OrderedHashmap **networks);
int network_reload(Manager *manager);
int network_load_one(Manager *manager, OrderedHashmap **networks, const char *filename);
int network_verify(Network *network);
int manager_build_dhcp_pd_subnet_ids(Manager *manager);
int network_get_by_name(Manager *manager, const char *name, Network **ret);
void network_apply_anonymize_if_set(Network *network);
bool network_has_static_ipv6_configurations(Network *network);
CONFIG_PARSER_PROTOTYPE(config_parse_stacked_netdev);
CONFIG_PARSER_PROTOTYPE(config_parse_tunnel);
CONFIG_PARSER_PROTOTYPE(config_parse_domains);
CONFIG_PARSER_PROTOTYPE(config_parse_dns);
CONFIG_PARSER_PROTOTYPE(config_parse_timezone);
CONFIG_PARSER_PROTOTYPE(config_parse_dnssec_negative_trust_anchors);
CONFIG_PARSER_PROTOTYPE(config_parse_ntp);
CONFIG_PARSER_PROTOTYPE(config_parse_required_for_online);
CONFIG_PARSER_PROTOTYPE(config_parse_required_family_for_online);
CONFIG_PARSER_PROTOTYPE(config_parse_keep_configuration);
CONFIG_PARSER_PROTOTYPE(config_parse_activation_policy);
CONFIG_PARSER_PROTOTYPE(config_parse_link_group);
CONFIG_PARSER_PROTOTYPE(config_parse_ignore_carrier_loss);
const struct ConfigPerfItem* network_network_gperf_lookup(const char *key, GPERF_LEN_TYPE length);
const char* keep_configuration_to_string(KeepConfiguration i) _const_;
KeepConfiguration keep_configuration_from_string(const char *s) _pure_;
const char* activation_policy_to_string(ActivationPolicy i) _const_;
ActivationPolicy activation_policy_from_string(const char *s) _pure_;
| 14,057 | 33.121359 | 110 |
h
|
null |
systemd-main/src/network/networkd-nexthop.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later
* Copyright © 2019 VMware, Inc.
*/
#pragma once
#include <inttypes.h>
#include "sd-netlink.h"
#include "conf-parser.h"
#include "hashmap.h"
#include "in-addr-util.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Network Network;
typedef struct NextHop {
Network *network;
Manager *manager;
Link *link;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
uint8_t protocol;
uint32_t id;
bool blackhole;
int family;
union in_addr_union gw;
uint8_t flags;
int onlink; /* Only used in conf parser and nexthop_section_verify(). */
Hashmap *group;
} NextHop;
NextHop *nexthop_free(NextHop *nexthop);
void network_drop_invalid_nexthops(Network *network);
int link_drop_managed_nexthops(Link *link);
int link_drop_foreign_nexthops(Link *link);
void link_foreignize_nexthops(Link *link);
int link_request_static_nexthops(Link *link, bool only_ipv4);
int manager_get_nexthop_by_id(Manager *manager, uint32_t id, NextHop **ret);
int manager_rtnl_process_nexthop(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(NextHop, nexthop);
CONFIG_PARSER_PROTOTYPE(config_parse_nexthop_id);
CONFIG_PARSER_PROTOTYPE(config_parse_nexthop_gateway);
CONFIG_PARSER_PROTOTYPE(config_parse_nexthop_family);
CONFIG_PARSER_PROTOTYPE(config_parse_nexthop_onlink);
CONFIG_PARSER_PROTOTYPE(config_parse_nexthop_blackhole);
CONFIG_PARSER_PROTOTYPE(config_parse_nexthop_group);
| 1,645 | 26.433333 | 92 |
h
|
null |
systemd-main/src/network/networkd-queue.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include "netdev.h"
#include "netlink-util.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-queue.h"
#include "string-table.h"
static Request *request_free(Request *req) {
if (!req)
return NULL;
/* To prevent from triggering assertions in the hash and compare functions, remove this request
* before freeing userdata below. */
if (req->manager)
ordered_set_remove(req->manager->request_queue, req);
if (req->free_func)
req->free_func(req->userdata);
if (req->counter)
(*req->counter)--;
link_unref(req->link); /* link may be NULL, but link_unref() can handle it gracefully. */
return mfree(req);
}
DEFINE_TRIVIAL_REF_UNREF_FUNC(Request, request, request_free);
DEFINE_TRIVIAL_DESTRUCTOR(request_destroy_callback, Request, request_unref);
void request_detach(Manager *manager, Request *req) {
assert(manager);
if (!req)
return;
req = ordered_set_remove(manager->request_queue, req);
if (!req)
return;
req->manager = NULL;
request_unref(req);
}
static void request_hash_func(const Request *req, struct siphash *state) {
assert(req);
assert(state);
siphash24_compress_boolean(req->link, state);
if (req->link)
siphash24_compress(&req->link->ifindex, sizeof(req->link->ifindex), state);
siphash24_compress(&req->type, sizeof(req->type), state);
siphash24_compress(&req->hash_func, sizeof(req->hash_func), state);
siphash24_compress(&req->compare_func, sizeof(req->compare_func), state);
if (req->hash_func)
req->hash_func(req->userdata, state);
}
static int request_compare_func(const struct Request *a, const struct Request *b) {
int r;
assert(a);
assert(b);
r = CMP(!!a->link, !!b->link);
if (r != 0)
return r;
if (a->link) {
r = CMP(a->link->ifindex, b->link->ifindex);
if (r != 0)
return r;
}
r = CMP(a->type, b->type);
if (r != 0)
return r;
r = CMP(PTR_TO_UINT64(a->hash_func), PTR_TO_UINT64(b->hash_func));
if (r != 0)
return r;
r = CMP(PTR_TO_UINT64(a->compare_func), PTR_TO_UINT64(b->compare_func));
if (r != 0)
return r;
if (a->compare_func)
return a->compare_func(a->userdata, b->userdata);
return 0;
}
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
request_hash_ops,
Request,
request_hash_func,
request_compare_func,
request_unref);
static int request_new(
Manager *manager,
Link *link,
RequestType type,
void *userdata,
mfree_func_t free_func,
hash_func_t hash_func,
compare_func_t compare_func,
request_process_func_t process,
unsigned *counter,
request_netlink_handler_t netlink_handler,
Request **ret) {
_cleanup_(request_unrefp) Request *req = NULL;
Request *existing;
int r;
assert(manager);
assert(process);
req = new(Request, 1);
if (!req) {
if (free_func)
free_func(userdata);
return -ENOMEM;
}
*req = (Request) {
.n_ref = 1,
.link = link_ref(link), /* link may be NULL, but link_ref() handles it gracefully. */
.type = type,
.userdata = userdata,
.free_func = free_func,
.hash_func = hash_func,
.compare_func = compare_func,
.process = process,
.netlink_handler = netlink_handler,
};
existing = ordered_set_get(manager->request_queue, req);
if (existing) {
if (ret)
*ret = existing;
return 0;
}
r = ordered_set_ensure_put(&manager->request_queue, &request_hash_ops, req);
if (r < 0)
return r;
req->manager = manager;
req->counter = counter;
if (req->counter)
(*req->counter)++;
if (ret)
*ret = req;
TAKE_PTR(req);
return 1;
}
int netdev_queue_request(
NetDev *netdev,
request_process_func_t process,
Request **ret) {
assert(netdev);
return request_new(netdev->manager, NULL, REQUEST_TYPE_NETDEV_INDEPENDENT,
netdev_ref(netdev), (mfree_func_t) netdev_unref,
trivial_hash_func, trivial_compare_func,
process, NULL, NULL, ret);
}
int link_queue_request_full(
Link *link,
RequestType type,
void *userdata,
mfree_func_t free_func,
hash_func_t hash_func,
compare_func_t compare_func,
request_process_func_t process,
unsigned *counter,
request_netlink_handler_t netlink_handler,
Request **ret) {
assert(link);
return request_new(link->manager, link, type,
userdata, free_func, hash_func, compare_func,
process, counter, netlink_handler, ret);
}
int manager_process_requests(sd_event_source *s, void *userdata) {
Manager *manager = ASSERT_PTR(userdata);
int r;
for (;;) {
bool processed = false;
Request *req;
ORDERED_SET_FOREACH(req, manager->request_queue) {
_unused_ _cleanup_(request_unrefp) Request *ref = request_ref(req);
_cleanup_(link_unrefp) Link *link = link_ref(req->link);
assert(req->process);
r = req->process(req, link, req->userdata);
if (r == 0)
continue;
processed = true;
request_detach(manager, req);
if (r < 0 && link) {
link_enter_failed(link);
/* link_enter_failed() may remove multiple requests,
* hence we need to exit from the loop. */
break;
}
}
/* When at least one request is processed, then another request may be ready now. */
if (!processed)
break;
}
return 0;
}
static int request_netlink_handler(sd_netlink *nl, sd_netlink_message *m, Request *req) {
assert(req);
if (req->counter) {
assert(*req->counter > 0);
(*req->counter)--;
req->counter = NULL; /* To prevent double decrement on free. */
}
if (req->link && IN_SET(req->link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
return 0;
if (req->netlink_handler)
return req->netlink_handler(nl, m, req, req->link, req->userdata);
return 0;
}
int request_call_netlink_async(sd_netlink *nl, sd_netlink_message *m, Request *req) {
int r;
assert(nl);
assert(m);
assert(req);
r = netlink_call_async(nl, NULL, m, request_netlink_handler, request_destroy_callback, req);
if (r < 0)
return r;
request_ref(req);
return 0;
}
static const char *const request_type_table[_REQUEST_TYPE_MAX] = {
[REQUEST_TYPE_ACTIVATE_LINK] = "activate link",
[REQUEST_TYPE_ADDRESS] = "address",
[REQUEST_TYPE_ADDRESS_LABEL] = "address label",
[REQUEST_TYPE_BRIDGE_FDB] = "bridge FDB",
[REQUEST_TYPE_BRIDGE_MDB] = "bridge MDB",
[REQUEST_TYPE_DHCP_SERVER] = "DHCP server",
[REQUEST_TYPE_DHCP4_CLIENT] = "DHCPv4 client",
[REQUEST_TYPE_DHCP6_CLIENT] = "DHCPv6 client",
[REQUEST_TYPE_IPV6_PROXY_NDP] = "IPv6 proxy NDP",
[REQUEST_TYPE_NDISC] = "NDisc",
[REQUEST_TYPE_NEIGHBOR] = "neighbor",
[REQUEST_TYPE_NETDEV_INDEPENDENT] = "independent netdev",
[REQUEST_TYPE_NETDEV_STACKED] = "stacked netdev",
[REQUEST_TYPE_NEXTHOP] = "nexthop",
[REQUEST_TYPE_RADV] = "RADV",
[REQUEST_TYPE_ROUTE] = "route",
[REQUEST_TYPE_ROUTING_POLICY_RULE] = "routing policy rule",
[REQUEST_TYPE_SET_LINK_ADDRESS_GENERATION_MODE] = "IPv6LL address generation mode",
[REQUEST_TYPE_SET_LINK_BOND] = "bond configurations",
[REQUEST_TYPE_SET_LINK_BRIDGE] = "bridge configurations",
[REQUEST_TYPE_SET_LINK_BRIDGE_VLAN] = "bridge VLAN configurations",
[REQUEST_TYPE_SET_LINK_CAN] = "CAN interface configurations",
[REQUEST_TYPE_SET_LINK_FLAGS] = "link flags",
[REQUEST_TYPE_SET_LINK_GROUP] = "interface group",
[REQUEST_TYPE_SET_LINK_IPOIB] = "IPoIB configurations",
[REQUEST_TYPE_SET_LINK_MAC] = "MAC address",
[REQUEST_TYPE_SET_LINK_MASTER] = "master interface",
[REQUEST_TYPE_SET_LINK_MTU] = "MTU",
[REQUEST_TYPE_SRIOV] = "SR-IOV",
[REQUEST_TYPE_TC_QDISC] = "QDisc",
[REQUEST_TYPE_TC_CLASS] = "TClass",
[REQUEST_TYPE_UP_DOWN] = "bring link up or down",
};
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(request_type, RequestType);
| 10,498 | 33.422951 | 103 |
c
|
null |
systemd-main/src/network/networkd-queue.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include "sd-event.h"
#include "sd-netlink.h"
#include "alloc-util.h"
#include "hash-funcs.h"
typedef struct Link Link;
typedef struct NetDev NetDev;
typedef struct Manager Manager;
typedef struct Request Request;
typedef int (*request_process_func_t)(Request *req, Link *link, void *userdata);
typedef int (*request_netlink_handler_t)(sd_netlink *nl, sd_netlink_message *m, Request *req, Link *link, void *userdata);
typedef enum RequestType {
REQUEST_TYPE_ACTIVATE_LINK,
REQUEST_TYPE_ADDRESS,
REQUEST_TYPE_ADDRESS_LABEL,
REQUEST_TYPE_BRIDGE_FDB,
REQUEST_TYPE_BRIDGE_MDB,
REQUEST_TYPE_DHCP_SERVER,
REQUEST_TYPE_DHCP4_CLIENT,
REQUEST_TYPE_DHCP6_CLIENT,
REQUEST_TYPE_IPV6_PROXY_NDP,
REQUEST_TYPE_NDISC,
REQUEST_TYPE_NEIGHBOR,
REQUEST_TYPE_NETDEV_INDEPENDENT,
REQUEST_TYPE_NETDEV_STACKED,
REQUEST_TYPE_NEXTHOP,
REQUEST_TYPE_RADV,
REQUEST_TYPE_ROUTE,
REQUEST_TYPE_ROUTING_POLICY_RULE,
REQUEST_TYPE_SET_LINK_ADDRESS_GENERATION_MODE, /* Setting IPv6LL address generation mode. */
REQUEST_TYPE_SET_LINK_BOND, /* Setting bond configs. */
REQUEST_TYPE_SET_LINK_BRIDGE, /* Setting bridge configs. */
REQUEST_TYPE_SET_LINK_BRIDGE_VLAN, /* Setting bridge VLAN configs. */
REQUEST_TYPE_SET_LINK_CAN, /* Setting CAN interface configs. */
REQUEST_TYPE_SET_LINK_FLAGS, /* Setting IFF_NOARP or friends. */
REQUEST_TYPE_SET_LINK_GROUP, /* Setting interface group. */
REQUEST_TYPE_SET_LINK_IPOIB, /* Setting IPoIB configs. */
REQUEST_TYPE_SET_LINK_MAC, /* Setting MAC address. */
REQUEST_TYPE_SET_LINK_MASTER, /* Setting IFLA_MASTER. */
REQUEST_TYPE_SET_LINK_MTU, /* Setting MTU. */
REQUEST_TYPE_SRIOV,
REQUEST_TYPE_TC_CLASS,
REQUEST_TYPE_TC_QDISC,
REQUEST_TYPE_UP_DOWN,
_REQUEST_TYPE_MAX,
_REQUEST_TYPE_INVALID = -EINVAL,
} RequestType;
struct Request {
unsigned n_ref;
Manager *manager; /* must be non-NULL */
Link *link; /* can be NULL */
RequestType type;
/* Target object, e.g. Address, Route, NetDev, and so on. */
void *userdata;
/* freeing userdata when the request is completed or failed. */
mfree_func_t free_func;
/* hash and compare functions for userdata, used for dedup requests. */
hash_func_t hash_func;
compare_func_t compare_func;
/* Checks the request dependencies, and then processes this request, e.g. call address_configure().
* Return 1 when processed, 0 when its dependencies not resolved, and negative errno on failure. */
request_process_func_t process;
/* incremented when requested, decremented when request is completed or failed. */
unsigned *counter;
/* called in netlink handler, the 'counter' is decremented before this is called.
* If this is specified, then the 'process' function must increment the reference of this
* request, and pass this request to the netlink_call_async(), and set the destroy function
* to the slot. */
request_netlink_handler_t netlink_handler;
};
Request *request_ref(Request *req);
Request *request_unref(Request *req);
DEFINE_TRIVIAL_CLEANUP_FUNC(Request*, request_unref);
void request_detach(Manager *manager, Request *req);
int netdev_queue_request(
NetDev *netdev,
request_process_func_t process,
Request **ret);
int link_queue_request_full(
Link *link,
RequestType type,
void *userdata,
mfree_func_t free_func,
hash_func_t hash_func,
compare_func_t compare_func,
request_process_func_t process,
unsigned *counter,
request_netlink_handler_t netlink_handler,
Request **ret);
static inline int link_queue_request(
Link *link,
RequestType type,
request_process_func_t process,
Request **ret) {
return link_queue_request_full(link, type, NULL, NULL, NULL, NULL,
process, NULL, NULL, ret);
}
#define link_queue_request_safe(link, type, userdata, free_func, hash_func, compare_func, process, counter, netlink_handler, ret) \
({ \
typeof(userdata) (*_f)(typeof(userdata)) = (free_func); \
void (*_h)(const typeof(*userdata)*, struct siphash*) = (hash_func); \
int (*_c)(const typeof(*userdata)*, const typeof(*userdata)*) = (compare_func); \
int (*_p)(Request*, Link*, typeof(userdata)) = (process); \
int (*_n)(sd_netlink*, sd_netlink_message*, Request*, Link*, typeof(userdata)) = (netlink_handler); \
\
link_queue_request_full(link, type, userdata, \
(mfree_func_t) _f, \
(hash_func_t) _h, \
(compare_func_t) _c, \
(request_process_func_t) _p, \
counter, \
(request_netlink_handler_t) _n, \
ret); \
})
int manager_process_requests(sd_event_source *s, void *userdata);
int request_call_netlink_async(sd_netlink *nl, sd_netlink_message *m, Request *req);
const char* request_type_to_string(RequestType t) _const_;
| 6,106 | 42.621429 | 131 |
h
|
null |
systemd-main/src/network/networkd-radv.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
/***
Copyright © 2017 Intel Corporation. All rights reserved.
***/
#include <inttypes.h>
#include <stdbool.h>
#include "sd-radv.h"
#include "in-addr-util.h"
#include "conf-parser.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Network Network;
typedef enum RADVPrefixDelegation {
RADV_PREFIX_DELEGATION_NONE = 0,
RADV_PREFIX_DELEGATION_STATIC = 1 << 0,
RADV_PREFIX_DELEGATION_DHCP6 = 1 << 1,
RADV_PREFIX_DELEGATION_BOTH = RADV_PREFIX_DELEGATION_STATIC | RADV_PREFIX_DELEGATION_DHCP6,
_RADV_PREFIX_DELEGATION_MAX,
_RADV_PREFIX_DELEGATION_INVALID = -EINVAL,
} RADVPrefixDelegation;
typedef struct Prefix {
Network *network;
ConfigSection *section;
struct in6_addr prefix;
uint8_t prefixlen;
usec_t preferred_lifetime;
usec_t valid_lifetime;
bool onlink;
bool address_auto_configuration;
bool assign;
uint32_t route_metric;
Set *tokens;
} Prefix;
typedef struct RoutePrefix {
Network *network;
ConfigSection *section;
struct in6_addr prefix;
uint8_t prefixlen;
usec_t lifetime;
} RoutePrefix;
Prefix *prefix_free(Prefix *prefix);
RoutePrefix *route_prefix_free(RoutePrefix *prefix);
void network_drop_invalid_prefixes(Network *network);
void network_drop_invalid_route_prefixes(Network *network);
void network_adjust_radv(Network *network);
int link_request_radv_addresses(Link *link);
bool link_radv_enabled(Link *link);
int radv_start(Link *link);
int radv_update_mac(Link *link);
int radv_add_prefix(Link *link, const struct in6_addr *prefix, uint8_t prefix_len,
usec_t lifetime_preferred_usec, usec_t lifetime_valid_usec);
int link_request_radv(Link *link);
const char* radv_prefix_delegation_to_string(RADVPrefixDelegation i) _const_;
RADVPrefixDelegation radv_prefix_delegation_from_string(const char *s) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_router_prefix_delegation);
CONFIG_PARSER_PROTOTYPE(config_parse_router_lifetime);
CONFIG_PARSER_PROTOTYPE(config_parse_router_preference);
CONFIG_PARSER_PROTOTYPE(config_parse_prefix);
CONFIG_PARSER_PROTOTYPE(config_parse_prefix_boolean);
CONFIG_PARSER_PROTOTYPE(config_parse_prefix_lifetime);
CONFIG_PARSER_PROTOTYPE(config_parse_prefix_metric);
CONFIG_PARSER_PROTOTYPE(config_parse_prefix_token);
CONFIG_PARSER_PROTOTYPE(config_parse_radv_dns);
CONFIG_PARSER_PROTOTYPE(config_parse_radv_search_domains);
CONFIG_PARSER_PROTOTYPE(config_parse_route_prefix);
CONFIG_PARSER_PROTOTYPE(config_parse_route_prefix_lifetime);
| 2,679 | 29.804598 | 101 |
h
|
null |
systemd-main/src/network/networkd-route-util.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include "conf-parser.h"
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Address Address;
unsigned routes_max(void);
int manager_find_uplink(Manager *m, int family, Link *exclude, Link **ret);
bool gateway_is_ready(Link *link, bool onlink, int family, const union in_addr_union *gw);
int link_address_is_reachable(
Link *link,
int family,
const union in_addr_union *address,
const union in_addr_union *prefsrc, /* optional */
Address **ret);
int manager_address_is_reachable(
Manager *manager,
int family,
const union in_addr_union *address,
const union in_addr_union *prefsrc, /* optional */
Address **ret);
int route_type_from_string(const char *s) _pure_;
const char *route_type_to_string(int t) _const_;
int route_scope_from_string(const char *s);
int route_scope_to_string_alloc(int t, char **ret);
int route_protocol_from_string(const char *s);
int route_protocol_to_string_alloc(int t, char **ret);
int route_protocol_full_from_string(const char *s);
int route_protocol_full_to_string_alloc(int t, char **ret);
int route_flags_to_string_alloc(uint32_t flags, char **ret);
int manager_get_route_table_from_string(const Manager *m, const char *table, uint32_t *ret);
int manager_get_route_table_to_string(const Manager *m, uint32_t table, bool append_num, char **ret);
CONFIG_PARSER_PROTOTYPE(config_parse_route_table_names);
| 1,635 | 31.72 | 101 |
h
|
null |
systemd-main/src/network/networkd-route.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <stdbool.h>
#include "sd-netlink.h"
#include "conf-parser.h"
#include "in-addr-util.h"
#include "networkd-link.h"
#include "networkd-util.h"
typedef struct Manager Manager;
typedef struct Network Network;
typedef struct Request Request;
typedef struct Route Route;
typedef int (*route_netlink_handler_t)(
sd_netlink *rtnl,
sd_netlink_message *m,
Request *req,
Link *link,
Route *route);
struct Route {
Link *link;
Manager *manager;
Network *network;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
union in_addr_union provider; /* DHCP server or router address */
int family;
int gw_family;
uint32_t gw_weight;
int quickack;
int fast_open_no_cookie;
int ttl_propagate;
unsigned char dst_prefixlen;
unsigned char src_prefixlen;
unsigned char scope;
unsigned char protocol; /* RTPROT_* */
unsigned char type; /* RTN_* */
unsigned char tos;
uint32_t priority; /* note that ip(8) calls this 'metric' */
uint32_t table;
uint32_t mtu;
uint32_t initcwnd;
uint32_t initrwnd;
uint32_t advmss;
char *tcp_congestion_control_algo;
unsigned char pref;
unsigned flags;
int gateway_onlink; /* Only used in conf parser and route_section_verify(). */
uint32_t nexthop_id;
bool scope_set:1;
bool table_set:1;
bool priority_set:1;
bool protocol_set:1;
bool pref_set:1;
bool gateway_from_dhcp_or_ra:1;
union in_addr_union gw;
union in_addr_union dst;
union in_addr_union src;
union in_addr_union prefsrc;
OrderedSet *multipath_routes;
/* This is an absolute point in time, and NOT a timespan/duration.
* Must be specified with clock_boottime_or_monotonic(). */
usec_t lifetime_usec;
/* Used when kernel does not support RTA_EXPIRES attribute. */
sd_event_source *expire;
};
extern const struct hash_ops route_hash_ops;
int route_new(Route **ret);
Route *route_free(Route *route);
DEFINE_SECTION_CLEANUP_FUNCTIONS(Route, route_free);
int route_dup(const Route *src, Route **ret);
int route_configure_handler_internal(sd_netlink *rtnl, sd_netlink_message *m, Link *link, const char *error_msg);
int route_remove(Route *route);
int route_remove_and_drop(Route *route);
int route_get(Manager *manager, Link *link, const Route *in, Route **ret);
int link_drop_managed_routes(Link *link);
int link_drop_foreign_routes(Link *link);
void link_foreignize_routes(Link *link);
void route_cancel_request(Route *route, Link *link);
int link_request_route(
Link *link,
Route *route,
bool consume_object,
unsigned *message_counter,
route_netlink_handler_t netlink_handler,
Request **ret);
int link_request_static_routes(Link *link, bool only_ipv4);
int manager_rtnl_process_route(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
int network_add_ipv4ll_route(Network *network);
int network_add_default_route_on_device(Network *network);
void network_drop_invalid_routes(Network *network);
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(Route, route);
void link_mark_routes(Link *link, NetworkConfigSource source);
CONFIG_PARSER_PROTOTYPE(config_parse_gateway);
CONFIG_PARSER_PROTOTYPE(config_parse_preferred_src);
CONFIG_PARSER_PROTOTYPE(config_parse_destination);
CONFIG_PARSER_PROTOTYPE(config_parse_route_priority);
CONFIG_PARSER_PROTOTYPE(config_parse_route_scope);
CONFIG_PARSER_PROTOTYPE(config_parse_route_table);
CONFIG_PARSER_PROTOTYPE(config_parse_route_boolean);
CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_route_preference);
CONFIG_PARSER_PROTOTYPE(config_parse_route_protocol);
CONFIG_PARSER_PROTOTYPE(config_parse_route_type);
CONFIG_PARSER_PROTOTYPE(config_parse_tcp_window);
CONFIG_PARSER_PROTOTYPE(config_parse_route_mtu);
CONFIG_PARSER_PROTOTYPE(config_parse_multipath_route);
CONFIG_PARSER_PROTOTYPE(config_parse_tcp_congestion);
CONFIG_PARSER_PROTOTYPE(config_parse_tcp_advmss);
CONFIG_PARSER_PROTOTYPE(config_parse_route_nexthop);
| 4,405 | 32.633588 | 113 |
h
|
null |
systemd-main/src/network/networkd-routing-policy-rule.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <linux/fib_rules.h>
#include <stdbool.h>
#include "conf-parser.h"
#include "in-addr-util.h"
#include "networkd-util.h"
typedef struct Link Link;
typedef struct Manager Manager;
typedef struct Network Network;
typedef struct RoutingPolicyRule {
Manager *manager;
Network *network;
ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
bool invert_rule;
bool priority_set;
uint8_t tos;
uint8_t type;
uint8_t ipproto; /* FRA_IP_PROTO */
uint8_t protocol; /* FRA_PROTOCOL */
uint8_t to_prefixlen;
uint8_t from_prefixlen;
uint8_t l3mdev; /* FRA_L3MDEV */
uint32_t table;
uint32_t fwmark;
uint32_t fwmask;
uint32_t priority;
AddressFamily address_family; /* Specified by Family= */
int family; /* Automatically determined by From= or To= */
char *iif;
char *oif;
union in_addr_union to;
union in_addr_union from;
struct fib_rule_port_range sport;
struct fib_rule_port_range dport;
struct fib_rule_uid_range uid_range;
int suppress_prefixlen;
int32_t suppress_ifgroup;
} RoutingPolicyRule;
const char *fr_act_type_full_to_string(int t) _const_;
RoutingPolicyRule *routing_policy_rule_free(RoutingPolicyRule *rule);
void network_drop_invalid_routing_policy_rules(Network *network);
int link_request_static_routing_policy_rules(Link *link);
int manager_rtnl_process_rule(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
int manager_drop_routing_policy_rules_internal(Manager *m, bool foreign, const Link *except);
static inline int manager_drop_foreign_routing_policy_rules(Manager *m) {
return manager_drop_routing_policy_rules_internal(m, true, NULL);
}
static inline int link_drop_managed_routing_policy_rules(Link *link) {
assert(link);
return manager_drop_routing_policy_rules_internal(link->manager, false, link);
}
void link_foreignize_routing_policy_rules(Link *link);
DEFINE_NETWORK_CONFIG_STATE_FUNCTIONS(RoutingPolicyRule, routing_policy_rule);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_tos);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_table);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_fwmark_mask);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_prefix);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_priority);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_device);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_port_range);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_ip_protocol);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_invert);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_family);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_uid_range);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_suppress_prefixlen);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_suppress_ifgroup);
CONFIG_PARSER_PROTOTYPE(config_parse_routing_policy_rule_type);
| 3,209 | 34.274725 | 93 |
h
|
null |
systemd-main/src/network/networkd-setlink.h
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
#include <inttypes.h>
#include <stdbool.h>
typedef struct Link Link;
int link_request_to_set_addrgen_mode(Link *link);
int link_request_to_set_bond(Link *link);
int link_request_to_set_bridge(Link *link);
int link_request_to_set_bridge_vlan(Link *link);
int link_request_to_set_can(Link *link);
int link_request_to_set_flags(Link *link);
int link_request_to_set_group(Link *link);
int link_request_to_set_mac(Link *link, bool allow_retry);
int link_request_to_set_ipoib(Link *link);
int link_request_to_set_master(Link *link);
int link_request_to_set_mtu(Link *link, uint32_t mtu);
int link_configure_mtu(Link *link);
int link_request_to_activate(Link *link);
int link_request_to_bring_up_or_down(Link *link, bool up);
int link_down_now(Link *link);
int link_down_slave_links(Link *link);
int link_remove(Link *link);
| 887 | 28.6 | 58 |
h
|
null |
systemd-main/src/network/networkd-speed-meter.c
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <errno.h>
#include "sd-event.h"
#include "sd-netlink.h"
#include "networkd-link-bus.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "networkd-speed-meter.h"
static int process_message(Manager *manager, sd_netlink_message *message) {
uint16_t type;
int ifindex, r;
Link *link;
r = sd_netlink_message_get_type(message, &type);
if (r < 0)
return r;
if (type != RTM_NEWLINK)
return 0;
r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
if (r < 0)
return r;
r = link_get_by_index(manager, ifindex, &link);
if (r < 0)
return r;
link->stats_old = link->stats_new;
r = sd_netlink_message_read(message, IFLA_STATS64, sizeof link->stats_new, &link->stats_new);
if (r < 0)
return r;
link->stats_updated = true;
return 0;
}
static int speed_meter_handler(sd_event_source *s, uint64_t usec, void *userdata) {
_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL, *reply = NULL;
Manager *manager = ASSERT_PTR(userdata);
usec_t usec_now;
Link *link;
int r;
assert(s);
r = sd_event_now(sd_event_source_get_event(s), CLOCK_MONOTONIC, &usec_now);
if (r < 0)
return r;
r = sd_event_source_set_time(s, usec_now + manager->speed_meter_interval_usec);
if (r < 0)
return r;
manager->speed_meter_usec_old = manager->speed_meter_usec_new;
manager->speed_meter_usec_new = usec_now;
HASHMAP_FOREACH(link, manager->links_by_index)
link->stats_updated = false;
r = sd_rtnl_message_new_link(manager->rtnl, &req, RTM_GETLINK, 0);
if (r < 0) {
log_warning_errno(r, "Failed to allocate RTM_GETLINK netlink message, ignoring: %m");
return 0;
}
r = sd_netlink_message_set_request_dump(req, true);
if (r < 0) {
log_warning_errno(r, "Failed to set dump flag, ignoring: %m");
return 0;
}
r = sd_netlink_call(manager->rtnl, req, 0, &reply);
if (r < 0) {
log_warning_errno(r, "Failed to call RTM_GETLINK, ignoring: %m");
return 0;
}
for (sd_netlink_message *i = reply; i; i = sd_netlink_message_next(i))
(void) process_message(manager, i);
return 0;
}
int manager_start_speed_meter(Manager *manager) {
_cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
int r;
assert(manager);
assert(manager->event);
if (!manager->use_speed_meter)
return 0;
r = sd_event_add_time(manager->event, &s, CLOCK_MONOTONIC, 0, 0, speed_meter_handler, manager);
if (r < 0)
return r;
r = sd_event_source_set_enabled(s, SD_EVENT_ON);
if (r < 0)
return r;
manager->speed_meter_event_source = TAKE_PTR(s);
return 0;
}
| 3,177 | 27.375 | 103 |
c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.