diff --git a/src/connectionmanager.cpp b/src/connectionmanager.cpp
index a1b38d88..c209d9a8 100644
--- a/src/connectionmanager.cpp
+++ b/src/connectionmanager.cpp
@@ -106,7 +106,7 @@ struct ConnectionInfo
     std::unique_ptr<asio::steady_timer> waitForAnswer_ {};
 
     void shutdown() {
-        std::lock_guard<std::mutex> lk(mutex_);
+        std::lock_guard lk(mutex_);
         if (tls_)
             tls_->shutdown();
         if (socket_)
@@ -232,7 +232,7 @@ struct DeviceInfo {
             cb.cb(sock, deviceId);
     }
     void executePendingOperations(dht::Value::Id vid, const std::shared_ptr<ChannelSocket>& sock, bool accepted = true) {
-        std::unique_lock<std::mutex> lock(mtx_);
+        std::unique_lock lock(mtx_);
         executePendingOperations(lock, vid, sock, accepted);
     }
 
@@ -264,11 +264,11 @@ struct DeviceInfo {
 
     std::vector<std::map<std::string, std::string>>
     getConnectionList(tls::CertificateStore& certStore) const {
-        std::lock_guard<std::mutex> lk(mtx_);
+        std::lock_guard lk(mtx_);
         std::vector<std::map<std::string, std::string>> ret;
         ret.reserve(info.size() + connecting.size() + waiting.size());
         for (auto& [id, ci] : info) {
-            std::lock_guard<std::mutex> lk(ci->mutex_);
+            std::lock_guard lk(ci->mutex_);
             ret.emplace_back(ci->getInfo(deviceId, id, certStore));
         }
         auto cert = certStore.getCertificate(deviceId.toString());
@@ -295,7 +295,7 @@ struct DeviceInfo {
 class DeviceInfoSet {
 public:
     std::shared_ptr<DeviceInfo> getDeviceInfo(const DeviceId& deviceId) {
-        std::lock_guard<std::mutex> lk(mtx_);
+        std::lock_guard lk(mtx_);
         auto it = infos_.find(deviceId);
         if (it != infos_.end())
             return it->second;
@@ -304,7 +304,7 @@ class DeviceInfoSet {
 
     std::vector<std::shared_ptr<DeviceInfo>> getDeviceInfos() {
         std::vector<std::shared_ptr<DeviceInfo>> deviceInfos;
-        std::lock_guard<std::mutex> lk(mtx_);
+        std::lock_guard lk(mtx_);
         deviceInfos.reserve(infos_.size());
         for (auto& [deviceId, info] : infos_)
             deviceInfos.emplace_back(info);
@@ -312,7 +312,7 @@ class DeviceInfoSet {
     }
 
     std::shared_ptr<DeviceInfo> createDeviceInfo(const DeviceId& deviceId) {
-        std::lock_guard<std::mutex> lk(mtx_);
+        std::lock_guard lk(mtx_);
         auto& info = infos_[deviceId];
         if (!info)
             info = std::make_shared<DeviceInfo>(deviceId);
@@ -320,13 +320,13 @@ class DeviceInfoSet {
     }
 
     bool removeDeviceInfo(const DeviceId& deviceId) {
-        std::lock_guard<std::mutex> lk(mtx_);
+        std::lock_guard lk(mtx_);
         return infos_.erase(deviceId) != 0;
     }
 
     std::shared_ptr<ConnectionInfo> getInfo(const DeviceId& deviceId, const dht::Value::Id& id) {
         if (auto info = getDeviceInfo(deviceId)) {
-            std::lock_guard<std::mutex> lk(info->mtx_);
+            std::lock_guard lk(info->mtx_);
             auto it = info->info.find(id);
             if (it != info->info.end())
                 return it->second;
@@ -339,7 +339,7 @@ class DeviceInfoSet {
         std::vector<std::shared_ptr<ConnectionInfo>> ret;
         ret.reserve(deviceInfos.size());
         for (auto& info : deviceInfos) {
-            std::lock_guard<std::mutex> lk(info->mtx_);
+            std::lock_guard lk(info->mtx_);
             for (auto& [id, ci] : info->info) {
                 if (ci->socket_)
                     ret.emplace_back(ci);
@@ -349,7 +349,7 @@ class DeviceInfoSet {
     }
     std::vector<std::shared_ptr<DeviceInfo>> shutdown() {
         std::vector<std::shared_ptr<DeviceInfo>> ret;
-        std::lock_guard<std::mutex> lk(mtx_);
+        std::lock_guard lk(mtx_);
         ret.reserve(infos_.size());
         for (auto& [deviceId, info] : infos_) {
             ret.emplace_back(std::move(info));
@@ -415,7 +415,7 @@ class ConnectionManager::Impl : public std::enable_shared_from_this<ConnectionMa
         std::vector<std::shared_ptr<ConnectionInfo>> unused;
         std::vector<std::pair<DeviceId, std::vector<PendingCb>>> pending;
         for (auto& dinfo: infos_.shutdown()) {
-            std::lock_guard<std::mutex> lk(dinfo->mtx_);
+            std::lock_guard lk(dinfo->mtx_);
             auto p = dinfo->extractPendingOperations(0, nullptr, false);
             if (!p.empty())
                 pending.emplace_back(dinfo->deviceId, std::move(p));
@@ -605,7 +605,7 @@ ConnectionManager::Impl::connectDeviceStartIce(
         return;
     }
 
-    std::unique_lock<std::mutex> lk(info->mutex_);
+    std::unique_lock lk(info->mutex_);
     auto& ice = info->ice_;
 
     if (!ice) {
@@ -674,7 +674,7 @@ ConnectionManager::Impl::onResponse(const asio::error_code& ec,
     if (!info)
         return;
 
-    std::unique_lock<std::mutex> lk(info->mutex_);
+    std::unique_lock lk(info->mutex_);
     auto& ice = info->ice_;
     if (isDestroying_) {
         info->onConnected_(true); // The destructor can wake a pending wait here.
@@ -715,7 +715,7 @@ ConnectionManager::Impl::connectDeviceOnNegoDone(
     if (!info)
         return false;
 
-    std::unique_lock<std::mutex> lk {info->mutex_};
+    std::unique_lock lk {info->mutex_};
     if (info->waitForAnswer_) {
         // Negotiation is done and connected, go to handshake
         // and avoid any cancellation at this point.
@@ -872,11 +872,11 @@ ConnectionManager::Impl::connectDevice(const std::shared_ptr<dht::crypto::Certif
             return;
         }
         auto di = sthis->infos_.createDeviceInfo(deviceId);
-        std::unique_lock<std::mutex> lk(di->mtx_);
+        std::unique_lock lk(di->mtx_);
 
         dht::Value::Id vid;
         {
-            std::lock_guard<std::mutex> lkr(sthis->randMtx_);
+            std::lock_guard lkr(sthis->randMtx_);
             vid = di->newId(sthis->rand_);
         }
 
@@ -892,7 +892,7 @@ ConnectionManager::Impl::connectDevice(const std::shared_ptr<dht::crypto::Certif
 
         // Check if already negotiated
         if (auto info = di->getConnectedInfo()) {
-            std::unique_lock<std::mutex> lkc(info->mutex_);
+            std::unique_lock lkc(info->mutex_);
             if (auto sock = info->socket_) {
                 info->cbIds_.emplace(vid);
                 diw.requested = true;
@@ -920,7 +920,7 @@ ConnectionManager::Impl::connectDevice(const std::shared_ptr<dht::crypto::Certif
         // all stored structures.
         auto eraseInfo = [w, diw=std::weak_ptr(di), vid] {
             if (auto di = diw.lock()) {
-                std::unique_lock<std::mutex> lk(di->mtx_);
+                std::unique_lock lk(di->mtx_);
                 di->info.erase(vid);
                 auto ops = di->extractPendingOperations(vid, nullptr);
                 if (di->empty()) {
@@ -1006,10 +1006,10 @@ ConnectionManager::Impl::connectDevice(const std::shared_ptr<dht::crypto::Certif
             };
 
             if (auto di = diw.lock()) {
-                std::lock_guard<std::mutex> lk(di->mtx_);
+                std::lock_guard lk(di->mtx_);
                 di->info[vid] = info;
             }
-            std::unique_lock<std::mutex> lk {info->mutex_};
+            std::unique_lock lk {info->mutex_};
             ice_config.master = false;
             ice_config.streamsCount = 1;
             ice_config.compCountPerStream = 1;
@@ -1062,7 +1062,7 @@ ConnectionManager::Impl::sendChannelRequest(const std::weak_ptr<DeviceInfo>& din
                 // Always lock top-down cinfo->mutex
                 dht::ThreadPool::io().run([cinfow, vid]() {
                     if (auto cinfo = cinfow.lock()) {
-                        std::lock_guard<std::mutex> lk(cinfo->mutex_);
+                        std::lock_guard lk(cinfo->mutex_);
                         cinfo->cbIds_.erase(vid);
                     }
                 });
@@ -1095,7 +1095,7 @@ ConnectionManager::Impl::onPeerResponse(PeerConnectionRequest&& req)
     if (auto info = infos_.getInfo(device, req.id)) {
         if (config_->logger)
             config_->logger->debug("[device {}] New response received", device);
-        std::lock_guard<std::mutex> lk {info->mutex_};
+        std::lock_guard lk {info->mutex_};
         info->responseReceived_ = true;
         info->response_ = std::move(req);
         info->waitForAnswer_->expires_at(std::chrono::steady_clock::now());
@@ -1197,7 +1197,7 @@ ConnectionManager::Impl::onTlsNegotiationDone(const std::shared_ptr<DeviceInfo>&
             dinfo->executePendingOperations(vid, nullptr);
         }
 
-        std::unique_lock<std::mutex> lk(dinfo->mtx_);
+        std::unique_lock lk(dinfo->mtx_);
         dinfo->info.erase(vid);
 
         if (dinfo->empty()) {
@@ -1219,10 +1219,10 @@ ConnectionManager::Impl::onTlsNegotiationDone(const std::shared_ptr<DeviceInfo>&
         }
 
         // Note: do not remove pending there it's done in sendChannelRequest
-        std::unique_lock<std::mutex> lk2 {dinfo->mtx_};
+        std::unique_lock lk2 {dinfo->mtx_};
         auto pendingIds = dinfo->requestPendingOps();
         lk2.unlock();
-        std::unique_lock<std::mutex> lk {info->mutex_};
+        std::unique_lock lk {info->mutex_};
         addNewMultiplexedSocket(dinfo, deviceId, vid, info);
         // Finally, open the channel and launch pending callbacks
         lk.unlock();
@@ -1278,7 +1278,7 @@ ConnectionManager::Impl::onRequestStartIce(const std::shared_ptr<ConnectionInfo>
         return false;
 
     auto deviceId = req.owner->getLongId();
-    std::unique_lock<std::mutex> lk {info->mutex_};
+    std::unique_lock lk {info->mutex_};
     auto& ice = info->ice_;
     if (!ice) {
         if (config_->logger)
@@ -1308,7 +1308,7 @@ ConnectionManager::Impl::onRequestOnNegoDone(const std::weak_ptr<DeviceInfo>& di
         return false;
 
     auto deviceId = req.owner->getLongId();
-    std::unique_lock<std::mutex> lk {info->mutex_};
+    std::unique_lock lk {info->mutex_};
     auto& ice = info->ice_;
     if (!ice) {
         if (config_->logger)
@@ -1391,7 +1391,7 @@ ConnectionManager::Impl::onDhtPeerRequest(const PeerConnectionRequest& req,
         auto eraseInfo = [w, wdi, id = req.id] {
             auto shared = w.lock();
             if (auto di = wdi.lock()) {
-                std::unique_lock<std::mutex> lk(di->mtx_);
+                std::unique_lock lk(di->mtx_);
                 di->info.erase(id);
                 auto ops = di->extractPendingOperations(id, nullptr);
                 if (di->empty()) {
@@ -1451,13 +1451,13 @@ ConnectionManager::Impl::onDhtPeerRequest(const PeerConnectionRequest& req,
 
         // Negotiate a new ICE socket
         {
-            std::lock_guard<std::mutex> lk(di->mtx_);
+            std::lock_guard lk(di->mtx_);
             di->info[req.id] = info;
         }
 
         if (shared->config_->logger)
             shared->config_->logger->debug("[device {}] Accepting connection", deviceId);
-        std::unique_lock<std::mutex> lk {info->mutex_};
+        std::unique_lock lk {info->mutex_};
         info->ice_ = shared->config_->factory->createUTransport("");
         if (not info->ice_) {
             if (shared->config_->logger)
@@ -1502,7 +1502,7 @@ ConnectionManager::Impl::addNewMultiplexedSocket(const std::weak_ptr<DeviceInfo>
         dht::ThreadPool::io().run([dinfo, wi, vid] {
             std::set<dht::Value::Id> ids;
             if (auto info = wi.lock()) {
-                std::lock_guard<std::mutex> lk(info->mutex_);
+                std::lock_guard lk(info->mutex_);
                 if (info->socket_) {
                     ids = std::move(info->cbIds_);
                     info->socket_->shutdown();
@@ -1511,7 +1511,7 @@ ConnectionManager::Impl::addNewMultiplexedSocket(const std::weak_ptr<DeviceInfo>
             if (auto deviceInfo = dinfo.lock()) {
                 std::shared_ptr<ConnectionInfo> info;
                 std::vector<PendingCb> ops;
-                std::unique_lock<std::mutex> lk(deviceInfo->mtx_);
+                std::unique_lock lk(deviceInfo->mtx_);
                 auto it = deviceInfo->info.find(vid);
                 if (it != deviceInfo->info.end()) {
                     info = std::move(it->second);
@@ -1539,7 +1539,7 @@ ConnectionManager::Impl::dhParams() const
 bool
 ConnectionManager::Impl::isMessageTreated(dht::Value::Id id)
 {
-    std::lock_guard<std::mutex> lock(messageMutex_);
+    std::lock_guard lock(messageMutex_);
     return !treatedMessages_.add(id);
 }
 
@@ -1815,7 +1815,7 @@ bool
 ConnectionManager::isConnecting(const DeviceId& deviceId, const std::string& name) const
 {
     if (auto dinfo = pimpl_->infos_.getDeviceInfo(deviceId)) {
-        std::unique_lock<std::mutex> lk {dinfo->mtx_};
+        std::unique_lock lk {dinfo->mtx_};
         return dinfo->isConnecting(name);
     }
     return false;
@@ -1825,7 +1825,7 @@ bool
 ConnectionManager::isConnected(const DeviceId& deviceId) const
 {
     if (auto dinfo = pimpl_->infos_.getDeviceInfo(deviceId)) {
-        std::unique_lock<std::mutex> lk {dinfo->mtx_};
+        std::unique_lock lk {dinfo->mtx_};
         return dinfo->getConnectedInfo() != nullptr;
     }
     return false;
@@ -1836,10 +1836,10 @@ ConnectionManager::closeConnectionsWith(const std::string& peerUri)
 {
     std::vector<std::shared_ptr<DeviceInfo>> dInfos;
     for (const auto& dinfo: pimpl_->infos_.getDeviceInfos()) {
-        std::unique_lock<std::mutex> lk(dinfo->mtx_);
+        std::unique_lock lk(dinfo->mtx_);
         bool isPeer = false;
         for (auto const& [id, cinfo]: dinfo->info) {
-            std::lock_guard<std::mutex> lkv {cinfo->mutex_};
+            std::lock_guard lkv {cinfo->mutex_};
             auto tls = cinfo->tls_ ? cinfo->tls_.get() : (cinfo->socket_ ? cinfo->socket_->endpoint() : nullptr);
             auto cert = tls ? tls->peerCertificate() : nullptr;
             if (not cert)
@@ -1856,7 +1856,7 @@ ConnectionManager::closeConnectionsWith(const std::string& peerUri)
     }
     // Stop connections to all peers devices
     for (const auto& dinfo : dInfos) {
-        std::unique_lock<std::mutex> lk {dinfo->mtx_};
+        std::unique_lock lk {dinfo->mtx_};
         auto unused = dinfo->extractUnusedConnections();
         auto pending = dinfo->extractPendingOperations(0, nullptr);
         pimpl_->infos_.removeDeviceInfo(dinfo->deviceId);
@@ -1912,7 +1912,7 @@ ConnectionManager::monitor() const
         return;
     logger->debug("ConnectionManager current status:");
     for (const auto& ci : pimpl_->infos_.getConnectedInfos()) {
-        std::lock_guard<std::mutex> lk(ci->mutex_);
+        std::lock_guard lk(ci->mutex_);
         if (ci->socket_)
             ci->socket_->monitor();
     }
@@ -1923,7 +1923,7 @@ void
 ConnectionManager::connectivityChanged()
 {
     for (const auto& ci : pimpl_->infos_.getConnectedInfos()) {
-        std::lock_guard<std::mutex> lk(ci->mutex_);
+        std::lock_guard lk(ci->mutex_);
         if (ci->socket_)
             dht::ThreadPool::io().run([s = ci->socket_] { s->sendBeacon(); });
     }
@@ -1987,7 +1987,7 @@ ConnectionManager::getChannelList(const std::string& connectionId) const
 {
     auto [deviceId, valueId] = parseCallbackId(connectionId);
     if (auto info = pimpl_->infos_.getInfo(deviceId, valueId)) {
-        std::lock_guard<std::mutex> lk(info->mutex_);
+        std::lock_guard lk(info->mutex_);
         if (info->socket_)
             return info->socket_->getChannelList();
     }
diff --git a/src/fileutils.cpp b/src/fileutils.cpp
index 72e78b65..9e235277 100644
--- a/src/fileutils.cpp
+++ b/src/fileutils.cpp
@@ -82,7 +82,7 @@ getFileLock(const std::filesystem::path& path)
     static std::mutex fileLockLock {};
     static std::map<std::string, std::mutex> fileLocks {};
 
-    std::lock_guard<std::mutex> l(fileLockLock);
+    std::lock_guard l(fileLockLock);
     return fileLocks[path.string()];
 }
 
diff --git a/src/ice_transport.cpp b/src/ice_transport.cpp
index 52a6383e..d9beef83 100644
--- a/src/ice_transport.cpp
+++ b/src/ice_transport.cpp
@@ -70,8 +70,6 @@ static constexpr int HANDLE_EVENT_DURATION {500};
 
 //==============================================================================
 
-using MutexGuard = std::lock_guard<std::mutex>;
-using MutexLock = std::unique_lock<std::mutex>;
 using namespace upnp;
 
 //==============================================================================
@@ -233,7 +231,7 @@ class IceTransport::Impl
     {
         for (auto& c : peerChannels_)
             c.stop();
-        std::lock_guard<std::mutex> lk(sendDataMutex_);
+        std::lock_guard lk(sendDataMutex_);
         destroying_ = true;
         waitDataCv_.notify_all();
     }
@@ -926,7 +924,7 @@ IceTransport::Impl::requestUpnpMappings()
 {
     // Must be called once !
 
-    std::lock_guard<std::mutex> lock(upnpMutex_);
+    std::lock_guard lock(upnpMutex_);
 
     if (not upnp_)
         return;
@@ -945,7 +943,7 @@ IceTransport::Impl::requestUpnpMappings()
         // To use a mapping, it must be valid, open and has valid host address.
         if (mapPtr and mapPtr->getMapKey() and (mapPtr->getState() == MappingState::OPEN)
             and mapPtr->hasValidHostAddress()) {
-            std::lock_guard<std::mutex> lock(upnpMappingsMutex_);
+            std::lock_guard lock(upnpMappingsMutex_);
             auto ret = upnpMappings_.emplace(mapPtr->getMapKey(), *mapPtr);
             if (ret.second) {
                 if (logger_)
@@ -1070,7 +1068,7 @@ IceTransport::Impl::setupUpnpReflexiveCandidates()
     if (not hasUpnp())
         return {};
 
-    std::lock_guard<std::mutex> lock(upnpMappingsMutex_);
+    std::lock_guard lock(upnpMappingsMutex_);
 
     if (upnpMappings_.size() < (size_t)compCount_) {
         if (logger_)
@@ -1132,7 +1130,7 @@ IceTransport::Impl::onReceiveData(unsigned comp_id, void* pkt, pj_size_t size)
 
     {
         auto& io = compIO_[comp_id - 1];
-        std::lock_guard<std::mutex> lk(io.mutex);
+        std::lock_guard lk(io.mutex);
 
         if (io.recvCb) {
             io.recvCb((uint8_t*) pkt, size);
@@ -1633,7 +1631,7 @@ IceTransport::recv(unsigned compId, unsigned char* buf, size_t len, std::error_c
 {
     ASSERT_COMP_ID(compId, getComponentCount());
     auto& io = pimpl_->compIO_[compId - 1];
-    std::lock_guard<std::mutex> lk(io.mutex);
+    std::lock_guard lk(io.mutex);
 
     if (io.queue.empty()) {
         ec = std::make_error_code(std::errc::resource_unavailable_try_again);
@@ -1666,7 +1664,7 @@ IceTransport::setOnRecv(unsigned compId, IceRecvCb cb)
     ASSERT_COMP_ID(compId, getComponentCount());
 
     auto& io = pimpl_->compIO_[compId - 1];
-    std::lock_guard<std::mutex> lk(io.mutex);
+    std::lock_guard lk(io.mutex);
     io.recvCb = std::move(cb);
 
     if (io.recvCb) {
diff --git a/src/multiplexed_socket.cpp b/src/multiplexed_socket.cpp
index f95a1b0d..8386d2b9 100644
--- a/src/multiplexed_socket.cpp
+++ b/src/multiplexed_socket.cpp
@@ -99,7 +99,7 @@ class MultiplexedSocket::Impl
     {
         decltype(sockets) socks;
         {
-            std::lock_guard<std::mutex> lkSockets(socketsMutex);
+            std::lock_guard lkSockets(socketsMutex);
             socks = std::move(sockets);
         }
         for (auto& socket : socks) {
@@ -121,7 +121,7 @@ class MultiplexedSocket::Impl
         if (onShutdown_)
             onShutdown_();
         if (endpoint) {
-            std::unique_lock<std::mutex> lk(writeMtx);
+            std::unique_lock lk(writeMtx);
             endpoint->shutdown();
         }
         clearSockets();
@@ -276,7 +276,7 @@ MultiplexedSocket::Impl::eventLoop()
 void
 MultiplexedSocket::Impl::onAccept(const std::string& name, uint16_t channel)
 {
-    std::lock_guard<std::mutex> lkSockets(socketsMutex);
+    std::lock_guard lkSockets(socketsMutex);
     auto& socket = sockets[channel];
     if (!socket) {
         if (logger_)
@@ -404,7 +404,7 @@ MultiplexedSocket::Impl::onRequest(const std::string& name, uint16_t channel)
 
     std::shared_ptr<ChannelSocket> channelSocket;
     if (accept) {
-        std::lock_guard<std::mutex> lkSockets(socketsMutex);
+        std::lock_guard lkSockets(socketsMutex);
         channelSocket = makeSocket(name, channel, false);
         if (not channelSocket) {
             if (logger_)
@@ -436,7 +436,7 @@ MultiplexedSocket::Impl::onRequest(const std::string& name, uint16_t channel)
         onChannelReady_(deviceId, channelSocket);
         channelSocket->ready(true);
         if (channelSocket->isRemovable()) {
-            std::lock_guard<std::mutex> lkSockets(socketsMutex);
+            std::lock_guard lkSockets(socketsMutex);
             sockets.erase(channel);
         } else
             channelSocket->answered();
@@ -465,7 +465,7 @@ MultiplexedSocket::Impl::handleControlPacket(std::vector<uint8_t>&& pkt)
                 onAccept(req.name, req.channel);
             } else {
                 // DECLINE or unknown
-                std::lock_guard<std::mutex> lkSockets(socketsMutex);
+                std::lock_guard lkSockets(socketsMutex);
                 auto channel = sockets.find(req.channel);
                 if (channel != sockets.end()) {
                     channel->second->ready(false);
@@ -483,7 +483,7 @@ MultiplexedSocket::Impl::handleControlPacket(std::vector<uint8_t>&& pkt)
 void
 MultiplexedSocket::Impl::handleChannelPacket(uint16_t channel, std::vector<uint8_t>&& pkt)
 {
-    std::lock_guard<std::mutex> lkSockets(socketsMutex);
+    std::lock_guard lkSockets(socketsMutex);
     auto sockIt = sockets.find(channel);
     if (channel > 0 && sockIt != sockets.end() && sockIt->second) {
         if (pkt.size() == 0) {
@@ -569,7 +569,7 @@ MultiplexedSocket::~MultiplexedSocket() {}
 std::shared_ptr<ChannelSocket>
 MultiplexedSocket::addChannel(const std::string& name)
 {
-    std::lock_guard<std::mutex> lk(pimpl_->socketsMutex);
+    std::lock_guard lk(pimpl_->socketsMutex);
     if (pimpl_->sockets.size() < UINT16_MAX)
         for (unsigned i = 0; i < UINT16_MAX; ++i) {
             auto c = pimpl_->nextChannel_++;
@@ -653,7 +653,7 @@ MultiplexedSocket::write(const uint16_t& channel,
     if (oneShot)
         pk.pack_bin_body((const char*) buf, len);
 
-    std::unique_lock<std::mutex> lk(pimpl_->writeMtx);
+    std::unique_lock lk(pimpl_->writeMtx);
     if (!pimpl_->endpoint) {
         if (pimpl_->logger_)
             pimpl_->logger_->warn("No endpoint found for socket");
@@ -710,7 +710,7 @@ MultiplexedSocket::monitor() const
     pimpl_->logger_->debug("- Socket with device: {:s} - account: {:s}", deviceId(), cert->issuer->getId());
     pimpl_->logger_->debug("- Duration: {}", dht::print_duration(now - pimpl_->start_));
     pimpl_->endpoint->monitor();
-    std::lock_guard<std::mutex> lk(pimpl_->socketsMutex);
+    std::lock_guard lk(pimpl_->socketsMutex);
     for (const auto& [_, channel] : pimpl_->sockets) {
         if (channel)
             pimpl_->logger_->debug("\t\t- Channel {} (count: {}) with name {:s} Initiator: {}",
@@ -793,7 +793,7 @@ MultiplexedSocket::endpoint()
 void
 MultiplexedSocket::eraseChannel(uint16_t channel)
 {
-    std::lock_guard<std::mutex> lkSockets(pimpl_->socketsMutex);
+    std::lock_guard lkSockets(pimpl_->socketsMutex);
     auto itSocket = pimpl_->sockets.find(channel);
     if (pimpl_->sockets.find(channel) != pimpl_->sockets.end())
         pimpl_->sockets.erase(itSocket);
@@ -878,7 +878,7 @@ void
 ChannelSocketTest::shutdown()
 {
     {
-        std::unique_lock<std::mutex> lk {mutex};
+        std::unique_lock lk {mutex};
         if (!isShutdown_.exchange(true)) {
             lk.unlock();
             shutdownCb_();
@@ -928,7 +928,7 @@ ChannelSocketTest::write(const ValueType* buf, std::size_t len, std::error_code&
 int
 ChannelSocketTest::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
 {
-    std::unique_lock<std::mutex> lk {mutex};
+    std::unique_lock lk {mutex};
     cv.wait_for(lk, timeout, [&] { return !rx_buf.empty() or isShutdown_; });
     return rx_buf.size();
 }
@@ -936,7 +936,7 @@ ChannelSocketTest::waitForData(std::chrono::milliseconds timeout, std::error_cod
 void
 ChannelSocketTest::setOnRecv(RecvCb&& cb)
 {
-    std::lock_guard<std::mutex> lkSockets(mutex);
+    std::lock_guard lkSockets(mutex);
     this->cb = std::move(cb);
     if (!rx_buf.empty() && this->cb) {
         this->cb(rx_buf.data(), rx_buf.size());
@@ -947,7 +947,7 @@ ChannelSocketTest::setOnRecv(RecvCb&& cb)
 void
 ChannelSocketTest::onRecv(std::vector<uint8_t>&& pkt)
 {
-    std::lock_guard<std::mutex> lkSockets(mutex);
+    std::lock_guard lkSockets(mutex);
     if (cb) {
         cb(pkt.data(), pkt.size());
         return;
@@ -965,7 +965,7 @@ ChannelSocketTest::onReady(ChannelReadyCb&& cb)
 void
 ChannelSocketTest::onShutdown(OnShutdownCb&& cb)
 {
-    std::unique_lock<std::mutex> lk {mutex};
+    std::unique_lock lk {mutex};
     shutdownCb_ = std::move(cb);
 
     if (isShutdown_) {
@@ -1037,7 +1037,7 @@ ChannelSocket::maxPayload() const
 void
 ChannelSocket::setOnRecv(RecvCb&& cb)
 {
-    std::lock_guard<std::mutex> lkSockets(pimpl_->mutex);
+    std::lock_guard lkSockets(pimpl_->mutex);
     pimpl_->cb = std::move(cb);
     if (!pimpl_->buf.empty() && pimpl_->cb) {
         pimpl_->cb(pimpl_->buf.data(), pimpl_->buf.size());
@@ -1048,7 +1048,7 @@ ChannelSocket::setOnRecv(RecvCb&& cb)
 void
 ChannelSocket::onRecv(std::vector<uint8_t>&& pkt)
 {
-    std::lock_guard<std::mutex> lkSockets(pimpl_->mutex);
+    std::lock_guard lkSockets(pimpl_->mutex);
     if (pimpl_->cb) {
         pimpl_->cb(&pkt[0], pkt.size());
         return;
@@ -1133,7 +1133,7 @@ ChannelSocket::shutdown()
 std::size_t
 ChannelSocket::read(ValueType* outBuf, std::size_t len, std::error_code& ec)
 {
-    std::lock_guard<std::mutex> lkSockets(pimpl_->mutex);
+    std::lock_guard lkSockets(pimpl_->mutex);
     std::size_t size = std::min(len, pimpl_->buf.size());
 
     for (std::size_t i = 0; i < size; ++i)
@@ -1171,7 +1171,7 @@ ChannelSocket::write(const ValueType* buf, std::size_t len, std::error_code& ec)
 int
 ChannelSocket::waitForData(std::chrono::milliseconds timeout, std::error_code& ec) const
 {
-    std::unique_lock<std::mutex> lk {pimpl_->mutex};
+    std::unique_lock lk {pimpl_->mutex};
     pimpl_->cv.wait_for(lk, timeout, [&] { return !pimpl_->buf.empty() or pimpl_->isShutdown_; });
     return pimpl_->buf.size();
 }
@@ -1228,7 +1228,7 @@ ChannelSocket::getRemoteAddress() const
 std::vector<std::map<std::string, std::string>>
 MultiplexedSocket::getChannelList() const
 {
-    std::lock_guard<std::mutex> lkSockets(pimpl_->socketsMutex);
+    std::lock_guard lkSockets(pimpl_->socketsMutex);
     std::vector<std::map<std::string, std::string>> channelsList;
     channelsList.reserve(pimpl_->sockets.size());
     for (const auto& [_, channel] : pimpl_->sockets) {
diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp
index 3fbd8205..85a218ec 100644
--- a/src/peer_connection.cpp
+++ b/src/peer_connection.cpp
@@ -75,8 +75,6 @@ init_crt(gnutls_session_t session, dht::crypto::Certificate& crt)
     return GNUTLS_E_SUCCESS;
 }
 
-using lock = std::lock_guard<std::mutex>;
-
 //==============================================================================
 
 IceSocketEndpoint::IceSocketEndpoint(std::shared_ptr<IceTransport> ice, bool isSender)
@@ -232,7 +230,7 @@ class TlsSocketEndpoint::Impl
     ~Impl()
     {
         {
-            std::lock_guard<std::mutex> lk(cbMtx_);
+            std::lock_guard lk(cbMtx_);
             onStateChangeCb_ = {};
             onReadyCb_ = {};
         }
@@ -293,7 +291,7 @@ TlsSocketEndpoint::Impl::verifyCertificate(gnutls_session_t session)
 void
 TlsSocketEndpoint::Impl::onTlsStateChange(tls::TlsSessionState state)
 {
-    std::lock_guard<std::mutex> lk(cbMtx_);
+    std::lock_guard lk(cbMtx_);
     if ((state == tls::TlsSessionState::SHUTDOWN || state == tls::TlsSessionState::ESTABLISHED)
         && !isReady_) {
         isReady_ = true;
@@ -395,14 +393,14 @@ TlsSocketEndpoint::waitForData(std::chrono::milliseconds timeout, std::error_cod
 void
 TlsSocketEndpoint::setOnStateChange(std::function<bool(tls::TlsSessionState state)>&& cb)
 {
-    std::lock_guard<std::mutex> lk(pimpl_->cbMtx_);
+    std::lock_guard lk(pimpl_->cbMtx_);
     pimpl_->onStateChangeCb_ = std::move(cb);
 }
 
 void
 TlsSocketEndpoint::setOnReady(std::function<void(bool ok)>&& cb)
 {
-    std::lock_guard<std::mutex> lk(pimpl_->cbMtx_);
+    std::lock_guard lk(pimpl_->cbMtx_);
     pimpl_->onReadyCb_ = std::move(cb);
 }
 
diff --git a/src/security/certstore.cpp b/src/security/certstore.cpp
index cea117af..b78d63f7 100644
--- a/src/security/certstore.cpp
+++ b/src/security/certstore.cpp
@@ -51,7 +51,7 @@ CertificateStore::CertificateStore(const std::filesystem::path& path, std::share
 unsigned
 CertificateStore::loadLocalCertificates()
 {
-    std::lock_guard<std::mutex> l(lock_);
+    std::lock_guard l(lock_);
     if (logger_)
         logger_->debug("CertificateStore: loading certificates from {}", certPath_);
 
@@ -134,7 +134,7 @@ CertificateStore::loadRevocations(crypto::Certificate& crt) const
 std::vector<std::string>
 CertificateStore::getPinnedCertificates() const
 {
-    std::lock_guard<std::mutex> l(lock_);
+    std::lock_guard l(lock_);
 
     std::vector<std::string> certIds;
     certIds.reserve(certs_.size());
@@ -150,7 +150,7 @@ CertificateStore::getCertificate(const std::string& k)
         auto cit = certs_.find(k);
         return cit != certs_.cend() ? cit->second : std::shared_ptr<crypto::Certificate>{};
     };
-    std::unique_lock<std::mutex> l(lock_);
+    std::unique_lock l(lock_);
     auto crt = getCertificate_(k);
     // Check if certificate is complete
     // If the certificate has been splitted, reconstruct it
@@ -191,7 +191,7 @@ CertificateStore::getCertificateLegacy(const std::string& dataDir, const std::st
 std::shared_ptr<crypto::Certificate>
 CertificateStore::findCertificateByName(const std::string& name, crypto::NameType type) const
 {
-    std::unique_lock<std::mutex> l(lock_);
+    std::unique_lock l(lock_);
     for (auto& i : certs_) {
         if (i.second->getName() == name)
             return i.second;
@@ -207,7 +207,7 @@ CertificateStore::findCertificateByName(const std::string& name, crypto::NameTyp
 std::shared_ptr<crypto::Certificate>
 CertificateStore::findCertificateByUID(const std::string& uid) const
 {
-    std::unique_lock<std::mutex> l(lock_);
+    std::unique_lock l(lock_);
     for (auto& i : certs_) {
         if (i.second->getUID() == uid)
             return i.second;
@@ -284,7 +284,7 @@ CertificateStore::pinCertificatePath(const std::string& path,
         ids.reserve(certs.size());
         scerts.reserve(certs.size());
         {
-            std::lock_guard<std::mutex> l(lock_);
+            std::lock_guard l(lock_);
 
             for (auto& cert : certs) {
                 try {
@@ -311,7 +311,7 @@ CertificateStore::pinCertificatePath(const std::string& path,
 unsigned
 CertificateStore::unpinCertificatePath(const std::string& path)
 {
-    std::lock_guard<std::mutex> l(lock_);
+    std::lock_guard l(lock_);
 
     auto certs = paths_.find(path);
     if (certs == std::end(paths_))
@@ -350,7 +350,7 @@ CertificateStore::pinCertificate(const std::shared_ptr<crypto::Certificate>& cer
     std::vector<std::string> ids {};
     {
         auto c = cert;
-        std::lock_guard<std::mutex> l(lock_);
+        std::lock_guard l(lock_);
         while (c) {
             bool inserted;
             auto id = c->getId().toString();
@@ -384,7 +384,7 @@ CertificateStore::pinCertificate(const std::shared_ptr<crypto::Certificate>& cer
 bool
 CertificateStore::unpinCertificate(const std::string& id)
 {
-    std::lock_guard<std::mutex> l(lock_);
+    std::lock_guard l(lock_);
 
     certs_.erase(id);
     return remove(certPath_ / id);
@@ -475,7 +475,7 @@ CertificateStore::pinOcspResponse(const dht::crypto::Certificate& cert)
                                serialhex = std::move(serialhex),
                                ocspResponse = cert.ocspResponse] {
         if (l) l->d("Saving OCSP Response of device %s with serial %s", id.c_str(), serialhex.c_str());
-        std::lock_guard<std::mutex> lock(fileutils::getFileLock(path));
+        std::lock_guard lock(fileutils::getFileLock(path));
         fileutils::check_dir(dir.c_str());
         fileutils::saveFile(path, ocspResponse->pack());
     });
@@ -555,7 +555,7 @@ TrustStore::setCertificateStatus(std::shared_ptr<crypto::Certificate> cert,
 {
     if (cert)
         certStore_.pinCertificate(cert, local);
-    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    std::lock_guard lk(mutex_);
     updateKnownCerts();
     bool dirty {false};
     if (status == PermissionStatus::UNDEFINED) {
@@ -598,7 +598,7 @@ TrustStore::setCertificateStatus(std::shared_ptr<crypto::Certificate> cert,
 TrustStore::PermissionStatus
 TrustStore::getCertificateStatus(const std::string& cert_id) const
 {
-    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    std::lock_guard lk(mutex_);
     auto cert = certStore_.getCertificate(cert_id);
     if (!cert)
         return PermissionStatus::UNDEFINED;
@@ -637,7 +637,7 @@ TrustStore::getCertificateStatus(const std::string& cert_id) const
 std::vector<std::string>
 TrustStore::getCertificatesByStatus(TrustStore::PermissionStatus status) const
 {
-    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    std::lock_guard lk(mutex_);
     std::vector<std::string> ret;
     for (const auto& i : certStatus_)
         if (i.second.second.allowed == (status == TrustStore::PermissionStatus::ALLOWED))
@@ -652,7 +652,7 @@ bool
 TrustStore::isAllowed(const crypto::Certificate& crt, bool allowPublic)
 {
     // Match by certificate pinning
-    std::lock_guard<std::recursive_mutex> lk(mutex_);
+    std::lock_guard lk(mutex_);
     bool allowed {allowPublic};
     for (auto c = &crt; c; c = c->issuer.get()) {
         auto status = getCertificateStatus(c->getId().toString()); // lock mutex_
diff --git a/src/security/diffie-hellman.cpp b/src/security/diffie-hellman.cpp
index 216e2338..9c69f8bb 100644
--- a/src/security/diffie-hellman.cpp
+++ b/src/security/diffie-hellman.cpp
@@ -106,7 +106,7 @@ DhParams::generate()
 DhParams
 DhParams::loadDhParams(const std::filesystem::path& path)
 {
-    std::lock_guard<std::mutex> l(fileutils::getFileLock(path));
+    std::lock_guard l(fileutils::getFileLock(path));
     try {
         // writeTime throw exception if file doesn't exist
         auto writeTime = std::filesystem::last_write_time(path);
diff --git a/src/security/threadloop.h b/src/security/threadloop.h
index 7e18e1b8..67b43ff4 100644
--- a/src/security/threadloop.h
+++ b/src/security/threadloop.h
@@ -97,7 +97,7 @@ class InterruptedThreadLoop : public ThreadLoop
         if (std::this_thread::get_id() != get_id())
             throw std::runtime_error("can not call wait_for outside thread context");
 
-        std::unique_lock<std::mutex> lk(mutex_);
+        std::unique_lock lk(mutex_);
         cv_.wait_for(lk, rel_time, [this]() { return isStopping(); });
     }
 
@@ -107,7 +107,7 @@ class InterruptedThreadLoop : public ThreadLoop
         if (std::this_thread::get_id() != get_id())
             throw std::runtime_error("can not call wait_for outside thread context");
 
-        std::unique_lock<std::mutex> lk(mutex_);
+        std::unique_lock lk(mutex_);
         return cv_.wait_for(lk, rel_time, [this, pred] { return isStopping() || pred(); });
     }
 
@@ -117,7 +117,7 @@ class InterruptedThreadLoop : public ThreadLoop
         if (std::this_thread::get_id() != get_id())
             throw std::runtime_error("Can not call wait outside thread context");
 
-        std::unique_lock<std::mutex> lk(mutex_);
+        std::unique_lock lk(mutex_);
         cv_.wait(lk, [this, p = std::forward<Pred>(pred)] { return isStopping() || p(); });
     }
 
diff --git a/src/security/tls_session.cpp b/src/security/tls_session.cpp
index 1d7b24d0..8d3539ae 100644
--- a/src/security/tls_session.cpp
+++ b/src/security/tls_session.cpp
@@ -339,7 +339,7 @@ TlsSession::TlsSessionImpl::TlsSessionImpl(std::unique_ptr<SocketType>&& transpo
 {
     if (not transport_->isReliable()) {
         transport_->setOnRecv([this](const ValueType* buf, size_t len) {
-            std::lock_guard<std::mutex> lk {rxMutex_};
+            std::lock_guard lk {rxMutex_};
             if (rxQueue_.size() == INPUT_MAX_SIZE) {
                 rxQueue_.pop_front(); // drop oldest packet if input buffer is full
                 ++stRxRawPacketDropCnt_;
@@ -362,7 +362,7 @@ TlsSession::TlsSessionImpl::~TlsSessionImpl()
     stateCondition_.notify_all();
     rxCv_.notify_all();
     {
-        std::lock_guard<std::mutex> lock(requestsMtx_);
+        std::lock_guard lock(requestsMtx_);
         // requests_ store a shared_ptr, so we need to cancel requests
         // to not be stuck in verifyCertificateWrapper
         for (auto& request : requests_)
@@ -816,12 +816,12 @@ TlsSession::TlsSessionImpl::sendOcspRequest(const std::string& uri,
         if (cb)
             cb(response);
         if (auto request = response.request.lock()) {
-            std::lock_guard<std::mutex> lock(requestsMtx_);
+            std::lock_guard lock(requestsMtx_);
             requests_.erase(request);
         }
     });
     {
-        std::lock_guard<std::mutex> lock(requestsMtx_);
+        std::lock_guard lock(requestsMtx_);
         requests_.emplace(request);
     }
     request->send();
@@ -851,7 +851,7 @@ TlsSession::TlsSessionImpl::peerCertificate(gnutls_session_t session) const
 std::size_t
 TlsSession::TlsSessionImpl::send(const ValueType* tx_data, std::size_t tx_size, std::error_code& ec)
 {
-    std::lock_guard<std::mutex> lk(sessionWriteMutex_);
+    std::lock_guard lk(sessionWriteMutex_);
     if (state_ != TlsSessionState::ESTABLISHED) {
         ec = std::error_code(GNUTLS_E_INVALID_SESSION, std::system_category());
         return 0;
@@ -959,7 +959,7 @@ TlsSession::TlsSessionImpl::recvRaw(void* buf, size_t size)
         return -1;
     }
 
-    std::lock_guard<std::mutex> lk {rxMutex_};
+    std::lock_guard lk {rxMutex_};
     if (rxQueue_.empty()) {
         gnutls_transport_set_errno(session_, EAGAIN);
         return -1;
@@ -997,7 +997,7 @@ TlsSession::TlsSessionImpl::waitForRawData(std::chrono::milliseconds timeout)
     }
 
     // non-reliable uses callback installed with setOnRecv()
-    std::unique_lock<std::mutex> lk {rxMutex_};
+    std::unique_lock lk {rxMutex_};
     rxCv_.wait_for(lk, timeout, [this] {
         return !rxQueue_.empty() or state_ == TlsSessionState::SHUTDOWN;
     });
@@ -1065,8 +1065,8 @@ TlsSession::TlsSessionImpl::cleanup()
     stateCondition_.notify_all();
 
     {
-        std::lock_guard<std::mutex> lk1(sessionReadMutex_);
-        std::lock_guard<std::mutex> lk2(sessionWriteMutex_);
+        std::lock_guard lk1(sessionReadMutex_);
+        std::lock_guard lk2(sessionWriteMutex_);
         if (session_) {
             if (transport_->isReliable())
                 gnutls_bye(session_, GNUTLS_SHUT_RDWR);
@@ -1119,7 +1119,7 @@ TlsSession::TlsSessionImpl::handleStateCookie(TlsSessionState state)
     std::size_t count;
     {
         // block until rx packet or shutdown
-        std::unique_lock<std::mutex> lk {rxMutex_};
+        std::unique_lock lk {rxMutex_};
         if (!rxCv_.wait_for(lk, COOKIE_TIMEOUT, [this] {
                 return !rxQueue_.empty() or state_ == TlsSessionState::SHUTDOWN;
             })) {
@@ -1140,7 +1140,7 @@ TlsSession::TlsSessionImpl::handleStateCookie(TlsSessionState state)
 
     // Peek and verify front packet
     {
-        std::lock_guard<std::mutex> lk {rxMutex_};
+        std::lock_guard lk {rxMutex_};
         auto& pkt = rxQueue_.front();
         std::memset(&prestate_, 0, sizeof(prestate_));
         ret = gnutls_dtls_cookie_verify(&cookie_key_, nullptr, 0, pkt.data(), pkt.size(), &prestate_);
@@ -1159,7 +1159,7 @@ TlsSession::TlsSessionImpl::handleStateCookie(TlsSessionState state)
 
         // Drop front packet
         {
-            std::lock_guard<std::mutex> lk {rxMutex_};
+            std::lock_guard lk {rxMutex_};
             rxQueue_.pop_front();
         }
 
@@ -1421,7 +1421,7 @@ TlsSession::TlsSessionImpl::handleDataPacket(std::vector<ValueType>&& buf, uint6
             params_.logger->warn("[TLS] OOO pkt: 0x{:x}", pkt_seq);
     }
 
-    std::unique_lock<std::mutex> lk {rxMutex_};
+    std::unique_lock lk {rxMutex_};
     auto now = clock::now();
     if (reorderBuffer_.empty())
         lastReadTime_ = now;
@@ -1509,7 +1509,7 @@ TlsSession::TlsSessionImpl::handleStateEstablished(TlsSessionState state)
             return state_.load() != TlsSessionState::ESTABLISHED
                    or newState_.load() != TlsSessionState::NONE;
         };
-        std::unique_lock<std::mutex> lk(stateMutex_);
+        std::unique_lock lk(stateMutex_);
         stateCondition_.wait(lk, disconnected);
         auto oldState = state_.load();
         if (oldState == TlsSessionState::ESTABLISHED) {
@@ -1524,7 +1524,7 @@ TlsSession::TlsSessionImpl::handleStateEstablished(TlsSessionState state)
 
     // block until rx packet or state change
     {
-        std::unique_lock<std::mutex> lk {rxMutex_};
+        std::unique_lock lk {rxMutex_};
         if (nextFlush_.empty())
             rxCv_.wait(lk, [this] {
                 return state_ != TlsSessionState::ESTABLISHED or not rxQueue_.empty()
@@ -1693,7 +1693,7 @@ TlsSession::read(ValueType* data, std::size_t size, std::error_code& ec)
     while (true) {
         ssize_t ret;
         {
-            std::lock_guard<std::mutex> lk(pimpl_->sessionReadMutex_);
+            std::lock_guard lk(pimpl_->sessionReadMutex_);
             if (!pimpl_->session_)
                 return 0;
             ret = gnutls_record_recv(pimpl_->session_, data, size);
@@ -1703,7 +1703,7 @@ TlsSession::read(ValueType* data, std::size_t size, std::error_code& ec)
             return ret;
         }
 
-        std::lock_guard<std::mutex> lk(pimpl_->stateMutex_);
+        std::lock_guard lk(pimpl_->stateMutex_);
         if (ret == 0) {
             if (pimpl_) {
                 if (pimpl_->params_.logger)
diff --git a/src/transport/peer_channel.h b/src/transport/peer_channel.h
index 8608a081..994e619e 100644
--- a/src/transport/peer_channel.h
+++ b/src/transport/peer_channel.h
@@ -30,7 +30,7 @@ class PeerChannel
     ~PeerChannel() { stop(); }
     PeerChannel(PeerChannel&& o)
     {
-        std::lock_guard<std::mutex> lk(o.mutex_);
+        std::lock_guard lk(o.mutex_);
         stream_ = std::move(o.stream_);
         stop_ = o.stop_;
         o.cv_.notify_all();
@@ -39,7 +39,7 @@ class PeerChannel
     template<typename Duration>
     ssize_t wait(Duration timeout, std::error_code& ec)
     {
-        std::unique_lock<std::mutex> lk {mutex_};
+        std::unique_lock lk {mutex_};
         cv_.wait_for(lk, timeout, [this] { return stop_ or not stream_.empty(); });
         if (stop_) {
             ec = std::make_error_code(std::errc::broken_pipe);
@@ -51,7 +51,7 @@ class PeerChannel
 
     ssize_t read(char* output, std::size_t size, std::error_code& ec)
     {
-        std::unique_lock<std::mutex> lk {mutex_};
+        std::unique_lock lk {mutex_};
         cv_.wait(lk, [this] { return stop_ or not stream_.empty(); });
         if (stream_.size()) {
             auto toRead = std::min(size, stream_.size());
@@ -73,7 +73,7 @@ class PeerChannel
 
     ssize_t write(const char* data, std::size_t size, std::error_code& ec)
     {
-        std::lock_guard<std::mutex> lk {mutex_};
+        std::lock_guard lk {mutex_};
         if (stop_) {
             ec = std::make_error_code(std::errc::broken_pipe);
             return -1;
@@ -86,7 +86,7 @@ class PeerChannel
 
     void stop() noexcept
     {
-        std::lock_guard<std::mutex> lk {mutex_};
+        std::lock_guard lk {mutex_};
         if (stop_)
             return;
         stop_ = true;
diff --git a/src/turn/turn_cache.cpp b/src/turn/turn_cache.cpp
index 65862cbf..0cf9267e 100644
--- a/src/turn/turn_cache.cpp
+++ b/src/turn/turn_cache.cpp
@@ -43,7 +43,7 @@ TurnCache::TurnCache(const std::string& accountId,
 
 TurnCache::~TurnCache() {
     {
-        std::lock_guard<std::mutex> lock(shutdownMtx_);
+        std::lock_guard lock(shutdownMtx_);
         if (refreshTimer_) {
             refreshTimer_->cancel();
             refreshTimer_.reset();
@@ -54,7 +54,7 @@ TurnCache::~TurnCache() {
         }
     }
     {
-        std::lock_guard<std::mutex> lock(cachedTurnMutex_);
+        std::lock_guard lock(cachedTurnMutex_);
         testTurnV4_.reset();
         testTurnV6_.reset();
         cacheTurnV4_.reset();
@@ -79,7 +79,7 @@ TurnCache::reconfigure(const TurnTransportParams& params, bool enabled)
     params_ = params;
     enabled_ = enabled;
     {
-        std::lock_guard<std::mutex> lk(cachedTurnMutex_);
+        std::lock_guard lk(cachedTurnMutex_);
         // Force re-resolution
         isRefreshing_ = false;
         cacheTurnV4_.reset();
@@ -87,7 +87,7 @@ TurnCache::reconfigure(const TurnTransportParams& params, bool enabled)
         testTurnV4_.reset();
         testTurnV6_.reset();
     }
-    std::lock_guard<std::mutex> lock(shutdownMtx_);
+    std::lock_guard lock(shutdownMtx_);
     if (refreshTimer_) {
         refreshTimer_->expires_at(std::chrono::steady_clock::now());
         refreshTimer_->async_wait(std::bind(&TurnCache::refresh, shared_from_this(), std::placeholders::_1));
@@ -106,7 +106,7 @@ TurnCache::refresh(const asio::error_code& ec)
         return;
     if (!enabled_) {
         // In this case, we do not use any TURN server
-        std::lock_guard<std::mutex> lk(cachedTurnMutex_);
+        std::lock_guard lk(cachedTurnMutex_);
         cacheTurnV4_.reset();
         cacheTurnV6_.reset();
         isRefreshing_ = false;
@@ -177,7 +177,7 @@ TurnCache::testTurn(IpAddr server)
 {
     TurnTransportParams params = params_;
     params.server = server;
-    std::lock_guard<std::mutex> lk(cachedTurnMutex_);
+    std::lock_guard lk(cachedTurnMutex_);
     auto& turn = server.isIpv4() ? testTurnV4_ : testTurnV6_;
     turn.reset(); // Stop previous TURN
     try {
@@ -185,7 +185,7 @@ TurnCache::testTurn(IpAddr server)
             params, [this, server](bool ok) {
                 // Stop server in an async job, because this callback can be called
                 // immediately and cachedTurnMutex_ must not be locked.
-                std::lock_guard<std::mutex> lock(shutdownMtx_);
+                std::lock_guard lock(shutdownMtx_);
                 if (onConnectedTimer_) {
                     onConnectedTimer_->expires_at(std::chrono::steady_clock::now());
                     onConnectedTimer_->async_wait(std::bind(&TurnCache::onConnected, shared_from_this(), std::placeholders::_1, ok, server));
@@ -202,7 +202,7 @@ TurnCache::onConnected(const asio::error_code& ec, bool ok, IpAddr server)
     if (ec == asio::error::operation_aborted)
         return;
 
-    std::lock_guard<std::mutex> lk(cachedTurnMutex_);
+    std::lock_guard lk(cachedTurnMutex_);
     auto& cacheTurn = server.isIpv4() ? cacheTurnV4_ : cacheTurnV6_;
     if (!ok) {
         if(logger_) logger_->error("Connection to {:s} failed - reset", server.toString());
@@ -222,7 +222,7 @@ TurnCache::refreshTurnDelay(bool scheduleNext)
 {
     isRefreshing_ = false;
     if (scheduleNext) {
-        std::lock_guard<std::mutex> lock(shutdownMtx_);
+        std::lock_guard lock(shutdownMtx_);
         if(logger_) logger_->warn("[Account {:s}] Cache for TURN resolution failed.", accountId_);
         if (refreshTimer_) {
             refreshTimer_->expires_at(std::chrono::steady_clock::now() + turnRefreshDelay_);
diff --git a/src/turn/turn_transport.cpp b/src/turn/turn_transport.cpp
index 3cf78d26..3ed4015f 100644
--- a/src/turn/turn_transport.cpp
+++ b/src/turn/turn_transport.cpp
@@ -78,7 +78,7 @@ class TurnTransport::Impl
     }
 
     void shutdown() {
-        std::lock_guard<std::mutex> lock(shutdownMtx_);
+        std::lock_guard lock(shutdownMtx_);
         if (relay) {
             pj_turn_sock_destroy(relay);
             relay = nullptr;
diff --git a/src/upnp/protocol/igd.h b/src/upnp/protocol/igd.h
index 8e8e5a92..19f773aa 100644
--- a/src/upnp/protocol/igd.h
+++ b/src/upnp/protocol/igd.h
@@ -50,32 +50,32 @@ class IGD
 
     IpAddr getLocalIp() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return localIp_;
     }
     IpAddr getPublicIp() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return publicIp_;
     }
     void setLocalIp(const IpAddr& addr)
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         localIp_ = addr;
     }
     void setPublicIp(const IpAddr& addr)
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         publicIp_ = addr;
     }
     void setUID(const std::string& uid)
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         uid_ = uid;
     }
     std::string getUID() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return uid_;
     }
 
diff --git a/src/upnp/protocol/mapping.cpp b/src/upnp/protocol/mapping.cpp
index 1222261e..846553f4 100644
--- a/src/upnp/protocol/mapping.cpp
+++ b/src/upnp/protocol/mapping.cpp
@@ -40,7 +40,7 @@ Mapping::Mapping(PortType type, uint16_t portExternal, uint16_t portInternal, bo
 
 Mapping::Mapping(const Mapping& other)
 {
-    std::lock_guard<std::mutex> lock(other.mutex_);
+    std::lock_guard lock(other.mutex_);
 
     internalAddr_ = other.internalAddr_;
     internalPort_ = other.internalPort_;
@@ -85,28 +85,28 @@ Mapping::setAvailable(bool val)
     //          available_ ? "AVAILABLE" : "UNAVAILABLE",
     //          val ? "AVAILABLE" : "UNAVAILABLE");
 
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     available_ = val;
 }
 
 void
 Mapping::setState(const MappingState& state)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     state_ = state;
 }
 
 const char*
 Mapping::getStateStr() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return getStateStr(state_);
 }
 
 std::string
 Mapping::toString(bool extraInfo) const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     std::ostringstream descr;
     descr << UPNP_MAPPING_DESCRIPTION_PREFIX << "-" << getTypeStr(type_);
     descr << ":" << std::to_string(internalPort_);
@@ -122,7 +122,7 @@ Mapping::toString(bool extraInfo) const
 bool
 Mapping::isValid() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     if (state_ == MappingState::FAILED)
         return false;
     if (internalPort_ == 0)
@@ -138,7 +138,7 @@ Mapping::isValid() const
 bool
 Mapping::hasValidHostAddress() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
 
     IpAddr intAddr(internalAddr_);
     return intAddr and not intAddr.isLoopback();
@@ -147,7 +147,7 @@ Mapping::hasValidHostAddress() const
 bool
 Mapping::hasPublicAddress() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
 
     return igd_ and igd_->getPublicIp() and not igd_->getPublicIp().isPrivate();
 }
@@ -155,7 +155,7 @@ Mapping::hasPublicAddress() const
 Mapping::key_t
 Mapping::getMapKey() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
 
     key_t mapKey = internalPort_;
     if (type_ == PortType::UDP)
@@ -172,7 +172,7 @@ Mapping::getTypeFromMapKey(key_t key)
 std::string
 Mapping::getExternalAddress() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     if (igd_)
         return igd_->getPublicIp().toString();
     return {};
@@ -181,91 +181,91 @@ Mapping::getExternalAddress() const
 void
 Mapping::setExternalPort(uint16_t port)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     externalPort_ = port;
 }
 
 uint16_t
 Mapping::getExternalPort() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return externalPort_;
 }
 
 std::string
 Mapping::getExternalPortStr() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return std::to_string(externalPort_);
 }
 
 void
 Mapping::setInternalAddress(const std::string& addr)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     internalAddr_ = addr;
 }
 
 std::string
 Mapping::getInternalAddress() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return internalAddr_;
 }
 
 void
 Mapping::setInternalPort(uint16_t port)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     internalPort_ = port;
 }
 
 uint16_t
 Mapping::getInternalPort() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return internalPort_;
 }
 
 std::string
 Mapping::getInternalPortStr() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return std::to_string(internalPort_);
 }
 
 PortType
 Mapping::getType() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return type_;
 }
 
 const char*
 Mapping::getTypeStr() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return getTypeStr(type_);
 }
 
 bool
 Mapping::isAvailable() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return available_;
 }
 
 std::shared_ptr<IGD>
 Mapping::getIgd() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return igd_;
 }
 
 NatProtocolType
 Mapping::getProtocol() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     if (igd_)
         return igd_->getProtocol();
     return NatProtocolType::UNKNOWN;
@@ -287,42 +287,42 @@ Mapping::getProtocolName() const
 void
 Mapping::setIgd(const std::shared_ptr<IGD>& igd)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     igd_ = igd;
 }
 
 MappingState
 Mapping::getState() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return state_;
 }
 
 Mapping::NotifyCallback
 Mapping::getNotifyCallback() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return notifyCb_;
 }
 
 void
 Mapping::setNotifyCallback(NotifyCallback cb)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     notifyCb_ = std::move(cb);
 }
 
 void
 Mapping::enableAutoUpdate(bool enable)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     autoUpdate_ = enable;
 }
 
 bool
 Mapping::getAutoUpdate() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return autoUpdate_;
 }
 
@@ -330,14 +330,14 @@ Mapping::getAutoUpdate() const
 sys_clock::time_point
 Mapping::getRenewalTime() const
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     return renewalTime_;
 }
 
 void
 Mapping::setRenewalTime(sys_clock::time_point time)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard lock(mutex_);
     renewalTime_ = time;
 }
 #endif
diff --git a/src/upnp/protocol/natpmp/nat_pmp.cpp b/src/upnp/protocol/natpmp/nat_pmp.cpp
index c822b378..cf45b122 100644
--- a/src/upnp/protocol/natpmp/nat_pmp.cpp
+++ b/src/upnp/protocol/natpmp/nat_pmp.cpp
@@ -42,7 +42,7 @@ NatPmp::initNatPmp()
     initialized_ = false;
 
     {
-        std::lock_guard<std::mutex> lock(natpmpMutex_);
+        std::lock_guard lock(natpmpMutex_);
         hostAddress_ = ip_utils::getLocalAddr(AF_INET);
     }
 
@@ -121,7 +121,7 @@ NatPmp::terminate(std::condition_variable& cv)
     initialized_ = false;
     observer_ = nullptr;
 
-    std::lock_guard<std::mutex> lock(natpmpMutex_);
+    std::lock_guard lock(natpmpMutex_);
     shutdownComplete_ = true;
     cv.notify_one();
 }
@@ -135,7 +135,7 @@ NatPmp::terminate()
         terminate(cv);
     });
 
-    std::unique_lock<std::mutex> lk(natpmpMutex_);
+    std::unique_lock lk(natpmpMutex_);
     if (cv.wait_for(lk, std::chrono::seconds(10), [this] { return shutdownComplete_; })) {
         if (logger_) logger_->debug("NAT-PMP: Shutdown completed");
     } else {
@@ -146,7 +146,7 @@ NatPmp::terminate()
 const IpAddr
 NatPmp::getHostAddress() const
 {
-    std::lock_guard<std::mutex> lock(natpmpMutex_);
+    std::lock_guard lock(natpmpMutex_);
     return hostAddress_;
 }
 
@@ -203,7 +203,7 @@ NatPmp::searchForIgd()
 std::list<std::shared_ptr<IGD>>
 NatPmp::getIgdList() const
 {
-    std::lock_guard<std::mutex> lock(natpmpMutex_);
+    std::lock_guard lock(natpmpMutex_);
     std::list<std::shared_ptr<IGD>> igdList;
     if (igd_->isValid())
         igdList.emplace_back(igd_);
diff --git a/src/upnp/protocol/pupnp/pupnp.cpp b/src/upnp/protocol/pupnp/pupnp.cpp
index 7003a493..8aa462db 100644
--- a/src/upnp/protocol/pupnp/pupnp.cpp
+++ b/src/upnp/protocol/pupnp/pupnp.cpp
@@ -155,7 +155,7 @@ PUPnP::initUpnpLib()
 bool
 PUPnP::isRunning() const
 {
-    std::unique_lock<std::mutex> lk(pupnpMutex_);
+    std::unique_lock lk(pupnpMutex_);
     return not shutdownComplete_;
 }
 
@@ -183,7 +183,7 @@ PUPnP::setObserver(UpnpMappingObserver* obs)
 const IpAddr
 PUPnP::getHostAddress() const
 {
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
     return hostAddress_;
 }
 
@@ -194,7 +194,7 @@ PUPnP::terminate(std::condition_variable& cv)
 
     clientRegistered_ = false;
     observer_ = nullptr;
-    std::unique_lock<std::mutex> lk(ongoingOpsMtx_);
+    std::unique_lock lk(ongoingOpsMtx_);
     destroying_ = true;
     cvOngoing_.wait(lk, [&]() { return ongoingOps_ == 0; });
 
@@ -211,7 +211,7 @@ PUPnP::terminate(std::condition_variable& cv)
     // Clear all the lists.
     discoveredIgdList_.clear();
 
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
     validIgdList_.clear();
     shutdownComplete_ = true;
     cv.notify_one();
@@ -225,7 +225,7 @@ PUPnP::terminate()
         terminate(cv);
     });
 
-    std::unique_lock<std::mutex> lk(pupnpMutex_);
+    std::unique_lock lk(pupnpMutex_);
     if (cv.wait_for(lk, std::chrono::seconds(10), [this] { return shutdownComplete_; })) {
         if (logger_) logger_->debug("PUPnP: Shutdown completed");
     } else {
@@ -282,7 +282,7 @@ PUPnP::clearIgds()
     igdSearchCounter_ = 0;
 
     {
-        std::lock_guard<std::mutex> lock(pupnpMutex_);
+        std::lock_guard lock(pupnpMutex_);
         for (auto const& igd : validIgdList_) {
             igd->setValid(false);
         }
@@ -350,7 +350,7 @@ PUPnP::searchForIgd()
 std::list<std::shared_ptr<IGD>>
 PUPnP::getIgdList() const
 {
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
     std::list<std::shared_ptr<IGD>> igdList;
     for (auto& it : validIgdList_) {
         // Return only active IGDs.
@@ -374,7 +374,7 @@ PUPnP::isReady() const
 bool
 PUPnP::hasValidIgd() const
 {
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
     for (auto& it : validIgdList_) {
         if (it->isValid()) {
             return true;
@@ -386,14 +386,14 @@ PUPnP::hasValidIgd() const
 void
 PUPnP::updateHostAddress()
 {
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
     hostAddress_ = ip_utils::getLocalAddr(AF_INET);
 }
 
 bool
 PUPnP::hasValidHostAddress()
 {
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
     return hostAddress_ and not hostAddress_.isLoopback();
 }
 
@@ -485,7 +485,7 @@ PUPnP::validateIgd(const std::string& location, IXML_Document* doc_container_ptr
 
     {
         // Add the IGD if not already present in the list.
-        std::lock_guard<std::mutex> lock(pupnpMutex_);
+        std::lock_guard lock(pupnpMutex_);
         for (auto& igd : validIgdList_) {
             // Must not be a null pointer
             assert(igd.get() != nullptr);
@@ -527,7 +527,7 @@ PUPnP::validateIgd(const std::string& location, IXML_Document* doc_container_ptr
 
     {
         // This is a new (and hopefully valid) IGD.
-        std::lock_guard<std::mutex> lock(pupnpMutex_);
+        std::lock_guard lock(pupnpMutex_);
         validIgdList_.emplace_back(igd_candidate);
     }
 
@@ -586,7 +586,7 @@ PUPnP::requestMappingRemove(const Mapping& mapping)
 std::shared_ptr<UPnPIGD>
 PUPnP::findMatchingIgd(const std::string& ctrlURL) const
 {
-    std::lock_guard<std::mutex> lock(pupnpMutex_);
+    std::lock_guard lock(pupnpMutex_);
 
     auto iter = std::find_if(validIgdList_.begin(),
                              validIgdList_.end(),
@@ -783,7 +783,7 @@ PUPnP::downLoadIgdDescription(const std::string& locationUrl)
 {
     if(logger_) logger_->debug("PUPnP: downLoadIgdDescription {}", locationUrl);
     {
-        std::lock_guard<std::mutex> lk(ongoingOpsMtx_);
+        std::lock_guard lk(ongoingOpsMtx_);
         if (destroying_)
             return;
         ongoingOps_++;
@@ -803,7 +803,7 @@ PUPnP::downLoadIgdDescription(const std::string& locationUrl)
             }
         });
     }
-    std::lock_guard<std::mutex> lk(ongoingOpsMtx_);
+    std::lock_guard lk(ongoingOpsMtx_);
     ongoingOps_--;
     cvOngoing_.notify_one();
 }
@@ -815,7 +815,7 @@ PUPnP::processDiscoveryAdvertisementByebye(const std::string& cpDeviceId)
 
     std::shared_ptr<IGD> igd;
     {
-        std::lock_guard<std::mutex> lk(pupnpMutex_);
+        std::lock_guard lk(pupnpMutex_);
         for (auto it = validIgdList_.begin(); it != validIgdList_.end();) {
             if ((*it)->getUID() == cpDeviceId) {
                 igd = *it;
@@ -842,7 +842,7 @@ PUPnP::processDiscoveryAdvertisementByebye(const std::string& cpDeviceId)
 void
 PUPnP::processDiscoverySubscriptionExpired(Upnp_EventType event_type, const std::string& eventSubUrl)
 {
-    std::lock_guard<std::mutex> lk(pupnpMutex_);
+    std::lock_guard lk(pupnpMutex_);
     for (auto& it : validIgdList_) {
         if (auto igd = std::dynamic_pointer_cast<UPnPIGD>(it)) {
             if (igd->getEventSubURL() == eventSubUrl) {
@@ -1023,7 +1023,7 @@ PUPnP::parseIgd(IXML_Document* doc, std::string locationUrl)
         if (logger_) logger_->warn("PUPnP: could not find UDN in description document of device");
         return nullptr;
     } else {
-        std::lock_guard<std::mutex> lk(pupnpMutex_);
+        std::lock_guard lk(pupnpMutex_);
         for (auto& it : validIgdList_) {
             if (it->getUID() == UDN) {
                 // We already have this device in our list.
diff --git a/src/upnp/protocol/pupnp/upnp_igd.h b/src/upnp/protocol/pupnp/upnp_igd.h
index 5ea7fe56..3324e808 100644
--- a/src/upnp/protocol/pupnp/upnp_igd.h
+++ b/src/upnp/protocol/pupnp/upnp_igd.h
@@ -48,37 +48,37 @@ class UPnPIGD : public IGD
 
     const std::string& getBaseURL() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return baseURL_;
     }
     const std::string& getFriendlyName() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return friendlyName_;
     }
     const std::string& getServiceType() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return serviceType_;
     }
     const std::string& getServiceId() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return serviceId_;
     }
     const std::string& getLocationURL() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return locationURL_;
     }
     const std::string& getControlURL() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return controlURL_;
     }
     const std::string& getEventSubURL() const
     {
-        std::lock_guard<std::mutex> lock(mutex_);
+        std::lock_guard lock(mutex_);
         return eventSubURL_;
     }
 
diff --git a/src/upnp/upnp_context.cpp b/src/upnp/upnp_context.cpp
index 0bbd2824..cc54cb16 100644
--- a/src/upnp/upnp_context.cpp
+++ b/src/upnp/upnp_context.cpp
@@ -88,7 +88,7 @@ UPnPContext::shutdown(std::condition_variable& cv)
         proto->terminate();
     }
 
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     mappingList_->clear();
     mappingListUpdateTimer_.cancel();
     controllerList_.clear();
@@ -100,7 +100,7 @@ UPnPContext::shutdown(std::condition_variable& cv)
 void
 UPnPContext::shutdown()
 {
-    std::unique_lock<std::mutex> lk(mappingMutex_);
+    std::unique_lock lk(mappingMutex_);
     std::condition_variable cv;
 
     ctx->post([&, this] { shutdown(cv); });
@@ -173,7 +173,7 @@ UPnPContext::stopUpnp(bool forceRelease)
     // list while holding the lock.
     std::list<Mapping::sharedPtr_t> toRemoveList;
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
 
         PortType types[2] {PortType::TCP, PortType::UDP};
         for (auto& type : types) {
@@ -302,7 +302,7 @@ UPnPContext::setPublicAddress(const IpAddr& addr)
     if (not addr)
         return;
 
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     if (knownPublicAddress_ != addr) {
         knownPublicAddress_ = std::move(addr);
         if (logger_) logger_->debug("Setting the known public address to {}", addr.toString());
@@ -312,14 +312,14 @@ UPnPContext::setPublicAddress(const IpAddr& addr)
 bool
 UPnPContext::isReady() const
 {
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     return not validIgdList_.empty();
 }
 
 IpAddr
 UPnPContext::getExternalIP() const
 {
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     // Return the first IGD Ip available.
     if (not validIgdList_.empty()) {
         return (*validIgdList_.begin())->getPublicIp();
@@ -342,7 +342,7 @@ UPnPContext::reserveMapping(Mapping& requestedMap)
     Mapping::sharedPtr_t mapRes;
 
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         auto& mappingList = getMappingList(requestedMap.getType());
 
         // We try to provide a mapping in "OPEN" state. If not found,
@@ -417,7 +417,7 @@ void
 UPnPContext::registerController(void* controller)
 {
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         if (shutdownComplete_) {
             if (logger_) logger_->warn("UPnPContext already shut down");
             return;
@@ -439,7 +439,7 @@ UPnPContext::unregisterController(void* controller)
 {
     if (shutdownComplete_)
         return;
-    std::unique_lock<std::mutex> lock(mappingMutex_);
+    std::unique_lock lock(mappingMutex_);
     if (controllerList_.erase(controller) == 1) {
         if (logger_) logger_->debug("Successfully unregistered controller {}", fmt::ptr(controller));
     } else {
@@ -458,7 +458,7 @@ UPnPContext::getAvailablePortNumber(PortType type)
     // Only return an availalable random port. No actual
     // reservation is made here.
 
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     auto& mappingList = getMappingList(type);
     int tryCount = 0;
     while (tryCount++ < MAX_REQUEST_RETRIES) {
@@ -533,7 +533,7 @@ UPnPContext::deleteUnneededMappings(PortType type, int portCount)
 
     //CHECK_VALID_THREAD();
 
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     auto& mappingList = getMappingList(type);
 
     for (auto it = mappingList.begin(); it != mappingList.end();) {
@@ -669,7 +669,7 @@ UPnPContext::updateMappingList(bool async)
                 status.failedCount_);
 
         if (status.failedCount_ > 0) {
-            std::lock_guard<std::mutex> lock(mappingMutex_);
+            std::lock_guard lock(mappingMutex_);
             auto const& mappingList = getMappingList(type);
             for (auto const& [_, map] : mappingList) {
                 if (map->getState() == MappingState::FAILED) {
@@ -734,7 +734,7 @@ UPnPContext::pruneMappingList()
     auto remoteMapList = protocol->getMappingsListByDescr(igd,
                                                           Mapping::UPNP_MAPPING_DESCRIPTION_PREFIX);
     /*if (remoteMapList.empty()) {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         if (not getMappingList(PortType::TCP).empty() or getMappingList(PortType::TCP).empty()) {
             // JAMI_WARN("We have provisionned mappings but the PUPNP IGD returned an empty list!");
         }
@@ -755,7 +755,7 @@ UPnPContext::pruneUnMatchedMappings(const std::shared_ptr<IGD>& igd,
         // Use a temporary list to avoid processing mappings while holding the lock.
         std::list<Mapping::sharedPtr_t> toRemoveList;
         {
-            std::lock_guard<std::mutex> lock(mappingMutex_);
+            std::lock_guard lock(mappingMutex_);
             for (auto const& [_, map] : getMappingList(type)) {
                 // Only check mappings allocated by UPNP protocol.
                 if (map->getProtocol() != NatProtocolType::PUPNP) {
@@ -789,7 +789,7 @@ UPnPContext::pruneUnTrackedMappings(const std::shared_ptr<IGD>& igd,
     // Use a temporary list to avoid processing mappings while holding the lock.
     std::list<Mapping> toRemoveList;
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
 
         for (auto const& [_, map] : remoteMapList) {
             // Must has valid IGD pointer and use UPNP protocol.
@@ -823,7 +823,7 @@ UPnPContext::pruneMappingsWithInvalidIgds(const std::shared_ptr<IGD>& igd)
     // processing the mapping list.
     std::list<Mapping::sharedPtr_t> toRemoveList;
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
 
         PortType types[2] {PortType::TCP, PortType::UDP};
         for (auto& type : types) {
@@ -855,7 +855,7 @@ UPnPContext::processPendingRequests(const std::shared_ptr<IGD>& igd)
 
     // Populate the list of requests to perform.
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         PortType typeArray[2] {PortType::TCP, PortType::UDP};
 
         for (auto type : typeArray) {
@@ -887,7 +887,7 @@ UPnPContext::processMappingWithAutoUpdate()
 
     // Populate the list of requests for mappings with auto-update enabled.
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         PortType typeArray[2] {PortType::TCP, PortType::UDP};
 
         for (auto type : typeArray) {
@@ -971,14 +971,14 @@ UPnPContext::onIgdUpdated(const std::shared_ptr<IGD>& igd, UpnpIgdEvent event)
 
         pruneMappingsWithInvalidIgds(igd);
 
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         validIgdList_.erase(igd);
         return;
     }
 
     // Update the IGD list.
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         auto ret = validIgdList_.emplace(igd);
         if (ret.second) {
             if (logger_) logger_->debug("IGD [{}] on address {} was added. Will process any pending requests",
@@ -1072,7 +1072,7 @@ UPnPContext::requestRemoveMapping(const Mapping::sharedPtr_t& map)
 void
 UPnPContext::deleteAllMappings(PortType type)
 {
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     auto& mappingList = getMappingList(type);
 
     for (auto const& [_, map] : mappingList) {
@@ -1108,7 +1108,7 @@ UPnPContext::registerMapping(Mapping& map)
     Mapping::sharedPtr_t mapPtr;
 
     {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         auto& mappingList = getMappingList(map.getType());
 
         auto ret = mappingList.emplace(map.getMapKey(), std::make_shared<Mapping>(map));
@@ -1167,7 +1167,7 @@ UPnPContext::getMappingList(PortType type)
 Mapping::sharedPtr_t
 UPnPContext::getMappingWithKey(Mapping::key_t key)
 {
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     auto const& mappingList = getMappingList(Mapping::getTypeFromMapKey(key));
     auto it = mappingList.find(key);
     if (it == mappingList.end())
@@ -1178,7 +1178,7 @@ UPnPContext::getMappingWithKey(Mapping::key_t key)
 void
 UPnPContext::getMappingStatus(PortType type, MappingStatus& status)
 {
-    std::lock_guard<std::mutex> lock(mappingMutex_);
+    std::lock_guard lock(mappingMutex_);
     auto& mappingList = getMappingList(type);
 
     for (auto const& [_, map] : mappingList) {
@@ -1278,7 +1278,7 @@ UPnPContext::renewAllocations()
     std::vector<Mapping::sharedPtr_t> toRenew;
 
     for (auto type : {PortType::TCP, PortType::UDP}) {
-        std::lock_guard<std::mutex> lock(mappingMutex_);
+        std::lock_guard lock(mappingMutex_);
         auto mappingList = getMappingList(type);
         for (auto const& [_, map] : mappingList) {
             if (not map->isValid())
diff --git a/src/upnp/upnp_control.cpp b/src/upnp/upnp_control.cpp
index 8dacd747..185ea7dc 100644
--- a/src/upnp/upnp_control.cpp
+++ b/src/upnp/upnp_control.cpp
@@ -96,7 +96,7 @@ Controller::releaseAllMappings()
 {
     assert(upnpContext_);
 
-    std::lock_guard<std::mutex> lk(mapListMutex_);
+    std::lock_guard lk(mapListMutex_);
     for (auto const& [_, map] : mappingList_) {
         upnpContext_->releaseMapping(map);
     }
@@ -107,7 +107,7 @@ void
 Controller::addLocalMap(const Mapping& map)
 {
     if (map.getMapKey()) {
-        std::lock_guard<std::mutex> lock(mapListMutex_);
+        std::lock_guard lock(mapListMutex_);
         auto ret = mappingList_.emplace(map.getMapKey(), map);
     }
 }
@@ -117,7 +117,7 @@ Controller::removeLocalMap(const Mapping& map)
 {
     assert(upnpContext_);
 
-    std::lock_guard<std::mutex> lk(mapListMutex_);
+    std::lock_guard lk(mapListMutex_);
     return mappingList_.erase(map.getMapKey()) == 1;
 }
 
diff --git a/tests/connectionManager.cpp b/tests/connectionManager.cpp
index afebe8ad..6c451108 100644
--- a/tests/connectionManager.cpp
+++ b/tests/connectionManager.cpp
@@ -232,7 +232,7 @@ ConnectionManagerTest::testConnectDevice()
     bob->connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&,
                                          const std::string& name) {
-            std::lock_guard<std::mutex> lock {mtx};
+            std::lock_guard lock {mtx};
             isBobRecvChanlReq = name == "dummyName";
             bobConVar.notify_one();
             return true;
@@ -241,14 +241,14 @@ ConnectionManagerTest::testConnectDevice()
     std::condition_variable alicConVar;
     bool isAlicConnected = false;
     alice->connectionManager->connectDevice(bob->id.second, "dummyName", [&](std::shared_ptr<ChannelSocket> socket, const DeviceId&) {
-        std::lock_guard<std::mutex> lock {mtx};
+        std::lock_guard lock {mtx};
         if (socket) {
             isAlicConnected = true;
         }
         alicConVar.notify_one();
     });
 
-    std::unique_lock<std::mutex> lock {mtx};
+    std::unique_lock lock {mtx};
     CPPUNIT_ASSERT(bobConVar.wait_for(lock, 30s, [&] { return isBobRecvChanlReq; }));
     CPPUNIT_ASSERT(alicConVar.wait_for(lock, 30s, [&] { return isAlicConnected; }));
 }
@@ -256,7 +256,7 @@ ConnectionManagerTest::testConnectDevice()
 void
 ConnectionManagerTest::testAcceptConnection()
 {
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
     bool successfullyReceive = false;
@@ -296,7 +296,7 @@ ConnectionManagerTest::testDeclineConnection()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool connectCompleted = false;
     bool successfullyConnected = false;
@@ -306,7 +306,7 @@ ConnectionManagerTest::testDeclineConnection()
     bob->connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&,
                                const std::string&) {
-            std::lock_guard<std::mutex> lock {mtx};
+            std::lock_guard lock {mtx};
             successfullyReceive = true;
             cv.notify_one();
             return false;
@@ -324,7 +324,7 @@ ConnectionManagerTest::testDeclineConnection()
                                             "git://*",
                                             [&](std::shared_ptr<ChannelSocket> socket,
                                                 const DeviceId&) {
-                                                std::lock_guard<std::mutex> lock {mtx};
+                                                std::lock_guard lock {mtx};
                                                 if (socket) {
                                                     successfullyConnected = true;
                                                 }
@@ -353,7 +353,7 @@ ConnectionManagerTest::testManyChannels()
 
     auto acceptAll = [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name) {
         if (name.empty()) return false;
-        std::lock_guard<std::mutex> lk {mtx};
+        std::lock_guard lk {mtx};
         accepted++;
         cv.notify_one();
         return true;
@@ -377,7 +377,7 @@ ConnectionManagerTest::testManyChannels()
             }
             return size;
         });
-        std::lock_guard<std::mutex> lk {mtx};
+        std::lock_guard lk {mtx};
         receiverConnected++;
         cv.notify_one();
     };
@@ -390,7 +390,7 @@ ConnectionManagerTest::testManyChannels()
     auto onConnect = [&](std::shared_ptr<ChannelSocket> socket, const DeviceId&) {
         CPPUNIT_ASSERT(socket);
         if (socket) {
-            std::lock_guard<std::mutex> lk {mtx};
+            std::lock_guard lk {mtx};
             successfullyConnected++;
             cv.notify_one();
         }
@@ -399,14 +399,14 @@ ConnectionManagerTest::testManyChannels()
             rxbuf->insert(rxbuf->end(), data, data + size);
             if (rxbuf->size() == 32) {
                 CPPUNIT_ASSERT(!std::memcmp(data_sent.data(), rxbuf->data(), data_sent.size()));
-                std::lock_guard<std::mutex> lk {mtx};
+                std::lock_guard lk {mtx};
                 successfullyReceived++;
                 cv.notify_one();
             }
             return size;
         });
         socket->onShutdown([&]() {
-            std::lock_guard<std::mutex> lk {mtx};
+            std::lock_guard lk {mtx};
             shutdownCount++;
             cv.notify_one();
         });
@@ -428,7 +428,7 @@ ConnectionManagerTest::testManyChannels()
            std::this_thread::sleep_for(5ms);
     }
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     cv.wait_for(lk, 30s, [&] { return successfullyConnected == N * 2; });
     CPPUNIT_ASSERT_EQUAL(N * 2, successfullyConnected);
     cv.wait_for(lk, 30s, [&] { return accepted == N * 2; });
@@ -489,7 +489,7 @@ ConnectionManagerTest::testMultipleChannels()
         [&](const DeviceId&, const std::string& name,
                              std::shared_ptr<ChannelSocket> socket) {
             if (not name.empty()) {
-                std::lock_guard<std::mutex> lk {mtx};
+                std::lock_guard lk {mtx};
                 if (socket)
                     receiverConnected += 1;
                 cv.notify_one();
@@ -501,7 +501,7 @@ ConnectionManagerTest::testMultipleChannels()
                                             [&](std::shared_ptr<ChannelSocket> socket,
                                                 const DeviceId&) {
                                                 if (socket) {
-                                                    std::lock_guard<std::mutex> lk {mtx};
+                                                    std::lock_guard lk {mtx};
                                                     successfullyConnected = true;
                                                     cv.notify_one();
                                                 }
@@ -512,13 +512,13 @@ ConnectionManagerTest::testMultipleChannels()
                                             [&](std::shared_ptr<ChannelSocket> socket,
                                                 const DeviceId&) {
                                                 if (socket) {
-                                                    std::lock_guard<std::mutex> lk {mtx};
+                                                    std::lock_guard lk {mtx};
                                                     successfullyConnected2 = true;
                                                     cv.notify_one();
                                                 }
                                             });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     CPPUNIT_ASSERT(cv.wait_for(lk, 60s, [&] {
         return successfullyConnected && successfullyConnected2 && receiverConnected == 2;
     }));
@@ -531,7 +531,7 @@ ConnectionManagerTest::testMultipleChannelsOneDeclined()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyNotConnected = false;
     bool successfullyConnected2 = false;
@@ -581,7 +581,7 @@ ConnectionManagerTest::testMultipleChannelsSameName()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
     bool successfullyConnected2 = false;
@@ -630,7 +630,7 @@ ConnectionManagerTest::testSendReceiveData()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     std::atomic_int events(0);
     bool successfullyConnected = false, successfullyConnected2 = false, successfullyReceive = false,
@@ -702,7 +702,7 @@ ConnectionManagerTest::testAcceptsICERequest()
 {
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
     bool successfullyReceive = false;
@@ -751,7 +751,7 @@ ConnectionManagerTest::testDeclineICERequest()
     bob->connectionManager->onChannelRequest(
         [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
     bob->connectionManager->onICERequest([&](const DeviceId&) {
-        std::lock_guard<std::mutex> lock {mtx};
+        std::lock_guard lock {mtx};
         successfullyReceive = true;
         cv.notify_one();
         return false;
@@ -768,7 +768,7 @@ ConnectionManagerTest::testDeclineICERequest()
                                             "git://*",
                                             [&](std::shared_ptr<ChannelSocket> socket,
                                                 const DeviceId&) {
-                                                std::lock_guard<std::mutex> lock {mtx};
+                                                std::lock_guard lock {mtx};
                                                 if (socket) {
                                                     successfullyConnected = true;
                                                 }
@@ -776,7 +776,7 @@ ConnectionManagerTest::testDeclineICERequest()
                                                 cv.notify_one();
                                             });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     CPPUNIT_ASSERT(cv.wait_for(lk, 35s, [&] { return successfullyReceive; }));
     CPPUNIT_ASSERT(cv.wait_for(lk, 35s, [&] { return connectCompleted; }));
     CPPUNIT_ASSERT(!receiverConnected);
@@ -789,7 +789,7 @@ ConnectionManagerTest::testChannelRcvShutdown()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
     bool shutdownReceived = false;
@@ -843,7 +843,7 @@ ConnectionManagerTest::testChannelSenderShutdown()
     bob->connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&,
                                const std::string& name) {
-            std::lock_guard<std::mutex> lk {mtx};
+            std::lock_guard lk {mtx};
             successfullyReceive = name == "git://*";
             rcv.notify_one();
             return true;
@@ -853,13 +853,13 @@ ConnectionManagerTest::testChannelSenderShutdown()
         [&](const DeviceId&, const std::string& name, std::shared_ptr<ChannelSocket> socket) {
             if (socket) {
                 socket->onShutdown([&] {
-                    std::lock_guard<std::mutex> lk {mtx};
+                    std::lock_guard lk {mtx};
                     shutdownReceived = true;
                     scv.notify_one();
                 });
             }
             if (not name.empty()) {
-                std::lock_guard<std::mutex> lk {mtx};
+                std::lock_guard lk {mtx};
                 receiverConnected = socket && (name == "git://*");
                 rcv.notify_one();
             }
@@ -870,14 +870,14 @@ ConnectionManagerTest::testChannelSenderShutdown()
                                             [&](std::shared_ptr<ChannelSocket> socket,
                                                 const DeviceId&) {
                                                 if (socket) {
-                                                    std::lock_guard<std::mutex> lk {mtx};
+                                                    std::lock_guard lk {mtx};
                                                     successfullyConnected = true;
                                                     rcv.notify_one();
                                                     socket->shutdown();
                                                 }
                                             });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     rcv.wait_for(lk, 30s, [&] { return successfullyConnected && successfullyReceive && receiverConnected; });
     scv.wait_for(lk, 30s, [&] { return shutdownReceived; });
 }
@@ -898,7 +898,7 @@ ConnectionManagerTest::testCloseConnectionWith()
     bob->connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&,
                                const std::string& name) {
-            std::lock_guard<std::mutex> lk {mtx};
+            std::lock_guard lk {mtx};
             successfullyReceive = name == "git://*";
             return true;
         });
@@ -908,13 +908,13 @@ ConnectionManagerTest::testCloseConnectionWith()
                                                   std::shared_ptr<dhtnet::ChannelSocket> socket) {
         if (socket) {
             socket->onShutdown([&] {
-                std::lock_guard<std::mutex> lk {mtx};
+                std::lock_guard lk {mtx};
                 events++;
                 scv.notify_one();
             });
         }
         if (not name.empty()) {
-            std::lock_guard<std::mutex> lk {mtx};
+            std::lock_guard lk {mtx};
             receiverConnected = socket && (name == "git://*");
             rcv.notify_one();
         }
@@ -926,18 +926,18 @@ ConnectionManagerTest::testCloseConnectionWith()
                                                 const DeviceId&) {
                                                 if (socket) {
                                                     socket->onShutdown([&] {
-                                                        std::lock_guard<std::mutex> lk {mtx};
+                                                        std::lock_guard lk {mtx};
                                                         events++;
                                                         scv.notify_one();
                                                     });
-                                                    std::lock_guard<std::mutex> lk {mtx};
+                                                    std::lock_guard lk {mtx};
                                                     successfullyConnected = true;
                                                     rcv.notify_one();
                                                 }
                                             });
 
     {
-        std::unique_lock<std::mutex> lk {mtx};
+        std::unique_lock lk {mtx};
         rcv.wait_for(lk, 30s, [&] {
             return successfullyReceive && successfullyConnected && receiverConnected;
         });
@@ -945,7 +945,7 @@ ConnectionManagerTest::testCloseConnectionWith()
     std::this_thread::sleep_for(1s);
     // This should trigger onShutdown
     alice->connectionManager->closeConnectionsWith(bobUri);
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     CPPUNIT_ASSERT(scv.wait_for(lk, 10s, [&] { return events == 2; }));
 }
 
@@ -966,7 +966,7 @@ ConnectionManagerTest::testShutdownCallbacks()
     bob->connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name) {
             if (name == "1") {
-                std::unique_lock<std::mutex> lk {mtx};
+                std::unique_lock lk {mtx};
                 successfullyReceive = true;
                 rcv.notify_one();
             } else {
@@ -981,7 +981,7 @@ ConnectionManagerTest::testShutdownCallbacks()
                                                   const std::string& name,
                                                   std::shared_ptr<dhtnet::ChannelSocket> socket) {
         if (name == "1") {
-            std::unique_lock<std::mutex> lk {mtx};
+            std::unique_lock lk {mtx};
             receiverConnected = (bool)socket;
             rcv.notify_one();
         }
@@ -992,13 +992,13 @@ ConnectionManagerTest::testShutdownCallbacks()
                                             [&](std::shared_ptr<dhtnet::ChannelSocket> socket,
                                                 const DeviceId&) {
                                                 if (socket) {
-                                                    std::unique_lock<std::mutex> lk {mtx};
+                                                    std::unique_lock lk {mtx};
                                                     successfullyConnected = true;
                                                     rcv.notify_one();
                                                 }
                                             });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     // Connect first channel. This will initiate a mx sock
     CPPUNIT_ASSERT(rcv.wait_for(lk, 30s, [&] {
         return successfullyReceive && successfullyConnected && receiverConnected;
@@ -1059,7 +1059,7 @@ ConnectionManagerTest::testFloodSocket()
                                                 }
                                                 cv.notify_one();
                                             });
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] {
         return successfullyReceive && successfullyConnected && receiverConnected;
     }));
@@ -1101,21 +1101,21 @@ ConnectionManagerTest::testFloodSocket()
     rcv2.reserve(totSize);
     rcv3.reserve(totSize);
     rcvSock1->setOnRecv([&](const uint8_t* buf, size_t len) {
-        std::lock_guard<std::mutex> lk {mtx1};
+        std::lock_guard lk {mtx1};
         rcv1 += std::string_view((const char*)buf, len);
         if (rcv1.size() == totSize)
             cv.notify_one();
         return len;
     });
     rcvSock2->setOnRecv([&](const uint8_t* buf, size_t len) {
-        std::lock_guard<std::mutex> lk {mtx2};
+        std::lock_guard lk {mtx2};
         rcv2 += std::string_view((const char*)buf, len);
         if (rcv2.size() == totSize)
             cv.notify_one();
         return len;
     });
     rcvSock3->setOnRecv([&](const uint8_t* buf, size_t len) {
-        std::lock_guard<std::mutex> lk {mtx3};
+        std::lock_guard lk {mtx3};
         rcv3 += std::string_view((const char*)buf, len);
         if (rcv3.size() == totSize)
             cv.notify_one();
@@ -1131,15 +1131,15 @@ ConnectionManagerTest::testFloodSocket()
         CPPUNIT_ASSERT(!ec);
     }
     {
-        std::unique_lock<std::mutex> lk {mtx1};
+        std::unique_lock lk {mtx1};
         CPPUNIT_ASSERT(cv.wait_for(lk, 30s, [&] { return shouldRcv == rcv1; }));
     }
     {
-        std::unique_lock<std::mutex> lk {mtx2};
+        std::unique_lock lk {mtx2};
         CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return shouldRcv == rcv2; }));
     }
     {
-        std::unique_lock<std::mutex> lk {mtx3};
+        std::unique_lock lk {mtx3};
         CPPUNIT_ASSERT(cv.wait_for(lk, 10s, [&] { return shouldRcv == rcv3; }));
     }
 }
@@ -1151,7 +1151,7 @@ ConnectionManagerTest::testDestroyWhileSending()
     // This test if a segfault occurs
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
     bool successfullyReceive = false;
@@ -1236,7 +1236,7 @@ ConnectionManagerTest::testIsConnecting()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false, successfullyReceive = false;
 
@@ -1274,7 +1274,7 @@ ConnectionManagerTest::testIsConnected()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false, successfullyReceive = false;
 
@@ -1304,7 +1304,7 @@ ConnectionManagerTest::testCanSendBeacon()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
 
@@ -1355,7 +1355,7 @@ ConnectionManagerTest::testCannotSendBeacon()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
 
@@ -1399,7 +1399,7 @@ ConnectionManagerTest::testConnectivityChangeTriggerBeacon()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
 
@@ -1442,7 +1442,7 @@ ConnectionManagerTest::testOnNoBeaconTriggersShutdown()
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyConnected = false;
 
@@ -1484,7 +1484,7 @@ ConnectionManagerTest::testShutdownWhileNegotiating()
 {
     alice->connectionManager->onICERequest([](const DeviceId&) { return true; });
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     std::condition_variable cv;
     bool successfullyReceive = false;
     bool notConnected = false;
@@ -1518,14 +1518,14 @@ ConnectionManagerTest::testGetChannelList()
 {
     bob->connectionManager->onICERequest([](const DeviceId&) { return true; });
     std::condition_variable cv;
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     bool successfullyConnected = false;
     int receiverConnected = 0;
     bob->connectionManager->onChannelRequest(
         [](const std::shared_ptr<dht::crypto::Certificate>&, const std::string&) { return true; });
     bob->connectionManager->onConnectionReady(
         [&](const DeviceId&, const std::string&, std::shared_ptr<ChannelSocket> socket) {
-            std::lock_guard<std::mutex> lk {mtx};
+            std::lock_guard lk {mtx};
             if (socket)
                 receiverConnected += 1;
             cv.notify_one();
@@ -1535,7 +1535,7 @@ ConnectionManagerTest::testGetChannelList()
                                             "git://*",
                                             [&](std::shared_ptr<ChannelSocket> socket,
                                                 const DeviceId&) {
-                                                std::lock_guard<std::mutex> lk {mtx};
+                                                std::lock_guard lk {mtx};
                                                 if (socket) {
                                                     channelId = fmt::format(FMT_COMPILE("{:x}"), socket->channel());
                                                     successfullyConnected = true;
diff --git a/tests/ice.cpp b/tests/ice.cpp
index 31315d25..9873bdbe 100644
--- a/tests/ice.cpp
+++ b/tests/ice.cpp
@@ -122,7 +122,7 @@ IceTest::testRawIceConnection()
     ice_config.tcpEnable = true;
     std::shared_ptr<dhtnet::IceTransport> ice_master, ice_slave;
     std::mutex mtx, mtx_create, mtx_resp, mtx_init;
-    std::unique_lock<std::mutex> lk {mtx}, lk_create {mtx_create}, lk_resp {mtx_resp},
+    std::unique_lock lk {mtx}, lk_create {mtx_create}, lk_resp {mtx_resp},
         lk_init {mtx_init};
     std::condition_variable cv, cv_create, cv_resp, cv_init;
     std::string init = {};
@@ -227,7 +227,7 @@ IceTest::testTurnMasterIceConnection()
         CPPUNIT_ASSERT(ok);
         dht::ThreadPool::io().run([&] {
             /*{
-                std::unique_lock<std::mutex> lk_create {mtx_create};
+                std::unique_lock lk_create {mtx_create};
                 CPPUNIT_ASSERT(cv_create.wait_for(lk_create, std::chrono::seconds(10), [&] {
                     return ice_master != nullptr;
                 }));
@@ -257,7 +257,7 @@ IceTest::testTurnMasterIceConnection()
                 cv_init.notify_one();
             }
             {
-                std::unique_lock<std::mutex> lk_resp {mtx_resp};
+                std::unique_lock lk_resp {mtx_resp};
                 CPPUNIT_ASSERT(cv_resp.wait_for(lk_resp, std::chrono::seconds(10), [&] {
                     return !response.empty();
                 }));
@@ -285,7 +285,7 @@ IceTest::testTurnMasterIceConnection()
     ice_config.upnpContext = upnpContext;
     ice_config.factory = factory;
     {
-        std::unique_lock<std::mutex> lk_create {mtx_create};
+        std::unique_lock lk_create {mtx_create};
         ice_master = factory->createTransport("master ICE");
         ice_master->initIceInstance(ice_config);
         cv_create.notify_all();
@@ -296,7 +296,7 @@ IceTest::testTurnMasterIceConnection()
     ice_config.onInitDone = [&](bool ok) {
         CPPUNIT_ASSERT(ok);
         dht::ThreadPool::io().run([&] {
-            /*std::unique_lock<std::mutex> lk_create {mtx_create};
+            /*std::unique_lock lk_create {mtx_create};
             CPPUNIT_ASSERT(cv_create.wait_for(lk_create, std::chrono::seconds(10), [&] {
                 return ice_slave != nullptr;
             }));*/
@@ -343,7 +343,7 @@ IceTest::testTurnMasterIceConnection()
     ice_config.upnpContext = upnpContext;
     ice_config.factory = factory;
     {
-        std::unique_lock<std::mutex> lk_create {mtx_create};
+        std::unique_lock lk_create {mtx_create};
         ice_slave = factory->createTransport("slave ICE");
         ice_slave->initIceInstance(ice_config);
         cv_create.notify_all();
@@ -368,7 +368,7 @@ IceTest::testTurnSlaveIceConnection()
     ice_config.tcpEnable = true;
     std::shared_ptr<dhtnet::IceTransport> ice_master, ice_slave;
     std::mutex mtx, mtx_create, mtx_resp, mtx_init;
-    std::unique_lock<std::mutex> lk {mtx}, lk_create {mtx_create}, lk_resp {mtx_resp},
+    std::unique_lock lk {mtx}, lk_create {mtx_create}, lk_resp {mtx_resp},
         lk_init {mtx_init};
     std::condition_variable cv, cv_create, cv_resp, cv_init;
     std::string init = {};
@@ -494,7 +494,7 @@ IceTest::testReceiveTooManyCandidates()
         CPPUNIT_ASSERT(ok);
         dht::ThreadPool::io().run([&] {
             {
-                std::unique_lock<std::mutex> lk_create {mtx_create};
+                std::unique_lock lk_create {mtx_create};
                 CPPUNIT_ASSERT(cv_create.wait_for(lk_create, std::chrono::seconds(10), [&] {
                     return ice_master != nullptr;
                 }));
@@ -510,7 +510,7 @@ IceTest::testReceiveTooManyCandidates()
             init = icemsg.str();
             cv_init.notify_one();
             {
-                std::unique_lock<std::mutex> lk_resp {mtx_resp};
+                std::unique_lock lk_resp {mtx_resp};
                 CPPUNIT_ASSERT(cv_resp.wait_for(lk_resp, std::chrono::seconds(10), [&] {
                     return !response.empty();
                 }));
@@ -544,7 +544,7 @@ IceTest::testReceiveTooManyCandidates()
         CPPUNIT_ASSERT(ok);
         dht::ThreadPool::io().run([&] {
             {
-                std::unique_lock<std::mutex> lk_create {mtx_create};
+                std::unique_lock lk_create {mtx_create};
                 CPPUNIT_ASSERT(cv_create.wait_for(lk_create, std::chrono::seconds(10), [&] {
                     return ice_slave != nullptr;
                 }));
@@ -566,11 +566,11 @@ IceTest::testReceiveTooManyCandidates()
                        << "\n";
             }
             {
-                std::lock_guard<std::mutex> lk_resp {mtx_resp};
+                std::lock_guard lk_resp {mtx_resp};
                 response = icemsg.str();
                 cv_resp.notify_one();
             }
-            std::unique_lock<std::mutex> lk_init {mtx_init};
+            std::unique_lock lk_init {mtx_init};
             CPPUNIT_ASSERT(
                 cv_init.wait_for(lk_init, std::chrono::seconds(10), [&] { return !init.empty(); }));
             auto sdp = ice_slave->parseIceCandidates(init);
@@ -592,7 +592,7 @@ IceTest::testReceiveTooManyCandidates()
     ice_slave->initIceInstance(ice_config);
     cv_create.notify_all();
 
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     CPPUNIT_ASSERT(
         cv.wait_for(lk, std::chrono::seconds(10), [&] { return iceMasterReady && iceSlaveReady; }));
 }
@@ -608,7 +608,7 @@ IceTest::testCompleteOnFailure()
     ice_config.tcpEnable = true;
     std::shared_ptr<dhtnet::IceTransport> ice_master, ice_slave;
     std::mutex mtx, mtx_create, mtx_resp, mtx_init;
-    std::unique_lock<std::mutex> lk {mtx}, lk_create {mtx_create}, lk_resp {mtx_resp},
+    std::unique_lock lk {mtx}, lk_create {mtx_create}, lk_resp {mtx_resp},
         lk_init {mtx_init};
     std::condition_variable cv, cv_create, cv_resp, cv_init;
     std::string init = {};
diff --git a/tools/benchmark/main.cpp b/tools/benchmark/main.cpp
index 068d1336..6823307a 100644
--- a/tools/benchmark/main.cpp
+++ b/tools/benchmark/main.cpp
@@ -90,7 +90,7 @@ runBench(std::shared_ptr<asio::io_context> ioContext,
 {
     BenchResult ret;
     std::mutex mtx;
-    std::unique_lock<std::mutex> lock {mtx};
+    std::unique_lock lock {mtx};
     std::condition_variable serverConVar;
 
     auto boostrap_node = std::make_shared<dht::DhtRunner>();
diff --git a/tools/dnc/dnc.cpp b/tools/dnc/dnc.cpp
index 6bde30e9..3923716c 100644
--- a/tools/dnc/dnc.cpp
+++ b/tools/dnc/dnc.cpp
@@ -99,7 +99,7 @@ Dnc::Dnc(dht::crypto::Identity identity,
     });
 
     std::mutex mtx;
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
 
     connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name) {
diff --git a/tools/dsh/dsh.cpp b/tools/dsh/dsh.cpp
index 60637ff2..9da05443 100644
--- a/tools/dsh/dsh.cpp
+++ b/tools/dsh/dsh.cpp
@@ -126,7 +126,7 @@ dhtnet::Dsh::Dsh(dht::crypto::Identity identity,
     });
 
     std::mutex mtx;
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
 
     connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string& name) {
diff --git a/tools/dvpn/dvpn.cpp b/tools/dvpn/dvpn.cpp
index 47cd95c6..021b000b 100644
--- a/tools/dvpn/dvpn.cpp
+++ b/tools/dvpn/dvpn.cpp
@@ -97,7 +97,7 @@ call_script_shell(const char* script,
     pid_t pid;
     int status;
     std::mutex mtx;
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     if ((pid = fork()) < 0) {
         perror("fork");
         return -1;
@@ -131,7 +131,7 @@ open_tun(char* dev)
     int fd; // file descriptor
     struct ifreq ifr;
     std::mutex mtx;
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
     if ((fd = open("/dev/net/tun", O_RDWR)) < 0) {
         perror("Opening /dev/net/tun");
         return -1;
@@ -209,7 +209,7 @@ dhtnet::DvpnServer::DvpnServer(dht::crypto::Identity identity,
     : Dvpn(identity, bootstrap, turn_host, turn_user, turn_pass, turn_realm, configuration_file)
 {
     std::mutex mtx;
-    std::unique_lock<std::mutex> lk {mtx};
+    std::unique_lock lk {mtx};
 
     connectionManager->onChannelRequest(
         [&](const std::shared_ptr<dht::crypto::Certificate>&, const std::string& channel) {