NEWS: mention NetworkEmulatorDuplicateRate= setting

tc qdisc: netem add support to duplicate packets.

NEWS

@@ -127,7 +127,8 @@ CHANGES WITH 244 in spe:
           disciplines in the kernel using the new
           [TrafficControlQueueingDiscipline] section and Parent=,
           NetworkEmulatorDelaySec=, NetworkEmulatorDelayJitterSec=,
-          NetworkEmulatorPacketLimit=, NetworkEmulatorLossRate= settings.
+          NetworkEmulatorPacketLimit=, NetworkEmulatorLossRate=,
+          NetworkEmulatorDuplicateRate= settings.
 
         * systemd-tmpfiles gained a new w+ setting to append to files.
 

man/systemd.network.xml

@@ -2351,6 +2351,14 @@
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><varname>NetworkEmulatorDuplicateRate=</varname></term>
+        <listitem>
+          <para>Specifies that the chosen percent of packets is duplicated before queuing them.
+          Takes a percentage value, suffixed with "%". Defaults to unset.</para>
+        </listitem>
+      </varlistentry>
+
     </variablelist>
   </refsect1>
 

src/libsystemd-network/sd-dhcp-server.c

@@ -151,10 +151,8 @@ _public_ int sd_dhcp_raw_option_new(uint8_t type, char *data, size_t length, sd_
                   .type = type,
         };
 
-        if (!p->data) {
+        if (!p->data)
-                free(p);
                 return -ENOMEM;
-        }
 
         *ret = TAKE_PTR(p);
         return 0;

src/network/networkd-network-gperf.gperf

@@ -247,7 +247,8 @@ CAN.TripleSampling,                     config_parse_tristate,
 TrafficControlQueueingDiscipline.Parent,                             config_parse_tc_qdiscs_parent,                     0,                             0
 TrafficControlQueueingDiscipline.NetworkEmulatorDelaySec,            config_parse_tc_network_emulator_delay,            0,                             0
 TrafficControlQueueingDiscipline.NetworkEmulatorDelayJitterSec,      config_parse_tc_network_emulator_delay,            0,                             0
-TrafficControlQueueingDiscipline.NetworkEmulatorLossRate,            config_parse_tc_network_emulator_loss_rate,        0,                             0
+TrafficControlQueueingDiscipline.NetworkEmulatorLossRate,            config_parse_tc_network_emulator_rate,             0,                             0
+TrafficControlQueueingDiscipline.NetworkEmulatorDuplicateRate,       config_parse_tc_network_emulator_rate,             0,                             0
 TrafficControlQueueingDiscipline.NetworkEmulatorPacketLimit,         config_parse_tc_network_emulator_packet_limit,     0,                             0
 /* backwards compatibility: do not add new entries to this section */
 Network.IPv4LL,                         config_parse_ipv4ll,                             0,                             offsetof(Network, link_local)

src/network/tc/netem.c

