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.

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)

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_;

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");
 

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);

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;

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);
 

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;

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);

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");
 

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);

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;

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);

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;
 }
 

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);

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;
 }
 

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);

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");
 

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);

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;
 }
 

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);

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;

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);
 

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;

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);

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;

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)

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_;

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)

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);
 

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;

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);

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;

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);

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;

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);

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;

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);