network: make request_process_address() and friends take Link and corresponding object

This also renames e.g. request_process_address() -> address_process_request().

Also, this drops type checks such as `assert(req->type == REQUEST_TYPE_ADDRESS)`,
as in the later commits, the function of processing request, e.g.
`address_process_request()`, will be assigned to the Request object when
it is created. And the request type will be used to distinguish and to
avoid deduplicating requests which do not have any assigned objects,
like REQUEST_TYPE_DHCP4_CLIENT. Hence, the type checks in process functions
are mostly not necessary and redundant.

This is mostly cleanups and preparation for later commits, and should
not change any behavior.

diff --git a/src/network/netdev/netdev.c b/src/network/netdev/netdev.c
index 30b29707120ad0dc073a1640d8eda11a06bc0603..d296d799c3fd17e6fb083475db7b3981c559accb 100644 (file)
--- a/src/network/netdev/netdev.c
+++ b/src/network/netdev/netdev.c
@@ -632,16 +632,12 @@ static int netdev_is_ready_to_create(NetDev *netdev, Link *link) {
         return true;
 }
 
-int request_process_stacked_netdev(Request *req) {
-        NetDev *netdev;
-        Link *link;
+int stacked_netdev_process_request(Request *req, Link *link, void *userdata) {
+        NetDev *netdev = ASSERT_PTR(userdata);
         int r;
 
         assert(req);
-        assert(req->type == REQUEST_TYPE_NETDEV_STACKED);
-
-        netdev = ASSERT_PTR(req->netdev);
-        link = ASSERT_PTR(req->link);
+        assert(link);
 
         r = netdev_is_ready_to_create(netdev, link);
         if (r <= 0)
@@ -707,14 +703,11 @@ int link_request_stacked_netdev(Link *link, NetDev *netdev) {
         return 0;
 }
 
-int request_process_independent_netdev(Request *req) {
-        NetDev *netdev;
+int independent_netdev_process_request(Request *req, Link *link, void *userdata) {
+        NetDev *netdev = ASSERT_PTR(userdata);
         int r;
 
-        assert(req);
-        assert(req->type == REQUEST_TYPE_NETDEV_INDEPENDENT);
-
-        netdev = ASSERT_PTR(req->netdev);
+        assert(!link);
 
         r = netdev_is_ready_to_create(netdev, NULL);
         if (r <= 0)

diff --git a/src/network/netdev/netdev.h b/src/network/netdev/netdev.h
index ccf58f7ccb497fd3dd72b4ad1df573720816fabe..4c2e949fb28f5f4fa4ef6e615c1478782d581eaf 100644 (file)
--- a/src/network/netdev/netdev.h
+++ b/src/network/netdev/netdev.h
@@ -209,8 +209,8 @@ int netdev_set_ifindex(NetDev *netdev, sd_netlink_message *newlink);
 int netdev_generate_hw_addr(NetDev *netdev, Link *link, const char *name,
                             const struct hw_addr_data *hw_addr, struct hw_addr_data *ret);
 
-int request_process_independent_netdev(Request *req);
-int request_process_stacked_netdev(Request *req);
+int independent_netdev_process_request(Request *req, Link *link, void *userdata);
+int stacked_netdev_process_request(Request *req, Link *link, void *userdata);
 int link_request_stacked_netdev(Link *link, NetDev *netdev);
 
 const char *netdev_kind_to_string(NetDevKind d) _const_;

diff --git a/src/network/networkd-address-label.c b/src/network/networkd-address-label.c
index 3447d96cf9c0ae70502e3a306e3ffc0dcabd3d76..c165cde092e92484e5fcdf8463ff5da0ef84a10e 100644 (file)
--- a/src/network/networkd-address-label.c
+++ b/src/network/networkd-address-label.c
@@ -132,20 +132,17 @@ static int address_label_configure(AddressLabel *label, Link *link, Request *req
         return 0;
 }
 
-int request_process_address_label(Request *req) {
-        Link *link;
+int address_label_process_request(Request *req, Link *link, void *userdata) {
+        AddressLabel *label = ASSERT_PTR(userdata);
         int r;
 
         assert(req);
-        assert(req->label);
-        assert(req->type == REQUEST_TYPE_ADDRESS_LABEL);
-
-        link = ASSERT_PTR(req->link);
+        assert(link);
 
         if (!link_is_ready_to_configure(link, false))
                 return 0;
 
-        r = address_label_configure(req->label, link, req);
+        r = address_label_configure(label, link, req);
         if (r < 0)
                 return log_link_warning_errno(link, r, "Failed to configure address label: %m");
 

diff --git a/src/network/networkd-address-label.h b/src/network/networkd-address-label.h
index 582dd05b8809705f080ba34ae279eb267c1dee78..19bb0383e6512355c3493b26f8aec45df43a8c5a 100644 (file)
--- a/src/network/networkd-address-label.h
+++ b/src/network/networkd-address-label.h
@@ -26,7 +26,7 @@ AddressLabel *address_label_free(AddressLabel *label);
 void network_drop_invalid_address_labels(Network *network);
 
 int link_request_static_address_labels(Link *link);
-int request_process_address_label(Request *req);
+int address_label_process_request(Request *req, Link *link, void *userdata);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_address_label);
 CONFIG_PARSER_PROTOTYPE(config_parse_address_label_prefix);

diff --git a/src/network/networkd-address.c b/src/network/networkd-address.c
index bf56335e316829bd04c75a0c2b251ae5e9e78b75..3164f82c304eb090ffe242dc78531182cd6079eb 100644 (file)
--- a/src/network/networkd-address.c
+++ b/src/network/networkd-address.c
@@ -1112,16 +1112,12 @@ static bool address_is_ready_to_configure(Link *link, const Address *address) {
         return true;
 }
 
-int request_process_address(Request *req) {
-        Address *address;
-        Link *link;
+int address_process_request(Request *req, Link *link, Address *address) {
         int r;
 
         assert(req);
-        assert(req->type == REQUEST_TYPE_ADDRESS);
-
-        address = ASSERT_PTR(req->address);
-        link = ASSERT_PTR(req->link);
+        assert(link);
+        assert(address);
 
         if (!address_is_ready_to_configure(link, address))
                 return 0;

diff --git a/src/network/networkd-address.h b/src/network/networkd-address.h
index b116237638bc5895ed84c5080b9d8aa85e7850a4..a90dbceb64945d03d599f9d4cf06f7d2e1d0a515 100644 (file)
--- a/src/network/networkd-address.h
+++ b/src/network/networkd-address.h
@@ -101,7 +101,7 @@ int link_request_address(
                 Request **ret);
 int link_request_static_address(Link *link, Address *address, bool consume);
 int link_request_static_addresses(Link *link);
-int request_process_address(Request *req);
+int address_process_request(Request *req, Link *link, Address *address);
 
 int manager_rtnl_process_address(sd_netlink *nl, sd_netlink_message *message, Manager *m);
 

diff --git a/src/network/networkd-bridge-fdb.c b/src/network/networkd-bridge-fdb.c
index a7ba2239c6aa020010eb193fdc958e1f34af07b7..e8a05e5e133c1dca3e01a349fe10218e1106b1c8 100644 (file)
--- a/src/network/networkd-bridge-fdb.c
+++ b/src/network/networkd-bridge-fdb.c
@@ -219,15 +219,12 @@ static bool bridge_fdb_is_ready_to_configure(BridgeFDB *fdb, Link *link) {
         return true;
 }
 
-int request_process_bridge_fdb(Request *req) {
-        BridgeFDB *fdb;
-        Link *link;
+int bridge_fdb_process_request(Request *req, Link *link, void *userdata) {
+        BridgeFDB *fdb = ASSERT_PTR(userdata);
         int r;
 
         assert(req);
-        assert(req->type == REQUEST_TYPE_BRIDGE_FDB);
-        assert_se(link = req->link);
-        assert_se(fdb = req->fdb);
+        assert(link);
 
         if (!bridge_fdb_is_ready_to_configure(fdb, link))
                 return 0;

diff --git a/src/network/networkd-bridge-fdb.h b/src/network/networkd-bridge-fdb.h
index b1098760d2d9e3ad522b3f90ab7ca44597896959..6a6e80384ec2b8ab82166fc28aadd04b3363cefd 100644 (file)
--- a/src/network/networkd-bridge-fdb.h
+++ b/src/network/networkd-bridge-fdb.h
@@ -47,7 +47,7 @@ void network_drop_invalid_bridge_fdb_entries(Network *network);
 
 int link_request_static_bridge_fdb(Link *link);
 
-int request_process_bridge_fdb(Request *req);
+int bridge_fdb_process_request(Request *req, Link *link, void *userdata);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_fdb_hwaddr);
 CONFIG_PARSER_PROTOTYPE(config_parse_fdb_vlan_id);

diff --git a/src/network/networkd-bridge-mdb.c b/src/network/networkd-bridge-mdb.c
index 4cd98f3545e1eda7d953ffc2c68d31fb0437f9d2..b9320f7ea2ca9cba7bb236cac525a36e359900c5 100644 (file)
--- a/src/network/networkd-bridge-mdb.c
+++ b/src/network/networkd-bridge-mdb.c
@@ -205,19 +205,17 @@ static bool bridge_mdb_is_ready_to_configure(Link *link) {
         return true;
 }
 
-int request_process_bridge_mdb(Request *req) {
-        Link *link;
+int bridge_mdb_process_request(Request *req, Link *link, void *userdata) {
+        BridgeMDB *mdb = ASSERT_PTR(userdata);
         int r;
 
         assert(req);
-        assert(req->mdb);
-        assert(req->type == REQUEST_TYPE_BRIDGE_MDB);
-        assert_se(link = req->link);
+        assert(link);
 
         if (!bridge_mdb_is_ready_to_configure(link))
                 return 0;
 
-        r = bridge_mdb_configure(req->mdb, link, req);
+        r = bridge_mdb_configure(mdb, link, req);
         if (r < 0)
                 return log_link_warning_errno(link, r, "Failed to configure bridge MDB: %m");
 

diff --git a/src/network/networkd-bridge-mdb.h b/src/network/networkd-bridge-mdb.h
index ce91e3f5725d691a5a5505318bcf37e6921de459..c9a34af88addd054d13a69da3ff2e01e9a5410cf 100644 (file)
--- a/src/network/networkd-bridge-mdb.h
+++ b/src/network/networkd-bridge-mdb.h
@@ -25,7 +25,7 @@ BridgeMDB *bridge_mdb_free(BridgeMDB *mdb);
 void network_drop_invalid_bridge_mdb_entries(Network *network);
 
 int link_request_static_bridge_mdb(Link *link);
-int request_process_bridge_mdb(Request *req);
+int bridge_mdb_process_request(Request *req, Link *link, void *userdata);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_mdb_group_address);
 CONFIG_PARSER_PROTOTYPE(config_parse_mdb_vlan_id);

diff --git a/src/network/networkd-dhcp-server.c b/src/network/networkd-dhcp-server.c
index 795ad686af9f9a390aa55a781c6cbab54721204f..b11ff073bcfe9120eed7d7773f9aaa8fb0f056b7 100644 (file)
--- a/src/network/networkd-dhcp-server.c
+++ b/src/network/networkd-dhcp-server.c
@@ -567,13 +567,10 @@ static bool dhcp_server_is_ready_to_configure(Link *link) {
         return true;
 }
 
-int request_process_dhcp_server(Request *req) {
-        Link *link;
+int dhcp_server_process_request(Request *req, Link *link, void *userdata) {
         int r;
 
-        assert(req);
-        assert(req->type == REQUEST_TYPE_DHCP_SERVER);
-        assert_se(link = req->link);
+        assert(link);
 
         if (!dhcp_server_is_ready_to_configure(link))
                 return 0;

diff --git a/src/network/networkd-dhcp-server.h b/src/network/networkd-dhcp-server.h
index 1af1c65c66f2cbbfc11904761eda79780199f29d..7a204e7d0a0d59355618b1ee5bd8944e6b9fa9e6 100644 (file)
--- a/src/network/networkd-dhcp-server.h
+++ b/src/network/networkd-dhcp-server.h
@@ -11,7 +11,7 @@ void network_adjust_dhcp_server(Network *network);
 
 int link_request_dhcp_server_address(Link *link);
 int link_request_dhcp_server(Link *link);
-int request_process_dhcp_server(Request *req);
+int dhcp_server_process_request(Request *req, Link *link, void *userdata);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_server_relay_agent_suboption);
 CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_server_emit);

diff --git a/src/network/networkd-dhcp4.c b/src/network/networkd-dhcp4.c
index 2b985f361a23ecd1f42737caa5e46d3dbd0d6af6..1aa389bb53b9dfe741e0a1ef0542aa7ced48e8f4 100644 (file)
--- a/src/network/networkd-dhcp4.c
+++ b/src/network/networkd-dhcp4.c
@@ -1597,15 +1597,10 @@ static int dhcp4_configure_duid(Link *link) {
         return dhcp_configure_duid(link, link_get_dhcp4_duid(link));
 }
 
-int request_process_dhcp4_client(Request *req) {
-        Link *link;
+int dhcp4_process_request(Request *req, Link *link, void *userdata) {
         int r;
 
-        assert(req);
-        assert(req->link);
-        assert(req->type == REQUEST_TYPE_DHCP4_CLIENT);
-
-        link = req->link;
+        assert(link);
 
         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
                 return 0;
@@ -1619,7 +1614,7 @@ int request_process_dhcp4_client(Request *req) {
         if (r <= 0)
                 return r;
 
-        r = dhcp4_configure(req->link);
+        r = dhcp4_configure(link);
         if (r < 0)
                 return log_link_warning_errno(link, r, "Failed to configure DHCPv4 client: %m");
 
@@ -1629,7 +1624,6 @@ int request_process_dhcp4_client(Request *req) {
 
         log_link_debug(link, "DHCPv4 client is configured%s.",
                        r > 0 ? ", acquiring DHCPv4 lease" : "");
-
         return 1;
 }
 

diff --git a/src/network/networkd-dhcp4.h b/src/network/networkd-dhcp4.h
index 830e39f66afe06a224f4896698a11badf423d09a..4e466ca4f9618f66f8811edd4dabb9731d4a008a 100644 (file)
--- a/src/network/networkd-dhcp4.h
+++ b/src/network/networkd-dhcp4.h
@@ -25,7 +25,7 @@ int dhcp4_start(Link *link);
 int dhcp4_lease_lost(Link *link);
 int dhcp4_check_ready(Link *link);
 
-int request_process_dhcp4_client(Request *req);
+int dhcp4_process_request(Request *req, Link *link, void *userdata);
 int link_request_dhcp4_client(Link *link);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_client_identifier);

diff --git a/src/network/networkd-dhcp6.c b/src/network/networkd-dhcp6.c
index 244c3a2a4d928bbcac0f22fe990bd97d9cb73fa6..3bb013ebaf86d6a6c2b880c03a39f4fd30c9b7e7 100644 (file)
--- a/src/network/networkd-dhcp6.c
+++ b/src/network/networkd-dhcp6.c
@@ -715,15 +715,10 @@ int dhcp6_update_mac(Link *link) {
         return 0;
 }
 
-int request_process_dhcp6_client(Request *req) {
-        Link *link;
+int dhcp6_process_request(Request *req, Link *link, void *userdata) {
         int r;
 
-        assert(req);
-        assert(req->link);
-        assert(req->type == REQUEST_TYPE_DHCP6_CLIENT);
-
-        link = req->link;
+        assert(link);
 
         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
                 return 0;
@@ -751,7 +746,6 @@ int request_process_dhcp6_client(Request *req) {
 
         log_link_debug(link, "DHCPv6 client is configured%s.",
                        r > 0 ? ", acquiring DHCPv6 lease" : "");
-
         return 1;
 }
 

diff --git a/src/network/networkd-dhcp6.h b/src/network/networkd-dhcp6.h
index 52347c5e7b7219db6d47971c1bc1541a835f9ec7..e3bc57cc30030b8ffef66cd4bc880035e448e003 100644 (file)
--- a/src/network/networkd-dhcp6.h
+++ b/src/network/networkd-dhcp6.h
@@ -21,7 +21,7 @@ int dhcp6_update_mac(Link *link);
 int dhcp6_start(Link *link);
 int dhcp6_start_on_ra(Link *link, bool information_request);
 
-int request_process_dhcp6_client(Request *req);
+int dhcp6_process_request(Request *req, Link *link, void *userdata);
 int link_request_dhcp6_client(Link *link);
 
 int link_serialize_dhcp6_client(Link *link, FILE *f);

diff --git a/src/network/networkd-ipv6-proxy-ndp.c b/src/network/networkd-ipv6-proxy-ndp.c
index 5844273be98ab9d0efaa64bfd9750b390e69a4c5..def456c9aa2890963b2c38eb64fa931be6cbbded 100644 (file)
--- a/src/network/networkd-ipv6-proxy-ndp.c
+++ b/src/network/networkd-ipv6-proxy-ndp.c
@@ -80,19 +80,17 @@ static int ipv6_proxy_ndp_address_configure(const struct in6_addr *address, Link
         return 0;
 }
 
-int request_process_ipv6_proxy_ndp_address(Request *req) {
-        Link *link;
+int ipv6_proxy_ndp_address_process_request(Request *req, Link *link, struct in6_addr *address) {
         int r;
 
         assert(req);
-        assert(req->ipv6_proxy_ndp);
-        assert(req->type == REQUEST_TYPE_IPV6_PROXY_NDP);
-        assert_se(link = req->link);
+        assert(link);
+        assert(address);
 
         if (!link_is_ready_to_configure(link, false))
                 return 0;
 
-        r = ipv6_proxy_ndp_address_configure(req->ipv6_proxy_ndp, link, req);
+        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");
 

diff --git a/src/network/networkd-ipv6-proxy-ndp.h b/src/network/networkd-ipv6-proxy-ndp.h
index b35cd56182f8b5cbeef33a293a8161ab7184aaf1..39a782059991de836006f3427775b50d71b021cd 100644 (file)
--- a/src/network/networkd-ipv6-proxy-ndp.h
+++ b/src/network/networkd-ipv6-proxy-ndp.h
@@ -10,6 +10,6 @@ typedef struct Request Request;
 void network_adjust_ipv6_proxy_ndp(Network *network);
 
 int link_request_static_ipv6_proxy_ndp_addresses(Link *link);
-int request_process_ipv6_proxy_ndp_address(Request *req);
+int ipv6_proxy_ndp_address_process_request(Request *req, Link *link, struct in6_addr *address);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_proxy_ndp_address);

diff --git a/src/network/networkd-ndisc.c b/src/network/networkd-ndisc.c
index 7f2366ba7056903fb28c0d635bc102ae8e8e32c2..2f86ade325ac069dae0f008bc222944f005b00c9 100644 (file)
--- a/src/network/networkd-ndisc.c
+++ b/src/network/networkd-ndisc.c
@@ -1122,14 +1122,10 @@ int ndisc_start(Link *link) {
         return 1;
 }
 
-int request_process_ndisc(Request *req) {
-        Link *link;
+int ndisc_process_request(Request *req, Link *link, void *userdata) {
         int r;
 
-        assert(req);
-        assert(req->type == REQUEST_TYPE_NDISC);
-
-        link = ASSERT_PTR(req->link);
+        assert(link);
 
         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
                 return 0;
@@ -1148,7 +1144,6 @@ int request_process_ndisc(Request *req) {
 
         log_link_debug(link, "IPv6 Router Discovery is configured%s.",
                        r > 0 ? " and started" : "");
-
         return 1;
 }
 

diff --git a/src/network/networkd-ndisc.h b/src/network/networkd-ndisc.h
index 1958652778d47693901f4d5c685da441cd364d7c..5a7eb58a562c0c3d4af34378d50200e36c81ff98 100644 (file)
--- a/src/network/networkd-ndisc.h
+++ b/src/network/networkd-ndisc.h
@@ -48,7 +48,7 @@ int ndisc_start(Link *link);
 void ndisc_vacuum(Link *link);
 void ndisc_flush(Link *link);
 
-int request_process_ndisc(Request *req);
+int ndisc_process_request(Request *req, Link *link, void *userdata);
 int link_request_ndisc(Link *link);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_ipv6_accept_ra_start_dhcp6_client);

diff --git a/src/network/networkd-neighbor.c b/src/network/networkd-neighbor.c
index 13dcba82864de08c6596f632120ff81c3163d3f4..33fa5e21ecfa964abed5373a92168e946b8c114a 100644 (file)
--- a/src/network/networkd-neighbor.c
+++ b/src/network/networkd-neighbor.c
@@ -225,16 +225,12 @@ static int neighbor_configure(Neighbor *neighbor, Link *link, Request *req) {
         return 0;
 }
 
-int request_process_neighbor(Request *req) {
-        Neighbor *neighbor;
-        Link *link;
+int neighbor_process_request(Request *req, Link *link, Neighbor *neighbor) {
         int r;
 
         assert(req);
-        assert(req->type == REQUEST_TYPE_NEIGHBOR);
-
-        neighbor = ASSERT_PTR(req->neighbor);
-        link = ASSERT_PTR(req->link);
+        assert(link);
+        assert(neighbor);
 
         if (!link_is_ready_to_configure(link, false))
                 return 0;

diff --git a/src/network/networkd-neighbor.h b/src/network/networkd-neighbor.h
index ac1678de181dd1efd54d26d1c5bf113e97f59fe8..52a7733a893d61de08a62add49541fda34284fc7 100644 (file)
--- a/src/network/networkd-neighbor.h
+++ b/src/network/networkd-neighbor.h
@@ -39,7 +39,7 @@ int link_drop_foreign_neighbors(Link *link);
 void link_foreignize_neighbors(Link *link);
 
 int link_request_static_neighbors(Link *link);
-int request_process_neighbor(Request *req);
+int neighbor_process_request(Request *req, Link *link, Neighbor *neighbor);
 
 int manager_rtnl_process_neighbor(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
 

diff --git a/src/network/networkd-nexthop.c b/src/network/networkd-nexthop.c
index ed9d621587c64ceb750c031b06953827efcea455..143ecce6c49fe7e74c89e872b8e052e7da1b89db 100644 (file)
--- a/src/network/networkd-nexthop.c
+++ b/src/network/networkd-nexthop.c
@@ -565,16 +565,12 @@ static bool nexthop_is_ready_to_configure(Link *link, const NextHop *nexthop) {
         return gateway_is_ready(link, FLAGS_SET(nexthop->flags, RTNH_F_ONLINK), nexthop->family, &nexthop->gw);
 }
 
-int request_process_nexthop(Request *req) {
-        NextHop *nexthop;
-        Link *link;
+int nexthop_process_request(Request *req, Link *link, NextHop *nexthop) {
         int r;
 
         assert(req);
-        assert(req->type == REQUEST_TYPE_NEXTHOP);
-
-        nexthop = ASSERT_PTR(req->nexthop);
-        link = ASSERT_PTR(req->link);
+        assert(link);
+        assert(nexthop);
 
         if (!nexthop_is_ready_to_configure(link, nexthop))
                 return 0;

diff --git a/src/network/networkd-nexthop.h b/src/network/networkd-nexthop.h
index 16eb02f7eb94f19ea07bc6047bdfd94b89ea0840..c5b58e5d38a9122275ae11688ad75a662e907a03 100644 (file)
--- a/src/network/networkd-nexthop.h
+++ b/src/network/networkd-nexthop.h
@@ -49,7 +49,7 @@ int link_drop_foreign_nexthops(Link *link);
 void link_foreignize_nexthops(Link *link);
 
 int link_request_static_nexthops(Link *link, bool only_ipv4);
-int request_process_nexthop(Request *req);
+int nexthop_process_request(Request *req, Link *link, NextHop *nexthop);
 
 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);

diff --git a/src/network/networkd-queue.c b/src/network/networkd-queue.c
index b30d0532d128c82cccd8acf8bc50e22aab497789..830802324ef72646061e4f3f828de50e25aeeedb 100644 (file)
--- a/src/network/networkd-queue.c
+++ b/src/network/networkd-queue.c
@@ -369,67 +369,67 @@ int manager_process_requests(sd_event_source *s, void *userdata) {
                 ORDERED_SET_FOREACH(req, manager->request_queue) {
                         switch (req->type) {
                         case REQUEST_TYPE_ACTIVATE_LINK:
-                                r = request_process_activation(req);
+                                r = link_process_activation(req, req->link, req->userdata);
                                 break;
                         case REQUEST_TYPE_ADDRESS:
-                                r = request_process_address(req);
+                                r = address_process_request(req, req->link, req->address);
                                 break;
                         case REQUEST_TYPE_ADDRESS_LABEL:
-                                r = request_process_address_label(req);
+                                r = address_label_process_request(req, req->link, req->label);
                                 break;
                         case REQUEST_TYPE_BRIDGE_FDB:
-                                r = request_process_bridge_fdb(req);
+                                r = bridge_fdb_process_request(req, req->link, req->fdb);
                                 break;
                         case REQUEST_TYPE_BRIDGE_MDB:
-                                r = request_process_bridge_mdb(req);
+                                r = bridge_mdb_process_request(req, req->link, req->mdb);
                                 break;
                         case REQUEST_TYPE_DHCP_SERVER:
-                                r = request_process_dhcp_server(req);
+                                r = dhcp_server_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_DHCP4_CLIENT:
-                                r = request_process_dhcp4_client(req);
+                                r = dhcp4_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_DHCP6_CLIENT:
-                                r = request_process_dhcp6_client(req);
+                                r = dhcp6_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_IPV6_PROXY_NDP:
-                                r = request_process_ipv6_proxy_ndp_address(req);
+                                r = ipv6_proxy_ndp_address_process_request(req, req->link, req->ipv6_proxy_ndp);
                                 break;
                         case REQUEST_TYPE_NDISC:
-                                r = request_process_ndisc(req);
+                                r = ndisc_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_NEIGHBOR:
-                                r = request_process_neighbor(req);
+                                r = neighbor_process_request(req, req->link, req->neighbor);
                                 break;
                         case REQUEST_TYPE_NETDEV_INDEPENDENT:
-                                r = request_process_independent_netdev(req);
+                                r = independent_netdev_process_request(req, req->link, req->netdev);
                                 break;
                         case REQUEST_TYPE_NETDEV_STACKED:
-                                r = request_process_stacked_netdev(req);
+                                r = stacked_netdev_process_request(req, req->link, req->netdev);
                                 break;
                         case REQUEST_TYPE_NEXTHOP:
-                                r = request_process_nexthop(req);
+                                r = nexthop_process_request(req, req->link, req->nexthop);
                                 break;
                         case REQUEST_TYPE_RADV:
-                                r = request_process_radv(req);
+                                r = radv_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_ROUTE:
-                                r = request_process_route(req);
+                                r = route_process_request(req, req->link, req->route);
                                 break;
                         case REQUEST_TYPE_ROUTING_POLICY_RULE:
-                                r = request_process_routing_policy_rule(req);
+                                r = routing_policy_rule_process_request(req, req->link, req->rule);
                                 break;
                         case REQUEST_TYPE_SET_LINK:
                                 r = request_process_set_link(req);
                                 break;
                         case REQUEST_TYPE_TC_QDISC:
-                                r = request_process_qdisc(req);
+                                r = qdisc_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_TC_CLASS:
-                                r = request_process_tclass(req);
+                                r = tclass_process_request(req, req->link, NULL);
                                 break;
                         case REQUEST_TYPE_UP_DOWN:
-                                r = request_process_link_up_or_down(req);
+                                r = link_process_up_or_down(req, req->link, req->userdata);
                                 break;
                         default:
                                 return -EINVAL;

diff --git a/src/network/networkd-radv.c b/src/network/networkd-radv.c
index 507f0a0ccc8740ab11bc04528ae22b2471b10acc..f6e1841c058a15bf5ef6d0e4a58ecb49d48fcc1b 100644 (file)
--- a/src/network/networkd-radv.c
+++ b/src/network/networkd-radv.c
@@ -582,15 +582,10 @@ static int radv_is_ready_to_configure(Link *link) {
         return true;
 }
 
-int request_process_radv(Request *req) {
-        Link *link;
+int radv_process_request(Request *req, Link *link, void *userdata) {
         int r;
 
-        assert(req);
-        assert(req->link);
-        assert(req->type == REQUEST_TYPE_RADV);
-
-        link = req->link;
+        assert(link);
 
         r = radv_is_ready_to_configure(link);
         if (r <= 0)

diff --git a/src/network/networkd-radv.h b/src/network/networkd-radv.h
index 952fa8ae58e173c4a02ebadd9fa53a0c245e90c1..0d340c955ed47a678c2e7f981760e9b3f5ba839b 100644 (file)
--- a/src/network/networkd-radv.h
+++ b/src/network/networkd-radv.h
@@ -68,7 +68,7 @@ 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 request_process_radv(Request *req);
+int radv_process_request(Request *req, Link *link, void *userdata);
 int link_request_radv(Link *link);
 
 const char* radv_prefix_delegation_to_string(RADVPrefixDelegation i) _const_;

diff --git a/src/network/networkd-route.c b/src/network/networkd-route.c
index a33ab92f3a7ac75f5db73393ea52f2fc5778cb85..1c5ace643ed0dd4f657d1c99b60fdbb634822e9a 100644 (file)
--- a/src/network/networkd-route.c
+++ b/src/network/networkd-route.c
@@ -1319,19 +1319,13 @@ static int route_is_ready_to_configure(const Route *route, Link *link) {
         return true;
 }
 
-int request_process_route(Request *req) {
+int route_process_request(Request *req, Link *link, Route *route) {
         _cleanup_(converted_routes_freep) ConvertedRoutes *converted = NULL;
-        Route *route;
-        Link *link;
         int r;
 
         assert(req);
-        assert(req->link);
-        assert(req->route);
-        assert(req->type == REQUEST_TYPE_ROUTE);
-
-        link = req->link;
-        route = req->route;
+        assert(link);
+        assert(route);
 
         r = route_is_ready_to_configure(route, link);
         if (r < 0)

diff --git a/src/network/networkd-route.h b/src/network/networkd-route.h
index ee8e36f83db2a7b090916a95a200f37907722e15..634ed16176a4a388bd7a67ab4f1c5aeb23ba050d 100644 (file)
--- a/src/network/networkd-route.h
+++ b/src/network/networkd-route.h
@@ -95,7 +95,7 @@ int link_request_route(
                 link_netlink_message_handler_t netlink_handler,
                 Request **ret);
 int link_request_static_routes(Link *link, bool only_ipv4);
-int request_process_route(Request *req);
+int route_process_request(Request *req, Link *link, Route *route);
 
 int manager_rtnl_process_route(sd_netlink *rtnl, sd_netlink_message *message, Manager *m);
 

diff --git a/src/network/networkd-routing-policy-rule.c b/src/network/networkd-routing-policy-rule.c
index 8ff6b0980ceef6feed560c7b655c486bb1613d52..a90c176f7694bcea182d986b89f4e826879f39cc 100644 (file)
--- a/src/network/networkd-routing-policy-rule.c
+++ b/src/network/networkd-routing-policy-rule.c
@@ -724,16 +724,12 @@ void link_foreignize_routing_policy_rules(Link *link) {
         }
 }
 
-int request_process_routing_policy_rule(Request *req) {
-        RoutingPolicyRule *rule;
-        Link *link;
+int routing_policy_rule_process_request(Request *req, Link *link, RoutingPolicyRule *rule) {
         int r;
 
         assert(req);
-        assert(req->type == REQUEST_TYPE_ROUTING_POLICY_RULE);
-
-        link = ASSERT_PTR(req->link);
-        rule = ASSERT_PTR(req->rule);
+        assert(link);
+        assert(rule);
 
         if (!link_is_ready_to_configure(link, false))
                 return 0;

diff --git a/src/network/networkd-routing-policy-rule.h b/src/network/networkd-routing-policy-rule.h
index 2d1ce19165e06bb41966a141610cad0b0e6a1bbb..2d60e595655e4a3eceab0c1e80326c6f83385acc 100644 (file)
--- a/src/network/networkd-routing-policy-rule.h
+++ b/src/network/networkd-routing-policy-rule.h
@@ -64,7 +64,7 @@ int routing_policy_rule_compare_func(const RoutingPolicyRule *a, const RoutingPo
 void network_drop_invalid_routing_policy_rules(Network *network);
 
 int link_request_static_routing_policy_rules(Link *link);
-int request_process_routing_policy_rule(Request *req);
+int routing_policy_rule_process_request(Request *req, Link *link, RoutingPolicyRule *rule);
 
 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);

diff --git a/src/network/networkd-setlink.c b/src/network/networkd-setlink.c
index 69bbff061d8dd3146d224948c3301c3ee3c21285..f5d879af78ae3e2c721b6ba5824fa9f788468ca5 100644 (file)
--- a/src/network/networkd-setlink.c
+++ b/src/network/networkd-setlink.c
@@ -1096,17 +1096,12 @@ static bool link_is_ready_to_activate(Link *link) {
         return true;
 }
 
-int request_process_activation(Request *req) {
-        Link *link;
-        bool up;
+int link_process_activation(Request *req, Link *link, void *userdata) {
+        bool up = PTR_TO_INT(userdata);
         int r;
 
         assert(req);
-        assert(req->link);
-        assert(req->type == REQUEST_TYPE_ACTIVATE_LINK);
-
-        link = req->link;
-        up = PTR_TO_INT(req->userdata);
+        assert(link);
 
         if (!link_is_ready_to_activate(link))
                 return 0;
@@ -1191,17 +1186,12 @@ static bool link_is_ready_to_bring_up_or_down(Link *link, bool up) {
         return true;
 }
 
-int request_process_link_up_or_down(Request *req) {
-        Link *link;
-        bool up;
+int link_process_up_or_down(Request *req, Link *link, void *userdata) {
+        bool up = PTR_TO_INT(userdata);
         int r;
 
         assert(req);
-        assert(req->link);
-        assert(req->type == REQUEST_TYPE_UP_DOWN);
-
-        link = req->link;
-        up = PTR_TO_INT(req->userdata);
+        assert(link);
 
         if (!link_is_ready_to_bring_up_or_down(link, up))
                 return 0;

diff --git a/src/network/networkd-setlink.h b/src/network/networkd-setlink.h
index e943f2012aef9f835a1816c1dd3fda2d72eb6927..3c9853e3add0ced13372d8755aa2b13be7580ff0 100644 (file)
--- a/src/network/networkd-setlink.h
+++ b/src/network/networkd-setlink.h
@@ -42,10 +42,10 @@ int link_configure_mtu(Link *link);
 
 int request_process_set_link(Request *req);
 
-int request_process_activation(Request *req);
+int link_process_activation(Request *req, Link *link, void *userdata);
 int link_request_to_activate(Link *link);
 
-int request_process_link_up_or_down(Request *req);
+int link_process_up_or_down(Request *req, Link *link, void *userdata);
 int link_request_to_bring_up_or_down(Link *link, bool up);
 
 int link_down_now(Link *link);

diff --git a/src/network/tc/qdisc.c b/src/network/tc/qdisc.c
index 9220299c9536e2e860f2e302b86948575fc294af..fa3b0925b92b88dd3d811e8e13aa390e790c1d91 100644 (file)
--- a/src/network/tc/qdisc.c
+++ b/src/network/tc/qdisc.c
@@ -368,14 +368,12 @@ static bool qdisc_is_ready_to_configure(QDisc *qdisc, Link *link) {
         return link_find_tclass(link, qdisc->parent, NULL) >= 0;
 }
 
-int request_process_qdisc(Request *req) {
-        QDisc *qdisc;
-        Link *link;
+int qdisc_process_request(Request *req, Link *link, QDisc *qdisc) {
         int r;
 
         assert(req);
-        assert_se(link = req->link);
-        assert_se(qdisc = req->qdisc);
+        assert(link);
+        assert(qdisc);
 
         if (!qdisc_is_ready_to_configure(qdisc, link))
                 return 0;

diff --git a/src/network/tc/qdisc.h b/src/network/tc/qdisc.h
index 54afe97ced1fb5be11df3d99a9ef8ba2cf41c84d..37ec61cbc7083eb3cd93b851af0a28c868da46e6 100644 (file)
--- a/src/network/tc/qdisc.h
+++ b/src/network/tc/qdisc.h
@@ -82,7 +82,7 @@ int qdisc_compare_func(const QDisc *a, const QDisc *b);
 
 int link_find_qdisc(Link *link, uint32_t handle, uint32_t parent, const char *kind, QDisc **qdisc);
 
-int request_process_qdisc(Request *req);
+int qdisc_process_request(Request *req, Link *link, QDisc *qdisc);
 int link_request_qdisc(Link *link, QDisc *qdisc);
 
 void network_drop_invalid_qdisc(Network *network);

diff --git a/src/network/tc/tclass.c b/src/network/tc/tclass.c
index 937727796eac1aa8e224d683c311454c18db02e8..b5b3615d9883ea524ab023dc4d044c4701bbca07 100644 (file)
--- a/src/network/tc/tclass.c
+++ b/src/network/tc/tclass.c
@@ -327,14 +327,12 @@ static bool tclass_is_ready_to_configure(TClass *tclass, Link *link) {
         return link_find_qdisc(link, tclass->classid, tclass->parent, tclass_get_tca_kind(tclass), NULL) >= 0;
 }
 
-int request_process_tclass(Request *req) {
-        TClass *tclass;
-        Link *link;
+int tclass_process_request(Request *req, Link *link, TClass *tclass) {
         int r;
 
         assert(req);
-        assert_se(link = req->link);
-        assert_se(tclass = req->tclass);
+        assert(link);
+        assert(tclass);
 
         if (!tclass_is_ready_to_configure(tclass, link))
                 return 0;

diff --git a/src/network/tc/tclass.h b/src/network/tc/tclass.h
index c588b38abe5defadd48952eb8f920137ec76c2fd..f7b724b002039cac578f03486919c8e90e042ac6 100644 (file)
--- a/src/network/tc/tclass.h
+++ b/src/network/tc/tclass.h
@@ -64,7 +64,7 @@ int tclass_compare_func(const TClass *a, const TClass *b);
 
 int link_find_tclass(Link *link, uint32_t classid, TClass **ret);
 
-int request_process_tclass(Request *req);
+int tclass_process_request(Request *req, Link *link, TClass *tclass);
 int link_request_tclass(Link *link, TClass *tclass);
 
 void network_drop_invalid_tclass(Network *network);