And move it and relevant functions to conf-parser.[ch].
if (s->tunnel && s->section)
ordered_hashmap_remove(s->tunnel->sessions_by_section, s->section);
- network_config_section_free(s->section);
+ config_section_free(s->section);
free(s->name);
return mfree(s);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(L2tpSession, l2tp_session_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(L2tpSession, l2tp_session_free);
static int l2tp_session_new_static(L2tpTunnel *t, const char *filename, unsigned section_line, L2tpSession **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(l2tp_session_freep) L2tpSession *s = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.section = TAKE_PTR(n),
};
- r = ordered_hashmap_ensure_put(&t->sessions_by_section, &network_config_hash_ops, s->section, s);
+ r = ordered_hashmap_ensure_put(&t->sessions_by_section, &config_section_hash_ops, s->section, s);
if (r < 0)
return r;
typedef struct L2tpSession {
L2tpTunnel *tunnel;
- NetworkConfigSection *section;
+ ConfigSection *section;
char *name;
if (c->macsec && c->section)
ordered_hashmap_remove(c->macsec->receive_associations_by_section, c->section);
- network_config_section_free(c->section);
+ config_section_free(c->section);
security_association_clear(&c->sa);
return mfree(c);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(ReceiveAssociation, macsec_receive_association_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(ReceiveAssociation, macsec_receive_association_free);
static int macsec_receive_association_new_static(MACsec *s, const char *filename, unsigned section_line, ReceiveAssociation **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(macsec_receive_association_freep) ReceiveAssociation *c = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
security_association_init(&c->sa);
- r = ordered_hashmap_ensure_put(&s->receive_associations_by_section, &network_config_hash_ops, c->section, c);
+ r = ordered_hashmap_ensure_put(&s->receive_associations_by_section, &config_section_hash_ops, c->section, c);
if (r < 0)
return r;
ordered_hashmap_remove(c->macsec->receive_channels_by_section, c->section);
}
- network_config_section_free(c->section);
+ config_section_free(c->section);
return mfree(c);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(ReceiveChannel, macsec_receive_channel_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(ReceiveChannel, macsec_receive_channel_free);
static int macsec_receive_channel_new(MACsec *s, uint64_t sci, ReceiveChannel **ret) {
ReceiveChannel *c;
}
static int macsec_receive_channel_new_static(MACsec *s, const char *filename, unsigned section_line, ReceiveChannel **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(macsec_receive_channel_freep) ReceiveChannel *c = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
c->section = TAKE_PTR(n);
- r = ordered_hashmap_ensure_put(&s->receive_channels_by_section, &network_config_hash_ops, c->section, c);
+ r = ordered_hashmap_ensure_put(&s->receive_channels_by_section, &config_section_hash_ops, c->section, c);
if (r < 0)
return r;
if (a->macsec && a->section)
ordered_hashmap_remove(a->macsec->transmit_associations_by_section, a->section);
- network_config_section_free(a->section);
+ config_section_free(a->section);
security_association_clear(&a->sa);
return mfree(a);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(TransmitAssociation, macsec_transmit_association_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(TransmitAssociation, macsec_transmit_association_free);
static int macsec_transmit_association_new_static(MACsec *s, const char *filename, unsigned section_line, TransmitAssociation **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(macsec_transmit_association_freep) TransmitAssociation *a = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
security_association_init(&a->sa);
- r = ordered_hashmap_ensure_put(&s->transmit_associations_by_section, &network_config_hash_ops, a->section, a);
+ r = ordered_hashmap_ensure_put(&s->transmit_associations_by_section, &config_section_hash_ops, a->section, a);
if (r < 0)
return r;
typedef struct TransmitAssociation {
MACsec *macsec;
- NetworkConfigSection *section;
+ ConfigSection *section;
SecurityAssociation sa;
} TransmitAssociation;
typedef struct ReceiveAssociation {
MACsec *macsec;
- NetworkConfigSection *section;
+ ConfigSection *section;
MACsecSCI sci;
SecurityAssociation sa;
typedef struct ReceiveChannel {
MACsec *macsec;
- NetworkConfigSection *section;
+ ConfigSection *section;
MACsecSCI sci;
ReceiveAssociation *rxsa[MACSEC_MAX_ASSOCIATION_NUMBER];
hashmap_remove(peer->wireguard->peers_by_section, peer->section);
}
- network_config_section_free(peer->section);
+ config_section_free(peer->section);
while ((mask = peer->ipmasks)) {
LIST_REMOVE(ipmasks, peer->ipmasks, mask);
return mfree(peer);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(WireguardPeer, wireguard_peer_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(WireguardPeer, wireguard_peer_free);
static int wireguard_peer_new_static(Wireguard *w, const char *filename, unsigned section_line, WireguardPeer **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(wireguard_peer_freep) WireguardPeer *peer = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
LIST_PREPEND(peers, w->peers, peer);
- r = hashmap_ensure_put(&w->peers_by_section, &network_config_hash_ops, peer->section, peer);
+ r = hashmap_ensure_put(&w->peers_by_section, &config_section_hash_ops, peer->section, peer);
if (r < 0)
return r;
typedef struct WireguardPeer {
Wireguard *wireguard;
- NetworkConfigSection *section;
+ ConfigSection *section;
uint8_t public_key[WG_KEY_LEN];
uint8_t preshared_key[WG_KEY_LEN];
hashmap_remove(label->network->address_labels_by_section, label->section);
}
- network_config_section_free(label->section);
+ config_section_free(label->section);
return mfree(label);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(AddressLabel, address_label_free);
+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_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(address_label_freep) AddressLabel *label = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.label = UINT32_MAX,
};
- r = hashmap_ensure_put(&network->address_labels_by_section, &network_config_hash_ops, label->section, label);
+ r = hashmap_ensure_put(&network->address_labels_by_section, &config_section_hash_ops, label->section, label);
if (r < 0)
return r;
typedef struct AddressLabel {
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
uint32_t label;
struct in6_addr prefix;
}
static int address_new_static(Network *network, const char *filename, unsigned section_line, Address **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(address_freep) Address *address = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
address->section = TAKE_PTR(n);
address->source = NETWORK_CONFIG_SOURCE_STATIC;
- r = ordered_hashmap_ensure_put(&network->addresses_by_section, &network_config_hash_ops, address->section, address);
+ r = ordered_hashmap_ensure_put(&network->addresses_by_section, &config_section_hash_ops, address->section, address);
if (r < 0)
return r;
sd_ipv4acd_unref(address->acd);
- network_config_section_free(address->section);
+ config_section_free(address->section);
free(address->label);
return mfree(address);
}
struct Address {
Link *link;
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
union in_addr_union provider; /* DHCP server or router address */
bool address_is_ready(const Address *a);
void address_set_broadcast(Address *a);
-DEFINE_NETWORK_SECTION_FUNCTIONS(Address, address_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(Address, address_free);
int link_drop_addresses(Link *link);
int link_drop_foreign_addresses(Link *link);
hashmap_remove(fdb->network->bridge_fdb_entries_by_section, fdb->section);
}
- network_config_section_free(fdb->section);
+ config_section_free(fdb->section);
free(fdb->outgoing_ifname);
return mfree(fdb);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(BridgeFDB, bridge_fdb_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(BridgeFDB, bridge_fdb_free);
/* create a new FDB entry or get an existing one. */
static int bridge_fdb_new_static(
unsigned section_line,
BridgeFDB **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(bridge_fdb_freep) BridgeFDB *fdb = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.ntf_flags = NEIGHBOR_CACHE_ENTRY_FLAGS_SELF,
};
- r = hashmap_ensure_put(&network->bridge_fdb_entries_by_section, &network_config_hash_ops, fdb->section, fdb);
+ r = hashmap_ensure_put(&network->bridge_fdb_entries_by_section, &config_section_hash_ops, fdb->section, fdb);
if (r < 0)
return r;
typedef struct BridgeFDB {
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
uint32_t vni;
hashmap_remove(mdb->network->bridge_mdb_entries_by_section, mdb->section);
}
- network_config_section_free(mdb->section);
+ config_section_free(mdb->section);
return mfree(mdb);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(BridgeMDB, bridge_mdb_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(BridgeMDB, bridge_mdb_free);
/* create a new MDB entry or get an existing one. */
static int bridge_mdb_new_static(
unsigned section_line,
BridgeMDB **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(bridge_mdb_freep) BridgeMDB *mdb = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.section = TAKE_PTR(n),
};
- r = hashmap_ensure_put(&network->bridge_mdb_entries_by_section, &network_config_hash_ops, mdb->section, mdb);
+ r = hashmap_ensure_put(&network->bridge_mdb_entries_by_section, &config_section_hash_ops, mdb->section, mdb);
if (r < 0)
return r;
typedef struct BridgeMDB {
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
int family;
union in_addr_union group_addr;
#include "networkd-network.h"
#include "networkd-util.h"
-DEFINE_NETWORK_SECTION_FUNCTIONS(DHCPStaticLease, dhcp_static_lease_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(DHCPStaticLease, dhcp_static_lease_free);
DHCPStaticLease *dhcp_static_lease_free(DHCPStaticLease *static_lease) {
if (!static_lease)
if (static_lease->network && static_lease->section)
hashmap_remove(static_lease->network->dhcp_static_leases_by_section, static_lease->section);
- network_config_section_free(static_lease->section);
+ config_section_free(static_lease->section);
free(static_lease->client_id);
return mfree(static_lease);
}
}
static int lease_new_static(Network *network, const char *filename, unsigned section_line, DHCPStaticLease **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(dhcp_static_lease_freep) DHCPStaticLease *static_lease = NULL;
int r;
assert(section_line > 0);
assert(ret);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
static_lease->network = network;
static_lease->section = TAKE_PTR(n);
- r = hashmap_ensure_put(&network->dhcp_static_leases_by_section, &network_config_hash_ops, static_lease->section, static_lease);
+ r = hashmap_ensure_put(&network->dhcp_static_leases_by_section, &config_section_hash_ops, static_lease->section, static_lease);
if (r < 0)
return r;
#include "in-addr-util.h"
typedef struct Network Network;
-typedef struct NetworkConfigSection NetworkConfigSection;
+typedef struct ConfigSection ConfigSection;
typedef struct DHCPStaticLease {
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
struct in_addr address;
uint8_t *client_id;
hashmap_remove(neighbor->network->neighbors_by_section, neighbor->section);
}
- network_config_section_free(neighbor->section);
+ config_section_free(neighbor->section);
if (neighbor->link)
set_remove(neighbor->link->neighbors, neighbor);
return mfree(neighbor);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(Neighbor, neighbor_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(Neighbor, neighbor_free);
static int neighbor_new_static(Network *network, const char *filename, unsigned section_line, Neighbor **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(neighbor_freep) Neighbor *neighbor = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.source = NETWORK_CONFIG_SOURCE_STATIC,
};
- r = hashmap_ensure_put(&network->neighbors_by_section, &network_config_hash_ops, neighbor->section, neighbor);
+ r = hashmap_ensure_put(&network->neighbors_by_section, &config_section_hash_ops, neighbor->section, neighbor);
if (r < 0)
return r;
typedef struct Neighbor {
Network *network;
Link *link;
- NetworkConfigSection *section;
+ ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
hashmap_remove(nexthop->network->nexthops_by_section, nexthop->section);
}
- network_config_section_free(nexthop->section);
+ config_section_free(nexthop->section);
if (nexthop->link) {
set_remove(nexthop->link->nexthops, nexthop);
return mfree(nexthop);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(NextHop, nexthop_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(NextHop, nexthop_free);
static int nexthop_new(NextHop **ret) {
_cleanup_(nexthop_freep) NextHop *nexthop = NULL;
}
static int nexthop_new_static(Network *network, const char *filename, unsigned section_line, NextHop **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(nexthop_freep) NextHop *nexthop = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
nexthop->section = TAKE_PTR(n);
nexthop->source = NETWORK_CONFIG_SOURCE_STATIC;
- r = hashmap_ensure_put(&network->nexthops_by_section, &network_config_hash_ops, nexthop->section, nexthop);
+ r = hashmap_ensure_put(&network->nexthops_by_section, &config_section_hash_ops, nexthop->section, nexthop);
if (r < 0)
return r;
Network *network;
Manager *manager;
Link *link;
- NetworkConfigSection *section;
+ ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
hashmap_remove(prefix->network->prefixes_by_section, prefix->section);
}
- network_config_section_free(prefix->section);
+ config_section_free(prefix->section);
set_free(prefix->tokens);
return mfree(prefix);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(Prefix, prefix_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(Prefix, prefix_free);
static int prefix_new_static(Network *network, const char *filename, unsigned section_line, Prefix **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(prefix_freep) Prefix *prefix = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.address_auto_configuration = true,
};
- r = hashmap_ensure_put(&network->prefixes_by_section, &network_config_hash_ops, prefix->section, prefix);
+ r = hashmap_ensure_put(&network->prefixes_by_section, &config_section_hash_ops, prefix->section, prefix);
if (r < 0)
return r;
hashmap_remove(prefix->network->route_prefixes_by_section, prefix->section);
}
- network_config_section_free(prefix->section);
+ config_section_free(prefix->section);
return mfree(prefix);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(RoutePrefix, route_prefix_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(RoutePrefix, route_prefix_free);
static int route_prefix_new_static(Network *network, const char *filename, unsigned section_line, RoutePrefix **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(route_prefix_freep) RoutePrefix *prefix = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
.lifetime = RADV_DEFAULT_VALID_LIFETIME_USEC,
};
- r = hashmap_ensure_put(&network->route_prefixes_by_section, &network_config_hash_ops, prefix->section, prefix);
+ r = hashmap_ensure_put(&network->route_prefixes_by_section, &config_section_hash_ops, prefix->section, prefix);
if (r < 0)
return r;
typedef struct Prefix {
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
struct in6_addr prefix;
uint8_t prefixlen;
typedef struct RoutePrefix {
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
struct in6_addr prefix;
uint8_t prefixlen;
}
static int route_new_static(Network *network, const char *filename, unsigned section_line, Route **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(route_freep) Route *route = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
route->section = TAKE_PTR(n);
route->source = NETWORK_CONFIG_SOURCE_STATIC;
- r = hashmap_ensure_put(&network->routes_by_section, &network_config_hash_ops, route->section, route);
+ r = hashmap_ensure_put(&network->routes_by_section, &config_section_hash_ops, route->section, route);
if (r < 0)
return r;
hashmap_remove(route->network->routes_by_section, route->section);
}
- network_config_section_free(route->section);
+ config_section_free(route->section);
if (route->link)
set_remove(route->link->routes, route);
Link *link;
Manager *manager;
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
union in_addr_union provider; /* DHCP server or router address */
int route_new(Route **ret);
Route *route_free(Route *route);
-DEFINE_NETWORK_SECTION_FUNCTIONS(Route, route_free);
+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);
if (rule->manager)
set_remove(rule->manager->rules, rule);
- network_config_section_free(rule->section);
+ config_section_free(rule->section);
free(rule->iif);
free(rule->oif);
return mfree(rule);
}
-DEFINE_NETWORK_SECTION_FUNCTIONS(RoutingPolicyRule, routing_policy_rule_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(RoutingPolicyRule, routing_policy_rule_free);
static int routing_policy_rule_new(RoutingPolicyRule **ret) {
RoutingPolicyRule *rule;
static int routing_policy_rule_new_static(Network *network, const char *filename, unsigned section_line, RoutingPolicyRule **ret) {
_cleanup_(routing_policy_rule_freep) RoutingPolicyRule *rule = NULL;
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
int r;
assert(network);
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
rule->source = NETWORK_CONFIG_SOURCE_STATIC;
rule->protocol = RTPROT_STATIC;
- r = hashmap_ensure_put(&network->rules_by_section, &network_config_hash_ops, rule->section, rule);
+ r = hashmap_ensure_put(&network->rules_by_section, &config_section_hash_ops, rule->section, rule);
if (r < 0)
return r;
typedef struct RoutingPolicyRule {
Manager *manager;
Network *network;
- NetworkConfigSection *section;
+ ConfigSection *section;
NetworkConfigSource source;
NetworkConfigState state;
}
static int sr_iov_new_static(Network *network, const char *filename, unsigned section_line, SRIOV **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(sr_iov_freep) SRIOV *sr_iov = NULL;
SRIOV *existing = NULL;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
sr_iov->network = network;
sr_iov->section = TAKE_PTR(n);
- r = ordered_hashmap_ensure_put(&network->sr_iov_by_section, &network_config_hash_ops, sr_iov->section, sr_iov);
+ r = ordered_hashmap_ensure_put(&network->sr_iov_by_section, &config_section_hash_ops, sr_iov->section, sr_iov);
if (r < 0)
return r;
if (sr_iov->network && sr_iov->section)
ordered_hashmap_remove(sr_iov->network->sr_iov_by_section, sr_iov->section);
- network_config_section_free(sr_iov->section);
+ config_section_free(sr_iov->section);
return mfree(sr_iov);
}
} SRIOVLinkState;
typedef struct SRIOV {
- NetworkConfigSection *section;
+ ConfigSection *section;
Network *network;
uint32_t vf; /* 0 - 2147483646 */
int link_configure_sr_iov(Link *link);
int network_drop_invalid_sr_iov(Network *network);
-DEFINE_NETWORK_SECTION_FUNCTIONS(SRIOV, sr_iov_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(SRIOV, sr_iov_free);
CONFIG_PARSER_PROTOTYPE(config_parse_sr_iov_uint32);
CONFIG_PARSER_PROTOTYPE(config_parse_sr_iov_boolean);
return free_and_replace(*url, unescaped);
}
-static void network_config_hash_func(const NetworkConfigSection *c, struct siphash *state) {
- siphash24_compress_string(c->filename, state);
- siphash24_compress(&c->line, sizeof(c->line), state);
-}
-
-static int network_config_compare_func(const NetworkConfigSection *x, const NetworkConfigSection *y) {
- int r;
-
- r = strcmp(x->filename, y->filename);
- if (r != 0)
- return r;
-
- return CMP(x->line, y->line);
-}
-
-DEFINE_HASH_OPS(network_config_hash_ops, NetworkConfigSection, network_config_hash_func, network_config_compare_func);
-
-int network_config_section_new(const char *filename, unsigned line, NetworkConfigSection **s) {
- NetworkConfigSection *cs;
-
- cs = malloc0(offsetof(NetworkConfigSection, filename) + strlen(filename) + 1);
- if (!cs)
- return -ENOMEM;
-
- strcpy(cs->filename, filename);
- cs->line = line;
-
- *s = TAKE_PTR(cs);
-
- return 0;
-}
-
-unsigned hashmap_find_free_section_line(Hashmap *hashmap) {
- NetworkConfigSection *cs;
- unsigned n = 0;
- void *entry;
-
- HASHMAP_FOREACH_KEY(entry, cs, hashmap)
- if (n < cs->line)
- n = cs->line;
-
- return n + 1;
-}
-
int log_link_message_full_errno(Link *link, sd_netlink_message *m, int level, int err, const char *msg) {
const char *err_msg = NULL;
typedef struct Link Link;
-typedef struct NetworkConfigSection {
- unsigned line;
- bool invalid;
- char filename[];
-} NetworkConfigSection;
-
typedef enum NetworkConfigSource {
NETWORK_CONFIG_SOURCE_FOREIGN, /* configured by kernel */
NETWORK_CONFIG_SOURCE_STATIC,
const char *dhcp_lease_server_type_to_string(sd_dhcp_lease_server_type_t t) _const_;
sd_dhcp_lease_server_type_t dhcp_lease_server_type_from_string(const char *s) _pure_;
-static inline NetworkConfigSection* network_config_section_free(NetworkConfigSection *cs) {
- return mfree(cs);
-}
-DEFINE_TRIVIAL_CLEANUP_FUNC(NetworkConfigSection*, network_config_section_free);
-
-int network_config_section_new(const char *filename, unsigned line, NetworkConfigSection **s);
-extern const struct hash_ops network_config_hash_ops;
-unsigned hashmap_find_free_section_line(Hashmap *hashmap);
-
-static inline bool section_is_invalid(NetworkConfigSection *section) {
- /* If this returns false, then it does _not_ mean the section is valid. */
-
- if (!section)
- return false;
-
- return section->invalid;
-}
-
-#define DEFINE_NETWORK_SECTION_FUNCTIONS(type, free_func) \
- static inline type* free_func##_or_set_invalid(type *p) { \
- assert(p); \
- \
- if (p->section) \
- p->section->invalid = true; \
- else \
- free_func(p); \
- return NULL; \
- } \
- DEFINE_TRIVIAL_CLEANUP_FUNC(type*, free_func); \
- DEFINE_TRIVIAL_CLEANUP_FUNC(type*, free_func##_or_set_invalid);
-
int log_link_message_full_errno(Link *link, sd_netlink_message *m, int level, int err, const char *msg);
#define log_link_message_error_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_ERR, err, msg)
#define log_link_message_warning_errno(link, m, err, msg) log_link_message_full_errno(link, m, LOG_WARNING, err, msg)
}
int qdisc_new_static(QDiscKind kind, Network *network, const char *filename, unsigned section_line, QDisc **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(qdisc_freep) QDisc *qdisc = NULL;
TrafficControl *existing;
QDisc *q = NULL;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
qdisc->network = network;
qdisc->section = TAKE_PTR(n);
- r = ordered_hashmap_ensure_put(&network->tc_by_section, &network_config_hash_ops, qdisc->section, TC(qdisc));
+ r = ordered_hashmap_ensure_put(&network->tc_by_section, &config_section_hash_ops, qdisc->section, TC(qdisc));
if (r < 0)
return r;
if (qdisc->network && qdisc->section)
ordered_hashmap_remove(qdisc->network->tc_by_section, qdisc->section);
- network_config_section_free(qdisc->section);
+ config_section_free(qdisc->section);
free(qdisc->tca_kind);
return mfree(qdisc);
typedef struct QDisc {
TrafficControl meta;
- NetworkConfigSection *section;
+ ConfigSection *section;
Network *network;
int family;
int qdisc_configure(Link *link, QDisc *qdisc);
int qdisc_section_verify(QDisc *qdisc, bool *has_root, bool *has_clsact);
-DEFINE_NETWORK_SECTION_FUNCTIONS(QDisc, qdisc_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(QDisc, qdisc_free);
DEFINE_TC_CAST(QDISC, QDisc);
}
int tclass_new_static(TClassKind kind, Network *network, const char *filename, unsigned section_line, TClass **ret) {
- _cleanup_(network_config_section_freep) NetworkConfigSection *n = NULL;
+ _cleanup_(config_section_freep) ConfigSection *n = NULL;
_cleanup_(tclass_freep) TClass *tclass = NULL;
TrafficControl *existing;
int r;
assert(filename);
assert(section_line > 0);
- r = network_config_section_new(filename, section_line, &n);
+ r = config_section_new(filename, section_line, &n);
if (r < 0)
return r;
tclass->network = network;
tclass->section = TAKE_PTR(n);
- r = ordered_hashmap_ensure_put(&network->tc_by_section, &network_config_hash_ops, tclass->section, tclass);
+ r = ordered_hashmap_ensure_put(&network->tc_by_section, &config_section_hash_ops, tclass->section, tclass);
if (r < 0)
return r;
if (tclass->network && tclass->section)
ordered_hashmap_remove(tclass->network->tc_by_section, tclass->section);
- network_config_section_free(tclass->section);
+ config_section_free(tclass->section);
return mfree(tclass);
}
typedef struct TClass {
TrafficControl meta;
- NetworkConfigSection *section;
+ ConfigSection *section;
Network *network;
uint32_t classid;
int tclass_configure(Link *link, TClass *tclass);
int tclass_section_verify(TClass *tclass);
-DEFINE_NETWORK_SECTION_FUNCTIONS(TClass, tclass_free);
+DEFINE_SECTION_CLEANUP_FUNCTIONS(TClass, tclass_free);
DEFINE_TC_CAST(TCLASS, TClass);
return config_parse_many_files(conf_files, files, sections, lookup, table, flags, userdata, ret_stats_by_path);
}
+static void config_section_hash_func(const ConfigSection *c, struct siphash *state) {
+ siphash24_compress_string(c->filename, state);
+ siphash24_compress(&c->line, sizeof(c->line), state);
+}
+
+static int config_section_compare_func(const ConfigSection *x, const ConfigSection *y) {
+ int r;
+
+ r = strcmp(x->filename, y->filename);
+ if (r != 0)
+ return r;
+
+ return CMP(x->line, y->line);
+}
+
+DEFINE_HASH_OPS(config_section_hash_ops, ConfigSection, config_section_hash_func, config_section_compare_func);
+
+int config_section_new(const char *filename, unsigned line, ConfigSection **s) {
+ ConfigSection *cs;
+
+ cs = malloc0(offsetof(ConfigSection, filename) + strlen(filename) + 1);
+ if (!cs)
+ return -ENOMEM;
+
+ strcpy(cs->filename, filename);
+ cs->line = line;
+
+ *s = TAKE_PTR(cs);
+
+ return 0;
+}
+
+unsigned hashmap_find_free_section_line(Hashmap *hashmap) {
+ ConfigSection *cs;
+ unsigned n = 0;
+ void *entry;
+
+ HASHMAP_FOREACH_KEY(entry, cs, hashmap)
+ if (n < cs->line)
+ n = cs->line;
+
+ return n + 1;
+}
+
#define DEFINE_PARSER(type, vartype, conv_func) \
DEFINE_CONFIG_PARSE_PTR(config_parse_##type, conv_func, vartype, "Failed to parse " #type " value")
void *userdata,
Hashmap **ret_stats_by_path); /* possibly NULL */
+typedef struct ConfigSection {
+ unsigned line;
+ bool invalid;
+ char filename[];
+} ConfigSection;
+
+static inline ConfigSection* config_section_free(ConfigSection *cs) {
+ return mfree(cs);
+}
+DEFINE_TRIVIAL_CLEANUP_FUNC(ConfigSection*, config_section_free);
+
+int config_section_new(const char *filename, unsigned line, ConfigSection **s);
+extern const struct hash_ops config_section_hash_ops;
+unsigned hashmap_find_free_section_line(Hashmap *hashmap);
+
+static inline bool section_is_invalid(ConfigSection *section) {
+ /* If this returns false, then it does _not_ mean the section is valid. */
+
+ if (!section)
+ return false;
+
+ return section->invalid;
+}
+
+#define DEFINE_SECTION_CLEANUP_FUNCTIONS(type, free_func) \
+ static inline type* free_func##_or_set_invalid(type *p) { \
+ assert(p); \
+ \
+ if (p->section) \
+ p->section->invalid = true; \
+ else \
+ free_func(p); \
+ return NULL; \
+ } \
+ DEFINE_TRIVIAL_CLEANUP_FUNC(type*, free_func); \
+ DEFINE_TRIVIAL_CLEANUP_FUNC(type*, free_func##_or_set_invalid);
+
CONFIG_PARSER_PROTOTYPE(config_parse_int);
CONFIG_PARSER_PROTOTYPE(config_parse_unsigned);
CONFIG_PARSER_PROTOTYPE(config_parse_long);