diff --git a/daemon/face/udp-factory.cpp b/daemon/face/udp-factory.cpp
index 2024cd6..0a377ab 100644
--- a/daemon/face/udp-factory.cpp
+++ b/daemon/face/udp-factory.cpp
@@ -80,6 +80,8 @@
   //   }
   // }
 
+  m_wantCongestionMarking = context.generalConfig.wantCongestionMarking;
+
   uint16_t port = 6363;
   bool enableV4 = false;
   bool enableV6 = false;
@@ -292,7 +294,7 @@
                                 ", endpoint already allocated for a UDP multicast face"));
   }
 
-  auto channel = std::make_shared<UdpChannel>(localEndpoint, idleTimeout);
+  auto channel = std::make_shared<UdpChannel>(localEndpoint, idleTimeout, m_wantCongestionMarking);
   m_channels[localEndpoint] = channel;
 
   return channel;
@@ -345,7 +347,9 @@
   ip::udp::socket txSock(getGlobalIoService());
   MulticastUdpTransport::openTxSocket(txSock, udp::Endpoint(localAddress, 0), netif);
 
-  auto linkService = make_unique<GenericLinkService>();
+  GenericLinkService::Options options;
+  options.allowCongestionMarking = m_wantCongestionMarking;
+  auto linkService = make_unique<GenericLinkService>(options);
   auto transport = make_unique<MulticastUdpTransport>(mcastEp, std::move(rxSock), std::move(txSock),
                                                       m_mcastConfig.linkType);
   auto face = make_shared<Face>(std::move(linkService), std::move(transport));