@@ -50,6 +50,9 @@ int network_emulator_fill_message(Link *link, QDiscs *qdisc, sd_netlink_message
         if (qdisc->ne.loss > 0)
                 opt.loss = qdisc->ne.loss;
 
+        if (qdisc->ne.duplicate > 0)
+                opt.duplicate = qdisc->ne.duplicate;
+
         if (qdisc->ne.delay != USEC_INFINITY) {
                 r = tc_time_to_tick(qdisc->ne.delay, &opt.latency);
                 if (r < 0)
@@ -124,7 +127,7 @@ int config_parse_tc_network_emulator_delay(
         return 0;
 }
 
-int config_parse_tc_network_emulator_loss_rate(
+int config_parse_tc_network_emulator_rate(
                 const char *unit,
                 const char *filename,
                 unsigned line,
@@ -138,6 +141,7 @@ int config_parse_tc_network_emulator_loss_rate(
 
         _cleanup_(qdisc_free_or_set_invalidp) QDiscs *qdisc = NULL;
         Network *network = data;
+        uint32_t rate;
         int r;
 
         assert(filename);
@@ -156,14 +160,19 @@ int config_parse_tc_network_emulator_loss_rate(
                 return 0;
         }
 
-        r = parse_tc_percent(rvalue, &qdisc->ne.loss);
+        r = parse_tc_percent(rvalue, &rate);
         if (r < 0) {
                 log_syntax(unit, LOG_ERR, filename, line, r,
-                           "Failed to parse 'NetworkEmularorLossRate=', ignoring assignment: %s",
+                           "Failed to parse '%s=', ignoring assignment: %s",
-                           rvalue);
+                           lvalue, rvalue);
                 return 0;
         }
 
+        if (streq(lvalue, "NetworkEmulatorLossRate"))
+                qdisc->ne.loss = rate;
+        else if (streq(lvalue, "NetworkEmulatorDuplicateRate"))
+                qdisc->ne.duplicate = rate;
+
         qdisc = NULL;
         return 0;
 }

src/network/tc/netem.h

@@ -16,11 +16,12 @@ typedef struct NetworkEmulator {
 
         uint32_t limit;
         uint32_t loss;
+        uint32_t duplicate;
 } NetworkEmulator;
 
 int network_emulator_new(NetworkEmulator **ret);
 int network_emulator_fill_message(Link *link, QDiscs *qdisc, sd_netlink_message *req);
 
 CONFIG_PARSER_PROTOTYPE(config_parse_tc_network_emulator_delay);
-CONFIG_PARSER_PROTOTYPE(config_parse_tc_network_emulator_loss_rate);
+CONFIG_PARSER_PROTOTYPE(config_parse_tc_network_emulator_rate);
 CONFIG_PARSER_PROTOTYPE(config_parse_tc_network_emulator_packet_limit);

src/network/tc/qdisc.c

@@ -116,6 +116,7 @@ static int qdisc_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 
 int qdisc_configure(Link *link, QDiscs *qdisc) {
         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
+        _cleanup_free_ char *tca_kind = NULL;
         int r;
 
         assert(link);
@@ -132,25 +133,31 @@ int qdisc_configure(Link *link, QDiscs *qdisc) {
                 return log_link_error_errno(link, r, "Could not create tcm_parent message: %m");
 
         if (qdisc->parent == TC_H_CLSACT) {
+                tca_kind = strdup("clsact");
+                if (!tca_kind)
+                        return log_oom();
+
                 r = sd_rtnl_message_set_qdisc_handle(req, TC_H_MAKE(TC_H_CLSACT, 0));
                 if (r < 0)
                         return log_link_error_errno(link, r, "Could not set tcm_handle message: %m");
-
-                r = sd_netlink_message_append_string(req, TCA_KIND, "clsact");
-                if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
         }
 
         if (qdisc->has_network_emulator) {
-                r = sd_netlink_message_append_string(req, TCA_KIND, "netem");
+                r = free_and_strdup(&tca_kind, "netem");
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
+                        return log_oom();
 
                 r = network_emulator_fill_message(link, qdisc, req);
                 if (r < 0)
                         return r;
         }
 
+        if (tca_kind) {
+                r = sd_netlink_message_append_string(req, TCA_KIND, tca_kind);
+                if (r < 0)
+                        return log_link_error_errno(link, r, "Could not append TCA_KIND attribute: %m");
+        }
+
         r = netlink_call_async(link->manager->rtnl, NULL, req, qdisc_handler, link_netlink_destroy_callback, link);
         if (r < 0)
                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");

test/fuzz/fuzz-network-parser/directives.network

@@ -268,4 +268,5 @@ Parent=
 NetworkEmulatorDelaySec=
 NetworkEmulatorDelayJitterSec=
 NetworkEmulatorLossRate=
+NetworkEmulatorDuplicateRate=
 NetworkEmulatorPacketLimit=