From ca7c9bff640b9b85c6eb74fda75e34da9d2d3e3e Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Fri, 8 Jul 2022 12:28:25 +0530 Subject: [PATCH 01/50] initial transport --- go.mod | 18 ++ go.sum | 58 ++++- p2p/transport/webrtc/connection.go | 87 +++++++ p2p/transport/webrtc/datachannel.go | 84 +++++++ p2p/transport/webrtc/listener.go | 152 +++++++++++ p2p/transport/webrtc/listener_test.go | 259 +++++++++++++++++++ p2p/transport/webrtc/protocol.go | 42 ++++ p2p/transport/webrtc/sdp.go | 87 +++++++ p2p/transport/webrtc/transport.go | 17 ++ p2p/transport/webrtc/udp_mux.go | 348 ++++++++++++++++++++++++++ p2p/transport/webrtc/udp_mux_conn.go | 247 ++++++++++++++++++ p2p/transport/webrtc/udp_mux_test.go | 63 +++++ p2p/transport/webrtc/util.go | 60 +++++ p2p/transport/webrtc/util_test.go | 36 +++ 14 files changed, 1557 insertions(+), 1 deletion(-) create mode 100644 p2p/transport/webrtc/connection.go create mode 100644 p2p/transport/webrtc/datachannel.go create mode 100644 p2p/transport/webrtc/listener.go create mode 100644 p2p/transport/webrtc/listener_test.go create mode 100644 p2p/transport/webrtc/protocol.go create mode 100644 p2p/transport/webrtc/sdp.go create mode 100644 p2p/transport/webrtc/transport.go create mode 100644 p2p/transport/webrtc/udp_mux.go create mode 100644 p2p/transport/webrtc/udp_mux_conn.go create mode 100644 p2p/transport/webrtc/udp_mux_test.go create mode 100644 p2p/transport/webrtc/util.go create mode 100644 p2p/transport/webrtc/util_test.go diff --git a/go.mod b/go.mod index 80dc32bc3d..698bc6066b 100644 --- a/go.mod +++ b/go.mod @@ -22,6 +22,7 @@ require ( github.com/libp2p/go-buffer-pool v0.1.0 github.com/libp2p/go-flow-metrics v0.1.0 github.com/libp2p/go-libp2p-asn-util v0.2.0 + github.com/libp2p/go-libp2p-core v0.20.1 github.com/libp2p/go-libp2p-testing v0.12.0 github.com/libp2p/go-mplex v0.7.0 github.com/libp2p/go-msgio v0.2.0 @@ -47,6 +48,12 @@ require ( github.com/multiformats/go-multistream v0.3.3 github.com/multiformats/go-varint v0.0.6 github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 + github.com/pion/datachannel v1.5.2 + github.com/pion/ice/v2 v2.2.6 + github.com/pion/logging v0.2.2 + github.com/pion/stun v0.3.5 + github.com/pion/transport v0.13.1 + github.com/pion/webrtc/v3 v3.1.42 github.com/prometheus/client_golang v1.13.0 github.com/raulk/go-watchdog v1.3.0 github.com/stretchr/testify v1.8.0 @@ -95,6 +102,17 @@ require ( github.com/nxadm/tail v1.4.8 // indirect github.com/onsi/ginkgo v1.16.5 // indirect github.com/opencontainers/runtime-spec v1.0.2 // indirect + github.com/pion/dtls/v2 v2.1.5 // indirect + github.com/pion/interceptor v0.1.11 // indirect + github.com/pion/mdns v0.0.5 // indirect + github.com/pion/randutil v0.1.0 // indirect + github.com/pion/rtcp v1.2.9 // indirect + github.com/pion/rtp v1.7.13 // indirect + github.com/pion/sctp v1.8.2 // indirect + github.com/pion/sdp/v3 v3.0.5 // indirect + github.com/pion/srtp/v2 v2.0.9 // indirect + github.com/pion/turn/v2 v2.0.8 // indirect + github.com/pion/udp v0.1.1 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/prometheus/client_model v0.2.0 // indirect diff --git a/go.sum b/go.sum index 35541b032a..143e4cd004 100644 --- a/go.sum +++ b/go.sum @@ -297,6 +297,8 @@ github.com/libp2p/go-flow-metrics v0.1.0 h1:0iPhMI8PskQwzh57jB9WxIuIOQ0r+15PChFG github.com/libp2p/go-flow-metrics v0.1.0/go.mod h1:4Xi8MX8wj5aWNDAZttg6UPmc0ZrnFNsMtpsYUClFtro= github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= +github.com/libp2p/go-libp2p-core v0.20.1 h1:fQz4BJyIFmSZAiTbKV8qoYhEH5Dtv/cVhZbG3Ib/+Cw= +github.com/libp2p/go-libp2p-core v0.20.1/go.mod h1:6zR8H7CvQWgYLsbG4on6oLNSGcyKaYFSEYyDt51+bIY= github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA= github.com/libp2p/go-libp2p-testing v0.12.0/go.mod h1:KcGDRXyN7sQCllucn1cOOS+Dmm7ujhfEyXQL5lvkcPg= github.com/libp2p/go-mplex v0.7.0 h1:BDhFZdlk5tbr0oyFq/xv/NPGfjbnrsDam1EvutpBDbY= @@ -399,18 +401,59 @@ github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= +github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/onsi/gomega v1.13.0 h1:7lLHu94wT9Ij0o6EWWclhu0aOh32VxhkwEJvzuWPeak= +github.com/onsi/gomega v1.17.0 h1:9Luw4uT5HTjHTN8+aNcSThgH1vdXnmdJ8xIfZ4wyTRE= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= github.com/opencontainers/runtime-spec v1.0.2 h1:UfAcuLBJB9Coz72x1hgl8O5RVzTdNiaglX6v2DM6FI0= github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8= github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0= github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pion/datachannel v1.5.2 h1:piB93s8LGmbECrpO84DnkIVWasRMk3IimbcXkTQLE6E= +github.com/pion/datachannel v1.5.2/go.mod h1:FTGQWaHrdCwIJ1rw6xBIfZVkslikjShim5yr05XFuCQ= +github.com/pion/dtls/v2 v2.1.3/go.mod h1:o6+WvyLDAlXF7YiPB/RlskRoeK+/JtuaZa5emwQcWus= +github.com/pion/dtls/v2 v2.1.5 h1:jlh2vtIyUBShchoTDqpCCqiYCyRFJ/lvf/gQ8TALs+c= +github.com/pion/dtls/v2 v2.1.5/go.mod h1:BqCE7xPZbPSubGasRoDFJeTsyJtdD1FanJYL0JGheqY= +github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig= +github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE= +github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs= +github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8= +github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY= +github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms= +github.com/pion/mdns v0.0.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw= +github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g= +github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA= +github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8= +github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U= +github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo= +github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA= +github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko= +github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= +github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA= +github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= +github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU= +github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw= +github.com/pion/srtp/v2 v2.0.9 h1:JJq3jClmDFBPX/F5roEb0U19jSU7eUhyDqR/NZ34EKQ= +github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4= +github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg= +github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA= +github.com/pion/transport v0.12.2/go.mod h1:N3+vZQD9HlDP5GWkZ85LohxNsDcNgofQmyL6ojX5d8Q= +github.com/pion/transport v0.12.3/go.mod h1:OViWW9SP2peE/HbwBvARicmAVnesphkNkCVZIWJ6q9A= +github.com/pion/transport v0.13.0/go.mod h1:yxm9uXpK9bpBBWkITk13cLo1y5/ur5VQpG22ny6EP7g= +github.com/pion/transport v0.13.1 h1:/UH5yLeQtwm2VZIPjxwnNFxjS4DFhyLfS4GlfuKUzfA= +github.com/pion/transport v0.13.1/go.mod h1:EBxbqzyv+ZrmDb82XswEE0BjfQFtuw1Nu6sjnjWCsGg= +github.com/pion/turn/v2 v2.0.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw= +github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw= +github.com/pion/udp v0.1.1 h1:8UAPvyqmsxK8oOjloDk4wUt63TzFe9WEJkg5lChlj7o= +github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M= +github.com/pion/webrtc/v3 v3.1.42 h1:wJEQFIXVanptnQcHOLTuIo4AtGB2+mG2x4OhIhnITOA= +github.com/pion/webrtc/v3 v3.1.42/go.mod h1:ffD9DulDrPxyWvDPUIPAOSAWx9GUlOExiJPf7cCcMLA= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -450,6 +493,7 @@ github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtD github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw= github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY= github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM= @@ -554,6 +598,9 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20200602180216-279210d13fed/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e h1:T8NU3HyQ8ClP4SEE+KbFlg6n0NhuTsN4MyznaarGsZM= golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -629,14 +676,21 @@ golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81R golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201201195509-5d6afe98e0b7/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211201190559-0a0e4e1bb54c/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220401154927-543a649e0bdd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220531201128-c960675eff93/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5 h1:KafLifaRFIuSJ5C+7CyFJOF9haxKNC1CEIDk8GX6X0k= golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -723,6 +777,8 @@ golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go new file mode 100644 index 0000000000..fd1891f416 --- /dev/null +++ b/p2p/transport/webrtc/connection.go @@ -0,0 +1,87 @@ +package libp2pwebrtc + +import ( + "context" + + "github.com/libp2p/go-libp2p-core/crypto" + "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p-core/peer" + ma "github.com/multiformats/go-multiaddr" + "github.com/pion/webrtc/v3" +) + +type connection struct { + conn *webrtc.PeerConnection + // ConnSecurity + idKey crypto.PrivKey + remotePeerID peer.ID + + // ConnMultiaddrs + localMultiaddr, remoteMultiaddr ma.Multiaddr + + closeChan chan struct{} +} + +func newConnection(conn *webrtc.PeerConnection) (*connection, error) { + return nil, nil +} + +// Implement network.ConnSecurity +func (c *connection) LocalPeer() peer.ID { + id, err := peer.IDFromPrivateKey(c.idKey) + if err != nil { + return "" + } + return id +} + +func (c *connection) LocalPrivateKey() crypto.PrivKey { + return c.idKey +} + +func (c *connection) RemotePeer() peer.ID { + return c.remotePeerID +} + +func (c *connection) RemotePublicKey() crypto.PubKey { + key, err := c.remotePeerID.ExtractPublicKey() + if err != nil { + return nil + } + return key +} + +// Implement network.ConnMultiaddrs +func (c *connection) LocalMultiaddr() ma.Multiaddr { + return c.localMultiaddr +} + +func (c *connection) RemoteMultiaddr() ma.Multiaddr { + return c.remoteMultiaddr +} + +// Implement network.MuxedConn + +func (c *connection) Close() error { + select { + case <-c.closeChan: + return nil + default: + close(c.closeChan) + } + return c.conn.Close() +} + +func (c *connection) IsClosed() bool { + select { + case <-c.closeChan: + return true + default: + } + return false +} + +func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error) { + return nil, nil +} + diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go new file mode 100644 index 0000000000..b3dafcd125 --- /dev/null +++ b/p2p/transport/webrtc/datachannel.go @@ -0,0 +1,84 @@ +package libp2pwebrtc + +import ( + "io" + "net" + "time" + + "github.com/pion/datachannel" +) + +// Package pion detached data channel into a net.Conn +// and then a network.MuxedStream +type DataChannel struct { + dc datachannel.ReadWriteCloser + readClosed, writeClosed chan struct{} +} + +func newDataChannel(dc datachannel.ReadWriteCloser) *DataChannel { + return &DataChannel { + dc: dc, + readClosed: make(chan struct{}), + writeClosed: make(chan struct{}), + } +} + +func (d *DataChannel) Read(b []byte) (int, error) { + select { + case <-d.readClosed: + return 0, io.EOF + default: + } + return d.dc.Read(b) +} + +func (d *DataChannel) Write(b []byte) (int, error) { + select { + case <-d.writeClosed: + return 0, io.ErrClosedPipe + default: + } + return d.dc.Write(b) +} + +func (d *DataChannel) Close() error { + return d.dc.Close() +} + +func (d *DataChannel) LocalAddr() net.Addr { + return nil +} + +func (d *DataChannel) RemoteAddr() net.Addr { + return nil +} + +func (d *DataChannel) SetDeadline(t time.Time) error { + return nil +} + +func (d *DataChannel) SetReadDeadline(t time.Time) error { + return nil +} + +func (d *DataChannel) SetWriteDeadline(t time.Time) error { + return nil +} + +func (d *DataChannel) CloseRead() error { + select { + case <-d.readClosed: + default: + close(d.readClosed) + } + return nil +} + +func (d *DataChannel) CloseWrite() error { + select { + case <-d.writeClosed: + default: + close(d.writeClosed) + } + return nil +} diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go new file mode 100644 index 0000000000..3a5775002b --- /dev/null +++ b/p2p/transport/webrtc/listener.go @@ -0,0 +1,152 @@ +package libp2pwebrtc + +import ( + "context" + "errors" + "fmt" + "strings" + "time" + + "github.com/libp2p/go-libp2p-core/crypto" + "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p/p2p/security/noise" + ma "github.com/multiformats/go-multiaddr" + "github.com/pion/webrtc/v3" +) + +type listener struct { + api *webrtc.API + config webrtc.Configuration + mux *UDPMuxNewAddr + newAddrChan chan candidateAddr + local ma.Multiaddr + idKey crypto.PrivKey +} + +var ( + ErrDataChannelTimeout = errors.New("timed out waiting for datachannel") + ErrNoiseHandshakeTimeout = errors.New("noise handshake timeout") + ErrNoCertInConfig = errors.New("no certificate configured in listener config") +) + +func (l *listener) accept(addr candidateAddr) (peer.ID, *webrtc.PeerConnection, error) { + + // Get local fingerprint + if len(l.config.Certificates) < 1 { + return "", nil, ErrNoCertInConfig + } + + localFps, err := l.config.Certificates[0].GetFingerprints() + if err != nil || len(localFps) < 1 { + return "", nil, err + } + localFp := strings.ReplaceAll(localFps[0].Value, ":", "") + + // get remote fingerprint + remoteFp := maFingerprintToSdp(addr.fingerprint) + + se := webrtc.SettingEngine{} + se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) + se.DetachDataChannels() + se.SetICECredentials(addr.fingerprint, localFp) + se.SetLite(true) + se.SetICEUDPMux(l.mux) + + api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) + + clientSdpString := renderClientSdp(sdpArgs{ + Addr: addr.raddr, + Fingerprint: remoteFp, + Ufrag: addr.fingerprint, + Password: addr.fingerprint, + }) + clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} + pc, err := api.NewPeerConnection(l.config) + if err != nil { + return "", nil, err + } + pc.SetRemoteDescription(clientSdp) + + answer, err := pc.CreateAnswer(nil) + if err != nil { + return "", nil, err + } + pc.SetLocalDescription(answer) + + // await openening of datachannel + dcChan := make(chan *DataChannel) + pc.OnDataChannel(func(dc *webrtc.DataChannel) { + // assert that the label of the first DataChannel is "data" + // TODO: Make const and move into spec + if dc.Label() != "data" { + // warn closing data channel + dc.Close() + return + } + + dc.OnOpen(func() { + detached, err := dc.Detach() + if err != nil { + return + } + dcChan <- newDataChannel(detached) + }) + + }) + + timeout := 10 * time.Second + var dc *DataChannel = nil + select { + case <-time.After(timeout): + return "", nil, ErrDataChannelTimeout + case dc = <-dcChan: + if dc == nil { + return "", nil, fmt.Errorf("should be unreachable") + } + // clear to allow opening of future data channels + pc.OnDataChannel(func (*webrtc.DataChannel) {}) + } + // perform noise handshake + noiseTpt, err := noise.New(l.idKey) + if err != nil { + return "", nil, err + } + // we do not yet know A's peer ID so accept any inbound + secureConn, err := noiseTpt.SecureInbound(context.Background(), dc, "") + if err != nil { + return "", nil, err + } + + _, err = secureConn.Write([]byte(maFingerprintToSdp(localFp))) + if err != nil { + return "", nil, err + } + + buf := make([]byte, 200) + n, err := secureConn.Read(buf) + if err != nil { + return "", nil, err + } + + // Ordinarily, we would do this with a ReadDeadline, but since the underlying datachannel.ReadWriteCloser + // does not allow us to set ReadDeadline, we have to manually spawn a goroutine + done := make(chan error, 1) + go func() { + if string(buf[:n]) != remoteFp { + done <- fmt.Errorf("could not verify remote fingerprint: expected: %s, got: %s", remoteFp, string(buf[:n])) + } + close(done) + }() + + select { + case err = <-done: + if done != nil { + return "", nil, err + } + case <-time.After(10 * time.Second): + return "", nil, ErrNoiseHandshakeTimeout + } + + // return the peerID and PeerConnection object + return secureConn.RemotePeer(), pc, nil +} diff --git a/p2p/transport/webrtc/listener_test.go b/p2p/transport/webrtc/listener_test.go new file mode 100644 index 0000000000..b0a4d0a325 --- /dev/null +++ b/p2p/transport/webrtc/listener_test.go @@ -0,0 +1,259 @@ +package libp2pwebrtc + +import ( + // "fmt" + // "log" + "context" + "fmt" + "net" + "os" + "strings" + "testing" + + "github.com/libp2p/go-libp2p-core/crypto" + "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p-core/sec" + "github.com/libp2p/go-libp2p/p2p/security/noise" + "github.com/pion/ice/v2" + "github.com/pion/logging" + "github.com/pion/webrtc/v3" + + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" +) + +func setupMux() (*UDPMuxNewAddr, chan candidateAddr) { + serverConn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}) + if err != nil { + panic(err) + } + + loggerFactory := logging.NewDefaultLoggerFactory() + loggerFactory.Writer = os.Stdout + loggerFactory.DefaultLogLevel = logging.LogLevelDebug + + logger := loggerFactory.NewLogger("mux-test") + + newAddrChan := make(chan candidateAddr, 1) + mux := NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: serverConn, Logger: logger}, newAddrChan) + return mux, newAddrChan +} + +func setupCert() *webrtc.Certificate { + pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + if err != nil { + panic(err) + } + cert, err := webrtc.GenerateCertificate(pk) + if err != nil { + panic(err) + } + return cert +} + +func fingerprintFromCert(certs []webrtc.Certificate) string { + c, err := certs[0].GetFingerprints() + if err != nil { + panic(err) + } + return c[0].Value +} + +func setupListener(mux *UDPMuxNewAddr, newAddrChan chan candidateAddr) (*listener, string, peer.ID) { + privKey, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1) + if err != nil { + panic(err) + } + + cert := setupCert() + config := webrtc.Configuration{ + Certificates: []webrtc.Certificate{*cert}, + } + + peerID, err := peer.IDFromPrivateKey(privKey) + if err != nil { + panic(err) + } + + fp := strings.ReplaceAll(fingerprintFromCert(config.Certificates), ":", "") + + settingEngine := webrtc.SettingEngine{} + settingEngine.DetachDataChannels() + settingEngine.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) + settingEngine.SetICEUDPMux(mux) + settingEngine.SetLite(true) + + api := webrtc.NewAPI(webrtc.WithSettingEngine(settingEngine)) + + return &listener{ + api: api, + config: config, + mux: mux, + newAddrChan: newAddrChan, + idKey: privKey, + }, fp, peerID + +} + +func testDial( + t *testing.T, + mux *UDPMuxNewAddr, + serverFp string, + serverID peer.ID, + handshakeFn func(*testing.T, sec.SecureConn, string) error, +) { + // NOTE: Pion does not allow changing SDP once generated using + // create offer, but chromium does allow this + cert := setupCert() + pcConfig := webrtc.Configuration{Certificates: []webrtc.Certificate{*cert}} + localFp := fingerprintFromCert(pcConfig.Certificates) + localFp = strings.ReplaceAll(localFp, ":", "") + // setting engine + se := webrtc.SettingEngine{} + se.SetICECredentials(localFp, localFp) + se.DetachDataChannels() + api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) + pc, err := api.NewPeerConnection(pcConfig) + pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) { + t.Logf("ice conn state: %v", state) + }) + if err != nil { + panic(err) + } + + dc, err := pc.CreateDataChannel("data", nil) + if err != nil { + panic(err) + } + + opened := make(chan *DataChannel, 1) + dc.OnOpen(func() { + t.Log("datachannel") + detached, err := dc.Detach() + if err != nil { + panic(err) + } + opened <- newDataChannel(detached) + }) + offer, err := pc.CreateOffer(nil) + if err != nil { + panic(err) + } + + // t.Logf("%v", offer) + err = pc.SetLocalDescription(offer) + if err != nil { + panic(err) + } + serverAddr, ok := mux.params.UDPConn.LocalAddr().(*net.UDPAddr) + if !ok { + panic("could not get server address") + } + answerSdpString := renderServerSdp(sdpArgs{ + Addr: serverAddr, + Fingerprint: maFingerprintToSdp(serverFp), + Ufrag: localFp, + Password: serverFp, + }) + + answer := webrtc.SessionDescription{SDP: answerSdpString, Type: webrtc.SDPTypeAnswer} + err = pc.SetRemoteDescription(answer) + if err != nil { + panic(err) + } + dataChannel := <-opened + if dataChannel == nil { + panic("data channel must not be nil") + } + t.Logf("opened data channel") + privKey, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1) + if err != nil { + panic(err) + } + noiseTpt, err := noise.New(privKey) + if err != nil { + panic(err) + } + secureConn, err := noiseTpt.SecureOutbound(context.Background(), dataChannel, serverID) + if err != nil { + panic(err) + } + + err = handshakeFn(t, secureConn, localFp) + if err != nil { + panic(err) + } +} + +func TestAcceptInner(t *testing.T) { + // setup mux + mux, addrChan := setupMux() + + // setup listener + // listener, lFp := setupListener(mux, addrChan) + listener, serverFp, serverID := setupListener(mux, addrChan) + + done := make(chan struct{}, 1) + + go func() { + addr := <-addrChan + _, _, err := listener.accept(addr) + if err != nil { + panic(err) + } + done <- struct{}{} + }() + + handshake := func(te *testing.T, conn sec.SecureConn, clientFp string) error { + _, err := conn.Write([]byte(maFingerprintToSdp(clientFp))) + if err != nil { + return err + } + b := make([]byte, 300) + n, err := conn.Read(b) + remoteFp := string(b[:n]) + if remoteFp != maFingerprintToSdp(serverFp) { + return fmt.Errorf("bad fingerprint") + } + return nil + } + testDial(t, mux, serverFp, serverID, handshake) + <-done +} + +func TestAcceptInnerBadFingerprint(t *testing.T) { + // setup mux + mux, addrChan := setupMux() + + // setup listener + listener, serverFp, serverID := setupListener(mux, addrChan) + + done := make(chan struct{}, 1) + + go func() { + addr := <-addrChan + _, _, err := listener.accept(addr) + t.Log(err) + if err == nil { + panic("should error with bad fingerprint") + } + done <- struct{}{} + }() + + handshake := func(te *testing.T, conn sec.SecureConn, clientFp string) error { + _, err := conn.Write([]byte("bad-fp")) + if err != nil { + return err + } + b := make([]byte, 300) + n, err := conn.Read(b) + remoteFp := string(b[:n]) + if remoteFp != maFingerprintToSdp(serverFp) { + return fmt.Errorf("bad fingerprint") + } + return nil + } + testDial(t, mux, serverFp, serverID, handshake) + <-done +} diff --git a/p2p/transport/webrtc/protocol.go b/p2p/transport/webrtc/protocol.go new file mode 100644 index 0000000000..02190a9a9a --- /dev/null +++ b/p2p/transport/webrtc/protocol.go @@ -0,0 +1,42 @@ +// Temporary until this this protocol can be merged into go-multiaddr +package libp2pwebrtc + +import ( + "encoding/hex" + "fmt" + ma "github.com/multiformats/go-multiaddr" +) + +const P_XWEBRTC = 0x115 + +func xwebrtcVal(b []byte) error { + if len(b) != 32 { + return fmt.Errorf("fingerprint should be 32 bytes, found: %d", len(b)) + } + return nil +} + +func xwebrtcStB(s string) ([]byte, error) { + return hex.DecodeString(s) +} + +func xwebrtcBtS(b []byte) (string, error) { + return hex.EncodeToString(b), nil +} + +var TranscoderXWebRTC = ma.NewTranscoderFromFunctions(xwebrtcStB, xwebrtcBtS, xwebrtcVal) + +var protocol = ma.Protocol{ + Name: "x-webrtc", + Code: P_XWEBRTC, + VCode: ma.CodeToVarint(P_XWEBRTC), + Size: 8 * 32, + Transcoder: TranscoderXWebRTC, +} + +func init() { + err := ma.AddProtocol(protocol) + if err != nil { + panic(err) + } +} diff --git a/p2p/transport/webrtc/sdp.go b/p2p/transport/webrtc/sdp.go new file mode 100644 index 0000000000..11b5b5fe63 --- /dev/null +++ b/p2p/transport/webrtc/sdp.go @@ -0,0 +1,87 @@ +package libp2pwebrtc + +import ( + "fmt" + "net" +) + +type sdpArgs struct { + Addr *net.UDPAddr + Ufrag string + Password string + Fingerprint string +} + +const CLIENT_SDP string = ` +v=0 +o=- 0 0 IN %s %s +s=- +c=IN %s %s +t=0 0 +m=application %d UDP/DTLS/SCTP webrtc-datachannel +a=mid:0 +a=ice-options:ice2 +a=ice-ufrag:%s +a=ice-pwd:%s +a=fingerprint:sha-256 %s +a=setup:actpass +a=sctp-port:5000 +a=max-message-size:100000 +` + +func renderClientSdp(args sdpArgs) string { + ipVersion := "IP4" + if args.Addr.IP.To4() == nil { + ipVersion = "IP6" + } + return fmt.Sprintf( + CLIENT_SDP, + ipVersion, + args.Addr.IP, + ipVersion, + args.Addr.IP, + args.Addr.Port, + args.Ufrag, + args.Password, + args.Fingerprint, + ) +} + +const SERVER_SDP string =` +v=0 +o=- 0 0 IN %s %s +s=- +t=0 0 +a=ice-lite +m=application %d UDP/DTLS/SCTP webrtc-datachannel +c=IN %s %s +a=mid:0 +a=ice-options:ice2 +a=ice-ufrag:%s +a=ice-pwd:%s +a=fingerprint:sha-256 %s +a=setup:passive +a=sctp-port:5000 +a=max-message-size:100000 +a=candidate:1 1 UDP 1 %s %d typ host +` + +func renderServerSdp(args sdpArgs) string { + ipVersion := "IP4" + if args.Addr.IP.To4() == nil { + ipVersion = "IP6" + } + return fmt.Sprintf( + SERVER_SDP, + ipVersion, + args.Addr.IP, + args.Addr.Port, + ipVersion, + args.Addr.IP, + args.Ufrag, + args.Password, + args.Fingerprint, + args.Addr.IP, + args.Addr.Port, + ) +} diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go new file mode 100644 index 0000000000..31adf4be3b --- /dev/null +++ b/p2p/transport/webrtc/transport.go @@ -0,0 +1,17 @@ +package libp2pwebrtc + +import ( + "github.com/pion/webrtc/v3" +) + +type transport struct { + api *webrtc.API +} + +func (t *transport) Protocols() []int { + return []int{ P_XWEBRTC } +} + +func (t *transport) Proxy() bool { + return false +} diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go new file mode 100644 index 0000000000..e4881df153 --- /dev/null +++ b/p2p/transport/webrtc/udp_mux.go @@ -0,0 +1,348 @@ +package libp2pwebrtc + +import ( + "errors" + "io" + "net" + "os" + "strings" + "sync" + + "github.com/pion/ice/v2" + "github.com/pion/logging" + "github.com/pion/stun" +) + +type candidateAddr struct { + raddr *net.UDPAddr + fingerprint string +} + +// UDPMuxNewAddr is an implementation of the interface +type UDPMuxNewAddr struct { + params ice.UDPMuxParams + + closedChan chan struct{} + closeOnce sync.Once + + // connsIPv4 and connsIPv6 are maps of all udpMuxedConn indexed by ufrag|network|candidateType + connsIPv4, connsIPv6 map[string]*udpMuxedConn + + addressMapMu sync.RWMutex + addressMap map[string]*udpMuxedConn + + // buffer pool to recycle buffers for net.UDPAddr encodes/decodes + pool *sync.Pool + + mu sync.Mutex + + newAddrChan chan candidateAddr + newAddrs map[*net.UDPAddr]struct{} +} + +const maxAddrSize = 512 +const receiveMTU = 8192 + +// NewUDPMuxNewAddr creates an implementation of UDPMux +func NewUDPMuxNewAddr(params ice.UDPMuxParams, newAddrChan chan candidateAddr) *UDPMuxNewAddr { + if params.Logger == nil { + params.Logger = logging.NewDefaultLoggerFactory().NewLogger("ice") + } + + m := &UDPMuxNewAddr{ + addressMap: map[string]*udpMuxedConn{}, + params: params, + connsIPv4: make(map[string]*udpMuxedConn), + connsIPv6: make(map[string]*udpMuxedConn), + closedChan: make(chan struct{}, 1), + pool: &sync.Pool{ + New: func() interface{} { + // big enough buffer to fit both packet and address + return newBufferHolder(receiveMTU + maxAddrSize) + }, + }, + newAddrChan: newAddrChan, + newAddrs: make(map[*net.UDPAddr]struct{}), + } + + go m.connWorker() + + return m +} + +// LocalAddr returns the listening address of this UDPMuxNewAddr +func (m *UDPMuxNewAddr) LocalAddr() net.Addr { + return m.params.UDPConn.LocalAddr() +} + +// GetConn returns a PacketConn given the connection's ufrag and network +// creates the connection if an existing one can't be found +func (m *UDPMuxNewAddr) GetConn(ufrag string, isIPv6 bool) (net.PacketConn, error) { + m.mu.Lock() + defer m.mu.Unlock() + + if m.IsClosed() { + m.params.Logger.Debugf("conn closed: %s", ufrag) + return nil, io.ErrClosedPipe + } + + if conn, ok := m.getConn(ufrag, isIPv6); ok { + return conn, nil + } + + c := m.createMuxedConn(ufrag) + go func() { + <-c.CloseChannel() + m.removeConn(ufrag) + m.params.Logger.Debugf("removing connection: %s", ufrag) + }() + + if isIPv6 { + m.connsIPv6[ufrag] = c + } else { + m.connsIPv4[ufrag] = c + } + + return c, nil +} + +// RemoveConnByUfrag stops and removes the muxed packet connection +func (m *UDPMuxNewAddr) RemoveConnByUfrag(ufrag string) { + removedConns := make([]*udpMuxedConn, 0, 2) + + // Keep lock section small to avoid deadlock with conn lock + m.mu.Lock() + if c, ok := m.connsIPv4[ufrag]; ok { + delete(m.connsIPv4, ufrag) + removedConns = append(removedConns, c) + } + if c, ok := m.connsIPv6[ufrag]; ok { + delete(m.connsIPv6, ufrag) + removedConns = append(removedConns, c) + } + m.mu.Unlock() + + m.addressMapMu.Lock() + defer m.addressMapMu.Unlock() + + for _, c := range removedConns { + addresses := c.getAddresses() + for _, addr := range addresses { + delete(m.addressMap, addr) + } + } +} + +// IsClosed returns true if the mux had been closed +func (m *UDPMuxNewAddr) IsClosed() bool { + select { + case <-m.closedChan: + return true + default: + return false + } +} + +// Close the mux, no further connections could be created +func (m *UDPMuxNewAddr) Close() error { + var err error + m.closeOnce.Do(func() { + m.mu.Lock() + defer m.mu.Unlock() + + for _, c := range m.connsIPv4 { + _ = c.Close() + } + for _, c := range m.connsIPv6 { + _ = c.Close() + } + + m.connsIPv4 = make(map[string]*udpMuxedConn) + m.connsIPv6 = make(map[string]*udpMuxedConn) + + close(m.closedChan) + }) + return err +} + +func (m *UDPMuxNewAddr) removeConn(key string) { + // keep lock section small to avoid deadlock with conn lock + c := func() *udpMuxedConn { + m.mu.Lock() + defer m.mu.Unlock() + + if c, ok := m.connsIPv4[key]; ok { + delete(m.connsIPv4, key) + return c + } + + if c, ok := m.connsIPv6[key]; ok { + delete(m.connsIPv6, key) + return c + } + + return nil + }() + + if c == nil { + return + } + + m.addressMapMu.Lock() + defer m.addressMapMu.Unlock() + + addresses := c.getAddresses() + for _, addr := range addresses { + delete(m.addressMap, addr) + } +} + +func (m *UDPMuxNewAddr) writeTo(buf []byte, raddr net.Addr) (n int, err error) { + return m.params.UDPConn.WriteTo(buf, raddr) +} + +func (m *UDPMuxNewAddr) registerConnForAddress(conn *udpMuxedConn, addr string) { + if m.IsClosed() { + return + } + + m.addressMapMu.Lock() + defer m.addressMapMu.Unlock() + + existing, ok := m.addressMap[addr] + if ok { + existing.removeAddress(addr) + } + m.addressMap[addr] = conn + + m.params.Logger.Debugf("Registered %s for %s", addr, conn.params.Key) +} + +func (m *UDPMuxNewAddr) createMuxedConn(key string) *udpMuxedConn { + c := newUDPMuxedConn(&udpMuxedConnParams{ + Mux: m, + Key: key, + AddrPool: m.pool, + LocalAddr: m.LocalAddr(), + Logger: m.params.Logger, + }) + return c +} + +func (m *UDPMuxNewAddr) connWorker() { + logger := m.params.Logger + + defer func() { + _ = m.Close() + }() + + buf := make([]byte, receiveMTU) + for { + n, addr, err := m.params.UDPConn.ReadFrom(buf) + if m.IsClosed() { + return + } else if err != nil { + if os.IsTimeout(err) { + continue + } else if err != io.EOF { + logger.Errorf("could not read udp packet: %v", err) + } + + return + } + + udpAddr, ok := addr.(*net.UDPAddr) + if !ok { + logger.Errorf("underlying PacketConn did not return a UDPAddr") + return + } + + // If we have already seen this address dispatch to the appropriate destination + m.addressMapMu.Lock() + destinationConn := m.addressMap[addr.String()] + m.addressMapMu.Unlock() + + // If we haven't seen this address before but is a STUN packet lookup by ufrag + if destinationConn == nil && stun.IsMessage(buf[:n]) { + msg := &stun.Message{ + Raw: append([]byte{}, buf[:n]...), + } + + if err = msg.Decode(); err != nil { + m.params.Logger.Warnf("Failed to handle decode ICE from %s: %v\n", addr.String(), err) + continue + } + + ufrag, ufragErr := ufragFromStunMessage(msg, false) + if ufragErr != nil { + m.params.Logger.Warnf("%v", ufragErr) + continue + } + + if err = validateFingerprint(ufrag); err != nil { + m.params.Logger.Debugf("invalid DTLS fingerprint: %s , dropping packet", ufrag) + continue + } + + isIPv6 := udpAddr.IP.To4() == nil + + m.mu.Lock() + destinationConn, ok = m.getConn(ufrag, isIPv6) + m.mu.Unlock() + + // notify that a new connection is requested + if !ok { + m.newAddrChan <- candidateAddr{raddr: udpAddr, fingerprint: ufrag} + m.mu.Lock() + m.newAddrs[udpAddr] = struct{}{} + m.mu.Unlock() + dc, _ := m.GetConn(ufrag, isIPv6) + destinationConn = dc.(*udpMuxedConn) + } + } + + if destinationConn == nil { + m.params.Logger.Debugf("dropping packet from %s, addr: %s", udpAddr.String(), addr.String()) + continue + } + + if err = destinationConn.writePacket(buf[:n], udpAddr); err != nil { + m.params.Logger.Errorf("could not write packet: %v", err) + } + } +} + +func ufragFromStunMessage(msg *stun.Message, local_ufrag bool) (string, error) { + attr, stunAttrErr := msg.Get(stun.AttrUsername) + if stunAttrErr != nil { + return "", stunAttrErr + } + ufrag := strings.Split(string(attr), ":") + if len(ufrag) < 2 { + return "", errors.New("invalid STUN username attribute") + } + if local_ufrag { + return ufrag[1], nil + } else { + return ufrag[0], nil + } +} + +func (m *UDPMuxNewAddr) getConn(ufrag string, isIPv6 bool) (val *udpMuxedConn, ok bool) { + if isIPv6 { + val, ok = m.connsIPv6[ufrag] + } else { + val, ok = m.connsIPv4[ufrag] + } + return +} + +type bufferHolder struct { + buffer []byte +} + +func newBufferHolder(size int) *bufferHolder { + return &bufferHolder{ + buffer: make([]byte, size), + } +} diff --git a/p2p/transport/webrtc/udp_mux_conn.go b/p2p/transport/webrtc/udp_mux_conn.go new file mode 100644 index 0000000000..f0a231c4bb --- /dev/null +++ b/p2p/transport/webrtc/udp_mux_conn.go @@ -0,0 +1,247 @@ +package libp2pwebrtc + +import ( + "encoding/binary" + "io" + "net" + "sync" + "time" + + "github.com/pion/logging" + "github.com/pion/transport/packetio" +) + +type udpMuxedConnParams struct { + Mux *UDPMuxNewAddr + AddrPool *sync.Pool + Key string + LocalAddr net.Addr + Logger logging.LeveledLogger +} + +// udpMuxedConn represents a logical packet conn for a single remote as identified by ufrag +type udpMuxedConn struct { + params *udpMuxedConnParams + // remote addresses that we have sent to on this conn + addresses []string + + // channel holding incoming packets + buffer *packetio.Buffer + closedChan chan struct{} + closeOnce sync.Once + mu sync.Mutex +} + +func newUDPMuxedConn(params *udpMuxedConnParams) *udpMuxedConn { + p := &udpMuxedConn{ + params: params, + buffer: packetio.NewBuffer(), + closedChan: make(chan struct{}), + } + + return p +} + +func (c *udpMuxedConn) ReadFrom(b []byte) (n int, raddr net.Addr, err error) { + buf := c.params.AddrPool.Get().(*bufferHolder) + defer c.params.AddrPool.Put(buf) + + // read address + total, err := c.buffer.Read(buf.buffer) + if err != nil { + return 0, nil, err + } + + dataLen := int(binary.LittleEndian.Uint16(buf.buffer[:2])) + if dataLen > total || dataLen > len(b) { + return 0, nil, io.ErrShortBuffer + } + + // read data and then address + offset := 2 + copy(b, buf.buffer[offset:offset+dataLen]) + offset += dataLen + + // read address len & decode address + addrLen := int(binary.LittleEndian.Uint16(buf.buffer[offset : offset+2])) + offset += 2 + + if raddr, err = decodeUDPAddr(buf.buffer[offset : offset+addrLen]); err != nil { + return 0, nil, err + } + + return dataLen, raddr, nil +} + +func (c *udpMuxedConn) WriteTo(buf []byte, raddr net.Addr) (n int, err error) { + if c.isClosed() { + return 0, io.ErrClosedPipe + } + // each time we write to a new address, we'll register it with the mux + addr := raddr.String() + if !c.containsAddress(addr) { + c.addAddress(addr) + } + + return c.params.Mux.writeTo(buf, raddr) +} + +func (c *udpMuxedConn) LocalAddr() net.Addr { + return c.params.LocalAddr +} + +func (c *udpMuxedConn) SetDeadline(tm time.Time) error { + return nil +} + +func (c *udpMuxedConn) SetReadDeadline(tm time.Time) error { + return nil +} + +func (c *udpMuxedConn) SetWriteDeadline(tm time.Time) error { + return nil +} + +func (c *udpMuxedConn) CloseChannel() <-chan struct{} { + return c.closedChan +} + +func (c *udpMuxedConn) Close() error { + var err error + c.closeOnce.Do(func() { + err = c.buffer.Close() + close(c.closedChan) + }) + c.mu.Lock() + defer c.mu.Unlock() + c.addresses = nil + return err +} + +func (c *udpMuxedConn) isClosed() bool { + select { + case <-c.closedChan: + return true + default: + return false + } +} + +func (c *udpMuxedConn) getAddresses() []string { + c.mu.Lock() + defer c.mu.Unlock() + addresses := make([]string, len(c.addresses)) + copy(addresses, c.addresses) + return addresses +} + +func (c *udpMuxedConn) addAddress(addr string) { + c.mu.Lock() + c.addresses = append(c.addresses, addr) + c.mu.Unlock() + + // map it on mux + c.params.Mux.registerConnForAddress(c, addr) +} + +func (c *udpMuxedConn) removeAddress(addr string) { + c.mu.Lock() + defer c.mu.Unlock() + + newAddresses := make([]string, 0, len(c.addresses)) + for _, a := range c.addresses { + if a != addr { + newAddresses = append(newAddresses, a) + } + } + + c.addresses = newAddresses +} + +func (c *udpMuxedConn) containsAddress(addr string) bool { + c.mu.Lock() + defer c.mu.Unlock() + for _, a := range c.addresses { + if addr == a { + return true + } + } + return false +} + +func (c *udpMuxedConn) writePacket(data []byte, addr *net.UDPAddr) error { + // write two packets, address and data + buf := c.params.AddrPool.Get().(*bufferHolder) + defer c.params.AddrPool.Put(buf) + + // format of buffer | data len | data bytes | addr len | addr bytes | + if len(buf.buffer) < len(data)+maxAddrSize { + return io.ErrShortBuffer + } + // data len + binary.LittleEndian.PutUint16(buf.buffer, uint16(len(data))) + offset := 2 + + // data + copy(buf.buffer[offset:], data) + offset += len(data) + + // write address first, leaving room for its length + n, err := encodeUDPAddr(addr, buf.buffer[offset+2:]) + if err != nil { + return nil + } + total := offset + n + 2 + + // address len + binary.LittleEndian.PutUint16(buf.buffer[offset:], uint16(n)) + + if _, err := c.buffer.Write(buf.buffer[:total]); err != nil { + return err + } + return nil +} + +func encodeUDPAddr(addr *net.UDPAddr, buf []byte) (int, error) { + ipdata, err := addr.IP.MarshalText() + if err != nil { + return 0, err + } + total := 2 + len(ipdata) + 2 + len(addr.Zone) + if total > len(buf) { + return 0, io.ErrShortBuffer + } + + binary.LittleEndian.PutUint16(buf, uint16(len(ipdata))) + offset := 2 + n := copy(buf[offset:], ipdata) + offset += n + binary.LittleEndian.PutUint16(buf[offset:], uint16(addr.Port)) + offset += 2 + copy(buf[offset:], addr.Zone) + return total, nil +} + +func decodeUDPAddr(buf []byte) (*net.UDPAddr, error) { + addr := net.UDPAddr{} + + offset := 0 + ipLen := int(binary.LittleEndian.Uint16(buf[:2])) + offset += 2 + // basic bounds checking + if ipLen+offset > len(buf) { + return nil, io.ErrShortBuffer + } + if err := addr.IP.UnmarshalText(buf[offset : offset+ipLen]); err != nil { + return nil, err + } + offset += ipLen + addr.Port = int(binary.LittleEndian.Uint16(buf[offset : offset+2])) + offset += 2 + zone := make([]byte, len(buf[offset:])) + copy(zone, buf[offset:]) + addr.Zone = string(zone) + + return &addr, nil +} + diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go new file mode 100644 index 0000000000..cdac78944c --- /dev/null +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -0,0 +1,63 @@ +package libp2pwebrtc + +import ( + "fmt" + "net" + "os" + "testing" + "time" + "strings" + + // ma "github.com/multiformats/go-multiaddr" + "github.com/pion/ice/v2" + "github.com/pion/logging" + "github.com/pion/stun" +) + +func TestUdpMuxNewAddrNewStun(t *testing.T) { + serverConn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(0, 0, 0, 0), Port: 0}) + if err != nil { + panic(err) + } + + clientConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}) + loggerFactory := logging.NewDefaultLoggerFactory() + loggerFactory.Writer = os.Stdout + loggerFactory.DefaultLogLevel = logging.LogLevelDebug + + logger := loggerFactory.NewLogger("mux-test") + + newAddrChan := make(chan candidateAddr, 1) + _ = NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: serverConn, Logger: logger}, newAddrChan) + + certhash := "496612170D1C91AE574CC636DDD597D27D62C99A7FB9A3F47003E7439173235E" + go func() { + <-time.After(1 * time.Second) + msg := stun.MustBuild( + stun.TransactionID, + stun.BindingRequest, + ice.AttrControl{Role: ice.Controlling}, + stun.NewUsername(fmt.Sprintf("%s:%s", certhash, certhash)), + ) + msg.Encode() + _, err := clientConn.WriteTo(msg.Raw, serverConn.LocalAddr()) + if err != nil { + panic(err) + } + }() + + select { + case addr := <-newAddrChan: + t.Logf("%v", addr) + hash := addr.fingerprint + if err != nil { + t.Fatal(err) + } + t.Logf("received hash: %v", hash) + if strings.ToLower(hash) != strings.ToLower(certhash) { + t.Fatalf("expected hash: %s, received: %s", certhash, hash) + } + case <-time.After(20 * time.Second): + t.Fatal("test timed out") + } +} diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go new file mode 100644 index 0000000000..f558534c92 --- /dev/null +++ b/p2p/transport/webrtc/util.go @@ -0,0 +1,60 @@ +package libp2pwebrtc + +import ( + ma "github.com/multiformats/go-multiaddr" + manet "github.com/multiformats/go-multiaddr/net" + "fmt" + "encoding/hex" + "net" + "strconv" + "strings" +) + +func maFingerprintToSdp(fp string) string { + result := "" + first := true + for pos, char := range fp { + if pos%2 == 0 { + if first { + first = false + } else { + result += ":" + } + } + result += string(char) + } + return strings.ToUpper(result) +} + +func maToAddrFingerprint(addr ma.Multiaddr) (*net.UDPAddr, string, error) { + ip, err := manet.ToIP(addr) + if err != nil { + return nil, "", err + } + portS, err := addr.ValueForProtocol(ma.P_UDP) + if err != nil { + return nil, "", err + } + port, err := strconv.Atoi(portS) + if err != nil { + return nil, "", err + } + + result := &net.UDPAddr{ IP: ip, Port: port } + + remoteFp, err := addr.ValueForProtocol(P_XWEBRTC) + if err != nil { + return nil, "", err + } + remoteFp = maFingerprintToSdp(remoteFp) + + return result, remoteFp, nil +} + +func validateFingerprint(fp string) error { + b, err := hex.DecodeString(fp) + if err != nil || len(b) != 32 { + return fmt.Errorf("invalid fingerprint") + } + return nil +} diff --git a/p2p/transport/webrtc/util_test.go b/p2p/transport/webrtc/util_test.go new file mode 100644 index 0000000000..f212ab1aa6 --- /dev/null +++ b/p2p/transport/webrtc/util_test.go @@ -0,0 +1,36 @@ +package libp2pwebrtc + +import ( + "testing" + ma "github.com/multiformats/go-multiaddr" +) + +func TestMaFingerprintToSdp(t *testing.T) { + certhash := "496612170D1C91AE574CC636DDD597D27D62C99A7FB9A3F47003E7439173235E" + expected := "49:66:12:17:0D:1C:91:AE:57:4C:C6:36:DD:D5:97:D2:7D:62:C9:9A:7F:B9:A3:F4:70:03:E7:43:91:73:23:5E" + result := maFingerprintToSdp(certhash) + t.Logf("result: %s", result) + if result != expected { + t.Fatalf("expected %s, found: %s", expected, result) + } +} + +func TestMaToAddrFingerprint(t *testing.T) { + maddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/44218/x-webrtc/496612170d1c91ae574cc636ddd597d27d62c99a7fb9a3f47003e7439173235e") + if err != nil { + t.Fatal(err) + } + addr, fp, err := maToAddrFingerprint(maddr) + if err != nil { + t.Fatal(err) + } + if addr.IP.String() != "127.0.0.1" { + t.Fatalf("expected localhost ipv4 address") + } + + expected := "49:66:12:17:0D:1C:91:AE:57:4C:C6:36:DD:D5:97:D2:7D:62:C9:9A:7F:B9:A3:F4:70:03:E7:43:91:73:23:5E" + if fp != expected { + t.Fatalf("expected %s, found: %s", expected, fp) + } + +} From 8412622e774b6e9dd84bff18f27c508992a3e0f4 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 12 Jul 2022 18:58:06 +0530 Subject: [PATCH 02/50] Implement webrtc transport --- p2p/transport/webrtc/connection.go | 186 +++++++++++---- p2p/transport/webrtc/datachannel.go | 146 +++++++++--- p2p/transport/webrtc/listener.go | 273 ++++++++++++++++++---- p2p/transport/webrtc/listener_test.go | 259 -------------------- p2p/transport/webrtc/protocol.go | 23 +- p2p/transport/webrtc/sdp.go | 21 +- p2p/transport/webrtc/transport.go | 312 ++++++++++++++++++++++++- p2p/transport/webrtc/transport_test.go | 154 ++++++++++++ p2p/transport/webrtc/udp_mux.go | 7 - p2p/transport/webrtc/udp_mux_conn.go | 1 - p2p/transport/webrtc/udp_mux_test.go | 7 +- p2p/transport/webrtc/util.go | 73 +++--- p2p/transport/webrtc/util_test.go | 26 +-- 13 files changed, 1006 insertions(+), 482 deletions(-) delete mode 100644 p2p/transport/webrtc/listener_test.go create mode 100644 p2p/transport/webrtc/transport_test.go diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index fd1891f416..28323e951c 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -2,56 +2,165 @@ package libp2pwebrtc import ( "context" + "os" - "github.com/libp2p/go-libp2p-core/crypto" + "github.com/google/uuid" + ic "github.com/libp2p/go-libp2p-core/crypto" "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-core/peer" + tpt "github.com/libp2p/go-libp2p-core/transport" ma "github.com/multiformats/go-multiaddr" "github.com/pion/webrtc/v3" ) type connection struct { - conn *webrtc.PeerConnection - // ConnSecurity - idKey crypto.PrivKey - remotePeerID peer.ID + pc *webrtc.PeerConnection + transport *WebRTCTransport + scope network.ConnManagementScope - // ConnMultiaddrs - localMultiaddr, remoteMultiaddr ma.Multiaddr + localPeer peer.ID + privKey ic.PrivKey + localMultiaddr ma.Multiaddr - closeChan chan struct{} + remotePeer peer.ID + remoteKey ic.PubKey + remoteMultiaddr ma.Multiaddr + + closed chan struct{} + accept chan network.MuxedStream } -func newConnection(conn *webrtc.PeerConnection) (*connection, error) { - return nil, nil +func newConnection( + pc *webrtc.PeerConnection, + transport *WebRTCTransport, + scope network.ConnManagementScope, + + localPeer peer.ID, + privKey ic.PrivKey, + localMultiaddr ma.Multiaddr, + + remotePeer peer.ID, + remoteKey ic.PubKey, + remoteMultiaddr ma.Multiaddr, +) (*connection, error) { + accept := make(chan network.MuxedStream, 1) + + pc.OnDataChannel(func(dc *webrtc.DataChannel) { + dc.OnOpen(func() { + dcrwc, err := dc.Detach() + if err != nil { + // cannot accept a non-detached datachannel + return + } + accept <- newDataChannel(dcrwc, pc, nil, nil) + }) + }) + + return &connection{ + pc: pc, + transport: transport, + scope: scope, + + localPeer: localPeer, + privKey: privKey, + localMultiaddr: localMultiaddr, + + remotePeer: remotePeer, + remoteKey: remoteKey, + remoteMultiaddr: remoteMultiaddr, + + closed: make(chan struct{}, 1), + accept: accept, + }, nil } -// Implement network.ConnSecurity -func (c *connection) LocalPeer() peer.ID { - id, err := peer.IDFromPrivateKey(c.idKey) +// Implement network.MuxedConn + +func (c *connection) Close() error { + _ = c.pc.Close() + c.scope.Done() + select { + case <-c.closed: + default: + close(c.closed) + } + return nil +} + +func (c *connection) IsClosed() bool { + select { + case <-c.closed: + return true + default: + } + return false +} + +func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error) { + label := uuid.New().String() + dc, err := c.pc.CreateDataChannel(label, nil) if err != nil { - return "" + return nil, err + } + result := make(chan struct { + network.MuxedStream + error + }, 1) + dc.OnOpen(func() { + rwc, err := dc.Detach() + if err != nil { + result <- struct { + network.MuxedStream + error + }{nil, err} + return + } + + result <- struct { + network.MuxedStream + error + }{newDataChannel(rwc, c.pc, nil, nil), err} + }) + + select { + case <-ctx.Done(): + _ = dc.Close() + return nil, ctx.Err() + case r := <-result: + return r.MuxedStream, r.error + } + // should be unreachable + return nil, nil +} + +func (c *connection) AcceptStream() (network.MuxedStream, error) { + var stream network.MuxedStream + select { + case <-c.closed: + return nil, os.ErrClosed + case stream = <-c.accept: } - return id + return stream, nil } -func (c *connection) LocalPrivateKey() crypto.PrivKey { - return c.idKey +// implement network.ConnSecurity +func (c *connection) LocalPeer() peer.ID { + return c.localPeer +} + +func (c *connection) LocalPrivateKey() ic.PrivKey { + return c.privKey } func (c *connection) RemotePeer() peer.ID { - return c.remotePeerID + return c.remotePeer } -func (c *connection) RemotePublicKey() crypto.PubKey { - key, err := c.remotePeerID.ExtractPublicKey() - if err != nil { - return nil - } - return key +func (c *connection) RemotePublicKey() ic.PubKey { + return c.remoteKey } -// Implement network.ConnMultiaddrs +// implement network.ConnMultiaddrs func (c *connection) LocalMultiaddr() ma.Multiaddr { return c.localMultiaddr } @@ -60,28 +169,11 @@ func (c *connection) RemoteMultiaddr() ma.Multiaddr { return c.remoteMultiaddr } -// Implement network.MuxedConn - -func (c *connection) Close() error { - select { - case <-c.closeChan: - return nil - default: - close(c.closeChan) - } - return c.conn.Close() -} - -func (c *connection) IsClosed() bool { - select { - case <-c.closeChan: - return true - default: - } - return false +// implement network.ConnScoper +func (c *connection) Scope() network.ConnScope { + return c.scope } -func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error) { - return nil, nil +func (c *connection) Transport() tpt.Transport { + return c.transport } - diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index b3dafcd125..988e07c972 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -3,82 +3,168 @@ package libp2pwebrtc import ( "io" "net" + "os" + "sync" "time" "github.com/pion/datachannel" + "github.com/pion/webrtc/v3" ) // Package pion detached data channel into a net.Conn // and then a network.MuxedStream type DataChannel struct { - dc datachannel.ReadWriteCloser - readClosed, writeClosed chan struct{} + // TODO: Are these circular references okay? + pc *webrtc.PeerConnection + dc datachannel.ReadWriteCloser + laddr net.Addr + raddr net.Addr + closeRead chan struct{} + closeWrite chan struct{} + readDeadline time.Time + writeDeadline time.Time + m sync.Mutex } -func newDataChannel(dc datachannel.ReadWriteCloser) *DataChannel { - return &DataChannel { - dc: dc, - readClosed: make(chan struct{}), - writeClosed: make(chan struct{}), +func newDataChannel( + dc datachannel.ReadWriteCloser, + pc *webrtc.PeerConnection, + laddr, raddr net.Addr) *DataChannel { + return &DataChannel{ + dc: dc, + laddr: laddr, + raddr: raddr, + closeRead: make(chan struct{}, 1), + closeWrite: make(chan struct{}, 1), } } func (d *DataChannel) Read(b []byte) (int, error) { select { - case <-d.readClosed: + case <-d.closeRead: return 0, io.EOF default: } - return d.dc.Read(b) + d.m.Lock() + readDeadline := d.readDeadline + d.m.Unlock() + + if readDeadline.IsZero() { + return d.dc.Read(b) + } else if readDeadline.Before(time.Now()) { + return 0, os.ErrDeadlineExceeded + } + + done := make(chan struct { + int + error + }, 1) + go func() { + n, err := d.dc.Read(b) + log.Debug(string(b[:n])) + done <- struct { + int + error + }{n, err} + }() + + select { + case <-time.After(readDeadline.Sub(time.Now())): + return 0, os.ErrDeadlineExceeded + case result := <-done: + return result.int, result.error + } } func (d *DataChannel) Write(b []byte) (int, error) { select { - case <-d.writeClosed: + case <-d.closeWrite: return 0, io.ErrClosedPipe default: } - return d.dc.Write(b) + d.m.Lock() + writeDeadline := d.writeDeadline + d.m.Unlock() + + if writeDeadline.IsZero() { + return d.dc.Write(b) + } else if writeDeadline.Before(time.Now()) { + return 0, os.ErrDeadlineExceeded + } + + done := make(chan struct { + int + error + }, 1) + go func() { + n, err := d.dc.Write(b) + done <- struct { + int + error + }{n, err} + }() + + select { + case <-time.After(writeDeadline.Sub(time.Now())): + return 0, os.ErrDeadlineExceeded + case result := <-done: + return result.int, result.error + + } } func (d *DataChannel) Close() error { return d.dc.Close() } -func (d *DataChannel) LocalAddr() net.Addr { +func (d *DataChannel) CloseRead() error { + select { + case <-d.closeRead: + default: + close(d.closeRead) + } return nil } -func (d *DataChannel) RemoteAddr() net.Addr { +func (d *DataChannel) CloseWrite() error { + select { + case <-d.closeWrite: + default: + close(d.closeWrite) + } return nil } -func (d *DataChannel) SetDeadline(t time.Time) error { - return nil +func (d *DataChannel) LocalAddr() net.Addr { + return d.laddr } -func (d *DataChannel) SetReadDeadline(t time.Time) error { - return nil +func (d *DataChannel) RemoteAddr() net.Addr { + return d.raddr } -func (d *DataChannel) SetWriteDeadline(t time.Time) error { +func (d *DataChannel) Reset() error { + return d.Close() +} + +func (d *DataChannel) SetDeadline(t time.Time) error { + d.m.Lock() + defer d.m.Unlock() + d.readDeadline = t + d.writeDeadline = t return nil } -func (d *DataChannel) CloseRead() error { - select { - case <-d.readClosed: - default: - close(d.readClosed) - } +func (d *DataChannel) SetReadDeadline(t time.Time) error { + d.m.Lock() + defer d.m.Unlock() + d.readDeadline = t return nil } -func (d *DataChannel) CloseWrite() error { - select { - case <-d.writeClosed: - default: - close(d.writeClosed) - } +func (d *DataChannel) SetWriteDeadline(t time.Time) error { + d.m.Lock() + defer d.m.Unlock() + d.writeDeadline = t return nil } diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 3a5775002b..03d6cda357 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -2,53 +2,153 @@ package libp2pwebrtc import ( "context" + "crypto/x509" + "encoding/hex" "errors" "fmt" + "net" + "os" "strings" "time" "github.com/libp2p/go-libp2p-core/crypto" - "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p-core/network" + + tpt "github.com/libp2p/go-libp2p-core/transport" "github.com/libp2p/go-libp2p/p2p/security/noise" ma "github.com/multiformats/go-multiaddr" + manet "github.com/multiformats/go-multiaddr/net" + "github.com/multiformats/go-multibase" + "github.com/multiformats/go-multihash" + + "github.com/pion/dtls/v2/pkg/crypto/fingerprint" + "github.com/pion/ice/v2" "github.com/pion/webrtc/v3" ) -type listener struct { - api *webrtc.API - config webrtc.Configuration - mux *UDPMuxNewAddr - newAddrChan chan candidateAddr - local ma.Multiaddr - idKey crypto.PrivKey -} - var ( ErrDataChannelTimeout = errors.New("timed out waiting for datachannel") ErrNoiseHandshakeTimeout = errors.New("noise handshake timeout") ErrNoCertInConfig = errors.New("no certificate configured in listener config") ) -func (l *listener) accept(addr candidateAddr) (peer.ID, *webrtc.PeerConnection, error) { +var ( + defaultMultihash *multihash.DecodedMultihash = nil +) + +func init() { + // populate default multihash + encoded, err := hex.DecodeString("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad") + if err != nil { + panic(err) + } - // Get local fingerprint - if len(l.config.Certificates) < 1 { - return "", nil, ErrNoCertInConfig + defaultMultihash = &multihash.DecodedMultihash{ + Code: multihash.SHA2_256, + Name: multihash.Codes[multihash.SHA2_256], + Digest: encoded, + Length: len(encoded), } - localFps, err := l.config.Certificates[0].GetFingerprints() - if err != nil || len(localFps) < 1 { - return "", nil, err +} + +/// implement net.Listener +type listener struct { + transport *WebRTCTransport + config webrtc.Configuration + privKey crypto.PrivKey + localFingerprint webrtc.DTLSFingerprint + localFingerprintMultibase string + mux *UDPMuxNewAddr + closeChan chan struct{} + localMultiaddr ma.Multiaddr + connChan chan tpt.CapableConn +} + +func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.PacketConn, privKey crypto.PrivKey, config webrtc.Configuration) (*listener, error) { + mux := NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: socket}, make(chan candidateAddr, 1)) + localFingerprints, err := config.Certificates[0].GetFingerprints() + if err != nil { + return nil, err } - localFp := strings.ReplaceAll(localFps[0].Value, ":", "") + localMh, err := hex.DecodeString(strings.ReplaceAll(localFingerprints[0].Value, ":", "")) + if err != nil { + return nil, err + } + localMhBuf, _ := multihash.EncodeName(localMh, sdpHashToMh[localFingerprints[0].Algorithm]) + localFpMultibase, _ := multibase.Encode(multibase.Base64, localMhBuf) + + l := &listener{ + mux: mux, + transport: transport, + privKey: privKey, + config: config, + localFingerprint: localFingerprints[0], + localFingerprintMultibase: localFpMultibase, + closeChan: make(chan struct{}, 1), + localMultiaddr: laddr, + connChan: make(chan tpt.CapableConn, 20), + } + go l.startAcceptLoop() + return l, err +} + +func (l *listener) startAcceptLoop() { + for { + select { + case <-l.closeChan: + return + case addr := <-l.mux.newAddrChan: + go func() { + conn, err := l.accept(addr) + if err != nil { + log.Debugf("could not accept connection: %v", err) + } + l.connChan <- conn + }() + } + } +} + +func (l *listener) Accept() (tpt.CapableConn, error) { + select { + case <-l.closeChan: + return nil, os.ErrClosed + case conn := <-l.connChan: + return conn, nil + } +} + +func (l *listener) Close() error { + select { + case <-l.closeChan: + return nil + default: + } + close(l.closeChan) + return nil +} + +func (l *listener) Addr() net.Addr { + return l.mux.LocalAddr() +} + +func (l *listener) Multiaddr() ma.Multiaddr { + return l.localMultiaddr +} + +func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { // get remote fingerprint - remoteFp := maFingerprintToSdp(addr.fingerprint) + // remoteFp := maFingerprintToSdp(addr.fingerprint) + // local fingerprint + localFingerprint := strings.ReplaceAll(l.localFingerprint.Value, ":", "") se := webrtc.SettingEngine{} se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) se.DetachDataChannels() - se.SetICECredentials(addr.fingerprint, localFp) + se.DisableCertificateFingerprintVerification(true) + se.SetICECredentials(addr.fingerprint, localFingerprint) se.SetLite(true) se.SetICEUDPMux(l.mux) @@ -56,20 +156,21 @@ func (l *listener) accept(addr candidateAddr) (peer.ID, *webrtc.PeerConnection, clientSdpString := renderClientSdp(sdpArgs{ Addr: addr.raddr, - Fingerprint: remoteFp, + Fingerprint: defaultMultihash, Ufrag: addr.fingerprint, Password: addr.fingerprint, }) clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} pc, err := api.NewPeerConnection(l.config) if err != nil { - return "", nil, err + return nil, err } pc.SetRemoteDescription(clientSdp) answer, err := pc.CreateAnswer(nil) if err != nil { - return "", nil, err + _ = pc.Close() + return nil, err } pc.SetLocalDescription(answer) @@ -89,7 +190,12 @@ func (l *listener) accept(addr candidateAddr) (peer.ID, *webrtc.PeerConnection, if err != nil { return } - dcChan <- newDataChannel(detached) + dcChan <- newDataChannel( + detached, + pc, + l.mux.LocalAddr(), + addr.raddr, + ) }) }) @@ -98,55 +204,132 @@ func (l *listener) accept(addr candidateAddr) (peer.ID, *webrtc.PeerConnection, var dc *DataChannel = nil select { case <-time.After(timeout): - return "", nil, ErrDataChannelTimeout + _ = pc.Close() + return nil, ErrDataChannelTimeout case dc = <-dcChan: if dc == nil { - return "", nil, fmt.Errorf("should be unreachable") + _ = pc.Close() + return nil, fmt.Errorf("should be unreachable") } // clear to allow opening of future data channels - pc.OnDataChannel(func (*webrtc.DataChannel) {}) + pc.OnDataChannel(func(*webrtc.DataChannel) {}) } // perform noise handshake - noiseTpt, err := noise.New(l.idKey) + noiseTpt, err := noise.New(l.privKey) if err != nil { - return "", nil, err + _ = pc.Close() + return nil, err } // we do not yet know A's peer ID so accept any inbound secureConn, err := noiseTpt.SecureInbound(context.Background(), dc, "") if err != nil { - return "", nil, err + _ = pc.Close() + return nil, err } - _, err = secureConn.Write([]byte(maFingerprintToSdp(localFp))) + _, err = secureConn.Write([]byte(l.localFingerprintMultibase)) if err != nil { - return "", nil, err - } - - buf := make([]byte, 200) - n, err := secureConn.Read(buf) - if err != nil { - return "", nil, err + return nil, err } // Ordinarily, we would do this with a ReadDeadline, but since the underlying datachannel.ReadWriteCloser // does not allow us to set ReadDeadline, we have to manually spawn a goroutine done := make(chan error, 1) go func() { - if string(buf[:n]) != remoteFp { - done <- fmt.Errorf("could not verify remote fingerprint: expected: %s, got: %s", remoteFp, string(buf[:n])) + buf := make([]byte, 200) + n, err := secureConn.Read(buf) + if err != nil { + done <- err + } + remoteFpMultibase := string(buf[:n]) + if !verifyRemoteFingerprint(pc.SCTP().Transport().GetRemoteCertificate(), remoteFpMultibase) { + done <- fmt.Errorf("could not verify remote fingerprint") } close(done) }() select { case err = <-done: - if done != nil { - return "", nil, err + if err != nil { + _ = pc.Close() + return nil, err } case <-time.After(10 * time.Second): - return "", nil, ErrNoiseHandshakeTimeout + _ = pc.Close() + return nil, ErrNoiseHandshakeTimeout + } + + remoteMultiaddr, err := manet.FromNetAddr(addr.raddr) + if err != nil { + _ = pc.Close() + return nil, err + } + scope, err := l.transport.rcmgr.OpenConnection(network.DirInbound, false) + if err != nil { + _ = pc.Close() + return nil, err + } + err = scope.SetPeer(secureConn.RemotePeer()) + if err != nil { + _ = pc.Close() + scope.Done() + return nil, err + } + + conn, err := newConnection( + pc, + l.transport, + scope, + secureConn.LocalPeer(), + secureConn.LocalPrivateKey(), + l.localMultiaddr, + secureConn.RemotePeer(), + secureConn.RemotePublicKey(), + remoteMultiaddr, + ) + + if err != nil { + _ = pc.Close() + return nil, err + } + + defer func() { _ = dc.Close() }() + + return conn, nil +} + +func verifyRemoteFingerprint(raw []byte, remoteMultibaseMultihash string) bool { + cert, err := x509.ParseCertificate(raw) + if err != nil { + log.Debugf("could not parse certificate: %v", err) + return false + } + + _, remoteData, err := multibase.Decode(remoteMultibaseMultihash) + if err != nil { + log.Debugf("could not decode multibase: %v", err) + return false + } + decoded, err := multihash.Decode(remoteData) + if err != nil { + log.Debugf("could not decode multihash: %v", err) + return false + } + remoteFingerprint := hex.EncodeToString(decoded.Digest) + remoteFingerprint = maFingerprintToSdp(remoteFingerprint) + + // create fingerprint for remote certificate + hashAlgoName, ok := mhToSdpHash[decoded.Name] + if !ok { + hashAlgoName = decoded.Name + } + + hashAlgo, err := fingerprint.HashFromString(hashAlgoName) + if err != nil { + log.Debugf("could not find hash algo: %s %v", hashAlgoName, err) + return false } + fp, err := fingerprint.Fingerprint(cert, hashAlgo) - // return the peerID and PeerConnection object - return secureConn.RemotePeer(), pc, nil + return strings.EqualFold(fp, remoteFingerprint) } diff --git a/p2p/transport/webrtc/listener_test.go b/p2p/transport/webrtc/listener_test.go deleted file mode 100644 index b0a4d0a325..0000000000 --- a/p2p/transport/webrtc/listener_test.go +++ /dev/null @@ -1,259 +0,0 @@ -package libp2pwebrtc - -import ( - // "fmt" - // "log" - "context" - "fmt" - "net" - "os" - "strings" - "testing" - - "github.com/libp2p/go-libp2p-core/crypto" - "github.com/libp2p/go-libp2p-core/peer" - "github.com/libp2p/go-libp2p-core/sec" - "github.com/libp2p/go-libp2p/p2p/security/noise" - "github.com/pion/ice/v2" - "github.com/pion/logging" - "github.com/pion/webrtc/v3" - - "crypto/ecdsa" - "crypto/elliptic" - "crypto/rand" -) - -func setupMux() (*UDPMuxNewAddr, chan candidateAddr) { - serverConn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}) - if err != nil { - panic(err) - } - - loggerFactory := logging.NewDefaultLoggerFactory() - loggerFactory.Writer = os.Stdout - loggerFactory.DefaultLogLevel = logging.LogLevelDebug - - logger := loggerFactory.NewLogger("mux-test") - - newAddrChan := make(chan candidateAddr, 1) - mux := NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: serverConn, Logger: logger}, newAddrChan) - return mux, newAddrChan -} - -func setupCert() *webrtc.Certificate { - pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) - if err != nil { - panic(err) - } - cert, err := webrtc.GenerateCertificate(pk) - if err != nil { - panic(err) - } - return cert -} - -func fingerprintFromCert(certs []webrtc.Certificate) string { - c, err := certs[0].GetFingerprints() - if err != nil { - panic(err) - } - return c[0].Value -} - -func setupListener(mux *UDPMuxNewAddr, newAddrChan chan candidateAddr) (*listener, string, peer.ID) { - privKey, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1) - if err != nil { - panic(err) - } - - cert := setupCert() - config := webrtc.Configuration{ - Certificates: []webrtc.Certificate{*cert}, - } - - peerID, err := peer.IDFromPrivateKey(privKey) - if err != nil { - panic(err) - } - - fp := strings.ReplaceAll(fingerprintFromCert(config.Certificates), ":", "") - - settingEngine := webrtc.SettingEngine{} - settingEngine.DetachDataChannels() - settingEngine.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) - settingEngine.SetICEUDPMux(mux) - settingEngine.SetLite(true) - - api := webrtc.NewAPI(webrtc.WithSettingEngine(settingEngine)) - - return &listener{ - api: api, - config: config, - mux: mux, - newAddrChan: newAddrChan, - idKey: privKey, - }, fp, peerID - -} - -func testDial( - t *testing.T, - mux *UDPMuxNewAddr, - serverFp string, - serverID peer.ID, - handshakeFn func(*testing.T, sec.SecureConn, string) error, -) { - // NOTE: Pion does not allow changing SDP once generated using - // create offer, but chromium does allow this - cert := setupCert() - pcConfig := webrtc.Configuration{Certificates: []webrtc.Certificate{*cert}} - localFp := fingerprintFromCert(pcConfig.Certificates) - localFp = strings.ReplaceAll(localFp, ":", "") - // setting engine - se := webrtc.SettingEngine{} - se.SetICECredentials(localFp, localFp) - se.DetachDataChannels() - api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) - pc, err := api.NewPeerConnection(pcConfig) - pc.OnICEConnectionStateChange(func(state webrtc.ICEConnectionState) { - t.Logf("ice conn state: %v", state) - }) - if err != nil { - panic(err) - } - - dc, err := pc.CreateDataChannel("data", nil) - if err != nil { - panic(err) - } - - opened := make(chan *DataChannel, 1) - dc.OnOpen(func() { - t.Log("datachannel") - detached, err := dc.Detach() - if err != nil { - panic(err) - } - opened <- newDataChannel(detached) - }) - offer, err := pc.CreateOffer(nil) - if err != nil { - panic(err) - } - - // t.Logf("%v", offer) - err = pc.SetLocalDescription(offer) - if err != nil { - panic(err) - } - serverAddr, ok := mux.params.UDPConn.LocalAddr().(*net.UDPAddr) - if !ok { - panic("could not get server address") - } - answerSdpString := renderServerSdp(sdpArgs{ - Addr: serverAddr, - Fingerprint: maFingerprintToSdp(serverFp), - Ufrag: localFp, - Password: serverFp, - }) - - answer := webrtc.SessionDescription{SDP: answerSdpString, Type: webrtc.SDPTypeAnswer} - err = pc.SetRemoteDescription(answer) - if err != nil { - panic(err) - } - dataChannel := <-opened - if dataChannel == nil { - panic("data channel must not be nil") - } - t.Logf("opened data channel") - privKey, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1) - if err != nil { - panic(err) - } - noiseTpt, err := noise.New(privKey) - if err != nil { - panic(err) - } - secureConn, err := noiseTpt.SecureOutbound(context.Background(), dataChannel, serverID) - if err != nil { - panic(err) - } - - err = handshakeFn(t, secureConn, localFp) - if err != nil { - panic(err) - } -} - -func TestAcceptInner(t *testing.T) { - // setup mux - mux, addrChan := setupMux() - - // setup listener - // listener, lFp := setupListener(mux, addrChan) - listener, serverFp, serverID := setupListener(mux, addrChan) - - done := make(chan struct{}, 1) - - go func() { - addr := <-addrChan - _, _, err := listener.accept(addr) - if err != nil { - panic(err) - } - done <- struct{}{} - }() - - handshake := func(te *testing.T, conn sec.SecureConn, clientFp string) error { - _, err := conn.Write([]byte(maFingerprintToSdp(clientFp))) - if err != nil { - return err - } - b := make([]byte, 300) - n, err := conn.Read(b) - remoteFp := string(b[:n]) - if remoteFp != maFingerprintToSdp(serverFp) { - return fmt.Errorf("bad fingerprint") - } - return nil - } - testDial(t, mux, serverFp, serverID, handshake) - <-done -} - -func TestAcceptInnerBadFingerprint(t *testing.T) { - // setup mux - mux, addrChan := setupMux() - - // setup listener - listener, serverFp, serverID := setupListener(mux, addrChan) - - done := make(chan struct{}, 1) - - go func() { - addr := <-addrChan - _, _, err := listener.accept(addr) - t.Log(err) - if err == nil { - panic("should error with bad fingerprint") - } - done <- struct{}{} - }() - - handshake := func(te *testing.T, conn sec.SecureConn, clientFp string) error { - _, err := conn.Write([]byte("bad-fp")) - if err != nil { - return err - } - b := make([]byte, 300) - n, err := conn.Read(b) - remoteFp := string(b[:n]) - if remoteFp != maFingerprintToSdp(serverFp) { - return fmt.Errorf("bad fingerprint") - } - return nil - } - testDial(t, mux, serverFp, serverID, handshake) - <-done -} diff --git a/p2p/transport/webrtc/protocol.go b/p2p/transport/webrtc/protocol.go index 02190a9a9a..0e4a328a6c 100644 --- a/p2p/transport/webrtc/protocol.go +++ b/p2p/transport/webrtc/protocol.go @@ -2,36 +2,15 @@ package libp2pwebrtc import ( - "encoding/hex" - "fmt" ma "github.com/multiformats/go-multiaddr" ) const P_XWEBRTC = 0x115 -func xwebrtcVal(b []byte) error { - if len(b) != 32 { - return fmt.Errorf("fingerprint should be 32 bytes, found: %d", len(b)) - } - return nil -} - -func xwebrtcStB(s string) ([]byte, error) { - return hex.DecodeString(s) -} - -func xwebrtcBtS(b []byte) (string, error) { - return hex.EncodeToString(b), nil -} - -var TranscoderXWebRTC = ma.NewTranscoderFromFunctions(xwebrtcStB, xwebrtcBtS, xwebrtcVal) - var protocol = ma.Protocol{ - Name: "x-webrtc", + Name: "webrtc", Code: P_XWEBRTC, VCode: ma.CodeToVarint(P_XWEBRTC), - Size: 8 * 32, - Transcoder: TranscoderXWebRTC, } func init() { diff --git a/p2p/transport/webrtc/sdp.go b/p2p/transport/webrtc/sdp.go index 11b5b5fe63..c663cbbde7 100644 --- a/p2p/transport/webrtc/sdp.go +++ b/p2p/transport/webrtc/sdp.go @@ -3,13 +3,15 @@ package libp2pwebrtc import ( "fmt" "net" + + "github.com/multiformats/go-multihash" ) type sdpArgs struct { - Addr *net.UDPAddr - Ufrag string - Password string - Fingerprint string + Addr *net.UDPAddr + Ufrag string + Password string + Fingerprint *multihash.DecodedMultihash } const CLIENT_SDP string = ` @@ -23,7 +25,7 @@ a=mid:0 a=ice-options:ice2 a=ice-ufrag:%s a=ice-pwd:%s -a=fingerprint:sha-256 %s +a=fingerprint:%s a=setup:actpass a=sctp-port:5000 a=max-message-size:100000 @@ -43,11 +45,11 @@ func renderClientSdp(args sdpArgs) string { args.Addr.Port, args.Ufrag, args.Password, - args.Fingerprint, + fingerprintSDP(args.Fingerprint), ) } -const SERVER_SDP string =` +const SERVER_SDP string = ` v=0 o=- 0 0 IN %s %s s=- @@ -59,7 +61,7 @@ a=mid:0 a=ice-options:ice2 a=ice-ufrag:%s a=ice-pwd:%s -a=fingerprint:sha-256 %s +a=fingerprint:%s a=setup:passive a=sctp-port:5000 a=max-message-size:100000 @@ -71,6 +73,7 @@ func renderServerSdp(args sdpArgs) string { if args.Addr.IP.To4() == nil { ipVersion = "IP6" } + fp := fingerprintSDP(args.Fingerprint) return fmt.Sprintf( SERVER_SDP, ipVersion, @@ -80,7 +83,7 @@ func renderServerSdp(args sdpArgs) string { args.Addr.IP, args.Ufrag, args.Password, - args.Fingerprint, + fp, args.Addr.IP, args.Addr.Port, ) diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 31adf4be3b..256e9d740d 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -1,17 +1,319 @@ package libp2pwebrtc import ( + "context" + "crypto/rand" + "crypto/rsa" + "encoding/hex" + "fmt" + "net" + "strings" + "time" + + ic "github.com/libp2p/go-libp2p-core/crypto" + "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p-core/peer" + tpt "github.com/libp2p/go-libp2p-core/transport" + "github.com/libp2p/go-libp2p/p2p/security/noise" + + logging "github.com/ipfs/go-log/v2" + ma "github.com/multiformats/go-multiaddr" + mafmt "github.com/multiformats/go-multiaddr-fmt" + manet "github.com/multiformats/go-multiaddr/net" + "github.com/pion/webrtc/v3" ) -type transport struct { - api *webrtc.API +var log = logging.Logger("webrtc-transport") + +var dialMatcher = mafmt.And(mafmt.IP, mafmt.Base(ma.P_UDP), mafmt.Base(P_XWEBRTC), mafmt.Base(ma.P_CERTHASH)) + +type WebRTCTransport struct { + webrtcConfig webrtc.Configuration + rcmgr network.ResourceManager + privKey ic.PrivKey } -func (t *transport) Protocols() []int { - return []int{ P_XWEBRTC } +type Option func(*WebRTCTransport) error + +func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*WebRTCTransport, error) { + pk, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + log.Debugf("could not generate rsa key for cert: %v", err) + return nil, err + } + cert, err := webrtc.GenerateCertificate(pk) + if err != nil { + log.Debugf("could not generate certificate: %v", err) + return nil, err + } + config := webrtc.Configuration{ + Certificates: []webrtc.Certificate{*cert}, + } + return &WebRTCTransport{rcmgr: rcmgr, webrtcConfig: config, privKey: privKey}, nil } -func (t *transport) Proxy() bool { +func (t *WebRTCTransport) Protocols() []int { + return []int{P_XWEBRTC} +} + +func (t *WebRTCTransport) Proxy() bool { return false } + +func (t *WebRTCTransport) CanDial(addr ma.Multiaddr) bool { + return dialMatcher.Matches(addr) +} + +func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { + nw, host, err := manet.DialArgs(addr) + if err != nil { + log.Debugf("listener could not fetch dialargs: %v", err) + } + udpAddr, err := net.ResolveUDPAddr(nw, host) + if err != nil { + log.Debugf("listener could not resolve udp address: %v", err) + return nil, err + } + + socket, err := net.ListenUDP(nw, udpAddr) + if err != nil { + log.Debugf("could not listen on udp: %v", err) + } + + // construct multiaddr + listenerMultiaddr, err := manet.FromNetAddr(socket.LocalAddr()) + if err != nil { + _ = socket.Close() + return nil, err + } + + listenerFingerprint, err := t.getCertificateFingerprint() + if err != nil { + _ = socket.Close() + return nil, err + } + + encodedLocalFingerprint, err := encodeDTLSFingerprint(listenerFingerprint) + if err != nil { + _ = socket.Close() + return nil, err + } + + certMultiaddress, err := ma.NewMultiaddr(fmt.Sprintf("/webrtc/certhash/%s", encodedLocalFingerprint)) + if err != nil { + _ = socket.Close() + return nil, err + } + + listenerMultiaddr = listenerMultiaddr.Encapsulate(certMultiaddress) + + return newListener( + t, + listenerMultiaddr, + socket, + t.privKey, + t.webrtcConfig, + ) +} + +func (t *WebRTCTransport) Dial( + ctx context.Context, + remoteMultiaddr ma.Multiaddr, + p peer.ID, +) (tpt.CapableConn, error) { + remoteMultihash, err := decodeRemoteFingerprint(remoteMultiaddr) + if err != nil { + log.Debugf("could not decode remote multiaddr: %v", err) + return nil, err + } + + rnw, rhost, err := manet.DialArgs(remoteMultiaddr) + if err != nil { + log.Debugf("could not generate dialargs: %v", err) + return nil, err + } + + raddr, err := net.ResolveUDPAddr(rnw, rhost) + if err != nil { + log.Debugf("could not resolve udp address: %v", err) + return nil, err + } + + localFingerprint, err := t.getCertificateFingerprint() + if err != nil { + log.Debugf("could not get local fingerprint: %v", err) + return nil, err + } + localFingerprintStr := strings.ReplaceAll(localFingerprint.Value, ":", "") + + se := webrtc.SettingEngine{} + se.DetachDataChannels() + se.SetICECredentials(localFingerprintStr, localFingerprintStr) + api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) + + pc, err := api.NewPeerConnection(t.webrtcConfig) + if err != nil { + log.Debugf("could not instantiate peerconnection: %v", err) + return nil, err + } + + dc, err := pc.CreateDataChannel("data", nil) + if err != nil { + _ = pc.Close() + log.Debugf("could not create datachannel: %v", err) + return nil, err + } + + opened := make(chan *DataChannel, 1) + errChan := make(chan error, 1) + dc.OnOpen(func() { + detached, err := dc.Detach() + if err != nil { + log.Debugf("could not detach datachannel: %v", err) + errChan <- err + } + cp, err := dc.Transport().Transport().ICETransport().GetSelectedCandidatePair() + if err != nil { + log.Debugf("could not fetch selected candidate pair: %v", err) + errChan <- err + return + } + + laddr := &net.UDPAddr{IP: net.ParseIP(cp.Local.Address), Port: int(cp.Local.Port)} + opened <- newDataChannel(detached, pc, laddr, raddr) + }) + + offer, err := pc.CreateOffer(nil) + if err != nil { + _ = pc.Close() + log.Debugf("could not create offer: %v", err) + return nil, err + } + + err = pc.SetLocalDescription(offer) + if err != nil { + _ = pc.Close() + log.Debugf("could not set local description: %v", err) + return nil, err + } + + answerSdpString := renderServerSdp(sdpArgs{ + Addr: raddr, + Fingerprint: remoteMultihash, + Ufrag: localFingerprintStr, + Password: hex.EncodeToString(remoteMultihash.Digest), + }) + + answer := webrtc.SessionDescription{SDP: answerSdpString, Type: webrtc.SDPTypeAnswer} + err = pc.SetRemoteDescription(answer) + if err != nil { + _ = pc.Close() + log.Debugf("could not set remote description: %v", err) + return nil, err + } + + var dataChannel *DataChannel = nil + select { + case dataChannel = <-opened: + case err = <-errChan: + _ = pc.Close() + return nil, err + case <-ctx.Done(): + _ = pc.Close() + return nil, ErrDataChannelTimeout + } + + // create noise transport for auth + noiseTpt, err := noise.New(t.privKey) + if err != nil { + log.Debugf("could not create noise transport: %v", err) + return nil, err + } + + mb, err := encodeDTLSFingerprint(localFingerprint) + if err != nil { + log.Debugf("could not encode local fingerprint: %v", err) + return nil, err + } + secureConn, err := noiseTpt.SecureOutbound(context.Background(), dataChannel, p) + if err != nil { + log.Debugf("could not create secure outbound transport: %v", err) + return nil, err + } + + // noise handshake + _, err = secureConn.Write([]byte(mb)) + if err != nil { + _ = pc.Close() + log.Debugf("could not write auth data: %v", err) + return nil, err + } + done := make(chan error, 1) + go func() { + buf := make([]byte, 2048) + n, err := secureConn.Read(buf) + if err != nil { + done <- err + } + remoteFpMultibase := string(buf[:n]) + if !verifyRemoteFingerprint(pc.SCTP().Transport().GetRemoteCertificate(), remoteFpMultibase) { + done <- fmt.Errorf("could not verify remote fingerprint") + } + close(done) + }() + + select { + case err = <-done: + if err != nil { + _ = pc.Close() + log.Debugf("dialed: read failed: %v", err) + return nil, err + } + case <-time.After(10 * time.Second): + _ = pc.Close() + return nil, ErrNoiseHandshakeTimeout + } + + scope, err := t.rcmgr.OpenConnection(network.DirOutbound, false) + if err != nil { + _ = pc.Close() + return nil, err + } + err = scope.SetPeer(secureConn.RemotePeer()) + if err != nil { + _ = pc.Close() + scope.Done() + return nil, err + } + + localAddr, err := manet.FromNetAddr(dataChannel.LocalAddr()) + if err != nil { + return nil, err + } + conn, err := newConnection( + pc, + t, + scope, + secureConn.LocalPeer(), + secureConn.LocalPrivateKey(), + localAddr, + secureConn.RemotePeer(), + secureConn.RemotePublicKey(), + remoteMultiaddr, + ) + if err != nil { + _ = pc.Close() + return nil, err + } + + return conn, nil +} + +func (t *WebRTCTransport) getCertificateFingerprint() (webrtc.DTLSFingerprint, error) { + fps, err := t.webrtcConfig.Certificates[0].GetFingerprints() + if err != nil { + return webrtc.DTLSFingerprint{}, err + } + return fps[0], nil +} diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go new file mode 100644 index 0000000000..59a87db3d3 --- /dev/null +++ b/p2p/transport/webrtc/transport_test.go @@ -0,0 +1,154 @@ +package libp2pwebrtc + +import ( + "context" + "testing" + + "github.com/libp2p/go-libp2p-core/crypto" + "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p-core/peer" + tpt "github.com/libp2p/go-libp2p-core/transport" + "github.com/multiformats/go-multiaddr" + "github.com/stretchr/testify/require" +) + +func getTransport(t *testing.T) (tpt.Transport, peer.ID) { + privKey, _, err := crypto.GenerateKeyPair(crypto.Ed25519, -1) + require.NoError(t, err) + rcmgr := network.NullResourceManager + transport, err := New(privKey, rcmgr) + require.NoError(t, err) + peerID, err := peer.IDFromPrivateKey(privKey) + require.NoError(t, err) + return transport, peerID +} + +func TestTransportCanDial(t *testing.T) { + tr, _ := getTransport(t) + invalid := []string{ + "/ip4/1.2.3.4/udp/1234/webrtc", + "/dns/test.test/udp/1234/webrtc", + "/dns/test.test/udp/1234/webrtc/certhash/uEiAsGPzpiPGQzSlVHRXrUCT5EkTV7YFrV4VZ3hpEKTd_zg", + } + + valid := []string{ + "/ip4/1.2.3.4/udp/1234/webrtc/certhash/uEiAsGPzpiPGQzSlVHRXrUCT5EkTV7YFrV4VZ3hpEKTd_zg", + "/ip6/0:0:0:0:0:0:0:1/udp/1234/webrtc/certhash/uEiAsGPzpiPGQzSlVHRXrUCT5EkTV7YFrV4VZ3hpEKTd_zg", + "/ip6/::1/udp/1234/webrtc/certhash/uEiAsGPzpiPGQzSlVHRXrUCT5EkTV7YFrV4VZ3hpEKTd_zg", + } + + for _, addr := range invalid { + ma, err := multiaddr.NewMultiaddr(addr) + require.NoError(t, err) + require.Equal(t, false, tr.CanDial(ma)) + } + + for _, addr := range valid { + ma, err := multiaddr.NewMultiaddr(addr) + require.NoError(t, err) + require.Equal(t, true, tr.CanDial(ma), addr) + } +} + +func TestTransportCanListen(t *testing.T) { + tr, listeningPeer := getTransport(t) + listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + require.NoError(t, err) + listener, err := tr.Listen(listenMultiaddr) + require.NoError(t, err) + + tr1, connectingPeer := getTransport(t) + + go func() { + _, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) + require.NoError(t, err) + }() + + conn, err := listener.Accept() + require.NoError(t, err) + + require.Equal(t, connectingPeer, conn.RemotePeer()) +} + +func TestTransportCanListenMultiple(t *testing.T) { + tr, listeningPeer := getTransport(t) + listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + require.NoError(t, err) + listener, err := tr.Listen(listenMultiaddr) + require.NoError(t, err) + + for i := 0; i < 10; i++ { + go func() { + ctr, _ := getTransport(t) + conn, err := ctr.Dial(context.Background(), listener.Multiaddr(), listeningPeer) + require.NoError(t, err) + require.Equal(t, conn.RemotePeer(), listeningPeer) + }() + } + + for i := 0; i < 10; i++ { + _, err := listener.Accept() + require.NoError(t, err) + } +} + +func TestTransportListenerCanCreateStreams(t *testing.T) { + tr, listeningPeer := getTransport(t) + listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + require.NoError(t, err) + listener, err := tr.Listen(listenMultiaddr) + require.NoError(t, err) + + tr1, connectingPeer := getTransport(t) + + go func() { + conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) + require.NoError(t, err) + stream, err := conn.AcceptStream() + require.NoError(t, err) + buf := make([]byte, 100) + n, err := stream.Read(buf) + require.NoError(t, err) + require.Equal(t, "test", string(buf[:n])) + }() + + conn, err := listener.Accept() + require.NoError(t, err) + + require.Equal(t, connectingPeer, conn.RemotePeer()) + + stream, err := conn.OpenStream(context.Background()) + require.NoError(t, err) + _, err = stream.Write([]byte("test")) + require.NoError(t, err) +} + +func TestTransportDialerCanCreateStreams(t *testing.T) { + tr, listeningPeer := getTransport(t) + listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + require.NoError(t, err) + listener, err := tr.Listen(listenMultiaddr) + require.NoError(t, err) + + tr1, connectingPeer := getTransport(t) + + go func() { + conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) + require.NoError(t, err) + stream, err := conn.OpenStream(context.Background()) + require.NoError(t, err) + _, err = stream.Write([]byte("test")) + require.NoError(t, err) + }() + + lconn, err := listener.Accept() + require.NoError(t, err) + require.Equal(t, connectingPeer, lconn.RemotePeer()) + + stream, err := lconn.AcceptStream() + require.NoError(t, err) + buf := make([]byte, 100) + n, err := stream.Read(buf) + require.NoError(t, err) + require.Equal(t, "test", string(buf[:n])) +} diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index e4881df153..45155f3200 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -82,7 +82,6 @@ func (m *UDPMuxNewAddr) GetConn(ufrag string, isIPv6 bool) (net.PacketConn, erro defer m.mu.Unlock() if m.IsClosed() { - m.params.Logger.Debugf("conn closed: %s", ufrag) return nil, io.ErrClosedPipe } @@ -94,7 +93,6 @@ func (m *UDPMuxNewAddr) GetConn(ufrag string, isIPv6 bool) (net.PacketConn, erro go func() { <-c.CloseChannel() m.removeConn(ufrag) - m.params.Logger.Debugf("removing connection: %s", ufrag) }() if isIPv6 { @@ -279,11 +277,6 @@ func (m *UDPMuxNewAddr) connWorker() { continue } - if err = validateFingerprint(ufrag); err != nil { - m.params.Logger.Debugf("invalid DTLS fingerprint: %s , dropping packet", ufrag) - continue - } - isIPv6 := udpAddr.IP.To4() == nil m.mu.Lock() diff --git a/p2p/transport/webrtc/udp_mux_conn.go b/p2p/transport/webrtc/udp_mux_conn.go index f0a231c4bb..d0e7d29765 100644 --- a/p2p/transport/webrtc/udp_mux_conn.go +++ b/p2p/transport/webrtc/udp_mux_conn.go @@ -244,4 +244,3 @@ func decodeUDPAddr(buf []byte) (*net.UDPAddr, error) { return &addr, nil } - diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go index cdac78944c..7340db7a2e 100644 --- a/p2p/transport/webrtc/udp_mux_test.go +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -4,11 +4,10 @@ import ( "fmt" "net" "os" + "strings" "testing" "time" - "strings" - // ma "github.com/multiformats/go-multiaddr" "github.com/pion/ice/v2" "github.com/pion/logging" "github.com/pion/stun" @@ -30,7 +29,7 @@ func TestUdpMuxNewAddrNewStun(t *testing.T) { newAddrChan := make(chan candidateAddr, 1) _ = NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: serverConn, Logger: logger}, newAddrChan) - certhash := "496612170D1C91AE574CC636DDD597D27D62C99A7FB9A3F47003E7439173235E" + certhash := "496612170D1C91AE574CC636DDD597D27D62C99A7FB9A3F47003E7439173235E" go func() { <-time.After(1 * time.Second) msg := stun.MustBuild( @@ -48,12 +47,10 @@ func TestUdpMuxNewAddrNewStun(t *testing.T) { select { case addr := <-newAddrChan: - t.Logf("%v", addr) hash := addr.fingerprint if err != nil { t.Fatal(err) } - t.Logf("received hash: %v", hash) if strings.ToLower(hash) != strings.ToLower(certhash) { t.Fatalf("expected hash: %s, received: %s", certhash, hash) } diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index f558534c92..3fb5569420 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -1,15 +1,28 @@ package libp2pwebrtc import ( - ma "github.com/multiformats/go-multiaddr" - manet "github.com/multiformats/go-multiaddr/net" - "fmt" "encoding/hex" - "net" - "strconv" "strings" + + ma "github.com/multiformats/go-multiaddr" + "github.com/pion/webrtc/v3" + + "github.com/multiformats/go-multibase" + mh "github.com/multiformats/go-multihash" ) +var mhToSdpHash = map[string]string{ + "sha1": "sha1", + "sha2-256": "sha-256", + "md5": "md5", +} + +var sdpHashToMh = map[string]string{ + "sha-256": "sha2-256", + "sha1": "sha1", + "md5": "md5", +} + func maFingerprintToSdp(fp string) string { result := "" first := true @@ -23,38 +36,42 @@ func maFingerprintToSdp(fp string) string { } result += string(char) } - return strings.ToUpper(result) + return result } -func maToAddrFingerprint(addr ma.Multiaddr) (*net.UDPAddr, string, error) { - ip, err := manet.ToIP(addr) - if err != nil { - return nil, "", err +func fingerprintSDP(fp *mh.DecodedMultihash) string { + if fp == nil { + return "" } - portS, err := addr.ValueForProtocol(ma.P_UDP) - if err != nil { - return nil, "", err + fpDigest := maFingerprintToSdp(hex.EncodeToString(fp.Digest)) + fpAlgo, ok := mhToSdpHash[strings.ToLower(fp.Name)] + if !ok { + fpAlgo = strings.ToLower(fp.Name) } - port, err := strconv.Atoi(portS) + return fpAlgo + " " + fpDigest +} + +func decodeRemoteFingerprint(maddr ma.Multiaddr) (*mh.DecodedMultihash, error) { + remoteFingerprintMultibase, err := maddr.ValueForProtocol(ma.P_CERTHASH) if err != nil { - return nil, "", err + return nil, err } - - result := &net.UDPAddr{ IP: ip, Port: port } - - remoteFp, err := addr.ValueForProtocol(P_XWEBRTC) + _, data, err := multibase.Decode(remoteFingerprintMultibase) if err != nil { - return nil, "", err + return nil, err } - remoteFp = maFingerprintToSdp(remoteFp) - - return result, remoteFp, nil + return mh.Decode(data) } -func validateFingerprint(fp string) error { - b, err := hex.DecodeString(fp) - if err != nil || len(b) != 32 { - return fmt.Errorf("invalid fingerprint") +func encodeDTLSFingerprint(fp webrtc.DTLSFingerprint) (string, error) { + digest, err := hex.DecodeString(strings.ReplaceAll(fp.Value, ":", "")) + if err != nil { + return "", err + } + algo, ok := sdpHashToMh[strings.ToLower(fp.Algorithm)] + if !ok { + algo = fp.Algorithm } - return nil + encoded, err := mh.EncodeName(digest, algo) + return multibase.Encode(multibase.Base16, encoded) } diff --git a/p2p/transport/webrtc/util_test.go b/p2p/transport/webrtc/util_test.go index f212ab1aa6..6cb0a612de 100644 --- a/p2p/transport/webrtc/util_test.go +++ b/p2p/transport/webrtc/util_test.go @@ -2,35 +2,13 @@ package libp2pwebrtc import ( "testing" - ma "github.com/multiformats/go-multiaddr" ) func TestMaFingerprintToSdp(t *testing.T) { - certhash := "496612170D1C91AE574CC636DDD597D27D62C99A7FB9A3F47003E7439173235E" - expected := "49:66:12:17:0D:1C:91:AE:57:4C:C6:36:DD:D5:97:D2:7D:62:C9:9A:7F:B9:A3:F4:70:03:E7:43:91:73:23:5E" + certhash := "496612170D1C91AE574CC636DDD597D27D62C99A7FB9A3F47003E7439173235E" + expected := "49:66:12:17:0D:1C:91:AE:57:4C:C6:36:DD:D5:97:D2:7D:62:C9:9A:7F:B9:A3:F4:70:03:E7:43:91:73:23:5E" result := maFingerprintToSdp(certhash) - t.Logf("result: %s", result) if result != expected { t.Fatalf("expected %s, found: %s", expected, result) } } - -func TestMaToAddrFingerprint(t *testing.T) { - maddr, err := ma.NewMultiaddr("/ip4/127.0.0.1/udp/44218/x-webrtc/496612170d1c91ae574cc636ddd597d27d62c99a7fb9a3f47003e7439173235e") - if err != nil { - t.Fatal(err) - } - addr, fp, err := maToAddrFingerprint(maddr) - if err != nil { - t.Fatal(err) - } - if addr.IP.String() != "127.0.0.1" { - t.Fatalf("expected localhost ipv4 address") - } - - expected := "49:66:12:17:0D:1C:91:AE:57:4C:C6:36:DD:D5:97:D2:7D:62:C9:9A:7F:B9:A3:F4:70:03:E7:43:91:73:23:5E" - if fp != expected { - t.Fatalf("expected %s, found: %s", expected, fp) - } - -} From a90bb533df7e65581e9ac70caef07b251f292dbe Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 12 Jul 2022 19:07:33 +0530 Subject: [PATCH 03/50] update interfaces --- p2p/transport/webrtc/listener.go | 2 +- p2p/transport/webrtc/transport.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 03d6cda357..219a95c9fb 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -264,7 +264,7 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { _ = pc.Close() return nil, err } - scope, err := l.transport.rcmgr.OpenConnection(network.DirInbound, false) + scope, err := l.transport.rcmgr.OpenConnection(network.DirInbound, false, remoteMultiaddr) if err != nil { _ = pc.Close() return nil, err diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 256e9d740d..c649539677 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -275,7 +275,7 @@ func (t *WebRTCTransport) Dial( return nil, ErrNoiseHandshakeTimeout } - scope, err := t.rcmgr.OpenConnection(network.DirOutbound, false) + scope, err := t.rcmgr.OpenConnection(network.DirOutbound, false, remoteMultiaddr) if err != nil { _ = pc.Close() return nil, err From f64248547d53bf625e61c714f562f81ac731f430 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 12 Jul 2022 19:22:41 +0530 Subject: [PATCH 04/50] cleanup --- p2p/transport/webrtc/connection.go | 2 -- p2p/transport/webrtc/listener.go | 19 +++++++++---------- p2p/transport/webrtc/util.go | 3 +-- 3 files changed, 10 insertions(+), 14 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index 28323e951c..f12e5a1fae 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -129,8 +129,6 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error case r := <-result: return r.MuxedStream, r.error } - // should be unreachable - return nil, nil } func (c *connection) AcceptStream() (network.MuxedStream, error) { diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 219a95c9fb..139f25631c 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -139,9 +139,6 @@ func (l *listener) Multiaddr() ma.Multiaddr { } func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { - // get remote fingerprint - // remoteFp := maFingerprintToSdp(addr.fingerprint) - // local fingerprint localFingerprint := strings.ReplaceAll(l.localFingerprint.Value, ":", "") se := webrtc.SettingEngine{} @@ -178,12 +175,12 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { dcChan := make(chan *DataChannel) pc.OnDataChannel(func(dc *webrtc.DataChannel) { // assert that the label of the first DataChannel is "data" - // TODO: Make const and move into spec - if dc.Label() != "data" { - // warn closing data channel - dc.Close() - return - } + // NOTE: Is enforcing the first datachannel name necessary? + // if dc.Label() != "data" { + // // warn closing data channel + // dc.Close() + // return + // } dc.OnOpen(func() { detached, err := dc.Detach() @@ -211,9 +208,11 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { _ = pc.Close() return nil, fmt.Errorf("should be unreachable") } - // clear to allow opening of future data channels + // clear to ignore opening of future data channels + // until noise handshake is complete pc.OnDataChannel(func(*webrtc.DataChannel) {}) } + // perform noise handshake noiseTpt, err := noise.New(l.privKey) if err != nil { diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index 3fb5569420..09a0a3af12 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -5,10 +5,9 @@ import ( "strings" ma "github.com/multiformats/go-multiaddr" - "github.com/pion/webrtc/v3" - "github.com/multiformats/go-multibase" mh "github.com/multiformats/go-multihash" + "github.com/pion/webrtc/v3" ) var mhToSdpHash = map[string]string{ From 18d3baa40f72046ad423e11dca840e350a910331 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 12 Jul 2022 23:23:24 +0530 Subject: [PATCH 05/50] create a negotiated datachannel on the listener --- p2p/transport/webrtc/listener.go | 39 ++++++++++++++----------------- p2p/transport/webrtc/transport.go | 8 ++++++- 2 files changed, 24 insertions(+), 23 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 139f25631c..c3d1b55c3a 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -173,28 +173,23 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { // await openening of datachannel dcChan := make(chan *DataChannel) - pc.OnDataChannel(func(dc *webrtc.DataChannel) { - // assert that the label of the first DataChannel is "data" - // NOTE: Is enforcing the first datachannel name necessary? - // if dc.Label() != "data" { - // // warn closing data channel - // dc.Close() - // return - // } - - dc.OnOpen(func() { - detached, err := dc.Detach() - if err != nil { - return - } - dcChan <- newDataChannel( - detached, - pc, - l.mux.LocalAddr(), - addr.raddr, - ) - }) - + // this enforces that the correct data channel label is used + // for the handshake + handshakeChannel, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ + Negotiated: func(v bool) *bool { return &v }(true), + ID: func(v uint16) *uint16 { return &v }(1), + }) + handshakeChannel.OnOpen(func() { + detached, err := handshakeChannel.Detach() + if err != nil { + return + } + dcChan <- newDataChannel( + detached, + pc, + l.mux.LocalAddr(), + addr.raddr, + ) }) timeout := 10 * time.Second diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index c649539677..b8e2019661 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -158,7 +158,13 @@ func (t *WebRTCTransport) Dial( return nil, err } - dc, err := pc.CreateDataChannel("data", nil) + // We need to set negotiated = true for this channel on both + // the client and server to avoid DCEP errors. + dc, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ + Negotiated: func(v bool) *bool { return &v }(true), + ID: func(v uint16) *uint16 { return &v }(1), + }) + if err != nil { _ = pc.Close() log.Debugf("could not create datachannel: %v", err) From c2de6cfb795c93aeca4c25653e4a662acea4c4c3 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 12 Jul 2022 23:56:39 +0530 Subject: [PATCH 06/50] Use uuid as ufrag instead of DTLS fingerprint --- p2p/transport/webrtc/listener.go | 35 ++++++++++++++++++++------ p2p/transport/webrtc/transport.go | 14 ++++++++--- p2p/transport/webrtc/transport_test.go | 1 + p2p/transport/webrtc/udp_mux.go | 6 ++--- p2p/transport/webrtc/udp_mux_test.go | 2 +- 5 files changed, 43 insertions(+), 15 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index c3d1b55c3a..0001742f30 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -9,6 +9,7 @@ import ( "net" "os" "strings" + "sync" "time" "github.com/libp2p/go-libp2p-core/crypto" @@ -101,9 +102,12 @@ func (l *listener) startAcceptLoop() { return case addr := <-l.mux.newAddrChan: go func() { - conn, err := l.accept(addr) + ctx, cancelFunc := context.WithTimeout(context.Background(), 20*time.Second) + defer cancelFunc() + conn, err := l.accept(ctx, addr) if err != nil { log.Debugf("could not accept connection: %v", err) + return } l.connChan <- conn }() @@ -138,14 +142,16 @@ func (l *listener) Multiaddr() ma.Multiaddr { return l.localMultiaddr } -func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { +func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableConn, error) { localFingerprint := strings.ReplaceAll(l.localFingerprint.Value, ":", "") + // signaling channel + signalChan := make(chan struct{}) se := webrtc.SettingEngine{} se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) se.DetachDataChannels() se.DisableCertificateFingerprintVerification(true) - se.SetICECredentials(addr.fingerprint, localFingerprint) + se.SetICECredentials(addr.ufrag, localFingerprint) se.SetLite(true) se.SetICEUDPMux(l.mux) @@ -154,14 +160,22 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { clientSdpString := renderClientSdp(sdpArgs{ Addr: addr.raddr, Fingerprint: defaultMultihash, - Ufrag: addr.fingerprint, - Password: addr.fingerprint, + Ufrag: addr.ufrag, + Password: addr.ufrag, }) clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} pc, err := api.NewPeerConnection(l.config) if err != nil { return nil, err } + + var connectedOnce sync.Once + pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) { + if state == webrtc.PeerConnectionStateConnected { + connectedOnce.Do(func() { signalChan <- struct{}{} }) + } + }) + pc.SetRemoteDescription(clientSdp) answer, err := pc.CreateAnswer(nil) @@ -171,6 +185,13 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { } pc.SetLocalDescription(answer) + // await peerconnection connected state + select { + case <-signalChan: + case <-ctx.Done(): + return nil, ctx.Err() + } + // await openening of datachannel dcChan := make(chan *DataChannel) // this enforces that the correct data channel label is used @@ -228,7 +249,7 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { // Ordinarily, we would do this with a ReadDeadline, but since the underlying datachannel.ReadWriteCloser // does not allow us to set ReadDeadline, we have to manually spawn a goroutine - done := make(chan error, 1) + done := make(chan error) go func() { buf := make([]byte, 200) n, err := secureConn.Read(buf) @@ -248,7 +269,7 @@ func (l *listener) accept(addr candidateAddr) (tpt.CapableConn, error) { _ = pc.Close() return nil, err } - case <-time.After(10 * time.Second): + case <-ctx.Done(): _ = pc.Close() return nil, ErrNoiseHandshakeTimeout } diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index b8e2019661..46bdeb926b 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -7,9 +7,9 @@ import ( "encoding/hex" "fmt" "net" - "strings" "time" + "github.com/google/uuid" ic "github.com/libp2p/go-libp2p-core/crypto" "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-core/peer" @@ -145,11 +145,17 @@ func (t *WebRTCTransport) Dial( log.Debugf("could not get local fingerprint: %v", err) return nil, err } - localFingerprintStr := strings.ReplaceAll(localFingerprint.Value, ":", "") + + // @mxinden instead of encoding the local fingerprint we + // instead generate a random uuid as the connection ufrag. + // The only requirement here is that the ufrag and password + // must be equal, which will allow the server to determine + // the password using the STUN message. + ufrag := uuid.New().String() se := webrtc.SettingEngine{} se.DetachDataChannels() - se.SetICECredentials(localFingerprintStr, localFingerprintStr) + se.SetICECredentials(ufrag, ufrag) api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) pc, err := api.NewPeerConnection(t.webrtcConfig) @@ -207,7 +213,7 @@ func (t *WebRTCTransport) Dial( answerSdpString := renderServerSdp(sdpArgs{ Addr: raddr, Fingerprint: remoteMultihash, - Ufrag: localFingerprintStr, + Ufrag: ufrag, Password: hex.EncodeToString(remoteMultihash.Digest), }) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 59a87db3d3..644ea182ce 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -66,6 +66,7 @@ func TestTransportCanListen(t *testing.T) { conn, err := listener.Accept() require.NoError(t, err) + require.NotNil(t, conn) require.Equal(t, connectingPeer, conn.RemotePeer()) } diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index 45155f3200..3a4d473d12 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -14,8 +14,8 @@ import ( ) type candidateAddr struct { - raddr *net.UDPAddr - fingerprint string + raddr *net.UDPAddr + ufrag string } // UDPMuxNewAddr is an implementation of the interface @@ -285,7 +285,7 @@ func (m *UDPMuxNewAddr) connWorker() { // notify that a new connection is requested if !ok { - m.newAddrChan <- candidateAddr{raddr: udpAddr, fingerprint: ufrag} + m.newAddrChan <- candidateAddr{raddr: udpAddr, ufrag: ufrag} m.mu.Lock() m.newAddrs[udpAddr] = struct{}{} m.mu.Unlock() diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go index 7340db7a2e..4adf1b329c 100644 --- a/p2p/transport/webrtc/udp_mux_test.go +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -47,7 +47,7 @@ func TestUdpMuxNewAddrNewStun(t *testing.T) { select { case addr := <-newAddrChan: - hash := addr.fingerprint + hash := addr.ufrag if err != nil { t.Fatal(err) } From a5a9e6ba1726a85ce7081d0b89ccda9845a5d8c6 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 25 Jul 2022 10:39:10 +0530 Subject: [PATCH 07/50] address review --- p2p/transport/webrtc/connection.go | 7 +- p2p/transport/webrtc/datachannel.go | 31 ++-- p2p/transport/webrtc/listener.go | 134 +++++++--------- p2p/transport/webrtc/transport.go | 220 ++++++++++++++------------- p2p/transport/webrtc/udp_mux.go | 32 ++-- p2p/transport/webrtc/udp_mux_conn.go | 2 +- p2p/transport/webrtc/util.go | 1 + 7 files changed, 213 insertions(+), 214 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index f12e5a1fae..4ebee87bf0 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -13,6 +13,8 @@ import ( "github.com/pion/webrtc/v3" ) +var _ tpt.CapableConn = &connection{} + type connection struct { pc *webrtc.PeerConnection transport *WebRTCTransport @@ -132,13 +134,12 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error } func (c *connection) AcceptStream() (network.MuxedStream, error) { - var stream network.MuxedStream select { case <-c.closed: return nil, os.ErrClosed - case stream = <-c.accept: + case stream := <-c.accept: + return stream, nil } - return stream, nil } // implement network.ConnSecurity diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 988e07c972..39e1ce24cb 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -7,13 +7,16 @@ import ( "sync" "time" + "github.com/libp2p/go-libp2p-core/network" "github.com/pion/datachannel" "github.com/pion/webrtc/v3" ) +var _ network.MuxedStream = &dataChannel{} + // Package pion detached data channel into a net.Conn // and then a network.MuxedStream -type DataChannel struct { +type dataChannel struct { // TODO: Are these circular references okay? pc *webrtc.PeerConnection dc datachannel.ReadWriteCloser @@ -29,8 +32,8 @@ type DataChannel struct { func newDataChannel( dc datachannel.ReadWriteCloser, pc *webrtc.PeerConnection, - laddr, raddr net.Addr) *DataChannel { - return &DataChannel{ + laddr, raddr net.Addr) *dataChannel { + return &dataChannel{ dc: dc, laddr: laddr, raddr: raddr, @@ -39,7 +42,7 @@ func newDataChannel( } } -func (d *DataChannel) Read(b []byte) (int, error) { +func (d *dataChannel) Read(b []byte) (int, error) { select { case <-d.closeRead: return 0, io.EOF @@ -76,7 +79,7 @@ func (d *DataChannel) Read(b []byte) (int, error) { } } -func (d *DataChannel) Write(b []byte) (int, error) { +func (d *dataChannel) Write(b []byte) (int, error) { select { case <-d.closeWrite: return 0, io.ErrClosedPipe @@ -113,11 +116,11 @@ func (d *DataChannel) Write(b []byte) (int, error) { } } -func (d *DataChannel) Close() error { +func (d *dataChannel) Close() error { return d.dc.Close() } -func (d *DataChannel) CloseRead() error { +func (d *dataChannel) CloseRead() error { select { case <-d.closeRead: default: @@ -126,7 +129,7 @@ func (d *DataChannel) CloseRead() error { return nil } -func (d *DataChannel) CloseWrite() error { +func (d *dataChannel) CloseWrite() error { select { case <-d.closeWrite: default: @@ -135,19 +138,19 @@ func (d *DataChannel) CloseWrite() error { return nil } -func (d *DataChannel) LocalAddr() net.Addr { +func (d *dataChannel) LocalAddr() net.Addr { return d.laddr } -func (d *DataChannel) RemoteAddr() net.Addr { +func (d *dataChannel) RemoteAddr() net.Addr { return d.raddr } -func (d *DataChannel) Reset() error { +func (d *dataChannel) Reset() error { return d.Close() } -func (d *DataChannel) SetDeadline(t time.Time) error { +func (d *dataChannel) SetDeadline(t time.Time) error { d.m.Lock() defer d.m.Unlock() d.readDeadline = t @@ -155,14 +158,14 @@ func (d *DataChannel) SetDeadline(t time.Time) error { return nil } -func (d *DataChannel) SetReadDeadline(t time.Time) error { +func (d *dataChannel) SetReadDeadline(t time.Time) error { d.m.Lock() defer d.m.Unlock() d.readDeadline = t return nil } -func (d *DataChannel) SetWriteDeadline(t time.Time) error { +func (d *dataChannel) SetWriteDeadline(t time.Time) error { d.m.Lock() defer d.m.Unlock() d.writeDeadline = t diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 0001742f30..55d8d8509c 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -12,11 +12,9 @@ import ( "sync" "time" - "github.com/libp2p/go-libp2p-core/crypto" "github.com/libp2p/go-libp2p-core/network" tpt "github.com/libp2p/go-libp2p-core/transport" - "github.com/libp2p/go-libp2p/p2p/security/noise" ma "github.com/multiformats/go-multiaddr" manet "github.com/multiformats/go-multiaddr/net" "github.com/multiformats/go-multibase" @@ -57,16 +55,15 @@ func init() { type listener struct { transport *WebRTCTransport config webrtc.Configuration - privKey crypto.PrivKey localFingerprint webrtc.DTLSFingerprint localFingerprintMultibase string - mux *UDPMuxNewAddr + mux *udpMuxNewAddr closeChan chan struct{} localMultiaddr ma.Multiaddr connChan chan tpt.CapableConn } -func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.PacketConn, privKey crypto.PrivKey, config webrtc.Configuration) (*listener, error) { +func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.PacketConn, config webrtc.Configuration) (*listener, error) { mux := NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: socket}, make(chan candidateAddr, 1)) localFingerprints, err := config.Certificates[0].GetFingerprints() if err != nil { @@ -83,7 +80,6 @@ func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.Pack l := &listener{ mux: mux, transport: transport, - privKey: privKey, config: config, localFingerprint: localFingerprints[0], localFingerprintMultibase: localFpMultibase, @@ -143,6 +139,31 @@ func (l *listener) Multiaddr() ma.Multiaddr { } func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableConn, error) { + var ( + scope network.ConnManagementScope + pc *webrtc.PeerConnection + ) + + cleanup := func() { + if scope != nil { + scope.Done() + } + if pc != nil { + _ = pc.Close() + } + } + + remoteMultiaddr, err := manet.FromNetAddr(addr.raddr) + if err != nil { + return nil, err + } + + scope, err = l.transport.rcmgr.OpenConnection(network.DirInbound, false, remoteMultiaddr) + if err != nil { + defer cleanup() + return nil, err + } + localFingerprint := strings.ReplaceAll(l.localFingerprint.Value, ":", "") // signaling channel signalChan := make(chan struct{}) @@ -164,8 +185,9 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC Password: addr.ufrag, }) clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} - pc, err := api.NewPeerConnection(l.config) + pc, err = api.NewPeerConnection(l.config) if err != nil { + defer cleanup() return nil, err } @@ -180,7 +202,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC answer, err := pc.CreateAnswer(nil) if err != nil { - _ = pc.Close() + defer cleanup() return nil, err } pc.SetLocalDescription(answer) @@ -189,105 +211,61 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC select { case <-signalChan: case <-ctx.Done(): + defer cleanup() return nil, ctx.Err() } // await openening of datachannel - dcChan := make(chan *DataChannel) + dcChan := make(chan *dataChannel) // this enforces that the correct data channel label is used // for the handshake handshakeChannel, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ Negotiated: func(v bool) *bool { return &v }(true), ID: func(v uint16) *uint16 { return &v }(1), }) + + var handshakeOnce sync.Once handshakeChannel.OnOpen(func() { - detached, err := handshakeChannel.Detach() - if err != nil { - return - } - dcChan <- newDataChannel( - detached, - pc, - l.mux.LocalAddr(), - addr.raddr, - ) + handshakeOnce.Do(func() { + detached, err := handshakeChannel.Detach() + if err != nil { + return + } + dcChan <- newDataChannel( + detached, + pc, + l.mux.LocalAddr(), + addr.raddr, + ) + }) }) - timeout := 10 * time.Second - var dc *DataChannel = nil + var dc *dataChannel select { - case <-time.After(timeout): - _ = pc.Close() + case <-ctx.Done(): + defer cleanup() return nil, ErrDataChannelTimeout case dc = <-dcChan: if dc == nil { - _ = pc.Close() + defer cleanup() return nil, fmt.Errorf("should be unreachable") } // clear to ignore opening of future data channels // until noise handshake is complete - pc.OnDataChannel(func(*webrtc.DataChannel) {}) + // pc.OnDataChannel(func(*webrtc.DataChannel) {}) } - // perform noise handshake - noiseTpt, err := noise.New(l.privKey) - if err != nil { - _ = pc.Close() - return nil, err - } // we do not yet know A's peer ID so accept any inbound - secureConn, err := noiseTpt.SecureInbound(context.Background(), dc, "") - if err != nil { - _ = pc.Close() - return nil, err - } - - _, err = secureConn.Write([]byte(l.localFingerprintMultibase)) + secureConn, err := l.transport.noiseHandshake(ctx, pc, dc, "", true) if err != nil { + defer cleanup() return nil, err } - // Ordinarily, we would do this with a ReadDeadline, but since the underlying datachannel.ReadWriteCloser - // does not allow us to set ReadDeadline, we have to manually spawn a goroutine - done := make(chan error) - go func() { - buf := make([]byte, 200) - n, err := secureConn.Read(buf) - if err != nil { - done <- err - } - remoteFpMultibase := string(buf[:n]) - if !verifyRemoteFingerprint(pc.SCTP().Transport().GetRemoteCertificate(), remoteFpMultibase) { - done <- fmt.Errorf("could not verify remote fingerprint") - } - close(done) - }() - - select { - case err = <-done: - if err != nil { - _ = pc.Close() - return nil, err - } - case <-ctx.Done(): - _ = pc.Close() - return nil, ErrNoiseHandshakeTimeout - } - - remoteMultiaddr, err := manet.FromNetAddr(addr.raddr) - if err != nil { - _ = pc.Close() - return nil, err - } - scope, err := l.transport.rcmgr.OpenConnection(network.DirInbound, false, remoteMultiaddr) - if err != nil { - _ = pc.Close() - return nil, err - } + // earliest point where we know the remote's peerID err = scope.SetPeer(secureConn.RemotePeer()) if err != nil { - _ = pc.Close() - scope.Done() + defer cleanup() return nil, err } @@ -304,7 +282,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC ) if err != nil { - _ = pc.Close() + defer cleanup() return nil, err } diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 46bdeb926b..e1cc8cc2b1 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -7,12 +7,12 @@ import ( "encoding/hex" "fmt" "net" - "time" "github.com/google/uuid" ic "github.com/libp2p/go-libp2p-core/crypto" "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p-core/sec" tpt "github.com/libp2p/go-libp2p-core/transport" "github.com/libp2p/go-libp2p/p2p/security/noise" @@ -32,25 +32,30 @@ type WebRTCTransport struct { webrtcConfig webrtc.Configuration rcmgr network.ResourceManager privKey ic.PrivKey + noiseTpt *noise.Transport } +var _ tpt.Transport = &WebRTCTransport{} + type Option func(*WebRTCTransport) error func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*WebRTCTransport, error) { pk, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { - log.Debugf("could not generate rsa key for cert: %v", err) - return nil, err + return nil, fmt.Errorf("could not generate rsa key for cert: %v", err) } cert, err := webrtc.GenerateCertificate(pk) if err != nil { - log.Debugf("could not generate certificate: %v", err) - return nil, err + return nil, fmt.Errorf("could not generate certificate: %v", err) } config := webrtc.Configuration{ Certificates: []webrtc.Certificate{*cert}, } - return &WebRTCTransport{rcmgr: rcmgr, webrtcConfig: config, privKey: privKey}, nil + noiseTpt, err := noise.New(privKey) + if err != nil { + return nil, fmt.Errorf("unable to create the noise transport") + } + return &WebRTCTransport{rcmgr: rcmgr, webrtcConfig: config, privKey: privKey, noiseTpt: noiseTpt}, nil } func (t *WebRTCTransport) Protocols() []int { @@ -68,17 +73,16 @@ func (t *WebRTCTransport) CanDial(addr ma.Multiaddr) bool { func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { nw, host, err := manet.DialArgs(addr) if err != nil { - log.Debugf("listener could not fetch dialargs: %v", err) + return nil, fmt.Errorf("listener could not fetch dialargs: %v", err) } udpAddr, err := net.ResolveUDPAddr(nw, host) if err != nil { - log.Debugf("listener could not resolve udp address: %v", err) - return nil, err + return nil, fmt.Errorf("listener could not resolve udp address: %v", err) } socket, err := net.ListenUDP(nw, udpAddr) if err != nil { - log.Debugf("could not listen on udp: %v", err) + return nil, fmt.Errorf("could not listen on udp: %v", err) } // construct multiaddr @@ -112,7 +116,6 @@ func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { t, listenerMultiaddr, socket, - t.privKey, t.webrtcConfig, ) } @@ -122,31 +125,48 @@ func (t *WebRTCTransport) Dial( remoteMultiaddr ma.Multiaddr, p peer.ID, ) (tpt.CapableConn, error) { - remoteMultihash, err := decodeRemoteFingerprint(remoteMultiaddr) + var pc *webrtc.PeerConnection + scope, err := t.rcmgr.OpenConnection(network.DirOutbound, false, remoteMultiaddr) + + cleanup := func() { + if pc != nil { + _ = pc.Close() + } + if scope != nil { + scope.Done() + } + } + if err != nil { - log.Debugf("could not decode remote multiaddr: %v", err) + defer cleanup() return nil, err } - rnw, rhost, err := manet.DialArgs(remoteMultiaddr) + err = scope.SetPeer(p) if err != nil { - log.Debugf("could not generate dialargs: %v", err) + defer cleanup() return nil, err } - raddr, err := net.ResolveUDPAddr(rnw, rhost) + remoteMultihash, err := decodeRemoteFingerprint(remoteMultiaddr) if err != nil { - log.Debugf("could not resolve udp address: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not decode remote multiaddr: %v", err) } - localFingerprint, err := t.getCertificateFingerprint() + rnw, rhost, err := manet.DialArgs(remoteMultiaddr) if err != nil { - log.Debugf("could not get local fingerprint: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not generate dialargs: %v", err) } - // @mxinden instead of encoding the local fingerprint we + raddr, err := net.ResolveUDPAddr(rnw, rhost) + if err != nil { + defer cleanup() + return nil, fmt.Errorf("could not resolve udp address: %v", err) + } + + // Instead of encoding the local fingerprint we // instead generate a random uuid as the connection ufrag. // The only requirement here is that the ufrag and password // must be equal, which will allow the server to determine @@ -158,10 +178,10 @@ func (t *WebRTCTransport) Dial( se.SetICECredentials(ufrag, ufrag) api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) - pc, err := api.NewPeerConnection(t.webrtcConfig) + pc, err = api.NewPeerConnection(t.webrtcConfig) if err != nil { - log.Debugf("could not instantiate peerconnection: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not instantiate peerconnection: %v", err) } // We need to set negotiated = true for this channel on both @@ -172,22 +192,22 @@ func (t *WebRTCTransport) Dial( }) if err != nil { - _ = pc.Close() - log.Debugf("could not create datachannel: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not create datachannel: %v", err) } - opened := make(chan *DataChannel, 1) + opened := make(chan *dataChannel, 1) errChan := make(chan error, 1) dc.OnOpen(func() { detached, err := dc.Detach() if err != nil { - log.Debugf("could not detach datachannel: %v", err) + err = fmt.Errorf("could not detach datachannel: %v", err) errChan <- err + return } cp, err := dc.Transport().Transport().ICETransport().GetSelectedCandidatePair() - if err != nil { - log.Debugf("could not fetch selected candidate pair: %v", err) + if cp == nil || err != nil { + err = fmt.Errorf("could not fetch selected candidate pair: %v", err) errChan <- err return } @@ -198,16 +218,14 @@ func (t *WebRTCTransport) Dial( offer, err := pc.CreateOffer(nil) if err != nil { - _ = pc.Close() - log.Debugf("could not create offer: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not create offer: %v", err) } err = pc.SetLocalDescription(offer) if err != nil { - _ = pc.Close() - log.Debugf("could not set local description: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not set local description: %v", err) } answerSdpString := renderServerSdp(sdpArgs{ @@ -220,47 +238,86 @@ func (t *WebRTCTransport) Dial( answer := webrtc.SessionDescription{SDP: answerSdpString, Type: webrtc.SDPTypeAnswer} err = pc.SetRemoteDescription(answer) if err != nil { - _ = pc.Close() - log.Debugf("could not set remote description: %v", err) - return nil, err + defer cleanup() + return nil, fmt.Errorf("could not set remote description: %v", err) } - var dataChannel *DataChannel = nil + var dataChannel *dataChannel = nil select { case dataChannel = <-opened: case err = <-errChan: - _ = pc.Close() + defer cleanup() return nil, err case <-ctx.Done(): - _ = pc.Close() + scope.Done() + defer cleanup() return nil, ErrDataChannelTimeout } - // create noise transport for auth - noiseTpt, err := noise.New(t.privKey) + secureConn, err := t.noiseHandshake(ctx, pc, dataChannel, p, false) if err != nil { - log.Debugf("could not create noise transport: %v", err) + defer cleanup() return nil, err } - mb, err := encodeDTLSFingerprint(localFingerprint) + localAddr, err := manet.FromNetAddr(dataChannel.LocalAddr()) if err != nil { - log.Debugf("could not encode local fingerprint: %v", err) + defer cleanup() return nil, err } - secureConn, err := noiseTpt.SecureOutbound(context.Background(), dataChannel, p) + conn, err := newConnection( + pc, + t, + scope, + secureConn.LocalPeer(), + secureConn.LocalPrivateKey(), + localAddr, + secureConn.RemotePeer(), + secureConn.RemotePublicKey(), + remoteMultiaddr, + ) if err != nil { - log.Debugf("could not create secure outbound transport: %v", err) + defer cleanup() return nil, err } - // noise handshake - _, err = secureConn.Write([]byte(mb)) + return conn, nil +} + +func (t *WebRTCTransport) getCertificateFingerprint() (webrtc.DTLSFingerprint, error) { + fps, err := t.webrtcConfig.Certificates[0].GetFingerprints() if err != nil { - _ = pc.Close() - log.Debugf("could not write auth data: %v", err) - return nil, err + return webrtc.DTLSFingerprint{}, err + } + return fps[0], nil +} + +func (t *WebRTCTransport) noiseHandshake(ctx context.Context, pc *webrtc.PeerConnection, datachannel *dataChannel, peer peer.ID, inbound bool) (secureConn sec.SecureConn, err error) { + if inbound { + secureConn, err = t.noiseTpt.SecureInbound(ctx, datachannel, peer) + if err != nil { + return + } + } else { + secureConn, err = t.noiseTpt.SecureOutbound(ctx, datachannel, peer) + if err != nil { + return + } + } + localFingerprint, err := t.getCertificateFingerprint() + if err != nil { + return + } + encodedMultibase, err := encodeDTLSFingerprint(localFingerprint) + if err != nil { + return + } + + _, err = secureConn.Write([]byte(encodedMultibase)) + if err != nil { + return } + done := make(chan error, 1) go func() { buf := make([]byte, 2048) @@ -278,54 +335,11 @@ func (t *WebRTCTransport) Dial( select { case err = <-done: if err != nil { - _ = pc.Close() - log.Debugf("dialed: read failed: %v", err) - return nil, err + err = fmt.Errorf("dialed: read failed: %v", err) + return } - case <-time.After(10 * time.Second): - _ = pc.Close() + case <-ctx.Done(): return nil, ErrNoiseHandshakeTimeout } - - scope, err := t.rcmgr.OpenConnection(network.DirOutbound, false, remoteMultiaddr) - if err != nil { - _ = pc.Close() - return nil, err - } - err = scope.SetPeer(secureConn.RemotePeer()) - if err != nil { - _ = pc.Close() - scope.Done() - return nil, err - } - - localAddr, err := manet.FromNetAddr(dataChannel.LocalAddr()) - if err != nil { - return nil, err - } - conn, err := newConnection( - pc, - t, - scope, - secureConn.LocalPeer(), - secureConn.LocalPrivateKey(), - localAddr, - secureConn.RemotePeer(), - secureConn.RemotePublicKey(), - remoteMultiaddr, - ) - if err != nil { - _ = pc.Close() - return nil, err - } - - return conn, nil -} - -func (t *WebRTCTransport) getCertificateFingerprint() (webrtc.DTLSFingerprint, error) { - fps, err := t.webrtcConfig.Certificates[0].GetFingerprints() - if err != nil { - return webrtc.DTLSFingerprint{}, err - } - return fps[0], nil + return secureConn, nil } diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index 3a4d473d12..6adad63c21 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -18,8 +18,10 @@ type candidateAddr struct { ufrag string } -// UDPMuxNewAddr is an implementation of the interface -type UDPMuxNewAddr struct { +var _ ice.UDPMux = &udpMuxNewAddr{} + +// udpMuxNewAddr is an implementation of the interface +type udpMuxNewAddr struct { params ice.UDPMuxParams closedChan chan struct{} @@ -44,12 +46,12 @@ const maxAddrSize = 512 const receiveMTU = 8192 // NewUDPMuxNewAddr creates an implementation of UDPMux -func NewUDPMuxNewAddr(params ice.UDPMuxParams, newAddrChan chan candidateAddr) *UDPMuxNewAddr { +func NewUDPMuxNewAddr(params ice.UDPMuxParams, newAddrChan chan candidateAddr) *udpMuxNewAddr { if params.Logger == nil { params.Logger = logging.NewDefaultLoggerFactory().NewLogger("ice") } - m := &UDPMuxNewAddr{ + m := &udpMuxNewAddr{ addressMap: map[string]*udpMuxedConn{}, params: params, connsIPv4: make(map[string]*udpMuxedConn), @@ -71,13 +73,13 @@ func NewUDPMuxNewAddr(params ice.UDPMuxParams, newAddrChan chan candidateAddr) * } // LocalAddr returns the listening address of this UDPMuxNewAddr -func (m *UDPMuxNewAddr) LocalAddr() net.Addr { +func (m *udpMuxNewAddr) LocalAddr() net.Addr { return m.params.UDPConn.LocalAddr() } // GetConn returns a PacketConn given the connection's ufrag and network // creates the connection if an existing one can't be found -func (m *UDPMuxNewAddr) GetConn(ufrag string, isIPv6 bool) (net.PacketConn, error) { +func (m *udpMuxNewAddr) GetConn(ufrag string, isIPv6 bool) (net.PacketConn, error) { m.mu.Lock() defer m.mu.Unlock() @@ -105,7 +107,7 @@ func (m *UDPMuxNewAddr) GetConn(ufrag string, isIPv6 bool) (net.PacketConn, erro } // RemoveConnByUfrag stops and removes the muxed packet connection -func (m *UDPMuxNewAddr) RemoveConnByUfrag(ufrag string) { +func (m *udpMuxNewAddr) RemoveConnByUfrag(ufrag string) { removedConns := make([]*udpMuxedConn, 0, 2) // Keep lock section small to avoid deadlock with conn lock @@ -132,7 +134,7 @@ func (m *UDPMuxNewAddr) RemoveConnByUfrag(ufrag string) { } // IsClosed returns true if the mux had been closed -func (m *UDPMuxNewAddr) IsClosed() bool { +func (m *udpMuxNewAddr) IsClosed() bool { select { case <-m.closedChan: return true @@ -142,7 +144,7 @@ func (m *UDPMuxNewAddr) IsClosed() bool { } // Close the mux, no further connections could be created -func (m *UDPMuxNewAddr) Close() error { +func (m *udpMuxNewAddr) Close() error { var err error m.closeOnce.Do(func() { m.mu.Lock() @@ -163,7 +165,7 @@ func (m *UDPMuxNewAddr) Close() error { return err } -func (m *UDPMuxNewAddr) removeConn(key string) { +func (m *udpMuxNewAddr) removeConn(key string) { // keep lock section small to avoid deadlock with conn lock c := func() *udpMuxedConn { m.mu.Lock() @@ -195,11 +197,11 @@ func (m *UDPMuxNewAddr) removeConn(key string) { } } -func (m *UDPMuxNewAddr) writeTo(buf []byte, raddr net.Addr) (n int, err error) { +func (m *udpMuxNewAddr) writeTo(buf []byte, raddr net.Addr) (n int, err error) { return m.params.UDPConn.WriteTo(buf, raddr) } -func (m *UDPMuxNewAddr) registerConnForAddress(conn *udpMuxedConn, addr string) { +func (m *udpMuxNewAddr) registerConnForAddress(conn *udpMuxedConn, addr string) { if m.IsClosed() { return } @@ -216,7 +218,7 @@ func (m *UDPMuxNewAddr) registerConnForAddress(conn *udpMuxedConn, addr string) m.params.Logger.Debugf("Registered %s for %s", addr, conn.params.Key) } -func (m *UDPMuxNewAddr) createMuxedConn(key string) *udpMuxedConn { +func (m *udpMuxNewAddr) createMuxedConn(key string) *udpMuxedConn { c := newUDPMuxedConn(&udpMuxedConnParams{ Mux: m, Key: key, @@ -227,7 +229,7 @@ func (m *UDPMuxNewAddr) createMuxedConn(key string) *udpMuxedConn { return c } -func (m *UDPMuxNewAddr) connWorker() { +func (m *udpMuxNewAddr) connWorker() { logger := m.params.Logger defer func() { @@ -321,7 +323,7 @@ func ufragFromStunMessage(msg *stun.Message, local_ufrag bool) (string, error) { } } -func (m *UDPMuxNewAddr) getConn(ufrag string, isIPv6 bool) (val *udpMuxedConn, ok bool) { +func (m *udpMuxNewAddr) getConn(ufrag string, isIPv6 bool) (val *udpMuxedConn, ok bool) { if isIPv6 { val, ok = m.connsIPv6[ufrag] } else { diff --git a/p2p/transport/webrtc/udp_mux_conn.go b/p2p/transport/webrtc/udp_mux_conn.go index d0e7d29765..aa26299cc4 100644 --- a/p2p/transport/webrtc/udp_mux_conn.go +++ b/p2p/transport/webrtc/udp_mux_conn.go @@ -12,7 +12,7 @@ import ( ) type udpMuxedConnParams struct { - Mux *UDPMuxNewAddr + Mux *udpMuxNewAddr AddrPool *sync.Pool Key string LocalAddr net.Addr diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index 09a0a3af12..79ee7ad923 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -74,3 +74,4 @@ func encodeDTLSFingerprint(fp webrtc.DTLSFingerprint) (string, error) { encoded, err := mh.EncodeName(digest, algo) return multibase.Encode(multibase.Base16, encoded) } + From a0c0a8ae34745b8c3738536f228a8df38460e8f7 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 25 Jul 2022 17:06:26 +0530 Subject: [PATCH 08/50] read/write deadlines --- p2p/transport/webrtc/connection.go | 57 +++++--- p2p/transport/webrtc/datachannel.go | 181 ++++++++++++++++++-------- p2p/transport/webrtc/deadline.go | 77 +++++++++++ p2p/transport/webrtc/deadline_test.go | 47 +++++++ p2p/transport/webrtc/listener.go | 37 +++--- p2p/transport/webrtc/udp_mux.go | 5 + p2p/transport/webrtc/udp_mux_conn.go | 4 + p2p/transport/webrtc/util.go | 1 - 8 files changed, 318 insertions(+), 91 deletions(-) create mode 100644 p2p/transport/webrtc/deadline.go create mode 100644 p2p/transport/webrtc/deadline_test.go diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index 4ebee87bf0..ba55008f16 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -28,8 +28,12 @@ type connection struct { remoteKey ic.PubKey remoteMultiaddr ma.Multiaddr - closed chan struct{} + streams []network.MuxedStream + accept chan network.MuxedStream + + ctx context.Context + cancel context.CancelFunc } func newConnection( @@ -47,18 +51,9 @@ func newConnection( ) (*connection, error) { accept := make(chan network.MuxedStream, 1) - pc.OnDataChannel(func(dc *webrtc.DataChannel) { - dc.OnOpen(func() { - dcrwc, err := dc.Detach() - if err != nil { - // cannot accept a non-detached datachannel - return - } - accept <- newDataChannel(dcrwc, pc, nil, nil) - }) - }) + ctx, cancel := context.WithCancel(context.Background()) - return &connection{ + conn := &connection{ pc: pc, transport: transport, scope: scope, @@ -70,28 +65,47 @@ func newConnection( remotePeer: remotePeer, remoteKey: remoteKey, remoteMultiaddr: remoteMultiaddr, + ctx: ctx, + cancel: cancel, + streams: []network.MuxedStream{}, - closed: make(chan struct{}, 1), accept: accept, - }, nil + } + + pc.OnDataChannel(func(dc *webrtc.DataChannel) { + dc.OnOpen(func() { + dcrwc, err := dc.Detach() + if err != nil { + // cannot accept a non-detached datachannel + return + } + + stream := newDataChannel(dcrwc, pc, nil, nil) + conn.streams = append(conn.streams, stream) + accept <- stream + }) + }) + return conn, nil } // Implement network.MuxedConn func (c *connection) Close() error { + // cleanup routine + go func() { + for _, stream := range c.streams { + _ = stream.Close() + } + }() _ = c.pc.Close() c.scope.Done() - select { - case <-c.closed: - default: - close(c.closed) - } + c.cancel() return nil } func (c *connection) IsClosed() bool { select { - case <-c.closed: + case <-c.ctx.Done(): return true default: } @@ -129,13 +143,14 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error _ = dc.Close() return nil, ctx.Err() case r := <-result: + c.streams = append(c.streams, r.MuxedStream) return r.MuxedStream, r.error } } func (c *connection) AcceptStream() (network.MuxedStream, error) { select { - case <-c.closed: + case <-c.ctx.Done(): return nil, os.ErrClosed case stream := <-c.accept: return stream, nil diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 39e1ce24cb..5f028962ea 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -1,6 +1,8 @@ package libp2pwebrtc import ( + "bytes" + "context" "io" "net" "os" @@ -14,6 +16,18 @@ import ( var _ network.MuxedStream = &dataChannel{} +type ioresponse struct { + int + error +} + +type iorequest struct { + chunk []byte + done chan ioresponse +} + +const defaultReadBufferLen = 3000 + // Package pion detached data channel into a net.Conn // and then a network.MuxedStream type dataChannel struct { @@ -24,55 +38,120 @@ type dataChannel struct { raddr net.Addr closeRead chan struct{} closeWrite chan struct{} - readDeadline time.Time - writeDeadline time.Time - m sync.Mutex + readDeadline *deadline + writeDeadline *deadline + readBuffer *bytes.Buffer + readChan chan *iorequest + writeChan chan *iorequest + ctx context.Context + cancel context.CancelFunc + wg sync.WaitGroup } func newDataChannel( dc datachannel.ReadWriteCloser, pc *webrtc.PeerConnection, laddr, raddr net.Addr) *dataChannel { - return &dataChannel{ - dc: dc, - laddr: laddr, - raddr: raddr, - closeRead: make(chan struct{}, 1), - closeWrite: make(chan struct{}, 1), + ctx, cancel := context.WithCancel(context.Background()) + + var b bytes.Buffer + b.Grow(defaultReadBufferLen) + + result := &dataChannel{ + dc: dc, + laddr: laddr, + raddr: raddr, + readDeadline: newDeadline(), + writeDeadline: newDeadline(), + ctx: ctx, + cancel: cancel, + readBuffer: &b, + readChan: make(chan *iorequest, 20), + closeRead: make(chan struct{}), + closeWrite: make(chan struct{}), + } + + result.wg.Add(1) + go result.readLoop() + + return result +} + +func (d *dataChannel) readLoop() { + defer d.wg.Done() + for { + select { + case <-d.ctx.Done(): + return + case <-d.closeRead: + return + case request := <-d.readChan: + // bad request or readChan is closed + if request == nil { + return + } + // test for cancelled read + select { + case <-request.done: + continue + default: + } + + // if we have data from a previous successful read, return that data + if n, err := d.readBuffer.Read(request.chunk); err != io.EOF { + request.done <- ioresponse{n, nil} + continue + } + // read from the datachannel + n, err := d.dc.Read(request.chunk) + + select { + // the read has been cancelled, so write the data + // to the buffer instead + case <-request.done: + d.readBuffer.Write(request.chunk) + continue + default: + } + request.done <- ioresponse{n, err} + } } } func (d *dataChannel) Read(b []byte) (int, error) { select { + case <-d.ctx.Done(): + return 0, os.ErrClosed case <-d.closeRead: return 0, io.EOF + // case where deadline is in the past + case <-d.readDeadline.wait(): + return 0, os.ErrDeadlineExceeded default: } - d.m.Lock() - readDeadline := d.readDeadline - d.m.Unlock() - if readDeadline.IsZero() { - return d.dc.Read(b) - } else if readDeadline.Before(time.Now()) { + done := make(chan ioresponse) + + // try to queue the read + select { + case d.readChan <- &iorequest{chunk: b, done: done}: + case <-d.ctx.Done(): + close(done) + return 0, os.ErrClosed + case <-d.readDeadline.wait(): + close(done) return 0, os.ErrDeadlineExceeded } - done := make(chan struct { - int - error - }, 1) - go func() { - n, err := d.dc.Read(b) - log.Debug(string(b[:n])) - done <- struct { - int - error - }{n, err} - }() - + // wait for read completion and cancel the read + // request if it times out or the connection is + // closed select { - case <-time.After(readDeadline.Sub(time.Now())): + case <-d.ctx.Done(): + close(done) + return 0, os.ErrClosed + case <-d.readDeadline.wait(): + close(done) return 0, os.ErrDeadlineExceeded case result := <-done: return result.int, result.error @@ -81,24 +160,15 @@ func (d *dataChannel) Read(b []byte) (int, error) { func (d *dataChannel) Write(b []byte) (int, error) { select { + case <-d.ctx.Done(): + return 0, os.ErrClosed case <-d.closeWrite: - return 0, io.ErrClosedPipe + return 0, os.ErrClosed default: } - d.m.Lock() - writeDeadline := d.writeDeadline - d.m.Unlock() - if writeDeadline.IsZero() { - return d.dc.Write(b) - } else if writeDeadline.Before(time.Now()) { - return 0, os.ErrDeadlineExceeded - } + done := make(chan ioresponse) - done := make(chan struct { - int - error - }, 1) go func() { n, err := d.dc.Write(b) done <- struct { @@ -108,7 +178,9 @@ func (d *dataChannel) Write(b []byte) (int, error) { }() select { - case <-time.After(writeDeadline.Sub(time.Now())): + case <-d.ctx.Done(): + return 0, os.ErrClosed + case <-d.writeDeadline.wait(): return 0, os.ErrDeadlineExceeded case result := <-done: return result.int, result.error @@ -117,11 +189,17 @@ func (d *dataChannel) Write(b []byte) (int, error) { } func (d *dataChannel) Close() error { - return d.dc.Close() + d.cancel() + _ = d.CloseRead() + _ = d.CloseWrite() + err := d.dc.Close() + d.wg.Wait() + return err } func (d *dataChannel) CloseRead() error { select { + case <-d.ctx.Done(): case <-d.closeRead: default: close(d.closeRead) @@ -131,6 +209,7 @@ func (d *dataChannel) CloseRead() error { func (d *dataChannel) CloseWrite() error { select { + case <-d.ctx.Done(): case <-d.closeWrite: default: close(d.closeWrite) @@ -151,23 +230,17 @@ func (d *dataChannel) Reset() error { } func (d *dataChannel) SetDeadline(t time.Time) error { - d.m.Lock() - defer d.m.Unlock() - d.readDeadline = t - d.writeDeadline = t + d.SetReadDeadline(t) + d.SetWriteDeadline(t) return nil } func (d *dataChannel) SetReadDeadline(t time.Time) error { - d.m.Lock() - defer d.m.Unlock() - d.readDeadline = t + d.readDeadline.set(t) return nil } func (d *dataChannel) SetWriteDeadline(t time.Time) error { - d.m.Lock() - defer d.m.Unlock() - d.writeDeadline = t + d.writeDeadline.set(t) return nil } diff --git a/p2p/transport/webrtc/deadline.go b/p2p/transport/webrtc/deadline.go new file mode 100644 index 0000000000..171850de3b --- /dev/null +++ b/p2p/transport/webrtc/deadline.go @@ -0,0 +1,77 @@ +package libp2pwebrtc + +import ( + "sync" + "time" +) + +type deadline struct { + m sync.Mutex + timer *time.Timer + closeChan chan struct{} +} + +func newDeadline() *deadline { + return &deadline{ + timer: nil, + closeChan: make(chan struct{}), + } +} + +func (d *deadline) set(t time.Time) { + d.m.Lock() + defer d.m.Unlock() + // if an existing timer is set, stop the timer + // from firing and drain the channel + if d.timer != nil { + if !d.timer.Stop() { + <-d.closeChan + } + } + + // remove reference to existing stopped timer + // so it can be GC'd + d.timer = nil + + closed := isClosed(d.closeChan) + + // no deadline + if t.IsZero() { + if closed { + d.closeChan = make(chan struct{}) + } + return + } + + if duration := time.Until(t); duration < 0 { + if !closed { + close(d.closeChan) + } + } else { + if closed { + d.closeChan = make(chan struct{}) + } + d.timer = time.AfterFunc(duration, func() { + // check to ensure channel is not closed + // twice + select { + case <-d.closeChan: + default: + close(d.closeChan) + } + }) + } +} + +func (d *deadline) wait() <-chan struct{} { + return d.closeChan +} + +func isClosed(c <-chan struct{}) bool { + select { + case <-c: + return true + default: + } + return false +} diff --git a/p2p/transport/webrtc/deadline_test.go b/p2p/transport/webrtc/deadline_test.go new file mode 100644 index 0000000000..6a31145439 --- /dev/null +++ b/p2p/transport/webrtc/deadline_test.go @@ -0,0 +1,47 @@ +package libp2pwebrtc + +import ( + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +func TestDeadlineExtend(t *testing.T) { + dl := newDeadline() + start := time.Now() + dl.set(start.Add(500 * time.Millisecond)) + done := make(chan struct{}) + go func() { + <-dl.wait() + end := time.Now() + d := end.Sub(start) + require.GreaterOrEqual(t, d, 900*time.Millisecond) + require.LessOrEqual(t, d, 1100*time.Millisecond) + close(done) + }() + timer := time.AfterFunc(300*time.Millisecond, func() { + dl.set(start.Add(1000 * time.Millisecond)) + }) + <-done + timer.Stop() +} + +func TestDeadlineSetToPast(t *testing.T) { + dl := newDeadline() + start := time.Now() + done := make(chan struct{}) + go func() { + <-dl.wait() + end := time.Now() + d := end.Sub(start) + require.GreaterOrEqual(t, d, 200*time.Millisecond) + require.LessOrEqual(t, d, 400*time.Millisecond) + close(done) + }() + timer := time.AfterFunc(300*time.Millisecond, func() { + dl.set(start.Add(200 * time.Millisecond)) + }) + <-done + timer.Stop() +} diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 55d8d8509c..3f2b908169 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -32,6 +32,10 @@ var ( ) var ( + // since verification of the remote fingerprint is deferred until + // the noise handshake, a multihash with an arbitrary value is considered + // as the remote fingerprint during the intial PeerConnection connection + // establishment. defaultMultihash *multihash.DecodedMultihash = nil ) @@ -58,9 +62,11 @@ type listener struct { localFingerprint webrtc.DTLSFingerprint localFingerprintMultibase string mux *udpMuxNewAddr - closeChan chan struct{} + ctx context.Context + cancel context.CancelFunc localMultiaddr ma.Multiaddr connChan chan tpt.CapableConn + wg sync.WaitGroup } func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.PacketConn, config webrtc.Configuration) (*listener, error) { @@ -77,24 +83,32 @@ func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.Pack localMhBuf, _ := multihash.EncodeName(localMh, sdpHashToMh[localFingerprints[0].Algorithm]) localFpMultibase, _ := multibase.Encode(multibase.Base64, localMhBuf) + var wg sync.WaitGroup + ctx, cancel := context.WithCancel(context.Background()) + l := &listener{ mux: mux, transport: transport, config: config, localFingerprint: localFingerprints[0], localFingerprintMultibase: localFpMultibase, - closeChan: make(chan struct{}, 1), localMultiaddr: laddr, + ctx: ctx, + cancel: cancel, connChan: make(chan tpt.CapableConn, 20), + wg: wg, } + + wg.Add(1) go l.startAcceptLoop() return l, err } func (l *listener) startAcceptLoop() { + defer l.wg.Done() for { select { - case <-l.closeChan: + case <-l.ctx.Done(): return case addr := <-l.mux.newAddrChan: go func() { @@ -113,7 +127,7 @@ func (l *listener) startAcceptLoop() { func (l *listener) Accept() (tpt.CapableConn, error) { select { - case <-l.closeChan: + case <-l.ctx.Done(): return nil, os.ErrClosed case conn := <-l.connChan: return conn, nil @@ -121,12 +135,8 @@ func (l *listener) Accept() (tpt.CapableConn, error) { } func (l *listener) Close() error { - select { - case <-l.closeChan: - return nil - default: - } - close(l.closeChan) + l.cancel() + l.wg.Wait() return nil } @@ -141,7 +151,7 @@ func (l *listener) Multiaddr() ma.Multiaddr { func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableConn, error) { var ( scope network.ConnManagementScope - pc *webrtc.PeerConnection + pc *webrtc.PeerConnection ) cleanup := func() { @@ -244,15 +254,12 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC select { case <-ctx.Done(): defer cleanup() - return nil, ErrDataChannelTimeout + return nil, ctx.Err() case dc = <-dcChan: if dc == nil { defer cleanup() return nil, fmt.Errorf("should be unreachable") } - // clear to ignore opening of future data channels - // until noise handshake is complete - // pc.OnDataChannel(func(*webrtc.DataChannel) {}) } // we do not yet know A's peer ID so accept any inbound diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index 6adad63c21..c9075a53be 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -1,5 +1,10 @@ package libp2pwebrtc +// udpMuxNewAddr is mostly similar to UDPMuxDefault exported from +// pion/ice [https://github.com/pion/ice/blob/master/udp_mux.go] with +// the only difference being the additional channel to notify the libp2p +// transport of any STUN requests from unknown ufrags. + import ( "errors" "io" diff --git a/p2p/transport/webrtc/udp_mux_conn.go b/p2p/transport/webrtc/udp_mux_conn.go index aa26299cc4..9369a2899a 100644 --- a/p2p/transport/webrtc/udp_mux_conn.go +++ b/p2p/transport/webrtc/udp_mux_conn.go @@ -1,5 +1,9 @@ package libp2pwebrtc +// This file is copied as is from https://github.com/pion/ice/blob/master/udp_muxed_conn.go . +// The udpMuxedConn struct is not exported from pion/ice and is required for implementing +// the custom udp muxer. + import ( "encoding/binary" "io" diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index 79ee7ad923..09a0a3af12 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -74,4 +74,3 @@ func encodeDTLSFingerprint(fp webrtc.DTLSFingerprint) (string, error) { encoded, err := mh.EncodeName(digest, algo) return multibase.Encode(multibase.Base16, encoded) } - From 121fc9acfbf09e067baa16351cdee56eee339952 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 25 Jul 2022 17:16:17 +0530 Subject: [PATCH 09/50] fix streams --- p2p/transport/webrtc/connection.go | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index ba55008f16..c23529efcc 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -91,15 +91,19 @@ func newConnection( // Implement network.MuxedConn func (c *connection) Close() error { + if c.IsClosed() { + return nil + } + + _ = c.pc.Close() + c.scope.Done() + c.cancel() // cleanup routine go func() { for _, stream := range c.streams { _ = stream.Close() } }() - _ = c.pc.Close() - c.scope.Done() - c.cancel() return nil } @@ -113,6 +117,10 @@ func (c *connection) IsClosed() bool { } func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error) { + if c.IsClosed() { + return nil, os.ErrClosed + } + label := uuid.New().String() dc, err := c.pc.CreateDataChannel(label, nil) if err != nil { @@ -132,10 +140,12 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error return } + stream := newDataChannel(rwc, c.pc, nil, nil) + c.streams = append(c.streams, stream) result <- struct { network.MuxedStream error - }{newDataChannel(rwc, c.pc, nil, nil), err} + }{stream, err} }) select { @@ -143,7 +153,6 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error _ = dc.Close() return nil, ctx.Err() case r := <-result: - c.streams = append(c.streams, r.MuxedStream) return r.MuxedStream, r.error } } From 853f90ad72d5dcfa8f742210c6ac05241ab6b609 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 25 Jul 2022 20:48:22 +0530 Subject: [PATCH 10/50] change privkey algorithm to ecdsa p224 --- p2p/transport/webrtc/transport.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index e1cc8cc2b1..176ba61443 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -2,8 +2,9 @@ package libp2pwebrtc import ( "context" + "crypto/ecdsa" + "crypto/elliptic" "crypto/rand" - "crypto/rsa" "encoding/hex" "fmt" "net" @@ -40,7 +41,7 @@ var _ tpt.Transport = &WebRTCTransport{} type Option func(*WebRTCTransport) error func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*WebRTCTransport, error) { - pk, err := rsa.GenerateKey(rand.Reader, 2048) + pk, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader) if err != nil { return nil, fmt.Errorf("could not generate rsa key for cert: %v", err) } From 7a1bf7f131008fb09181fc0d8610864746f0801e Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 27 Jul 2022 18:39:39 +0530 Subject: [PATCH 11/50] switch to updated multiformats --- go.mod | 4 ++-- p2p/transport/webrtc/listener.go | 6 ++--- p2p/transport/webrtc/protocol.go | 21 ---------------- p2p/transport/webrtc/sdp.go | 4 ++-- p2p/transport/webrtc/transport.go | 4 ++-- p2p/transport/webrtc/util.go | 40 +++++++++++++++++++++---------- 6 files changed, 36 insertions(+), 43 deletions(-) delete mode 100644 p2p/transport/webrtc/protocol.go diff --git a/go.mod b/go.mod index 698bc6066b..0d7d8accc2 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( github.com/gogo/protobuf v1.3.2 github.com/golang/mock v1.6.0 github.com/google/gopacket v1.1.19 + github.com/google/uuid v1.3.0 github.com/gorilla/websocket v1.5.0 github.com/hashicorp/golang-lru v0.5.4 github.com/ipfs/go-cid v0.3.2 @@ -49,6 +50,7 @@ require ( github.com/multiformats/go-varint v0.0.6 github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 github.com/pion/datachannel v1.5.2 + github.com/pion/dtls/v2 v2.1.5 github.com/pion/ice/v2 v2.2.6 github.com/pion/logging v0.2.2 github.com/pion/stun v0.3.5 @@ -83,7 +85,6 @@ require ( github.com/godbus/dbus/v5 v5.1.0 // indirect github.com/golang/protobuf v1.5.2 // indirect github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect - github.com/google/uuid v1.3.0 // indirect github.com/huin/goupnp v1.0.3 // indirect github.com/jackpal/go-nat-pmp v1.0.2 // indirect github.com/jbenet/goprocess v0.1.4 // indirect @@ -102,7 +103,6 @@ require ( github.com/nxadm/tail v1.4.8 // indirect github.com/onsi/ginkgo v1.16.5 // indirect github.com/opencontainers/runtime-spec v1.0.2 // indirect - github.com/pion/dtls/v2 v2.1.5 // indirect github.com/pion/interceptor v0.1.11 // indirect github.com/pion/mdns v0.0.5 // indirect github.com/pion/randutil v0.1.0 // indirect diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 3f2b908169..db7b7661f3 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -80,7 +80,7 @@ func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.Pack if err != nil { return nil, err } - localMhBuf, _ := multihash.EncodeName(localMh, sdpHashToMh[localFingerprints[0].Algorithm]) + localMhBuf, _ := multihash.EncodeName(localMh, sdpHashToMh(localFingerprints[0].Algorithm)) localFpMultibase, _ := multibase.Encode(multibase.Base64, localMhBuf) var wg sync.WaitGroup @@ -319,8 +319,8 @@ func verifyRemoteFingerprint(raw []byte, remoteMultibaseMultihash string) bool { remoteFingerprint = maFingerprintToSdp(remoteFingerprint) // create fingerprint for remote certificate - hashAlgoName, ok := mhToSdpHash[decoded.Name] - if !ok { + hashAlgoName := mhToSdpHash(decoded.Name) + if hashAlgoName == "" { hashAlgoName = decoded.Name } diff --git a/p2p/transport/webrtc/protocol.go b/p2p/transport/webrtc/protocol.go deleted file mode 100644 index 0e4a328a6c..0000000000 --- a/p2p/transport/webrtc/protocol.go +++ /dev/null @@ -1,21 +0,0 @@ -// Temporary until this this protocol can be merged into go-multiaddr -package libp2pwebrtc - -import ( - ma "github.com/multiformats/go-multiaddr" -) - -const P_XWEBRTC = 0x115 - -var protocol = ma.Protocol{ - Name: "webrtc", - Code: P_XWEBRTC, - VCode: ma.CodeToVarint(P_XWEBRTC), -} - -func init() { - err := ma.AddProtocol(protocol) - if err != nil { - panic(err) - } -} diff --git a/p2p/transport/webrtc/sdp.go b/p2p/transport/webrtc/sdp.go index c663cbbde7..c270999a19 100644 --- a/p2p/transport/webrtc/sdp.go +++ b/p2p/transport/webrtc/sdp.go @@ -45,7 +45,7 @@ func renderClientSdp(args sdpArgs) string { args.Addr.Port, args.Ufrag, args.Password, - fingerprintSDP(args.Fingerprint), + fingerprintToSDP(args.Fingerprint), ) } @@ -73,7 +73,7 @@ func renderServerSdp(args sdpArgs) string { if args.Addr.IP.To4() == nil { ipVersion = "IP6" } - fp := fingerprintSDP(args.Fingerprint) + fp := fingerprintToSDP(args.Fingerprint) return fmt.Sprintf( SERVER_SDP, ipVersion, diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 176ba61443..a61a18366f 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -27,7 +27,7 @@ import ( var log = logging.Logger("webrtc-transport") -var dialMatcher = mafmt.And(mafmt.IP, mafmt.Base(ma.P_UDP), mafmt.Base(P_XWEBRTC), mafmt.Base(ma.P_CERTHASH)) +var dialMatcher = mafmt.And(mafmt.IP, mafmt.Base(ma.P_UDP), mafmt.Base(ma.P_WEBRTC), mafmt.Base(ma.P_CERTHASH)) type WebRTCTransport struct { webrtcConfig webrtc.Configuration @@ -60,7 +60,7 @@ func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*We } func (t *WebRTCTransport) Protocols() []int { - return []int{P_XWEBRTC} + return []int{ma.P_WEBRTC} } func (t *WebRTCTransport) Proxy() bool { diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index 09a0a3af12..83cc4f8aed 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -10,16 +10,30 @@ import ( "github.com/pion/webrtc/v3" ) -var mhToSdpHash = map[string]string{ - "sha1": "sha1", - "sha2-256": "sha-256", - "md5": "md5", +func mhToSdpHash(mh string) string { + switch mh { + case "sha1": + return "sha1" + case "sha2-256": + return "sha-256" + case "md5": + return "md5" + default: + return "" + } } -var sdpHashToMh = map[string]string{ - "sha-256": "sha2-256", - "sha1": "sha1", - "md5": "md5", +func sdpHashToMh(sdpHash string) string { + switch sdpHash { + case "sha-256": + return "sha2-256" + case "sha1": + return "sha1" + case "md5": + return "md5" + default: + return "" + } } func maFingerprintToSdp(fp string) string { @@ -38,13 +52,13 @@ func maFingerprintToSdp(fp string) string { return result } -func fingerprintSDP(fp *mh.DecodedMultihash) string { +func fingerprintToSDP(fp *mh.DecodedMultihash) string { if fp == nil { return "" } fpDigest := maFingerprintToSdp(hex.EncodeToString(fp.Digest)) - fpAlgo, ok := mhToSdpHash[strings.ToLower(fp.Name)] - if !ok { + fpAlgo := mhToSdpHash(strings.ToLower(fp.Name)) + if fpAlgo == "" { fpAlgo = strings.ToLower(fp.Name) } return fpAlgo + " " + fpDigest @@ -67,8 +81,8 @@ func encodeDTLSFingerprint(fp webrtc.DTLSFingerprint) (string, error) { if err != nil { return "", err } - algo, ok := sdpHashToMh[strings.ToLower(fp.Algorithm)] - if !ok { + algo := sdpHashToMh(strings.ToLower(fp.Algorithm)) + if algo == "" { algo = fp.Algorithm } encoded, err := mh.EncodeName(digest, algo) From f1610567edeb0d9f228412ce0fd8fef35c0da265 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Fri, 29 Jul 2022 12:41:30 +0530 Subject: [PATCH 12/50] change mtu --- p2p/transport/webrtc/listener.go | 7 ++++++- p2p/transport/webrtc/udp_mux.go | 2 +- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index db7b7661f3..ea10b618ef 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -215,7 +215,12 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC defer cleanup() return nil, err } - pc.SetLocalDescription(answer) + + err = pc.SetLocalDescription(answer) + if err != nil { + defer cleanup() + return nil, err + } // await peerconnection connected state select { diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index c9075a53be..03b41c8a0d 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -48,7 +48,7 @@ type udpMuxNewAddr struct { } const maxAddrSize = 512 -const receiveMTU = 8192 +const receiveMTU = 1500 // NewUDPMuxNewAddr creates an implementation of UDPMux func NewUDPMuxNewAddr(params ice.UDPMuxParams, newAddrChan chan candidateAddr) *udpMuxNewAddr { From 82b4fff163ef7d63da6f23e4dc4c8f03fa9b83b0 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 15 Aug 2022 12:28:14 +0530 Subject: [PATCH 13/50] use noise prologue mechanism --- p2p/transport/webrtc/connection.go | 3 +- p2p/transport/webrtc/listener.go | 44 +----------- p2p/transport/webrtc/transport.go | 92 ++++++++++++++++---------- p2p/transport/webrtc/transport_test.go | 5 ++ 4 files changed, 67 insertions(+), 77 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index c23529efcc..7bde7221d9 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -71,8 +71,8 @@ func newConnection( accept: accept, } - pc.OnDataChannel(func(dc *webrtc.DataChannel) { + log.Debugf("[%s] incoming datachannel: %s", localPeer, dc.Label()) dc.OnOpen(func() { dcrwc, err := dc.Detach() if err != nil { @@ -131,6 +131,7 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error error }, 1) dc.OnOpen(func() { + log.Debugf("[%s] opened new datachannel: %s", c.localPeer, dc.Label()) rwc, err := dc.Detach() if err != nil { result <- struct { diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index ea10b618ef..8b3c810cf1 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -2,7 +2,6 @@ package libp2pwebrtc import ( "context" - "crypto/x509" "encoding/hex" "errors" "fmt" @@ -20,7 +19,6 @@ import ( "github.com/multiformats/go-multibase" "github.com/multiformats/go-multihash" - "github.com/pion/dtls/v2/pkg/crypto/fingerprint" "github.com/pion/ice/v2" "github.com/pion/webrtc/v3" ) @@ -55,7 +53,7 @@ func init() { } -/// implement net.Listener +// / implement net.Listener type listener struct { transport *WebRTCTransport config webrtc.Configuration @@ -83,7 +81,6 @@ func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.Pack localMhBuf, _ := multihash.EncodeName(localMh, sdpHashToMh(localFingerprints[0].Algorithm)) localFpMultibase, _ := multibase.Encode(multibase.Base64, localMhBuf) - var wg sync.WaitGroup ctx, cancel := context.WithCancel(context.Background()) l := &listener{ @@ -96,10 +93,9 @@ func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.Pack ctx: ctx, cancel: cancel, connChan: make(chan tpt.CapableConn, 20), - wg: wg, } - wg.Add(1) + l.wg.Add(1) go l.startAcceptLoop() return l, err } @@ -302,39 +298,3 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return conn, nil } - -func verifyRemoteFingerprint(raw []byte, remoteMultibaseMultihash string) bool { - cert, err := x509.ParseCertificate(raw) - if err != nil { - log.Debugf("could not parse certificate: %v", err) - return false - } - - _, remoteData, err := multibase.Decode(remoteMultibaseMultihash) - if err != nil { - log.Debugf("could not decode multibase: %v", err) - return false - } - decoded, err := multihash.Decode(remoteData) - if err != nil { - log.Debugf("could not decode multihash: %v", err) - return false - } - remoteFingerprint := hex.EncodeToString(decoded.Digest) - remoteFingerprint = maFingerprintToSdp(remoteFingerprint) - - // create fingerprint for remote certificate - hashAlgoName := mhToSdpHash(decoded.Name) - if hashAlgoName == "" { - hashAlgoName = decoded.Name - } - - hashAlgo, err := fingerprint.HashFromString(hashAlgoName) - if err != nil { - log.Debugf("could not find hash algo: %s %v", hashAlgoName, err) - return false - } - fp, err := fingerprint.Fingerprint(cert, hashAlgo) - - return strings.EqualFold(fp, remoteFingerprint) -} diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index a61a18366f..ee9f99dc10 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -1,13 +1,17 @@ package libp2pwebrtc import ( + "bytes" "context" "crypto/ecdsa" "crypto/elliptic" "crypto/rand" + "crypto/x509" "encoding/hex" "fmt" "net" + "sort" + "strings" "github.com/google/uuid" ic "github.com/libp2p/go-libp2p-core/crypto" @@ -21,7 +25,9 @@ import ( ma "github.com/multiformats/go-multiaddr" mafmt "github.com/multiformats/go-multiaddr-fmt" manet "github.com/multiformats/go-multiaddr/net" + "github.com/multiformats/go-multihash" + "github.com/pion/dtls/v2/pkg/crypto/fingerprint" "github.com/pion/webrtc/v3" ) @@ -293,54 +299,72 @@ func (t *WebRTCTransport) getCertificateFingerprint() (webrtc.DTLSFingerprint, e return fps[0], nil } -func (t *WebRTCTransport) noiseHandshake(ctx context.Context, pc *webrtc.PeerConnection, datachannel *dataChannel, peer peer.ID, inbound bool) (secureConn sec.SecureConn, err error) { - if inbound { - secureConn, err = t.noiseTpt.SecureInbound(ctx, datachannel, peer) - if err != nil { - return - } - } else { - secureConn, err = t.noiseTpt.SecureOutbound(ctx, datachannel, peer) - if err != nil { - return - } +func (t *WebRTCTransport) generateNoisePrologue(pc *webrtc.PeerConnection) ([]byte, error) { + raw := pc.SCTP().Transport().GetRemoteCertificate() + cert, err := x509.ParseCertificate(raw) + if err != nil { + return nil, err } - localFingerprint, err := t.getCertificateFingerprint() + // guess hash algorithm + localFp, err := t.getCertificateFingerprint() if err != nil { - return + return nil, err } - encodedMultibase, err := encodeDTLSFingerprint(localFingerprint) + + hashAlgo, err := fingerprint.HashFromString(localFp.Algorithm) if err != nil { - return + log.Debugf("could not find hash algo: %s %v", localFp.Algorithm, err) + return nil, err } + remoteFp, err := fingerprint.Fingerprint(cert, hashAlgo) + remoteFp = strings.ToLower(remoteFp) - _, err = secureConn.Write([]byte(encodedMultibase)) + mhAlgoName := sdpHashToMh(localFp.Algorithm) + if mhAlgoName == "" { + mhAlgoName = localFp.Algorithm + } + + local := strings.ReplaceAll(localFp.Value, ":", "") + remote := strings.ReplaceAll(remoteFp, ":", "") + localEncoded, err := multihash.EncodeName([]byte(local), mhAlgoName) if err != nil { - return + log.Debugf("could not encode multihash for local fingerprint") + return nil, err } + remoteEncoded, err := multihash.EncodeName([]byte(remote), mhAlgoName) + if err != nil { + log.Debugf("could not encode multihash for remote fingerprint") + return nil, err + } + + b := [][]byte{localEncoded, remoteEncoded} + sort.Slice(b, func(i, j int) bool { + return bytes.Compare(b[i], b[j]) < 0 + }) + result := append([]byte("libp2p-webrtc-noise:"), b[0]...) + result = append(result, b[1]...) + return result, nil +} - done := make(chan error, 1) - go func() { - buf := make([]byte, 2048) - n, err := secureConn.Read(buf) +func (t *WebRTCTransport) noiseHandshake(ctx context.Context, pc *webrtc.PeerConnection, datachannel *dataChannel, peer peer.ID, inbound bool) (secureConn sec.SecureConn, err error) { + prologue, err := t.generateNoisePrologue(pc) + if err != nil { + return nil, fmt.Errorf("could not generate noise prologue: %v", err) + } + sessionTransport, err := t.noiseTpt.WithSessionOptions(noise.Prologue(prologue)) + if err != nil { + return nil, fmt.Errorf("could not instantiate noise session transport: %v", err) + } + if inbound { + secureConn, err = sessionTransport.SecureInbound(ctx, datachannel, peer) if err != nil { - done <- err - } - remoteFpMultibase := string(buf[:n]) - if !verifyRemoteFingerprint(pc.SCTP().Transport().GetRemoteCertificate(), remoteFpMultibase) { - done <- fmt.Errorf("could not verify remote fingerprint") + return } - close(done) - }() - - select { - case err = <-done: + } else { + secureConn, err = sessionTransport.SecureOutbound(ctx, datachannel, peer) if err != nil { - err = fmt.Errorf("dialed: read failed: %v", err) return } - case <-ctx.Done(): - return nil, ErrNoiseHandshakeTimeout } return secureConn, nil } diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 644ea182ce..9d87091a99 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -3,6 +3,7 @@ package libp2pwebrtc import ( "context" "testing" + "time" "github.com/libp2p/go-libp2p-core/crypto" "github.com/libp2p/go-libp2p-core/network" @@ -136,7 +137,10 @@ func TestTransportDialerCanCreateStreams(t *testing.T) { go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) + t.Log("dialer creating stream") + time.Sleep(100 * time.Millisecond) stream, err := conn.OpenStream(context.Background()) + t.Log("dialer created stream") require.NoError(t, err) _, err = stream.Write([]byte("test")) require.NoError(t, err) @@ -145,6 +149,7 @@ func TestTransportDialerCanCreateStreams(t *testing.T) { lconn, err := listener.Accept() require.NoError(t, err) require.Equal(t, connectingPeer, lconn.RemotePeer()) + t.Log("accepted connection") stream, err := lconn.AcceptStream() require.NoError(t, err) From bc879d4ffdd1f75b5f091723628a2cac1be01c94 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 15 Aug 2022 23:23:08 +0530 Subject: [PATCH 14/50] debug --- p2p/transport/webrtc/transport_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 9d87091a99..26d86d6cf6 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -61,6 +61,7 @@ func TestTransportCanListen(t *testing.T) { tr1, connectingPeer := getTransport(t) go func() { + t.Log(listener.Multiaddr()) _, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) }() From c0b2a84403e82511efdff067d905dc58947ade7e Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 15 Aug 2022 23:33:03 +0530 Subject: [PATCH 15/50] fix staticcheck --- p2p/transport/webrtc/datachannel.go | 2 -- p2p/transport/webrtc/listener.go | 4 ++++ p2p/transport/webrtc/transport.go | 3 +++ p2p/transport/webrtc/transport_test.go | 4 ---- p2p/transport/webrtc/udp_mux_test.go | 2 +- p2p/transport/webrtc/util.go | 3 +++ 6 files changed, 11 insertions(+), 7 deletions(-) diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 5f028962ea..066abd2403 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -32,7 +32,6 @@ const defaultReadBufferLen = 3000 // and then a network.MuxedStream type dataChannel struct { // TODO: Are these circular references okay? - pc *webrtc.PeerConnection dc datachannel.ReadWriteCloser laddr net.Addr raddr net.Addr @@ -42,7 +41,6 @@ type dataChannel struct { writeDeadline *deadline readBuffer *bytes.Buffer readChan chan *iorequest - writeChan chan *iorequest ctx context.Context cancel context.CancelFunc wg sync.WaitGroup diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 8b3c810cf1..e4cbcd03b4 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -234,6 +234,10 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC Negotiated: func(v bool) *bool { return &v }(true), ID: func(v uint16) *uint16 { return &v }(1), }) + if err != nil { + defer cleanup() + return nil, err + } var handshakeOnce sync.Once handshakeChannel.OnOpen(func() { diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index ee9f99dc10..20b3f8454f 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -317,6 +317,9 @@ func (t *WebRTCTransport) generateNoisePrologue(pc *webrtc.PeerConnection) ([]by return nil, err } remoteFp, err := fingerprint.Fingerprint(cert, hashAlgo) + if err != nil { + return nil, err + } remoteFp = strings.ToLower(remoteFp) mhAlgoName := sdpHashToMh(localFp.Algorithm) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 26d86d6cf6..9439744bf6 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -61,7 +61,6 @@ func TestTransportCanListen(t *testing.T) { tr1, connectingPeer := getTransport(t) go func() { - t.Log(listener.Multiaddr()) _, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) }() @@ -138,10 +137,8 @@ func TestTransportDialerCanCreateStreams(t *testing.T) { go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) - t.Log("dialer creating stream") time.Sleep(100 * time.Millisecond) stream, err := conn.OpenStream(context.Background()) - t.Log("dialer created stream") require.NoError(t, err) _, err = stream.Write([]byte("test")) require.NoError(t, err) @@ -150,7 +147,6 @@ func TestTransportDialerCanCreateStreams(t *testing.T) { lconn, err := listener.Accept() require.NoError(t, err) require.Equal(t, connectingPeer, lconn.RemotePeer()) - t.Log("accepted connection") stream, err := lconn.AcceptStream() require.NoError(t, err) diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go index 4adf1b329c..89336d9eea 100644 --- a/p2p/transport/webrtc/udp_mux_test.go +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -51,7 +51,7 @@ func TestUdpMuxNewAddrNewStun(t *testing.T) { if err != nil { t.Fatal(err) } - if strings.ToLower(hash) != strings.ToLower(certhash) { + if !strings.EqualFold(hash, certhash) { t.Fatalf("expected hash: %s, received: %s", certhash, hash) } case <-time.After(20 * time.Second): diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index 83cc4f8aed..f5e3359e11 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -86,5 +86,8 @@ func encodeDTLSFingerprint(fp webrtc.DTLSFingerprint) (string, error) { algo = fp.Algorithm } encoded, err := mh.EncodeName(digest, algo) + if err != nil { + return "", err + } return multibase.Encode(multibase.Base16, encoded) } From d6cd3a3ca4d882b324624b1b8adbe3ac7b90271e Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 15 Aug 2022 23:54:00 +0530 Subject: [PATCH 16/50] log --- p2p/transport/webrtc/listener.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index e4cbcd03b4..54b2530522 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -131,6 +131,11 @@ func (l *listener) Accept() (tpt.CapableConn, error) { } func (l *listener) Close() error { + select { + case <-l.ctx.Done(): + return nil + default: + } l.cancel() l.wg.Wait() return nil From 9b55ae4e30be8a38d8622588608272041e1192d9 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 16 Aug 2022 18:12:28 +0530 Subject: [PATCH 17/50] change multibase to b58btc --- p2p/transport/webrtc/listener.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 54b2530522..cab6d56666 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -79,7 +79,7 @@ func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.Pack return nil, err } localMhBuf, _ := multihash.EncodeName(localMh, sdpHashToMh(localFingerprints[0].Algorithm)) - localFpMultibase, _ := multibase.Encode(multibase.Base64, localMhBuf) + localFpMultibase, _ := multibase.Encode(multibase.Base58BTC, localMhBuf) ctx, cancel := context.WithCancel(context.Background()) From 5ef0b928ee45eb576864a59f317775312f97592b Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 17 Aug 2022 00:06:12 +0530 Subject: [PATCH 18/50] fix tests on non-linux systems --- p2p/transport/webrtc/listener.go | 1 + p2p/transport/webrtc/test_constants.go | 8 ++++++++ p2p/transport/webrtc/test_constants_linux.go | 8 ++++++++ p2p/transport/webrtc/transport_test.go | 11 ++++++----- p2p/transport/webrtc/udp_mux_test.go | 2 +- 5 files changed, 24 insertions(+), 6 deletions(-) create mode 100644 p2p/transport/webrtc/test_constants.go create mode 100644 p2p/transport/webrtc/test_constants_linux.go diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index cab6d56666..12f45afc2a 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -110,6 +110,7 @@ func (l *listener) startAcceptLoop() { go func() { ctx, cancelFunc := context.WithTimeout(context.Background(), 20*time.Second) defer cancelFunc() + log.Debugf("new incoming connection: %v", addr) conn, err := l.accept(ctx, addr) if err != nil { log.Debugf("could not accept connection: %v", err) diff --git a/p2p/transport/webrtc/test_constants.go b/p2p/transport/webrtc/test_constants.go new file mode 100644 index 0000000000..7edd3f5ac4 --- /dev/null +++ b/p2p/transport/webrtc/test_constants.go @@ -0,0 +1,8 @@ +//go:build !linux +// +build !linux + +package libp2pwebrtc + +import "net" + +var listenerIp = net.IPv4(127, 0, 0, 1) diff --git a/p2p/transport/webrtc/test_constants_linux.go b/p2p/transport/webrtc/test_constants_linux.go new file mode 100644 index 0000000000..f0057c4bf1 --- /dev/null +++ b/p2p/transport/webrtc/test_constants_linux.go @@ -0,0 +1,8 @@ +//go:build linux +// +build linux + +package libp2pwebrtc + +import "net" + +var listenerIp = net.IPv4(0, 0, 0, 0) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 9439744bf6..b8ffb06587 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -2,6 +2,7 @@ package libp2pwebrtc import ( "context" + "fmt" "testing" "time" @@ -51,9 +52,9 @@ func TestTransportCanDial(t *testing.T) { } } -func TestTransportCanListen(t *testing.T) { +func TestTransportCanListenSingle(t *testing.T) { tr, listeningPeer := getTransport(t) - listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/127.0.0.1/udp/0/webrtc") require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) @@ -74,7 +75,7 @@ func TestTransportCanListen(t *testing.T) { func TestTransportCanListenMultiple(t *testing.T) { tr, listeningPeer := getTransport(t) - listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) @@ -96,7 +97,7 @@ func TestTransportCanListenMultiple(t *testing.T) { func TestTransportListenerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) - listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) @@ -127,7 +128,7 @@ func TestTransportListenerCanCreateStreams(t *testing.T) { func TestTransportDialerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) - listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/udp/0/webrtc") + listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go index 89336d9eea..fb9a3ba77f 100644 --- a/p2p/transport/webrtc/udp_mux_test.go +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -14,7 +14,7 @@ import ( ) func TestUdpMuxNewAddrNewStun(t *testing.T) { - serverConn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4(0, 0, 0, 0), Port: 0}) + serverConn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: listenerIp, Port: 0}) if err != nil { panic(err) } From 382bb88d0332e25ed7cad5d2e7bf114a6fedaaa6 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 17 Aug 2022 01:31:46 +0530 Subject: [PATCH 19/50] fix windows --- p2p/transport/webrtc/test_constants.go | 25 +++++++++++++++++++++++++ p2p/transport/webrtc/transport.go | 1 + p2p/transport/webrtc/transport_test.go | 3 ++- p2p/transport/webrtc/udp_mux_test.go | 2 +- 4 files changed, 29 insertions(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/test_constants.go b/p2p/transport/webrtc/test_constants.go index 7edd3f5ac4..8518a168d2 100644 --- a/p2p/transport/webrtc/test_constants.go +++ b/p2p/transport/webrtc/test_constants.go @@ -6,3 +6,28 @@ package libp2pwebrtc import "net" var listenerIp = net.IPv4(127, 0, 0, 1) + +func init() { + ifaces, err := net.Interfaces() + if err != nil { + return + } + for _, iface := range ifaces { + log.Debugf("checking interface: %s", iface.Name) + if iface.Flags&net.FlagUp == 0 { + continue + } + addrs, err := iface.Addrs() + if err != nil { + return + } + for _, addr := range addrs { + if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.IsPrivate() { + if ipnet.IP.To4() != nil { + listenerIp = ipnet.IP.To4() + return + } + } + } + } +} diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 20b3f8454f..428270fbdd 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -91,6 +91,7 @@ func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { if err != nil { return nil, fmt.Errorf("could not listen on udp: %v", err) } + log.Debugf("[webrtc] listening on address: %s", socket.LocalAddr()) // construct multiaddr listenerMultiaddr, err := manet.FromNetAddr(socket.LocalAddr()) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index b8ffb06587..e064c4a65d 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -54,7 +54,7 @@ func TestTransportCanDial(t *testing.T) { func TestTransportCanListenSingle(t *testing.T) { tr, listeningPeer := getTransport(t) - listenMultiaddr, err := multiaddr.NewMultiaddr("/ip4/127.0.0.1/udp/0/webrtc") + listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) @@ -62,6 +62,7 @@ func TestTransportCanListenSingle(t *testing.T) { tr1, connectingPeer := getTransport(t) go func() { + t.Logf("dialing: %s", listener.Multiaddr()) _, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) }() diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go index fb9a3ba77f..f819d3b1ca 100644 --- a/p2p/transport/webrtc/udp_mux_test.go +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -19,7 +19,7 @@ func TestUdpMuxNewAddrNewStun(t *testing.T) { panic(err) } - clientConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 0}) + clientConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: listenerIp, Port: 0}) loggerFactory := logging.NewDefaultLoggerFactory() loggerFactory.Writer = os.Stdout loggerFactory.DefaultLogLevel = logging.LogLevelDebug From 3f16cf58191d6dbeef0b22845f9f7681f2edcdd0 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 17 Aug 2022 01:39:11 +0530 Subject: [PATCH 20/50] fix dialer ip in linux --- p2p/transport/webrtc/test_constants.go | 2 ++ p2p/transport/webrtc/test_constants_linux.go | 1 + p2p/transport/webrtc/udp_mux_test.go | 2 +- 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/p2p/transport/webrtc/test_constants.go b/p2p/transport/webrtc/test_constants.go index 8518a168d2..25778247f6 100644 --- a/p2p/transport/webrtc/test_constants.go +++ b/p2p/transport/webrtc/test_constants.go @@ -6,6 +6,7 @@ package libp2pwebrtc import "net" var listenerIp = net.IPv4(127, 0, 0, 1) +var dialerIp = net.IPv4(127, 0, 0, 1) func init() { ifaces, err := net.Interfaces() @@ -25,6 +26,7 @@ func init() { if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.IsPrivate() { if ipnet.IP.To4() != nil { listenerIp = ipnet.IP.To4() + dialerIp = listenerIp return } } diff --git a/p2p/transport/webrtc/test_constants_linux.go b/p2p/transport/webrtc/test_constants_linux.go index f0057c4bf1..f507001778 100644 --- a/p2p/transport/webrtc/test_constants_linux.go +++ b/p2p/transport/webrtc/test_constants_linux.go @@ -6,3 +6,4 @@ package libp2pwebrtc import "net" var listenerIp = net.IPv4(0, 0, 0, 0) +var dialerIp = net.IPv4(127, 0, 0, 1) diff --git a/p2p/transport/webrtc/udp_mux_test.go b/p2p/transport/webrtc/udp_mux_test.go index f819d3b1ca..eedf518ffc 100644 --- a/p2p/transport/webrtc/udp_mux_test.go +++ b/p2p/transport/webrtc/udp_mux_test.go @@ -19,7 +19,7 @@ func TestUdpMuxNewAddrNewStun(t *testing.T) { panic(err) } - clientConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: listenerIp, Port: 0}) + clientConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: dialerIp, Port: 0}) loggerFactory := logging.NewDefaultLoggerFactory() loggerFactory.Writer = os.Stdout loggerFactory.DefaultLogLevel = logging.LogLevelDebug From 2bdc93c2e4664ab33f2411f8bc0daa6187d852f4 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Fri, 26 Aug 2022 22:31:23 +0530 Subject: [PATCH 21/50] fix race condition in accepting streams --- examples/webrtc/README.md | 0 examples/webrtc/go.mod | 3 + examples/webrtc/main.go | 94 ++++++ p2p/transport/webrtc/connection.go | 61 ++-- p2p/transport/webrtc/datachannel.go | 346 ++++++++++++++------- p2p/transport/webrtc/listener.go | 39 +-- p2p/transport/webrtc/pb/Makefile | 9 + p2p/transport/webrtc/pb/message.pb.go | 412 +++++++++++++++++++++++++ p2p/transport/webrtc/pb/message.proto | 21 ++ p2p/transport/webrtc/test_constants.go | 9 +- p2p/transport/webrtc/transport.go | 41 ++- p2p/transport/webrtc/transport_test.go | 25 +- p2p/transport/webrtc/util.go | 2 +- 13 files changed, 896 insertions(+), 166 deletions(-) create mode 100644 examples/webrtc/README.md create mode 100644 examples/webrtc/go.mod create mode 100644 examples/webrtc/main.go create mode 100644 p2p/transport/webrtc/pb/Makefile create mode 100644 p2p/transport/webrtc/pb/message.pb.go create mode 100644 p2p/transport/webrtc/pb/message.proto diff --git a/examples/webrtc/README.md b/examples/webrtc/README.md new file mode 100644 index 0000000000..e69de29bb2 diff --git a/examples/webrtc/go.mod b/examples/webrtc/go.mod new file mode 100644 index 0000000000..13caca91c4 --- /dev/null +++ b/examples/webrtc/go.mod @@ -0,0 +1,3 @@ +module github.com/libp2p/go-libp2p/examples/webrtc + +go 1.19 diff --git a/examples/webrtc/main.go b/examples/webrtc/main.go new file mode 100644 index 0000000000..576e0dea00 --- /dev/null +++ b/examples/webrtc/main.go @@ -0,0 +1,94 @@ +package main + +import ( + "context" + "fmt" + "os" + "os/signal" + "syscall" + // "time" + + // "github.com/libp2p/go-libp2p/p2p/protocol/identify" + "github.com/libp2p/go-libp2p/p2p/protocol/ping" + + // "github.com/libp2p/go-libp2p/p2p/protocol/ping" + + "github.com/libp2p/go-libp2p" + "github.com/libp2p/go-libp2p-core/host" + "github.com/libp2p/go-libp2p-core/peer" + webrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc" +) + +func main() { + host := createHost() + defer host.Close() + fmt.Println("listening on: ", host.Network().ListenAddresses()) + ctx, cancel := context.WithCancel(context.Background()) + + go dialHost(ctx, host) + + fmt.Println("press Ctrl+C to quit") + ch := make(chan os.Signal, 1) + signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT) + <-ch + cancel() +} + +func dialHost(ctx context.Context, server host.Host) { + client, err := libp2p.New( + libp2p.Transport(webrtc.New), + libp2p.DisableRelay(), + libp2p.Ping(true), + ) + if err != nil { + panic(err) + } + + if err = server.ID().Validate(); err != nil { + panic(err) + } + + remoteInfo := peer.AddrInfo{ + ID: server.ID(), + Addrs: server.Network().ListenAddresses(), + } + + fmt.Println("=========================== connecting ==============================") + err = client.Connect(context.Background(), remoteInfo) + if err != nil { + panic(err) + } + fmt.Println("============================ connected ==============================") + + resultChan := ping.Ping(ctx, server, server.ID()) + + for i := 0; i < 5; i++{ + select { + case <-ctx.Done(): + case result := <-resultChan: + if result.Error != nil { + fmt.Println("ping error", result.Error) + } else { + fmt.Println("pinged", remoteInfo.Addrs, " in ", result.RTT) + } + } + + } + +} + +func createHost() host.Host { + h, err := libp2p.New( + libp2p.Transport(webrtc.New), + libp2p.ListenAddrStrings( + "/ip4/0.0.0.0/udp/0/webrtc", // a UDP endpoint for the WebRTC Transport + ), + libp2p.DisableRelay(), + libp2p.Ping(true), + ) + if err != nil { + panic(err) + } + + return h +} diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index 7bde7221d9..17c620059a 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -3,6 +3,7 @@ package libp2pwebrtc import ( "context" "os" + "sync" "github.com/google/uuid" ic "github.com/libp2p/go-libp2p-core/crypto" @@ -28,12 +29,13 @@ type connection struct { remoteKey ic.PubKey remoteMultiaddr ma.Multiaddr - streams []network.MuxedStream + streams map[uint16]*dataChannel accept chan network.MuxedStream ctx context.Context cancel context.CancelFunc + m sync.Mutex } func newConnection( @@ -49,7 +51,7 @@ func newConnection( remoteKey ic.PubKey, remoteMultiaddr ma.Multiaddr, ) (*connection, error) { - accept := make(chan network.MuxedStream, 1) + accept := make(chan network.MuxedStream, 10) ctx, cancel := context.WithCancel(context.Background()) @@ -67,24 +69,28 @@ func newConnection( remoteMultiaddr: remoteMultiaddr, ctx: ctx, cancel: cancel, - streams: []network.MuxedStream{}, + streams: make(map[uint16]*dataChannel), accept: accept, } + pc.OnDataChannel(func(dc *webrtc.DataChannel) { log.Debugf("[%s] incoming datachannel: %s", localPeer, dc.Label()) dc.OnOpen(func() { - dcrwc, err := dc.Detach() + detached, err := dc.Detach() if err != nil { - // cannot accept a non-detached datachannel + log.Warn("[%s] could not detach data channel: %s", localPeer, dc.Label()) return } - - stream := newDataChannel(dcrwc, pc, nil, nil) - conn.streams = append(conn.streams, stream) + stream := newDataChannel(detached, dc, pc, nil, nil) + conn.m.Lock() + conn.streams[*dc.ID()] = stream + conn.m.Unlock() accept <- stream }) + dc.SetBufferedAmountLowThreshold(0) }) + // log.Infof("localMultiaddr: %s", conn.localMultiaddr) return conn, nil } @@ -95,15 +101,13 @@ func (c *connection) Close() error { return nil } - _ = c.pc.Close() c.scope.Done() - c.cancel() // cleanup routine - go func() { - for _, stream := range c.streams { - _ = stream.Close() - } - }() + for _, stream := range c.streams { + _ = stream.Close() + } + c.cancel() + _ = c.pc.Close() return nil } @@ -122,7 +126,11 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error } label := uuid.New().String() - dc, err := c.pc.CreateDataChannel(label, nil) + dc, err := c.pc.CreateDataChannel(label, &webrtc.DataChannelInit{ + Ordered: func(b bool) *bool { return &b }(true), + MaxRetransmits: func(x uint16) *uint16 { return &x }(100), + }) + dc.SetBufferedAmountLowThreshold(0) if err != nil { return nil, err } @@ -131,18 +139,20 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error error }, 1) dc.OnOpen(func() { - log.Debugf("[%s] opened new datachannel: %s", c.localPeer, dc.Label()) - rwc, err := dc.Detach() + // log.Infof("[%s] opened new datachannel: %d, %s", c.localPeer, dc.ID(), dc.Label()) + detached, err := dc.Detach() if err != nil { + log.Warn("[%s] could not detach data channel: %s", c.localPeer, dc.Label()) result <- struct { network.MuxedStream error }{nil, err} return } - - stream := newDataChannel(rwc, c.pc, nil, nil) - c.streams = append(c.streams, stream) + stream := newDataChannel(detached, dc, c.pc, nil, nil) + c.m.Lock() + c.streams[*dc.ID()] = stream + c.m.Unlock() result <- struct { network.MuxedStream error @@ -172,6 +182,11 @@ func (c *connection) LocalPeer() peer.ID { return c.localPeer } +// only used during setup +func (c *connection) setRemotePeer(id peer.ID) { + c.remotePeer = id +} + func (c *connection) LocalPrivateKey() ic.PrivKey { return c.privKey } @@ -184,6 +199,10 @@ func (c *connection) RemotePublicKey() ic.PubKey { return c.remoteKey } +func (c *connection) setRemotePublicKey(key ic.PubKey) { + c.remoteKey = key +} + // implement network.ConnMultiaddrs func (c *connection) LocalMultiaddr() ma.Multiaddr { return c.localMultiaddr diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 066abd2403..6a518b666b 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -6,10 +6,14 @@ import ( "io" "net" "os" + "sync" + "sync/atomic" "time" "github.com/libp2p/go-libp2p-core/network" + pb "github.com/libp2p/go-libp2p/p2p/transport/webrtc/pb" + protoio "github.com/libp2p/go-msgio/protoio" "github.com/pion/datachannel" "github.com/pion/webrtc/v3" ) @@ -26,193 +30,315 @@ type iorequest struct { done chan ioresponse } -const defaultReadBufferLen = 3000 +const defaultReadBufferLen = 8192 // Package pion detached data channel into a net.Conn // and then a network.MuxedStream type dataChannel struct { // TODO: Are these circular references okay? dc datachannel.ReadWriteCloser + channel *webrtc.DataChannel laddr net.Addr raddr net.Addr closeRead chan struct{} closeWrite chan struct{} readDeadline *deadline writeDeadline *deadline - readBuffer *bytes.Buffer readChan chan *iorequest ctx context.Context cancel context.CancelFunc wg sync.WaitGroup + m sync.Mutex + readBuf bytes.Buffer + wc atomic.Bool } func newDataChannel( dc datachannel.ReadWriteCloser, + channel *webrtc.DataChannel, pc *webrtc.PeerConnection, laddr, raddr net.Addr) *dataChannel { ctx, cancel := context.WithCancel(context.Background()) - var b bytes.Buffer - b.Grow(defaultReadBufferLen) - result := &dataChannel{ dc: dc, + channel: channel, laddr: laddr, raddr: raddr, readDeadline: newDeadline(), writeDeadline: newDeadline(), ctx: ctx, cancel: cancel, - readBuffer: &b, readChan: make(chan *iorequest, 20), closeRead: make(chan struct{}), closeWrite: make(chan struct{}), } - result.wg.Add(1) - go result.readLoop() + channel.OnClose(func() { + log.Errorf("remote closed stream") + // result.Close() + }) + + // channel.OnBufferedAmountLow(func() { + // log.Infof("[%s] buffered amount low: amount: %d, threshold: %d", channel.Label(), channel.BufferedAmount(), channel.BufferedAmountLowThreshold()) + // }) + + // result.wg.Add(1) + // go result.readLoop() return result } -func (d *dataChannel) readLoop() { - defer d.wg.Done() - for { - select { - case <-d.ctx.Done(): - return - case <-d.closeRead: - return - case request := <-d.readChan: - // bad request or readChan is closed - if request == nil { - return - } - // test for cancelled read - select { - case <-request.done: - continue - default: - } - - // if we have data from a previous successful read, return that data - if n, err := d.readBuffer.Read(request.chunk); err != io.EOF { - request.done <- ioresponse{n, nil} - continue - } - // read from the datachannel - n, err := d.dc.Read(request.chunk) - - select { - // the read has been cancelled, so write the data - // to the buffer instead - case <-request.done: - d.readBuffer.Write(request.chunk) - continue - default: - } - request.done <- ioresponse{n, err} - } - } -} +// func (d *dataChannel) readLoop() { +// defer d.wg.Done() +// rdr := protoio.NewDelimitedReader(d.dc, defaultReadBufferLen) +// for { +// select { +// case <-d.ctx.Done(): +// return +// case request := <-d.readChan: +// // bad request or readChan is closed +// if request == nil { +// return +// } +// // test for cancelled read +// select { +// case <-request.done: +// continue +// default: +// } + +// var msg pb.Message +// err := rdr.ReadMsg(&msg) +// if err != nil && err != io.EOF { +// log.Errorf("%v", err) +// request.done <- ioresponse{0, err} +// continue +// } +// log.Warnf("flag: %v", msg.Flag) +// if msg.Flag != nil { +// switch msg.GetFlag() { +// case pb.Message_CLOSE_WRITE: +// log.Warnf("remote closed write") +// d.dc.Close() +// case pb.Message_CLOSE_READ: +// case pb.Message_RESET: +// log.Errorf("remote reset the connection") +// } +// } +// if err == io.EOF { +// select { +// case <-request.done: +// continue +// default: +// } +// request.done <- ioresponse {0, err} +// continue +// } +// if msg.Flag == nil && msg.GetMessage() == nil { +// panic("what??") +// } + +// select { +// case <-d.closeRead: +// request.done <- ioresponse {0, io.EOF} +// continue +// // the read has been cancelled, so discard +// case <-request.done: +// continue +// default: +// } +// rcv := msg.Message +// if rcv == nil { +// rcv = []byte{} +// } +// copied := copy(request.chunk, rcv) +// request.done <- ioresponse{copied, nil} +// } +// } +// } func (d *dataChannel) Read(b []byte) (int, error) { - select { - case <-d.ctx.Done(): - return 0, os.ErrClosed - case <-d.closeRead: - return 0, io.EOF - // case where deadline is in the past - case <-d.readDeadline.wait(): - return 0, os.ErrDeadlineExceeded - default: + // select { + // case <-d.ctx.Done(): + // return 0, os.ErrClosed + // case <-d.closeRead: + // return 0, io.EOF + // // case where deadline is in the past + // case <-d.readDeadline.wait(): + // return 0, os.ErrDeadlineExceeded + // default: + // } + + // done := make(chan ioresponse) + + // // try to queue the read + // select { + // case d.readChan <- &iorequest{chunk: b, done: done}: + // case <-d.ctx.Done(): + // close(done) + // return 0, os.ErrClosed + // case <-d.readDeadline.wait(): + // close(done) + // return 0, os.ErrDeadlineExceeded + // } + + // // wait for read completion and cancel the read + // // request if it times out or the connection is + // // closed + // select { + // case <-d.ctx.Done(): + // close(done) + // return 0, os.ErrClosed + // case <-d.readDeadline.wait(): + // close(done) + // return 0, os.ErrDeadlineExceeded + // case result := <-done: + // // log.Infof("read result: %d %v", result.int, result.error) + // // log.Debugf("read: %s" ,string(b[:result.int])) + // return result.int, result.error + // } + + // method 2 + initialRead, ierr := d.readBuf.Read(b) + if ierr == io.EOF && d.wc.Load() { + return initialRead, io.EOF } - - done := make(chan ioresponse) - - // try to queue the read - select { - case d.readChan <- &iorequest{chunk: b, done: done}: - case <-d.ctx.Done(): - close(done) - return 0, os.ErrClosed - case <-d.readDeadline.wait(): - close(done) - return 0, os.ErrDeadlineExceeded + if initialRead > 0 { + return initialRead, nil } - - // wait for read completion and cancel the read - // request if it times out or the connection is - // closed - select { - case <-d.ctx.Done(): - close(done) - return 0, os.ErrClosed - case <-d.readDeadline.wait(): - close(done) - return 0, os.ErrDeadlineExceeded - case result := <-done: - return result.int, result.error + var msg pb.Message + rdr := protoio.NewDelimitedReader(d.dc, 1500) + err := rdr.ReadMsg(&msg) + if err != nil { + return initialRead, err + } + copied := copy(b[initialRead:], msg.GetMessage()) + d.readBuf.Write(msg.GetMessage()[copied:]) + if msg.Flag != nil && msg.GetFlag() == pb.Message_CLOSE_WRITE { + d.wc.Store(true) + return copied, nil } + return copied, err } +// func (d *dataChannel) Read(b []byte) (int, error) { +// for { +// d.bufm.Lock() +// n, err := d.readBuffer.Read(b) +// // log.Infof("reading from buffer: %d %v", n, err) +// d.bufm.Unlock() +// if err == io.EOF && !d.isReadClosed() { +// err = nil +// } +// if n > 0 { +// log.Infof("received %d bytes: %s", n, string(b)) +// return n, err +// } +// if n == 0 { +// select { +// case <-d.ctx.Done(): +// return 0, io.EOF +// case <-d.closeRead: +// return n, io.EOF +// case <-d.readDeadline.wait(): +// return 0, os.ErrDeadlineExceeded +// case <-d.msgChan: + +// } +// } +// } +// } + func (d *dataChannel) Write(b []byte) (int, error) { select { case <-d.ctx.Done(): return 0, os.ErrClosed + case <-d.writeDeadline.wait(): + return 0, os.ErrDeadlineExceeded case <-d.closeWrite: return 0, os.ErrClosed default: } - done := make(chan ioresponse) - - go func() { - n, err := d.dc.Write(b) - done <- struct { - int - error - }{n, err} - }() + // done := make(chan ioresponse) + + // go func() { + // wr := protoio.NewDelimitedWriter(d.dc) + // err := wr.WriteMsg( + // &pb.Message{ + // Message: b, + // }) + // if err != nil { + // log.Warnf("write error: %v", err) + // } + // done <- struct { + // int + // error + // }{len(b), err} + // }() + + // select { + // case <-d.ctx.Done(): + // return 0, os.ErrClosed + // case <-d.writeDeadline.wait(): + // return 0, os.ErrDeadlineExceeded + // case result := <-done: + // fmt.Printf("[%s] wrote: %s\n", d.uuid, string(b)) + // return result.int, result.error + + // } + + // fmt.Printf("[%s][%s] writing: %s\n", d.uuid, d.channel.Label(), string(b)) + wr := protoio.NewDelimitedWriter(d.dc) + _ = wr.WriteMsg( + &pb.Message{ + Message: b, + }) + // fmt.Printf("[%s][%s] wrote: %s\n", d.uuid, d.channel.Label(), string(b)) + return len(b), nil +} +func (d *dataChannel) Close() error { select { case <-d.ctx.Done(): - return 0, os.ErrClosed - case <-d.writeDeadline.wait(): - return 0, os.ErrDeadlineExceeded - case result := <-done: - return result.int, result.error - + return nil + default: } -} - -func (d *dataChannel) Close() error { + err := d.channel.Close() + d.CloseWrite() d.cancel() - _ = d.CloseRead() - _ = d.CloseWrite() - err := d.dc.Close() - d.wg.Wait() + // d.wg.Wait() return err } func (d *dataChannel) CloseRead() error { select { case <-d.ctx.Done(): + return nil case <-d.closeRead: + return nil default: close(d.closeRead) } + return nil } func (d *dataChannel) CloseWrite() error { select { case <-d.ctx.Done(): + return nil case <-d.closeWrite: + return nil default: close(d.closeWrite) } - return nil + wr := protoio.NewDelimitedWriter(d.dc) + err := wr.WriteMsg(&pb.Message{ + Flag: pb.Message_CLOSE_WRITE.Enum(), + }) + return err } func (d *dataChannel) LocalAddr() net.Addr { @@ -224,6 +350,7 @@ func (d *dataChannel) RemoteAddr() net.Addr { } func (d *dataChannel) Reset() error { + log.Errorf("stream reset") return d.Close() } @@ -242,3 +369,12 @@ func (d *dataChannel) SetWriteDeadline(t time.Time) error { d.writeDeadline.set(t) return nil } + +func (d *dataChannel) isReadClosed() bool { + select { + case <-d.closeRead: + return true + default: + } + return false +} diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 12f45afc2a..0f560a3eb8 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -110,7 +110,6 @@ func (l *listener) startAcceptLoop() { go func() { ctx, cancelFunc := context.WithTimeout(context.Background(), 20*time.Second) defer cancelFunc() - log.Debugf("new incoming connection: %v", addr) conn, err := l.accept(ctx, addr) if err != nil { log.Debugf("could not accept connection: %v", err) @@ -254,6 +253,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC } dcChan <- newDataChannel( detached, + handshakeChannel, pc, l.mux.LocalAddr(), addr.raddr, @@ -273,38 +273,41 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC } } - // we do not yet know A's peer ID so accept any inbound - secureConn, err := l.transport.noiseHandshake(ctx, pc, dc, "", true) + conn, err := newConnection( + pc, + l.transport, + scope, + l.transport.localPeerId, + l.transport.privKey, + l.localMultiaddr, + "", + nil, + remoteMultiaddr, + ) + if err != nil { defer cleanup() return nil, err } - // earliest point where we know the remote's peerID - err = scope.SetPeer(secureConn.RemotePeer()) + // we do not yet know A's peer ID so accept any inbound + secureConn, err := l.transport.noiseHandshake(ctx, pc, dc, "", true) if err != nil { defer cleanup() return nil, err } - conn, err := newConnection( - pc, - l.transport, - scope, - secureConn.LocalPeer(), - secureConn.LocalPrivateKey(), - l.localMultiaddr, - secureConn.RemotePeer(), - secureConn.RemotePublicKey(), - remoteMultiaddr, - ) - + // earliest point where we know the remote's peerID + err = scope.SetPeer(secureConn.RemotePeer()) if err != nil { defer cleanup() return nil, err } - defer func() { _ = dc.Close() }() + conn.setRemotePeer(secureConn.RemotePeer()) + conn.setRemotePublicKey(secureConn.RemotePublicKey()) + + // defer func() { _ = dc.Close() }() return conn, nil } diff --git a/p2p/transport/webrtc/pb/Makefile b/p2p/transport/webrtc/pb/Makefile new file mode 100644 index 0000000000..9555a98a49 --- /dev/null +++ b/p2p/transport/webrtc/pb/Makefile @@ -0,0 +1,9 @@ +pbgos := $(patsubst %.proto,%.pb.go,$(wildcard *.proto)) + +all: $(pbgos) + +%.pb.go: %.proto + protoc --gogofast_out=. --proto_path=$(GOPATH)/src:. $< + +clean: + rm -f *.pb.go diff --git a/p2p/transport/webrtc/pb/message.pb.go b/p2p/transport/webrtc/pb/message.pb.go new file mode 100644 index 0000000000..2c4c747ab1 --- /dev/null +++ b/p2p/transport/webrtc/pb/message.pb.go @@ -0,0 +1,412 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: message.proto + +package webrtc_pb + +import ( + fmt "fmt" + proto "github.com/gogo/protobuf/proto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Message_Flag int32 + +const ( + // The local endpoint will no longer send messages. + Message_CLOSE_WRITE Message_Flag = 0 + // The local endpoint will no longer read messages. + Message_CLOSE_READ Message_Flag = 1 + // The local endpoint abruptly terminates the stream. The remote endpoint + // may discard any in-flight data. + Message_RESET Message_Flag = 2 +) + +var Message_Flag_name = map[int32]string{ + 0: "CLOSE_WRITE", + 1: "CLOSE_READ", + 2: "RESET", +} + +var Message_Flag_value = map[string]int32{ + "CLOSE_WRITE": 0, + "CLOSE_READ": 1, + "RESET": 2, +} + +func (x Message_Flag) Enum() *Message_Flag { + p := new(Message_Flag) + *p = x + return p +} + +func (x Message_Flag) String() string { + return proto.EnumName(Message_Flag_name, int32(x)) +} + +func (x *Message_Flag) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Message_Flag_value, data, "Message_Flag") + if err != nil { + return err + } + *x = Message_Flag(value) + return nil +} + +func (Message_Flag) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_33c57e4bae7b9afd, []int{0, 0} +} + +type Message struct { + Flag *Message_Flag `protobuf:"varint,1,opt,name=flag,enum=webrtc.pb.Message_Flag" json:"flag,omitempty"` + Message []byte `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Message) Reset() { *m = Message{} } +func (m *Message) String() string { return proto.CompactTextString(m) } +func (*Message) ProtoMessage() {} +func (*Message) Descriptor() ([]byte, []int) { + return fileDescriptor_33c57e4bae7b9afd, []int{0} +} +func (m *Message) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Message.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Message) XXX_Merge(src proto.Message) { + xxx_messageInfo_Message.Merge(m, src) +} +func (m *Message) XXX_Size() int { + return m.Size() +} +func (m *Message) XXX_DiscardUnknown() { + xxx_messageInfo_Message.DiscardUnknown(m) +} + +var xxx_messageInfo_Message proto.InternalMessageInfo + +func (m *Message) GetFlag() Message_Flag { + if m != nil && m.Flag != nil { + return *m.Flag + } + return Message_CLOSE_WRITE +} + +func (m *Message) GetMessage() []byte { + if m != nil { + return m.Message + } + return nil +} + +func init() { + proto.RegisterEnum("webrtc.pb.Message_Flag", Message_Flag_name, Message_Flag_value) + proto.RegisterType((*Message)(nil), "webrtc.pb.Message") +} + +func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) } + +var fileDescriptor_33c57e4bae7b9afd = []byte{ + // 163 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcd, 0x4d, 0x2d, 0x2e, + 0x4e, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x2c, 0x4f, 0x4d, 0x2a, 0x2a, + 0x49, 0xd6, 0x2b, 0x48, 0x52, 0x6a, 0x61, 0xe4, 0x62, 0xf7, 0x85, 0x48, 0x0a, 0x69, 0x73, 0xb1, + 0xa4, 0xe5, 0x24, 0xa6, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x19, 0x89, 0xeb, 0xc1, 0x55, 0xe9, + 0x41, 0x55, 0xe8, 0xb9, 0xe5, 0x24, 0xa6, 0x07, 0x81, 0x15, 0x09, 0x49, 0x70, 0xb1, 0x43, 0x0d, + 0x95, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x09, 0x82, 0x71, 0x95, 0x8c, 0xb8, 0x58, 0x40, 0xea, 0x84, + 0xf8, 0xb9, 0xb8, 0x9d, 0x7d, 0xfc, 0x83, 0x5d, 0xe3, 0xc3, 0x83, 0x3c, 0x43, 0x5c, 0x05, 0x18, + 0x84, 0xf8, 0xb8, 0xb8, 0x20, 0x02, 0x41, 0xae, 0x8e, 0x2e, 0x02, 0x8c, 0x42, 0x9c, 0x5c, 0xac, + 0x41, 0xae, 0xc1, 0xae, 0x21, 0x02, 0x4c, 0x4e, 0x3c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, + 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0x23, 0x20, 0x00, 0x00, 0xff, 0xff, 0x58, 0x33, 0x0d, 0x31, 0xaf, + 0x00, 0x00, 0x00, +} + +func (m *Message) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Message) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Message != nil { + i -= len(m.Message) + copy(dAtA[i:], m.Message) + i = encodeVarintMessage(dAtA, i, uint64(len(m.Message))) + i-- + dAtA[i] = 0x12 + } + if m.Flag != nil { + i = encodeVarintMessage(dAtA, i, uint64(*m.Flag)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func encodeVarintMessage(dAtA []byte, offset int, v uint64) int { + offset -= sovMessage(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Message) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Flag != nil { + n += 1 + sovMessage(uint64(*m.Flag)) + } + if m.Message != nil { + l = len(m.Message) + n += 1 + l + sovMessage(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func sovMessage(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozMessage(x uint64) (n int) { + return sovMessage(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Message) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Message: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Flag", wireType) + } + var v Message_Flag + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= Message_Flag(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Flag = &v + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthMessage + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthMessage + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Message = append(m.Message[:0], dAtA[iNdEx:postIndex]...) + if m.Message == nil { + m.Message = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipMessage(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthMessage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipMessage(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMessage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMessage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowMessage + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthMessage + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupMessage + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthMessage + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthMessage = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowMessage = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupMessage = fmt.Errorf("proto: unexpected end of group") +) diff --git a/p2p/transport/webrtc/pb/message.proto b/p2p/transport/webrtc/pb/message.proto new file mode 100644 index 0000000000..ecf3075c35 --- /dev/null +++ b/p2p/transport/webrtc/pb/message.proto @@ -0,0 +1,21 @@ +syntax = "proto2"; + +/* option go_package = "."; */ + +package webrtc.pb; + +message Message { + enum Flag { + // The local endpoint will no longer send messages. + CLOSE_WRITE = 0; + // The local endpoint will no longer read messages. + CLOSE_READ = 1; + // The local endpoint abruptly terminates the stream. The remote endpoint + // may discard any in-flight data. + RESET = 2; + } + + optional Flag flag=1; + + optional bytes message = 2; +} diff --git a/p2p/transport/webrtc/test_constants.go b/p2p/transport/webrtc/test_constants.go index 25778247f6..24b187b162 100644 --- a/p2p/transport/webrtc/test_constants.go +++ b/p2p/transport/webrtc/test_constants.go @@ -5,8 +5,13 @@ package libp2pwebrtc import "net" -var listenerIp = net.IPv4(127, 0, 0, 1) -var dialerIp = net.IPv4(127, 0, 0, 1) +// non-linux builds need to bind to a non-loopback interface +// to accept incoming connections. 0.0.0.0 does not work since +// Pion will bind to a local interface which is not loopback +// and there may not be a route from, say 192.168.0.0/16 to 0.0.0.0. + +var listenerIp = net.IPv4(0, 0, 0, 0) +var dialerIp = net.IPv4(0, 0, 0, 0) func init() { ifaces, err := net.Interfaces() diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 428270fbdd..7a362ad423 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -40,6 +40,7 @@ type WebRTCTransport struct { rcmgr network.ResourceManager privKey ic.PrivKey noiseTpt *noise.Transport + localPeerId peer.ID } var _ tpt.Transport = &WebRTCTransport{} @@ -47,6 +48,10 @@ var _ tpt.Transport = &WebRTCTransport{} type Option func(*WebRTCTransport) error func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*WebRTCTransport, error) { + localPeerId, err := peer.IDFromPrivateKey(privKey) + if err != nil { + return nil, fmt.Errorf("could not get local peer ID: %v", err) + } pk, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader) if err != nil { return nil, fmt.Errorf("could not generate rsa key for cert: %v", err) @@ -62,11 +67,11 @@ func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*We if err != nil { return nil, fmt.Errorf("unable to create the noise transport") } - return &WebRTCTransport{rcmgr: rcmgr, webrtcConfig: config, privKey: privKey, noiseTpt: noiseTpt}, nil + return &WebRTCTransport{rcmgr: rcmgr, webrtcConfig: config, privKey: privKey, noiseTpt: noiseTpt, localPeerId: localPeerId}, nil } func (t *WebRTCTransport) Protocols() []int { - return []int{ma.P_WEBRTC} + return []int{ma.P_WEBRTC, ma.P_CERTHASH} } func (t *WebRTCTransport) Proxy() bool { @@ -78,6 +83,11 @@ func (t *WebRTCTransport) CanDial(addr ma.Multiaddr) bool { } func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { + addr, wrtcComponent := ma.SplitLast(addr) + isWebrtc := wrtcComponent.Equal(ma.StringCast("/webrtc")) + if !isWebrtc { + return nil, fmt.Errorf("must listen on webrtc multiaddr") + } nw, host, err := manet.DialArgs(addr) if err != nil { return nil, fmt.Errorf("listener could not fetch dialargs: %v", err) @@ -91,7 +101,6 @@ func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { if err != nil { return nil, fmt.Errorf("could not listen on udp: %v", err) } - log.Debugf("[webrtc] listening on address: %s", socket.LocalAddr()) // construct multiaddr listenerMultiaddr, err := manet.FromNetAddr(socket.LocalAddr()) @@ -120,6 +129,8 @@ func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { listenerMultiaddr = listenerMultiaddr.Encapsulate(certMultiaddress) + // log.Debugf("can be dialed at: %s", listenerMultiaddr.Encapsulate(ma.StringCast(fmt.Sprintf("/p2p/%s", t.localPeerId)))) + return newListener( t, listenerMultiaddr, @@ -221,7 +232,7 @@ func (t *WebRTCTransport) Dial( } laddr := &net.UDPAddr{IP: net.ParseIP(cp.Local.Address), Port: int(cp.Local.Port)} - opened <- newDataChannel(detached, pc, laddr, raddr) + opened <- newDataChannel(detached, dc, pc, laddr, raddr) }) offer, err := pc.CreateOffer(nil) @@ -262,32 +273,34 @@ func (t *WebRTCTransport) Dial( return nil, ErrDataChannelTimeout } - secureConn, err := t.noiseHandshake(ctx, pc, dataChannel, p, false) - if err != nil { - defer cleanup() - return nil, err - } - localAddr, err := manet.FromNetAddr(dataChannel.LocalAddr()) if err != nil { defer cleanup() return nil, err } + conn, err := newConnection( pc, t, scope, - secureConn.LocalPeer(), - secureConn.LocalPrivateKey(), + t.localPeerId, + t.privKey, localAddr, - secureConn.RemotePeer(), - secureConn.RemotePublicKey(), + p, + nil, remoteMultiaddr, ) if err != nil { defer cleanup() return nil, err } + secureConn, err := t.noiseHandshake(ctx, pc, dataChannel, p, false) + if err != nil { + defer cleanup() + return nil, err + } + + conn.setRemotePublicKey(secureConn.RemotePublicKey()) return conn, nil } diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index e064c4a65d..3208279a48 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -25,7 +25,7 @@ func getTransport(t *testing.T) (tpt.Transport, peer.ID) { return transport, peerID } -func TestTransportCanDial(t *testing.T) { +func TestTransportWebRTCCanDial(t *testing.T) { tr, _ := getTransport(t) invalid := []string{ "/ip4/1.2.3.4/udp/1234/webrtc", @@ -52,7 +52,22 @@ func TestTransportCanDial(t *testing.T) { } } -func TestTransportCanListenSingle(t *testing.T) { +func TestTransportWebRTC_ListenFailsOnNonWebRTCMultiaddr(t *testing.T) { + tr, _ := getTransport(t) + testAddrs := []string{ + "/ip4/0.0.0.0/udp/0", + "/ip4/0.0.0.0/tcp/0/wss", + } + for _, addr := range testAddrs { + listenMultiaddr, err := multiaddr.NewMultiaddr(addr) + require.NoError(t, err) + listener, err := tr.Listen(listenMultiaddr) + require.Error(t, err) + require.Nil(t, listener) + } +} + +func TestTransportWebRTC_CanListenSingle(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) @@ -74,7 +89,7 @@ func TestTransportCanListenSingle(t *testing.T) { require.Equal(t, connectingPeer, conn.RemotePeer()) } -func TestTransportCanListenMultiple(t *testing.T) { +func TestTransportWebRTCCanListenMultiple(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) @@ -96,7 +111,7 @@ func TestTransportCanListenMultiple(t *testing.T) { } } -func TestTransportListenerCanCreateStreams(t *testing.T) { +func TestTransportWebRTCListenerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) @@ -127,7 +142,7 @@ func TestTransportListenerCanCreateStreams(t *testing.T) { require.NoError(t, err) } -func TestTransportDialerCanCreateStreams(t *testing.T) { +func TestTransportWebRTCDialerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) diff --git a/p2p/transport/webrtc/util.go b/p2p/transport/webrtc/util.go index f5e3359e11..712b111d12 100644 --- a/p2p/transport/webrtc/util.go +++ b/p2p/transport/webrtc/util.go @@ -89,5 +89,5 @@ func encodeDTLSFingerprint(fp webrtc.DTLSFingerprint) (string, error) { if err != nil { return "", err } - return multibase.Encode(multibase.Base16, encoded) + return multibase.Encode(multibase.Base58BTC, encoded) } From 17e16d1644bef1b17e7e7c92932bee0ffe201012 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 6 Sep 2022 16:00:45 +0530 Subject: [PATCH 22/50] use message callback instead of detached data channels --- p2p/transport/webrtc/connection.go | 52 ++-- p2p/transport/webrtc/datachannel.go | 400 +++++++++------------------- p2p/transport/webrtc/listener.go | 13 +- p2p/transport/webrtc/transport.go | 16 +- 4 files changed, 167 insertions(+), 314 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index 17c620059a..df9f56b1dc 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -76,21 +76,18 @@ func newConnection( pc.OnDataChannel(func(dc *webrtc.DataChannel) { log.Debugf("[%s] incoming datachannel: %s", localPeer, dc.Label()) + id := *dc.ID() + stream := newDataChannel(dc, pc, nil, nil) dc.OnOpen(func() { - detached, err := dc.Detach() - if err != nil { - log.Warn("[%s] could not detach data channel: %s", localPeer, dc.Label()) - return - } - stream := newDataChannel(detached, dc, pc, nil, nil) - conn.m.Lock() - conn.streams[*dc.ID()] = stream - conn.m.Unlock() + conn.addStream(id, stream) accept <- stream }) - dc.SetBufferedAmountLowThreshold(0) + + dc.OnClose(func() { + stream.remoteClosed() + conn.removeStream(id) + }) }) - // log.Infof("localMultiaddr: %s", conn.localMultiaddr) return conn, nil } @@ -138,26 +135,19 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error network.MuxedStream error }, 1) + streamId := *dc.ID() + stream := newDataChannel(dc, c.pc, nil, nil) dc.OnOpen(func() { - // log.Infof("[%s] opened new datachannel: %d, %s", c.localPeer, dc.ID(), dc.Label()) - detached, err := dc.Detach() - if err != nil { - log.Warn("[%s] could not detach data channel: %s", c.localPeer, dc.Label()) - result <- struct { - network.MuxedStream - error - }{nil, err} - return - } - stream := newDataChannel(detached, dc, c.pc, nil, nil) - c.m.Lock() - c.streams[*dc.ID()] = stream - c.m.Unlock() + c.addStream(streamId, stream) result <- struct { network.MuxedStream error }{stream, err} }) + dc.OnClose(func() { + stream.remoteClosed() + c.removeStream(streamId) + }) select { case <-ctx.Done(): @@ -220,3 +210,15 @@ func (c *connection) Scope() network.ConnScope { func (c *connection) Transport() tpt.Transport { return c.transport } + +func (c *connection) addStream(id uint16, stream *dataChannel) { + c.m.Lock() + defer c.m.Unlock() + c.streams[id] = stream +} + +func (c *connection) removeStream(id uint16) { + c.m.Lock() + defer c.m.Unlock() + delete(c.streams, id) +} diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 6a518b666b..b220b5ff64 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -4,64 +4,59 @@ import ( "bytes" "context" "io" - "net" "os" + // "io" + "net" + "sync" - "sync/atomic" "time" + "sync/atomic" + "github.com/libp2p/go-libp2p-core/network" - pb "github.com/libp2p/go-libp2p/p2p/transport/webrtc/pb" - protoio "github.com/libp2p/go-msgio/protoio" - "github.com/pion/datachannel" "github.com/pion/webrtc/v3" + + pb "github.com/libp2p/go-libp2p/p2p/transport/webrtc/pb" ) var _ network.MuxedStream = &dataChannel{} -type ioresponse struct { - int - error -} - -type iorequest struct { - chunk []byte - done chan ioresponse -} - const defaultReadBufferLen = 8192 // Package pion detached data channel into a net.Conn // and then a network.MuxedStream type dataChannel struct { // TODO: Are these circular references okay? - dc datachannel.ReadWriteCloser channel *webrtc.DataChannel laddr net.Addr raddr net.Addr - closeRead chan struct{} - closeWrite chan struct{} readDeadline *deadline writeDeadline *deadline - readChan chan *iorequest - ctx context.Context - cancel context.CancelFunc - wg sync.WaitGroup - m sync.Mutex - readBuf bytes.Buffer - wc atomic.Bool + + closeWriteOnce sync.Once + closeReadOnce sync.Once + + remoteWriteClosed atomic.Bool + localWriteClosed atomic.Bool + + remoteReadClosed atomic.Bool + localReadClosed atomic.Bool + + ctx context.Context + cancel context.CancelFunc + m sync.Mutex + readBuf bytes.Buffer + readSignal chan struct{} } func newDataChannel( - dc datachannel.ReadWriteCloser, channel *webrtc.DataChannel, pc *webrtc.PeerConnection, laddr, raddr net.Addr) *dataChannel { ctx, cancel := context.WithCancel(context.Background()) result := &dataChannel{ - dc: dc, channel: channel, laddr: laddr, raddr: raddr, @@ -69,233 +64,89 @@ func newDataChannel( writeDeadline: newDeadline(), ctx: ctx, cancel: cancel, - readChan: make(chan *iorequest, 20), - closeRead: make(chan struct{}), - closeWrite: make(chan struct{}), + readSignal: make(chan struct{}), } + result.readBuf.Grow(defaultReadBufferLen) - channel.OnClose(func() { - log.Errorf("remote closed stream") - // result.Close() - }) - - // channel.OnBufferedAmountLow(func() { - // log.Infof("[%s] buffered amount low: amount: %d, threshold: %d", channel.Label(), channel.BufferedAmount(), channel.BufferedAmountLowThreshold()) - // }) - - // result.wg.Add(1) - // go result.readLoop() + channel.OnMessage(result.handleMessage) return result } -// func (d *dataChannel) readLoop() { -// defer d.wg.Done() -// rdr := protoio.NewDelimitedReader(d.dc, defaultReadBufferLen) -// for { -// select { -// case <-d.ctx.Done(): -// return -// case request := <-d.readChan: -// // bad request or readChan is closed -// if request == nil { -// return -// } -// // test for cancelled read -// select { -// case <-request.done: -// continue -// default: -// } - -// var msg pb.Message -// err := rdr.ReadMsg(&msg) -// if err != nil && err != io.EOF { -// log.Errorf("%v", err) -// request.done <- ioresponse{0, err} -// continue -// } -// log.Warnf("flag: %v", msg.Flag) -// if msg.Flag != nil { -// switch msg.GetFlag() { -// case pb.Message_CLOSE_WRITE: -// log.Warnf("remote closed write") -// d.dc.Close() -// case pb.Message_CLOSE_READ: -// case pb.Message_RESET: -// log.Errorf("remote reset the connection") -// } -// } -// if err == io.EOF { -// select { -// case <-request.done: -// continue -// default: -// } -// request.done <- ioresponse {0, err} -// continue -// } -// if msg.Flag == nil && msg.GetMessage() == nil { -// panic("what??") -// } - -// select { -// case <-d.closeRead: -// request.done <- ioresponse {0, io.EOF} -// continue -// // the read has been cancelled, so discard -// case <-request.done: -// continue -// default: -// } -// rcv := msg.Message -// if rcv == nil { -// rcv = []byte{} -// } -// copied := copy(request.chunk, rcv) -// request.done <- ioresponse{copied, nil} -// } -// } -// } - -func (d *dataChannel) Read(b []byte) (int, error) { - // select { - // case <-d.ctx.Done(): - // return 0, os.ErrClosed - // case <-d.closeRead: - // return 0, io.EOF - // // case where deadline is in the past - // case <-d.readDeadline.wait(): - // return 0, os.ErrDeadlineExceeded - // default: - // } - - // done := make(chan ioresponse) - - // // try to queue the read - // select { - // case d.readChan <- &iorequest{chunk: b, done: done}: - // case <-d.ctx.Done(): - // close(done) - // return 0, os.ErrClosed - // case <-d.readDeadline.wait(): - // close(done) - // return 0, os.ErrDeadlineExceeded - // } - - // // wait for read completion and cancel the read - // // request if it times out or the connection is - // // closed - // select { - // case <-d.ctx.Done(): - // close(done) - // return 0, os.ErrClosed - // case <-d.readDeadline.wait(): - // close(done) - // return 0, os.ErrDeadlineExceeded - // case result := <-done: - // // log.Infof("read result: %d %v", result.int, result.error) - // // log.Debugf("read: %s" ,string(b[:result.int])) - // return result.int, result.error - // } - - // method 2 - initialRead, ierr := d.readBuf.Read(b) - if ierr == io.EOF && d.wc.Load() { - return initialRead, io.EOF +func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { + d.m.Lock() + defer d.m.Unlock() + if msg.IsString { + return } - if initialRead > 0 { - return initialRead, nil + + var pbmsg pb.Message + if err := pbmsg.Unmarshal(msg.Data); err != nil { + log.Warnf("could not unmarshal protobuf message") + return } - var msg pb.Message - rdr := protoio.NewDelimitedReader(d.dc, 1500) - err := rdr.ReadMsg(&msg) - if err != nil { - return initialRead, err + + if !d.remoteWriteClosed.Load() && !d.localReadClosed.Load() { + d.readBuf.Write(pbmsg.GetMessage()) + select { + case d.readSignal <- struct{}{}: + default: + } } - copied := copy(b[initialRead:], msg.GetMessage()) - d.readBuf.Write(msg.GetMessage()[copied:]) - if msg.Flag != nil && msg.GetFlag() == pb.Message_CLOSE_WRITE { - d.wc.Store(true) - return copied, nil + + if pbmsg.Flag != nil { + switch pbmsg.GetFlag() { + case pb.Message_CLOSE_WRITE: + d.remoteWriteClosed.Store(true) + select { + case <-d.readSignal: + default: + close(d.readSignal) + } + + case pb.Message_CLOSE_READ: + d.remoteReadClosed.Store(true) + } } - return copied, err + } -// func (d *dataChannel) Read(b []byte) (int, error) { -// for { -// d.bufm.Lock() -// n, err := d.readBuffer.Read(b) -// // log.Infof("reading from buffer: %d %v", n, err) -// d.bufm.Unlock() -// if err == io.EOF && !d.isReadClosed() { -// err = nil -// } -// if n > 0 { -// log.Infof("received %d bytes: %s", n, string(b)) -// return n, err -// } -// if n == 0 { -// select { -// case <-d.ctx.Done(): -// return 0, io.EOF -// case <-d.closeRead: -// return n, io.EOF -// case <-d.readDeadline.wait(): -// return 0, os.ErrDeadlineExceeded -// case <-d.msgChan: - -// } -// } -// } -// } +func (d *dataChannel) Read(b []byte) (int, error) { + for { + + d.m.Lock() + read, err := d.readBuf.Read(b) + d.m.Unlock() + if err == io.EOF && d.remoteWriteClosed.Load() { + return read, io.EOF + } + // log.Warnf("read %d bytes: %s", read, string(b[:read])) + if read > 0 { + return read, nil + } + + select { + case <-d.readSignal: + case <-d.ctx.Done(): + return 0, d.ctx.Err() + case <-d.readDeadline.wait(): + return 0, os.ErrDeadlineExceeded + } + } +} func (d *dataChannel) Write(b []byte) (int, error) { - select { - case <-d.ctx.Done(): - return 0, os.ErrClosed - case <-d.writeDeadline.wait(): - return 0, os.ErrDeadlineExceeded - case <-d.closeWrite: - return 0, os.ErrClosed - default: + if d.localWriteClosed.Load() || d.remoteReadClosed.Load() { + return 0, io.ErrClosedPipe } - - // done := make(chan ioresponse) - - // go func() { - // wr := protoio.NewDelimitedWriter(d.dc) - // err := wr.WriteMsg( - // &pb.Message{ - // Message: b, - // }) - // if err != nil { - // log.Warnf("write error: %v", err) - // } - // done <- struct { - // int - // error - // }{len(b), err} - // }() - - // select { - // case <-d.ctx.Done(): - // return 0, os.ErrClosed - // case <-d.writeDeadline.wait(): - // return 0, os.ErrDeadlineExceeded - // case result := <-done: - // fmt.Printf("[%s] wrote: %s\n", d.uuid, string(b)) - // return result.int, result.error - - // } - - // fmt.Printf("[%s][%s] writing: %s\n", d.uuid, d.channel.Label(), string(b)) - wr := protoio.NewDelimitedWriter(d.dc) - _ = wr.WriteMsg( - &pb.Message{ - Message: b, - }) - // fmt.Printf("[%s][%s] wrote: %s\n", d.uuid, d.channel.Label(), string(b)) + msg := &pb.Message{ + Message: b, + } + data, err := msg.Marshal() + if err != nil { + return 0, err + } + d.channel.Send(data) return len(b), nil } @@ -305,38 +156,51 @@ func (d *dataChannel) Close() error { return nil default: } - err := d.channel.Close() - d.CloseWrite() d.cancel() - // d.wg.Wait() - return err + d.CloseWrite() + _ = d.channel.Close() + return nil } func (d *dataChannel) CloseRead() error { - select { - case <-d.ctx.Done(): - return nil - case <-d.closeRead: - return nil - default: - close(d.closeRead) - } + var err error + d.closeWriteOnce.Do(func() { + d.localReadClosed.Store(true) + msg := &pb.Message{ + Flag: pb.Message_CLOSE_READ.Enum(), + } + data, err := msg.Marshal() + if err != nil { + return + } + err = d.channel.Send(data) + if err != nil { + return + } + }) + return err - return nil +} + +func (d *dataChannel) remoteClosed() { + d.cancel() } func (d *dataChannel) CloseWrite() error { - select { - case <-d.ctx.Done(): - return nil - case <-d.closeWrite: - return nil - default: - close(d.closeWrite) - } - wr := protoio.NewDelimitedWriter(d.dc) - err := wr.WriteMsg(&pb.Message{ - Flag: pb.Message_CLOSE_WRITE.Enum(), + var err error + d.closeWriteOnce.Do(func() { + d.localWriteClosed.Store(true) + msg := &pb.Message{ + Flag: pb.Message_CLOSE_WRITE.Enum(), + } + data, err := msg.Marshal() + if err != nil { + return + } + err = d.channel.Send(data) + if err != nil { + return + } }) return err } @@ -350,7 +214,6 @@ func (d *dataChannel) RemoteAddr() net.Addr { } func (d *dataChannel) Reset() error { - log.Errorf("stream reset") return d.Close() } @@ -369,12 +232,3 @@ func (d *dataChannel) SetWriteDeadline(t time.Time) error { d.writeDeadline.set(t) return nil } - -func (d *dataChannel) isReadClosed() bool { - select { - case <-d.closeRead: - return true - default: - } - return false -} diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 0f560a3eb8..1be60aa8b9 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -181,7 +181,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC se := webrtc.SettingEngine{} se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) - se.DetachDataChannels() + // se.DetachDataChannels() se.DisableCertificateFingerprintVerification(true) se.SetICECredentials(addr.ufrag, localFingerprint) se.SetLite(true) @@ -247,12 +247,11 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC var handshakeOnce sync.Once handshakeChannel.OnOpen(func() { handshakeOnce.Do(func() { - detached, err := handshakeChannel.Detach() - if err != nil { - return - } + // detached, err := handshakeChannel.Detach() + // if err != nil { + // return + // } dcChan <- newDataChannel( - detached, handshakeChannel, pc, l.mux.LocalAddr(), @@ -307,7 +306,5 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC conn.setRemotePeer(secureConn.RemotePeer()) conn.setRemotePublicKey(secureConn.RemotePublicKey()) - // defer func() { _ = dc.Close() }() - return conn, nil } diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 7a362ad423..79d4d11228 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -193,7 +193,7 @@ func (t *WebRTCTransport) Dial( ufrag := uuid.New().String() se := webrtc.SettingEngine{} - se.DetachDataChannels() + // se.DetachDataChannels() se.SetICECredentials(ufrag, ufrag) api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) @@ -218,12 +218,12 @@ func (t *WebRTCTransport) Dial( opened := make(chan *dataChannel, 1) errChan := make(chan error, 1) dc.OnOpen(func() { - detached, err := dc.Detach() - if err != nil { - err = fmt.Errorf("could not detach datachannel: %v", err) - errChan <- err - return - } + // detached, err := dc.Detach() + // if err != nil { + // err = fmt.Errorf("could not detach datachannel: %v", err) + // errChan <- err + // return + // } cp, err := dc.Transport().Transport().ICETransport().GetSelectedCandidatePair() if cp == nil || err != nil { err = fmt.Errorf("could not fetch selected candidate pair: %v", err) @@ -232,7 +232,7 @@ func (t *WebRTCTransport) Dial( } laddr := &net.UDPAddr{IP: net.ParseIP(cp.Local.Address), Port: int(cp.Local.Port)} - opened <- newDataChannel(detached, dc, pc, laddr, raddr) + opened <- newDataChannel(dc, pc, laddr, raddr) }) offer, err := pc.CreateOffer(nil) From e7f3d9e86781fc189ae26b10103ce3865aa1d56b Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 6 Sep 2022 16:06:41 +0530 Subject: [PATCH 23/50] resets --- p2p/transport/webrtc/datachannel.go | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index b220b5ff64..86981b732d 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -36,6 +36,7 @@ type dataChannel struct { closeWriteOnce sync.Once closeReadOnce sync.Once + resetOnce sync.Once remoteWriteClosed atomic.Bool localWriteClosed atomic.Bool @@ -106,6 +107,9 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { case pb.Message_CLOSE_READ: d.remoteReadClosed.Store(true) + case pb.Message_RESET: + log.Errorf("remote reset") + d.Close() } } @@ -214,7 +218,20 @@ func (d *dataChannel) RemoteAddr() net.Addr { } func (d *dataChannel) Reset() error { - return d.Close() + var err error + d.resetOnce.Do(func() { + msg := &pb.Message{Flag: pb.Message_RESET.Enum()} + data, err := msg.Marshal() + if err != nil { + return + } + err = d.channel.Send(data) + if err != nil { + return + } + d.channel.Close() + }) + return err } func (d *dataChannel) SetDeadline(t time.Time) error { From 2c506c6c40c7b0c1a11362ae893e98ccd75cc619 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 6 Sep 2022 19:36:08 +0530 Subject: [PATCH 24/50] fix libp2p core --- go.mod | 27 +++++--- go.sum | 104 +++++++++++++++++++++++++++++ p2p/transport/webrtc/connection.go | 8 +-- p2p/transport/webrtc/listener.go | 4 +- p2p/transport/webrtc/transport.go | 11 +-- 5 files changed, 132 insertions(+), 22 deletions(-) diff --git a/go.mod b/go.mod index 0d7d8accc2..24be01f015 100644 --- a/go.mod +++ b/go.mod @@ -55,27 +55,30 @@ require ( github.com/pion/logging v0.2.2 github.com/pion/stun v0.3.5 github.com/pion/transport v0.13.1 - github.com/pion/webrtc/v3 v3.1.42 + github.com/pion/webrtc/v3 v3.1.43 github.com/prometheus/client_golang v1.13.0 github.com/raulk/go-watchdog v1.3.0 github.com/stretchr/testify v1.8.0 go.opencensus.io v0.23.0 go.uber.org/goleak v1.1.12 - golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e - golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 - golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab + golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90 + golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde + golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 ) require ( github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96 // indirect github.com/beorn7/perks v1.0.1 // indirect + github.com/btcsuite/btcd v0.23.1 // indirect + github.com/btcsuite/btcd/btcec/v2 v2.2.1 // indirect + github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 // indirect github.com/cespare/xxhash v1.1.0 // indirect github.com/cespare/xxhash/v2 v2.1.2 // indirect github.com/containerd/cgroups v1.0.4 // indirect github.com/coreos/go-systemd/v22 v22.4.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/dgraph-io/badger v1.6.2 // indirect - github.com/dgraph-io/ristretto v0.0.2 // indirect + github.com/dgraph-io/ristretto v0.1.0 // indirect github.com/docker/go-units v0.5.0 // indirect github.com/dustin/go-humanize v1.0.0 // indirect github.com/elastic/gosigar v0.14.2 // indirect @@ -83,8 +86,9 @@ require ( github.com/fsnotify/fsnotify v1.5.4 // indirect github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 // indirect github.com/godbus/dbus/v5 v5.1.0 // indirect + github.com/golang/glog v1.0.0 // indirect github.com/golang/protobuf v1.5.2 // indirect - github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect + github.com/golang/snappy v0.0.4 // indirect github.com/huin/goupnp v1.0.3 // indirect github.com/jackpal/go-nat-pmp v1.0.2 // indirect github.com/jbenet/goprocess v0.1.4 // indirect @@ -103,14 +107,15 @@ require ( github.com/nxadm/tail v1.4.8 // indirect github.com/onsi/ginkgo v1.16.5 // indirect github.com/opencontainers/runtime-spec v1.0.2 // indirect - github.com/pion/interceptor v0.1.11 // indirect + github.com/pion/datachannel v1.5.2 // indirect + github.com/pion/interceptor v0.1.12 // indirect github.com/pion/mdns v0.0.5 // indirect github.com/pion/randutil v0.1.0 // indirect - github.com/pion/rtcp v1.2.9 // indirect + github.com/pion/rtcp v1.2.10 // indirect github.com/pion/rtp v1.7.13 // indirect github.com/pion/sctp v1.8.2 // indirect - github.com/pion/sdp/v3 v3.0.5 // indirect - github.com/pion/srtp/v2 v2.0.9 // indirect + github.com/pion/sdp/v3 v3.0.6 // indirect + github.com/pion/srtp/v2 v2.0.10 // indirect github.com/pion/turn/v2 v2.0.8 // indirect github.com/pion/udp v0.1.1 // indirect github.com/pkg/errors v0.9.1 // indirect @@ -120,7 +125,7 @@ require ( github.com/prometheus/procfs v0.8.0 // indirect github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect - github.com/syndtr/goleveldb v1.0.0 // indirect + github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect go.uber.org/atomic v1.10.0 // indirect go.uber.org/multierr v1.8.0 // indirect go.uber.org/zap v1.23.0 // indirect diff --git a/go.sum b/go.sum index 143e4cd004..87a368c6aa 100644 --- a/go.sum +++ b/go.sum @@ -59,6 +59,19 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g= +<<<<<<< HEAD +======= +github.com/btcsuite/btcd v0.22.1 h1:CnwP9LM/M9xuRrGSCGeMVs9iv09uMqwsVX7EeIpgV2c= +github.com/btcsuite/btcd v0.22.1/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y= +github.com/btcsuite/btcd v0.23.1 h1:IB8cVQcC2X5mHbnfirLG5IZnkWYNTPlLZVrxUYSotbE= +github.com/btcsuite/btcd v0.23.1/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY= +github.com/btcsuite/btcd/btcec/v2 v2.1.3 h1:xM/n3yIhHAhHy04z4i43C8p4ehixJZMsnrVJkgl+MTE= +github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= +github.com/btcsuite/btcd/btcec/v2 v2.2.1 h1:xP60mv8fvp+0khmrN0zTdPC3cNm24rfeE6lh2R/Yv3E= +github.com/btcsuite/btcd/btcec/v2 v2.2.1/go.mod h1:9/CSmJxmuvqzX9Wh2fXMWToLOHhPd11lSPuIupwTkI8= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +>>>>>>> e1fb4607 (fix libp2p core) github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= @@ -97,6 +110,11 @@ github.com/dgraph-io/badger v1.6.2 h1:mNw0qs90GVgGGWylh0umH5iag1j6n/PeJtNvL6KY/x github.com/dgraph-io/badger v1.6.2/go.mod h1:JW2yswe3V058sS0kZ2h/AXeDSqFjxnZcRrVH//y2UQE= github.com/dgraph-io/ristretto v0.0.2 h1:a5WaUrDa0qm0YrAAS1tUykT5El3kt62KNZZeMxQn3po= github.com/dgraph-io/ristretto v0.0.2/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E= +<<<<<<< HEAD +======= +github.com/dgraph-io/ristretto v0.1.0 h1:Jv3CGQHp9OjuMBSne1485aDpUkTKEcUqF+jm/LuerPI= +github.com/dgraph-io/ristretto v0.1.0/go.mod h1:fux0lOrBhrVCJd3lcTHsIJhq1T2rokOu6v9Vcb3Q9ug= +>>>>>>> e1fb4607 (fix libp2p core) github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= @@ -146,6 +164,8 @@ github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXP github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0 h1:nfP3RFugxnNRyKgeWd4oI1nYvXpxrx8ck8ZrcizshdQ= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY= @@ -179,6 +199,8 @@ github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= @@ -234,9 +256,19 @@ github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixH github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +<<<<<<< HEAD github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= github.com/ipfs/go-datastore v0.5.0/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= +======= +github.com/ipfs/go-cid v0.2.0 h1:01JTiihFq9en9Vz0lc0VDWvZe/uBonGpzo4THP0vcQ0= +github.com/ipfs/go-cid v0.2.0/go.mod h1:P+HXFDF4CVhaVayiEb4wkAy7zBHxBwsJyt0Y5U6MLro= +github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= +github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= +github.com/ipfs/go-datastore v0.5.0/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= +github.com/ipfs/go-datastore v0.5.1 h1:WkRhLuISI+XPD0uk3OskB0fYFSyqK8Ob5ZYew9Qa1nQ= +github.com/ipfs/go-datastore v0.5.1/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= +>>>>>>> e1fb4607 (fix libp2p core) github.com/ipfs/go-datastore v0.6.0 h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk= github.com/ipfs/go-datastore v0.6.0/go.mod h1:rt5M3nNbSO/8q1t4LNkLyUwRs8HupMeN/8O4Vn9YAT8= github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= @@ -273,6 +305,11 @@ github.com/klauspost/compress v1.15.10 h1:Ai8UzuomSCDw90e1qNMtb15msBXsNpH6gzkkEN github.com/klauspost/compress v1.15.10/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM= github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +<<<<<<< HEAD +======= +github.com/klauspost/cpuid/v2 v2.1.0 h1:eyi1Ad2aNJMW95zcSbmGg7Cg6cq3ADwLpMAP96d8rF0= +github.com/klauspost/cpuid/v2 v2.1.0/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= +>>>>>>> e1fb4607 (fix libp2p core) github.com/klauspost/cpuid/v2 v2.1.1 h1:t0wUqjowdm8ezddV5k0tLWVklVuvLJpoHeb4WBdydm0= github.com/klauspost/cpuid/v2 v2.1.1/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= @@ -297,8 +334,17 @@ github.com/libp2p/go-flow-metrics v0.1.0 h1:0iPhMI8PskQwzh57jB9WxIuIOQ0r+15PChFG github.com/libp2p/go-flow-metrics v0.1.0/go.mod h1:4Xi8MX8wj5aWNDAZttg6UPmc0ZrnFNsMtpsYUClFtro= github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= +<<<<<<< HEAD +github.com/libp2p/go-libp2p-core v0.20.1 h1:fQz4BJyIFmSZAiTbKV8qoYhEH5Dtv/cVhZbG3Ib/+Cw= +github.com/libp2p/go-libp2p-core v0.20.1/go.mod h1:6zR8H7CvQWgYLsbG4on6oLNSGcyKaYFSEYyDt51+bIY= +======= +github.com/libp2p/go-libp2p-core v0.19.0 h1:KDw7hanmh0EuVdZqsHCAzmkdiYMk5uR5h0UGSCVTxSU= +github.com/libp2p/go-libp2p-core v0.19.0/go.mod h1:AkA+FUKQfYt1FLNef5fOPlo/naAWjKy/RCjkcPjqzYg= github.com/libp2p/go-libp2p-core v0.20.1 h1:fQz4BJyIFmSZAiTbKV8qoYhEH5Dtv/cVhZbG3Ib/+Cw= github.com/libp2p/go-libp2p-core v0.20.1/go.mod h1:6zR8H7CvQWgYLsbG4on6oLNSGcyKaYFSEYyDt51+bIY= +github.com/libp2p/go-libp2p-testing v0.11.0 h1:+R7FRl/U3Y00neyBSM2qgDzqz3HkWH24U9nMlascHL4= +github.com/libp2p/go-libp2p-testing v0.11.0/go.mod h1:qG4sF27dfKFoK9KlVzK2y52LQKhp0VEmLjV5aDqr1Hg= +>>>>>>> e1fb4607 (fix libp2p core) github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA= github.com/libp2p/go-libp2p-testing v0.12.0/go.mod h1:KcGDRXyN7sQCllucn1cOOS+Dmm7ujhfEyXQL5lvkcPg= github.com/libp2p/go-mplex v0.7.0 h1:BDhFZdlk5tbr0oyFq/xv/NPGfjbnrsDam1EvutpBDbY= @@ -366,20 +412,37 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +<<<<<<< HEAD +======= +github.com/multiformats/go-base32 v0.0.4 h1:+qMh4a2f37b4xTNs6mqitDinryCI+tfO2dRVMN9mjSE= +github.com/multiformats/go-base32 v0.0.4/go.mod h1:jNLFzjPZtp3aIARHbJRZIaPuspdH0J6q39uUM5pnABM= +>>>>>>> e1fb4607 (fix libp2p core) github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU55txyt0p4aiWVohjo= github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4= +<<<<<<< HEAD github.com/multiformats/go-multiaddr v0.7.0 h1:gskHcdaCyPtp9XskVwtvEeQOG465sCohbQIirSyqxrc= github.com/multiformats/go-multiaddr v0.7.0/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs= +======= +github.com/multiformats/go-multiaddr v0.6.0 h1:qMnoOPj2s8xxPU5kZ57Cqdr0hHhARz7mFsPMIiYNqzg= +github.com/multiformats/go-multiaddr v0.6.0/go.mod h1:F4IpaKZuPP360tOMn2Tpyu0At8w23aRyVqeK0DbFeGM= +github.com/multiformats/go-multiaddr v0.6.1-0.20220825120744-e8c0913a8eb7 h1:yC9ss03Io46t4CXmL/f/Ga3NvEc3UuAvF8xAs5sciAI= +github.com/multiformats/go-multiaddr v0.6.1-0.20220825120744-e8c0913a8eb7/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs= +>>>>>>> e1fb4607 (fix libp2p core) github.com/multiformats/go-multiaddr-dns v0.3.1 h1:QgQgR+LQVt3NPTjbrLLpsaT2ufAA2y0Mkk+QRVJbW3A= github.com/multiformats/go-multiaddr-dns v0.3.1/go.mod h1:G/245BRQ6FJGmryJCrOuTdB37AMA5AMOVuO6NY3JwTk= github.com/multiformats/go-multiaddr-fmt v0.1.0 h1:WLEFClPycPkp4fnIzoFoV9FVd49/eQsuaL3/CWe167E= github.com/multiformats/go-multiaddr-fmt v0.1.0/go.mod h1:hGtDIW4PU4BqJ50gW2quDuPVjyWNZxToGUh/HwTZYJo= github.com/multiformats/go-multibase v0.1.1 h1:3ASCDsuLX8+j4kx58qnJ4YFq/JWTJpCyDW27ztsVTOI= github.com/multiformats/go-multibase v0.1.1/go.mod h1:ZEjHE+IsUrgp5mhlEAYjMtZwK1k4haNkcaPg9aoe1a8= +<<<<<<< HEAD +======= +github.com/multiformats/go-multicodec v0.5.0 h1:EgU6cBe/D7WRwQb1KmnBvU7lrcFGMggZVTPtOW9dDHs= +github.com/multiformats/go-multicodec v0.5.0/go.mod h1:DiY2HFaEp5EhEXb/iYzVAunmyX/aSFMxq2KMKfWEues= +>>>>>>> e1fb4607 (fix libp2p core) github.com/multiformats/go-multicodec v0.6.0 h1:KhH2kSuCARyuJraYMFxrNO3DqIaYhOdS039kbhgVwpE= github.com/multiformats/go-multicodec v0.6.0/go.mod h1:GUC8upxSBE4oG+q3kWZRw/+6yC1BqO550bjhWsJbZlw= github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= @@ -424,6 +487,8 @@ github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig= github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE= github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs= github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8= +github.com/pion/interceptor v0.1.12 h1:CslaNriCFUItiXS5o+hh5lpL0t0ytQkFnUcbbCs2Zq8= +github.com/pion/interceptor v0.1.12/go.mod h1:bDtgAD9dRkBZpWHGKaoKb42FhDHTG2rX8Ii9LRALLVA= github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY= github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms= github.com/pion/mdns v0.0.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw= @@ -432,6 +497,8 @@ github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA= github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8= github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U= github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo= +github.com/pion/rtcp v1.2.10 h1:nkr3uj+8Sp97zyItdN60tE/S6vk4al5CPRR6Gejsdjc= +github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I= github.com/pion/rtp v1.7.13 h1:qcHwlmtiI50t1XivvoawdCGTP4Uiypzfrsap+bijcoA= github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko= github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= @@ -439,8 +506,15 @@ github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA= github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU= github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw= +<<<<<<< HEAD github.com/pion/srtp/v2 v2.0.9 h1:JJq3jClmDFBPX/F5roEb0U19jSU7eUhyDqR/NZ34EKQ= github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4= +======= +github.com/pion/sdp/v3 v3.0.6 h1:WuDLhtuFUUVpTfus9ILC4HRyHsW6TdugjEX/QY9OiUw= +github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw= +github.com/pion/srtp/v2 v2.0.10 h1:b8ZvEuI+mrL8hbr/f1YiJFB34UMrOac3R3N1yq2UN0w= +github.com/pion/srtp/v2 v2.0.10/go.mod h1:XEeSWaK9PfuMs7zxXyiN252AHPbH12NX5q/CFDWtUuA= +>>>>>>> e1fb4607 (fix libp2p core) github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg= github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA= github.com/pion/transport v0.12.2/go.mod h1:N3+vZQD9HlDP5GWkZ85LohxNsDcNgofQmyL6ojX5d8Q= @@ -549,6 +623,8 @@ github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PK github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE= github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= @@ -582,6 +658,11 @@ go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95a go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc= go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= +<<<<<<< HEAD +======= +go.uber.org/zap v1.22.0 h1:Zcye5DUgBloQ9BaT4qc9BnjOFog5TvBSAGkJ3Nf70c0= +go.uber.org/zap v1.22.0/go.mod h1:H4siCOZOrAolnUPJEkfaSjDqyP+BDS0DdDWzwcgt3+U= +>>>>>>> e1fb4607 (fix libp2p core) go.uber.org/zap v1.23.0 h1:OjGQ5KQDEUawVHxNwQgPpiypGHOxo2mNZsOqTak4fFY= go.uber.org/zap v1.23.0/go.mod h1:D+nX8jyLsMHMYrln8A0rJjFt/T/9/bGgIhAqxv5URuY= go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= @@ -603,6 +684,8 @@ golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0 golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e h1:T8NU3HyQ8ClP4SEE+KbFlg6n0NhuTsN4MyznaarGsZM= golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90 h1:Y/gsMcFOcR+6S6f3YeMKl5g+dZMEWqcz5Czj/GWYbkM= +golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -613,8 +696,15 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +<<<<<<< HEAD golang.org/x/exp v0.0.0-20220916125017-b168a2c6b86b h1:SCE/18RnFsLrjydh/R/s5EVvHoZprqEQUuoxK8q2Pc4= golang.org/x/exp v0.0.0-20220916125017-b168a2c6b86b/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= +======= +golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e h1:+WEEuIdZHnUeJJmEUjyYC2gfUMj69yZXw17EnHg/otA= +golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA= +golang.org/x/exp v0.0.0-20220827204233-334a2380cb91 h1:tnebWN09GYg9OLPss1KXj8txwZc6X6uMr6VFdcGNbHw= +golang.org/x/exp v0.0.0-20220827204233-334a2380cb91/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= +>>>>>>> e1fb4607 (fix libp2p core) golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -673,6 +763,7 @@ golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/ golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= @@ -691,8 +782,16 @@ golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su golang.org/x/net v0.0.0-20220401154927-543a649e0bdd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220531201128-c960675eff93/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +<<<<<<< HEAD golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5 h1:KafLifaRFIuSJ5C+7CyFJOF9haxKNC1CEIDk8GX6X0k= golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +======= +golang.org/x/net v0.0.0-20220630215102-69896b714898/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220812174116-3211cb980234 h1:RDqmgfe7SvlMWoqC3xwQ2blLO3fcWcxMa3eBLRdRW7E= +golang.org/x/net v0.0.0-20220812174116-3211cb980234/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b h1:ZmngSVLe/wycRns9MKikG9OWIEjGcGAkacif7oYQaUY= +golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +>>>>>>> e1fb4607 (fix libp2p core) golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -716,6 +815,8 @@ golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde h1:ejfdSekXMDxDLbRrJMwUk6KnSLZ2McaUCVcIKM+N6jc= +golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -762,6 +863,7 @@ golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -782,6 +884,8 @@ golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY= +golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index df9f56b1dc..b92cd034d1 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -6,10 +6,10 @@ import ( "sync" "github.com/google/uuid" - ic "github.com/libp2p/go-libp2p-core/crypto" - "github.com/libp2p/go-libp2p-core/network" - "github.com/libp2p/go-libp2p-core/peer" - tpt "github.com/libp2p/go-libp2p-core/transport" + ic "github.com/libp2p/go-libp2p/core/crypto" + "github.com/libp2p/go-libp2p/core/network" + "github.com/libp2p/go-libp2p/core/peer" + tpt "github.com/libp2p/go-libp2p/core/transport" ma "github.com/multiformats/go-multiaddr" "github.com/pion/webrtc/v3" ) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 1be60aa8b9..698ba03e3a 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -11,9 +11,9 @@ import ( "sync" "time" - "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p/core/network" - tpt "github.com/libp2p/go-libp2p-core/transport" + tpt "github.com/libp2p/go-libp2p/core/transport" ma "github.com/multiformats/go-multiaddr" manet "github.com/multiformats/go-multiaddr/net" "github.com/multiformats/go-multibase" diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 79d4d11228..d2cdbf8003 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -14,11 +14,11 @@ import ( "strings" "github.com/google/uuid" - ic "github.com/libp2p/go-libp2p-core/crypto" - "github.com/libp2p/go-libp2p-core/network" - "github.com/libp2p/go-libp2p-core/peer" - "github.com/libp2p/go-libp2p-core/sec" - tpt "github.com/libp2p/go-libp2p-core/transport" + ic "github.com/libp2p/go-libp2p/core/crypto" + "github.com/libp2p/go-libp2p/core/network" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/libp2p/go-libp2p/core/sec" + tpt "github.com/libp2p/go-libp2p/core/transport" "github.com/libp2p/go-libp2p/p2p/security/noise" logging "github.com/ipfs/go-log/v2" @@ -33,6 +33,7 @@ import ( var log = logging.Logger("webrtc-transport") + var dialMatcher = mafmt.And(mafmt.IP, mafmt.Base(ma.P_UDP), mafmt.Base(ma.P_WEBRTC), mafmt.Base(ma.P_CERTHASH)) type WebRTCTransport struct { From 0cd637ecb36e632be8055b424b680f7661170277 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 6 Sep 2022 19:42:08 +0530 Subject: [PATCH 25/50] fix imports --- p2p/transport/webrtc/datachannel.go | 4 ++-- p2p/transport/webrtc/transport_test.go | 8 ++++---- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 86981b732d..74e1df26db 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -14,7 +14,7 @@ import ( "sync/atomic" - "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p/core/network" "github.com/pion/webrtc/v3" pb "github.com/libp2p/go-libp2p/p2p/transport/webrtc/pb" @@ -168,7 +168,7 @@ func (d *dataChannel) Close() error { func (d *dataChannel) CloseRead() error { var err error - d.closeWriteOnce.Do(func() { + d.closeReadOnce.Do(func() { d.localReadClosed.Store(true) msg := &pb.Message{ Flag: pb.Message_CLOSE_READ.Enum(), diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 3208279a48..9a7fbf6047 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -6,10 +6,10 @@ import ( "testing" "time" - "github.com/libp2p/go-libp2p-core/crypto" - "github.com/libp2p/go-libp2p-core/network" - "github.com/libp2p/go-libp2p-core/peer" - tpt "github.com/libp2p/go-libp2p-core/transport" + "github.com/libp2p/go-libp2p/core/crypto" + "github.com/libp2p/go-libp2p/core/network" + "github.com/libp2p/go-libp2p/core/peer" + tpt "github.com/libp2p/go-libp2p/core/transport" "github.com/multiformats/go-multiaddr" "github.com/stretchr/testify/require" ) From 5b6a3459c12de635d387dd5509901fda22e20dd8 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 6 Sep 2022 19:46:13 +0530 Subject: [PATCH 26/50] update protobuf --- p2p/transport/webrtc/datachannel.go | 8 ++--- p2p/transport/webrtc/pb/message.pb.go | 45 ++++++++++++++------------- p2p/transport/webrtc/pb/message.proto | 15 +++++---- p2p/transport/webrtc/transport.go | 1 - 4 files changed, 34 insertions(+), 35 deletions(-) diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 74e1df26db..5322b4a79b 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -97,7 +97,7 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { if pbmsg.Flag != nil { switch pbmsg.GetFlag() { - case pb.Message_CLOSE_WRITE: + case pb.Message_FIN: d.remoteWriteClosed.Store(true) select { case <-d.readSignal: @@ -105,7 +105,7 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { close(d.readSignal) } - case pb.Message_CLOSE_READ: + case pb.Message_STOP_SENDING: d.remoteReadClosed.Store(true) case pb.Message_RESET: log.Errorf("remote reset") @@ -171,7 +171,7 @@ func (d *dataChannel) CloseRead() error { d.closeReadOnce.Do(func() { d.localReadClosed.Store(true) msg := &pb.Message{ - Flag: pb.Message_CLOSE_READ.Enum(), + Flag: pb.Message_STOP_SENDING.Enum(), } data, err := msg.Marshal() if err != nil { @@ -195,7 +195,7 @@ func (d *dataChannel) CloseWrite() error { d.closeWriteOnce.Do(func() { d.localWriteClosed.Store(true) msg := &pb.Message{ - Flag: pb.Message_CLOSE_WRITE.Enum(), + Flag: pb.Message_FIN.Enum(), } data, err := msg.Marshal() if err != nil { diff --git a/p2p/transport/webrtc/pb/message.pb.go b/p2p/transport/webrtc/pb/message.pb.go index 2c4c747ab1..a8a261af1b 100644 --- a/p2p/transport/webrtc/pb/message.pb.go +++ b/p2p/transport/webrtc/pb/message.pb.go @@ -25,25 +25,26 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Message_Flag int32 const ( - // The local endpoint will no longer send messages. - Message_CLOSE_WRITE Message_Flag = 0 - // The local endpoint will no longer read messages. - Message_CLOSE_READ Message_Flag = 1 - // The local endpoint abruptly terminates the stream. The remote endpoint - // may discard any in-flight data. + // The sender will no longer send messages on the stream. + Message_FIN Message_Flag = 0 + // The sender will no longer read messages on the stream. Incoming data is + // being discarded on receipt. + Message_STOP_SENDING Message_Flag = 1 + // The sender abruptly terminates the sending part of the stream. The + // receiver can discard any data that it already received on that stream. Message_RESET Message_Flag = 2 ) var Message_Flag_name = map[int32]string{ - 0: "CLOSE_WRITE", - 1: "CLOSE_READ", + 0: "FIN", + 1: "STOP_SENDING", 2: "RESET", } var Message_Flag_value = map[string]int32{ - "CLOSE_WRITE": 0, - "CLOSE_READ": 1, - "RESET": 2, + "FIN": 0, + "STOP_SENDING": 1, + "RESET": 2, } func (x Message_Flag) Enum() *Message_Flag { @@ -114,7 +115,7 @@ func (m *Message) GetFlag() Message_Flag { if m != nil && m.Flag != nil { return *m.Flag } - return Message_CLOSE_WRITE + return Message_FIN } func (m *Message) GetMessage() []byte { @@ -132,18 +133,18 @@ func init() { func init() { proto.RegisterFile("message.proto", fileDescriptor_33c57e4bae7b9afd) } var fileDescriptor_33c57e4bae7b9afd = []byte{ - // 163 bytes of a gzipped FileDescriptorProto + // 161 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcd, 0x4d, 0x2d, 0x2e, 0x4e, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x2c, 0x4f, 0x4d, 0x2a, 0x2a, - 0x49, 0xd6, 0x2b, 0x48, 0x52, 0x6a, 0x61, 0xe4, 0x62, 0xf7, 0x85, 0x48, 0x0a, 0x69, 0x73, 0xb1, - 0xa4, 0xe5, 0x24, 0xa6, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x19, 0x89, 0xeb, 0xc1, 0x55, 0xe9, - 0x41, 0x55, 0xe8, 0xb9, 0xe5, 0x24, 0xa6, 0x07, 0x81, 0x15, 0x09, 0x49, 0x70, 0xb1, 0x43, 0x0d, - 0x95, 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x09, 0x82, 0x71, 0x95, 0x8c, 0xb8, 0x58, 0x40, 0xea, 0x84, - 0xf8, 0xb9, 0xb8, 0x9d, 0x7d, 0xfc, 0x83, 0x5d, 0xe3, 0xc3, 0x83, 0x3c, 0x43, 0x5c, 0x05, 0x18, - 0x84, 0xf8, 0xb8, 0xb8, 0x20, 0x02, 0x41, 0xae, 0x8e, 0x2e, 0x02, 0x8c, 0x42, 0x9c, 0x5c, 0xac, - 0x41, 0xae, 0xc1, 0xae, 0x21, 0x02, 0x4c, 0x4e, 0x3c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, - 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0x23, 0x20, 0x00, 0x00, 0xff, 0xff, 0x58, 0x33, 0x0d, 0x31, 0xaf, - 0x00, 0x00, 0x00, + 0x49, 0xd6, 0x2b, 0x48, 0x52, 0xaa, 0xe3, 0x62, 0xf7, 0x85, 0xc8, 0x09, 0x69, 0x73, 0xb1, 0xa4, + 0xe5, 0x24, 0xa6, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x19, 0x89, 0xeb, 0xc1, 0x15, 0xe9, 0x41, + 0x55, 0xe8, 0xb9, 0xe5, 0x24, 0xa6, 0x07, 0x81, 0x15, 0x09, 0x49, 0x70, 0xb1, 0x43, 0xcd, 0x94, + 0x60, 0x52, 0x60, 0xd4, 0xe0, 0x09, 0x82, 0x71, 0x95, 0x74, 0xb8, 0x58, 0x40, 0xea, 0x84, 0xd8, + 0xb9, 0x98, 0xdd, 0x3c, 0xfd, 0x04, 0x18, 0x84, 0x04, 0xb8, 0x78, 0x82, 0x43, 0xfc, 0x03, 0xe2, + 0x83, 0x5d, 0xfd, 0x5c, 0x3c, 0xfd, 0xdc, 0x05, 0x18, 0x85, 0x38, 0xb9, 0x58, 0x83, 0x5c, 0x83, + 0x5d, 0x43, 0x04, 0x98, 0x9c, 0x78, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, + 0x23, 0x39, 0x46, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2b, 0x2a, 0x76, 0x30, 0xa8, 0x00, 0x00, + 0x00, } func (m *Message) Marshal() (dAtA []byte, err error) { diff --git a/p2p/transport/webrtc/pb/message.proto b/p2p/transport/webrtc/pb/message.proto index ecf3075c35..eab3ceb720 100644 --- a/p2p/transport/webrtc/pb/message.proto +++ b/p2p/transport/webrtc/pb/message.proto @@ -1,17 +1,16 @@ syntax = "proto2"; -/* option go_package = "."; */ - package webrtc.pb; message Message { enum Flag { - // The local endpoint will no longer send messages. - CLOSE_WRITE = 0; - // The local endpoint will no longer read messages. - CLOSE_READ = 1; - // The local endpoint abruptly terminates the stream. The remote endpoint - // may discard any in-flight data. + // The sender will no longer send messages on the stream. + FIN = 0; + // The sender will no longer read messages on the stream. Incoming data is + // being discarded on receipt. + STOP_SENDING = 1; + // The sender abruptly terminates the sending part of the stream. The + // receiver can discard any data that it already received on that stream. RESET = 2; } diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index d2cdbf8003..228774fde3 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -33,7 +33,6 @@ import ( var log = logging.Logger("webrtc-transport") - var dialMatcher = mafmt.And(mafmt.IP, mafmt.Base(ma.P_UDP), mafmt.Base(ma.P_WEBRTC), mafmt.Base(ma.P_CERTHASH)) type WebRTCTransport struct { From 0896819c3133ff6d2ca01744b3ce38ade6dc0266 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 6 Sep 2022 20:39:00 +0530 Subject: [PATCH 27/50] fix atomics --- examples/webrtc/main.go | 8 +-- go.mod | 6 -- go.sum | 103 ++-------------------------- p2p/transport/webrtc/datachannel.go | 37 ++++++---- 4 files changed, 31 insertions(+), 123 deletions(-) diff --git a/examples/webrtc/main.go b/examples/webrtc/main.go index 576e0dea00..79d83fa4c6 100644 --- a/examples/webrtc/main.go +++ b/examples/webrtc/main.go @@ -6,16 +6,12 @@ import ( "os" "os/signal" "syscall" - // "time" - // "github.com/libp2p/go-libp2p/p2p/protocol/identify" "github.com/libp2p/go-libp2p/p2p/protocol/ping" - // "github.com/libp2p/go-libp2p/p2p/protocol/ping" - "github.com/libp2p/go-libp2p" - "github.com/libp2p/go-libp2p-core/host" - "github.com/libp2p/go-libp2p-core/peer" + "github.com/libp2p/go-libp2p/core/host" + "github.com/libp2p/go-libp2p/core/peer" webrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc" ) diff --git a/go.mod b/go.mod index 24be01f015..de22c47f48 100644 --- a/go.mod +++ b/go.mod @@ -23,7 +23,6 @@ require ( github.com/libp2p/go-buffer-pool v0.1.0 github.com/libp2p/go-flow-metrics v0.1.0 github.com/libp2p/go-libp2p-asn-util v0.2.0 - github.com/libp2p/go-libp2p-core v0.20.1 github.com/libp2p/go-libp2p-testing v0.12.0 github.com/libp2p/go-mplex v0.7.0 github.com/libp2p/go-msgio v0.2.0 @@ -49,7 +48,6 @@ require ( github.com/multiformats/go-multistream v0.3.3 github.com/multiformats/go-varint v0.0.6 github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 - github.com/pion/datachannel v1.5.2 github.com/pion/dtls/v2 v2.1.5 github.com/pion/ice/v2 v2.2.6 github.com/pion/logging v0.2.2 @@ -69,10 +67,6 @@ require ( require ( github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96 // indirect github.com/beorn7/perks v1.0.1 // indirect - github.com/btcsuite/btcd v0.23.1 // indirect - github.com/btcsuite/btcd/btcec/v2 v2.2.1 // indirect - github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 // indirect - github.com/cespare/xxhash v1.1.0 // indirect github.com/cespare/xxhash/v2 v2.1.2 // indirect github.com/containerd/cgroups v1.0.4 // indirect github.com/coreos/go-systemd/v22 v22.4.0 // indirect diff --git a/go.sum b/go.sum index 87a368c6aa..d9fcd167de 100644 --- a/go.sum +++ b/go.sum @@ -42,7 +42,6 @@ github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96 h1:cTp8I5+VIo github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= @@ -59,22 +58,8 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g= -<<<<<<< HEAD -======= -github.com/btcsuite/btcd v0.22.1 h1:CnwP9LM/M9xuRrGSCGeMVs9iv09uMqwsVX7EeIpgV2c= -github.com/btcsuite/btcd v0.22.1/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y= -github.com/btcsuite/btcd v0.23.1 h1:IB8cVQcC2X5mHbnfirLG5IZnkWYNTPlLZVrxUYSotbE= -github.com/btcsuite/btcd v0.23.1/go.mod h1:0QJIIN1wwIXF/3G/m87gIwGniDMDQqjVn4SZgnFpsYY= -github.com/btcsuite/btcd/btcec/v2 v2.1.3 h1:xM/n3yIhHAhHy04z4i43C8p4ehixJZMsnrVJkgl+MTE= -github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE= -github.com/btcsuite/btcd/btcec/v2 v2.2.1 h1:xP60mv8fvp+0khmrN0zTdPC3cNm24rfeE6lh2R/Yv3E= -github.com/btcsuite/btcd/btcec/v2 v2.2.1/go.mod h1:9/CSmJxmuvqzX9Wh2fXMWToLOHhPd11lSPuIupwTkI8= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= -github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= ->>>>>>> e1fb4607 (fix libp2p core) github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE= @@ -108,13 +93,9 @@ github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 h1:HbphB4TFFXpv7MNrT52FGrrgVXF1 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0/go.mod h1:DZGJHZMqrU4JJqFAWUS2UO1+lbSKsdiOoYi9Zzey7Fc= github.com/dgraph-io/badger v1.6.2 h1:mNw0qs90GVgGGWylh0umH5iag1j6n/PeJtNvL6KY/x8= github.com/dgraph-io/badger v1.6.2/go.mod h1:JW2yswe3V058sS0kZ2h/AXeDSqFjxnZcRrVH//y2UQE= -github.com/dgraph-io/ristretto v0.0.2 h1:a5WaUrDa0qm0YrAAS1tUykT5El3kt62KNZZeMxQn3po= github.com/dgraph-io/ristretto v0.0.2/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E= -<<<<<<< HEAD -======= github.com/dgraph-io/ristretto v0.1.0 h1:Jv3CGQHp9OjuMBSne1485aDpUkTKEcUqF+jm/LuerPI= github.com/dgraph-io/ristretto v0.1.0/go.mod h1:fux0lOrBhrVCJd3lcTHsIJhq1T2rokOu6v9Vcb3Q9ug= ->>>>>>> e1fb4607 (fix libp2p core) github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= @@ -197,7 +178,6 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw= github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= @@ -256,19 +236,9 @@ github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixH github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= -<<<<<<< HEAD github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= github.com/ipfs/go-datastore v0.5.0/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= -======= -github.com/ipfs/go-cid v0.2.0 h1:01JTiihFq9en9Vz0lc0VDWvZe/uBonGpzo4THP0vcQ0= -github.com/ipfs/go-cid v0.2.0/go.mod h1:P+HXFDF4CVhaVayiEb4wkAy7zBHxBwsJyt0Y5U6MLro= -github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= -github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= -github.com/ipfs/go-datastore v0.5.0/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= -github.com/ipfs/go-datastore v0.5.1 h1:WkRhLuISI+XPD0uk3OskB0fYFSyqK8Ob5ZYew9Qa1nQ= -github.com/ipfs/go-datastore v0.5.1/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= ->>>>>>> e1fb4607 (fix libp2p core) github.com/ipfs/go-datastore v0.6.0 h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk= github.com/ipfs/go-datastore v0.6.0/go.mod h1:rt5M3nNbSO/8q1t4LNkLyUwRs8HupMeN/8O4Vn9YAT8= github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= @@ -305,11 +275,6 @@ github.com/klauspost/compress v1.15.10 h1:Ai8UzuomSCDw90e1qNMtb15msBXsNpH6gzkkEN github.com/klauspost/compress v1.15.10/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM= github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= -<<<<<<< HEAD -======= -github.com/klauspost/cpuid/v2 v2.1.0 h1:eyi1Ad2aNJMW95zcSbmGg7Cg6cq3ADwLpMAP96d8rF0= -github.com/klauspost/cpuid/v2 v2.1.0/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= ->>>>>>> e1fb4607 (fix libp2p core) github.com/klauspost/cpuid/v2 v2.1.1 h1:t0wUqjowdm8ezddV5k0tLWVklVuvLJpoHeb4WBdydm0= github.com/klauspost/cpuid/v2 v2.1.1/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= @@ -334,17 +299,6 @@ github.com/libp2p/go-flow-metrics v0.1.0 h1:0iPhMI8PskQwzh57jB9WxIuIOQ0r+15PChFG github.com/libp2p/go-flow-metrics v0.1.0/go.mod h1:4Xi8MX8wj5aWNDAZttg6UPmc0ZrnFNsMtpsYUClFtro= github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= -<<<<<<< HEAD -github.com/libp2p/go-libp2p-core v0.20.1 h1:fQz4BJyIFmSZAiTbKV8qoYhEH5Dtv/cVhZbG3Ib/+Cw= -github.com/libp2p/go-libp2p-core v0.20.1/go.mod h1:6zR8H7CvQWgYLsbG4on6oLNSGcyKaYFSEYyDt51+bIY= -======= -github.com/libp2p/go-libp2p-core v0.19.0 h1:KDw7hanmh0EuVdZqsHCAzmkdiYMk5uR5h0UGSCVTxSU= -github.com/libp2p/go-libp2p-core v0.19.0/go.mod h1:AkA+FUKQfYt1FLNef5fOPlo/naAWjKy/RCjkcPjqzYg= -github.com/libp2p/go-libp2p-core v0.20.1 h1:fQz4BJyIFmSZAiTbKV8qoYhEH5Dtv/cVhZbG3Ib/+Cw= -github.com/libp2p/go-libp2p-core v0.20.1/go.mod h1:6zR8H7CvQWgYLsbG4on6oLNSGcyKaYFSEYyDt51+bIY= -github.com/libp2p/go-libp2p-testing v0.11.0 h1:+R7FRl/U3Y00neyBSM2qgDzqz3HkWH24U9nMlascHL4= -github.com/libp2p/go-libp2p-testing v0.11.0/go.mod h1:qG4sF27dfKFoK9KlVzK2y52LQKhp0VEmLjV5aDqr1Hg= ->>>>>>> e1fb4607 (fix libp2p core) github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA= github.com/libp2p/go-libp2p-testing v0.12.0/go.mod h1:KcGDRXyN7sQCllucn1cOOS+Dmm7ujhfEyXQL5lvkcPg= github.com/libp2p/go-mplex v0.7.0 h1:BDhFZdlk5tbr0oyFq/xv/NPGfjbnrsDam1EvutpBDbY= @@ -412,37 +366,20 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= -<<<<<<< HEAD -======= -github.com/multiformats/go-base32 v0.0.4 h1:+qMh4a2f37b4xTNs6mqitDinryCI+tfO2dRVMN9mjSE= -github.com/multiformats/go-base32 v0.0.4/go.mod h1:jNLFzjPZtp3aIARHbJRZIaPuspdH0J6q39uUM5pnABM= ->>>>>>> e1fb4607 (fix libp2p core) github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU55txyt0p4aiWVohjo= github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4= -<<<<<<< HEAD github.com/multiformats/go-multiaddr v0.7.0 h1:gskHcdaCyPtp9XskVwtvEeQOG465sCohbQIirSyqxrc= github.com/multiformats/go-multiaddr v0.7.0/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs= -======= -github.com/multiformats/go-multiaddr v0.6.0 h1:qMnoOPj2s8xxPU5kZ57Cqdr0hHhARz7mFsPMIiYNqzg= -github.com/multiformats/go-multiaddr v0.6.0/go.mod h1:F4IpaKZuPP360tOMn2Tpyu0At8w23aRyVqeK0DbFeGM= -github.com/multiformats/go-multiaddr v0.6.1-0.20220825120744-e8c0913a8eb7 h1:yC9ss03Io46t4CXmL/f/Ga3NvEc3UuAvF8xAs5sciAI= -github.com/multiformats/go-multiaddr v0.6.1-0.20220825120744-e8c0913a8eb7/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs= ->>>>>>> e1fb4607 (fix libp2p core) github.com/multiformats/go-multiaddr-dns v0.3.1 h1:QgQgR+LQVt3NPTjbrLLpsaT2ufAA2y0Mkk+QRVJbW3A= github.com/multiformats/go-multiaddr-dns v0.3.1/go.mod h1:G/245BRQ6FJGmryJCrOuTdB37AMA5AMOVuO6NY3JwTk= github.com/multiformats/go-multiaddr-fmt v0.1.0 h1:WLEFClPycPkp4fnIzoFoV9FVd49/eQsuaL3/CWe167E= github.com/multiformats/go-multiaddr-fmt v0.1.0/go.mod h1:hGtDIW4PU4BqJ50gW2quDuPVjyWNZxToGUh/HwTZYJo= github.com/multiformats/go-multibase v0.1.1 h1:3ASCDsuLX8+j4kx58qnJ4YFq/JWTJpCyDW27ztsVTOI= github.com/multiformats/go-multibase v0.1.1/go.mod h1:ZEjHE+IsUrgp5mhlEAYjMtZwK1k4haNkcaPg9aoe1a8= -<<<<<<< HEAD -======= -github.com/multiformats/go-multicodec v0.5.0 h1:EgU6cBe/D7WRwQb1KmnBvU7lrcFGMggZVTPtOW9dDHs= -github.com/multiformats/go-multicodec v0.5.0/go.mod h1:DiY2HFaEp5EhEXb/iYzVAunmyX/aSFMxq2KMKfWEues= ->>>>>>> e1fb4607 (fix libp2p core) github.com/multiformats/go-multicodec v0.6.0 h1:KhH2kSuCARyuJraYMFxrNO3DqIaYhOdS039kbhgVwpE= github.com/multiformats/go-multicodec v0.6.0/go.mod h1:GUC8upxSBE4oG+q3kWZRw/+6yC1BqO550bjhWsJbZlw= github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= @@ -485,7 +422,6 @@ github.com/pion/dtls/v2 v2.1.5 h1:jlh2vtIyUBShchoTDqpCCqiYCyRFJ/lvf/gQ8TALs+c= github.com/pion/dtls/v2 v2.1.5/go.mod h1:BqCE7xPZbPSubGasRoDFJeTsyJtdD1FanJYL0JGheqY= github.com/pion/ice/v2 v2.2.6 h1:R/vaLlI1J2gCx141L5PEwtuGAGcyS6e7E0hDeJFq5Ig= github.com/pion/ice/v2 v2.2.6/go.mod h1:SWuHiOGP17lGromHTFadUe1EuPgFh/oCU6FCMZHooVE= -github.com/pion/interceptor v0.1.11 h1:00U6OlqxA3FFB50HSg25J/8cWi7P6FbSzw4eFn24Bvs= github.com/pion/interceptor v0.1.11/go.mod h1:tbtKjZY14awXd7Bq0mmWvgtHB5MDaRN7HV3OZ/uy7s8= github.com/pion/interceptor v0.1.12 h1:CslaNriCFUItiXS5o+hh5lpL0t0ytQkFnUcbbCs2Zq8= github.com/pion/interceptor v0.1.12/go.mod h1:bDtgAD9dRkBZpWHGKaoKb42FhDHTG2rX8Ii9LRALLVA= @@ -495,7 +431,6 @@ github.com/pion/mdns v0.0.5 h1:Q2oj/JB3NqfzY9xGZ1fPzZzK7sDSD8rZPOvcIQ10BCw= github.com/pion/mdns v0.0.5/go.mod h1:UgssrvdD3mxpi8tMxAXbsppL3vJ4Jipw1mTCW+al01g= github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA= github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8= -github.com/pion/rtcp v1.2.9 h1:1ujStwg++IOLIEoOiIQ2s+qBuJ1VN81KW+9pMPsif+U= github.com/pion/rtcp v1.2.9/go.mod h1:qVPhiCzAm4D/rxb6XzKeyZiQK69yJpbUDJSF7TgrqNo= github.com/pion/rtcp v1.2.10 h1:nkr3uj+8Sp97zyItdN60tE/S6vk4al5CPRR6Gejsdjc= github.com/pion/rtcp v1.2.10/go.mod h1:ztfEwXZNLGyF1oQDttz/ZKIBaeeg/oWbRYqzBM9TL1I= @@ -504,17 +439,11 @@ github.com/pion/rtp v1.7.13/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUk github.com/pion/sctp v1.8.0/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= github.com/pion/sctp v1.8.2 h1:yBBCIrUMJ4yFICL3RIvR4eh/H2BTTvlligmSTy+3kiA= github.com/pion/sctp v1.8.2/go.mod h1:xFe9cLMZ5Vj6eOzpyiKjT9SwGM4KpK/8Jbw5//jc+0s= -github.com/pion/sdp/v3 v3.0.5 h1:ouvI7IgGl+V4CrqskVtr3AaTrPvPisEOxwgpdktctkU= github.com/pion/sdp/v3 v3.0.5/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw= -<<<<<<< HEAD -github.com/pion/srtp/v2 v2.0.9 h1:JJq3jClmDFBPX/F5roEb0U19jSU7eUhyDqR/NZ34EKQ= -github.com/pion/srtp/v2 v2.0.9/go.mod h1:5TtM9yw6lsH0ppNCehB/EjEUli7VkUgKSPJqWVqbhQ4= -======= github.com/pion/sdp/v3 v3.0.6 h1:WuDLhtuFUUVpTfus9ILC4HRyHsW6TdugjEX/QY9OiUw= github.com/pion/sdp/v3 v3.0.6/go.mod h1:iiFWFpQO8Fy3S5ldclBkpXqmWy02ns78NOKoLLL0YQw= github.com/pion/srtp/v2 v2.0.10 h1:b8ZvEuI+mrL8hbr/f1YiJFB34UMrOac3R3N1yq2UN0w= github.com/pion/srtp/v2 v2.0.10/go.mod h1:XEeSWaK9PfuMs7zxXyiN252AHPbH12NX5q/CFDWtUuA= ->>>>>>> e1fb4607 (fix libp2p core) github.com/pion/stun v0.3.5 h1:uLUCBCkQby4S1cf6CGuR9QrVOKcvUwFeemaC865QHDg= github.com/pion/stun v0.3.5/go.mod h1:gDMim+47EeEtfWogA37n6qXZS88L5V6LqFcf+DZA2UA= github.com/pion/transport v0.12.2/go.mod h1:N3+vZQD9HlDP5GWkZ85LohxNsDcNgofQmyL6ojX5d8Q= @@ -526,8 +455,8 @@ github.com/pion/turn/v2 v2.0.8 h1:KEstL92OUN3k5k8qxsXHpr7WWfrdp7iJZHx99ud8muw= github.com/pion/turn/v2 v2.0.8/go.mod h1:+y7xl719J8bAEVpSXBXvTxStjJv3hbz9YFflvkpcGPw= github.com/pion/udp v0.1.1 h1:8UAPvyqmsxK8oOjloDk4wUt63TzFe9WEJkg5lChlj7o= github.com/pion/udp v0.1.1/go.mod h1:6AFo+CMdKQm7UiA0eUPA8/eVCTx8jBIITLZHc9DWX5M= -github.com/pion/webrtc/v3 v3.1.42 h1:wJEQFIXVanptnQcHOLTuIo4AtGB2+mG2x4OhIhnITOA= -github.com/pion/webrtc/v3 v3.1.42/go.mod h1:ffD9DulDrPxyWvDPUIPAOSAWx9GUlOExiJPf7cCcMLA= +github.com/pion/webrtc/v3 v3.1.43 h1:YT3ZTO94UT4kSBvZnRAH82+0jJPUruiKr9CEstdlQzk= +github.com/pion/webrtc/v3 v3.1.43/go.mod h1:G/J8k0+grVsjC/rjCZ24AKoCCxcFFODgh7zThNZGs0M= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -621,7 +550,6 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= -github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE= github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= @@ -658,11 +586,6 @@ go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95a go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc= go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= -<<<<<<< HEAD -======= -go.uber.org/zap v1.22.0 h1:Zcye5DUgBloQ9BaT4qc9BnjOFog5TvBSAGkJ3Nf70c0= -go.uber.org/zap v1.22.0/go.mod h1:H4siCOZOrAolnUPJEkfaSjDqyP+BDS0DdDWzwcgt3+U= ->>>>>>> e1fb4607 (fix libp2p core) go.uber.org/zap v1.23.0 h1:OjGQ5KQDEUawVHxNwQgPpiypGHOxo2mNZsOqTak4fFY= go.uber.org/zap v1.23.0/go.mod h1:D+nX8jyLsMHMYrln8A0rJjFt/T/9/bGgIhAqxv5URuY= go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= @@ -682,8 +605,6 @@ golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220427172511-eb4f295cb31f/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220516162934-403b01795ae8/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e h1:T8NU3HyQ8ClP4SEE+KbFlg6n0NhuTsN4MyznaarGsZM= -golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90 h1:Y/gsMcFOcR+6S6f3YeMKl5g+dZMEWqcz5Czj/GWYbkM= golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -696,15 +617,8 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -<<<<<<< HEAD golang.org/x/exp v0.0.0-20220916125017-b168a2c6b86b h1:SCE/18RnFsLrjydh/R/s5EVvHoZprqEQUuoxK8q2Pc4= golang.org/x/exp v0.0.0-20220916125017-b168a2c6b86b/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= -======= -golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e h1:+WEEuIdZHnUeJJmEUjyYC2gfUMj69yZXw17EnHg/otA= -golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA= -golang.org/x/exp v0.0.0-20220827204233-334a2380cb91 h1:tnebWN09GYg9OLPss1KXj8txwZc6X6uMr6VFdcGNbHw= -golang.org/x/exp v0.0.0-20220827204233-334a2380cb91/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= ->>>>>>> e1fb4607 (fix libp2p core) golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -782,16 +696,9 @@ golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su golang.org/x/net v0.0.0-20220401154927-543a649e0bdd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220531201128-c960675eff93/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -<<<<<<< HEAD +golang.org/x/net v0.0.0-20220630215102-69896b714898/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5 h1:KafLifaRFIuSJ5C+7CyFJOF9haxKNC1CEIDk8GX6X0k= golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= -======= -golang.org/x/net v0.0.0-20220630215102-69896b714898/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.0.0-20220812174116-3211cb980234 h1:RDqmgfe7SvlMWoqC3xwQ2blLO3fcWcxMa3eBLRdRW7E= -golang.org/x/net v0.0.0-20220812174116-3211cb980234/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= -golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b h1:ZmngSVLe/wycRns9MKikG9OWIEjGcGAkacif7oYQaUY= -golang.org/x/net v0.0.0-20220826154423-83b083e8dc8b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= ->>>>>>> e1fb4607 (fix libp2p core) golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -813,8 +720,6 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde h1:ejfdSekXMDxDLbRrJMwUk6KnSLZ2McaUCVcIKM+N6jc= golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -881,8 +786,8 @@ golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab h1:2QkjZIsXupsJbJIdSjjUOgWK3aEtzyuh2mPt3l/CkeU= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY= golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 5322b4a79b..3efb10aa9e 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -22,7 +22,7 @@ import ( var _ network.MuxedStream = &dataChannel{} -const defaultReadBufferLen = 8192 +const defaultReadBufferLen = 4096 // Package pion detached data channel into a net.Conn // and then a network.MuxedStream @@ -38,11 +38,11 @@ type dataChannel struct { closeReadOnce sync.Once resetOnce sync.Once - remoteWriteClosed atomic.Bool - localWriteClosed atomic.Bool + remoteWriteClosed uint32 + localWriteClosed uint32 - remoteReadClosed atomic.Bool - localReadClosed atomic.Bool + remoteReadClosed uint32 + localReadClosed uint32 ctx context.Context cancel context.CancelFunc @@ -87,7 +87,7 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { return } - if !d.remoteWriteClosed.Load() && !d.localReadClosed.Load() { + if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { d.readBuf.Write(pbmsg.GetMessage()) select { case d.readSignal <- struct{}{}: @@ -98,7 +98,7 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { if pbmsg.Flag != nil { switch pbmsg.GetFlag() { case pb.Message_FIN: - d.remoteWriteClosed.Store(true) + atomic.StoreUint32(&d.remoteWriteClosed, 1) select { case <-d.readSignal: default: @@ -106,7 +106,7 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { } case pb.Message_STOP_SENDING: - d.remoteReadClosed.Store(true) + atomic.StoreUint32(&d.remoteReadClosed, 1) case pb.Message_RESET: log.Errorf("remote reset") d.Close() @@ -121,7 +121,7 @@ func (d *dataChannel) Read(b []byte) (int, error) { d.m.Lock() read, err := d.readBuf.Read(b) d.m.Unlock() - if err == io.EOF && d.remoteWriteClosed.Load() { + if err == io.EOF && d.isRemoteWriteClosed() { return read, io.EOF } // log.Warnf("read %d bytes: %s", read, string(b[:read])) @@ -140,7 +140,7 @@ func (d *dataChannel) Read(b []byte) (int, error) { } func (d *dataChannel) Write(b []byte) (int, error) { - if d.localWriteClosed.Load() || d.remoteReadClosed.Load() { + if d.isLocalWriteClosed() || d.isRemoteReadClosed() { return 0, io.ErrClosedPipe } msg := &pb.Message{ @@ -169,7 +169,7 @@ func (d *dataChannel) Close() error { func (d *dataChannel) CloseRead() error { var err error d.closeReadOnce.Do(func() { - d.localReadClosed.Store(true) + atomic.StoreUint32(&d.localReadClosed, 1) msg := &pb.Message{ Flag: pb.Message_STOP_SENDING.Enum(), } @@ -193,7 +193,7 @@ func (d *dataChannel) remoteClosed() { func (d *dataChannel) CloseWrite() error { var err error d.closeWriteOnce.Do(func() { - d.localWriteClosed.Store(true) + atomic.StoreUint32(&d.localWriteClosed, 1) msg := &pb.Message{ Flag: pb.Message_FIN.Enum(), } @@ -249,3 +249,16 @@ func (d *dataChannel) SetWriteDeadline(t time.Time) error { d.writeDeadline.set(t) return nil } + +func (d *dataChannel) isRemoteWriteClosed() bool { + return atomic.LoadUint32(&d.remoteWriteClosed) == 1 +} +func (d *dataChannel) isLocalWriteClosed() bool { + return atomic.LoadUint32(&d.localWriteClosed) == 1 +} +func (d *dataChannel) isRemoteReadClosed() bool { + return atomic.LoadUint32(&d.remoteReadClosed) == 1 +} +func (d *dataChannel) isLocalReadClosed() bool { + return atomic.LoadUint32(&d.localReadClosed) == 1 +} From 15eae54015ed52d695e64dd4f9810154e8c19dc7 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Fri, 9 Sep 2022 04:14:14 +0530 Subject: [PATCH 28/50] fix main --- examples/webrtc/main.go | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/examples/webrtc/main.go b/examples/webrtc/main.go index 79d83fa4c6..16bce2046d 100644 --- a/examples/webrtc/main.go +++ b/examples/webrtc/main.go @@ -18,16 +18,24 @@ import ( func main() { host := createHost() defer host.Close() - fmt.Println("listening on: ", host.Network().ListenAddresses()) - ctx, cancel := context.WithCancel(context.Background()) + // fmt.Println("listening on: ", host.Network().ListenAddresses()) + remoteInfo := peer.AddrInfo{ + ID: host.ID(), + Addrs: host.Network().ListenAddresses(), + } + + remoteAddrs, _ := peer.AddrInfoToP2pAddrs(&remoteInfo) + fmt.Println("p2p addr: ", remoteAddrs) - go dialHost(ctx, host) + // ctx, cancel := context.WithCancel(context.Background()) + + // go dialHost(ctx, host) fmt.Println("press Ctrl+C to quit") ch := make(chan os.Signal, 1) signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT) <-ch - cancel() + // cancel() } func dialHost(ctx context.Context, server host.Host) { @@ -49,6 +57,9 @@ func dialHost(ctx context.Context, server host.Host) { Addrs: server.Network().ListenAddresses(), } + remoteAddrs, err := peer.AddrInfoToP2pAddrs(&remoteInfo) + fmt.Println("p2p addr: ", remoteAddrs) + fmt.Println("=========================== connecting ==============================") err = client.Connect(context.Background(), remoteInfo) if err != nil { @@ -58,7 +69,7 @@ func dialHost(ctx context.Context, server host.Host) { resultChan := ping.Ping(ctx, server, server.ID()) - for i := 0; i < 5; i++{ + for i := 0; i < 5; i++ { select { case <-ctx.Done(): case result := <-resultChan: @@ -77,7 +88,8 @@ func createHost() host.Host { h, err := libp2p.New( libp2p.Transport(webrtc.New), libp2p.ListenAddrStrings( - "/ip4/0.0.0.0/udp/0/webrtc", // a UDP endpoint for the WebRTC Transport + // "/ip4/0.0.0.0/udp/0/webrtc", // a UDP endpoint for the WebRTC Transport + "/ip4/192.168.1.16/udp/0/webrtc", // a UDP endpoint for the WebRTC Transport ), libp2p.DisableRelay(), libp2p.Ping(true), From 1fd841df9b58cbbe5e513708078601d939c8c27a Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Fri, 9 Sep 2022 11:40:22 +0530 Subject: [PATCH 29/50] fix --- p2p/transport/webrtc/sdp.go | 2 +- p2p/transport/webrtc/transport.go | 3 ++- p2p/transport/webrtc/udp_mux.go | 3 +++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/sdp.go b/p2p/transport/webrtc/sdp.go index c270999a19..cbdeaaae72 100644 --- a/p2p/transport/webrtc/sdp.go +++ b/p2p/transport/webrtc/sdp.go @@ -22,7 +22,7 @@ c=IN %s %s t=0 0 m=application %d UDP/DTLS/SCTP webrtc-datachannel a=mid:0 -a=ice-options:ice2 +a=ice-options:trickle a=ice-ufrag:%s a=ice-pwd:%s a=fingerprint:%s diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 228774fde3..275c9b4ce4 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -52,7 +52,7 @@ func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*We if err != nil { return nil, fmt.Errorf("could not get local peer ID: %v", err) } - pk, err := ecdsa.GenerateKey(elliptic.P224(), rand.Reader) + pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) if err != nil { return nil, fmt.Errorf("could not generate rsa key for cert: %v", err) } @@ -195,6 +195,7 @@ func (t *WebRTCTransport) Dial( se := webrtc.SettingEngine{} // se.DetachDataChannels() se.SetICECredentials(ufrag, ufrag) + se.SetLite(false) api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) pc, err = api.NewPeerConnection(t.webrtcConfig) diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index 03b41c8a0d..7954f3bb87 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -272,6 +272,7 @@ func (m *udpMuxNewAddr) connWorker() { msg := &stun.Message{ Raw: append([]byte{}, buf[:n]...), } + // log.Info("received new stun message: %v", *msg) if err = msg.Decode(); err != nil { m.params.Logger.Warnf("Failed to handle decode ICE from %s: %v\n", addr.String(), err) @@ -281,6 +282,7 @@ func (m *udpMuxNewAddr) connWorker() { ufrag, ufragErr := ufragFromStunMessage(msg, false) if ufragErr != nil { m.params.Logger.Warnf("%v", ufragErr) + log.Warnf("%v", ufragErr) continue } @@ -292,6 +294,7 @@ func (m *udpMuxNewAddr) connWorker() { // notify that a new connection is requested if !ok { + log.Debugf("new connection requested: %v %v", udpAddr, ufrag) m.newAddrChan <- candidateAddr{raddr: udpAddr, ufrag: ufrag} m.mu.Lock() m.newAddrs[udpAddr] = struct{}{} From e4143f7787819aef7859785bebd9db1abd22ebc5 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Fri, 9 Sep 2022 21:53:51 +0530 Subject: [PATCH 30/50] bind webrtc example to correct interface --- examples/webrtc/main.go | 155 +++++++++++++++++++----------- p2p/transport/webrtc/transport.go | 16 ++- p2p/transport/webrtc/udp_mux.go | 2 +- 3 files changed, 110 insertions(+), 63 deletions(-) diff --git a/examples/webrtc/main.go b/examples/webrtc/main.go index 16bce2046d..32830d326e 100644 --- a/examples/webrtc/main.go +++ b/examples/webrtc/main.go @@ -1,95 +1,86 @@ package main import ( - "context" + "bufio" "fmt" + "log" + "net" "os" "os/signal" "syscall" - "github.com/libp2p/go-libp2p/p2p/protocol/ping" - "github.com/libp2p/go-libp2p" "github.com/libp2p/go-libp2p/core/host" + "github.com/libp2p/go-libp2p/core/network" "github.com/libp2p/go-libp2p/core/peer" webrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc" ) +var listenerIp = net.IPv4(0, 0, 0, 0) +func init() { + ifaces, err := net.Interfaces() + if err != nil { + return + } + for _, iface := range ifaces { + if iface.Flags&net.FlagUp == 0 { + continue + } + addrs, err := iface.Addrs() + if err != nil { + return + } + for _, addr := range addrs { + // bind to private non-loopback ip + if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.IsPrivate() { + if ipnet.IP.To4() != nil { + listenerIp = ipnet.IP.To4() + return + } + } + } + } +} + +func echoHandler(stream network.Stream) { + for { + reader := bufio.NewReader(stream) + str, err := reader.ReadString('\n') + if err != nil { + return + } + log.Printf("echo: %s", str) + _, err = stream.Write([]byte(str)) + if err != nil { + return + } + + } +} + func main() { host := createHost() + host.SetStreamHandler("/echo/1.0.0", echoHandler) defer host.Close() - // fmt.Println("listening on: ", host.Network().ListenAddresses()) remoteInfo := peer.AddrInfo{ ID: host.ID(), Addrs: host.Network().ListenAddresses(), } remoteAddrs, _ := peer.AddrInfoToP2pAddrs(&remoteInfo) - fmt.Println("p2p addr: ", remoteAddrs) - - // ctx, cancel := context.WithCancel(context.Background()) - - // go dialHost(ctx, host) + fmt.Println("p2p addr: ", remoteAddrs[0]) fmt.Println("press Ctrl+C to quit") ch := make(chan os.Signal, 1) signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT) <-ch - // cancel() -} - -func dialHost(ctx context.Context, server host.Host) { - client, err := libp2p.New( - libp2p.Transport(webrtc.New), - libp2p.DisableRelay(), - libp2p.Ping(true), - ) - if err != nil { - panic(err) - } - - if err = server.ID().Validate(); err != nil { - panic(err) - } - - remoteInfo := peer.AddrInfo{ - ID: server.ID(), - Addrs: server.Network().ListenAddresses(), - } - - remoteAddrs, err := peer.AddrInfoToP2pAddrs(&remoteInfo) - fmt.Println("p2p addr: ", remoteAddrs) - - fmt.Println("=========================== connecting ==============================") - err = client.Connect(context.Background(), remoteInfo) - if err != nil { - panic(err) - } - fmt.Println("============================ connected ==============================") - - resultChan := ping.Ping(ctx, server, server.ID()) - - for i := 0; i < 5; i++ { - select { - case <-ctx.Done(): - case result := <-resultChan: - if result.Error != nil { - fmt.Println("ping error", result.Error) - } else { - fmt.Println("pinged", remoteInfo.Addrs, " in ", result.RTT) - } - } - - } - } func createHost() host.Host { h, err := libp2p.New( libp2p.Transport(webrtc.New), libp2p.ListenAddrStrings( - // "/ip4/0.0.0.0/udp/0/webrtc", // a UDP endpoint for the WebRTC Transport - "/ip4/192.168.1.16/udp/0/webrtc", // a UDP endpoint for the WebRTC Transport + fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp), ), libp2p.DisableRelay(), libp2p.Ping(true), @@ -100,3 +91,51 @@ func createHost() host.Host { return h } + +// func dialHost(ctx context.Context, server host.Host) { +// client, err := libp2p.New( +// libp2p.Transport(webrtc.New), +// libp2p.DisableRelay(), +// libp2p.Ping(true), +// ) +// if err != nil { +// panic(err) +// } + +// if err = server.ID().Validate(); err != nil { +// panic(err) +// } + +// remoteInfo := peer.AddrInfo{ +// ID: server.ID(), +// Addrs: server.Network().ListenAddresses(), +// } + +// remoteAddrs, err := peer.AddrInfoToP2pAddrs(&remoteInfo) +// fmt.Println("p2p addr: ", remoteAddrs) + +// fmt.Println("=========================== connecting ==============================") +// err = client.Connect(context.Background(), remoteInfo) +// if err != nil { +// panic(err) +// } +// fmt.Println("============================ connected ==============================") + +// resultChan := ping.Ping(ctx, server, server.ID()) + +// for i := 0; i < 5; i++ { +// select { +// case <-ctx.Done(): +// case result := <-resultChan: +// if result.Error != nil { +// fmt.Println("ping error", result.Error) +// } else { +// fmt.Println("pinged", remoteInfo.Addrs, " in ", result.RTT) +// } +// } + +// } + +// } + + diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 275c9b4ce4..64b99e4430 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -335,7 +335,11 @@ func (t *WebRTCTransport) generateNoisePrologue(pc *webrtc.PeerConnection) ([]by if err != nil { return nil, err } - remoteFp = strings.ToLower(remoteFp) + remoteFp = strings.ReplaceAll(strings.ToLower(remoteFp), ":", "") + remoteFpBytes, err := hex.DecodeString(remoteFp) + if err != nil { + return nil, err + } mhAlgoName := sdpHashToMh(localFp.Algorithm) if mhAlgoName == "" { @@ -343,13 +347,17 @@ func (t *WebRTCTransport) generateNoisePrologue(pc *webrtc.PeerConnection) ([]by } local := strings.ReplaceAll(localFp.Value, ":", "") - remote := strings.ReplaceAll(remoteFp, ":", "") - localEncoded, err := multihash.EncodeName([]byte(local), mhAlgoName) + localBytes, err := hex.DecodeString(local) + if err != nil { + return nil, err + } + + localEncoded, err := multihash.EncodeName(localBytes, mhAlgoName) if err != nil { log.Debugf("could not encode multihash for local fingerprint") return nil, err } - remoteEncoded, err := multihash.EncodeName([]byte(remote), mhAlgoName) + remoteEncoded, err := multihash.EncodeName(remoteFpBytes, mhAlgoName) if err != nil { log.Debugf("could not encode multihash for remote fingerprint") return nil, err diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index 7954f3bb87..b864a71e14 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -294,7 +294,7 @@ func (m *udpMuxNewAddr) connWorker() { // notify that a new connection is requested if !ok { - log.Debugf("new connection requested: %v %v", udpAddr, ufrag) + log.Debugf("new connection requested: %v %v", udpAddr, ufrag) m.newAddrChan <- candidateAddr{raddr: udpAddr, ufrag: ufrag} m.mu.Lock() m.newAddrs[udpAddr] = struct{}{} From 8d194a27e328b60a2feab8c31a68a185cb60f6b9 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Mon, 12 Sep 2022 17:22:56 +0530 Subject: [PATCH 31/50] match webrtc listener ufrag pwd to spec --- p2p/transport/webrtc/listener.go | 4 +--- p2p/transport/webrtc/sdp.go | 5 ++--- p2p/transport/webrtc/transport.go | 1 - 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 698ba03e3a..353277affa 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -175,7 +175,6 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } - localFingerprint := strings.ReplaceAll(l.localFingerprint.Value, ":", "") // signaling channel signalChan := make(chan struct{}) @@ -183,7 +182,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) // se.DetachDataChannels() se.DisableCertificateFingerprintVerification(true) - se.SetICECredentials(addr.ufrag, localFingerprint) + se.SetICECredentials(addr.ufrag, addr.ufrag) se.SetLite(true) se.SetICEUDPMux(l.mux) @@ -193,7 +192,6 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC Addr: addr.raddr, Fingerprint: defaultMultihash, Ufrag: addr.ufrag, - Password: addr.ufrag, }) clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} pc, err = api.NewPeerConnection(l.config) diff --git a/p2p/transport/webrtc/sdp.go b/p2p/transport/webrtc/sdp.go index cbdeaaae72..eb283451c9 100644 --- a/p2p/transport/webrtc/sdp.go +++ b/p2p/transport/webrtc/sdp.go @@ -10,7 +10,6 @@ import ( type sdpArgs struct { Addr *net.UDPAddr Ufrag string - Password string Fingerprint *multihash.DecodedMultihash } @@ -44,7 +43,7 @@ func renderClientSdp(args sdpArgs) string { args.Addr.IP, args.Addr.Port, args.Ufrag, - args.Password, + args.Ufrag, fingerprintToSDP(args.Fingerprint), ) } @@ -82,7 +81,7 @@ func renderServerSdp(args sdpArgs) string { ipVersion, args.Addr.IP, args.Ufrag, - args.Password, + args.Ufrag, fp, args.Addr.IP, args.Addr.Port, diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 64b99e4430..9bf43eaa8d 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -252,7 +252,6 @@ func (t *WebRTCTransport) Dial( Addr: raddr, Fingerprint: remoteMultihash, Ufrag: ufrag, - Password: hex.EncodeToString(remoteMultihash.Digest), }) answer := webrtc.SessionDescription{SDP: answerSdpString, Type: webrtc.SDPTypeAnswer} From f3ef76251a3537536f1dbb2d2d9fbd381a514301 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 13 Sep 2022 18:10:42 +0530 Subject: [PATCH 32/50] make fixes --- p2p/transport/webrtc/connection.go | 2 +- p2p/transport/webrtc/datachannel.go | 19 ++++- p2p/transport/webrtc/errors.go | 49 +++++++++++ p2p/transport/webrtc/listener.go | 111 ++++++++++++++----------- p2p/transport/webrtc/transport.go | 98 ++++++++++++++-------- p2p/transport/webrtc/transport_test.go | 51 ++++++++++-- p2p/transport/webrtc/udp_mux.go | 4 +- 7 files changed, 237 insertions(+), 97 deletions(-) create mode 100644 p2p/transport/webrtc/errors.go diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index b92cd034d1..e16f59de2b 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -51,7 +51,7 @@ func newConnection( remoteKey ic.PubKey, remoteMultiaddr ma.Multiaddr, ) (*connection, error) { - accept := make(chan network.MuxedStream, 10) + accept := make(chan network.MuxedStream) ctx, cancel := context.WithCancel(context.Background()) diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 3efb10aa9e..771683d913 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -75,9 +75,8 @@ func newDataChannel( } func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { - d.m.Lock() - defer d.m.Unlock() if msg.IsString { + log.Warnf("received string message") return } @@ -88,7 +87,11 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { } if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { + d.m.Lock() d.readBuf.Write(pbmsg.GetMessage()) + // n, err := d.readBuf.Write(pbmsg.GetMessage()) + // log.Warnf("wrote %d bytes to buffer, msg size: %d: %v", n, len(pbmsg.GetMessage()), err) + d.m.Unlock() select { case d.readSignal <- struct{}{}: default: @@ -117,6 +120,11 @@ func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { func (d *dataChannel) Read(b []byte) (int, error) { for { + select { + case <-d.readDeadline.wait(): + return 0, os.ErrDeadlineExceeded + default: + } d.m.Lock() read, err := d.readBuf.Read(b) @@ -129,6 +137,7 @@ func (d *dataChannel) Read(b []byte) (int, error) { return read, nil } + // log.Warnf("waiting for read") select { case <-d.readSignal: case <-d.ctx.Done(): @@ -143,11 +152,17 @@ func (d *dataChannel) Write(b []byte) (int, error) { if d.isLocalWriteClosed() || d.isRemoteReadClosed() { return 0, io.ErrClosedPipe } + select { + case <-d.writeDeadline.wait(): + return 0, os.ErrDeadlineExceeded + default: + } msg := &pb.Message{ Message: b, } data, err := msg.Marshal() if err != nil { + log.Warnf("write failed on datachannel: %s", err) return 0, err } d.channel.Send(data) diff --git a/p2p/transport/webrtc/errors.go b/p2p/transport/webrtc/errors.go new file mode 100644 index 0000000000..55bcbb4d35 --- /dev/null +++ b/p2p/transport/webrtc/errors.go @@ -0,0 +1,49 @@ +package libp2pwebrtc + +import ( + "fmt" +) + +type errKind string + +const ( + errKindConnectionFailed errKind = "peerconnection failed" + errKindDatachannel errKind = "datachannel" + errKindMultiaddr errKind = "bad multiaddr" + errKindNoise errKind = "noise" + errKindInternal errKind = "internal" +) + +var ( + errDataChannelTimeout = errDatachannel("timed out waiting for datachannel", nil) +) + +type webRTCTransportError struct { + kind errKind + message string + nested error +} + +func (e *webRTCTransportError) Error() string { + return fmt.Sprintf("[webrtc-transport-error] %s : %s : %v", e.kind, e.message, e.nested) +} + +func errConnectionFailed(msg string, err error) error { + return &webRTCTransportError{kind: errKindConnectionFailed, message: msg, nested: err} +} + +func errDatachannel(msg string, err error) error { + return &webRTCTransportError{kind: errKindDatachannel, message: msg, nested: err} +} + +func errMultiaddr(msg string, err error) error { + return &webRTCTransportError{kind: errKindMultiaddr, message: msg, nested: err} +} + +func errNoise(msg string, err error) error { + return &webRTCTransportError{kind: errKindNoise, message: msg, nested: err} +} + +func errInternal(msg string, err error) error { + return &webRTCTransportError{kind: errKindInternal, message: msg, nested: err} +} diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 353277affa..054f642c05 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -3,7 +3,6 @@ package libp2pwebrtc import ( "context" "encoding/hex" - "errors" "fmt" "net" "os" @@ -23,12 +22,6 @@ import ( "github.com/pion/webrtc/v3" ) -var ( - ErrDataChannelTimeout = errors.New("timed out waiting for datachannel") - ErrNoiseHandshakeTimeout = errors.New("noise handshake timeout") - ErrNoCertInConfig = errors.New("no certificate configured in listener config") -) - var ( // since verification of the remote fingerprint is deferred until // the noise handshake, a multihash with an arbitrary value is considered @@ -68,7 +61,7 @@ type listener struct { } func newListener(transport *WebRTCTransport, laddr ma.Multiaddr, socket net.PacketConn, config webrtc.Configuration) (*listener, error) { - mux := NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: socket}, make(chan candidateAddr, 1)) + mux := NewUDPMuxNewAddr(ice.UDPMuxParams{UDPConn: socket}, make(chan candidateAddr)) localFingerprints, err := config.Certificates[0].GetFingerprints() if err != nil { return nil, err @@ -153,12 +146,16 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC var ( scope network.ConnManagementScope pc *webrtc.PeerConnection + dc *dataChannel ) cleanup := func() { if scope != nil { scope.Done() } + if dc != nil { + _ = dc.Close() + } if pc != nil { _ = pc.Close() } @@ -175,62 +172,36 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } - // signaling channel - signalChan := make(chan struct{}) + // signaling channel wraps an error in a struct to make + // the error nullable. se := webrtc.SettingEngine{} se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) - // se.DetachDataChannels() - se.DisableCertificateFingerprintVerification(true) se.SetICECredentials(addr.ufrag, addr.ufrag) se.SetLite(true) se.SetICEUDPMux(l.mux) + se.DisableCertificateFingerprintVerification(true) api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) - clientSdpString := renderClientSdp(sdpArgs{ - Addr: addr.raddr, - Fingerprint: defaultMultihash, - Ufrag: addr.ufrag, - }) - clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} pc, err = api.NewPeerConnection(l.config) if err != nil { defer cleanup() return nil, err } + signalChan := make(chan struct{ error }) + dcChan := make(chan *dataChannel) var connectedOnce sync.Once pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) { - if state == webrtc.PeerConnectionStateConnected { - connectedOnce.Do(func() { signalChan <- struct{}{} }) + switch state { + case webrtc.PeerConnectionStateConnected: + connectedOnce.Do(func() { signalChan <- struct{ error }{nil} }) + case webrtc.PeerConnectionStateFailed: + connectedOnce.Do(func() { signalChan <- struct{ error }{fmt.Errorf("peerconnection failed to connect")} }) } }) - pc.SetRemoteDescription(clientSdp) - - answer, err := pc.CreateAnswer(nil) - if err != nil { - defer cleanup() - return nil, err - } - - err = pc.SetLocalDescription(answer) - if err != nil { - defer cleanup() - return nil, err - } - - // await peerconnection connected state - select { - case <-signalChan: - case <-ctx.Done(): - defer cleanup() - return nil, ctx.Err() - } - - // await openening of datachannel - dcChan := make(chan *dataChannel) // this enforces that the correct data channel label is used // for the handshake handshakeChannel, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ @@ -245,10 +216,6 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC var handshakeOnce sync.Once handshakeChannel.OnOpen(func() { handshakeOnce.Do(func() { - // detached, err := handshakeChannel.Detach() - // if err != nil { - // return - // } dcChan <- newDataChannel( handshakeChannel, pc, @@ -257,8 +224,47 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC ) }) }) + handshakeChannel.OnError(func(e error) { + handshakeOnce.Do(func() { + signalChan <- struct{ error }{e} + + }) + }) + + clientSdpString := renderClientSdp(sdpArgs{ + Addr: addr.raddr, + Fingerprint: defaultMultihash, + Ufrag: addr.ufrag, + }) + clientSdp := webrtc.SessionDescription{SDP: clientSdpString, Type: webrtc.SDPTypeOffer} + pc.SetRemoteDescription(clientSdp) + + answer, err := pc.CreateAnswer(nil) + if err != nil { + defer cleanup() + return nil, err + } - var dc *dataChannel + err = pc.SetLocalDescription(answer) + if err != nil { + defer cleanup() + return nil, err + } + + // await peerconnection connected state + select { + case s := <-signalChan: + if s.error != nil { + log.Debug("peerconnection error", err) + defer cleanup() + return nil, err + } + case <-ctx.Done(): + defer cleanup() + return nil, ctx.Err() + } + + // await opening of datachannel select { case <-ctx.Done(): defer cleanup() @@ -268,6 +274,13 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC defer cleanup() return nil, fmt.Errorf("should be unreachable") } + case s := <-signalChan: + if s.error != nil { + log.Debugf("datachannel: ", s.error) + return nil, errDatachannel("datachannel error", s.error) + } else { + return nil, fmt.Errorf("should be unreachable") + } } conn, err := newConnection( diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 9bf43eaa8d..e9d89e8678 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -12,6 +12,7 @@ import ( "net" "sort" "strings" + "sync" "github.com/google/uuid" ic "github.com/libp2p/go-libp2p/core/crypto" @@ -50,22 +51,24 @@ type Option func(*WebRTCTransport) error func New(privKey ic.PrivKey, rcmgr network.ResourceManager, opts ...Option) (*WebRTCTransport, error) { localPeerId, err := peer.IDFromPrivateKey(privKey) if err != nil { - return nil, fmt.Errorf("could not get local peer ID: %v", err) + return nil, errInternal("could not get local peer ID", err) } + // We use elliptic P-256 since it is widely supported by browsers. + // See: https://github.com/libp2p/specs/pull/412#discussion_r968294244 pk, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) if err != nil { - return nil, fmt.Errorf("could not generate rsa key for cert: %v", err) + return nil, errInternal("could not generate key for cert", err) } cert, err := webrtc.GenerateCertificate(pk) if err != nil { - return nil, fmt.Errorf("could not generate certificate: %v", err) + return nil, errInternal("could not generate certificate", err) } config := webrtc.Configuration{ Certificates: []webrtc.Certificate{*cert}, } noiseTpt, err := noise.New(privKey) if err != nil { - return nil, fmt.Errorf("unable to create the noise transport") + return nil, errInternal("unable to create noise transport", err) } return &WebRTCTransport{rcmgr: rcmgr, webrtcConfig: config, privKey: privKey, noiseTpt: noiseTpt, localPeerId: localPeerId}, nil } @@ -86,20 +89,20 @@ func (t *WebRTCTransport) Listen(addr ma.Multiaddr) (tpt.Listener, error) { addr, wrtcComponent := ma.SplitLast(addr) isWebrtc := wrtcComponent.Equal(ma.StringCast("/webrtc")) if !isWebrtc { - return nil, fmt.Errorf("must listen on webrtc multiaddr") + return nil, errMultiaddr("must listen on webrtc multiaddr", nil) } nw, host, err := manet.DialArgs(addr) if err != nil { - return nil, fmt.Errorf("listener could not fetch dialargs: %v", err) + return nil, errMultiaddr("listener could not fetch dialargs", err) } udpAddr, err := net.ResolveUDPAddr(nw, host) if err != nil { - return nil, fmt.Errorf("listener could not resolve udp address: %v", err) + return nil, errMultiaddr("listener could not resolve udp address", err) } socket, err := net.ListenUDP(nw, udpAddr) if err != nil { - return nil, fmt.Errorf("could not listen on udp: %v", err) + return nil, errInternal("could not listen on udp", err) } // construct multiaddr @@ -170,19 +173,19 @@ func (t *WebRTCTransport) Dial( remoteMultihash, err := decodeRemoteFingerprint(remoteMultiaddr) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not decode remote multiaddr: %v", err) + return nil, errMultiaddr("could not decode fingerprint", err) } rnw, rhost, err := manet.DialArgs(remoteMultiaddr) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not generate dialargs: %v", err) + return nil, errMultiaddr("could not generate dial args", err) } raddr, err := net.ResolveUDPAddr(rnw, rhost) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not resolve udp address: %v", err) + return nil, errMultiaddr("could not resolve udp address", err) } // Instead of encoding the local fingerprint we @@ -193,7 +196,6 @@ func (t *WebRTCTransport) Dial( ufrag := uuid.New().String() se := webrtc.SettingEngine{} - // se.DetachDataChannels() se.SetICECredentials(ufrag, ufrag) se.SetLite(false) api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) @@ -201,7 +203,7 @@ func (t *WebRTCTransport) Dial( pc, err = api.NewPeerConnection(t.webrtcConfig) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not instantiate peerconnection: %v", err) + return nil, errInternal("could not instantiate peerconnection", err) } // We need to set negotiated = true for this channel on both @@ -213,39 +215,48 @@ func (t *WebRTCTransport) Dial( if err != nil { defer cleanup() - return nil, fmt.Errorf("could not create datachannel: %v", err) - } + return nil, errDatachannel("could not create", err) + } + + signalChan := make(chan struct{ error }) + dcOpenedChan := make(chan *dataChannel) + var connectedOnce sync.Once + pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) { + switch state { + case webrtc.PeerConnectionStateConnected: + connectedOnce.Do(func() { + signalChan <- struct{ error }{nil} + }) + case webrtc.PeerConnectionStateFailed: + connectedOnce.Do(func() { + err := errConnectionFailed("peerconnection move to failed state", nil) + signalChan <- struct{ error }{err} + }) + } + }) - opened := make(chan *dataChannel, 1) - errChan := make(chan error, 1) dc.OnOpen(func() { - // detached, err := dc.Detach() - // if err != nil { - // err = fmt.Errorf("could not detach datachannel: %v", err) - // errChan <- err - // return - // } cp, err := dc.Transport().Transport().ICETransport().GetSelectedCandidatePair() if cp == nil || err != nil { - err = fmt.Errorf("could not fetch selected candidate pair: %v", err) - errChan <- err + err = errDatachannel("could not fetch selected candidate pair", err) + signalChan <- struct{ error }{err} return } laddr := &net.UDPAddr{IP: net.ParseIP(cp.Local.Address), Port: int(cp.Local.Port)} - opened <- newDataChannel(dc, pc, laddr, raddr) + dcOpenedChan <- newDataChannel(dc, pc, laddr, raddr) }) offer, err := pc.CreateOffer(nil) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not create offer: %v", err) + return nil, errConnectionFailed("could not create offer", err) } err = pc.SetLocalDescription(offer) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not set local description: %v", err) + return nil, errConnectionFailed("could not set local description", err) } answerSdpString := renderServerSdp(sdpArgs{ @@ -258,19 +269,34 @@ func (t *WebRTCTransport) Dial( err = pc.SetRemoteDescription(answer) if err != nil { defer cleanup() - return nil, fmt.Errorf("could not set remote description: %v", err) + return nil, errConnectionFailed("could not set remote description", err) + } + + select { + case s := <-signalChan: + if s.error != nil { + return nil, err + } + case <-ctx.Done(): + scope.Done() + defer cleanup() + return nil, errDataChannelTimeout } var dataChannel *dataChannel = nil select { - case dataChannel = <-opened: - case err = <-errChan: + case dataChannel = <-dcOpenedChan: + case s := <-signalChan: defer cleanup() - return nil, err + if s.error != nil { + return nil, s.error + } + // should be unreachable + return nil, fmt.Errorf("should be unreachable") case <-ctx.Done(): scope.Done() defer cleanup() - return nil, ErrDataChannelTimeout + return nil, errDataChannelTimeout } localAddr, err := manet.FromNetAddr(dataChannel.LocalAddr()) @@ -374,20 +400,22 @@ func (t *WebRTCTransport) generateNoisePrologue(pc *webrtc.PeerConnection) ([]by func (t *WebRTCTransport) noiseHandshake(ctx context.Context, pc *webrtc.PeerConnection, datachannel *dataChannel, peer peer.ID, inbound bool) (secureConn sec.SecureConn, err error) { prologue, err := t.generateNoisePrologue(pc) if err != nil { - return nil, fmt.Errorf("could not generate noise prologue: %v", err) + return nil, errNoise("could not generate prologue", err) } sessionTransport, err := t.noiseTpt.WithSessionOptions(noise.Prologue(prologue)) if err != nil { - return nil, fmt.Errorf("could not instantiate noise session transport: %v", err) + return nil, errNoise("could not instantiate transport", err) } if inbound { secureConn, err = sessionTransport.SecureInbound(ctx, datachannel, peer) if err != nil { + err = errNoise("failed to secure inbound", err) return } } else { secureConn, err = sessionTransport.SecureOutbound(ctx, datachannel, peer) if err != nil { + err = errNoise("failed to secure outbound", err) return } } diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 9a7fbf6047..704a9df716 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -4,13 +4,14 @@ import ( "context" "fmt" "testing" - "time" "github.com/libp2p/go-libp2p/core/crypto" "github.com/libp2p/go-libp2p/core/network" "github.com/libp2p/go-libp2p/core/peer" tpt "github.com/libp2p/go-libp2p/core/transport" "github.com/multiformats/go-multiaddr" + "github.com/multiformats/go-multibase" + "github.com/multiformats/go-multihash" "github.com/stretchr/testify/require" ) @@ -77,7 +78,6 @@ func TestTransportWebRTC_CanListenSingle(t *testing.T) { tr1, connectingPeer := getTransport(t) go func() { - t.Logf("dialing: %s", listener.Multiaddr()) _, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) }() @@ -89,29 +89,32 @@ func TestTransportWebRTC_CanListenSingle(t *testing.T) { require.Equal(t, connectingPeer, conn.RemotePeer()) } -func TestTransportWebRTCCanListenMultiple(t *testing.T) { +func TestTransportWebRTC_CanListenMultiple(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) + count := 10 - for i := 0; i < 10; i++ { + for i := 0; i < count; i++ { go func() { ctr, _ := getTransport(t) conn, err := ctr.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) require.Equal(t, conn.RemotePeer(), listeningPeer) }() + // time.Sleep(50 * time.Millisecond) } - for i := 0; i < 10; i++ { + for i := 0; i < count; i++ { _, err := listener.Accept() require.NoError(t, err) + t.Logf("accepted connection: %d", i) } } -func TestTransportWebRTCListenerCanCreateStreams(t *testing.T) { +func TestTransportWebRTC_ListenerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) @@ -142,7 +145,7 @@ func TestTransportWebRTCListenerCanCreateStreams(t *testing.T) { require.NoError(t, err) } -func TestTransportWebRTCDialerCanCreateStreams(t *testing.T) { +func TestTransportWebRTC_DialerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) @@ -154,7 +157,6 @@ func TestTransportWebRTCDialerCanCreateStreams(t *testing.T) { go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) - time.Sleep(100 * time.Millisecond) stream, err := conn.OpenStream(context.Background()) require.NoError(t, err) _, err = stream.Write([]byte("test")) @@ -172,3 +174,36 @@ func TestTransportWebRTCDialerCanCreateStreams(t *testing.T) { require.NoError(t, err) require.Equal(t, "test", string(buf[:n])) } + +func TestTransportWebRTC_PeerConnectionDTLSFailed(t *testing.T) { + tr, listeningPeer := getTransport(t) + listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) + require.NoError(t, err) + listener, err := tr.Listen(listenMultiaddr) + require.NoError(t, err) + + tr1, _ := getTransport(t) + + go func() { + listener.Accept() + }() + + badMultiaddr, _ := multiaddr.SplitFunc(listener.Multiaddr(), func(component multiaddr.Component) bool { + return component.Protocol().Code == multiaddr.P_CERTHASH + }) + encodedCerthash, err := multihash.Encode(defaultMultihash.Digest, defaultMultihash.Code) + require.NoError(t, err) + badEncodedCerthash, err := multibase.Encode(multibase.Base58BTC, encodedCerthash) + require.NoError(t, err) + badCerthash, err := multiaddr.NewMultiaddr(fmt.Sprintf("/certhash/%s", badEncodedCerthash)) + require.NoError(t, err) + badMultiaddr = badMultiaddr.Encapsulate(badCerthash) + + _, err = tr1.Dial(context.Background(), badMultiaddr, listeningPeer) + require.Error(t, err) + webrtcErr, ok := err.(*webRTCTransportError) + require.True(t, ok, "could not cast to webRTCTransportError") + require.Equal(t, webrtcErr.kind, errKindConnectionFailed) + require.Contains(t, webrtcErr.message, "failed") + +} diff --git a/p2p/transport/webrtc/udp_mux.go b/p2p/transport/webrtc/udp_mux.go index b864a71e14..b12054fa2c 100644 --- a/p2p/transport/webrtc/udp_mux.go +++ b/p2p/transport/webrtc/udp_mux.go @@ -61,7 +61,7 @@ func NewUDPMuxNewAddr(params ice.UDPMuxParams, newAddrChan chan candidateAddr) * params: params, connsIPv4: make(map[string]*udpMuxedConn), connsIPv6: make(map[string]*udpMuxedConn), - closedChan: make(chan struct{}, 1), + closedChan: make(chan struct{}), pool: &sync.Pool{ New: func() interface{} { // big enough buffer to fit both packet and address @@ -294,7 +294,7 @@ func (m *udpMuxNewAddr) connWorker() { // notify that a new connection is requested if !ok { - log.Debugf("new connection requested: %v %v", udpAddr, ufrag) + // log.Debugf("new connection requested: %v %v", udpAddr, ufrag) m.newAddrChan <- candidateAddr{raddr: udpAddr, ufrag: ufrag} m.mu.Lock() m.newAddrs[udpAddr] = struct{}{} From 00770d002f4e4bb1d92db5f30fdad9141f1ec68a Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 13 Sep 2022 18:12:10 +0530 Subject: [PATCH 33/50] remove example --- examples/webrtc/README.md | 0 examples/webrtc/go.mod | 3 - examples/webrtc/main.go | 141 -------------------------------------- 3 files changed, 144 deletions(-) delete mode 100644 examples/webrtc/README.md delete mode 100644 examples/webrtc/go.mod delete mode 100644 examples/webrtc/main.go diff --git a/examples/webrtc/README.md b/examples/webrtc/README.md deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/examples/webrtc/go.mod b/examples/webrtc/go.mod deleted file mode 100644 index 13caca91c4..0000000000 --- a/examples/webrtc/go.mod +++ /dev/null @@ -1,3 +0,0 @@ -module github.com/libp2p/go-libp2p/examples/webrtc - -go 1.19 diff --git a/examples/webrtc/main.go b/examples/webrtc/main.go deleted file mode 100644 index 32830d326e..0000000000 --- a/examples/webrtc/main.go +++ /dev/null @@ -1,141 +0,0 @@ -package main - -import ( - "bufio" - "fmt" - "log" - "net" - "os" - "os/signal" - "syscall" - - "github.com/libp2p/go-libp2p" - "github.com/libp2p/go-libp2p/core/host" - "github.com/libp2p/go-libp2p/core/network" - "github.com/libp2p/go-libp2p/core/peer" - webrtc "github.com/libp2p/go-libp2p/p2p/transport/webrtc" -) - -var listenerIp = net.IPv4(0, 0, 0, 0) -func init() { - ifaces, err := net.Interfaces() - if err != nil { - return - } - for _, iface := range ifaces { - if iface.Flags&net.FlagUp == 0 { - continue - } - addrs, err := iface.Addrs() - if err != nil { - return - } - for _, addr := range addrs { - // bind to private non-loopback ip - if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.IsPrivate() { - if ipnet.IP.To4() != nil { - listenerIp = ipnet.IP.To4() - return - } - } - } - } -} - -func echoHandler(stream network.Stream) { - for { - reader := bufio.NewReader(stream) - str, err := reader.ReadString('\n') - if err != nil { - return - } - log.Printf("echo: %s", str) - _, err = stream.Write([]byte(str)) - if err != nil { - return - } - - } -} - -func main() { - host := createHost() - host.SetStreamHandler("/echo/1.0.0", echoHandler) - defer host.Close() - remoteInfo := peer.AddrInfo{ - ID: host.ID(), - Addrs: host.Network().ListenAddresses(), - } - - remoteAddrs, _ := peer.AddrInfoToP2pAddrs(&remoteInfo) - fmt.Println("p2p addr: ", remoteAddrs[0]) - - fmt.Println("press Ctrl+C to quit") - ch := make(chan os.Signal, 1) - signal.Notify(ch, syscall.SIGTERM, syscall.SIGINT) - <-ch -} - -func createHost() host.Host { - h, err := libp2p.New( - libp2p.Transport(webrtc.New), - libp2p.ListenAddrStrings( - fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp), - ), - libp2p.DisableRelay(), - libp2p.Ping(true), - ) - if err != nil { - panic(err) - } - - return h -} - -// func dialHost(ctx context.Context, server host.Host) { -// client, err := libp2p.New( -// libp2p.Transport(webrtc.New), -// libp2p.DisableRelay(), -// libp2p.Ping(true), -// ) -// if err != nil { -// panic(err) -// } - -// if err = server.ID().Validate(); err != nil { -// panic(err) -// } - -// remoteInfo := peer.AddrInfo{ -// ID: server.ID(), -// Addrs: server.Network().ListenAddresses(), -// } - -// remoteAddrs, err := peer.AddrInfoToP2pAddrs(&remoteInfo) -// fmt.Println("p2p addr: ", remoteAddrs) - -// fmt.Println("=========================== connecting ==============================") -// err = client.Connect(context.Background(), remoteInfo) -// if err != nil { -// panic(err) -// } -// fmt.Println("============================ connected ==============================") - -// resultChan := ping.Ping(ctx, server, server.ID()) - -// for i := 0; i < 5; i++ { -// select { -// case <-ctx.Done(): -// case result := <-resultChan: -// if result.Error != nil { -// fmt.Println("ping error", result.Error) -// } else { -// fmt.Println("pinged", remoteInfo.Addrs, " in ", result.RTT) -// } -// } - -// } - -// } - - From 12732c2fb2663e0deb9fd500ef204f96de9928aa Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 13 Sep 2022 18:31:28 +0530 Subject: [PATCH 34/50] fix dtls failure test --- p2p/transport/webrtc/sdp.go | 8 ++++---- p2p/transport/webrtc/transport.go | 3 ++- p2p/transport/webrtc/transport_test.go | 5 ++++- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/p2p/transport/webrtc/sdp.go b/p2p/transport/webrtc/sdp.go index eb283451c9..b397d70c40 100644 --- a/p2p/transport/webrtc/sdp.go +++ b/p2p/transport/webrtc/sdp.go @@ -13,7 +13,7 @@ type sdpArgs struct { Fingerprint *multihash.DecodedMultihash } -const CLIENT_SDP string = ` +const clientSDP string = ` v=0 o=- 0 0 IN %s %s s=- @@ -36,7 +36,7 @@ func renderClientSdp(args sdpArgs) string { ipVersion = "IP6" } return fmt.Sprintf( - CLIENT_SDP, + clientSDP, ipVersion, args.Addr.IP, ipVersion, @@ -48,7 +48,7 @@ func renderClientSdp(args sdpArgs) string { ) } -const SERVER_SDP string = ` +const serverSDP string = ` v=0 o=- 0 0 IN %s %s s=- @@ -74,7 +74,7 @@ func renderServerSdp(args sdpArgs) string { } fp := fingerprintToSDP(args.Fingerprint) return fmt.Sprintf( - SERVER_SDP, + serverSDP, ipVersion, args.Addr.IP, args.Addr.Port, diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index e9d89e8678..ab346caa78 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -230,6 +230,7 @@ func (t *WebRTCTransport) Dial( case webrtc.PeerConnectionStateFailed: connectedOnce.Do(func() { err := errConnectionFailed("peerconnection move to failed state", nil) + // log.Warn(err) signalChan <- struct{ error }{err} }) } @@ -275,7 +276,7 @@ func (t *WebRTCTransport) Dial( select { case s := <-signalChan: if s.error != nil { - return nil, err + return nil, s.error } case <-ctx.Done(): scope.Done() diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 704a9df716..66b287cdf8 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -191,6 +191,7 @@ func TestTransportWebRTC_PeerConnectionDTLSFailed(t *testing.T) { badMultiaddr, _ := multiaddr.SplitFunc(listener.Multiaddr(), func(component multiaddr.Component) bool { return component.Protocol().Code == multiaddr.P_CERTHASH }) + encodedCerthash, err := multihash.Encode(defaultMultihash.Digest, defaultMultihash.Code) require.NoError(t, err) badEncodedCerthash, err := multibase.Encode(multibase.Base58BTC, encodedCerthash) @@ -199,8 +200,10 @@ func TestTransportWebRTC_PeerConnectionDTLSFailed(t *testing.T) { require.NoError(t, err) badMultiaddr = badMultiaddr.Encapsulate(badCerthash) - _, err = tr1.Dial(context.Background(), badMultiaddr, listeningPeer) + conn, err := tr1.Dial(context.Background(), badMultiaddr, listeningPeer) + require.Nil(t, conn) require.Error(t, err) + webrtcErr, ok := err.(*webRTCTransportError) require.True(t, ok, "could not cast to webRTCTransportError") require.Equal(t, webrtcErr.kind, errKindConnectionFailed) From 7b6db785e69d1d4b8c34981162487316f4962d04 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 13 Sep 2022 19:03:59 +0530 Subject: [PATCH 35/50] cleanup datachannels --- p2p/transport/webrtc/connection.go | 17 +++--- p2p/transport/webrtc/transport_test.go | 78 +++++++++++++++++--------- 2 files changed, 59 insertions(+), 36 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index e16f59de2b..ce346b6bbc 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -51,7 +51,7 @@ func newConnection( remoteKey ic.PubKey, remoteMultiaddr ma.Multiaddr, ) (*connection, error) { - accept := make(chan network.MuxedStream) + accept := make(chan network.MuxedStream, 10) ctx, cancel := context.WithCancel(context.Background()) @@ -88,6 +88,7 @@ func newConnection( conn.removeStream(id) }) }) + return conn, nil } @@ -123,18 +124,15 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error } label := uuid.New().String() - dc, err := c.pc.CreateDataChannel(label, &webrtc.DataChannelInit{ - Ordered: func(b bool) *bool { return &b }(true), - MaxRetransmits: func(x uint16) *uint16 { return &x }(100), + result := make(chan struct { + network.MuxedStream + error }) - dc.SetBufferedAmountLowThreshold(0) + dc, err := c.pc.CreateDataChannel(label, nil) if err != nil { return nil, err } - result := make(chan struct { - network.MuxedStream - error - }, 1) + streamId := *dc.ID() stream := newDataChannel(dc, c.pc, nil, nil) dc.OnOpen(func() { @@ -144,6 +142,7 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error error }{stream, err} }) + dc.OnClose(func() { stream.remoteClosed() c.removeStream(streamId) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 66b287cdf8..ffc1f9f277 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "testing" + "time" "github.com/libp2p/go-libp2p/core/crypto" "github.com/libp2p/go-libp2p/core/network" @@ -70,13 +71,12 @@ func TestTransportWebRTC_ListenFailsOnNonWebRTCMultiaddr(t *testing.T) { func TestTransportWebRTC_CanListenSingle(t *testing.T) { tr, listeningPeer := getTransport(t) + tr1, connectingPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) - tr1, connectingPeer := getTransport(t) - go func() { _, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) @@ -95,7 +95,7 @@ func TestTransportWebRTC_CanListenMultiple(t *testing.T) { require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) - count := 10 + count := 5 for i := 0; i < count; i++ { go func() { @@ -104,45 +104,57 @@ func TestTransportWebRTC_CanListenMultiple(t *testing.T) { require.NoError(t, err) require.Equal(t, conn.RemotePeer(), listeningPeer) }() - // time.Sleep(50 * time.Millisecond) + time.Sleep(50 * time.Millisecond) } for i := 0; i < count; i++ { _, err := listener.Accept() require.NoError(t, err) - t.Logf("accepted connection: %d", i) + t.Logf("listener accepted connection: %d", i) } } func TestTransportWebRTC_ListenerCanCreateStreams(t *testing.T) { tr, listeningPeer := getTransport(t) + tr1, connectingPeer := getTransport(t) listenMultiaddr, err := multiaddr.NewMultiaddr(fmt.Sprintf("/ip4/%s/udp/0/webrtc", listenerIp)) require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) - tr1, connectingPeer := getTransport(t) + go func() { + conn, err := listener.Accept() + require.NoError(t, err) + + require.Equal(t, connectingPeer, conn.RemotePeer()) + + stream, err := conn.OpenStream(context.Background()) + require.NoError(t, err) + _, err = stream.Write([]byte("test")) + require.NoError(t, err) + }() + streamChan := make(chan network.MuxedStream) go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) stream, err := conn.AcceptStream() require.NoError(t, err) - buf := make([]byte, 100) - n, err := stream.Read(buf) - require.NoError(t, err) - require.Equal(t, "test", string(buf[:n])) + streamChan <- stream }() - conn, err := listener.Accept() + var stream network.MuxedStream + select { + case stream = <-streamChan: + case <-time.After(3 * time.Second): + t.Fatal("stream opening timed out") + } + buf := make([]byte, 100) + stream.SetReadDeadline(time.Now().Add(3 * time.Second)) + n, err := stream.Read(buf) require.NoError(t, err) + require.Equal(t, "test", string(buf[:n])) - require.Equal(t, connectingPeer, conn.RemotePeer()) - - stream, err := conn.OpenStream(context.Background()) - require.NoError(t, err) - _, err = stream.Write([]byte("test")) - require.NoError(t, err) } func TestTransportWebRTC_DialerCanCreateStreams(t *testing.T) { @@ -153,6 +165,22 @@ func TestTransportWebRTC_DialerCanCreateStreams(t *testing.T) { require.NoError(t, err) tr1, connectingPeer := getTransport(t) + done := make(chan struct{}) + + go func() { + lconn, err := listener.Accept() + require.NoError(t, err) + require.Equal(t, connectingPeer, lconn.RemotePeer()) + + stream, err := lconn.AcceptStream() + require.NoError(t, err) + buf := make([]byte, 100) + n, err := stream.Read(buf) + require.NoError(t, err) + require.Equal(t, "test", string(buf[:n])) + + done <- struct{}{} + }() go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) @@ -161,18 +189,14 @@ func TestTransportWebRTC_DialerCanCreateStreams(t *testing.T) { require.NoError(t, err) _, err = stream.Write([]byte("test")) require.NoError(t, err) - }() - lconn, err := listener.Accept() - require.NoError(t, err) - require.Equal(t, connectingPeer, lconn.RemotePeer()) + }() + select { + case <-done: + case <-time.After(10 * time.Second): + t.Fatal("timed out") + } - stream, err := lconn.AcceptStream() - require.NoError(t, err) - buf := make([]byte, 100) - n, err := stream.Read(buf) - require.NoError(t, err) - require.Equal(t, "test", string(buf[:n])) } func TestTransportWebRTC_PeerConnectionDTLSFailed(t *testing.T) { From bac8ff490dac4daaaeb141b6fb5021ae34e74775 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 13 Sep 2022 19:26:07 +0530 Subject: [PATCH 36/50] fix deadline tests running until timeout --- p2p/transport/webrtc/deadline_test.go | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/p2p/transport/webrtc/deadline_test.go b/p2p/transport/webrtc/deadline_test.go index 6a31145439..82f2fd7fec 100644 --- a/p2p/transport/webrtc/deadline_test.go +++ b/p2p/transport/webrtc/deadline_test.go @@ -23,7 +23,12 @@ func TestDeadlineExtend(t *testing.T) { timer := time.AfterFunc(300*time.Millisecond, func() { dl.set(start.Add(1000 * time.Millisecond)) }) - <-done + + select { + case <-done: + case <-time.After(5 * time.Second): + t.Fatal() + } timer.Stop() } @@ -36,12 +41,16 @@ func TestDeadlineSetToPast(t *testing.T) { end := time.Now() d := end.Sub(start) require.GreaterOrEqual(t, d, 200*time.Millisecond) - require.LessOrEqual(t, d, 400*time.Millisecond) + require.LessOrEqual(t, d, 500*time.Millisecond) close(done) }() timer := time.AfterFunc(300*time.Millisecond, func() { dl.set(start.Add(200 * time.Millisecond)) }) - <-done + select { + case <-done: + case <-time.After(5 * time.Second): + t.Fatal() + } timer.Stop() } From cff28c111f3e8b620d1c09b3041090ce65b936f2 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Tue, 13 Sep 2022 19:58:02 +0530 Subject: [PATCH 37/50] fix error condition --- p2p/transport/webrtc/listener.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 054f642c05..560b1b403d 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -255,9 +255,9 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC select { case s := <-signalChan: if s.error != nil { - log.Debug("peerconnection error", err) + log.Debug("peerconnection error", s.error) defer cleanup() - return nil, err + return nil, s.error } case <-ctx.Done(): defer cleanup() From 8103da30093ad51d8e5bf3420983e78115d37735 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 14 Sep 2022 15:33:11 +0530 Subject: [PATCH 38/50] lagging listener --- p2p/transport/webrtc/listener.go | 67 +++++++------------------- p2p/transport/webrtc/transport_test.go | 3 +- 2 files changed, 18 insertions(+), 52 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 560b1b403d..84f0d6fd88 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -3,7 +3,6 @@ package libp2pwebrtc import ( "context" "encoding/hex" - "fmt" "net" "os" "strings" @@ -146,16 +145,12 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC var ( scope network.ConnManagementScope pc *webrtc.PeerConnection - dc *dataChannel ) cleanup := func() { if scope != nil { scope.Done() } - if dc != nil { - _ = dc.Close() - } if pc != nil { _ = pc.Close() } @@ -175,14 +170,14 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC // signaling channel wraps an error in a struct to make // the error nullable. - se := webrtc.SettingEngine{} - se.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) - se.SetICECredentials(addr.ufrag, addr.ufrag) - se.SetLite(true) - se.SetICEUDPMux(l.mux) - se.DisableCertificateFingerprintVerification(true) + settingEngine := webrtc.SettingEngine{} + settingEngine.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) + settingEngine.SetICECredentials(addr.ufrag, addr.ufrag) + settingEngine.SetLite(true) + settingEngine.SetICEUDPMux(l.mux) + settingEngine.DisableCertificateFingerprintVerification(true) - api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) + api := webrtc.NewAPI(webrtc.WithSettingEngine(settingEngine)) pc, err = api.NewPeerConnection(l.config) if err != nil { @@ -191,19 +186,10 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC } signalChan := make(chan struct{ error }) - dcChan := make(chan *dataChannel) - var connectedOnce sync.Once - pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) { - switch state { - case webrtc.PeerConnectionStateConnected: - connectedOnce.Do(func() { signalChan <- struct{ error }{nil} }) - case webrtc.PeerConnectionStateFailed: - connectedOnce.Do(func() { signalChan <- struct{ error }{fmt.Errorf("peerconnection failed to connect")} }) - } - }) - // this enforces that the correct data channel label is used // for the handshake + // we create the data channel early and set up the callbacks to buffer + // data handshakeChannel, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ Negotiated: func(v bool) *bool { return &v }(true), ID: func(v uint16) *uint16 { return &v }(1), @@ -212,16 +198,17 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC defer cleanup() return nil, err } + wrappedChannel := newDataChannel( + handshakeChannel, + pc, + l.mux.LocalAddr(), + addr.raddr, + ) var handshakeOnce sync.Once handshakeChannel.OnOpen(func() { handshakeOnce.Do(func() { - dcChan <- newDataChannel( - handshakeChannel, - pc, - l.mux.LocalAddr(), - addr.raddr, - ) + signalChan <- struct{ error }{nil} }) }) handshakeChannel.OnError(func(e error) { @@ -251,35 +238,15 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } - // await peerconnection connected state - select { - case s := <-signalChan: - if s.error != nil { - log.Debug("peerconnection error", s.error) - defer cleanup() - return nil, s.error - } - case <-ctx.Done(): - defer cleanup() - return nil, ctx.Err() - } - // await opening of datachannel select { case <-ctx.Done(): defer cleanup() return nil, ctx.Err() - case dc = <-dcChan: - if dc == nil { - defer cleanup() - return nil, fmt.Errorf("should be unreachable") - } case s := <-signalChan: if s.error != nil { log.Debugf("datachannel: ", s.error) return nil, errDatachannel("datachannel error", s.error) - } else { - return nil, fmt.Errorf("should be unreachable") } } @@ -301,7 +268,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC } // we do not yet know A's peer ID so accept any inbound - secureConn, err := l.transport.noiseHandshake(ctx, pc, dc, "", true) + secureConn, err := l.transport.noiseHandshake(ctx, pc, wrappedChannel, "", true) if err != nil { defer cleanup() return nil, err diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index ffc1f9f277..be444f8eb1 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -95,7 +95,7 @@ func TestTransportWebRTC_CanListenMultiple(t *testing.T) { require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) - count := 5 + count := 100 for i := 0; i < count; i++ { go func() { @@ -104,7 +104,6 @@ func TestTransportWebRTC_CanListenMultiple(t *testing.T) { require.NoError(t, err) require.Equal(t, conn.RemotePeer(), listeningPeer) }() - time.Sleep(50 * time.Millisecond) } for i := 0; i < count; i++ { From 37e56864913f8247edd679604b3c118a2e247a16 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 14 Sep 2022 16:00:49 +0530 Subject: [PATCH 39/50] cleanup dialer and listener --- go.mod | 5 ++- go.sum | 17 +++++--- p2p/transport/webrtc/connection.go | 4 +- p2p/transport/webrtc/datachannel.go | 3 ++ p2p/transport/webrtc/listener.go | 16 +++----- p2p/transport/webrtc/transport.go | 57 +++++++++++++------------- p2p/transport/webrtc/transport_test.go | 2 +- 7 files changed, 54 insertions(+), 50 deletions(-) diff --git a/go.mod b/go.mod index de22c47f48..9da9a098c5 100644 --- a/go.mod +++ b/go.mod @@ -60,8 +60,8 @@ require ( go.opencensus.io v0.23.0 go.uber.org/goleak v1.1.12 golang.org/x/crypto v0.0.0-20220829220503-c86fa9a7ed90 - golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde - golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 + golang.org/x/sync v0.0.0-20220907140024-f12130a52804 + golang.org/x/sys v0.0.0-20220913175220-63ea55921009 ) require ( @@ -88,6 +88,7 @@ require ( github.com/jbenet/goprocess v0.1.4 // indirect github.com/klauspost/cpuid/v2 v2.1.1 // indirect github.com/koron/go-ssdp v0.0.3 // indirect + github.com/kr/pretty v0.3.0 // indirect github.com/libp2p/go-cidranger v1.1.0 // indirect github.com/marten-seemann/qpack v0.2.1 // indirect github.com/marten-seemann/qtls-go1-18 v0.1.2 // indirect diff --git a/go.sum b/go.sum index d9fcd167de..fa5d08bb78 100644 --- a/go.sum +++ b/go.sum @@ -83,6 +83,7 @@ github.com/coreos/go-systemd/v22 v22.4.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSV github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -285,12 +286,14 @@ github.com/koron/go-ssdp v0.0.3/go.mod h1:b2MxI6yh02pKrsyNoQUsk4+YNikaGhe4894J+Q github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8= github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg= github.com/libp2p/go-cidranger v1.1.0 h1:ewPN8EZ0dd1LSnrtuwd4709PXVcITVeuwbag38yPW7c= @@ -494,6 +497,8 @@ github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0ua github.com/raulk/go-watchdog v1.3.0 h1:oUmdlHxdkXRJlwfG0O9omj8ukerm8MEQavSiDTEtBsk= github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtDqv66NfsMU= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.6.1 h1:/FiVV8dS/e+YqF2JvO3yXRFbBLTIuSDkuC7aBOAvL+k= +github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw= @@ -720,8 +725,8 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde h1:ejfdSekXMDxDLbRrJMwUk6KnSLZ2McaUCVcIKM+N6jc= -golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220907140024-f12130a52804 h1:0SH2R3f1b1VmIMG7BXbEZCBUu2dKmHschSmjqGUrW8A= +golang.org/x/sync v0.0.0-20220907140024-f12130a52804/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -789,8 +794,8 @@ golang.org/x/sys v0.0.0-20220608164250-635b8c9b7f68/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220622161953-175b2fd9d664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY= -golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220913175220-63ea55921009 h1:PuvuRMeLWqsf/ZdT1UUZz0syhioyv1mzuFZsXs4fvhw= +golang.org/x/sys v0.0.0-20220913175220-63ea55921009/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index ce346b6bbc..bf70d8b787 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -50,7 +50,7 @@ func newConnection( remotePeer peer.ID, remoteKey ic.PubKey, remoteMultiaddr ma.Multiaddr, -) (*connection, error) { +) *connection { accept := make(chan network.MuxedStream, 10) ctx, cancel := context.WithCancel(context.Background()) @@ -89,7 +89,7 @@ func newConnection( }) }) - return conn, nil + return conn } // Implement network.MuxedConn diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 771683d913..21bfedd53f 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -268,12 +268,15 @@ func (d *dataChannel) SetWriteDeadline(t time.Time) error { func (d *dataChannel) isRemoteWriteClosed() bool { return atomic.LoadUint32(&d.remoteWriteClosed) == 1 } + func (d *dataChannel) isLocalWriteClosed() bool { return atomic.LoadUint32(&d.localWriteClosed) == 1 } + func (d *dataChannel) isRemoteReadClosed() bool { return atomic.LoadUint32(&d.remoteReadClosed) == 1 } + func (d *dataChannel) isLocalReadClosed() bool { return atomic.LoadUint32(&d.localReadClosed) == 1 } diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 84f0d6fd88..20feea2e6d 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -243,14 +243,15 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC case <-ctx.Done(): defer cleanup() return nil, ctx.Err() - case s := <-signalChan: - if s.error != nil { - log.Debugf("datachannel: ", s.error) - return nil, errDatachannel("datachannel error", s.error) + case signal := <-signalChan: + if signal.error != nil { + defer cleanup() + log.Debugf("datachannel: ", signal.error) + return nil, errDatachannel("datachannel error", signal.error) } } - conn, err := newConnection( + conn := newConnection( pc, l.transport, scope, @@ -262,11 +263,6 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC remoteMultiaddr, ) - if err != nil { - defer cleanup() - return nil, err - } - // we do not yet know A's peer ID so accept any inbound secureConn, err := l.transport.noiseHandshake(ctx, pc, wrappedChannel, "", true) if err != nil { diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index ab346caa78..a09e6ac2c9 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -147,7 +147,10 @@ func (t *WebRTCTransport) Dial( remoteMultiaddr ma.Multiaddr, p peer.ID, ) (tpt.CapableConn, error) { - var pc *webrtc.PeerConnection + var ( + pc *webrtc.PeerConnection + wrappedChannel *dataChannel + ) scope, err := t.rcmgr.OpenConnection(network.DirOutbound, false, remoteMultiaddr) cleanup := func() { @@ -195,10 +198,10 @@ func (t *WebRTCTransport) Dial( // the password using the STUN message. ufrag := uuid.New().String() - se := webrtc.SettingEngine{} - se.SetICECredentials(ufrag, ufrag) - se.SetLite(false) - api := webrtc.NewAPI(webrtc.WithSettingEngine(se)) + settingEngine := webrtc.SettingEngine{} + settingEngine.SetICECredentials(ufrag, ufrag) + settingEngine.SetLite(false) + api := webrtc.NewAPI(webrtc.WithSettingEngine(settingEngine)) pc, err = api.NewPeerConnection(t.webrtcConfig) if err != nil { @@ -208,7 +211,7 @@ func (t *WebRTCTransport) Dial( // We need to set negotiated = true for this channel on both // the client and server to avoid DCEP errors. - dc, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ + handshakeChannel, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ Negotiated: func(v bool) *bool { return &v }(true), ID: func(v uint16) *uint16 { return &v }(1), }) @@ -219,7 +222,6 @@ func (t *WebRTCTransport) Dial( } signalChan := make(chan struct{ error }) - dcOpenedChan := make(chan *dataChannel) var connectedOnce sync.Once pc.OnConnectionStateChange(func(state webrtc.PeerConnectionState) { switch state { @@ -230,14 +232,14 @@ func (t *WebRTCTransport) Dial( case webrtc.PeerConnectionStateFailed: connectedOnce.Do(func() { err := errConnectionFailed("peerconnection move to failed state", nil) - // log.Warn(err) signalChan <- struct{ error }{err} }) } }) - dc.OnOpen(func() { - cp, err := dc.Transport().Transport().ICETransport().GetSelectedCandidatePair() + wrappedChannel = newDataChannel(handshakeChannel, pc, nil, raddr) + handshakeChannel.OnOpen(func() { + cp, err := handshakeChannel.Transport().Transport().ICETransport().GetSelectedCandidatePair() if cp == nil || err != nil { err = errDatachannel("could not fetch selected candidate pair", err) signalChan <- struct{ error }{err} @@ -245,9 +247,11 @@ func (t *WebRTCTransport) Dial( } laddr := &net.UDPAddr{IP: net.ParseIP(cp.Local.Address), Port: int(cp.Local.Port)} - dcOpenedChan <- newDataChannel(dc, pc, laddr, raddr) + wrappedChannel.laddr = laddr + signalChan <- struct{ error }{nil} }) + // do offer-answer exchange offer, err := pc.CreateOffer(nil) if err != nil { defer cleanup() @@ -273,10 +277,12 @@ func (t *WebRTCTransport) Dial( return nil, errConnectionFailed("could not set remote description", err) } + // await peerconnection opening select { - case s := <-signalChan: - if s.error != nil { - return nil, s.error + case signal := <-signalChan: + if signal.error != nil { + defer cleanup() + return nil, signal.error } case <-ctx.Done(): scope.Done() @@ -284,29 +290,26 @@ func (t *WebRTCTransport) Dial( return nil, errDataChannelTimeout } - var dataChannel *dataChannel = nil + // await datachannel opening select { - case dataChannel = <-dcOpenedChan: - case s := <-signalChan: - defer cleanup() - if s.error != nil { - return nil, s.error + case signal := <-signalChan: + if signal.error != nil { + defer cleanup() + return nil, signal.error } - // should be unreachable - return nil, fmt.Errorf("should be unreachable") case <-ctx.Done(): scope.Done() defer cleanup() return nil, errDataChannelTimeout } - localAddr, err := manet.FromNetAddr(dataChannel.LocalAddr()) + localAddr, err := manet.FromNetAddr(wrappedChannel.LocalAddr()) if err != nil { defer cleanup() return nil, err } - conn, err := newConnection( + conn := newConnection( pc, t, scope, @@ -317,11 +320,7 @@ func (t *WebRTCTransport) Dial( nil, remoteMultiaddr, ) - if err != nil { - defer cleanup() - return nil, err - } - secureConn, err := t.noiseHandshake(ctx, pc, dataChannel, p, false) + secureConn, err := t.noiseHandshake(ctx, pc, wrappedChannel, p, false) if err != nil { defer cleanup() return nil, err diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index be444f8eb1..1f25494f99 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -95,7 +95,7 @@ func TestTransportWebRTC_CanListenMultiple(t *testing.T) { require.NoError(t, err) listener, err := tr.Listen(listenMultiaddr) require.NoError(t, err) - count := 100 + count := 5 for i := 0; i < count; i++ { go func() { From 700949ec55481cec1217c515215d6dde7ddf019b Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 14 Sep 2022 17:35:13 +0530 Subject: [PATCH 40/50] cleanup --- p2p/transport/webrtc/listener.go | 27 ++++++++++++++++++++++----- p2p/transport/webrtc/transport.go | 3 +++ 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index 20feea2e6d..ecad6770e5 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -167,8 +167,6 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } - // signaling channel wraps an error in a struct to make - // the error nullable. settingEngine := webrtc.SettingEngine{} settingEngine.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) @@ -185,11 +183,11 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } + // signaling channel wraps an error in a struct to make + // the error nullable. signalChan := make(chan struct{ error }) // this enforces that the correct data channel label is used // for the handshake - // we create the data channel early and set up the callbacks to buffer - // data handshakeChannel, err := pc.CreateDataChannel("data", &webrtc.DataChannelInit{ Negotiated: func(v bool) *bool { return &v }(true), ID: func(v uint16) *uint16 { return &v }(1), @@ -198,6 +196,18 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC defer cleanup() return nil, err } + + // The raw datachannel is wrapped in the libp2p abstraction + // as early as possible to allow any messages sent by the remote + // to be buffered. This is done since the dialer leads the listener + // in the handshake process, and a faster dialer could have set up + // their connection and started sending Noise handshake messages before + // the listener has set up the onmessage callback. In this use case, + // since the data channels are negotiated out-of-band, they will be + // instantly in `readyState=open` once the SCTP connection is set up. + // Therefore, we wrap the datachannel before performing the + // offer-answer exchange, so any messages sent from the remote get + // buffered. wrappedChannel := newDataChannel( handshakeChannel, pc, @@ -211,6 +221,10 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC signalChan <- struct{ error }{nil} }) }) + + // Checking the peerconnection state is not necessary in this case as any + // error caused while accepting will trigger the onerror callback of the + // handshake channel. handshakeChannel.OnError(func(e error) { handshakeOnce.Do(func() { signalChan <- struct{ error }{e} @@ -238,7 +252,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } - // await opening of datachannel + // await datachannel moving to open state select { case <-ctx.Done(): defer cleanup() @@ -251,6 +265,9 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC } } + // The connection is instantiated before performing the Noise handshake. This is + // to handle the case where the remote is faster and attempts to initiate a stream + // before the ondatachannel callback can be set. conn := newConnection( pc, l.transport, diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index a09e6ac2c9..24999c18e3 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -303,6 +303,9 @@ func (t *WebRTCTransport) Dial( return nil, errDataChannelTimeout } + // the local address of the selected candidate pair should be the + // local address for the connection, since different datachannels + // are multiplexed over the same SCTP connection localAddr, err := manet.FromNetAddr(wrappedChannel.LocalAddr()) if err != nil { defer cleanup() From 3aaed7c9b6aaac0b340397eda7db702585b8ae76 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 14 Sep 2022 17:46:06 +0530 Subject: [PATCH 41/50] fmt listener.go --- p2p/transport/webrtc/listener.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index ecad6770e5..cab9f02f43 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -167,7 +167,6 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC return nil, err } - settingEngine := webrtc.SettingEngine{} settingEngine.SetAnsweringDTLSRole(webrtc.DTLSRoleServer) settingEngine.SetICECredentials(addr.ufrag, addr.ufrag) @@ -205,7 +204,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC // the listener has set up the onmessage callback. In this use case, // since the data channels are negotiated out-of-band, they will be // instantly in `readyState=open` once the SCTP connection is set up. - // Therefore, we wrap the datachannel before performing the + // Therefore, we wrap the datachannel before performing the // offer-answer exchange, so any messages sent from the remote get // buffered. wrappedChannel := newDataChannel( From 56d7ca06839e13cdd100b7b8c39ae070c2718169 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 14 Sep 2022 18:01:28 +0530 Subject: [PATCH 42/50] add logging to tests --- p2p/transport/webrtc/transport_test.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 1f25494f99..0738e6314e 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -124,11 +124,13 @@ func TestTransportWebRTC_ListenerCanCreateStreams(t *testing.T) { go func() { conn, err := listener.Accept() require.NoError(t, err) + t.Logf("listener accepted connection") require.Equal(t, connectingPeer, conn.RemotePeer()) stream, err := conn.OpenStream(context.Background()) require.NoError(t, err) + t.Logf("stream opened by listener") _, err = stream.Write([]byte("test")) require.NoError(t, err) }() @@ -137,8 +139,10 @@ func TestTransportWebRTC_ListenerCanCreateStreams(t *testing.T) { go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) + t.Logf("connection opened by dialer") stream, err := conn.AcceptStream() require.NoError(t, err) + t.Logf("dialer accepted stream") streamChan <- stream }() @@ -169,10 +173,12 @@ func TestTransportWebRTC_DialerCanCreateStreams(t *testing.T) { go func() { lconn, err := listener.Accept() require.NoError(t, err) + t.Logf("listener accepted connection") require.Equal(t, connectingPeer, lconn.RemotePeer()) stream, err := lconn.AcceptStream() require.NoError(t, err) + t.Logf("listener accepted stream") buf := make([]byte, 100) n, err := stream.Read(buf) require.NoError(t, err) From 1e0375f10d467171485c648f8b1cbfcc09e41977 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 14 Sep 2022 18:02:37 +0530 Subject: [PATCH 43/50] add logging to tests --- p2p/transport/webrtc/transport_test.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/p2p/transport/webrtc/transport_test.go b/p2p/transport/webrtc/transport_test.go index 0738e6314e..ef24790a26 100644 --- a/p2p/transport/webrtc/transport_test.go +++ b/p2p/transport/webrtc/transport_test.go @@ -130,7 +130,7 @@ func TestTransportWebRTC_ListenerCanCreateStreams(t *testing.T) { stream, err := conn.OpenStream(context.Background()) require.NoError(t, err) - t.Logf("stream opened by listener") + t.Logf("listener opened stream") _, err = stream.Write([]byte("test")) require.NoError(t, err) }() @@ -190,8 +190,10 @@ func TestTransportWebRTC_DialerCanCreateStreams(t *testing.T) { go func() { conn, err := tr1.Dial(context.Background(), listener.Multiaddr(), listeningPeer) require.NoError(t, err) + t.Logf("dialer opened connection") stream, err := conn.OpenStream(context.Background()) require.NoError(t, err) + t.Logf("dialer opened stream") _, err = stream.Write([]byte("test")) require.NoError(t, err) From 54f95355adbd54e09610dddfaaa10e3e5ac8ecb2 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Sun, 9 Oct 2022 22:15:06 +0530 Subject: [PATCH 44/50] use backpressure in sctp layer --- p2p/transport/webrtc/connection.go | 27 +++- p2p/transport/webrtc/datachannel.go | 191 ++++++++++++++++------------ p2p/transport/webrtc/listener.go | 20 ++- p2p/transport/webrtc/transport.go | 8 +- 4 files changed, 155 insertions(+), 91 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index bf70d8b787..f1759665a6 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -77,8 +77,15 @@ func newConnection( pc.OnDataChannel(func(dc *webrtc.DataChannel) { log.Debugf("[%s] incoming datachannel: %s", localPeer, dc.Label()) id := *dc.ID() - stream := newDataChannel(dc, pc, nil, nil) + var stream *dataChannel dc.OnOpen(func() { + // datachannel cannot be detached before opening + rwc, err := dc.Detach() + if err != nil { + log.Errorf("[%s] could not detch channel: %s", localPeer, dc.Label()) + return + } + stream = newDataChannel(dc, rwc, pc, nil, nil) conn.addStream(id, stream) accept <- stream }) @@ -92,6 +99,11 @@ func newConnection( return conn } +// ConnState implements transport.CapableConn +func (c *connection) ConnState() network.ConnectionState { + return network.ConnectionState{} +} + // Implement network.MuxedConn func (c *connection) Close() error { @@ -134,8 +146,19 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error } streamId := *dc.ID() - stream := newDataChannel(dc, c.pc, nil, nil) + var stream *dataChannel dc.OnOpen(func() { + rwc, err := dc.Detach() + if err != nil { + result <- struct { + network.MuxedStream + error + }{nil, + errDatachannel("could not detach", err), + } + return + } + stream = newDataChannel(dc, rwc, c.pc, nil, nil) c.addStream(streamId, stream) result <- struct { network.MuxedStream diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 21bfedd53f..e2900d1e69 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -15,6 +15,8 @@ import ( "sync/atomic" "github.com/libp2p/go-libp2p/core/network" + "github.com/libp2p/go-msgio/protoio" + "github.com/pion/datachannel" "github.com/pion/webrtc/v3" pb "github.com/libp2p/go-libp2p/p2p/transport/webrtc/pb" @@ -22,8 +24,6 @@ import ( var _ network.MuxedStream = &dataChannel{} -const defaultReadBufferLen = 4096 - // Package pion detached data channel into a net.Conn // and then a network.MuxedStream type dataChannel struct { @@ -44,15 +44,17 @@ type dataChannel struct { remoteReadClosed uint32 localReadClosed uint32 - ctx context.Context - cancel context.CancelFunc - m sync.Mutex - readBuf bytes.Buffer - readSignal chan struct{} + ctx context.Context + cancel context.CancelFunc + m sync.Mutex + readBuf bytes.Buffer + writer protoio.Writer + reader protoio.Reader } func newDataChannel( channel *webrtc.DataChannel, + rwc datachannel.ReadWriteCloser, pc *webrtc.PeerConnection, laddr, raddr net.Addr) *dataChannel { ctx, cancel := context.WithCancel(context.Background()) @@ -65,57 +67,97 @@ func newDataChannel( writeDeadline: newDeadline(), ctx: ctx, cancel: cancel, - readSignal: make(chan struct{}), + writer: protoio.NewDelimitedWriter(rwc), + reader: protoio.NewDelimitedReader(rwc, 1500), } - result.readBuf.Grow(defaultReadBufferLen) - channel.OnMessage(result.handleMessage) + // channel.OnMessage(result.handleMessage) return result } -func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { - if msg.IsString { - log.Warnf("received string message") - return - } - - var pbmsg pb.Message - if err := pbmsg.Unmarshal(msg.Data); err != nil { - log.Warnf("could not unmarshal protobuf message") - return - } - - if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { - d.m.Lock() - d.readBuf.Write(pbmsg.GetMessage()) - // n, err := d.readBuf.Write(pbmsg.GetMessage()) - // log.Warnf("wrote %d bytes to buffer, msg size: %d: %v", n, len(pbmsg.GetMessage()), err) - d.m.Unlock() - select { - case d.readSignal <- struct{}{}: - default: - } +// func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { +// if msg.IsString { +// log.Warnf("received string message") +// return +// } + +// var pbmsg pb.Message +// if err := pbmsg.Unmarshal(msg.Data); err != nil { +// log.Warnf("could not unmarshal protobuf message") +// return +// } + +// if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { +// d.m.Lock() +// d.readBuf.Write(pbmsg.GetMessage()) +// // n, err := d.readBuf.Write(pbmsg.GetMessage()) +// // log.Warnf("wrote %d bytes to buffer, msg size: %d: %v", n, len(pbmsg.GetMessage()), err) +// d.m.Unlock() +// select { +// case d.readSignal <- struct{}{}: +// default: +// } +// } + +// if pbmsg.Flag != nil { +// switch pbmsg.GetFlag() { +// case pb.Message_FIN: +// atomic.StoreUint32(&d.remoteWriteClosed, 1) +// select { +// case <-d.readSignal: +// default: +// close(d.readSignal) +// } + +// case pb.Message_STOP_SENDING: +// atomic.StoreUint32(&d.remoteReadClosed, 1) +// case pb.Message_RESET: +// log.Errorf("remote reset") +// d.Close() +// } +// } + +// } + +// func (d *dataChannel) Read(b []byte) (int, error) { +// for { +// select { +// case <-d.readDeadline.wait(): +// return 0, os.ErrDeadlineExceeded +// default: +// } + +// d.m.Lock() +// read, err := d.readBuf.Read(b) +// d.m.Unlock() +// if err == io.EOF && d.isRemoteWriteClosed() { +// return read, io.EOF +// } +// // log.Warnf("read %d bytes: %s", read, string(b[:read])) +// if read > 0 { +// return read, nil +// } + +// // log.Warnf("waiting for read") +// select { +// case <-d.readSignal: +// case <-d.ctx.Done(): +// return 0, d.ctx.Err() +// case <-d.readDeadline.wait(): +// return 0, os.ErrDeadlineExceeded +// } +// } +// } + +func (d *dataChannel) processControlMessage(msg pb.Message) { + switch msg.GetFlag() { + case pb.Message_FIN: + atomic.StoreUint32(&d.remoteWriteClosed, 1) + case pb.Message_STOP_SENDING: + atomic.StoreUint32(&d.remoteReadClosed, 1) + // TODO: Process reset } - - if pbmsg.Flag != nil { - switch pbmsg.GetFlag() { - case pb.Message_FIN: - atomic.StoreUint32(&d.remoteWriteClosed, 1) - select { - case <-d.readSignal: - default: - close(d.readSignal) - } - - case pb.Message_STOP_SENDING: - atomic.StoreUint32(&d.remoteReadClosed, 1) - case pb.Message_RESET: - log.Errorf("remote reset") - d.Close() - } - } - } func (d *dataChannel) Read(b []byte) (int, error) { @@ -132,19 +174,24 @@ func (d *dataChannel) Read(b []byte) (int, error) { if err == io.EOF && d.isRemoteWriteClosed() { return read, io.EOF } - // log.Warnf("read %d bytes: %s", read, string(b[:read])) if read > 0 { return read, nil } - // log.Warnf("waiting for read") - select { - case <-d.readSignal: - case <-d.ctx.Done(): - return 0, d.ctx.Err() - case <-d.readDeadline.wait(): - return 0, os.ErrDeadlineExceeded + // read until data message + var msg pb.Message + err = d.reader.ReadMsg(&msg) + if err != nil { + return 0, err + } + if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { + d.readBuf.Write(msg.GetMessage()) } + // process control message + if msg.Flag != nil { + d.processControlMessage(msg) + } + } } @@ -160,13 +207,7 @@ func (d *dataChannel) Write(b []byte) (int, error) { msg := &pb.Message{ Message: b, } - data, err := msg.Marshal() - if err != nil { - log.Warnf("write failed on datachannel: %s", err) - return 0, err - } - d.channel.Send(data) - return len(b), nil + return len(b), d.writer.WriteMsg(msg) } func (d *dataChannel) Close() error { @@ -188,14 +229,7 @@ func (d *dataChannel) CloseRead() error { msg := &pb.Message{ Flag: pb.Message_STOP_SENDING.Enum(), } - data, err := msg.Marshal() - if err != nil { - return - } - err = d.channel.Send(data) - if err != nil { - return - } + err = d.writer.WriteMsg(msg) }) return err @@ -212,14 +246,7 @@ func (d *dataChannel) CloseWrite() error { msg := &pb.Message{ Flag: pb.Message_FIN.Enum(), } - data, err := msg.Marshal() - if err != nil { - return - } - err = d.channel.Send(data) - if err != nil { - return - } + err = d.writer.WriteMsg(msg) }) return err } diff --git a/p2p/transport/webrtc/listener.go b/p2p/transport/webrtc/listener.go index cab9f02f43..5c5ee9c452 100644 --- a/p2p/transport/webrtc/listener.go +++ b/p2p/transport/webrtc/listener.go @@ -173,6 +173,7 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC settingEngine.SetLite(true) settingEngine.SetICEUDPMux(l.mux) settingEngine.DisableCertificateFingerprintVerification(true) + settingEngine.DetachDataChannels() api := webrtc.NewAPI(webrtc.WithSettingEngine(settingEngine)) @@ -207,15 +208,22 @@ func (l *listener) accept(ctx context.Context, addr candidateAddr) (tpt.CapableC // Therefore, we wrap the datachannel before performing the // offer-answer exchange, so any messages sent from the remote get // buffered. - wrappedChannel := newDataChannel( - handshakeChannel, - pc, - l.mux.LocalAddr(), - addr.raddr, - ) + var wrappedChannel *dataChannel var handshakeOnce sync.Once handshakeChannel.OnOpen(func() { + rwc, err := handshakeChannel.Detach() + if err != nil { + signalChan <- struct{ error }{errDatachannel("could not detach", err)} + return + } + wrappedChannel = newDataChannel( + handshakeChannel, + rwc, + pc, + l.mux.LocalAddr(), + addr.raddr, + ) handshakeOnce.Do(func() { signalChan <- struct{ error }{nil} }) diff --git a/p2p/transport/webrtc/transport.go b/p2p/transport/webrtc/transport.go index 24999c18e3..422b872ad5 100644 --- a/p2p/transport/webrtc/transport.go +++ b/p2p/transport/webrtc/transport.go @@ -201,6 +201,7 @@ func (t *WebRTCTransport) Dial( settingEngine := webrtc.SettingEngine{} settingEngine.SetICECredentials(ufrag, ufrag) settingEngine.SetLite(false) + settingEngine.DetachDataChannels() api := webrtc.NewAPI(webrtc.WithSettingEngine(settingEngine)) pc, err = api.NewPeerConnection(t.webrtcConfig) @@ -237,8 +238,13 @@ func (t *WebRTCTransport) Dial( } }) - wrappedChannel = newDataChannel(handshakeChannel, pc, nil, raddr) handshakeChannel.OnOpen(func() { + rwc, err := handshakeChannel.Detach() + if err != nil { + signalChan <- struct{ error }{err} + return + } + wrappedChannel = newDataChannel(handshakeChannel, rwc, pc, nil, raddr) cp, err := handshakeChannel.Transport().Transport().ICETransport().GetSelectedCandidatePair() if cp == nil || err != nil { err = errDatachannel("could not fetch selected candidate pair", err) From 559c292f35a8e4bfb4e1cf5f87a3b817c0851f9d Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Sun, 9 Oct 2022 22:26:30 +0530 Subject: [PATCH 45/50] go mod tidy --- go.mod | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 9da9a098c5..bb69945f81 100644 --- a/go.mod +++ b/go.mod @@ -48,6 +48,7 @@ require ( github.com/multiformats/go-multistream v0.3.3 github.com/multiformats/go-varint v0.0.6 github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 + github.com/pion/datachannel v1.5.2 github.com/pion/dtls/v2 v2.1.5 github.com/pion/ice/v2 v2.2.6 github.com/pion/logging v0.2.2 @@ -102,7 +103,6 @@ require ( github.com/nxadm/tail v1.4.8 // indirect github.com/onsi/ginkgo v1.16.5 // indirect github.com/opencontainers/runtime-spec v1.0.2 // indirect - github.com/pion/datachannel v1.5.2 // indirect github.com/pion/interceptor v0.1.12 // indirect github.com/pion/mdns v0.0.5 // indirect github.com/pion/randutil v0.1.0 // indirect From 894e6a897432f7fc7a2830a905580c5e1eb36367 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Sun, 9 Oct 2022 23:35:31 +0530 Subject: [PATCH 46/50] reset? --- p2p/transport/webrtc/datachannel.go | 89 ++--------------------------- 1 file changed, 5 insertions(+), 84 deletions(-) diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index e2900d1e69..050e74aea7 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -76,87 +76,14 @@ func newDataChannel( return result } -// func (d *dataChannel) handleMessage(msg webrtc.DataChannelMessage) { -// if msg.IsString { -// log.Warnf("received string message") -// return -// } - -// var pbmsg pb.Message -// if err := pbmsg.Unmarshal(msg.Data); err != nil { -// log.Warnf("could not unmarshal protobuf message") -// return -// } - -// if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { -// d.m.Lock() -// d.readBuf.Write(pbmsg.GetMessage()) -// // n, err := d.readBuf.Write(pbmsg.GetMessage()) -// // log.Warnf("wrote %d bytes to buffer, msg size: %d: %v", n, len(pbmsg.GetMessage()), err) -// d.m.Unlock() -// select { -// case d.readSignal <- struct{}{}: -// default: -// } -// } - -// if pbmsg.Flag != nil { -// switch pbmsg.GetFlag() { -// case pb.Message_FIN: -// atomic.StoreUint32(&d.remoteWriteClosed, 1) -// select { -// case <-d.readSignal: -// default: -// close(d.readSignal) -// } - -// case pb.Message_STOP_SENDING: -// atomic.StoreUint32(&d.remoteReadClosed, 1) -// case pb.Message_RESET: -// log.Errorf("remote reset") -// d.Close() -// } -// } - -// } - -// func (d *dataChannel) Read(b []byte) (int, error) { -// for { -// select { -// case <-d.readDeadline.wait(): -// return 0, os.ErrDeadlineExceeded -// default: -// } - -// d.m.Lock() -// read, err := d.readBuf.Read(b) -// d.m.Unlock() -// if err == io.EOF && d.isRemoteWriteClosed() { -// return read, io.EOF -// } -// // log.Warnf("read %d bytes: %s", read, string(b[:read])) -// if read > 0 { -// return read, nil -// } - -// // log.Warnf("waiting for read") -// select { -// case <-d.readSignal: -// case <-d.ctx.Done(): -// return 0, d.ctx.Err() -// case <-d.readDeadline.wait(): -// return 0, os.ErrDeadlineExceeded -// } -// } -// } - func (d *dataChannel) processControlMessage(msg pb.Message) { switch msg.GetFlag() { case pb.Message_FIN: atomic.StoreUint32(&d.remoteWriteClosed, 1) case pb.Message_STOP_SENDING: atomic.StoreUint32(&d.remoteReadClosed, 1) - // TODO: Process reset + case pb.Message_RESET: + atomic.StoreUint32(&d.remoteWriteClosed, 1) } } @@ -262,16 +189,10 @@ func (d *dataChannel) RemoteAddr() net.Addr { func (d *dataChannel) Reset() error { var err error d.resetOnce.Do(func() { + // does reset mean that no more data will be sent? + atomic.StoreUint32(&d.localWriteClosed, 1) msg := &pb.Message{Flag: pb.Message_RESET.Enum()} - data, err := msg.Marshal() - if err != nil { - return - } - err = d.channel.Send(data) - if err != nil { - return - } - d.channel.Close() + err = d.writer.WriteMsg(msg) }) return err } From 6c3bf8a530a6328af04d4952c0826d1e2a55e899 Mon Sep 17 00:00:00 2001 From: Chinmay Kousik Date: Wed, 12 Oct 2022 19:04:16 +0530 Subject: [PATCH 47/50] state transitions --- p2p/transport/webrtc/connection.go | 6 +- p2p/transport/webrtc/datachannel.go | 210 ++++++++++++++++++++-------- 2 files changed, 156 insertions(+), 60 deletions(-) diff --git a/p2p/transport/webrtc/connection.go b/p2p/transport/webrtc/connection.go index f1759665a6..d481b75498 100644 --- a/p2p/transport/webrtc/connection.go +++ b/p2p/transport/webrtc/connection.go @@ -145,7 +145,7 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error return nil, err } - streamId := *dc.ID() + streamID := *dc.ID() var stream *dataChannel dc.OnOpen(func() { rwc, err := dc.Detach() @@ -159,7 +159,7 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error return } stream = newDataChannel(dc, rwc, c.pc, nil, nil) - c.addStream(streamId, stream) + c.addStream(streamID, stream) result <- struct { network.MuxedStream error @@ -168,7 +168,7 @@ func (c *connection) OpenStream(ctx context.Context) (network.MuxedStream, error dc.OnClose(func() { stream.remoteClosed() - c.removeStream(streamId) + c.removeStream(streamID) }) select { diff --git a/p2p/transport/webrtc/datachannel.go b/p2p/transport/webrtc/datachannel.go index 050e74aea7..5a9aa45ef7 100644 --- a/p2p/transport/webrtc/datachannel.go +++ b/p2p/transport/webrtc/datachannel.go @@ -6,14 +6,11 @@ import ( "io" "os" - // "io" "net" "sync" "time" - "sync/atomic" - "github.com/libp2p/go-libp2p/core/network" "github.com/libp2p/go-msgio/protoio" "github.com/pion/datachannel" @@ -24,6 +21,24 @@ import ( var _ network.MuxedStream = &dataChannel{} +const ( + // bufferedAmountLowThreshold and maxBufferedAmount are bound + // to a stream but congestion control is done on the whole + // SCTP association. This means that a single stream can monopolize + // the complete congestion control window (cwnd) if it does not + // read stream data and it's remote continues to send. + bufferedAmountLowThreshold uint64 = 1024 + // Max message size limit in Pion is 2^16 + maxBufferedAmount uint64 = 65536 +) + +const ( + stateOpen uint32 = iota + stateReadClosed + stateWriteClosed + stateClosed +) + // Package pion detached data channel into a net.Conn // and then a network.MuxedStream type dataChannel struct { @@ -38,18 +53,16 @@ type dataChannel struct { closeReadOnce sync.Once resetOnce sync.Once - remoteWriteClosed uint32 - localWriteClosed uint32 + state uint32 - remoteReadClosed uint32 - localReadClosed uint32 + ctx context.Context + cancel context.CancelFunc + m sync.Mutex + readBuf bytes.Buffer + writeAvailable chan struct{} - ctx context.Context - cancel context.CancelFunc - m sync.Mutex - readBuf bytes.Buffer - writer protoio.Writer - reader protoio.Reader + writer protoio.Writer + reader protoio.Reader } func newDataChannel( @@ -60,30 +73,48 @@ func newDataChannel( ctx, cancel := context.WithCancel(context.Background()) result := &dataChannel{ - channel: channel, - laddr: laddr, - raddr: raddr, - readDeadline: newDeadline(), - writeDeadline: newDeadline(), - ctx: ctx, - cancel: cancel, - writer: protoio.NewDelimitedWriter(rwc), - reader: protoio.NewDelimitedReader(rwc, 1500), + channel: channel, + laddr: laddr, + raddr: raddr, + readDeadline: newDeadline(), + writeDeadline: newDeadline(), + ctx: ctx, + cancel: cancel, + writer: protoio.NewDelimitedWriter(rwc), + reader: protoio.NewDelimitedReader(rwc, 1500), + writeAvailable: make(chan struct{}), } // channel.OnMessage(result.handleMessage) + channel.SetBufferedAmountLowThreshold(bufferedAmountLowThreshold) + channel.OnBufferedAmountLow(func() { + result.writeAvailable <- struct{}{} + }) return result } func (d *dataChannel) processControlMessage(msg pb.Message) { + d.m.Lock() + defer d.m.Unlock() + if d.state == stateClosed { + return + } switch msg.GetFlag() { case pb.Message_FIN: - atomic.StoreUint32(&d.remoteWriteClosed, 1) + if d.state == stateWriteClosed { + d.Close() + return + } + d.state = stateReadClosed case pb.Message_STOP_SENDING: - atomic.StoreUint32(&d.remoteReadClosed, 1) + if d.state == stateReadClosed { + d.Close() + return + } + d.state = stateWriteClosed case pb.Message_RESET: - atomic.StoreUint32(&d.remoteWriteClosed, 1) + d.channel.Close() } } @@ -98,7 +129,7 @@ func (d *dataChannel) Read(b []byte) (int, error) { d.m.Lock() read, err := d.readBuf.Read(b) d.m.Unlock() - if err == io.EOF && d.isRemoteWriteClosed() { + if state := d.getState(); err == io.EOF && (state == stateReadClosed || state == stateClosed) { return read, io.EOF } if read > 0 { @@ -107,23 +138,76 @@ func (d *dataChannel) Read(b []byte) (int, error) { // read until data message var msg pb.Message - err = d.reader.ReadMsg(&msg) - if err != nil { - return 0, err - } - if !d.isRemoteWriteClosed() && !d.isLocalReadClosed() { - d.readBuf.Write(msg.GetMessage()) - } - // process control message - if msg.Flag != nil { - d.processControlMessage(msg) + signal := make(chan struct { + error + }) + + // read in a separate goroutine to enable read deadlines + go func() { + err = d.reader.ReadMsg(&msg) + if err != nil { + signal <- struct { + error + }{err} + return + } + if state := d.getState(); state != stateClosed && state != stateReadClosed { + d.m.Lock() + d.readBuf.Write(msg.GetMessage()) + d.m.Unlock() + } + // process control message + if msg.Flag != nil { + d.processControlMessage(msg) + } + signal <- struct{ error }{nil} + + }() + select { + case sig := <-signal: + if sig.error != nil { + return 0, sig.error + } + case <-d.readDeadline.wait(): + return 0, os.ErrDeadlineExceeded } } } func (d *dataChannel) Write(b []byte) (int, error) { - if d.isLocalWriteClosed() || d.isRemoteReadClosed() { + if s := d.getState(); s == stateWriteClosed || s == stateClosed { + return 0, io.ErrClosedPipe + } + + var err error + var ( + start int = 0 + end = 0 + written = 0 + chunkSize = 1024*1024 - 10 + n = 0 + ) + + for start < len(b) { + end = len(b) + if start+chunkSize < end { + end = start + chunkSize + } + chunk := b[start:end] + n, err = d.partialWrite(chunk) + if err != nil { + break + } + written += n + start = end + } + return written, err + +} + +func (d *dataChannel) partialWrite(b []byte) (int, error) { + if s := d.getState(); s == stateWriteClosed || s == stateClosed { return 0, io.ErrClosedPipe } select { @@ -131,8 +215,14 @@ func (d *dataChannel) Write(b []byte) (int, error) { return 0, os.ErrDeadlineExceeded default: } - msg := &pb.Message{ - Message: b, + msg := &pb.Message{Message: b} + // approximate overhead + if d.channel.BufferedAmount()+uint64(len(b))+10 > maxBufferedAmount { + select { + case <-d.writeAvailable: + case <-d.writeDeadline.wait(): + return 0, os.ErrDeadlineExceeded + } } return len(b), d.writer.WriteMsg(msg) } @@ -143,6 +233,11 @@ func (d *dataChannel) Close() error { return nil default: } + + d.m.Lock() + d.state = stateClosed + d.m.Unlock() + d.cancel() d.CloseWrite() _ = d.channel.Close() @@ -152,7 +247,11 @@ func (d *dataChannel) Close() error { func (d *dataChannel) CloseRead() error { var err error d.closeReadOnce.Do(func() { - atomic.StoreUint32(&d.localReadClosed, 1) + d.m.Lock() + if d.state != stateClosed { + d.state = stateReadClosed + } + d.m.Unlock() msg := &pb.Message{ Flag: pb.Message_STOP_SENDING.Enum(), } @@ -163,13 +262,21 @@ func (d *dataChannel) CloseRead() error { } func (d *dataChannel) remoteClosed() { + d.m.Lock() + defer d.m.Unlock() + d.state = stateClosed d.cancel() + } func (d *dataChannel) CloseWrite() error { var err error d.closeWriteOnce.Do(func() { - atomic.StoreUint32(&d.localWriteClosed, 1) + d.m.Lock() + if d.state != stateClosed { + d.state = stateWriteClosed + } + d.m.Unlock() msg := &pb.Message{ Flag: pb.Message_FIN.Enum(), } @@ -189,10 +296,9 @@ func (d *dataChannel) RemoteAddr() net.Addr { func (d *dataChannel) Reset() error { var err error d.resetOnce.Do(func() { - // does reset mean that no more data will be sent? - atomic.StoreUint32(&d.localWriteClosed, 1) msg := &pb.Message{Flag: pb.Message_RESET.Enum()} err = d.writer.WriteMsg(msg) + d.Close() }) return err } @@ -213,18 +319,8 @@ func (d *dataChannel) SetWriteDeadline(t time.Time) error { return nil } -func (d *dataChannel) isRemoteWriteClosed() bool { - return atomic.LoadUint32(&d.remoteWriteClosed) == 1 -} - -func (d *dataChannel) isLocalWriteClosed() bool { - return atomic.LoadUint32(&d.localWriteClosed) == 1 -} - -func (d *dataChannel) isRemoteReadClosed() bool { - return atomic.LoadUint32(&d.remoteReadClosed) == 1 -} - -func (d *dataChannel) isLocalReadClosed() bool { - return atomic.LoadUint32(&d.localReadClosed) == 1 +func (d *dataChannel) getState() uint32 { + d.m.Lock() + defer d.m.Unlock() + return d.state } From 6a01cfeb4d3d12d40fb523f4ca6dabc58d48e8da Mon Sep 17 00:00:00 2001 From: Ryan Plauche Date: Wed, 12 Oct 2022 16:57:10 -0500 Subject: [PATCH 48/50] Attempting to include webrtc in example --- examples/webrtc-echo/.gitignore | 1 + examples/webrtc-echo/README.md | 52 ++++++++ examples/webrtc-echo/main.go | 198 ++++++++++++++++++++++++++++++ examples/webrtc-echo/main_test.go | 58 +++++++++ examples/webrtc-echo/webrtc-echo | Bin 0 -> 29575464 bytes 5 files changed, 309 insertions(+) create mode 100644 examples/webrtc-echo/.gitignore create mode 100644 examples/webrtc-echo/README.md create mode 100644 examples/webrtc-echo/main.go create mode 100644 examples/webrtc-echo/main_test.go create mode 100755 examples/webrtc-echo/webrtc-echo diff --git a/examples/webrtc-echo/.gitignore b/examples/webrtc-echo/.gitignore new file mode 100644 index 0000000000..fa11a6a9c5 --- /dev/null +++ b/examples/webrtc-echo/.gitignore @@ -0,0 +1 @@ +echo diff --git a/examples/webrtc-echo/README.md b/examples/webrtc-echo/README.md new file mode 100644 index 0000000000..380716001c --- /dev/null +++ b/examples/webrtc-echo/README.md @@ -0,0 +1,52 @@ +# Echo client/server with libp2p + +This is an example that quickly shows how to use the `go-libp2p` stack, including Host/Basichost, Network/Swarm, Streams, Peerstores and Multiaddresses. + +This example can be started in either listen mode, or dial mode. + +In listen mode, it will sit and wait for incoming connections on the `/echo/1.0.0` protocol. Whenever it receives a stream, it will write the message `"Hello, world!"` over the stream and close it. + +In dial mode, the node will start up, connect to the given address, open a stream to the target peer, and read a message on the protocol `/echo/1.0.0`. + +## Build + +From the `go-libp2p/examples` directory run the following: + +``` +> cd echo/ +> go build +``` + +## Usage + +``` +> ./echo -l 10000 +2017/03/15 14:11:32 I am /ip4/127.0.0.1/tcp/10000/p2p/QmYo41GybvrXk8y8Xnm1P7pfA4YEXCpfnLyzgRPnNbG35e +2017/03/15 14:11:32 Now run "./echo -l 10001 -d /ip4/127.0.0.1/tcp/10000/p2p/QmYo41GybvrXk8y8Xnm1P7pfA4YEXCpfnLyzgRPnNbG35e" on a different terminal +2017/03/15 14:11:32 listening for connections +``` + +The listener libp2p host will print its `Multiaddress`, which indicates how it can be reached (ip4+tcp) and its randomly generated ID (`QmYo41Gyb...`) + +Now, launch another node that talks to the listener: + +``` +> ./echo -l 10001 -d /ip4/127.0.0.1/tcp/10000/p2p/QmYo41GybvrXk8y8Xnm1P7pfA4YEXCpfnLyzgRPnNbG35e +``` + +The new node with send the message `"Hello, world!"` to the listener, which will in turn echo it over the stream and close it. The listener logs the message, and the sender logs the response. + +## Details + +The `makeBasicHost()` function creates a [go-libp2p-basichost](https://godoc.org/github.com/libp2p/go-libp2p/p2p/host/basic) object. `basichost` objects wrap [go-libp2p swarms](https://godoc.org/github.com/libp2p/go-libp2p-swarm#Swarm) and should be used preferentially. A [go-libp2p-swarm Network](https://godoc.org/github.com/libp2p/go-libp2p-swarm#Network) is a `swarm` which complies to the [go-libp2p-net Network interface](https://godoc.org/github.com/libp2p/go-libp2p-net#Network) and takes care of maintaining streams, connections, multiplexing different protocols on them, handling incoming connections etc. + +In order to create the swarm (and a `basichost`), the example needs: + +- An [ipfs-procotol ID](https://godoc.org/github.com/libp2p/go-libp2p-peer#ID) like `QmNtX1cvrm2K6mQmMEaMxAuB4rTexhd87vpYVot4sEZzxc`. The example autogenerates a key pair on every run and uses an ID extracted from the public key (the hash of the public key). When using `-insecure`, it leaves the connection unencrypted (otherwise, it uses the key pair to encrypt communications). +- A [Multiaddress](https://godoc.org/github.com/multiformats/go-multiaddr), which indicates how to reach this peer. There can be several of them (using different protocols or locations for example). Example: `/ip4/127.0.0.1/tcp/1234`. +- A [go-libp2p-peerstore](https://godoc.org/github.com/libp2p/go-libp2p-peerstore), which is used as an address book which matches node IDs to the multiaddresses through which they can be contacted. This peerstore gets autopopulated when manually opening a connection (with [`Connect()`](https://godoc.org/github.com/libp2p/go-libp2p/p2p/host/basic#BasicHost.Connect). Alternatively, we can manually [`AddAddr()`](https://godoc.org/github.com/libp2p/go-libp2p-peerstore#AddrManager.AddAddr) as in the example. + +A `basichost` can now open streams (bi-directional channel between two peers) using [NewStream](https://godoc.org/github.com/libp2p/go-libp2p/p2p/host/basic#BasicHost.NewStream) and use them to send and receive data tagged with a `Protocol.ID` (a string). The host can also listen for incoming connections for a given +`Protocol` with [`SetStreamHandle()`](https://godoc.org/github.com/libp2p/go-libp2p/p2p/host/basic#BasicHost.SetStreamHandler). + +The example makes use of all of this to enable communication between a listener and a sender using protocol `/echo/1.0.0` (which could be any other thing). diff --git a/examples/webrtc-echo/main.go b/examples/webrtc-echo/main.go new file mode 100644 index 0000000000..4af0323eec --- /dev/null +++ b/examples/webrtc-echo/main.go @@ -0,0 +1,198 @@ +package main + +import ( + "bufio" + "context" + "crypto/rand" + "flag" + "fmt" + "io" + "log" + mrand "math/rand" + + "github.com/libp2p/go-libp2p" + "github.com/libp2p/go-libp2p/core/crypto" + "github.com/libp2p/go-libp2p/core/host" + "github.com/libp2p/go-libp2p/core/network" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/libp2p/go-libp2p/core/peerstore" + libp2pwebrtc "github.com/plauche/go-libp2p/p2p/transport/webrtc" + + golog "github.com/ipfs/go-log/v2" + + ma "github.com/multiformats/go-multiaddr" +) + +func main() { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // LibP2P code uses golog to log messages. They log with different + // string IDs (i.e. "swarm"). We can control the verbosity level for + // all loggers with: + golog.SetAllLoggers(golog.LevelInfo) // Change to INFO for extra info + + // Parse options from the command line + listenF := flag.Int("l", 0, "wait for incoming connections") + targetF := flag.String("d", "", "target peer to dial") + insecureF := flag.Bool("insecure", false, "use an unencrypted connection") + seedF := flag.Int64("seed", 0, "set random seed for id generation") + flag.Parse() + + if *listenF == 0 { + log.Fatal("Please provide a port to bind on with -l") + } + + // Make a host that listens on the given multiaddress + ha, err := makeBasicHost(*listenF, *insecureF, *seedF) + if err != nil { + log.Fatal(err) + } + + if *targetF == "" { + startListener(ctx, ha, *listenF, *insecureF) + // Run until canceled. + <-ctx.Done() + } else { + runSender(ctx, ha, *targetF) + } +} + +// makeBasicHost creates a LibP2P host with a random peer ID listening on the +// given multiaddress. It won't encrypt the connection if insecure is true. +func makeBasicHost(listenPort int, insecure bool, randseed int64) (host.Host, error) { + var r io.Reader + if randseed == 0 { + r = rand.Reader + } else { + r = mrand.New(mrand.NewSource(randseed)) + } + + // Generate a key pair for this host. We will use it at least + // to obtain a valid host ID. + priv, _, err := crypto.GenerateKeyPairWithReader(crypto.RSA, 2048, r) + if err != nil { + return nil, err + } + + opts := []libp2p.Option{ + libp2p.ListenAddrStrings(fmt.Sprintf("/ip4/127.0.0.1/udp/0/webrtc")), + libp2p.Identity(priv), + libp2p.DisableRelay(), + libp2p.Transport(libp2pwebrtc.New), + } + + if insecure { + opts = append(opts, libp2p.NoSecurity) + } + + return libp2p.New(opts...) +} + +func getHostAddress(ha host.Host) string { + // Build host multiaddress + hostAddr, _ := ma.NewMultiaddr(fmt.Sprintf("/p2p/%s", ha.ID().Pretty())) + + // Now we can build a full multiaddress to reach this host + // by encapsulating both addresses: + addr := ha.Addrs()[0] + return addr.Encapsulate(hostAddr).String() +} + +func startListener(ctx context.Context, ha host.Host, listenPort int, insecure bool) { + fullAddr := getHostAddress(ha) + log.Printf("I am %s\n", fullAddr) + + // Set a stream handler on host A. /echo/1.0.0 is + // a user-defined protocol name. + ha.SetStreamHandler("/echo/1.0.0", func(s network.Stream) { + log.Println("listener received new stream") + if err := doEcho(s); err != nil { + log.Println(err) + s.Reset() + } else { + s.Close() + } + }) + + log.Println("listening for connections") + + if insecure { + log.Printf("Now run \"./echo -l %d -d %s -insecure\" on a different terminal\n", listenPort+1, fullAddr) + } else { + log.Printf("Now run \"./echo -l %d -d %s\" on a different terminal\n", listenPort+1, fullAddr) + } +} + +func runSender(ctx context.Context, ha host.Host, targetPeer string) { + fullAddr := getHostAddress(ha) + log.Printf("I am %s\n", fullAddr) + + // Set a stream handler on host A. /echo/1.0.0 is + // a user-defined protocol name. + ha.SetStreamHandler("/echo/1.0.0", func(s network.Stream) { + log.Println("sender received new stream") + if err := doEcho(s); err != nil { + log.Println(err) + s.Reset() + } else { + s.Close() + } + }) + + // Turn the targetPeer into a multiaddr. + maddr, err := ma.NewMultiaddr(targetPeer) + if err != nil { + log.Println(err) + return + } + + // Extract the peer ID from the multiaddr. + info, err := peer.AddrInfoFromP2pAddr(maddr) + if err != nil { + log.Println(err) + return + } + + // We have a peer ID and a targetAddr so we add it to the peerstore + // so LibP2P knows how to contact it + ha.Peerstore().AddAddrs(info.ID, info.Addrs, peerstore.PermanentAddrTTL) + + log.Println("sender opening stream") + // make a new stream from host B to host A + // it should be handled on host A by the handler we set above because + // we use the same /echo/1.0.0 protocol + s, err := ha.NewStream(context.Background(), info.ID, "/echo/1.0.0") + if err != nil { + log.Println(err) + return + } + + log.Println("sender saying hello") + _, err = s.Write([]byte("Hello, world!\n")) + if err != nil { + log.Println(err) + return + } + + out, err := io.ReadAll(s) + if err != nil { + log.Println(err) + return + } + + log.Printf("read reply: %q\n", out) +} + +// doEcho reads a line of data a stream and writes it back +func doEcho(s network.Stream) error { + buf := bufio.NewReader(s) + str, err := buf.ReadString('\n') + if err != nil { + return err + } + + log.Printf("read: %s", str) + _, err = s.Write([]byte(str)) + return err +} diff --git a/examples/webrtc-echo/main_test.go b/examples/webrtc-echo/main_test.go new file mode 100644 index 0000000000..b57f094c9f --- /dev/null +++ b/examples/webrtc-echo/main_test.go @@ -0,0 +1,58 @@ +package main + +import ( + "context" + "log" + "testing" + + "github.com/libp2p/go-libp2p/examples/testutils" +) + +func TestMain(t *testing.T) { + var h testutils.LogHarness + h.Expect("listening for connections") + h.Expect("sender opening stream") + h.Expect("sender saying hello") + h.Expect("listener received new stream") + h.Expect("read: Hello, world!") + h.Expect(`read reply: "Hello, world!\n"`) + + h.Run(t, func() { + // Create a context that will stop the hosts when the tests end + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + // Get a tcp port for the listener + lport, err := testutils.FindFreePort(t, "", 5) + if err != nil { + log.Println(err) + return + } + + // Get a tcp port for the sender + sport, err := testutils.FindFreePort(t, "", 5) + if err != nil { + log.Println(err) + return + } + + // Make listener + lh, err := makeBasicHost(lport, true, 1) + if err != nil { + log.Println(err) + return + } + + startListener(ctx, lh, lport, true) + + // Make sender + listenAddr := getHostAddress(lh) + sh, err := makeBasicHost(sport, true, 2) + if err != nil { + log.Println(err) + return + } + + runSender(ctx, sh, listenAddr) + }) +} diff --git a/examples/webrtc-echo/webrtc-echo b/examples/webrtc-echo/webrtc-echo new file mode 100755 index 0000000000000000000000000000000000000000..50988770e578d3fd19e997c1a0db674d32c22eb2 GIT binary patch literal 29575464 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 z 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�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

9idOkAxJQfC#2H&S>!3&I`3Yl>(7xZ;I?}X z<96_4SVA1|22(Qv@2gVEe@(T+yX|nJFt5(c@do>0g|oHlLQi0PdZHXyx1*0Fr)J`F z-k|i|?c~`$HGkr}H5vcF+Oa0!Q!$aYj{F{d*6x0^KO_8Rtm6~-cS8FjVd(gZ)-EdT zS(0&+UIsgOm|XLfqvrg^A@dK3G}q$8%$`-w8OX+2vt_`@HDvNxGTU{#6R?mIa zIOL-P(k*|(hw7GCRxWGB)_4Sb7Asr9`z;^%7A zdvY3HUwA&cJj>(y%j@X#y53xODpHdiS}vIOlg33!){bl7

%Jb4-H|I^l|p^(zW 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

qLL9@p69x`jMQwQxA( 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%0AqFDla4U5s@ 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�+qQZ8s@yFo);~PU!>J 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

5vE-vF{9Qp58;u8PmvA6Z{yX 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%0DW)*K2E_>*xv4YzW*@*!)Y+}7~z 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 z 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

)-yVZPG>_gxI{eBBJ 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�aFvBccrSkV=YKw-Ge)$kO7)*y)W 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

>~k!~ME+YhU4#F57AIU) z9&W9e`{!*deny!BJp2JAW|nzBA(De{{y1K49}IA=4sy;$e#1qqP$cOZfT~rJHcA)UmEQa*FT;-Kc!5%+El=jkm9`EV&!*TyFTPsn`;_ z?JamYc|U)=Yd`ehie3<7tnQoCW?ZwtTQ#3N4_^7JKKnb1*J(Q5h92c@az}5=%4r$# z)$^~J_hrq$j{e*K$NX!e)1Pp*gfwA%PTl`PF$fJVAkY97pT<6>UoIcj?x zVjwF~r1V(QbA{UO6>Sh7Iwm~|o6dPRkRC2Qh*x;)4}v3(HH2sU@?PwJZ3u60&*O#T zGKTQd{XK{9W4|UhgyZS`@frrYN{dX1{L6UH5Po`(8v>3%m0$?W;i^bg);Qe!C}W&A zMZT+M2JrX+{7D@bEb<0BVb&noWJCM+iRopKU?DmDSbjh^MtAm`_D%Ug9)HoNu<+JR z;l&^I4JSt49$x!Fc=+eckOxd#o;s6gx&hNqB>7+2{Be0y5Z)}uH(AWWLsy0qm-A@r z8=4ib^#=c1z7C}8lH|=`?Fr_YifQT(_P>25 z0_+xFf$Bj1viK8fy}{^HVH~EJ$bWNY8n+|9^zJ0tR2GG9J)=8v-{Fa(9K8GfV#xg$ z_rm#fAvXf4DW!w==VuMQ?a%ns`DeeLvd)*)CNE51@ z$s1ASJ%A~LDu2l>-$i(9;TG)1VN}e&a8IYH@-)9eSj(r%VSah<^M|eDr*cm<`Pm)+ z@|o<8e_8DS;5t6k(WFFhB7ZfnINu=8?{>M7BUE^(;DBs}$wYLiZ@9@?6{fDvOIjnU z^KUx2-@?NDoD*A@_|9K{TzlgH=i3kFny!R*#+Rwin&@J@R%>hH7vR(#Tq_r+^7>V` z+*~~Sci+1O_=VaO(-uh_dC{bYISgf!yO)g-viU`A1+o8af1*r{8D*?aM=CakqTfa0 z*TmioFW!VtWaJ=T5;i$=SR^)U&>*nH|8rTED!M{ya&P3-pkh*Ee?sI4C5wsCiGGkP zEY`%fhNCa_32$9NeL0cP*juA1n}c|0lLNlj?%R#&EgCrmgq$`tb?r`eTJ3*}T@ zRui9z|EDuAH1E&!IUJu8jwC8yyIRLow2f0h~megsb%e?CUW9K?DPE_GNe6Frqk?qVHA4#aMa90((`qMDeC z5!(0rJ|xB*SOO&4J`pKWVN*r0Py8o1ZS(Qy_Ve^bGj>M}9B8j47)Oy}cA1rW|pv zdpn8BaK| z!2|TJ_|{aq@%o63^51>i;TI>+x`qPNddz`OnSu&2B;TRPp*w$JFGT7frIA|5(^{~ zSpRCL=-Bwp#nmmH6^W<%huU7`0gWyHKDlRn`LNTeqUzA27w60$S9&%-8gpg1j^)?v zK2`H)m7Yo7#<6|JphK&H?y9FI;R|CtR_nVXsheA3Ov9 zm!2+}XgyuX#d>O$`#nt^OjlZXqtmK4ri9<=!5z2-zZa(QyCXj|?^yJcc0<&K{TT4t z_{HOEHMAs`(~(3hlYc#{lVW^T&EfS#(=dm z`Uq=h@ar7#C;b(#thhjN`9-63;r!+&e8700Ug$7+*8I9cp>E9lI+ERwD?MX=-F~`O z&95VZzb7g+-)Zw|Jvx^2PjMSPYzQF7xRRglR4 z?U4vcW)phhjS@@~({XeXYw)t%DOQSpTTB#Y>tERS72&*^NTRS`Ehj-oE4N%4sKkCc zSW`#XyzEW&B>Abq=tL4Liz?7>-!Yh9#YI+QY)9%a$fVIdJ&#LjKklz~_ovzABJ|JN z&}|EpzMCboYq&m+K%_fs*LD+>~P?|KTHirRYtr^HrjKZ(7k+FN1;dPAgu7R&?`A8LoamT9&DM zT?tvUA7|^zMU+HW+6QS}*}pb^X@RlP5TI7wGP8Ja%Nk}wouClBzc@h>?cGq@m)zIJ zi`#1}E;9Xi?1{WdZndWuAwMUi<>yZ1=NCNJI44U#I-b(x8odbHwU##16Vxga^};%9 zyA_5V8^5M_QhRmFf1F5NPnk&K*!wP12R;h53EYU%1ALV@-9+kH2+}i6q>km+xh7J_ zAW}a#*F@@vy5Jvq#22Z;|H9fpKRT(3bTz4pqBN&NKSE?JpU+ z@!a#Abk)1oKE$u}RE~S@Wk1);C=K=KrS#&lQ+Ol2xK4WU*a^X%JhiO{f*7r`Vd!Wl z6YDnzvMJ)*6PygK>yn|y6OJvt*!^GTBYMATsbr3%bj|&EtBJfs++nks$+ZTG$Pj?~ONHeuqnj7<|b+ zJ)4V(!Drn4$#(I@;6sY#Lk!-=)fa=Wdq4XyE%=^a>1H`-u)hy>`mt@}jLPQnxuH8cGP)J79Cx;cP;{|f@-N|Hs~GDev6sC0gEGe;C)n%W zfDeRo)y*V*_=bJM<^jW0zK;X?P78M^Ea zNPeH;ng$aBiZ$68OsO>u`ow*?FH442c^$9*jXHEdl>i-0W29o zXQku;z$LQ36gD+aW|tjn)URPs^N#x(52lLT8B;=!*5^h)*n;b(xN&a_Q%@b(yrZL$ z?f<;4Xl}~Aha(U)Cv%ZD#o%<%QXGiIjfl2>(RX$=Z~u2MC5&F^huZfxzK8yX>(w#u zC2kx%m+{MWRq#wk1Qnw2qTBn;?x*Ng7NkB&y=Ac6V6a>lPSgWS4bGpOY%%+C|2>k= z3%i4#BN==+sqeT-1+hbb)(o6l1<`l5G;e>~r}9}iNS~TmPzQ}f9$-A$ zADA(sk5m7!5xs6BTHkX-$r;^8<48s1J)pU~voREUG@KiKC)BKclRj$pxP@tVf1&inww1a6B^nqLVtzv-d{Jl+Myz4R5(I~b@4y_RsMQ{(3_bF46 z^ko*%TYXknN9vp2;poRn?bMcsJU*!V=cTxv?epEKqUe)7W$q_@luaHl1pF5$nS7Zw zfqlFbEx^{_ezT#+k;PT5UpD+R^`7AZ$%XvifbWf5UyHvmiPbBgI`~U|1OGBf`eBmv z%vM-M4fNYk13V^khUie**)zE)L)PP z7CQc0BrqYTZ;+gx&6p>(H}7bkb|y+|`ZtL2pL>AFa!9jXidyWFmP+w__k4(ZUUWaGc#ImtU{R=NB7g25CYjoQty*&q3jp)|<-_orm1Y2yH34Em zLyw+%BJ`Sf@R*@1s^+su!Aeub>RF!VozT83i2~&ME@1W}DZJiC9 zlW)St;phrDZ}}I=HM*fc_+|ooOA`=4z~a2^F7}#i&00kOL9yRa6#*E-2RI!=tN#KkR3Z5Bf66zEMc_OiJQ9h;=lBC%I8_YaosWCBu4gO zNsRyJ2J2I5CN| zy76#SZ{jYKHPXK~&y@VimXuHGXff{{!m>D#@Cmya$Bp}Sjy+yuH}d~xmO3t7sx& z^k9CJS!`zJo9i;(xcVpX#MO5Jzs^aVS|#otGe4v?X6;{neGZc3)Dvsig1B~5b!>Z8 z$0vD+SE929et32?=L}vR#L0%Cv+;5C=lGiG-#ITapsITQ=yN$BQgv~J$h1GOja)l& zn1QvHD%8c>)bvrO`4qJB5qnEW8**ajLpk2JY;$Zj!hn<_jsE~ASfEHf&(qX%H3X;(*Zv%Y zZ=bpQ`HHb-MTZolv_8`s7VL?+db;!px@$i=f*))6fwukf*`xRoNi47;sR6Z#x;_@- z+QnY*|MucgVjBEqtF$B)X#9R8aY>&@#cR_~Lz~a~%_P<_*xLCi`-Qv*Dn0_P7jZbT z;u_+<_72ud>uO{Z*y@aN`SQFGqpO#X8Ie002BDP@t#AroiZjMm&AE(Lz@OR)%ft)Q zSSYKpYS$PR@z-cfR!_KEEvEX`#6A;%c~VFHOYtAkaIHcTh%A|>V62GmbU!Qf*r6Pi zyLf5ASmJsn)Bp%=hz`rU+eC-v{MtsZd=-Bw_r0%~z3GZ^pnUe|t@$&T=k+g3YG>#e zthX`GD2aY*B#=zj^NfD#fI3Tu(O}!ev#F}4^Mz{d)B2z`_7QO+vsTo^z6dY=pbs=r zGIsFCHCo^KbWH56>h-CyLsN{vdCF=N*W^}5H-#dscqJ+~jfv(!`iGtpsrY32Rmx;n zKZba!Gd0AC3~}LI!4M;{e|j&TECgSh4Ri22CUc|{5%sDePF=kW`t13K_O}yO=|FAl zZ#Gqkh$~+AZe43qKtH4WWNOJ^M1UX2XSme1HrJqGZaPr#g|pc=U;c=20g5 zO*fG#fq6bM@vz`nr$#w(KE^ynp=m4>M=Q@dRjU-X9gi>Tifucd6&U7iT&?-3 zMxLm=ZM0S+w1bh^l#N^QFD80NzAQ2@(L0=n^_zH&1gQD>0CH zg$L3SE&_stZ7T*f)`7D4s_{lB; zezZ81j^H1nH%2A1;Dw5}8V@li*uF;JJH25))|6g_qRUD^u)pUetcI)Hhw>)e=e|x;q1|{h!|PlHm-{d9;qYgZR_EWSDe|Up5O=Gs=pzCu{A=&ODhHO#G=Z)b>ZH6Ym!yx{5UY zkA^iDt78Jec6`z@4yih}Ah(95o+zdqk&CN&R?0K^DoBF4so^4gh2K!%&=AE89WsX7 z!J-R{BBHK2{vi_E=q-^228Qbt8}tpiMzC1a2ar$tR<=kC;jcbdfx*;qs;aD1m8Yr7 z)5D2KskUBd)CK@W_c30`0C`UO!Z8{wFE0lq10iusme6{Es(2=U|8hs|?YeS4>QF5b3{@&Tn@h`8_X{ee^QHK24fvDu`^HlWf?K0Zsw>%?t=PQzZ*aRG5ZhJHKbB6 z7}S;<)H<-b3sX;1(8mw!S3&C^CC{cd*LtP>QtK!3ONM|uDtph|RrI^BokZFPw$U{IXUtZ3LFTnqGrRf7`RNpj(PD+A!p0#Q8nL9s}v zOmsEOdqRAV1yjaUAy0c4#}QyoB47d}s-Q|%^Y?AHha^%-&9Ng^fn#HV%>gOP6p++} zt5O4;APyMF$%jbA;@QVA5axX^&5-lHuwu;6)m#VkA3OAU;;+izXjq^5p~<2&XUhIu z$t=u!WEoozIy-74&Wq2Ynm!7r__#eemGKHXp|&gRmn6=3enk@J6h>mtS6fVa@?4&X zfl#7ZUVh>Sf765RoSn7Av^YF;(?4eASkzr_3v?Or>t{&Gx9m24{Y0-$f)HI(qsLbnqfaKS`qUZSjFCzNN zk-drNx?V*z8xP?p^TC;s1AluHuI_zIVH*<`{#vhGLvW(|SboBW)ob6W{&I11;}^{T zS7DcQE=e8eJI|8MqH;w)HA5%p$5%tQUdN*uvT+Iz64$=t7d82Qfr?9Le(J612=s!N zztHE(|?HNptyeliEXVb9LW|hwhE=){WuCJ5P^p$_?jk(3ya5u(11OaxirN z6wo55F||K_B#wUkk{6w+d`mZOCv1(QOt@udCv}BxJ6ks-?VdBh_#-s$LLM}imxWpn z)tidXLQzFz82=@Y=24(I(5bsw-9furT>kGyQTjl{H6cH{iXk*{?dO*?@Rw|o{s7KCgDHv zA)=Jl^2%7}DGS}Ad`7|kVxCllezcq?EYd7w`DG2pNXPk!yfAAJ$e)@PHgB>&@PXtn zDf2Y|A+u|(HuwwE^Wj8cF@`G6 zZyDug(=mT5#(waw7SS=08l>q0o|-OW3Ql?5o5Y~t7%0%&_}A?5t^S42Iks5cZnCLs zI6Z#3@jZv>(Chq^NuA9SA>Aa>nMjAPDIKcHe>@WN)8Y=mzp&G@mxQ@s#E{xuY9L zagM{T8r%b0{}Eo?d3yB2KH=P5Drt^`p_!2)Rc_j*?{zNvip5}?p%L7I5#QgeDTeu~ zA1%ZR{|>yF_lw=}uVT+&>PqJf6ZlHd1yG%L&)>B8*9r&;VP<>qbt+y76~TMo*Kdp+ z(6f5>q40Oq9n44EfxlVxxW<0Tl!0Hd2q=}s+i>uJ3a#{)SI^HY4=2uM`P0?U{IWO{ z9f0aTV}8Tl;CglFN4wNU;>JGV;i!r(e6O|$=U3rpNy392eWSET6KpQNk9OvUTK|V% zaKgbXSHg$qV=t@<&67I-UOqUtdB8;=gET zpHS;)6^Ly~-UknHt%*I4X(XhT7+cvdh;}xcd_{B7&ccQRGk7gPl7NsnI}hukICL98 zHgyl^p~=OPHh8ylZSS)2y(PD23c}<8y~n{z{>``?*_Smp!jpr|fMj1R{{i!t z0R_!Fj%yeo{`<&VDM|+`Zl>eiWC>)0+YBW6Gokdf!#h5!OQ|T**xH}8=k}3IS?y0I zN;0GU?O&o8J4bxk^(g3rO+C9FX8`B-Kgj}4kFesjp3wZpKi?_k<~On&6~APgBNG0V zK%+(W+|RTd%Ok+k&yIb(_gGW+WU_LYJN`$$Ezk<9_GefXBt*PrrkY~kG4@f#lF%(z z>J|ZCrx8q)?d|sXtd@PPg{9zIsS)LChS)n<=w0JWL)!>lgF#O@eOZ&cR`amEpULAU z#d@LkqEdgoiL%eV53xCdvOzW(e;*r#o)O*Kgq{7xDJ^53`~gb?4-a!o14fsLqSuQ3 zrGW)LWVAZ)*Tc0sVB7fI2w02hANCLF)Dtg48V6(h5zHD!eRrsKCU$6k>;u|ASgNLT zX>G;Q*`ru_EFE0k{O_`9-{Nn@jiu)&2Haj9T_!8)J${d?X@OX=pI)kdQdgV|sRP*} z+_b+tW?jWWsM6Ml!4>;`^tHf|uZPuCJV5ZzTUt>5yz0*uh}wx!e(PNZ+xATciyr4G*~n#0X*eABQ zNAq3#LdPkI5Amme))(rmb(GB#Zy*3oK94~@mt?H1(f7k~Ji6|y@0Oi*jrZs0onXd-Vqq=q$#SaI zb4QSo1Gwb>EGELo{KV_2uov$O@=?qFZ2Lg9a9l-W;iQ)GDfJDblJ~nOeM4=(<5%dh z;z=z#rqnkUvVCJ@d&5Ax3$^`-cRV>M)HYk?;{)IDFn8lcKmF73xh{l95|XWMz8Fmm z=}#ZXzie)+i0j1}4vT+)x-W*5OC(Ik2|mahH$i@W_WF=TVUX*5^#d+%DN2*@w*l&$Y)(z>7xr?b%N zwfs1f>cu{0x|SrvSkYPZF}oXmKpK$5xe^OlV)+|ZP0jIsdbqO8J$tg}=W}R>3=&Rb% z7gQx%68fqV5seQ=%Q?)rKrf-8I`3r+EKN9CZT`cf5=U!*qfCHN%=W&oOwaL_4|TFy z`V(k=c!RPcBgbsRMt_dotK$Ggi8OTHszWqnvdoMxw#>W5-h2!BpxCs@6q`sf60H0- zC{}M-{+fn)E$L!S6oU`y%A%Dwr;C+aZROr&Rt!Hh1;`kAnH4Z`NT0J4jehb+!N|C$ zXwzU344dvXN?@5`Vke6B8ewog`%MRD_s$qt00DCWk+gdg=I@3|ZZRrx@SnOT_>V}# z|9otRuY!Mk9q>P^Bn$pOsNVzpYYy%X{{jO;e=;;?!2fVpEE1~<;6F57ECc>K2U~3v z3*f)QB0tjbf5Qs&4*wroQ3wAk2W7w??-gQymuAZdt;CSSF5qPsQV37cJ0}&o5XF6> za)KB?G3u_3Uxg~~p?SN()c6d34){8_I{aPZ@COYlwHo|0Ih_uV^I*)BGgh($mherJ zmj^4^{7LzT2Z)`VE|!7V!_&nA#8z7|y!ei>a;<q{(#JP^>L%j!*@78xJ)lcU# z-q$aIz>#Ulr{$VHsDKm!`Nl^@&SOhA2Y4|}(@3Nm5XAX^eF>yD9qN$o7E_9TS>;mX z(*KD)kbd)l-H|@p0#dq3({Vwuv@|`@ia9n#j-F@*44cqmUAe_6(QCTpt^B=Un?`&= zS5d|W;?ZeMAerSL^zT9yCjapOv9pG9?#*s-?DdQ8 z0kg?SH*`AunO846|1(H{T_16oX|Tg>+G_Yb7(*%&Jb?pY=z;e~=p(M`HV*UR<#O+; zeFOewNxx zcsqZq{tp~ET>YjzWw^3<6G*#vhLo$-xOQjPLq_5UH@<#NO+Oth>`ATCTLnqn|Y#KLyvRyUbhT} zSZywOhN%==+f;Cw2_$5ZN(Qp1qb8G9CyG{qOa6%GLE`3vvXEGGs*l74rOm3LJGpM| z-yM&CvN(=zcziA>md4}VR?Ij>c)Z&R7`f7)OmQ^PtMH48I5F^U>MF|cGWF18Z$B%l z!6%CP6brXz;Efj&>p^dmuYD3lrAGyj?zZZP3wO2~*{k?WbS(-`{V%nlbJYS5~YH zwaJEWC5vnRF>CQI9Ce^WqM7F_s*3H3Iw>I_oH*K(i-j~6o``=*6#yge(f?vRtPLmf z?>?Ivfz~jfRkn0ed&~AG?_GaqsO=BJKKa9g27keQ{M-V*_|?an0Iv2P{(~GIIvt#T zq9XGDd(HLC{}v8(eJNH2^u?}zUkam@e+sEDM79;Uo*bi|@Vc1bS!M+b>@{>@26uRn zsi{GB>*c09{mEIGowm7BdI()O^&Xs+iM6CMkG>#3Ae+MrhyW^JSs`x@i602@=|`x` zp_YI^6hoQ4+|A>MF^r`|76x&J19B}B#T(5xSyqpm2+(;coTx5LJ@3#g{LZ+5`C*lC z%d}m8sP9|hIQ|12Z`VWsQx%I#;SyV8Ur)l?6(@<+R8me0=gnp3$3MEBWsK^Ln=?n1 zx;2ZueEa5DR33eps6OC>(jUS?nuQVs1Y$?ZGM?k@$0lW41pmvwaN^JtSomV^GL%~-=7#gu;4|?y*<3{rX?&Qq z5E*VON9YzHA!8@Drak#A{cG9bm_#dIfMkB?VQl|aZnza_e##HhUIClyKH|i=`FA@` z2@CG9d;X0t%Ky24?~Edd!6>&BW<#v+U4od?_b|$p_Sys})n=am9QL+ZFojSUbX=3( zRDtr(6Hm(0Gmf+Ea$Q1mfnx6&E9KSSlu2ohC#kU{`HP-lZCTnf^`@I05_vzm|X-;&cIe6b}K>zAjjx@uX+tf*s*Gss= zG(-WRY?IH?;eZ1EVuKnuPi;H@xZ3|UPvhS;{CmRxZyo+8Ya~^||7zjCxOe=kTf%?8 z>~8h7ZaD=i{M&28KhQdjVR9U|={;;Z$=Fmf3;vrWDQ2ZOEC7%D zPiz5tRm1*BY)8?MGu)#*Q!q+ZIKIDVmZ_+Hxm+7`SR&Gl)%)2bP?Ax6$W=?wYVo40 zxj5@EsA$NOi|x%*T(aKm4n|(Zj6FamxpPm}K`=l4mxB+3mTMUJnCL*9H$aDRA4sA- z%WjuYX}UwC{sOm52bka!XE(Z!fL^`eI2mVMx$+WUq(w#i>RqAHVL(@Bpd0Ulj>7s3 zA8u3Eel^zw`7>)`_-PED6TRP0cJK`9C>mf;s~qT{hN%It(=UI}A&^#1<|5o>zT6#D z&F0Rq$X;pK1CYD?0nQ@(Ll?|5;WGf8c*u_In&Hl3i?n6%d-LU6#vWEj8{Z0*xF+ zwXDUA6#-2~HZ6Pr=k=@m%6Z+HFA+qV8J3o`GF4>eH8;{y@IPQ^NPuV{Ca;jNms2U1Ax+l71SC?|ikffZ_R z7JoH~znZjk=QNcuN|04DI2OImj5b4XCdR$QJRjLdQlt6*GL~8@lADAyL-yT`drq8A{PVUg79= zgrI(J>T@E~7^WHVq7D3PTg9p5iToG!G{Jnv`^yQN*}#*(QV$qt3FI=2`H?q)j-`GX zm^(eLX8-T5{qJS8e`Qzuzumf%OD!R7xi7(_MWVkKk#;m5qBf&+Sv+P{d8+ zRgEFtH11;s?-PDlDA87n<7cGjtlA#2zDt`*T)ytjgFU6IF)q(8mhgnIOGFA)oNg@x z0Ja=&WWmg)a?4eVG;K-h65G=GT5Ct+H>BiC*y1FMX(E%Xxeo$0vv*N%sb)Q<4yGT; znXHzRD0d|0?M#y7?3xe`jd_juikga5b3er8R2BNKeO0jS+nks>qpmQhhHGd`r^WCM* zlvO_aiStQF?^d~dbYVEMjKlgsB!0TpwWGT8HKBy_88AKx-i(x?T&)vTXl9h&xy z?IaM11QHtlS#H(?SJy{4T_gg)9;7$q*IpmGtrMCwGX_C{E`F7Okw|Qb@lSHGy-O>R zH2r&5OzEBAlfyG9T=ebdH!n~W-|q68-(?aEsu*4TA{ zkt5`-Jkn5n^6xx$6fZs3W}cXM(LW#2#3KI_yVMNoM2=trOC8pMmWfX>?cSNgv>OQ4 z;cx`dhwK!f(NB1suyMQMGwQvEEFQ!^5YR#!{<%YiZS_IDX5L*4;rQWvdV+m$Ghewl z-bCf`+qLpw`4#RfU8FDk^ymuvPz0x@Pg!q>Uy3e;VF*csXw~t_l0H>pE~a-Z!A0Un z$nI|n6`xrU;`qI0s^#|}{Wb<|>u4;fema-Osm4g$SgJ|lIqiLY5E2|%OX^`AM$(jBkG`)YBb5L^|8_rrFA zK^|;h1+tIZF8tvLzucW*u#HKZ_mKiRv~J+jTp9ulzWaC;@*U%VBNVW~$AKo2xFWqj zAX4#8=(cj^9N`$XGb?-}Ibk;()m@|HPU@Y(x@(kQ?rDeAZdI2+V*6j&YVVRA?~DC~ zm6&OK!GHe#dGm8?|GfO%@0c~k{&~!=moki@UVeU!_KVp)+JO%W%g^_#vtir$)$vd6 zZ!H#DizJw(MVBQY#5RB0cJ|lX`OtE={0h*68i&!lHtB>GTWOQ;?++OX#G3C@2PYW=JDq~i0?Emzx11vWR77I3O&@o3GTHlEu(wmHf+iJaMN z^tZH1czC5UbQ)L(I)p4#Ny~PU$baWit&iONZ>B~ostOKPGl`<}fAkZ2P$2BkeZ>sN zzD!Fb1VC57Fa)Re4rrzkM#Hbg)ct`=m+B6%V3dvhegjhx}_IJE*_2@8dafTUj z*v*pAgk4+L1OMfcP;0K9!%}RTSsH5F2RntAfq$ED?Xv{GC@H6JIYGY?H$d%MwQ&+B zI|qf?_|Hoe?&ac)72v&t8qIqnX;vmYm4t^spSd${Z6ueeY++Xz`2?^2oL)g4O7ugz zIfw!2l5oZ1&@FeU%fqQ*b$Y)QAd#5QU5OCrs`fkH;NGj9jl9FY4JXb39>RvIEw^gd zh7&h2#2xqyM+W*!;iWC*JfWPtk}}|IAh8v+pS)}DjHaI%M$?Em)^AUJ zpABSHsKt)ZZA(Ohe&uNo^*Qocwl|)p7k63#f4JC|2FRct=8giOY$pL!R-V9=xU_rWu zl~y1i64R_&kns*WnH%hnw&%^nSS-aeF__b;E+fD+P<;IPUt67Tbk*s%NE+rv^hE#g zcRuah2RwY-JtOLJ$V9rWV}KU%NKS=&?CMrvMXV}{1Bd)Ukc3sz!4vzjGWa3uKf|dN zYJG(V$?1$k)BZ5_F_8Ibjh71mbhwtLlYzmm{n2N@aShM$WYKG^Z_ z09EjS9S?V#Rg=Hwe&prq&!{0iCkRe!zssMO5=26rd$jVE&C&r~VJ#P1=*a?`ENOoJ zwwkxN_di-m!s7{UAyBkwkT+aq6GaD?YW+HCq5FPE%|qzI3FH_w`Qz3`IiGD(eU5kB z*XrEK)?`-vkHwIfTPKWftVchGMJxNH`&nZBWPgM{N)&x`1Sd`@0l&E{$p8tlsCT~n zY5M{9SOe?Tzgs{3I>7ryO2EtP-+^D^~VoU^&w2y7pPq8{3XP0Qg2xpzldy;CNf~2U#&-~~sjFx4Cc+BEB%&K5KF+LmC zahG}XO3g$b!$;b4^LNTgKGd=HlZyj)U8+W%8830steO=Igg;jMpyHL=-_pjKQ9HOq z;`uvuhl}%o2bn{f9V$ahu?OzkR!$`RkUESlz2L`|;75*{jt@NY;p3@n;5Y3ud-ab{e*aBflWS&G0~QiIvnE=ZObT1a>I_d; z-+(o|)RcheooRIfWpwLR=4Kxx?EU;Rw4^i6NKo z|C1a$c0H)X+i=K7o!(!lz#(&=G0^|r4PK^6B^(Uu)vtZ?#hJF2C=dZb&`)7PW%%S2J4$9Il>%mR(3e^VJ4bxZU zreS{QG)&muY;$(h;>tk7ymq2Vec4ca;M7Z~Rgeo5OCG6D2F?Q@6X=xY53+SiuEmuYYnZcAyQnU=GMUL&lx8N#(YtjJoHS)gz)8`h2g%{*M_sJj)kkrKeTW$ z#aTA22*;l*^5BGNV|HeizI`EYT zq?G#MLB~3fzF1yes9?{WL)iR_hG+l#GfMJ9icyGn;F}vL&O)&5l@Es^pYd$5o+b3Y zVn@RWv3*zqpi0VlvN68A%jI)(a;%Da^2%><@}IS&E#U-z zykA&&BBP@|l!{K8W=7Ub-*hI)BCc>6tR_z_O79;3#e-an{ok^9^;`Z(IeyIl*(a2^ zT0Ba%l+p@rv@X}E+KpiOZ&X| zg1kj^9Wb%u7JGm;kC8X3?5W}0K5+48`J?#FN}-uiH2%z*l*6xQrLxKTqP zfG%q&$PYGe}R_p~8GZ>KLg!q34h~;M$MV z@j-SHt=soVN4~`0ZJ&SjZfkj^!FNZ!Jbi!3IUi# zxOyL5R=m{Po2pXJMJPL{w&Ix5#@A|MrKPF0y{IqWzx%xhPg83oqYx8FEIp#*+&gLD=RVHwUaV(*W*xkXjW|XRT)mVi=UErVdGxlm6TisGI zb;|UH#_~zkEjQ&|eSPE6;Hk0e;LQu@#kS6M;uvU-&rScx?;1`ilpW`~634Qz-)JA2 zBQ|w#I9`Lq-Ud@gx9J2v`_#T74Fuk8vtPdq&VC#aj-SU;R7bkF0$TXPoKxEqEfiup# z8t?vO7;oVS(*sAY49!Tvr+l?ngKd{Wvy!qt3_FieRF)u&4}Ne4Ag8zbp-0C{;aQU~jGEL; z(z+7Q55FwiX-JJ-iq7FezOCIB_d5V{xrY6YC|!4(oNF$zdsw;B>XZ&`yh}|EOC0$F zs;-ItySVzVqKn#4WHS%dUIfKIzP94u4KwDCD?M2$A5T(t@liUdgtc@(xCmAZi^@=B ztW|G{#FE%I8*P^1mw@%cN-BA>Gs|`}1`BIBiN9(=N12SIt*g}P)oOK;TK$2zVtlpb z1Va%i%XfBe_L1X)u8UTaCI#06KTt`4jwJ_yxYVWK}d_-LW%rW?u4s<_*NEI z-?Ki=)pb~gaP{mB;%Wj;0{IVP`^z!ziMRO&#@k;_?Z)%Jc~v~0-MzH1ffi)SAkW52 zUL&B9QQoy<9rIR+1i})~brR6yC7_YW6iJ3N?6Zvd%PbW0ZssrITZbRt2?eYj8$Rv0 zfc7Vwk<$7Tp)tDcuuz*0j+3So*QF~+8?dQk z+g5Xbd2x~(h2w=R5W7Hiq1ys$r0R5Iku{n;=w_G@ZTgYQ14(9WtqoCzPHiJjSySU8bl9kIS4)9?)@y`NNT0N zHPa%I-|};ke9T#X_=>u+ zf|+qQvz>1KrHOg^0~;OKH>exEgWU)7Ris!873Y;o@zo2G#e!rr-{}VabUx@%|J*JX zBbfXvp|x3A24bswhgQ!hwr;kcmpJ2VnSIG41B=hu7dtfGZu=|UmI0GUPA)aE8LepQ z^~dKn%=E^Rc2M7xwGNiq-zv-pJu44AHm>yW&|~W) zF3W@uXP@X-l@QhxSSqg0Zc1KFRC#As_fYbo$9U20{2Ivz&*}H~#n~;J#WM157&j&S zE6gZkqMM^`a%!Bjm%WC^ z{*$IhEKcXmxB1CBHiyQi$#t^kxJgtoniGiP2ZrM_3Yc1bi7!7-e?j3-9+XBhAI4eN z`5Gx~fUUE?6YZ}Nd%2)EPGCOH2eTsv5P;NmI!@586H{oIx|tZr8r_%%(r^Q*Vc=?6 zCg?5oJ^;TGf6d&9!pi90wA-Puq77LTcGin&3M+FIcF4N4hH)QfY8XB7e*Ar3!z|*? zpso(uk1RYm>N|CfsL#iu-@R@cMu-^i9dLRNy&`%UpL`==wM?@<{af_o?=QX4>6iKR zM)cFHEA(SmU||4?1*@D3jEv;pkzIA0%3|s{+VjgMisl{_c#wZK1h}yZ&$Pr%tXf9f z8fAM!f&DtEairT%mB=sZH!~+y-BnJmWR;Q!xpBXs)aUz9>JSU~bX}3SwC1rN1yBKr z`6AXBuCueIh_n_f2ATD%cc$=my*Kn|Es+#+K*Thotn=+Jiue&%L3G#PCoIG$6nROi z9J1~*an6^CGu-SUZ<|8bF?-JUr(4)a>7wb%whs>dNO4vpI+F&iME=lr>6fSeCXp|Z z&2)tPRlvOHpcS*|VSy}!Ce>L5^Yp#l&(tTwcoF3^lhi;-8T(paWrehG?Mu-}zj#?R z$ogM3@wcpr-c;-jB;vyyvYTIY^wi9kC`loku)!7KikD~WprJ9RoX-uYPWJJ5en%e%peQzeu^%yI>DWT2UcglAa!d?QR;M5M=(JQ2$QbvZ__k(z`YnKXzz1D zz&+RDHjl1%y{mV<``wG_-qC1R?vQ=uMkXIQ9HQ{&at zMB75aN@C@`IWu#fK}h9zlPttUMWf0}xu^c^tk`q^ZiZAdJJjvBgW*z*mx+f~T}$Xjt+t-t%R2zvJ8 zW3u)?x_#c-?E1fay}SL7zvP_-12Ml2wZ+wrFDn$6jfVjV(!o?XU;Mo5$17o=Z|=ykpaEVk%2#0%1X9$t>S;zHIOjPis5|ZIEMw)#1^ZoOtES= zg%2V>^RB#I1`>p+^qqIvJzXoaw~~%Dy)tWn^}pI(Wwuq=C2!7drY73KJ{*oNeYKV> zA+?-xlo(Rb=i!{%iZ?=STEf=xuC?)@wecyuttpOFteZYX)+}_WT`CN`$qpmcW*Z!A zW-vl&MAos%pS&0Ohp%qb{)AJ21xL;zOccKa(N_r?Y}4Tj+PouI`$(@+&I6f{${LRk zAd)zB#(A-++X~K$MYa`lT*$ zz1G`L!&HEX)gy|rVBDAGyhjKJ9}OV$N*;kQm#-9oabtz4N=AoI4+tCQIrebaAHV;W`1T0u2JM3;Zg1yU|?>#m0>ru@5 zfMT)*sLA)~$oCS-cl@vV1BiwRSY^IhRaYF2*AHT)i9%aghOskb`&{vU=cIOaC9<#8 ztyv60+Lu^Dg<%%q5I=)&E-?+p9}G0D;HZ8pMk5(Y%lrJq9^(-Hk`um4{@-2N1gP8; zD~y2#3lvBbU?S(}n((iP_CfX>kBVKNE*-{Is-ViQgduVz#?lEOjF9imH6vuAU7Qi( z$0|~pk#iz{<0wp#pRbm(_dO(Ljr`>~QG+GAE*D>-@*!My-Q3|qBF9+R$sN|To0+uO z7q;0-{V>bK_kHmVPrPEj$uv&hUYa3|ZLBTJG<3w^Bc)|l$6YS85;iZk`|e}!Kn8o` zaq(iigxc;Zpk2R*U=XCWI#`i^_=IaD&3?V)gxpS~>%e6E34>E zqNvi+EYp@RC$%T|4%bIwZljfdU+VYH{~BBey>m~zb1xFV-{I@f1wQ=42#7`YEv$qi z-H=f~2>Ge8!6xpRcb$DLx7fxiC0Sy9{De;oPUge|${m6-otN0g=DItYG3^kQ$Y>Cx z<-{UXRt@n))Zo=^MY;iUsr5j_KMg|7`t%+y*laXxP-oSWsId!de_(vb%Za^nm3{3Z zNZ6e)KnHKxJWcv_;YtJC9f~~Hl*sujozeRMmFG0F3>z%ZNs#!UQ4XJ@7`r{upu7WH@)Z?zhQ*zgE5H7J&-n4WkaT1-lsxyqxJrNK9k7%PQi z^=0-AB<`MgpW8Ri=8>?fGj4SrPVc}X3_l>Zg?_efY#h+8@k3{Sa;rYKS=uLqlm9hH7Z~$qu;`Ou5vr7Ga)=M?f$*`r29o&1x%x{ zcpq((Wb$qgnat~|gT&6(57M+hixjF@-)M+*GGJZuB)y~W8|aQmt)5B#;5%3*suqpiGNbnyXysAbrDf;1wlc) za8VJ(RaBH71_e>M#U=0eTixf(naL#JKF|C9KEHqF%sHpKPjyvwRdscBwSU^FEQFU@ zK&-38ZpF7akqw>xk09g&&-#IU5MB`p!$E}p`}dQ)Fn>J!ghL9EKQVAC@v~gy$1nVh z$p3#Cnc)lo<`6XEj^~Z%0KM{r!-MO0gGFk9`*b0-3J+BG{fxaa(pRD{^nlddA*&>i zrAknl_Tm-L2L-;zajEK|wq^@IqCwxA;0 zTu)XHWqpbZ)P9qShJO<3 zCN&O~65vBTG%IP&6V;E118;27NSIX5aBRJTR8o+39d0W-@c|hZM$v1yBt=ffwrL6j zB0$UMMaK|Wmwgc(9$d;EZ$gRbR$k?a#i1doGzYqsgxb?kK#(~$a^@_OEnB^p6oDkB zxV!~Rr{bME%S__9bL|?l;suEU8(y48mGmfUr#X1)gJE#Jq%wdJ+=n7$9w|lze9U5E zQ8;l8po2{Y{YyL&em+qzNOXqGIT&sF<04iNP4k#kfX?FncL*Ep!v_CNLX}wejj=Z! zm{C-QDmuwA3IPC@H^&)Fr90O?anssXy$MS}%i>=Tg0DcxM?(_i|JjbxF z0d%j|WQ35zVmtn2J$eJ2uwub#BeXrDthpcLD{)u=r*UA|X=^8rOj0E?zY|U&RY@5T z#lHX^SptN~I^@c9yrBnz@&@PEk~~KEfbM)5?!h@ON+h8~v0aLoDNOTZ>Ne9XM7F2E zD#vSoI@SiEQAXse!UI;gx5(%_*?t?x$_~om)qcVyku2w_o}+Ox?r z1D$TtGy?*Z6ZfU0!blRJEZ(uD?mL4zK?+J4DV?a`%A81Jco|p#coh1a2>O5`jIYG} z*p0u0VcRcNP25ig;5&)E454xaXINvNOZpsK{ACvkxj6qg{Jg{tI9vpnNWA`t$OBrS z)3qxCjsi~Lju=j})L$oVb|9dF!CoB~p;3&Oj82gWN#Q5?ADP*zdXbYxj^L_JRr{KW z*kx6B7vA9kcL`F;^I_#UN&MohA3ed^K;1}8kp`uiMI$Z$hqVTCV&&*KX;&{BVXP5~ zNN=-tbdA2n_5^%dR*L!{8iqxXf5faD70Nw70uGZNe=4p}@zoi}3u=_9_L+bMva^CS zoKcQbUV4rEv*WM`n7SAsVYNn1;ltE&(H)R8_?|4lP&ppHfC3@$3cz!W|FE;Jn=htW z%r^>o#OAm^K^C>)XC7aqKVue!T0LtPg$%HwhUdNFeyLh!^zI(!YE`7awC|ryzND9C z+`h$nN}}$4j~D2bV-HRW+3{W=^0)ua?}R&=^YK@b3E}8h7YXX&ANf1W1FSsC{ap1b zQcWZJbrLZ1ehv(nyI!ZjN?Q`56_l}*7wqz=Eu1@_*pQtJ2&TjK+yL@B^e5!t3vFCa zk|IJHNC5BROu0%&QP>DLkLP8gOyV>~Icp4HoIJ8nt`3bb&zXM@Rlp|)Sc*_%yS0G9 z@F!Xtcm%8Y>+!#~rhWY1`Cp@fv2(<5Qa)f>#@ArZ-#!p@b7z4W_e49a8@g&S5)M^o z)QFJ{1hA0pJHF~V*zeGEu&hC5uE&93>lbQPK2n~gEhxB8 zj~Jcx24)ln&DSrJcw!7~5O}2e5L_axOC#h<9D8!^OEmIK(o4}h#xYEyFfTL9 zQBHf`F)5qY3UvEI_>E+Cl6&}tl2GTJ$N*dU1vN%FktWJ3)T%giMXKt3JCUGwo^!Bc zO=L9qk0MlO)}a$P8(mJVybjU~(uexHEAc~@uSrm4*_~I`7XI>*+gX0X3U*!@IUM-J z>H_h|XKE@VKv>J*6)l25Tq>fMw>*3rjft3-d`!qhL0Ob_72!0NDroT6&E~AXb2O(uE#zQm-aRZ6Gr#iW7kdoFFu&?5wIoc0 z(Ab4r=TZ1$ODW)@U^nOwHt2Px=!2N`g{an4!LBWET==|%cR%|-j?=0Q)(0=CHVtMByt3! z6#884IUaHZoSusrMqcyL6zavy7Csz#u&MEaC!YD?g%qNR=Z8*Q1nmz!e4Tg-9Y3K? z?}fTC5eX1WzT4Z3(4tg*@`UE{06jtJq61+8VEs6}Q=|bx6Jl18Md>;b2?d||>zg$K6eLQ%fMTVU1j^-&p2{xtbDztsGx`EOp%V?d~7>#N6qL1hmQ!3lWh zyYJlFk{0o}byal{`Ez4c5mmk3Kp_OO(`K_(u(jO69V(`%?c8hQf$b%$wS(aR#hl-K z+DUCmJ)~a2J8TsM6=mphrW{O(CSf~H&HQb1;{g9oSxUCP;NOWk05W>7MJ?e2O7=LVu-TBR;+NC^I``wG|4nvBkBIOiL z)n4@`FNgugk;F@IesLrIro9djq5SLci%w(v%3dKgre0**d>TLyX5web8h$Q4=$L!M zXOI2CuOKpUQ1bVUh)Tq>p*X)VauWRH=SnFtO|W8&{0O!$2SsIm*w@EEMihm+mfV+T z)xNXe&ApdR_A4(*md$&)#oXpucO$?-c+q~2oiZRtyx28>wYYXEhTjhCBqVqkZ1Z#Y z*b2cXSb`B4nv%*Mz!uJW{v5z<`{vFEzz-vXDgcHp1}Gxk@%CQ*wgzuWE7U|Sbze#> zq@^$k30_%A!8`sLUzTIbLk6-y)aV<&i?+C{nlVEj*46tfGi|LG7k z@w@#`!^w4V`v)O`WcC$0eZ!NdCQsW{MJx0J{DpVqg?5i&{_`=%u$j$pOij)?MSd~W zZtNn_qn5t}_U_P}Y|HMSa|$vH(v{7aAaxxlPx4T=z%syM1vb?q5O)R00*%nxYFvh; z#oN007gQc~N`HGG0$=xZ86U2FCp$15PansYR%Q4O(6O;j$1?OLr z5Vt}vJ|k~Wd4j3|8hQ;0;%swVs{?5}o!MLNc&( z=4m|*`KaY(T;Kp^L2J$_In;Byw>(#{zM+J*|x#U(O`yq0e!CK>NnwUzyesQ()Ndh7Ry*1vE9ZGys! zaEU;&IQ6wp$e?EGa$;q8m&k6}Ent2!1OcQXEBJnr&gJpQysLjv4Z za=OX}LK%HW(H;U%iem!1b60f$L8x%_{1gQD)trR{M_gaerPhJ`bIlzzQm)D}l9R9u zRn+RBnyh`YPKWMM1qhANie~zbzQ9yVF|0VfeGenA6B){=)I9JGZ638_Le?hMEQ$VhMtJ!JYDp%78gcyo! zC6rNnqtFco71TC&Rd>S4E~L@9tRy`N&CzRUur9g2#>FoI0gHILF@z1{x!TiH)9=!S zxI;062xkcn)pT{;gLqhQ@{t3kdLa>Jnqca{gQiV~76=|4G?1_1t}RjD$&Z{!e~E!j z?IgCevG7Q)8X^JKb~WWI$=;4+XV$XeqVU8v2i?}rIW@T+;|wzb-`n^P!rjvfgbRK^ z;CRCI6dP)MJ0XpKCNL%Xkl)526vF^^y#6MMODmHm(}M!T22qAl8LK`#EIA3m ztd)PHTeqK)mUL{3S&6X;T_$@@^n8L8XN&6aQgjJb5R}5wTF}Xy)=@*^Zw)zj%>yTE z$lP@dt`qxf5iRFv#eal=KVtd@W4h>o~9Fc*SAB?v*xfr$!BW5G+Xi$JCm zXUp&+m5#w*P)Q|$O5eUGR66^5mr85fMyX_0nMBkDhz*EJdLWWT`goT0l{lfxwQcpnR*x(y^9r&!hrRQ@8D4m@DL) z;?*`+sPyzSEs(P1ir7zFDTq?#ie18TMHm}`_2@m%<2@|9b_{y0`&@Vu3Vw0U9!B#~ z$Jf&k43JENy5n#o%f&Bhf| zE)kr$_)kHar;F~pjOG)fs!Y)Uu9R2=)smufa!PTko&FyE3%aK` zr_IPL_LJg{{f1?VD3L=56T%&EZDPOtc#7^HkHrXnS+uYlJ`MW+jl}JYxg0`1q&l*r zGdH$r#)F_)rpkby!PP=ZXIsou}T}Ak%fX`chfPo((3FoCmPSP&wudu`-DOA_$ClChxOzUXyWoNU?OqOlKtG|ovK3JEef>AH@f7{}eYO0rnT=IzPS-G4(q-{Ec%p zE;}XJ@JE5~Gu&YE141aENUhqpnafPmZcahd5bb;jE#jZ{EXh;5IOi$A*v&tUTwb#{ z=OGk>b%lRV;&~FxY=A>bvO5A^lmqU~i^U-47qj2{4gA+Z_Uq5}u^PT0*UFqWG58ze z)CT)WNwD860*M-P<%$oYW^?%K=+tLtCXx#XDcvK0R2qmv`kmo5|AHAg53w_F7@&9l zyMDus9-piU`ML1}j7;EerLfl=ZEM-S<(PC zZ0}Im@ft`;!Sx8@!zxc{PZXec028}v&{T-hLP@E znjJ_`^g4=&bk8XYTF9$U2o%0hFN2#=)SXxd{&T&cOB^tcI>WN7vssWbNA&+})Qm3H zVukR=2Rw_qG1A2LeV77&Z19m7h)+la@ywYAg7~;55SL4xbO$=ZYvSi!h}93r#X-9m z+j89{=s0Mz3GK#*W1yW7UHaDAllcAqfdfHXh404V_hr^O2>kYqhq!&S5Q7axNP|l? z$H1NhJ=MZ%p`tieNnDIoN*BjJ=aJ97dur(-V-|zcFYA+f;EpdegO=^(uF}d>e{8Y& z*nIhzS^I^}??vY89Q-N|15^Jy9{*rE9B?8KT?ke`H*$|OYrwh!k(-I5^Q;4Z&5W$H zkCO05+eh;$=BI9}p|TCm%c&NnYpz@nmgkU)a)mOME6f61Mb+iWI1t^QF9X1J%>$0~~a4>Z_QR3D2nsr3)ODkG52oeN|0BH%3>9zm9 z15vg82c?HfTE7p2=+lW#5Y}q+(|n_!V)gq=Jq-Urzq6zt`q}#}vMy_Sx*zcNf3&AQ z>#;s{0MYlfT#-c%&zq~?+tf#7(xIgu{l51iN55}EuhiC^TEF|*BqcxbL#cfkh86Yu z9Kv3iPuU(tL+ANMwr}7dglrc{%Wzt`hipeP;YqOUoqFo)H=>&T5$aI%V~$)ab6O=B zzoT;v{=q&{p88$X^WvOGjGAWsX8Z5dXJ=%c0UvZ^hBOe>?>iJRCO%PZQO60E-x%VgNiq}|K{wS5cEn#1*nRiM06Xi{1i<>DpL9Vr zZf?wa0IHfvG=PjzFxSoin8to^;dJc>KGE_K6&+YlX#v&;egmu*#=^R-cLG>1=XXue zh=bNxSd|2Lcwy}xt>c2qI$}5oO6Q}F1LpL*n?orzFi8Rptj9HW6M=4O*VR-4iC;R~ zpS^-uw4~;*25@`xsuK3|o)+{X*3TP|Xv%RGB)G=v$3Onx)Q>M@8~H^22zg}q`=Nu@ zk7Z&+-7H?v|3W`@G1dRS(vNQ+WBMPX82UbUu=?>niQ&CjcIN#z`f-S-{(qw%JDU2? zk3U)-{rDMf^!%5qP_2q+{rCk{l~+F=P2FSkW2<=m_{%(_ADKO61S0vJI}aq1FO_%?uSmY1b)5N;E0mk+kFKcc z2Nvp8#s>1l_QUVhXDSczXU(fJ)p2JF znk;-t;zQ1;zm`D7>G|DQDqp0?Gl&@f>yHw*XXbb5j{cfdAJtz{-7~*q8y=xCOKc>qzgU#>yIh$HEzZf4>--#6 zaivr2_b)fqjsBXWZF5+*NvPZG{7(9g%&X|4cYfy#wHe0nMsj-0X9NkGDbFA|ci`%k zk3OgW&|d^w&+jHZ71duGL|87)*(}$1|Ls~ayR`mdNzTu_-{Sm^H9g%Ac+q#Cr#|bk z{`*Eu%d86Z33GGxhnV`%U%mQy^j8<$X#JIqUa9uqY5ldGXaJA%q0H~jWZTeR?*qnk zt-qpZ=<_$DzZMcA%&K38&TehrzrWyjBwfDhEnm__WJfE*S`cS#3L8fQmk9J+ zPB*Lf;RGAhPT5gz_{~h!1WC?RO@J84saiVw@8HAsl>rDs%K|DyC>XYg2O3|F3s!2O z^YV2$>lnuxV*=N{ws1fV9o3u{rxdZZd%d{BzJFUB`CMYTN zc9)&Ed*rVcB;NTOpXm9mU(4TFLR)%P7qX_Fpm5}hU)5C>e4@@r9Y_9lo#K(dF@qWL zv)cjeS+T%wkOa5zk{RET?9CYv{iF-3J1623^)b-^_K1Snk#)@c&4ts|zkDM7n~jPN zthe6QJggu62w3l_i$QG9M6fauyBSZ*m&#`=#^J~xIF939za%V=u?4`ZE5X5M;6QtNEO$mg z67s1b5N?fXbEKxWK-7q+1bD{yk%IO9dyhl3jB8$+!5w~!S)q}Vjd}1}SEM57?)Dvk z2lLD8`KCEfF6`gFTU*fTsNc8c`RV_{`v0Wp`ak}1{eRP=SpR>HDDa(qesukR3zEjd z_GgsF!LR>sOxM9Pxy@Em)eC4M{I2!?a0^I_S^p<~#tlboL@o`DY)0B;LyJ$&NneO1 zPKafT>K>?v(u<0aAod3?UX>D5PD{)><-U?m~VMr>B@vW0vf zy;T)zYh&b|SSNy^4-3|As~`*`2?L^P5Ccy81yLsfaY7RsKD6u(!z{ZPOe6bsd=ocN z#i)luGwaY7(4V>Nqe24&)Wo#d(Y2R};KhFpdBu_{= z6e&-02Es_1a&d`d-&;NQJVu6;!r?8Uz098E!$GnI4&c~NiID$+0`STh3SB|hc zWTDezcIKxTv#ZfZoomqfmh+kO83b64FJ7555G~$=7M%|doSuR#a{ZEvYQOd4D;xn#7wB@9a}JS+ z_QDrQ1P9S^!&+5*--IjSU-CvH$MOd6G=Ds-`6EF7fMc9Lq=@hbc4U?dpQR(X)L%DL zXeqlI*3iD0gmaa^ME*LS<4cILN$EV+$B@g|dG7=Fdq|b|{1AO9QoqlcbdFe+CXpEh%a-@G?)Ov#6cbZXDIyQt2g$ zsdqNhDWBEL#w+BpFTllp6GvvoQ)R2V%}r=+h43PLk|+4crLTk*H_ZX-&=>Kc_@1V3 zyEyuG{m9Vwdty9FTA{S_v`Ije)0|>1Q98NB zJVfc>7Rwjf<*SH~t-17wRPl2jdT@V`riY;)%iCF%mCX|6VS2sow9n5xAW^n|(+p9t z^QRdnuO5E^B0WY&xa&tycy&S(?80D_*MEcz5>vR6<7d$d(g%ff_!rOM0cp}PUXo89 zi}WI6v% zQ2#4wV#ZI{(8sEWA@?udsp_daHHjp>Fu;VY&^hm~J_)0z%LGj!OaaMfCG%PkX-AEX zQi!K9r>l*vB0MaKOCiKQ&`vetgp%;=ca?C5ax(|?WsF~t9#+ndAxmpy?0hsVd@ z|NUoM!2g`l@%SH>+#LQZoU$(d{V40f|3y+DG5(h)Ir#tlRxf6o;J@Kc!T;H(c}pe4 z|Bx^L-{XJ0@c)$N@PBnK`F~st{!5-|0slu;#N&S>;!c|3|67~zzr?6S`Ckeo#(#en z)%<^p7qd<9KWUoae{pYbsf74n`^Enh{}{K<93n^Id9b8m@a-_Z}l_BV(B3a50G|529wZ>0Z4QXsMP zU;ZBl|DTW2nAOtX!N02u8tDJFv(C=*mWtwE4cq9&dU#%(tcj8D{|$b-HjCe>-HG46 zV`K1p%imhS?>RR&#c#uJ&EYrQDedC-A1Ld=@Agq_E-`+uV^QJni8pyM*95<_?-2Zc z(aT%PgWrbF4g$ZOwf+Q8a+Zzx1u!jB_*8JID*MiunBN)}&8D3RgMfi#wyz)uLgJUv z8jZ&8@3PcIBVzjF%$VIbvERrSSEkSBfR=ovfl$U7{;Q=N<_E47^MYHyA%tZbRmPP*M8-YKM(eKFxpcZa0C=7oX$DL;XXgAm% zz*JA<&g_|^-aUZ>+4nN2YlZNvc6sVDRf#qt>%^pq`5}LgI~(-@*(jnDKcTb{sEa5x z?ztGoW{^jJHGD3&K0^KEE0dO4x)z6}sxEB$)tFYJH%R6hutH@P=%@{<=qvfB$JZoH z|5Cz$&4>7jkzWJ(8Vpfpg)-3~k{Vi>C80n%>|5+?s63i;qr%TmG?|i>H5apBnG$mj zg-WH^MjXiH-p3*`O@Qo^k34tT$gjryhrF{3A9fnRMmP8g&?xtTsC|ElZLPLCFR600 zRa>2ny=3y`6Xr}X=VJ6i*~nq?@B*hb)kPY(l5=M6^uyNx(hx|`(SX58xh^os=@8C$ zznK&JU4dDk50#>o046CHXCnWw1HRvZA{P9<{5s}}X1A*Cn{VU9Ynh2fp8~K{HDtZR zX4gmAOw;Fn4!qd?JE1ZFVS!i~my>moAQ+h#Rz^5rC6#DZZ&=FdlDXIR?OK0hlDf~r z5H(4Du~}1+q}CJt9PYJ}`C=&;ZWYT8M_HMFITc{LI$2dc|*Qz1690sxFv%)-~5&JG|<=5mP6oR8&^=1-qbEr!Rvqob%s;iU4{R>J;(4jz*HI zx?%_O8O)8l@AN7^{jW)$4n&dC{{~hMBti@*?;_@^Pte)w^P`AK+)v`=R2Ch4z@kLS zT^}2iFn%aX%Xr-IUdDehXzLk!RtSt)fl*ePUJ@$HBs*t4+I@1;YxGDWLj11}Pe>|y z4QpPEk61K2hQEZ9+D5-0nVaaV(PzDvBoqs7fdjo4_<6p87k0_f2u`(+gX|z&UgYdh?Z1U>kO0CX|WoH2v+sv zLqrAAp&+Lz_G$OSiR#c4R10?D19Ks;#Zr)yE;0pcQnVFH17$4q=AVsJhZ%(SewOwe zZydTkYPyFf%yd_{zuj7cYmWbL-$Y#DqW^vWfxo7!0H{RM}aU8e@4s_B0|?^I-@H=i=cp!=k0hcY;WXi%{t%krydr8yPTi`I*?~zALzh9?oe3+a zs%`HjVVgq+3k>F0F zW#BwAWUWAkLRr5a2J$1{vlSYT>NpALBIxz~$^JX;Kv}C1nPA4J7Tcr2PUF+vtTLHM zC{tUw^MDk;QVv>20BeOn-od6f(_W0f-}lal23hQs9h2|AN}2j{!Wwr zVgc|n^tTkyT!#LBZY|w+ZtXXjR`Sl;!X&4^M})_)zmNa8wGr#T?C^P34-kJ0I*fkz zLx(pMFWrLTsq8X3A9C-Xk9P%-seQ-hp^2B7ydgb#G9Exi6JLGNIkA=FhzY8D4SDhaL={%+Vt{{9>b ze#Hep`D;6YTwxxgF8x6KAavj94|P5TQ@z4jxX5X)!iziyVlO!|fPrpdoa-u;3kM?) z%-~R2`ruIZi24$oOf};&G&%r2VvIMOfwSRCg43>e1-=5-JG?lE1FKd5q~7b)%^DhR zp$-MWzTjT;2ggT@8CKl5vLqP5Qs;SqH{kG4QSGM8!O3fC3-6FtQ%izLGTP86B8#|w zAT53xz7jA<@}_r{MTs6nYmhIhFK&dTIHY>vCZ47Ade_W%oA4D0k{!lD#mzDoSk0B+ z;LlOuO7Ip~lddu@2PDJ3JLzYU->JZ2I$}7$y6ObyV;KMcisje%JI%jWaspes4GcR9 zVjSNnWkcnd7~^AzKM9p)Vn;X9A-!W2eCW5o2HyP(&OQzN6R2ryU$upa60)^4hDgs7 zMF3+q_!IK~-cLJ6v_cm?~XynIwqunq=dA@y6Qt$ zkb&S|`9rFle>x>qosK9HF=EJ&r9frbvKmaFN7Q4#w4TAM`|r~RTe-EOAEPsqppAs^ zkv0%CP-0m44XzBzd{MVh5?ocUHvZtSgsNX*cp!YIJL%E*@1^k%tULY%;=c^|RXiWF z4k@qq@Qc7y8HfR{4#2@+rE+|{<+nc&Xo&bwCa?%iX(VKEw>1~o9gu%#cX4nB%#|On zfUy*Q3Rc9lC6lv>7Bu$xsAACR^Ox;^6u-Nctp6G#rb!DQmvw}=%{90yILyfZKx z(C$#f859mum>Ev=UvRGqVno&pqZ2=U-*J%ol8aOilWY8nK8wq51XBUgAC2mYLot95 z05I(y={Q%nke_RT#3d#rC1ZW16odykvhno_~ zmkty0>B@TBbXjy%xCb^m9uYq9eabO=r?n@7emJYeRTQo4Tm42Gk0OnE?`G?w;qGWI;qZ z%O03))lSaIOtSogcSs*ByA&GBxWh`>A4nH|2Z3pG!JvugLKuJ#PB#9w%-bm=mniK| zj_aQB|FqHeL#cQCbFKpnmlN0MA7(vjJ2>33EsPM3Gu!v*OT&{eiq!7GnnTIZ>k!b? zj+y_0n;;xHu*xa3??GlClogU(i7pG0C{FwfI)evcbz8xsa#*~AxJ#W5ifa4y*?5!* zru;MhLY^YMHK7Yu-gb-st~2E;knyluR$9A1vtXB6-BwZ*mkqW%3r@iY0N=#NSOqKn zwZEaMVhHo4n^Hx{VPq%=O`E~N&M7?gbd8E2aHQDAs^t;TCDN`` zVHb46I0hjkM)$0yT7!S?gzj-MIc$p z>vbCi?~N^n$JJW;Z3;54WkL&|4K-4#L9>E=G9x~9n!t5=GQ}pTQ}Et+I1yb5#&dE$ zQy)?=1UIOGa$Q61)qub14F3FtpZe%9_psAtOB1sb#_xgb2WgLNLG8U1P)(WQU(hEt zP_sX8OeN~$PXT5gOTS5}eP>O;zhD=P(#Rk@y=F`f>5qRS#$TY{KPvC-&WBs}#qA^A z#s7)-MPp9F@4)fhb*VSKrRuGz`@r%^lkcE8@LunCmqFH4rMfqq&Algzw;3lx+{{(P zuyAp~SGVU`useG+SOuSt8Ey4|3A*0QD6DQDS$5}4!jFU-a%vlnh>f(;@-!W?HFKHO zxJ19-aofoh6!xSyVas$G-@0}g1jpH_{q6JL1b&K`@UeC6itIpsL*;vDI;yQgv7 zwAaB1jgd@!>DYUTKDEk)40*?@4%ZEhX~#n6MmmqEXEw4l{dAmoxC5NW?*1H1wi>Kt z`3Jm(uxq!G=wXP!ebLz2Ri?>(wlp}rw~qjeugK%?{xIk$?w~>7@oy6JWvnr zhGd3+0Tf1(G)$8xGY~axE}I0qR&&=u4GLPe++dRfZgg7TeZK-LII}eF6beYz3h;;8 zh}X#MTV-r6@wKFQGyA^&RJ?$O{K*7vV)FWKrC`R30I3IA&%C}J?soF}j>G0B$?H2^ z{4lUEc|=F#csH#t!L^*UzV*D(CutzRVk6AP)wi8VPC5&tC2vem{1%Kq-m?2FD5_n; zoW4tn?LHM24r!qz`0!u6Fl+D;!vBp`?HK>g2W^UEa3R;DzmDqy@_v{99?^RRtNr%( zd{}!p`ohn#KE8E|e;U^vwS@xRB{V3tdhE5tuLAiW740SVMajk8ei~$Vz!71x(3Lf4 z3%zN+v46ZFiRW^i#C)tw-dZ)7{HJL03H}5?-q7dlclU%9zB}?l;xDJX# z9dJU!CV8_1rwd2frCiPSVoS-($m(XRP2JwRID8Nq2;i)eHPx-`|4r zvCO5~EP^X3nKMtyr*SQxFZC0E!vND0Om))ha1j2!^QFd(f)vlC?1QPrA9NA|5X>0L z=ujfj^L=UHSn`Z?6cQ4_KU^T*&v#yW6zg-7>HTC?&Bw;4VX3l78p3P{_FO#$W+Ulr zE>jz18GxE~Q>pubH@@KXyZ%7uJ8SuUB1ccm8b{3f@6R$ibo|N|{znJV1&LqjdM$#7 z@IBbZ9ks89!7Q&zDY2h*uw&;G1PQDj0@@-MFc&K@KHKy#CpwwhF~Py>fEn)3^o9rD zyRo@gi>FwcW!+ed^H7#>0ZWXftCa$YV=eZ4PWGj{`_Mr;io&el*uKJR@W9TRk{0tE z-A@$?z&|p3p%?Sb#IKaJj9(q!tMTi^_d57pv^WudKa0oj{8qs4t)&{jTqgv6XSZ(w zzhee9#qTLZM0^xRF$)s4ZWKnY6oY%l8%uhuQ_Q8nQi(iqDUd7$5>sFtiwXs1STUH! z`o|xI0>2#+^W3F?>iTL7{%1hcG__Cu2l$`##zEn~Pcrbo{X&g@HDHezSC!As~{)?oTi~p%oATj=Ted^%9!}&3IwtaoC7W_|c zAM-ql|Jkp!h<^;Ky;n&KXQ73rMljxgrr#f#@V%B#k0SOK@~N6Kwt_OYf?HxlX=9(4 z=xYeXG77}fs43z*=8@q^>WaZsC{${8#-RfMO2OJH$u(c}8g(ZJ2VZvGXm>EPbjx-vjw9=Rex z%o0`ml2G}9kDW3*9L2Ixy%C($`1nHOawLLb5{rDa(EDk23XZ{{XK5G*Yfky6THe4?&rga=4i!TtF!vJA2S z)Nzr4J9(Gjft$lX&UZXY%&)!4l?Wc&ixW)lMG2>WwR?U3X$^RwMz5!tjRTNz!_F?` zl`GrG_$ZI?K{bjgp+Rpf*EkAD=1zRK=7If0Y z-$bYQLCv3w()9<=VuvBo=j7C|JqRmIpD}+M=6fjf-Cg|4BR!DD>;zl6eXpinmIVic{<`q%&*nP zd3yXq%&-!G&*#i3Ky6`BRg{XZ#(bQ$P-bM<@`y2x-zD0=vK3|@lcz{$kTiu?j9__#GdpIZ~i+AQj@sXcyiB1?Vl*BY3$>#n}YW6?+ksw6ii5cE>&^ug#1=jr}bV^ z5{#4tzedE<+xuQj`WNt@q?T21xzv;keo-8Jn=D&SE-H=m_Eh<1zf+~Yg({S7BrKy* zusCI(e%xFp*2R}qN$^{q5>G*V6N2lAUJ{WX-ym0K@M_+oOx%R$9Nd~nMhN5hxOS2a zB`CEn0-u**fb3w~Sb*J&@E(qB3>OJ~lEtB!=2K(RO+YvFZt)2}5P5ZIMQZq`S*(iQ z2iSWEWer#p0JwmR<7gf5HP{r;bpjDaX@wZj#k7(E8|-4nC&Qus2d7PUXjbSb>-g4G z3APoohFGLT(>q00a^w;?D;U88VIjj2`F!vSvM1rwP#J`nRVL=Y>N=FRAaH*PVzvne z8`W!xMjk(g2bc>3Lu=FroslU3G6ZYG4t}sFbSXzH)QBeA6f8S7CiAqHDS>+V3p*vF z;n7EvBG==#70f_8;|t!FVg07I(N|TB2Osgl`Fzjd=f(A!<6WsbUdCT+9Y8zW4 zcFWEf%Li@oXVu(C0SphihtPSNusfQ}bWQ@}5yMq=D*go+%_R+7!3IX)wiRXc6f@a-4)MzepWdILU7_)wkw`-Qgx-+m3>M|?o|PSx;{pUSA1h+Y5- z-~?C)jlm1cYYU$*a7~5j(vv@ojC8W>DNq7U9 zvkmMB|IqfYc+CZGYi=?G-b}3Cuf&Q_H{M!37`bR zOehBIIj(scn7I-gMgtSkT<}wbpT}xg%p6qvzeb_s@&2#*A{l9_uz#))hfuGPd$D1W z-5FZxQ#jm3hjnB-z=#OT&=82I`MPxIYW%O0mJr@Tb6`D19!UKd8>9ItYrGI{n1jGl zr@=EMB*-I!eE$sVDX!-dClLm^um8Uggy#c2Q$V z!BYR7rvZ3a?ESkmV*RX7I>s=&W6(~ zf+^X$hTjcABM&@;W|;E;e2x%p8cfEVq4o^@8S<3&5eyP)&zpGv2hqO8xV?_I=kxtO zF=+N3?Jb$`wyCZLQiA4xaWgpumy zB_PC#q6+jOskZPVdEXuns`(%Soid>s0l=eJ3i+1?QC+*j5k)(>H3j>n(SbOEY$W5mQY3`I=Uzw z{IL%4F>0>^|0U)Lpon7+RXeUEtx@?=8K2B=bd0bUoY!#YkKzoBJjaL- z5aR4-5iq&C4`pEXDI{sO)2cr`+20Y#ri;@39kEq5y(k;kY^ZowLc@D)0I+?(JcD+& z^Q;uelNz>-chYr=X)s~cnHZ6CcX5IK^ha?i3Hcu5T@V`u5$=urN4@xYY!XP141nlW z{SY65@l}AzM_0jC$@uzMdR9*V1{YNRmUnLD>!OuG_Z7+~!6k+WcGe$0%-ibdlV{6aeS(-%sG6^TbY9)-zS3$0UAJgx0cmh; zV^mczwp4p$=mQf+z>)VfuSK~32M7i`hJ{DHDnv7nSB2Ccp;gGuF_L@VzMGTO>8Hl1 zkVk6bRmgcgNfKE-EQc(QQ6UQvZJ|}jhbMzi;#tEm4QBMv{?4>|dHq{K z-yy&6^lAC+836I}`@MPySdaXEj`vad{S;8`X-gvgi@1yV;bxJEoe#ecjCMb=2?^>_k zF$rmo_=H6mEA@%wx%&DcfRaFzhb@FOI#OKQpXKDP*gd}BT`+hZ7;su3ynVrzeIa*47q$iUppYi+bSZ zwXXQF;JE84TSe8&J;)O>DRf&q22i=H5!2?eLTy8`_W7aFTs%nP72qc=YUE-}HvX~E zTxk^e8OCO@e5hCK{zy#aX+dWDzS@nUapWm_Xy7ai)J%KfH`k~^Ia*h_J=~!YkfDJE zB5hp-ocIt~y?g0I3eoqt3Z%pS^>oO&i=z=Sn2q{<|J;O1L}GUMPZH^%>GLvStKDXC zjVfT-_;FCmYqa-z{^X!k?Au|viTlqL->-JD|Gi@S-_WH0xo-by=4C=VnEvOp|BTPj z{qN!SKL8Wcg8L0thPvWG)4^~a0_PmQbFR977i<0l!;OM{jQ*9e?m=}@O@zA=1g^Y= zR4rvab}a>6lm7QTIi`E7_qp9;XF%TK6Ws2hc645eU;z4u7A;`^Xg{ybrSKzcwad$w zk?lYgm;K1P0nLL+H1}N|RG%I1r2yjl4F_`ed)2R?z^tAzAoh%cXgKh1$Gaec1-!!9 zQe6c;t{(R$e476>h#LQ&Kj7dWnb@1bzl3weuF(?zbxE(aN=ILUUrEQ*KOTdx)Xqpf z8y_lIQ$_!KbZB9|V3uaG0ZiR52LFpris{@%dtLnJYW%<3-R)d{A{Tnvl>EGz%5758#-`_v~f(Ff#sbE#LeXjJ+I_tpwTfWouuc1dw z|L)x#-@kS(_ixfao&Md|z1jXvC;58cXUNAauj%1qMOtY3eX8YOfbs#On?D$T*?0;D z+&KAA-cSmH4RSEua^Ha?tvaI_YFHSfGFz#~1r0^W@`?QuYpO;?nfN+)bmoGI-~0)q zb6;)@0`A%6BEXE!)Z<(NlchcKF&FZ2(#vlDb7K1srMf)e<=?z|g8K;?BPHf#rQ{O1!ij*VmC-nA}{DH0&0pXz3COk+AG zekPy_7>QzMoq8O_-%@ME65tJ=bo8!->8s8^Z4)hVJ3ER-WhRqx^fu!G0bKBU*uD?8 z1DaF=jR|9YXn#C3hqnODbBs5!vz|IOF*Je#y;ko4NQhEJf)VwZs>eNEHX!aY!@oAS z%a-F~9P?X);-g4${y-a^t63q0nOqq>G@RV7QUBP*6Z05*9h!*w$QbhHqK4=*(1z7( zkt+x@8>Hnh0YxTUmT;<&ZJ>+PQHKL(XJ0-+pLNkR`cKEdtkLV|7S-a^Z8Akf{L9la z9?ca~oVpHtkIC~wz7VJZJOFoBtFh^Fje2iACiWmRW*t%xK7r}10E)uus?NoV@PDKM z=3`h1`)Uga@3MxQTkJ=vN?|`v*8R}sHI~cK zkjO6fLl=jkrG6cfpcl4pWIs0tOk5Aii(=n3+->+Vd|#q5BIBb!#z!{CM<&My_LeNE zJl66I4LR-uyybtFP9v76U7o$njVaT&GECJB=W~(2iV3UrQ+I8@mhv0mCH?@wGCh9+ z{~ju5!C}yEi|kmG0IQReD%2%i@z%~bd#JVzkfvcnteB!iK#q)`qLNkcKWQ(vKigUJ z=^4OjEMQ#rzIJ&jOy;b)oyS1urd_rL;ifx(-Q3JXH9y!y;K}9&wjZ9Iz-Vo&D#aF!&o~P5g(erd=SLzW7C51#per2o_a~T5#)lbg?3?uYxUo8*8 zaCt$da(3FG%ra^hUi9x5J?}JQjGgZA;SFNA7#KBw)M)+yy+%PbgFo`Lyn?(hwQBPr zv--0Hsi{_V#y|Q)PcV-l$0WLzx;d0_*gDX-AS(qIC!zbXvX>7roNLw1x4GHeA=pqu z&&4x6Y20sIHzrAS&(;bzl{{sqUGurC;sUZkz?;TB_ekOlt`Ikk`<7?eS2$t4Y21^Y zVhHf1(?3`IZ)&4kwi;eA@Gf(?f6~P?S>dE~oG-;B*pq48=Su-uw1iFNP2--cidodo z>X#`TXKV_hl+yt)pq+L7DI`jf^nTXihzlVesESB$l{#uad|!1yEh!1j_6`4Fyn>Q?x6JozK!eAR)--_IoY4Mo zZVQ>gpURAct z{wt-Ji~spjATj=Xu&Chw+>93SU*1#j|M-Tc_o@;30oLzwin%+OMo6(Zq?bFz zfONzMRbvZ(0PEXNu|*g0eWg%h#J|X*g7|k1YZ38V=n1s5azAZ?c%mX*oqvbHzMkkE zIREY*x{(pEf0sh-M#a#SQJ&|_S)1NfKzc?CJ))@3_N5jKSgnpcT;lK0u;Qz!7 zBXyec|0?o-W(@wnyr2dAztAZj|2IppNu1`r%PHpKe}oi^!+*I`EC&A#j}sX#{`*Ry z#Q1-aMK%AYw}}5O@YIq2KW>75!~eG%0{q|L{~Mddf5p4x|081XfAydi@ZYOrJpO-p zjF89SzpYcu#sBwGEDryh(i8H(6m{{xND3v!e;$i!{`a?t|LfsNB>%5#f`85bw;A*w zH2>F7ST~tN4dEOLhIX-IXy5w=4DD5jL__?8pPiL$YLNfYZEET2?nk8;;#;tNCFXPs zJ;yR;_TS+tgqf|@YWThLuMQ6E;XjF)t?e_jzu9A-#n@jz3HUU#o!!lO>O4Oq0JNpO zjPL1t5%z@TGH?YrC7B_0*wkg5QezgoHgZ!b7OdQJIz+LIfFwD8sA0B?XUemY(erK6 zozkum`wx`$=#uS+u(`yt>^c?|SvC>-g5xmh;uS-2b~oZQ>x&PX;8f2q8>$_|Cd{8k zv^l2^dDOc5HwOO!&hO0n0vs*ndVR}Zr}0l&7sbB?mx?}Ks7n_tCy)Y53YykHq;l)r^G%61|#5?X1ylf$3O@ z?j08>aqrQjMcSHGO~!)yrOF^boJhXhs^vGhfc|~>pTHrqQp9BtvaT4o;M#0B+^6n6 z_u|K|sk#wg`WMG0GMr7zMgw)N!49MDKpfkaG!Gt;Cs6PSzRSi@nb(JcQoo&bQaj>K18{lc$5f#;zMQc-X4 zcl2<+r-nbuRRFVOMIYbCQvugS2Cj6r1GwaB;ObCY_(y?DBIxM#Gx9^?FEnVz48|G6 zeWa)>y0XQimCdmQ{|9SGFZ?mRaQq*h)e>#)mQ@b9bs|T{hmH3ew-V2jR(8nVbu;vn< zRZ)uoRXx_*zsL+%xZ;m||4Mux9OwGZXdn%Wg^vPiJi9YNp57^StO3PlHe9OLv{lL zQ6#@`*X|^ij(IEzJ!O{O^lDBC7RBWA*rvd>px%w)ATGtB!R5uF+eQu!-RwfaBc$z& zs{x3tTEzk~SO6)G1q7+dH(+a}dL)McFm(iS^)?TQ-dE1WI6{I$X$N!FWHJL->vC%F zh+FUcb}IXd}836z9x;K__;`K~zlL2>X4)Gxx&sK=() zDrB1;j%?F6XAYjWxiTAXR+Npx$7|3s@|S>YRh^1!Z%gW3sj`st4Z;pl{ zJ0YnK7ogiEp;#IX2ySx77ioK6Xb7pI6L<$hruGjmD<}Yk>^;-s@5x3hUcd) ze+&qq{6tq|G?*vN4oLOFElp%cbTEeNJ^R8PA)@WaRrpY|G6d^?$lzQGj9TS9Bx4xF z2-ZRZ5*MgF zX5HKbE8!F)mURE$)BSHE*uL%i=9!x?e$;HAra3akyxE8| zjOjBFZ%C?Hn!}Ac<6aN7gOqb9gDy@;PnwL-ceJP(;m6N8*7=G@08QIyy_U4T;}n!f zX59XtNkMftMw~1fIm??`jl@p#xJL2#DAVom5zWhB-T&RX|JBqX7{>g8gq3w~cmI}= zB9i^O9NDjPJpy*j^OHORmJSCIu!yaxlx^aBa2msa-s@Z$>n`|V{r?zr87y`qsRkM6 zyYVfAunb6{6Xurv2BDOG9w*F5<&zkbnK?BCJcNy)7lTrz2(;-dRcOdcdX?%_btH;9 zsH(smfv2;Q;p9K_JH)78(QazQO-(pPPX#{k+CCgZ8h;Z=lbHA>Hd|JQ_$>Q@#&;h< zdcCFA!uKz}V)kRFEbLERuzM?xUO0+*L?v^oEF7*}M9jUG%*JqvLUQ#^@G{2N?cn*L z^w<}ygsefs;8PkOw(raLfU7R8wKZ!3fS+IE`XNw`!AB?jhiDXI5LN;Lym-DGVr5El z^1;6|&{aEaKC%ErfHoLO(0#zlO5(^Ygo8oLG;G=;SO^ouN z2wfiG3;@Kw1aVxe7!cb>K@4aR>wa@VL``pmXr9^|;^1L~sGmT#jz&-#@LUS27jE#< zP1fI;zuggb39g!c&Bj+U{!kMIlu@^ilRmHPsQcVf{AmAGCjM|za!l9#tK+E?Y;e1t zEnR1NDxpp`=Z6v>BE9eUpV;1O5h?sDZqb)Un$E|^A0Bjk)kSNgu~gY6zG~R|=rcg& zOnESd6317aRkJT_DZc6| zG@3BJs^DaAT#^o$Vtm!8UWwzYRxa?wCF$ZNIc3mK!w8?Tg^=ZkRF^7{d=Lq=}fSx4^} zO@nUtQkZV{uW4$!X>GjWTCY^6-hv>44ifo(5b;(1J7w7GhRZwg-=G8}zB3)^u+hg+d>sgd@`(!35Q>fqc1&g!6C zE9pb>t*C%A=Z*$_AP4ms+!Sn3wDH5g8l#4;1568a02gjl`ZV^FZm6IIA5Mi7bk(-U zhm)_qtJ~V>f3+m%X#cD4QfW{ymx3$H;_VrBF9J-O)-I$!&n~*u1M9d8BI-e))Ia{rpFNu`QC2op?gKMIy17f~XF zM8L-P!9|m`D=H7YxZpWBircUkSo$-L;uDHpM{!vbpMATZNfPhU-%1JZ@Op@|YYV^G zX^Odv#7o^`)zQefMQ$<2k^G1hW1dP`8hk_wfU9M^cq8NT)hSYxJ+jk|`w28=Xd{W^ znxcje22z^Xg?G)@d=PI3MhT)fg+KJiChYH-7Efqt1i1W-!A;6zZiJ4wTm#I5KgcNv zB_0L-nX$Wh{z=D&=;}WbJ~y1#MLX8c`X^&O&_8X>VHr-|>4i{_g%{6g%dbw{rSJu@ zjHdZ(l;*E;_Mwb@0MK;U2!F}q9hhmPx;2Z=A-L21!g3;@FwqzRv35L}4C4i!Pv#Dh zbafmwUpx(VduUe-yDc2(vfIce?Doixcy_zIhF$4c61o_rF9wXIV7IZlSV^!nmq$5P zBW=k#<#$VZIIh?&nJ*=gmTR5*P9iiU=O)*qyGt2iIt+I&(^=|uDJp(k^ws|=`-)*- z3ghKb?2I;PF)$-1*0^&{co645BUvrVEb>8z+G)SNq*+lHNhljSUeyfA%35GRO~1Q2 z-fOpwB>l=sKVV7H1!#wtT95ZQipux>^j^ub!L^wA1Iw7;MQDaji=4oW&kF9*DF*rn zS95-`agTO6B=8Swuf)8Z8sfw@S9mM5b7sEw3xlz>|H)r>iSV)x)>j`uf=aT& zlks#!e{k|SOuSf4@PS>dnUZueI)FIgbBq&7lmlkp{#P*jvp>f$`+LrMsFMLQZb|gn zAL9A_1_=QHzyHa@@3p#ENw7ROlCJsv8`?Ljt6SQ`^Ow4%U7r6&{WO^<*Bgw$^SxQ7 zUMEhfh-LZ;^|q8n|44PHIrbh*kJSMnqdzT+bC5*((Fpk;(*>dga|l8C)a9fAohWn@ zEJcpp;C}j3d*e`ojOSZ%G-Unw0!Kq^g+yZ_o@;)*{Ghld{JpzXLXVGINaHyBj%m(B zzUecOnEMb3XW0dH0_2>NUzMw^hX{+vq7G4lv4YWHoJ+9(5aM!r2X1~dmLBpV(cFWU z^8NcsaKx;iG)I^ah1W9N5QXw4;%{~&o*k}`IF>kVTj>;Ywe2NROiMHb;anmGM4|;i z+7^IF2`H_cL0omkca4Z|gIvX0|>gC5_CR7jj(nBK^Rpj-*Ok(+QOVV&`PpAb*y zlEjD}nlq3Js+z+Z6vw%Csv3)q^z+yK!O$6KDB*Ai>mzsg;+z^bxk8Hw{7o8x{}d;9 z3M&xOU`9@jxj~a=7ZTn;Z0J$X0W)v}ZbS&#zIPr6TTI;^!xm2*X4qne7E$rB6H~)c z&S1Dyx?bPyI|1lKUn;DSH+}^wvec;n70D>9T(!NLwDhgqJ{AO zLcYP`VQiXPVVuX{uEVFlewK_A`@UKBA=z|xGNENaZM?Jvc8aDagUkZ!ho5%^gYorg z`EU(Zq9GqZyjc4O0)fJ;1WRP}HE4NpBnrDv0M1BEd(#+2Qn21Xjgfjd-%)MO)azry zS6Y6E=nx@do z3gP19M<1t{D?bjCVy^r+ObR5HA5V`X%3b-PzBjDE>2MSIF^Prktjh1m2T}Rq*g<3{ z+qYmYx;c7VOgHaOZ=su&@=fog)uA76MVs1Bk8rZ?c+^Ex23P`SQp#~)-{i`D1 z`9v*Z;0f}5HW2>O0RHxVTKftw)`9qSLz-(hJxtu0HsZ(8PQ)#;K0F>?5# zcrE0&5=X~rPBE8`*GVxMDWv0dQb5=h z@Oaf-x!Nn?8=5&GxeB61A>zHZ{z&zq6s5&ur@i$JX)6;<7&m4;$e1;D+UC8aaAEhq zX$oVigoUG)DeTFqc>It9(b|(!k!#5bRwnc#kABRe5NlpPZXo`hl=>e1xXkdx8ljI_ z-wt-pVW_}DJfm@&%1qfy$kL}I0VhQ8bqE;RfJ`^yb{Hv5Q6fThf)10Z0ihrd zs6>s*bM>eb#o?&Z8S?R{Hr1I-Jqoqz5%3^rsrGV&C;0wAG z>u*|@RwF)=-+?lPs3%VCv=cXxFF%dfnA+a9(=OO8j5*^;GG~9>YC>%%oI}hZ!Y8Ln+^Lxz~#@n^Gk8wZDFaYs1m*X~(NTLYzZpYGeQ3UBU z^!Y@+jN=wbRUnTJh@D@d0^%n{=75l33|eKt8xFlu(@+>(UkwaqbbA$rRfr!fwRC*Er7mUTcGiVolD4wT*kEnyav~FwWwB&|;t*i0qJ@LxzTS+Pxoxad z7%n?38$W7>L`vQa>dz3sS!ENj#g1qKIEPh4bNKI(_gO1O0Yuwb$X~3#gxIBAe6bko zzIImOAg%~3Rc~X+JMk_0w$256MhXZ=~MgVf#}moVq3HU1NvOd3J!g!?LG7!_N2vH+YI6a9p%~ z_7)F4h5($844dHLKZi$P{Yh^}1ie-lfH^k{u>Q8gN=swDp#OI50e)%-Vh?6M8E4)^NhDLZTCpkrUy^eqJ z!s~B*i`@P|p>O#gZWZ~ZCSe%UFb448(v|9vuNx^j;A@dzo>gjwIL5U7leaLjjiYFgSe9D zxCMQgT?YAE9~h&@w_3DGbDh~mG(BkI7iJiQaqzzLx#2pKjv0|SQQ^uysY`Fv@-mye zkgd6>UTO&!k*_>1jC|D{TZ+#Wh@q4G6jys&f;r792?r>u_xxmN#{?%YfO-$@x zA$Y(ljihSney;BReXMKr3%=~_e?WDYS}Wn7*|$Wpj)uyIz2oSk>&-aY z%3Zs99L01wb{whNflY=`cy-eNK|O!|Z{zRJ;h2tzzn^yr7D=xEQlnNBHsajnia`v{ zWBmR24aBN9{{CVIpv(n(9eC07F%;_tuulyJqx-%kSG>6(#6SPA^&+UlxWqHv zf6gd>$0X<`_>O#+|Fc)Js=RqW#lFs1EPs{&Zuzr@9dL!enJU2p$;p}KL>=4haAP?E zSjkHG-v1%*&EumgviIQx(h!i?K^DUjZ6sh6K~R(gh;|UP104;Bej~ULf2vJk-7SJD~0w#Oy*ZyjK*53DzhgUl(GKko!vE=*nYNwo^7xwvalDzeBY-m) z!!h~_$nSw%0{)K40(yi}Z%g!u%!iJ9)?K34#MfP-m5zS|42Q;g2(oiW4`OeJeQ&PU z;sh253Muo(eoD{<2n znMfrq)?tMueC+=uj|W4V-@|*iwfdOn{~^zREO0O2kbV@%-y#$C0>-yxYUo>||L8s9 zaW3aDiIE&zgfJ74gVD~(tN$tuSJ!6r&a2;(n&0X(x#@$Ok|xj7Lk8ywSL^A`R5=%=YK^XSP1>7_2mMVgy*3OM1QMW`Vc?44YQMykQSjICZn z=YEs*%T>KVAIN?gSq0RVg%?=AbXDy}U8*7`Mi#!h^I^?buyW|60|!#CVZO=FLCQ~F ztXZpPv1Tp4r4LWDRv}rdK)v`fSxcLudH&D&utcw8z*fczXO(<6&;JocvMf-AHlzdP z)XEbl)qp1F;2NCeW%GOv#u=aC&8y!_=9-w1pI84im}|e>T#g$s*Vj_! z3Ovnw7d1@g`r2F5BllJ^*FldTJAL31$mMpdWBFWEU6=3Q%?ND&cV7SB$wCSh!9pZ$ zTo#I6M}2;9e2x;;6IwLE_!wAqBK~?dqrmq6Y|}$@2DGPDX+J&du=1uT^gp3GWBky54{E7oXIt(3;7uBDIHlxGCU0bF3=#@j zQH^Sjd`SHAJ$ahxN=sRfdOo6+>o7GQRA z?jJdNiqFdhsPHf~*j~?0EDsLWKNzTi^_xwcHJF|$p{Lyy8x*2l)f~X!o|=?FJWx=G zRGc886HF3m@~|xyEP1n#CGfHwzue03?_mrF@Tnk2s~B{p&##7Ns7ZMQKk>+szL%k| zH7Q@?C(e85r(~*})R2!sM2h1}b`zq+_{rEgQ>1==HlxUvpFe8((bRZFt76EHc7r{U zLEhmKcOj`|$zn%^bNmQXl(fjrHAPBSr4!LDRcZR#@&l2Y!lxohUy>01 zgZjYTq1a_I_Hami$k(>`>^5&id_*!V@u66d!?pI+ik8Hd8X)!}soAtR#V~{5pkfVC zBjO_+)Z#<5&^i$H0r8POLVOnDJL)(zGx;H+zSTj{Z`D!`DW=SW#0Y+bqXeDea3Hwtaz>6w1*YR;$6R zVfh%(u&Q09XYm->mbmg|;0*VgluydpwVciPLDw+y*05#f{zSpjn~~cB!GxRDk%Nre z+)(O_Dy01}HQ4J)qXx!>m>FfXFv{^|o<>Uu^86p<`4QK-nU+YAx{U^_^&#v(t4Z0R z!PprKMre{8rIpLO+bW3v}tYSZfkmI{>LYRJ%aSL`^ zu?QsbItqB@2^m~J%)(P|cKS_4h(QFBxB3PJd!cu?%@QQvjvo_$k-}q3G=b`J0g-WX?AL94_M=`uw+R&(z`z?f$U=`VKMOypz)#e^=V>MJ_dRnDE%QfU zMQ_!O#ErcH+Qg7r^A*wKj>M01BJeYO9q}`%zA^l?Mr;ZFJrOZ07*84xQBl9^6CX94 z{~d1xF(w-!#|mV)5O(|ecq*dD7R|FXR9xumayBB}`dzf^&X- z&>?#S!`6Ig`32NXR&1q)0!eyEiy zQ3bvD>OONl*Gn;vie(x9KKmUW57(W&WwG!a);U(O5<7oy7b(Zk(K4hyE5SMi7H~UQ z<*@36WmqKeTPATKdi?^9*B{^G_w4lxd+pncaG+aRRMszMy{qx)0*>S4PhQCUnMV4T z<>93?wjJkK*#24j_kMByST(4E%q&Is*T_!M5Uqj)(uf??&VQnfy5T zf7dD&!v6v(7lr>vta3K~`%5t!|D{qOKK=t<3;zwP!ZB;DA8BfU%Us(8|2NJGFQxHc zefBTHzqvmRR`*1VJg~prWamO1FPki87*0D>OF9$bVf)iuES5#fye|z{uC2aY3e->d zK%+iMv;O_3*r+dvVf|a*iAH@U5fIJ#L#$#zJy|+ab+e0s^R3M7UF>2O=N}uv)^uD6 zIRDrxlk@fBv(5RqRr91Mdt{_kz74GE@Ie=Ki5oKDvGmOI%>0SGL-%UT>vw{AA|%Yq zP^*q-nv~%94pj>Y)1eH=3x^R)k5A_Qt@!u{ynuxGKNl z18+y;f6;Kkzqe)xW<8^dFfn#j=6s-w;jB*!|MhmUF#IpDi&^-8T#DKFpC$#s`El^? zl%g8{%~yuuKYCN$?C--7AGxV6L@11*M$U02yEHBsJR`hDJW{EVXEs8q6Yt-;jU=kv z5A8dVh7kW?zEV!^$9(2d{#G)*tDbnlS*|ibN^Kv&e=7L{Nnvsim;h^I5+1}^U?Ck< zTmc((Hwc^Zegt9rIBmj$22o>5>dI)se&R6+J3NfAffZ8Bi#^GvU?ofR4K^?h4z6lJ#{1RnB#5#x}N93jtN$5kV!1tP6-O^F$y z3s)uFE*Io{ycGM595bhB>gf{ks2A-auj&z>m{A_`+Q6Wu?ISIpzi|K2Iw3B}Py6p@ z?LS&}0LedM_a9w%7l@wrZp1*A{iRLxq8Orgc`KUepGhD{lp*osa<>BBl3$y?UhTEQNJtHaX+5W|R?PkO zzlG>4!FgCChEU&o2k4u%DuTY(d|}fUVj3mXgWim$?=guUiK1_NtC&sSAEcN~-yfE- zo%r;fV-_{(yFOGj4t>Y6u#rCcjY#^!cEDCzN@W4M`P+%;=14{iV$-^558w0GCb~IV zz8P*0w~N=!-c~WYn{7U&ocd@Byp|I+@DqgX%^tKsMF56MI^foy(GbP1H(SMQIu4a$I*b)`94ZBbT>($H zIx12-B@V+5?ClgPicvUx94c0er6?AWLA?#`HmWRw7a&& z=_jJ~&)pxQ^%sW{*cUF^7iqLFRO$en|0G3( z-2hWK52dNwSky=#$1Tu$L3JVm8)bqVo8SK44~fZ?_wLr1)a5iLzv^mX^1qVbzB{B| z`{$fhA4cQ1#Vx>Z{jv!Bo_B2%_+7I&8o!kYYC%{UCb0=rjq70I7yh4mc^dBjxf%Gq@r_7Tx!oS`V)=LctI_!Fo@3)T zd|xo|nG?OUNo`w_Wx6ju64=5+nEXAJ){!id*8Ec$XvQ&%DgF=$uepPoYkHqA+ zUn8Ut?&F37fz)u!y9x9dzEso0^bOtBVABIebCmgz|5At^bo!*KHUn*PM5*;|R@oAB zr-Aqf)p3dMur<%|7ujNb%~Q*wM!H}22iJ323gt$GFa}-hzQym87%2yC*Tm3ov`Dl& z)x>__#c+vW{GOTr`lw!fT_~tAGyWRpFBaui$aB3-GZX>5OrkKnc)uI(xmv2^cfJHO zas9I)$=9wT+jr-!WzOom@Coi*NeEtr7s#@~A5L^FRw^)>jO*Z+jfhP(*IVyKDLk5E6~F(aKNgFzHB7-F_qYH2Lcry{W_ zHJ2lmKwZNYq(mt|B+DHS@i-wK@u`rfc9cpUQHe#-`udJmRYJ#@L9$_ASz}v8^H=H8{wKd z;nrz)gTsGK3-K`lczq+e!0u};@`Lz3UoJKzwa3am7W+HkhqED*ZOw$$V1gFN42`FY z02CQu;;oZPeK$?OWzx-e`mXW#`)6<#l*~=4skD*P(s4R>)+w>A>&39h zFIwLcseH*-k+AY)qQ!r}>))pq?NrdMRT<@YMAZY2oMZlBq#*p{WvCwTMKQ)s>_a*5 z9CZP5c$=wUuuR!OW(4|P`md&6AWC8W?;!G4{G2%S>}1{Raqg^YUx}uT^nAFq8YyOO zMsaCJxptYuvq!YJi5BeQML4tMby90j(aI!^svJs)LkgT`up3wdipkCS1NQT>28t90 z=0|UgGe=@QzLHlke}FAJkrM^}!Dj)A9KxRR)(e0d$%n5uA2=r5ilBg}ULv;S(@?c} z7;ij4+S|_(X|hQMPu8iij7(YQPBYbc|Kn8WSW}d-?XTQF2^E?O6`H1<=k}ebO&J-~ zr)^E$DI-_F6P7aSXTg8?`6&3GF9!Tyz8DYwW6wmwzu z|4sM@M8m)D7Qo*vF8l+d;NNwghTqH%-F8Yi{MU1TmW^@C!qe0U!~g%KHj4ih98Ka{ zZkoYJpUIP>cnfR7S7-(^9J_vpu3WuHlLD+9#!7cR9Z8B*cEz5Vp7C4^>=H&3>Q7h? z9&twWV1ms-nt$%50TU;G6ojCNh7E$iwjKH>?HFfOSCp-oo;q^K zv*fXD&gvr~OH;An&GkoT)n491eqj&|rR7Iw38WjwC4DE19vkI`LQV7`G`B;CBV`Gz zC@R6edVCO7i;d?UCf_tYVHKG$*b&bh&gvK0uF=8m!*d}n)B_AO>I1{^;mu4xjqj`D z&ui3b{5W?88xy|1e2W0MSNPQp0i2KgI*z^i5NjB0pvCZ(`E)6DcmWKP8+{R4>qR z+}V3&xYZPzM$mpbsP{jd3_}9JYof~#yvA|RW0=3NFBbA1T3?hiEQA%fr=78$&udb# zZ-Hd?9s!w!?7(Cp=~h6Jl~4^s18X-HawK99tll+KHUdZkp#1$+gWSX@dKXPkcwZQ)6X#FDOOpQ_NpSALD~p$k*%dbk zH+38&blJ0-jR1F;g#Pglk!*CQ1e$2C9N1{FycRY>YvF8EtS*tF7D^%!p;HeQfv2{D zr?!HpKpUhXT$|6d^d?Cw){xTVth8goS$9tXXT5UvH=y56wYT55@i{EYAE&0D6rbUu z7J>r5iN8-m>yJA~`8a3rSTWqE^F7T}A*LnpC%;Y7VEO9wAIlODD@m)$`8G*|XS1)L zo)A10_B&;r8@S&lVesOLyAg9#b2%cBuEzQA-t3LOUSwD(6$JU33_F9YigOsKQ zlSMnBCBJN3F#AcpatDFxats0$`bbUsw^xa!7{m{4Is5Z9>2CcdH~Nj?xbTQjcpm)e zYGY<2x<ZfZ^ zjg%J5R*E>N>ofysz`+2Q*Mb2yEF=S1VS!;h@Wtac4}{Jin|?O&?S;(@E&$I6#t;e} z9R&@|Q}TOq#Rt@eg+YgGR>U@|eE+sQWNf|ixaJcZmLZ3P<_q9tR)6l<6wPJ*BrN;V zqLxjtfUKm1dDrpTxPgHY_Axi8LB65HqVlg=%NkbjWMQG#=w0^rGK?(eWO#7el-_P? z#RKYa$%EMvE@=iz9+UH~%_vC-kHbF{UizU=(o28GW5l?4=^@aeD9J*VbXF(|un2rt zOa}ybP+yZ(lErqWLP(RLRg1^m7ERzLaI$R|StG32Z?~cEF81AATc}A;Yf_@(7rDOh z$t8gNfj2C6t0Fo79}w zaq9t(qJvnLR8Hh4LObAS_}POp5%3GWT{?^KdgF4`S}Y{{qN-9{2)&3O*`P>W(vv8cgcdxvr&0>qrb4nh)%gbhlGe5~TZY##cu0j~-vtpqs(0I2Gb#I&s^P z#4cF*IL*tBI1XJ^)jeCJa% z`;vFuwH!l=JoQJLX^mw#hU|m>hqOFC7v381K^pfYWAbB+OvF5E*2BTs9)JHGp33?p zPXmTu8b2_p3q9H2-P?B39Uh~<(=+bES`@wK)8Ht6BMWfjW8$!AzrJ=A{hVN42}xGV z7EmS`{$LD;Ba8lPeiQY#%-Fq_wh$bQMTM)lTK9;?@>L4y_`6WoX<$70L z5@W~`xIe^z8voa7`vcI?oecSn^sjg4Ytz4eDzDiafDZdzjpaS(r3Xz_=i=K`LI7>; z7(4y_t?Ya$?(XEm1nRAC>9=Ryv-_RugJe{7sLF= z3b%a4E@nlA)kra*783%jfz(I=k$V7+l~m@R@(}kfJ%8=O@FEE5;mHeV@dfpf5sr!IJxO$hXiqp;!VQw00!*55@?qvH^p8Ysu}x~4ot z5(rL+r8LonX~K`HO*f(=#qk@WLrkeu9^19iJQR!4XCWu7)4%;!c&7trhBU&>-kSbB z`l5T95zT=FfLMb)Y#0w-Ck%7`pUzuVz)=%&P7beeyfd~%B463Tbo+4|j{@sXI7_k&Oq*zG@3V>bqWU3ANlcvHjdRu@FKsscYqi(eJ!7CjLdSDWw_ zkQPKf{pmIf$`LW`J*I1nj;yiTuJPDcQTAy7d|NMcvrLp`! zRc6MgC(LzFof!qWLolU;Qtk6T9DOus)Jd`jU{`78&^bdhE~A?Ea6NR6P~x48a{O|1 z(#vWSYJ>eG*$ez@FrqhmYNFEBfIej&I{=|DRVaH(O$fh9( zKuXkIl`sX3Nhr@Z82)gG4p<%25H?i*WfH2iPWBpYT36bXGX$We4fK#-3Wi8CF(_GdU+K9zUvqhvV~N zpc^#~>1&>E5QH>&2OUL)8!?O!uyI#0kNO< zNNht}!h;1~A6!ti!M4ujqfcrmKi0prW%;oSOW|t9wXgL$cM`>^HrNJFeJydzlj{kD z(5Ggk%X0EJAUPC*i~91DhGXu9;}i5*zE8K(gmL5PBJ4mawsCLrHY5L-B)fNcCLFIk(v8*I*rIUllnOnlv|+TY#pfs+-%vKT(J2 z*0q&O;{z9W@D?AWxNBAO@8he@(7KE8Utra-6Z&T-Uxe{Ji{m@IdiaxHGr@(U;;v!GJo8)@mD(?5;QknEi^PjN2qpJvQ_-(B9&Y05X1 zYhA&wI7+}d=-4o9T!Pv=hrD7+pD;I*)p6}opLSTH?qhe+0RakfTMH<$?g^yoTB<@6 znI7ZW8SuX44sR8h0H&pUR316WhqcFdq?rWYX<$kJqnzN()eRdd_YBpyY#$z)ewa5B z(n59P4Wcgx&JQaNh*^%jS?H-e3e&5;b`B1!qT&)j0h}%{Dh-M`+>AKydx*&2?$;tx zWO6qnR+8@{cZ-u93W}MF8TAjxqn{}4*^FPM z-qg}lD86TPxI|VP_4`Pmb=-6`nqJI!EG~`<~!g^6md3nuCG#_g zLge}kTK2*{gZ*P4!r6SJN(5;nF-gPY)LBFf{7WnY!^85m<5tZjil7;_JA|B*tO_lN zf)B}@CH#+k-;3|}rT*2vOQ>DxnhOA2n>&v4jRy4_EJ0GLTpoY>3{{PkN|Dn+d{g`C zR9+C;_yzML+U@cVL64n-GJXNB&)E-2&&&iW7zjA>8jdgBa6sU6b$-1AzmEKo7J96s1ALL*Xxop&<>bQ79~d0Lnx69j19&W+J)CrZGt~P0&-B>Me`t& z_{8uMF^@(5ZpeD$VpNUKCm}y##omT>2{cPREAfY+?kMO< zqD~Spu%d{4xy&avU%n5;-dg4pCvp5R=M-$3`j&HxHs;(S=mh^p&n}9j%h$jJpuq|M z{Z3AP-;tiGbMJwIv-FkWNVo_Cc^AOPXVhKVO65RqrugMpuGO3RfhG@7w@~2MS$Xk& zOkJw$q^dbF4?0+`N^(OH5zX0A-FREf;*g$GN)Jg>^`C%qQIZ&C%c7|<`E+qWBxStj zOWw0zytmZ3{(VAMMsBrpIr%=RA-DWUpVIEMEOYh`Fg3k8@~ZB3#D{FC`UO5h+m%O> zeP_Zzf8~6d?j2s`4;W;jz^3!Z%B%tw#su0V=h7zOTWyp4G*25Dd;;C@*FpMr5pL-p z37%(KB}Hn})uK$FtqH4uez7DK02b@SD(P1T_sgX)O@@&#q*;vNy40vNEFRH1G0iWK zn)>RY07gUaEQ%Yg8;Pc!IF+gzA;_j>h4aEs5%WafgMW7=Q(@0FMS!O;+PfZ^keG*%AYs+=K9{5K48AMb=c>sSORJ z@j}!f>j|B3UnlqG90ju((ws(;#)4(bnqpqDhEk8o+hkZYh?Ke-B8MoqMBm>yX(+Cl znN-<;OqN`!tZX>Vhx3uHc2OgjRWF82v9-^0v5$Dg<>_py5aaE zLyVA{`fI0|j(rEJNiTO>7YEr8^gS9d=gfLQn4iHSd{bbhnk5CLIJp0aytHOl^l4c$ zE^|7UeR$FtfZ+BlECD@VLXI{ufJW+A8FEWMJ*vXXvz||k{(g@!_y?SSF@h=>~W8wCwA)GugF}$X5bNwD#V~5FG(U! ziM+*WCN`+%1TBnim5Vf7u)lmmY1dg_=GwW|HNcJcdlFz#i|_hn{k~(e-EaNf$bJ(B zXItqv!L$3_GSqKYQv-Mgi}d^Vi1v~0ECimko`-nKutG~%^RuUYQ~a#?nB--bPr%Q$ zt5xS8X%a?DgT?)pv{=%ir6|;Dlyt59aulzFHejK(h$_nE*P5ZIcmofI^hoDrn zjRYgnvL6@lwM4r@)xZSO_Ty6*iv0-HH|10@6_1<;Q*qO7u_V`A6S5==_3NE{{R&@e zh0$IIfT3;C8g6Q7zTfA$00}f;p5f@+t0Y1BriciA z%z~VP&A;0gAs{Gx3YMi>NyNx}Q^PV7@dPO?K3)wKe8lwEg3R*;PW4j)#csX{WI-m@ zKUfF;eW{fyO1r=%`HNjF$S2x=iJI!rQgQOWBSW+3$ECoMT+~??n~67!-ZJ2s{%;O? z4O=zY|WH!PaK8E}OV??`pJD!Sh0iNC&+S7YI!3B_u_(@2Oq!K4Y zj3O%IFjprx+O*|8fpa4D^rQGCbCpmE%51aAvWH=WEJTUi75D(kMV;hfcTW3_*|}Qn zIQCE++%PYz+rWOvc1*^P<^SDkyNzozX?vzWgr8szq3{q2Ry*wyaT`1F15fjuP?c9N z6_@d1{Aic4uEISOJk>zX@}ShkfNBoJ7=>gY2IxX#bd-Fmp8Fm{n13A-amMd!ExA)B z>8T`ETFC#PCvrFcr3q=%6S=1);i!xsgCghumjAU^wEtCnuMfb3VQXuQk7IU0U9X_? zHA|eY8^!s$#uVZ(`F)4N^Xudnv5Hz=!S~GW;R7LYz5M{}l(myYTxVJ0`t==+ zi|ZIfjF4HiK}2zVOG-B-u9u>Ys(AJPt9E=uCswGxR-!Vg3z{}Wr<&gdc1)*U}VOtQkHZRy1=67Buz*^b9> zi>jxDst%wy)}&|QCtT_nUxqZyhx9(UDCJ-{Ha>~HS>OmL4s&!s*GP3WfFayihxh-0 zvoo>G9JjA=MGpRl9q}bC&`bi;MZUPcfx*=BuUYcd2kROb0`9^31_F(Z^s@lqN&={Q z!sxSQY_&T4skOeLMJ!@{q=Yj^cV~`FnnD=5zXaHqH6BN@*W;*Sv`+#a`1sT>aVkM%-+vlBn zyq#LBMSlSih~DXjLI#BsPSdmU@!)Xu! zbhMnv0)x}d_sFO4{S+`j6610iWci(<`w~{BvILZjl*IhigGG+u;~*Wb%RK(;!N?)MC|{VK)Axb8g85?6Jq`fZJ9&djhi649U8@%87~;r0oZhs8V@K^16ECgK0y3f;LfWS(pi z^W;NojuEy#{E41lXdyHg&!9XPf{0P;!QGesd^x!*S6@?X7+kZ&)XBg&S9p@~v0~?qu5FAA7cZNi|d?v0c#4-+6Kpz*4gi zwkPr9i1-4*9Xmf5pP>3*2e!iFBATo);AJtm7<_h)I{GO`H;NWOE)(Srt#NYcqxw76 z7vTAAX&yX>BXUpjWq2w9ae@zSx0K&9KPPHq`8nmjp8C2BZdL4Dq=D?;p-OW_LFY?u zJr)!>fONUTmU%%i`sFaz!?d>+cnd8V8o3?3*@j`EsOHiB({sj?4Y9T>9@S(>JJ)t` zqn`PJ++!U?PnJ!PvJeY1d<3!Bh>tVpS^Al}1GVTeJ=^k_mILqfnAYN#|Iop_o2<^V z4?PvScTq-PBZDHy%^6t231z}>e4Ib zjLtZn9&+kF#<-p~6ss)hL-82rd}w%73(T(=U~xKws92DrC?Vx46KYU|)A1K|P;V%k z8OCNVWiyv~3}E{0R1}B&w+7g$rAgGS5@~TiTZ2!+MSaGhds+@m5jfcqq;oF!Is^R> zE63`cJV84_O}}|B$(n`#Wo;&`OX!LqaimdzUCCb;Ti4^f)4S1Q6bM&&uxqIl>pb*B zVheTFKQ!SAS9O)HOa%AnOvo5NF;wY0G6^_ETr7^S&$Q0(K0cmb}nz9j3a>#1piuI*1DnA_i1_ANe#X&Uc=o+^8+$6$$CRz4<P`8Ldv%ZO!YzwjQv6HQfsy}%xnn<3J|KJd*_)gouga2Kw7%o zZmGA`QU+UE$1nuLQTHlZI)0<>-zmDK+n@LAmO6Zu&;E5-B`qb{Exo~(*uR%>f&NX` zZI!aEC1zXgbz5gtSWx{|+Ddu9J^Qy}tc9z$a4-E^j0@FIw{$jJy4h?AiCb5V!MIJR%=yb0_6;QK(Car$P}X(TWE`0)myjF({2H33;P$J)-dQ63hfrE&WLEi zhg%iYxY;}0f`NdmH_a9t0z*f;g_kRsbkm063EZj|bqi11Enr5FpeC6uXgqAchIpW9 zoAt1rpAgtfnfQJ0#Gp%Xl9G;BYLK*+GaApScirl2-F)|#Z^g(JeWorH>0OPXA|Hv!x$#p)S)cx!KZm zvn8{CpZ?kE-%Yxulcc38yQSuYiTrsCEunwM_euYLd=YJ(Yqr&0_wS=p3#yK~txr$| z@eg)e>ny0=BUG=UCFR9FD4c&|7ukP-3HTmds0Uf(EGhE+|DkVKKOxRPu?nqap<6XX zueCzrCB!RXee~Ubpv`(#kmAYT!LLBHHXLk`s0Qld<6bf|J1M^ue>klDZ%|Gu{FN12 z=?ZQ3p?zv)RVWp1wA){A6@Q<_Kl@q`INwt3&v?#j0>UE9B`4*G)H%fl`l3g{N3S@Z+(H zU(Dj2b@5iGTj1O(#qSAg|4ggGX{->~D;>Vg?r@e=$hF%~wu(0#K=HR(ye6mn2pP*W z_+vP}e#08ecX?IAI(HkGzYs%5eR`in8MW6r-ZL*NbH2ICg8UD7#u;JGBe>A|ajb5B z&2VY{L;fInkJUWJ58eK5%x%zqZm9i>?Dp@s+ds`}zk}WW@jU|mc-{WZy8WJ^_Pf~a zHzWLAL-3oIl{shH?f(JKH2k>G@GsEqC+YSby8X4Uo9Kc4H$w0O!oz-y-~PJMHhyB; zAH?24mwT~A z!gmHPR6bf$iY7NkQ<$TO=SkVQ$lN9c!1He^PEf_KQ@QH7uHhJnN80IPq%60Js-e0J zhd)&77*@uZi{>~AY5H~11!bcY{Bt*k8Y{61s>71vI6*c(A^tzCOy{o1_$69nn=UgD z4I}^CD0UCtJL!bu$sh(bvi)yyArIAf1X&3Fj*ruw?W?{suP_N=w;xVG(&s*)x)ny8Fnd`&KOqn`0;eFa4s#urdHZgo_U|5-3>@q`j8E(uY{lm(5tTHD3 zb-};rf`7Xq)VU0+pgO!n8175mxeZ}uzO(_~rpw%^+j%am%r3i~CA!QW-A+YV8HbI? z8eK*Y_m1nr%DnHlsCmTSVafg!+>7kri3>IIucDiVv!!aYC36?n){)vpj=U7QrLU9O(t~zO zpW|Ly+Kvm=Qn!@AmIj$EX=J5b^rQvT8M>t|($Y}7rFLwI_ET$Iz+2V4mg%0m>wn*)`3>WGO-LFi-GR}m>-0`u<%t?a%ks6jg0?S0J zCC4rcmaT;4Yl%jS<4 zWSrCc=LXY%g0)3B=lOky|BoBoN(S4R47tnc5c9VLL^96;c$@g#eZ#fsb1W!t+K$xi%Vc#$IL zQ=Ik~a<8aj8z44-3RZxNdT^x)9|r*Ri7&)?>x20h+W&XIz*|8t?ytemqJQcHVkUle zwzctdvi1F+jUQkp+2cPa!(*J2Vd3RM5(U9E$vjsz)z`i}yTRv#D>bq5OK17fL>{z? zEUZkGiF%c5l2@y%2?G0k}Xwg5_?q8o3zl#39l>f|Bf#&z8hQ7b} zt^dXMi5t`-|WFU-aM8 zI#U0og!=#MzW?v)zqkIO5u)A8s@Mi7M*l4{@$+BRe=17>rXyw?7vEhGPN1o6*C$d{lF+4bc66aG=cTzvGYLc>Nj6Ww2=QiQWIX;{1P4uK*xX z3C1i2hf!>?^n&w3)CVWoXgU14NtQs0ISyr6@oUuA&g#?gm^wSq5f@b3_P==J!z7Lm z#U>s+HHc2C1QM{2^{-T4N1S7kuECKkC*}yzuR$=g&w~}`$|J4s#cZ*d#yr zJa<(?>EEn(PkH;w$#z$tMiBIo&k%wR4Lt7Ap)PmUv7%jOY zc%KA5Zc#t{2|P?%Y*7lAYEQDw-f2rM_Wl@)QetKy`9>8wkdUB}`vsm0a{sJXt!(!G zC?0>y;dY4Ia)V(k3#XKy3o+s6Y%TbyX}?{8R{D|)Gs%USmK}ASY2PBO1lFY+DnsmB z7?m(Eb>3{OZ$1AH8Ej3dZDV&Uq+8X1B{6C>IGey^Y5Vtg0!{4ZX>?QbkIdd>F4K|fqN=<5+&Ex_gftnB2-HY0>l^mLHI<>@}JXR7{v|$ zHhjm8rs3O#_f5e!=)~|jXa7J+jo{G`4v9f$^@l7`GaXngOLJDsc?{8*94U}Gs~(r4 zHWEwW=c>70u&Mg!&P>;S)0!bJARM@sB9~`+vM+V{ZcwcjN{_F$3ZeQK@UJd}7@JG` z`Ua}KPwo-bp7jV2k`bpF8uR%WN2$>1L5s^nDqgTf-#P2s<9}!Y0)W4BJc=gyv@tYPfB%%d{ zN;kwWgjXy782?p7{bd{D7qa`eCjNWE_d*j2RF6M9V)@hNJ~j2D?~oYFGOmUC_Y~4? zk}3AtltO3qT-G-(%kmgwvQ~1LK|T9`%|G{;EHkD+tQSwsrMS4fP*tD^&o@JAH_cx~ z;ICqf5sNMUy0pmGS6%gc;aTkP*F{TEw9I0~GEer95|atfLBU3uaNY~yOepr}iSla@ ze~qA4=!5syG(|ts_rv(4G3kpT35Ax`#V^F~H(g)z=ln(rq5jcESTBOVwy$mU`<*t$ ze-%-`eIxQ=@#nJo_>B<0XPe+pyzkVA=vw&S*%W-JpWPJwEcp7r-za>Yny#<$-@cJT z`2N&JP!oZ_(T&sZv7bY~`Hj%e?qB2lHT9XM@&8yOq_gmUO(UwwdcX36_^37eZ}R`U z@e2Wek2PK2Ua7%^lRS;{Ve=1d#};{9et_^{KvO%Qa#!2 zeAxGb`AW@|$+SITMWp(&oy*J8+*z>0&aElyD*7#ZdRN~WHD#{s=`LUAnzD@S=@~vm zmeMrS>xajy8dsRKzs5ctt~2A>U(VU@#*QDhji~J#J;k@|n+le%DZ}~ztj0{AFUD%T z8Bk$pxYimv(9cp@jhEu$@-%g+evM7GG8~P8ougml;_^&&rhY9pC#HN%`p0s{n7%8q zbeW)9HqmEw+fxx8?h<8i3fF}G#IvvC%}=)<#b6h*(Czst>c{#=e0R~pAMdGQIB;K1 z$Z^nE*S|X7ntlq-BbbC8acw?!zBTd`&}TySvB@nZ&Mw&2m*RZu%JvhoN49tV&RznD zn4)b_-nHnRo~GyGvQ`bU0F!x_Z?;Sw%Iywn`#{F`7)b5;=_4d3Ail}+Ic5JaX#^&t zpJ4*}87H9Ud1{gn-Q0g8;{VR$OtLlRnV(@cxiOfcI@J@T!|I_Ai1-M2zk~ndLlfZd zR4p!5%@H6nG(`{(idz08t8#{Cuj>ScfN(^(IiI{1w=$o+GJ>EYU*j6H&CU5urx^bH zu!8)F#7}j>u4FE98CX+uS?WrLJ*cNpCf=+@B}YITuv}#}&ciQ$E`OCC{w4f1n$*e* z<1g6wik_@6hXGAlh&B@*kbCB)ga0tBykY#)=c!2Fwp|` z<3G+nWBNw(&(8M<(P1^Rj!Y2EKVt!(>60iRs3Qn!H2+NgJ*)m|{<-7?{Bx@Ft+Lb! z+0#>z$w^eNs-D%j)>Z0>aA<;0g!4o6weauR_S`5SfcUuXzsz^~snBanblbd__W!N<|4h;3jnDt_zA=Mc=Kp{SKMkAmrSAxsN? zPu#vMw*3##5kbs$j8-$3#0F~j2QCLZ8d|g4G$je zh{1;#ax&V;lwMsD@!e1;LC^?M`$?hpViD)mNn#w z@W=V+ACL-LhW&F{`h5hu1J50#jY>#1#6k(V0JC{+T{P1^*a)P-N6EB(MMb?NO#7?} zk9?o;8F9W}OuY2fKmez1*b@{TJ4+N&95xA#pimuqqzUZR%K3jG;0yuo{t&V-Kij!0 z{?tkeS-5fvn(P>+)ohaMi_+yi((31-Rzp`-eJqS%4Ng~+ItN$>{`+r2W#e55{t9CG zlljSS*X+o}rvfZK6{Ze#zEuPaZbs&xJpXzexZ(A0^ZIuV#Tk6_v-C1l;|!@@n;##M za$FhvE6nG6KssAx0xR$#ZXjBI2;Z$CNm1>a`u+rNj138d9L1^5hy};_7Rzy}CQ>1% za0aG@i-vEmKsVb)rGUx^3N)}t8p*n`#2gn-uH*G zPj0nyP|PPoaxbJ&zkN7{HG~${`jeLYc^lSSM z%qM&NSZ521zjJZ+)B&sXCtrs>J@hDqR^s*tta+IBUyH8zM3{O*JOW$%?Le~jaP@Lf zs(kyA^&UWgfBi?oG|=Cq$j{L~zkq*V=@(1C!rK2T|7OR2GMavWp7*Qi2NON}BwsgK zZ{u1eviMMuz*`1yi6?DB_J}k)U@}giut0)ArahP}9{sHMr32!>7x@_gE=rA^pY_A| zLsmM4r_Nsa2(uelQwa6!H`X*&?R?Ne|LasAX~I%#g!u2pUEl4(MiC8@#gnN*tT~cR zvV~M>;WM^S8{8JJSD|O|_&;|2`Ov(ZTD7xg~%zI zHFBaA#uuD=3KM4rZAXk-{pv6tBb?nis!V4zQ)92>D!+IiQ7F%kj5avw1*KH3yx}$k z_=S+$03G0nSD?!vV#jL~B<5#tcFv=3%1gs(XW(pHsuz&Zp;nAe?C+dwQa|vT86Z(i z@;R%q>Y*K4@O;N*O(CMjzhq;mTvJZ`ml6ME5%}L{;lEz+uf2}dTahCKeJ&x^i#$e~ zQ63`?t`r*2hU3{8;}iPr;{MEz>_1BY2_;+>EEM|m6#CeNC<7yvufB9nn^a^9Kx~Z_ z{{w%M(>RZxMZ+G1rX-!rfV@i)9yRj{uQ4LgoBhco5MJ!|oyccM+8T}?_`LQ%jYaB6 zmNQ{sIRb)~*a{B_L%VB}(gp^b=lOT$ZNm% zlJkuriMf?~B($o#H+!A4@(9TYlom7G5C^p3Gh2|BAD=1UXKLg#mqdOB1$k5%fYL1o z-asRIwt{G^GNdEW(O7{RJXghgEcRji*aH^-e21I~UgH(Xvl115)qq!22LVJjNAi;B zFWRpz@=h9g2X>AXy}-z=40^>t;LC)A3>U*) z>ZjWq_cEx$2oM9eLPTvSwS0*KJQ7DbN{c=axxf&ycb zUXW61jLXyP_3u<)FLjmnqMbo*&P2i#7qQhB^|P*Y`4AtO*DY&AH+vk5i|B{vgd;j| ziSC8acUUBTY1RVf?%F?G0&btaruSPjTTG^G$b=I? z&Ak%G0fW!=z{AFpRoeZQ2=)nQoe+OV<#z-=fD;ea6dc!Wz9m7GVTlGKovb#r!V3tX z>0i-7iTW$A&o;jjd^rruLf^*Q|NSRuKka9=KdRC8owI)vhdz=p3`DB+812V;phxS! zy%?iNN6(g{#37dB95+nnAfi^JDrSNM&Ox6UL_Cyh?us+eD37W1Z&X*$`n##_BoC09 zeT8aR*^VETG`SLZSDiU8LH!ZCm7~xv7Mhx09l`x}5U-Zs=QRAqtn@MjVJ62e~=0sn7jhQsexYcB`Nj#Hg9mx(qVzO0lwk+6C21fJXm1H`6t+qH2X}XiX-a_pIm1(rvQzE?D9vWUA#pshG=ugrZhbeSa`NCo`1UzIbFtGg_+qF# zC=LGBtwu42FMY5Z#m+^si+!zRO%(H6$KZjwAd0joZH2!reH{S*3L1T@YX{$e;xna3 z@+x(3w^AT!NBPlaQ{aNGHOqxbROBV||83TX*F1=Q)W}b~6z%fxnnnD@a4Ww^o?0i* z%@a_NtaCl?k*|+wQk#2mmTC4j=YuOSnRL$1W<$_5h3+{saDE7EFfoi$aj+@O*tr?y zsA<_xx#dTCIIDX#!$}0jkY?WO)y@YG%grdgzu${yXMdh7nXg8tCJr;kY|bq|-fD^i zMT0$t88H*JC_?>zw3^&ym{I&B=#yLi zPsikwaf6EgM8#>Sh(u7$oz?dO$_cglW5fKP2eXD5x8Y;|bWCyL>cwIH19&>je>`|P zZl$)ofV^8TTChOBU1%bC(g3e9rnxtJm-D`3$hqOo{>*v*K3u?K)-`oPZpHB)=Q*oi z07-$53rbrDp1>t)WBnFsuAJ3OHGogIn$m*62QLB|p48(j8h1=d!TpPTLpZzP2H=>F zH&~Bb^CFjl4hfUb8fFyO^^ZBGv;bOO47S5lR5b551e*`*w>P)`>!e|=_Ir&{0DhbE zz8(VnR_Fa~HSp~T{IMSA`2ZLI_u?Zip933Jf|m~U?-t*J!psvoO*0I~uR`Xps{tFZY;@i~!2y8rZ7K>i+Nw9A(R$T~e4VhF#Md74A7Co76EIKo zSqgH&lyn$ZtdsuC-!1#NL*uL;c&6FhZAth#$jYK#WNKZA-+ceJ{IfRZf%y%NxSXdH z)ebk>V0fjy0;A-v@p!sPO=!ho&^qFe*@Ck%DgGF#-ZqkXYEjvfy`!`}2e>k|!wg3+ zBSRHgx%ITEgfnpXW#(y=S|)edj9~VG$N$u!946)|dB!z7Tve~Xz%VV>37~VXsD6UFvnU=&cM}^&>vc!Mv8omwB>80$k$dh z&`cWO5ty8Wr9nlF(<-VvuAYQIiF}Te`r}aFytm}@E6C^eT4Hz(;LnGx*E%nID+Z;` zXwf>1k*`UJJmVfr%uEC#rQkw5!@1RyZXhX2hRzv}DW~C>a|fxgMf9gymCVW6+$b!X z(j0|7P9-^WMKgK+&p6XH(VcIMN%Ue2Aq;jj)oYj)L9pVffh!VBv zjy_(K{)-Ll&=z#)LaJuall`}4J<%xP={Ln{7zt&ormGf zW)uLK500?FzhrGvYgb@l1ejq!^03=q0%X?^kR$)IK=wjMus+uZ+A1Dm6=j}x4E-;6Brp3=kDOds?0I)<}h$T1y1Y&OjVxJYhxNJ_Fb^tkWuM8KK zxN4q>r;$M6FN%4tP5O#YmLR{`V@Qx{I6l&kp2H)}zhm|DW%{|nq8|O|Dg9^~A6*M)ORUprif%Y@?p?stc%3e*AOUy}ks=MS{aycHCwK6dh`=1IjP0gDcZZdPikro() zlWZbQx`;d4ce}NHS3`wRv7f9<`;M|m`%Zo#n;fgCCKt)CPAqKNcU{H#mj`zr#X=WA zI!CJxor~GqX3n6^=cc*m!iL9G?od4)Ll!n94*0Qw(U4#RJiO)7Q_hkoeiM(j?lO_dHj#dI9@I#` z2HH{0Jq_zT*~gs^4iL>U1D;q6dVPV*HrQkftMI7H*NLW(uU%gDL1*Pa(CM%^%~Ap;Xa7@>^TsN$tv9n7``e~*fzRFHM%ybc@GarO=6wqKkTmi zJNH^1!W?govmzlEr0q+m=j<&g3mT_kZ*f7h%5R+5h1tKQyjfztX@;b!IDXOUsg6K{htM(d(PnIXcr<#tc9V>e{GpCA&!H^1cK*yiENVI%XU@$cStqi<>*ZeoP{bzh8dgT4VQjy5IVTq-#!+;eNqmYh_T%8?V2TexgpPA2OUov8F^y0|4Q}; z^NY-cL-6VU(08K$)MKS4Vggsh`Uo`q-O0ZZ@x83->bIem@qlT z_!9Qv3icGP{(>vmTt{0?PAxyytMsJuW4%jTAcwfG8_vht;Cok`(>PcK@(7;L5T*j& zwAHoc#|HXJS!gg6hO-cffrcYp0FyB3%ugvpC(HxdlDXlV8*_~d&OWjv0cap!prg7O z&sm#1#&mGuG0)*IJoOD1dyTxrylzMH60t{l6D$~y|5N#VSQYcImspq@hgR^Z{YgV7 zg>zfrO-M<^xMAIB{I1vdEeiKvTK+LieGYuEB;kD&!TID>LG;382p2~!4;P=H($wqJ zt(X~9e?vy1>LLAsI%m~7VJ+rr16z1hGBTZ6_BZ&@)L3Y>FJUhLqW8_cGeLcc9qvT5 zFs706b#Lw@PiD&{9y!C|KoUc3Asw>vfCC(mR*FZR;8s;hbO(Lu{sLEJ&YDnB2th%n z6oqofP@t}1Q6qh;gY!G&ttSmk_b3!pmQdDy6nRH@@dfR1?MI-`i3GZD2xwr7S^Niv zAaMhdFreM)6A8qyfp&(9#sK{+iyGkk`;z81t>D5A?{=2jA@LVD zyjs&LEmRaZ3#S$Gqp_%w-ZLqTR@%vI5hl##EJ#oTOCk_(QlyU2{qG7ML;rzgswUBo z=z3wlt)gG(`cJ{X7{_hi$vh#@4kol=`XHZ{__{kQ~I zCPQh3htay2P!$ogg<3v#`Le1ul=eq+OW9norEU&BHa2(j#%X4ATYrdY4t1{0Dos#t zu?|}7OZh5-$(86s`X#FHfoJ=A0ysB?7YooozQ;BSY@RmNFpE<4&pW0^X|VJd9E~t9 zku<~EEzN=_BiIW%N~Ivw0tZO(1l;O3WCA*akyRK4)b}?+HNaXzglC#D<2XN<*n?Ekh>!n=PKzWS~J-EG_g9Gc~2aR=bmD0W>3} z@?ERb&y@wSI!FIF^rxYh#RWSAU$7tmn9k@Nt7)u|Z3yCM>Eq2of(<+xDt-C|IFt*> zNl*`6!6i_u0p@~1iNZMbI#y<8O-s!173YQt6nt?_Vk3xgX6@biylNuu^W)Q-OVul}4_o0=_oK62i zY=<5rz?ef^ICq#`grm%e|X=@oF}9>NHr!icnS)k4@YoLp}I;4wvH2! zHYS$=Il)tC8Xo5yAk3!01W@Jy^+@x;^EY`?0-x!T#S%G4Yb5z0%uB9-0{FJMRsemp z0ywb3(kELE#8Uv%S!cOf$FxcIj-3ZFrw;mkY#oAZrTQ^}!Q8h!BG6WV?ND#0x}V`_ z{?BCmI1Zk#CFS&(0u7d?zPT-2rE>D07I*`?!!jzuezktxNa>3@pW}&)a`_xQeBgd&Urt%uKZlnKO|4?q+*n4&xdW4fm&lCCWUBBIf?h0{?Ur#hK(_ zlQK>)_)T>StHY+lv3#^&t2fN(!5IbLvHAN`_}&@-i)zU+WnlR8@hv7IvT0ci8?i*& zv=W~UE(9Owr*{66@0<@FMZ*|BlFrMmIKq$I>wvdA2;PE7Aj0Q6)v+@XN?7o(uJahN&ZpN2O#IID)^+IElD;@M1R)rEKl{&ePp*M=u* z{xlP&|FukbO?cVJ>HRnI=vvL{8WCnMjg${pSla8GNz`7%gy^riqCYf+IL$Cp9=D1j z|Hd@31A}_F`$11V&itCdoAoz1t6yhBU>T1nVIr=Oh%-wc-3#DB?Wrt+X7B=ixuo(= z7@^4jo`CL%vXSF}796wn1zJn3HBV&1!n*1wkt#Ai@D$CvS+Z8E7PJ~}(iAEO%C2?0 z5^DpTddaLOhC|{%H8~Y{(0v_bLO+4f7ZCbPc;+2d_Yr(|f?Cx;tu65b9t^v?j@s~} za2Wgr>TZOIz%^2q3c#RWX(^zdTR7Tg+xS4KpBUu@3*inZ%P?&~|JQ_YT@Yv!HJuGx ze=Mhw)!6!@x$elpHMu-%ECzFotXp~hSe+18zpvWrtbURAIP-eB#Z8^Ez#)}K8k|)H zlv{XlSjFNGxIgYs;Flq3XF)H2X0N{Npf5rkKE~h{45E-#OfGZ{WPlE45j?M_9Bp}w zG3Y%I#`O=qcvHCtwnfq)I@IV?!6`H6U_k`ui!B8VvUVGIp3oqNvkhp;02%6>bH#mS z>a;qxPn~wBC>@zveN5d3o-d|?3w;v{M)ZplEMF#izCXLW_4EXz{4(%8JYP}L> zdgsAkgT55$byib}QawUPf@|&hBUi$nmHM1IqW5J&>21`Yp>;N_g=k7Aor=+KB}j$& zF-vYFPMoQaj*GA;38bK|f zol?S95Pcc)j+Chz&qi2AoTa#U4aIvVZceh2gpRIOBe#KKM#@Vg>D8QT`hBZ177}lU zV=oSaS=Cvt^*gbi84`3f0U<$tFx(gMz7kp}(W0nr#pk}D2A1);k*>$<88t{R2CKo~ zcm^R@UVji%t9$Rb)VVyPOK!zK$^qWJExg9fS`Fn^)}ynq2%dx{>WLm{P1F@v>UBhUg{f|J#*Gn* z`^u*5w?qn9Wc(l`CDSywIiSk6D(x!pe;#H)hsd0SsK;Nz5q6rGl3@$y%OEBLRhw6954_oAFVo z(Ly)lPv9)*LO(%AD2eThmn29$L3poCkRFE7752Dh2oT4VNfGE#A6;)ECD05^XT?W; ztosi#aQh$pD=tAH$0q1}PKCD8k*kA@9%f+-zp19j<(w&Jz~hoJr9J+3E8WTK(rv*k z9Up_c9;F`!SK~Kl$|=Uowea32PF}{_(#64cwYYGXK8L?!OP|Ew>q;NvX39;fYNxh; zfsjtZVM0IRD3zvBR^U#6ugzE&to%$JXT{#?TSA>o_<>?F!}jZ9m_hX8iSjpT{^;~G z=>LEng*w&xL$RZJaV3lCOMQzUE&n@-={HfP7WV z!I${2GRH5irQlh)Jb{#5;W1Y7rr$1%&$A$D7qJ>RN<{nt)~(DL$$GUsq(h|b0aieY zPUCG}$U|+v0}gX$Ccw?E-0(!Oe-c1Kl+VhKbMR*U|qI{T|IIje>GyH9|t zd0c}UA#Sig#*VcFuB`}M*xZ|!w7(bX_2J*)C;G)XN}`FoXriHjCK@#$Y67t)3UwC)?!pG6rZoy}V^u_p8biQ{pn(m_8m^}Q(rSyX zSZ%eftyU?bP|ZRD0Tg+NynOIbxXYphM0r*6|9;QhyN~Q{5`O=Oe#qWCcOK`QIp@ro zGiPRWyvqPcLrEUmm_yFV!HF?&dfd-j4Y)fWzI)oxlOvYP-UU_ddj@D&srqor8% z6%z4|sWO33U{%8B;i~qZ(RYMao)O|BwIrA_^0>e3r#w}A+7-jGJ%z-n~dY?rw|XUT5j zE}uXP;B0mgGEP{Ta>f-`FyKsh46{Mi$0jqB=V1PTIgdCjp#`3X=mKtIAsp)9tPqrl zaLNj-OzjHpqP}svkv&*q%;Fjht6m||e7*FbesmX6z%&_dknK>HAyiL6eol^p{FD&T8j>b!uv| z52jIwdDuVLoEODCKj;$JPQ5_Q(ah@2UMM%G{3a`14IDU4soAM|0U2+SIM3MZg?9afgvs}`7fcH1FMW$q0?K9qn}8WoC4`_MfTamrgB;Kb&_&yLrxifl z7U3Hs@01{^O^cf0O(6&(Lj#bcOWG)exwnk%|{5?TFKv zCLoNwYbFW;H9b&V2d8Fd8_pFesaMcdtH2JXnoln8Qpu2Ho2{;q%J|`54d)NWzX@{@n01%ol{?s(z{wY#+er^kT_)PIC99qo=uc|KT zT4UURIg+c#n&0Hr`npP`+i_)U!xY*OW}k@sc9PElfy>2j7Cji7Xm>X#4?%zYbp-n3 zi%(Ng^a5JXQndTtTAMe{|NAG+4t4SDq}4MpiNWnq>>>Fsy6D_Ot? zQ*TS&(CA4E?iH4f(%aWz-g9cQ(9Akukx=^l3r6usVZqFlHh+s zT9eGC^`@~TDdyFIQQw$u6wY7T)cj>1={9q}3`>~5yv|q5U*wljL>%B;+I0FBR)iL? z=y7PL$Dv&xI*rxeCnK_hlePQnAI?eQMI^AF8GX{|hIQo0v!gREx`)dv7$5X;I68o1 zxE*mUSYLT$2j|w}LdwPxtGPZz7r?;>Q2$CtHil8akum;s#=y9^+JZ@dtb8M6P5&jL zG}-$C_RJPyV?@P8rwK_gzk8(2B+9|gz9r7@=s%cxC+4>Kk-inWRj}~~KHK zq3R@E`yp4m5R^uH{7iG+ZMZZVG1%RPQP=cwbo$)M)M0W=w2+5v5L8Ub=djq9sZ_Sm52P2YAo}yg9hD4ye7dz z=xr&+{5u+Lf{X&SdHMRzF);*SivSp31ID!w3V#v#PVq&w+0>MTHX(Em)>i>OmwS90 z-Q3#mN2HCueHeR;7aD*;5#0tujJBv;WZ*!VB_$x%cOO%SF)+e+gWWs)<4;K^L^1Tn z{zCoMNr2O^`j4t9DNaz38#iRNr1T6#3Jg2LJN$Vm2Huvbdde9=+;56UJ)0GPB4)He zl;&X(TLPv)J^@* zu>PB_`l180PuRjCcMNvH7sS7!EB$l>j05PWXUS*KPh$LQ#xI6_8A33Q&%t-b-3QU1 z>Wv&*=kj3()JgJfx%dQv9EG8lz~~F}>ZMLF2Es@)Ivz7jUGYzi8wYb2JUY=3Au&wB z_sDqW?@XI`YK5|iu{{X2qB(In!_?-wy0M%PxDWm#b~siYGtxpuPu#}(MFhcLP3q{_ zzqBGNH0S^i@>gOm;kJ!z4tW#w<%C@V&k z+U55o6cyR}P+^Knt(1bO@L&;Nricn2^^AMTB#~4-m+))W7p+Z6OY%S+Sr@~qoA*m| zeJFtI;(+2hIO;ht2;axH*o z&8y=tSX6#Fgi71wQG5^=;88#!4=O}M#>a`=4r#saN_tR|^!e*)=r!cEBd1GSnwKqg zKDNVLe-Dqp(>XrM_>0byTyu@w)^qkl03SSwotDj{9=dd%REYRGo}+`1aRbPiErcEB zQiBx5__##kH-x*4g3W}497BdAIN(oP1I4ba5ogchC_-*TL3sZ)bV}B7`ngVuV9glA zC8CO~6NjpklXSQ5E6@qtB>aoX2O`dtQ%ZvO@SH^I zK?GE%M3aU{>p;h?IqdN5MXm%hnS;OKk;HI<{^a08X_5}HYWpBu@Ce>@Ii(511T;`N z&-jKCdL6|f$PI=8J3g;k$@0T%z`lSNdTT>1d|1YQ5E;?2WXWOx9HX(Z-xJF`7$K|F z`i-mPW82d%&?Imn{t);b$nW+x+u719coucV189JZw1WO>Vmd%#UQgp`9<)hA%F{SD zl{*~~y}eY3lhkBu*n|(9R?o{LGjjuFmPdO|UckR)CEIET1Zpwm^k^yvgD05N%*2u; zwCrUAA1dN6&7&bP0sh&&lYfDpD+0%0IUC!;Jia~pgbyhcb0rT6qRJR>3lbpA4mJWL z736^0Y*9ASwMOA@Zloh1*R3ecO1e0hYG#kZ?Q|lP5onT$s>0GlV62vRHaFu@5~%cv zfX6_HXkg=!5d)`L?;0A3&NFMNGBIkfs(KW6`&tdRf%K3OCgZ`Vw*_CvXcbxL9@Ed* zw}x^b-b<{w)@TY%5)OW6QSv5CXSZRliVv#s7#Onx0p{-n zBPXj0HcnO-Ms)2Q2f;^9xNI|!Y~oRZygk=h#&>eUpu2!F}{SIF!&mrKEqnDjJ~ny9){^#+GA(gm(Q7SC=pM>@_ApH+j~F#2_8?iVcwPTV1w z8^7iN1(_5oBaRok?Q>}R;N<#}D{66-v(gxp)^?VJ#U}h@me4Z%^GtK<H~HBV%i``LGTTP2?J;khA$q z6~PZ``=oLoa5Q4iPH1vt92-MbqXd!jDb4ya$gHLhh|gQC_*@tP$hDyu8By|^O~Hb~ z;sNZ-SoF&;$M|}cNgvXL$hp1P3oxrMX5rY-is-owp%`?F+p-=b%gMkd0E7z&^RA!J zgpC3jbZ#}HWS|v)lvMN8#`%9pw3(vR&rFmy(F}ExQ3W}Io#nwH4OEr{h(SrDep$(y z$v;N#q=DlR|AX<&!|TD<>cy+#chLeAV&wiPTDavVl!#0-_OAHIRrc!;5~_ z6=5U@zu~-Ggr4L`*^FFaIMWde2(K@JC6EM`K$n%Qo_r-of6NA~w_HYuw+qCZ3Gw4? zR6r7wgyym9+l|=^_>>UI*>Q|7T+9~>jtMXa0=vv3Whv5JsAUzVmI4GU!goSIQ_$#j z;ut0brpiWBoFB}j@$5Zm;Rz+hmt)1vdotNJdpat>$t7TsDYeR{-i#D3df>2ubr>LJ zldK_OY=@+ixwU~m2T0Px95X5gW6XGZWt@(R8Z%f8#*8a4G#Cpf21B^K$1RVh*FS8z z0`qe0SnR-T57MxamhBFKY!#lQKlcM#D5@BpQw`jD(Ux3`Z1E+ z9c@5xI*;<}Z@~dES4{Z|_H%Fd%4S$rh_zE;f3$gBO>y)Nj^0%3n(Vt~faGa>Nyt*B zP09l^t2G#pZ?&m>L_W$&0+SzLmveq~#iitv6CU4AcrHA?uQ@*$w;~SBLLIA2!f@Zx z)`pdV>P%?dzE9jZgv#h~j(SyPng;+G{EqV)F1Z3S-!bKM71?(jp!3wqC(Z!B!!}Yu z2y%o&S;Y$jl^nck$iYW6jA-9$)*A*9KNxv%&g{j}i^T7d zR*Hhc!+;){VIaAE?|XcA=1rtkM7|!Qm1cmsabAUAKaKNDVo7Ef))Qe$APHgQ`U661h21`*8zAR&Q7YW^$uUViU=S&(vbri zCI!#H{#b09)~`pKNGxEYclaxzT=}6~+|Zk=ayeA4S)p9TpKi=UVwh{d_m+x7A#Rc2iVm|0| zqzEq_ttmj=*!J~j$w@Hs8IW3+uivTi)Scg7KYbM2aWs8J0`-O~Nmjm6>;hL}lrv4y54|iZGyYfX<~@oA`E%Vr~VCNU`n=DgcmXc)OLqNl!J~hJRDZ&vKBhv;2sncHw9b zhn>pxhi>n&BIg4TPXsYLpfy)xi^%}#H3nCRe2SzB$&wE`aA>|jXZ2N;`Xg8ga5*c zhJx@5U~heM1b33Y`oJQCwDhk8y1741=sOU&Lk&!V!h-&S5_ExP2to0+!G0y&ARyLM zc)Po_uyUx;0>#8UR-UDNXBn$v*aXZ#G4QNCURTK zHy$m$7mX_?>d3_TS=fn!xChxPRhyUX)+$jER%OCvunom+L6|$DMsXSnk3PXq4t^xU zIdG07uzwK!e1)`p6m;-tqj28xa@(xWNR)wSc1%Z^Z?*f#RyQ_>mgTm&Ex70x^N^8+ z8*pxd_|IS(PRG<@oRg=|;;^?>BT?m8T8uNSJU;^A(AYT2vA=+(5q6(tp61eS!u)Q) zowHt3@Gx3xawa4QBSQ`cd7PGw{3 z$Bh9UE@hlIB>Klw;-685qoOm@a86%6$in>-w_1Xi$`MD);UC?JNhhHt@Ny6jF1G;L zoxWu}=$rb=>0O3h131#`Z}8LoQF^!LF{LQ2gyBKSZ@bU?HH;zG&jevArGo zS^p75Gi5Z*m;8p_4HzN*vCJ6Z;av=^6Q3dR#TenSZx?%e=@0(y=w$4VzU+&bNM)KY z?8XSdg-l@!N`L2yNP|LVdnPK-W$S!6E;MzZhtpU`h=C*BL)EsFgWgdQws+&}NY4X8P| z0X5zc;C&RJp(DV72jl7G(4EoQ`XO5v;Qcrnya^_F#`wJf`ZN)Y>i$#NLKnK<{kP1I z!^#Q&BRRI&kIVZb=!?1n+w3~^<`Df_Qs=PEmQ8<+kCfwkxovhOz5`D=-vYSe{_Rn! zzKN)9qHT7uDqm-mud~g*SW=dV^;WW&KepLtF^vKo+1Fp4$-cHVd`p3k-`}f^EE^)S zfQpJG@G!POe;HYf^(j{NN<_|LGbbL#Iv`(<7}bf2F&=4U*Nt)HdN?`GP>&jOQYEHw9s0+(vSOz zVO0D<)cp!+LTb#c)p8J*%NDYPEDlMG0#=PQYxO!V4ylNejrxfGF$=DAmLS+%VqL5k z^t}`Izdmje=f|PYglqm|*yO!~Y3zS}38N?s7g3kd2^J|C8=Wvs!Z6I}1pN%JsgF7- zVimM8cu*vv!rEB+B(RnvD^zD?D1J!YW$`)E<^F+>LxeSSsK~z?v;~_&<wraPUdOSYY^Ha6jfVqThdIfE4v3 z@b%<=myO(K3urL!I@#C*f7P^p23Oj3QiQ|Bi{pjrWg*`!`SZ?+qVB;$g{(4k*#9 z>rI+QfI9z@|Kt9(J^qEFe=&KmfIL_bCEv1r6TArfp9=((?^g}^uB2E%?n5zHFg0ZA zs99&;dMD!Z#=RGsIfmk}roOHG3Q%Y$9~p<0!5|sUI_iB8g0o%<7?dR3*ZNu6=+>1E zE`UYEVO?rgB_|k!( z8r-F53=8B`qVOk+Bk4ryj7vD%TEE*>vTf=eyhIY=31b^mPJ^d2txUTK^Qa9E{TcJq zVgBax{r>Y250>LfYtvsPjOer~Ok#RZ%>vkbLoZ{oYZAs{Z%e`Q#aL*=`W+&!u=AYJ z0?#n`imtr%`doR$@n8UWtpeEGxS!oMz&5Q$Bs8U8ndUg?KC;D_-z=M&1GsTGcsf3~ z4`H(BDOvr{e9Ujq9^_xZXlC1XJPK?)q_r1bgkS9Bmu$t<=&yY8i<;_@upk@==0TQn z-JYj-2!QRk&L+&Uc|5JmzZVe_S<^Qb zSUi@^zLaNNxEo2B<{;K$>@z-eX_d$1goxeASW$Gi`r=%ll?dX&{MmZi!ektik&ZYA z^xn=Cw`CQk*y#up-s;}C)17+|YoMzFGa&_7$8+LvE4P1F3fvC#YNTPoYolxZE@#>X zuFkLDfqO;Hccrbv5gi-Qu){X%=V0?7E~^@l^peGbJPUJA|2kZ`SejanY&rbu-<|3z z+~V@@%H|tNybasj#(zAE>z(%Yq$K`x}X=B#@*9t5!uHe-QM~}P?reHjS%yTsBDr5oo?Q8#o*ylT`^vtbDbJcQt zqsrVQ{Dpz-b~fF3w#&8}*4XyoXdH8TM;n=U*ih`Z2fH@I6}O6hIPWpMZE$s9MR<+x znA`V}YvVpo?lSK#aPKPD#$E2*4P|Lq1KTAIEC)u_6UEbC$8sc01o>Mff2(DIvR(iu zPxVKu6=?MjzmZnYE7h(~fvYlSWZzY#+ATYrN4CM~h_?++-x_Gqk-kry8+VU{*!Y7f zPX8AvM?Uu*b8g%}GI!U=w2h^{@z0e5#8Tf@$j=G;^uI`(cKMqle+%TV1AL$2-^ZgF zaNzua9BI6$ul8sPutsamrP^4uy_JVF0}^NpwBp;iaaU>XG8A+Acc&cr%y-baF$hpf z)3%N9Rm`)yd4GfVn0@*`3RmI$;#t740o{Xh@`9(?7GaT{HxZphZQPkbLz#*6a z>+|3__|E0uV|S%}MoIJU8>F&iyV4HX7JY+H7{5PO_29xS+%T~_-<9@_stzXuv$_Ho zw3Gj9oSw4?PRZTHQhWb4r8@01vKlMqmLpsL#_@B}&NeK%eHZ+htFco|sy6(RB^C?4 z#Xmw9pu1Ojw4bbZAK3;Y2yfeQwi(tw(F<9Zk8ht5|K~kf zF#XlQaadu>tQa#Q%HJ5_NPDntA!k^XhZ+XIBd zu)g;hmL9bMf4}2toUb6;X-#8?rd+E2Z9k*!;6I~VSe%L)q9iu@yRsjbu^I1vm{F7H zb>|;g923pZZa2m=+gzVyI+i-U+EwydZC(@l(xXl2?JoJGCe!UZ?9uMU^S7K}Lw@$q zmAtV5!3KFrWxi!)zBO*&Q49(aU$l0KUGSp+_!=%d!E`H!=~l@Y(5@MEuw$tVB7ip44f{lnf9*|j+^zV!`o1T!)_!~HKTpQ+=y z!b~i|f?VD}FLBAc<@x*2{qVm$@-H>NgQ<%N`rBk@8oe%k7UJ%d4Xn+qmsFm;rE!B0 zCLJ#A(W8=Czbzu43U}iSM4Q&msR#?eoM!O6cUe1)^h=o??ejES&Jek*9iCcrA|d@B z*)aqQ>F+9%`I$-?DCmV1gw;F2(IP`HRHo5Ve zIgu+?6F5}w#q_PPAsJeU6F7`eHt%g{!i^X^{~lcRS2W}X7^j#GS(-55+H3w2xE!C+ zL?L0u)NAQ7_Ly%u=STO+CovD(^`&C`YC= zEX+cerZ=Pd+`z~vrWDjWj^2w z;{Q`b2Rv{eMEiJ=D1e()l7~rqRgyy`4P??sNCKO5uK@m@6~oVAM@58!yiUz4m42MA z_!lf``ghpTE-IHQ#lNFM{5#O#Uyz7ddcwcEL3$VpCjYjv2c!8Ho{3-)D+K>8T^8zW z$Y;NU(Om2>x!4@v6Y$qB*e3Xkb#>;i->Mbi?LiDGSO7qitI38YKflthn#?yG3XU*8 z3p-zB@|e<(VCL;89l>g>EQ-~h4bV0Qj?l2mcd<;End7I?m?=E*@Ea5(KarcT!Q5?KPbv!BKFyjqjj^n z{&@rY59^-=xPM&PY)>V}+H6N|eL6{>vW2S*=5VKbH0sxwUjhETB0KoB`gnf*KeD%i97zxyD{>(|kyp}e`?wp=*!Zr|TOIDlQKuD4Hq^3JnU zD~8y)-xX7ky7DeeODV7PLpz1ZyMH2asG@yPMO9Q?xc%+%;A=qm8}z8&K7Vh=%B1`5 zyb`D(_ONkClWnc9I;F8DWo2nz5i(-C%vz|FqEgstMWsGRYH8z$RD3ItZ%$iVDQYcv zPwMn`*lT)A^}+MtFL)b=OC`N4W~XMogsuJJId%!!VQmGdEgiL`qqf13wINL6Smxvl zC6?~PcQf$`(C$sTGf6Zx^-E+mgHes$(>S6$v_1pv=deAo3+1RP$`K@=$*okp_$@qr+@X{YuS&C&1|eGr)n;D4Lst~Zm6K$1AAa? z%>%e>x6%bnT!IN^#f)`<&GYl|u-t2~R)JcBm(x3pX1MI3Su+8K%XfrBI;@^by;OkV zH)#PUoTEu7fQsG~7_!ZH2r#Bxs(MIYh?p!u_l|>@+>Mte8EoL6w-H>3U4Zvz$8eb9 z4Ib4VSd{f=Hv#xm(p0mKM({rQ zT(lJSM|+QrH!gV7Zu~DiTq(9$4CZRQImNcx2kE%wXea!!QYuaWpe#p2K{p$k!gu=hlks$k(p&Wg#CtqIPCP z+}|zx!x>##f1DC><9>5|I_|)6+`f;4K<{HAuLnEla4ldh_A7`NUzSD?_`|NuS1Ty! z?ri91+OyXTSM+z#RtCSwK?2MOZpmTiR=P?KJv75LaI;H$2w+GwkSq6N*TD5S+kQXD zms*3X!qbPkY&gT-RS8!we#*_g_i8Kv*?)Zy{j&DYs$VWt{i471bhuyM_*F!|EEl_& z`ezBF#OS6!sK1WK#qjS#R95LPM!x(u{NmSr<_pk+{f#%pYsB9kp4sR-(+$oeN87_w zy}+CZMil*8(Mi8zf7#*(F#RY6FQ0gcs=6C3s5o!Id9MrS*&!9#%k|sQepB#|F)SaI zu$U^T3njYP(e-yFKVnlwt)G(^RV2nlr9&*PN>^hwwm^Podx}dq=KdEL)6h@b!H(pd zYAJ>=wq~x#9NB{CEsxFP7b}M$Y;Y~(7(H^cBRt9M5=( zZ31B0W}OKfJOkk>S?d`H*A9H=a+8re_o&CRJc!uYwM>Nn&o)=$d=V(%-P!CeS!J8G z2K9=2fHWu|4ICt0jzEexh@L0U&K%kL-+RSC=Rp}@n&T?**E~uIgC1Mq8n}+m;eiKT z{-d}TVx7yoqnY0vknd!L5hQRT_m`ItDiLj$&9ffiy&&$1+ViQjQPWXM@f6xhXaf{x zqLlQNmxKOhU_RC&I@0{&{oud&^RyV%;~yV~_YI%(5M?ND^vEfU;&ABsY`VSHVJ z>^6H!o~;i?Y3^ESmU?f6KpS?${jw1EZPR=%Y`b$I(?Z zBu>9FtI15Y*-@{p4<@t6=t*3_+Gn;92^B2cnNW?X2?&+={0Q6QV<=zVmU`k@NBgG^ z#?w;SU@4AV<<2dZXPoj5XLF_eowx$P)kA`?_jVNg*IT&s#w~CW_Qf%m?TJqTu3K}x zE$cxPQ{>$y`b#bRzD}(CdwPwSQ=4Ak7Kd%>2p{${V3Ua3zb}8nC|^bTm2kZlGsjh^ z3KxAJb3ODR-Sp40u!eBO_h?V(Ps+V&#$IXfwDP1W3htc7WQ<2SjU!U!MP3^x1OW*bKjzyv;nh!4pYA1;yoSjNE@RNE*4rT-8xuJDdfwm z_#zyfty_Alp2!Y76ZW@6DObFp9XqKGoy9+BI@=ie7{TPC72nfKEvx+gJ~%4df|T_mwC8$#z4kwTXYMNG#&>(EWsQINIcVLo#%TXF+w^Zk z?PtceKWN1h*N58Aj&1+!Q3bDr+V3CRzU4Qgz7MsZ6WjilXY20?wVxN;{%c1{8$<2q z$F~2kakxd>#D8#X`|oZZ?+dkG5ZnF*eVTq5YQHG9{a-)$EZ{fjUmV;1Q`bHGmr(n| zV%yJ6UFbI3KP{qp_BOe|x50S?9o3NZi;K?t&Y8OndGRTGWZG(QL8)b()3@5+Yy~?o z*SuuMn~r8@?lM4(T!SUo)=~==gSPpXrGY7!Yp&(S+kSSjGj{{v2CqpbeQO;131XPwiKH90Ds}a>W7b=FHOM5Lm+! zfi-i_3tLREM%fd=)plaz-Vj`QiQwAv!Oq+eT*Zmt`ndO1%R_LbCxYvVj7^6_aOEU| z>#NM$Muy-jN(7fRu=}qexKb0rb@asp{|&*_KM`D8lOMP{1Xn>KxSsS3(oDEiXGeA; z`xcx;4jWN&yaTT}&QEZz6+OZaGy+vZ(9_K(|U)tDvU z;bVT>HmjGu_bxsb#cgxNqx18rW8;pFee2c^WrvH zvhE`aWI^0Ezx>_yJ@_~*ZktD^|LJ^uOpV*-T|arXMKI|^S*E>>K!^^sCse**;9+MP z`Ud20Lv8)lSAR2zfT4u_`%K56>zrw*2OYl}S&EG;%T7m<>gAU&ocDKU8h8WUPbHLT zWbxaOr24vK!LR@8Oaq623DzJ>fsti-7LrttFTZu%U6HV)$HMZz-cNrz5|;c}SY{kP z&=CnsN-Qkvf7&oR5|*4;SZ;Xql?NhW85Rr6jy;1gSsMNBf z)DkSU94y7`TEUxZGdgY^`4p7qij!l=n`3jLDb$#7;4{qbw`r^_2bHj&f$U+T2r%s znCSK-eF&n{)Z9Y9`+M%`fzJo=1CM~;!{Ed`34GY@6bYZc(yBnqrhi)^hd7UfVK1;| z>ni~(x8jN$1M@U}5jSy%;E@TAzU#jR5W)E|t%eiS{CO$OQt$pMT8i+u@ed|@b!^hb z+8lf>_cUgGf1A~U^+4ZAcGcLxq!?YU=H((2z|Q#Nq7?Uv?4F594Gwp&&m za@z*2Ib^eExyQbibjbFz)rV}Ae*Fvf9x$%Nw4$o>Ohw;w!oZ!)E7wQhthgN^^uGzX zmlJmvaTkn1fRFjZe?3!g?-I-2!m+H}*C$^?yL|K{;XQUsq4cfCAG`^9JQ-b=xYo&+{_In) ze`KQi)8o{?_?SVWp2KgI`f=N!5(Oa+sIg9e^~)Ig2p8x#n~exd246P%Apw0ZN(8?r zwtoHS(Qe?svUC4hzeI=)nHS0}+`syPFCu|g{=fOCJot7et_i;;fd9{^AGOEQXKqvz zVJXpvnn=W<&yX1S?}~w69}-pbA^J<8fA#H0^bTkbyaeA2gB^NG0RKpVKOX<@jwF%6 z|7b$geIov0e3K(ezN`lP{`V-vAtgc%x;L@~`0qu;vO-OCiff zk!-}o^(Ro-dI{XU`aJxh8n!c-jLG8CqkoB~QHYi-+42}xIauOu$;_I(*!iL$`1N-t zl5<1E!-KRx4(-R&pHP?_0`7noX;TY?_wC`?c?dAVp72kc(~{nWlL0Hg&EZSw^?gg# zSSEVZz+Xg2+>hxd7y>hD$__jnSFsyF5`7#~Q!0!pg zp7j*KA=`e3;VmrFTXyOlSmwMzxu;ODQWea&W(@uN4A?=r$>-5tNgkhTSRtMY<@|$JfEwj}2@$Nb~ry}oKCd18~+_6q5 z!XaICj^31l1$j~_oF=lNI;`fKNU{VX&KI6K2)NtHd&&!EuAk%BkrAo-arP4$QI@OT zcnJCy5u0$-$^NVo>>t}K%i-%I<<5Lo{5_ZCh>l;>vT}LgSv(z_`nmA4N2pm0)}?0= z{F-51@{~}unEdR>LL#UOo5;GTpW^3YJ-v$IX!Kkr&sFPLSk*w_qPZTX-Xh2{4)~C0 z@IAs53wSy)ih`g1TfkpO8dXz1s|5lDmaGGF?M}}Bm^?CaTGA3KBJxpH=-$PdPal*zgf+#6 zbwH2lqrr!41krt5AG^kQ1VNHzA0A!$E@<0jo&{k>6PR>(5vNifbQv zK4ld&(!3%2>u9@CZKClfw*I@M{y5|F{!e1+SM2?3vk~dXDEr0s_`g*DfufXT^dJ6Y z@RrU$a4ymQ;H0~^}1m4QtH|XDw z=e3IxfC6zSoxtAF|HNoCJe3n*h%8iuxojVz#v|r(Ciaaw)m^~^Gk(aHu1xf zx%{zywd1LzCA`sFzlt%cK5OL+2JTzmHPco6kNP%PeH%Uu_fZaDnO-Wrze-Q50Sm(B zPSS%C++{sHUFxzdLmTHXeWObMNTpx2@gAs0^4~b@?m7mKVM+wb2K+QBk|3R)14Fy{ zettLKt=)X@)y?_!w_kP`cKhUph{5N&;ePcJ@ zU+Ct$*3I|3yZJt_>+hl;AHvuWVc(eJXRQ%`hP_%?O}`_Jn|!fm3|X&+5migG&M-T_ z+a5MM@470k**W=*2(xp!erIVYLhW}!Q$suex!}lLDM4y8WqWd6SXMfThP(>=PQaf- z-H}b*fdx2T7r?VKjPob5aB)D%BX$I@A%YkuX1x5tt`3}9(@aI54Y|xwHn>v6r<>p? zMchq%g|rX*rBnRelxrn^ZYqDg$9ge-&IwJV;^&%|O8gv8K+~oHWb124(BC+N%Z;X@ zSPcIQG!XQU9d0ju%05^v@#5!{{w$E_*C_iNDx2|dRj39n{AL@xYwfj+f15n<_W#59 zH>p#_zwt3n{2N>Q#T0h<|1AD(>mA|vx5#QF{taPtcGyq(XgaCM2+GR`m9x#Lw|BGg z1xPPoH4^&vF)$Col8+#|Oa#$Ya{O?|#Ls0%$Ip#pC9F{Ym03w_{2V&*He6mS@pFSD zU|+@0!DtD^&*3>DeoiJxViz_=#LrbFjGy~x3yrF9{9K9v6EA)a=2V>cx!N-$;^!{G zOOu#Ph%eMl>HAki*iuN;6n|AK{(`_q#a~Cn&ylMnelEBM2FJzN>CZuPkaR@Gdnd%; zPyaJ7)>Tl8?W-DpPRXgBKI`WhQ&mx=R>dm3oB!3dleQwv5{ z{6M>DD$ouPL&u;EVaH-yivMd-%n#SC}u1M!Fs^ia$jq)98e0I314o z`@}tG&UR#OOcBcoRK#OmaB&xrb+`+sedmVdn7q_gCXA31{Z9W20Enirk0gE%(+0%vAqclJQ^LvM zJB9sBPa&om2sm~qzfhbyBtWknVD~6MZ~A>)Jwb3D^q0iv{gWj@i(&>M7LYU!k|u}u z4~>)d|F4JOfj*r=@D3qFULgw6E;d8(pv^mn-~|vN#t^(0}d{-7D zTnn%m;Rp<$D-_}{NL4$nws!qL86<#;%q!P-OYwAsfO_(V(Z8HRkF$fJbyBnTAO>8V zOTjQboq0=+s4zXk5j-D??1l9hG8+|O`bU#s0l*h;7Kb*;XYko#7RBMm^d=4yV}U;6 z2{5|MkUx?Ot$2{X(ZF_Q3yBb6G)8EsHFST0UzI;5g3NEk4I(3bk1F~;r06?`5P`n+ z`~`jG7m&V!cj&66auI<%%wvwm>MGJfZQFJrz0*c=cq|KrUiq}F|I6ORkAx$ z)%TF(Hf|C0PQ!JWzYstN%in^=WLp~qZ!kjpm=J9#KVc%M8J!{n2PVI(bLFdKvl zMr>t6o}z?7tC=k%A&0W(Kak+RIaeY0Z|KP{JKhoO+}414692(9coTui(e3ctvHqOE zgiv4o|K$JE|1b0Z+DQJt=al$gMA49rQ{;bfp!Jylm3`TS*$&27j74+?LmN~HXYdq+ z>3OyERpz5h!R+N#WH_w748*D_jwb1aJp^QEGAT}BaN~{~Id5T3MNvNZ7l$sa#;4R8 zT%A*1snxVOnor`~ttIuCRN`O+1iIEAb4;#u`q~DrZ$8Ed%OmS^x8kgmb)#&H#@jPT z;sk}XHKXR>u@sN>M~iD#kJMak$gxW8pMd?BYV$6GeT)*G^n7RT!I5cON6qorGlS3b zA_oLHsIb&I!L7c|gxuqP}{5zAKzJoa6CYR^4<9nvfn+5pBY84Fy&N?{2=#-0*P|5l+eszDvCuqLcm+XCOFcUXf-9RUSwKg%KuAGj5dA#xERdTXYS>o|9_LYwCM{GC%p(OdIP6o4cH^J+Khi_ zaMsOa!1JhVU~XWhPEA%sTxw}q!=HflD>Ze!CW)i_7WHy@k^HBI^s8urn(1@odrnXkL;_VRT?6H;qa!#<&&E@od6{|_2ZBKPtSgcnnD zoT@-dVXTTD|KE5YcHm$OK-SsZ0GeFsV#&vDvTmx9&|14q=YYy$8v zKd;n+9L-KdeUH#y&HCNLvu-Q3w3ashBt^1UhPM0SguLk5rT{#YH-L!tH2}MThZEKL6N_@{pFE zaDPQ!dg)Mw!eAE9G>SubdcquNkEH~M0zPFMg5=PA!dM_3Sw2bpI1 z7=@tRj@{O{PKjMqxG0H=gh4L^uSwI(}4K@lx7<)i3>0tp~h*n?}hGh1D zUedq9qC&JHqcFs@2lSH86$TZe6&r;ivpt}fbgsZI9X`w`3<2%|!9+9!c2Et245bTQ z-XnTR-wNnLv=pN-B)eOBB^K)*P)oX202h))$aD{=C0#3!3&|n`x(C!k*T$FT9&nfR ztbi^gixA~*snwMz_kdm^55ko~vITkP!}u5N_R> zhRt$YD5$x9*3#MdQMHI-6G@3H<(Sgx&fI27Y;J(HbT)}pEu!Is0R$}}Y=pSCIdL*- zu1@0Su4gTs4JB2J=(@yme=5`!mWZbSPKCI_8iJKjI6@QjoVbZq!l{r}SVV9V`bOx6 zQz30)C2=aGO{gtSg|xyUf|bxWLT&V%v|Z_sQz5PhVO&LWD#R5Q5wwJDA~edW5I3P} zIThjxkHl3ir$XGss^wIOn^?7+3UP%=1TCR(glb7NM1Ac4#cD&-Ce|p4hA3576l_98 zl4yidWkszf)*p#RC{-BRG_l%9G(M@KqC!Qk;%bW?P%E*L=mE77>V_UrOL{i0O6Zna zU1@?I&?~V5=mEVF%Y6^%l~CM!K(EA7-UE6i7VaL(uF0}+oEr&`i--mXc2KO_r7^|4R-oBrw_-;t`-IDHmz)shi1AcK= zv^y?zh>u5mDeowv($!jO?*Vks?w=#^>{u7%FV|A}iv{B*`CXXzto+W)Tfkq#S%>5A z_ZGd5O*1&X8z&gv@1SebyUgMCZ7eJKw9Iy$-umbRSt-L_Lx514v+=kre(2B(0k>5Xr-94kqJc&HD40x4FeRa9b;goGz zo@F~Jm2OFC@sB+4UuIm<+Irw<>%S*=q_=)wbHvixTC@55*6)KWks(xJ>-PunKI6bK zB%X8ttw$ewe1TLr!1h&Y>-UpCM}0p&pfgWv>!t%b>ieGceQRmmRI`co0f8S!)+Y!B zkZ9J|EcFeyeZu-aO=tp`r>b91Zpz)?KZ908rIHJi@^iGm&MN&_YOMkO|Bp^-^TG zttA!x`#sTD9gRLtW*?siA_8}Gr-EvMuHCmA~`J5(+*KZ98#o*9ioa(D-}|26!+N4}o~Tu^VhD+<3Jq4mGe+3SWpK}1V0WTxGc>6>KY zH9||zb@sX?KOS-sI1P@A6V+z~I*z#LkU~vBJOZWCcqp|%JI`iDO9XPRxX3|)ABsTE z(+zS}@sJZGAA#YW@i2@)Zel#-B5;}%7bj3?R8AP5=g9$aQ6iNV;A0rAryC?M_^(s9 z389$R67IlfxD+23P0(sz7|kcRd9D*{7H-3V6NQJIz20M`owJI!tBi6Ko+!2KEL`sF^-MFf z#E~zq`WE6aj9rDtoV}iCVXipB#axy!E^W*fD_Oh3xV+CCiE!D$kI}fu;2uWk3+9MM zD2$5EkI|@vG1$+KoiHFNs>0AGLDzPMKEj{~Bay<4(MW`?jd0iSqO(rugiVn!P7Iyy zgcC{&TmaVxb(r_xv zPH?IVnL}0==-~S{?E~gDhlSkla}TD$mfi(^^)PS9Fat4spQdeMW^-uB{Wf=7+CIo2 zB(O>{o3i)B(rJLc0-q!1Z0EGt=&-L6=d#) z1g}bcGY)h%p1UDNGm9+`+1K5WqXoG`CU`g0Xj6HWmEH|8-bda}DgsnD?0Q2%xM#|h z4`n6WFhg4hdD+22(dq)mr7;BvYl|V8bMm%&0*ZqnIjrE&St_`(eCYp6?N~CF4%W{Jj2=3ZgMT+9*OUDQ`$ zv^>lZjTUEZVSH$;cfyCH`7Sw()t$`J8LQBIFO1Pd=8NvAFfNn$F@#I>98vVM#p$y+ zd)!1JRBpi8x|M4=m~ZNp5^iIUlMgA3lbu6p zC!Chk!4yU+lUX_;1@BWBscdG5Mv8Q44I|Z`IXWQ)2V@u@M1*$62Xy&1Vq7d@j%cJp z9)%<@u`*S40m5QIM*R>H`q=`mQGH?Zt!km39-1kL3|!F(ihwf z=FbWUu)ey%{5j;K4b~0PudC`HiQS;SP%?(>v2M^_jNIKIyi`?q(orQ2Sg};Q?(}sm zAr@LUxPQcq^pSUi{1)WH__(qg)IUMC&O%HRPPvxcGh6GSchrgv<^%7wGkdg(;@}B` zF63!C%q-C|9pS(aOZ8FaOC;6*<;Q6CB(8r&Pg>kzO~tGBfMw(~UYTWKRh1cKAF4rx zHd$C#Wiv-KVxV4Y7_I)y5RDeCu`oV7J)#pnBn{ME$dy*aES<3mEmVXtDrUZDjKa7K zk~yL~3Zz*cMr%AXM59HkD~t~h zKInuGNpm=2gsf$j&RB))tuRJ)%omMO7?vyqbovTm?qeE&f4y$R zGywm4xiJmEzh1Xu8o+;teJ6dJecODvsA?yc8UjswaWrAcUvT8mN4w%5ldJZh%z&t1 z{|UB?@IVyoWWa8B*)4*tuWEl#?VMd54b8Pqca9mqUR|`@6^3RbQIRfLb#U*0DM(0P~k7ji> zI_x+QEP7>F<>daP*VUSEGS6$9xu2#N_t(-}%Qa#7MJ;!6qaJN4UKPEAzu1A-IHtB8j$7d2#zw<4TL{l`Pvc9nwawkp;=!jTq+$K}SyHQ?e4!k%# zz;OXy&_C@q?J&5E`)MY+8jF@Sxf?6(WsQzhwLh-p8{6YcQ}|u&OO(R|J%|~0;ldBA zyRo7mTOH;%dwcD59&>v&*6&dnZf7K1Y?WKxTx1T1t5G%W0Vh?;Q7Rs!5X``L*s8;J zo|OV~>U$BN`a1bh+rHh6zvEs}cZu&={M7Ph>H)ZjO5ZelSBKd+PGLkxunz1$YFK4! z_=8kO5@72iLklJvo5dAqL0P5qA7`VBGt&V$3tHBa87u3k1o(J`} zE(HMhM6EuZK+fLxaul=y&k%VxUBEtCwG#6L1jK4M9%Eo=_Te>jG*K zBL}3S&QEQ}`+zSPLMgc@+n)Su!6*vnB&eZ3l!2ynu;9P?IlO=x?ICb3L_XugDAgU%r zz+`>Rj4<{Js)W##D`>I|XoMN`KN6bo?sL>TH?JOWcGj8+lqpYeXlW%+ti$=c^3aZh zI`#IJsLg{SUwXgikrA@0_6-K!$7!LFV+_ZSSJe2?2V#lwgBqUW$2$IE{E*+-+ieY> ziWY6i+aVdAQ>Rii_Hs4ejJn5Q#Mr2x`OeV}b=j0Uvw#~*)48#90m|6yMk2NWkLQad z;su&?o>ANAa#!PRuEJ(LZz9RwpmZx#H>MI7Z|A_ubH4>d~*S|5kr58u}*}~cakT$tj~|A$u~ONJN%zl7|LWsYA_9F zv8C#ly-RLD1voPqr$&U2OoDJ_Ou)DQk1!Y<~{<%@(c&YJh zw=boDg9j;DhFsafEPca&xWgKvyHJw#3*KW>IHUF^uto)sU$s6^csD3K*BCIdC7S0) zY7_<@XoqXtMB!&cmrfoQ(leTMaXpS(`{oj2x75%*H=yU&T~6$9w`1?1Rj)wnkOA(3 zh9=i;w77VKB>2AE)zOCWYYk;fSb1g(Ih@C5R6QxjXQX}m&m{fuJ70pWtYs=`&tW9( zL{by&M70+e_lpvtkR&aW?czLwmsiNev&|@H4BMLs6VEsTg@(q={n?_=Ud^-f7a}IV zuvqdXy&*3Lzl9rur(;+~2k{Np+}Rq=M(H^fdDmmRyo=WtAESPn-}ji}?skeV3^#9G z>KRjpxZb^PV2bX;_|xeZU*|+}pOO zH1GQ0T+&^s0NN4CuzD`c+)p85PQlJtQ?(PPM!O1RLQlDqLnm`S(hz!1)N`6@v% z7kcRO%Zwhf^Y+b^`iD!|N$d2NCljOXwK!m$RtwA$sh^gMKp}@8vk9extXIv1;J-0M zHJfBKE8iOXpjGtqgW$1s7>D$^{|;*)#z%xS&|-OM$dg1KL_iHBi4gsId?YHW&RbnT z12=Sve9pf^DI&5u<&dIx{iBnT^a}`&ma$!wN-EAj986@v@AL8mMB%@Aib}q6d+-8N zDed-#ws=1O? zzso7=YC;nf77w>Lm5TlvQBjjV|N02kB}Ab5(DUw8%0>YYt+uGM?j`F~h7^}hcs1)& zmq+U?$bY}Qh>ApO9UVkMf?-DB{Cz`jO?jKLhZ@6rORDUt-g-&u%rx~DX)AiG35u&P z>NXS?)Af7aVO!`(U(B^#Z_BBBG>Lv$Xce~k%aqKE>wC;5`ENL z*#ZlU>fXWAK;Ok^Emm>C{&aQV-r-CruFf(-H&;^Na~wLvGgGby<3qQJ4w>0P)k59Y zFk5unW$jR8*^8nS8G9yMj+>+YIPqIzYicz%20`YDb0bi{aX$auoz89`WuW)uY>Vvh z=`~u`SYi%kkLu-s2F$S=?Xx#b!J#m?rqre3%mjUPC6Bq_D`vIk?VANWEOEKM_BS{y zZf>M~BInaRhV~0McgM_}e~g|1pf`a{u)`KJG}sN$1EcNw=m(OLyu;tjClj5a@bNkA zn7#;V+QW7||1F{n9D%@NklZIEZ<=c*4tta$95;9oF~z%_OP>UPdtzGVd=F$7~Q1}!Ad{xKL6uP<7% zz6AJpa6A0;3m|8GI~q1j>Fd&*Cvjwm?eX={(o8*x)LwEi0;P0)K&d^=TI#(6lPl=A zap$T2t)yY}I)Q`{vp{}PqHuel4Xs09fBg`US$nBMrVqbs8B<1hfdCIO*D~HbHvuvt zg>^8AfAuVs6gaF7$2%d&f7utw7PpqUj-H%)sn6PP1x^F+C(p2HLkHDwDd0i%yxTz? zmKjYfNW(MZfdd$Nq6~oWNt}noSxAiAF_;aOta)^rZBZul_srvLdj_rueb5rj)HANr zJLqhHmN9iD3_cRFj@p#vL7#v83n!ne^Hw8Z$M`|uAtEkf zz)B%#t9UE$FckXHR1o#yK~Y34bcTugvvU#1v_3lY_S&rb0 zE*Rh|Jg~`VrV(JCvn2B`@Q=mz`0tS9(Z*Pu{vFVoi*B)uw5;=#te*TT^<2q6IMLr+q<855#2;5jGdcVz4KSk*ducV#JL*sNow`@6c~2fb(`we? zA#Lg=t!678lBd3})oj8;%GBlc$8&1mtv`Ns?c4Rohu1Eg&{Ti?+S-5AA0JfvO8xPR zYhOg4{H+#!@@2m26XVqR|JH}4c6DZ=K55p^ye&Qo3g$;|R`4q5fxZ58r{=?katM zUu8}SHeyb#%Ha@aOasea;}9mtJK=!-n=e>@8Jl~NNIFr(Z_8$cQTyb#}tsZ~Tq}4fRC7_kEZ=&hP zo3g0`+sQVNa~`D)*>{nsq)L*l;cGgILDO}7#eYImnP-8f3y|OfP5DuE`H>&9%WVyl zF(^q^-7M2?KFE{=g;|J&nM39`OUhN*?~QKcl!*UHJ)P-uvpW5C+_xyYj#{oxpZVWiplsH*X;k*+q{*CC!tPf3 z6RykItx}b^J(Rn(obJ}%?A7WZeTm;)^h>lgKCfDT|6K3~T-&I4rc^AxL>HW^J{(ou z>>d95^T;kk=)E8f#`@Bm$7(6fWf~R)Fe470>j?-{HU>i6 z-iL-~uwhMArI*W`z#Or%ENmZ2dLnJjs(=-B2vM6*32nl$sXhe>IQhqwU^K+r3?X;|+pw zAJ8|B?Th&K+t9ZL!+!(kq&}rg2|)$B0&>hoM80edy_sa5@CgQ(o>u^ox&)PnE5N+Q zgTpU7^vlMvp4w`hwV8*LHD%@}C-Y*0z?F$&a?2dj7mPwi@<6jIhA}b0A^f3J24TO3 zu^Rqwg_UXKEnqd~A%B|ntozV~Wx0xNe!y>9#=%z&4HvI+C7p;itsOuAl-JnL#iJpdh(W2wx{ z)@?1(lKIi&iVUd6luYUWzzL|eIChPhr08SktS|b0F8B{96_ua|#~P|rI4^ng3g*9O z)n9$CI)B#Iz{AU#X05+EyY_mJ@Sc0Y2rr$d7-0avY8f-ODnWff4o+VJV8 zQ}wLCO)fBrNu+8_q3bYv#Nn&bzbD3s05BMWfGr-nIe=KQ< z4fX1OnIFUmz(eD~Dph2YiR7F!7xOE~v3KudNx@Q7Gh0>jIDa(j=UFq8mdM-^%@%W5 zD$vKpR<+oee!hl}y4(6L&$Ea`kI+kY9+0E;{3>Jz07|A=+-OXG{%8VBj`fa`1U$G3FDjCUl=8t@vep&`CBZ1l_IK?=ZW%{XHctkT6y4@ z!jVa81LIEAe?Lm`Y$k_SxSZt+hB&s9)Kq(M{neH!x#1$u<<%oyf2jn1c-YT0OUD=^ zU^YG|kaEKL;oN!~vmV@ktpu^*DZG%Gay*T9=H+`Jve_Qf-4q)1UNT}RDC97p3+Ugj z=5k&!4Yzt!!50@_h!J1F7d(v^Qddl=!zs=1$i8I!wY_( zSob2-2qF9PEl-2sqE`U~j=}925Xfi%fx~>`0pZcIR#;y{Tnv`7l-BAzidrWSoEQ2k zaPk#6E9(EBfpb+i;B3AV;GAWEbD;ufXVL#Na9&C2iaJn>sSze+zxtSgEAVny<|tna zl>O*RL$}V{zk~3D;kF1K#xJZa&K4+N?fh-Lxz5%2X1zQ%iapl2gp4MuP~Yf(d5o?X zY3=+Ec$FRNjYE@%_XpieR3uSNpQJL?Q4JZmIWA>sXANO;0XaCwLS{Y>`nManwy zm1mp0%wK42asi`^xIlX~)??*+fqwBH$pr?l_vMR*oW9L6o!4EGz_nWx)sO!HpF^Tr zQ{`%$264R!Q;1qRu+`Yg>6)ksSp7&;0web4HKjy(N^jxbpp$jFL~fW-8_@qT2+g@e zBl8R}@=$J6rX!Cc)1e_pJG|`{2+ZvMhH#-GgmV~~HZao%$V8Dk&Q8Qoh#WT~TGf=P zvmsM)B{8u?CK2TX%|1p2_sGw{dyCFe@{*@` zZ^VznJU{>BKNBjr=aX+wGCld7L^u!C3jN0!RU2$={ZE*!9bHuY#ZQg${i4h7TpBK) zl(4+_crRPSHXuX!NU_b9`x#6g@=lwWH0560w2)Kl1OcX@CH>!h6akFE_2tXL1o-{; z2?(I;VJ`#45CN*v5@U8;0Y@r!KV<Ayhs8JDuXQD8Q@L>zRkf+dKd?g(D@9rC84jKPg8nmVUe%i z(@!F1FhR;sQY-i-(m#K#e=t%1j315udCjS5puZp|b^ZHM8hG+>8#I7sT*AC%CU1t$ z+y190m5w?}-Xo)sH`nCl`SciY`s=B-(8Vcj=8b4!>Y4GBk5tMaZ_+|R9IG5N%hC1$ zaV2VTK7{EB7gg&*nX078Zw3WgJ}1>_;{TLKs_=CLC2k6HrC=ywuIi?7WoDTROQpS# zr}rNsresy)ekkI8cpc!;<9uZ!oSaLnXU>_c=E&ymOl9Zl`*M!p8< z<=YynO@DRbND8~N$EK?`6KeIOUZ%zGvE_LCMu6%tpq`;Y{l|?lpoaFvf+{0O z6!3WT5=$AXXlyGKi~A1cXXx1|u4BYX9(Wd-vBg|5SCcUZcq#{veE_#ZHYH3-)Vib2f(^3JYRR#*qsBnkwrc1e{w>EHmtYAWX z$%v|qpcJ)Ob{vQa4hDYivXE{mrtQMzK`+5*D03V15)CKFZu`sY;S+}+!R5#s*u~*r z#?@)-hzf{5b0#E21I!}ot5S_^^tf#*2`y<8$;5B9#_u2DK85*n6B~f}vyz6GE9Ssl zfrMjo8XcSAvjhn+0{$Towe6;k!f&$gT;4mYwlE!l=P(V+Xs=6X8Pzr&vP$8=O`#2( zE(2G!I>~`tokUtigD8^Zz@|j{K$#uO;4L*<6b_X4jwBWfChV_B`Ka*bflkh4$9QmYh0O1ad z1u)%5z(u8D-q&s&+y(lAn;TpyYRz;Hh8<8WP*W4-Ld%+I>@>*i%y0`&%X z;=n!1>V4aTbFqGRp*BL76VEOPmF5v(VUQ&yj;+LM(G;(2I*3aO#lySGl3Uj z)aeIuxas<7>qrrBK!L{4;vH8%bKh~!sX_v}3&lAL^>p^Z`jFarN=uKSe0mJ66FreC zoXY(-*O617xS8w7#>N7Islzu)PRsZW*~_OcOQ%u0x@ga#e2!3HBinPxS;eGk&7mWZ zzi?A_R&|vwrHv$51hy#5qVsY(Y(4Owc=nN`r2NWeXXSL(hhmV(tl`2rk8V%mOZq63 zi2dVo0nn_Mu%qVmgPIPsFrrszyQCO8m@$W_Jfs(Sb)hUsI{mVD{CWRs9)NC!yF!O| zLVpBrsvD3Y^fc}wXpt6?h4WSVCxW1dM<+zk+KE8WS%NH$7#mR<|0_BZOYwbahAh1j zDK%1f%FQ-|1q>djn)vxxD*thmuAB+U&h?Uxt2J=d!eaPHSqz6$yE$kTIGia-&3+8a zapfvFul43TbRdga)lL!|QR#_5v>XM6_mKWO=s`1Ea;CoY@0gM3R(Qv@Y#Y`ygeGSo zeJo9SpcjTuRGyPbj&6A12hH>Z?JOomu8*Kzy}VP}oMhTeDrKAN1O&%tv)ZD_VaI5S zEEbB?RSlij-OKGYQ5x$z;tI z>JsS!x6+t)2)UBVR`2TI4&0mqSDeeh^J66UG4P&F30(l&soE0+xt)zWRJ!9@2#Fr; z;}kZP6oci1-z3Dcv44{PY4UG{>yr)tpA>`e3TZnA0U~@w6yX=`5QNVyN=V^j18pFj z^M{?CG|n*+Lkj3|CVb4mP4@YZ@aT)6eo@<~?~ba8de46}>Lsb5{;Z#3Q2$ptI2ge$ zsE@R$4b+DZ3#SX}m%$T4-G>rFui_4DDtzcUBKmZAmml&@Q(zQz1P zt5`Rb04@lx6tZm^g*#?G(7mcdy>NbDM4M`T6Qf^sp^>j`{i=q@1AA+tG@F1d;IYKwi<_0!klC%$-if=_zeI7LR)ucEoJF{7uig6{deIU^KKGwuNaO>OqH!Pm4 z(Qd!htkq~bLhuLR=E`lJWa3R2faqZvb-Y?_Bz=+0I*o6ZXzGw=wCK601eT*vE$%8< zyxj=vW{iUOnYj|Axv(o!P(Lg81W*6+qYl{Hb?!D?yj7q3QU=ylhbAH&TZ=jDZPdD< zl8?oZ0sUR*KgQANY{FCwT$KC`?&B!3lykr=36x<1Wg zWkLnXJxGe}=z$7?jd2}MJ{o+-#N zSBx%NmC&x1)Psc2K$`l!nN+@auJ9KqkNg#;l6R6D7{B3Xjqy`8#=nhBg5hRn8pmm~cqa;F(f>g~W#E9~nlV0>hMQ55@}xE@$Nz zNW|1dk<=h~>QqQtq?}pW4k7An94SZGq!6dhT8@|cYBDaw{QO(PA8~YSFZgmIRf32C zq~PmG!CgVY6ZVmUJ9`2h>Z?ONY2Y9gf1pa~0~7cl)RC`XAH16SMK5|Wf>sUY{&9?q zd?J&8xu3sm3v)QXUGncd9GAZ=KL0=4%ny?x92*Q_3oY0iBU;eiNq4lOyU& z+5daKL+EQ8y8!f6&#Pswpsz-GZ?^q{zMABDrEJ~HpSf7i?~so39?rKoRpI=Iu5d6v z4H0Q5lOot&`H}M=e&kH9MhaVO1_xuKZ9z3K60@EBlaXH-0WX*8clu==9#Gp=w%e*r zVYZM~@0=|hfGMZ(w)L5%mm3VBJ!d$}lX=yu8uYY!S|qx?LeoEzjP=rVa`mbgm~1SP z`J0l%sUijJ^L@D-^DGBOSY*nRoKrm36`8YVgbD@>L(@n}ofYfQyYV>%-2< zQ}A8*2Apu=*G!CI2=~6sA=(ucg0z^Lix5HZIX$_@ByzsMhb5}!t)5_JCOs*zS!hyb znkTTECIYxs+)2L&7z=bX4f~x7gOew?AhQt#xG`e8Fqd|tM+cfsHZC}k zg?lg`->55*&wlN!nlJQd5GfrCMAi|3K;%YVVUqcu5m}6iiO3RxF-^CLh%Ca3a32ik zZfl-A=(s1;PbboU0VjMDod}D9gv8~1DdGL^OjoSToXHYSBrbWUaVhHymm)v$StmKM zS|T~;>72ypQsxwV@=m=X_+OaWBg(Zp^Dahs9+-zs>CN@>cZe{Fy$uF5yEq zqtWCroJ_uY{FYXNSer4IFfo)MG2y{_hs2>fjn}isT9DZUZ9<#aPCO2{hYBE46GK0* z5Yci4Rn*CQ^s!uLXV&v7dnD&&=Hp&QebK3h46M^CQe5<&v%G4ex>%uMme>3<^o}jTvuu_1~FgC>hLGBznqoeWl`+QVmzR?uLe#GF0AJyo7OQl zXKL+XHDxGLus|15unaB7S(y5ZQAM6XGTC2SacH`;@@jmmIP_TAU6iz}h?tO^7|lxf z>_3nK-$!f8PabPf2ao0Y2?jiJR8lw#-!hz4OWLuXDNT6q+W)C*b@LVeFQIXCI1!1P zmZl*kbh4eHnpD;_%~|;p-eCXK3}2~@_4Vzb<^%Egz}iTf+VaJR*b3Z5w@ zj=+5rIbL8I_$$#v2;0D8@V`;;e@0$H{P%nZ_|GQP*6d8;-8LnvvVBdul=Wi27Mjox6iSfdxG z<>8Z5xKqU59Z#qc2s{=dmFPyXQtf5Oxlc-m-hP{`hNmPtct% z_VMP;%QB>!BTEfm?wFIL{)C;Z?0O~Ns3KU7$1lMk{O&hsL6CM~S#8*>Nb{+rZk;qO ze4IFD86Qg6cgs~9lx6jpx`RVLT$V{VsO|rYzyjZC`v~ll^8jV5uIl5I^@&S6#`ISj zD*|s*+OfZuN4iS=_ATj}y;mmenh$(!Nv=zOh?QKi6~sucH)Lo@y}R~rn&s48#b3dL zaxkEQFN}47ScX6#ShTnIBR*MF#U=gA5d3N+`r_ZN{X1Q&4`1Q`EZJpsI7x>4HIOf` z2uM}&cSG5|2MVd!SjD<}tSSQW>c~HXUe*6lWtNmD72nx^lzd9whfNba} zHUI(9J~ddW=haBQ@GxsAXU{6+=#fITE$2~8!q z33N{hpBNR_drRkGn5|qG|KNp8bV70exFr^ek8{YQh)Qvcyw zbswEY+UBRW^kH}4usiUhJMdPU{M7h;3w{zHOlPXatEBr<*)&XIsQhrmDdZLQ$b594 zo>#`pJM6#z`d4PC2uV>U$HADUVZ0}?@|Jo&_8aF(=f%UQmhSzPL4+?TwS(3?|4svR zgFtu9@!O>PwI@Q^dEod(do;%zPlWo$2*>NBQI6-cx($vjf()u~aXP2f{h#Yj#bOqN0E$-$W5<2}Z}cww!$tQyAQ_|m%V#z1LE2MbmV?`E25(SdVU|B{ zDRb&!S62w9Tt+oBN{*!9#zRl zw#b6^kC~Q91=&}FLa+*k$hqeW5b*wtM9%$EExO-`CNpK{#0~Lg|NkcF5&48wG-Cq@ z4f#edH)V5x%+YRK{-MMUj7qe?!JiKcf1y{uZnc(6`%-Phz7)jHPuQ2XvC#oo;iU2A z8mw-@DB=muS5!6;F%XM;f^#elAf1j1q>^6|Fn3^7~i z2?P~E!o#s{Bd#iU3$PE;YUInn^hQAsyoUDCAC3!;T#zMsQibE39!8!w0SNOfm4X(V z0<}$z99)ZJG=j-+h*{`TK4aRPg7o|o8IZ=zFl0$$7_#_L@1@*xEPO|${q*nk6A)C! z?}UN*h|P572l)|jPhdVnGm=vA>7|k? zF*+aO(p6iP9sC#j=Xx%F=v5H7AWq`y$I8qK6wQYW4;)QP&Fe{-McyjJtj1ab5aSL! z--w#sfw>A7_`mHSV&Gx-*fu;@hkJPtir#ve53>64rP@Sa3YzQRbqC%!fcM_OV@V(& zf8HsQ7k)IW7_2i45E_wH0(Z(fxtep2YIX_MA9GY4ZNIzXRg|#MO@alR`CUh5=%g;06B>lxM0DneT}o~ z&(ejf*xaPD47Yz3fln$s0e1u^sjMqf+UsELXxnc|2M9_RI1t)}Y%%=R$2s>cY*{D zESTb7FT_hvV0w{c+F)l|?qa6nkcl_2+j|0^s!Nc`OSa-7OIz}&zX05}JgSq9(2;$) zr>&mPkVhrJ1ph=HmEwW&s17e^Sm#G=dcQGMo8H?K1R$SZxP-tQvcXgfp>TP{B^5p~ zmy-3u_pmfc3;!VKKFuoC6f~XfGX+tku^@`HauysFY4ec`BCQ4&e_qX2TclOvSwtFd zR4%dFij)WL6!{tIZc0of$Ed%I{&!q&W{`>kv$AkO{9C)m>FIcu-sFwx%@^*}y~zj* zX8@44`sNAX$P>(Kw;0Ytx#zaWr7RUg$Z?VdKEgj}?eM{)F;q3X1Pmow4*IW#&p@tz zZy0J(7wM%c1_BR#Xh@hHkqA2#Sfs}%ECB7pZzbY`e}k(hSd)R=ZmdpYsbYRQVGJ(K z!iB^3d}N?pt-;kB*v5{lW%2NgebmFbJr7?fr!1yp%C6?S(RsVn!S|qUp|1rJpcaMs z^R|3wGYacqXD;WB@`$%Xl#BJUI7MI~7r^0#g~Hu|kHrH?QyrGI+}8DgH&9L3ud%w{ z2@tlxBjn~SX$TLt#h-VV)CQlXep|v=KL1KN(05^IcU#d67o$z*ZgtK*7V)h@2VizF zHes~5p3O6w5SsM2(=m++ZHLASkC9C2gVb{!F}{-Ty@h#6%Y5|Q7c+8PX`u27mVl;} zw#ou`SyV;(oM>u0UDx)~2{EdGCtNyDCv$u15aQ3X*0lQ<4`vxnZaEJ&fd@z`wo0lhMx~ zxr5z5_2lmG?F_w#_vnQz!hDCR_cRT&^T#=0kQD7Ud3B41`|=I+uSU z{ARMJZH|KQ<3}z0My6=t*O45BY#FiHvP?E6r_AI>b!Pjx{qMiyH!y&t0T`?*$=9jk zk{Q_lF7u;Cya|mGwT7A_L5wMM_b z0nZ};@NGEnt0?~vzx5BePy-fNFq{$=EDx5YV9svyXmHjd@R2LHd?_!OUwMMlYk3Pk zznPP&3czpM@^<#qjd*VS-sW=V7cS?G8gnc4q&oV?$FM=6#~O(U_RmP| z@gB?zbV1@qdmg4cDibBh`eG)YKoi|h1x*aws%h~w!e^x({w{_l&R>&|jz8{8`j5}I zHa6ek)d}-0Kt4_X|B9>gvDmz;66Ixh&U&Xcfs?jizqRl}T<6XG*7s#-2wNgwC-<_y zRP)nUcF%+^HjBG0dhd;nalN+@C`Rwq^P+pNj<<<=ulG5+_ior2*L%$B&l~W8-FwV0 zy~i6>3rC2ydrxYQ@4Y?mOF`0mJ}{pegAzjbk`2KQjp!|KrH(SAO>TT6TvCKL~{n@|@O)lDcIv{u^(H1pY(xKW_J_GQ-cXTz$5G*ilauf*qj=SU2V&P|*z zhxx|E=lgAJzMB%|Gg?%lu|L$zNRD84X(hUV$U+x92nvK$a#r0%QiP~$B0BLW7(IX+ z_Ju~G4x}PNN?iaj-P%&P zOv$1-_6G##ReyggjzXEupJ%;mQz%Ol3gwOJIGU;%!doSjF9HB<)PbA3VQv1hZvMQ% zc0nDwg+4>$)w)qezWj@*upEnfqYu8_9M|Vg?bodPe9J!*^f_IN)W}@wr??9ZgPo^^ zlQ8W!dW=L(cgYZwNZ4quF`2Zh3YR-2fGpVgR zvjHrAv4eBVOcBqVDH1Gq;Nc8!pa53I+XbwS?!fT$@G)-dk#v=8Ad~zyWcMfO!XN3X z3uhrNYnBa-q_ui?oO)Z5h!D7R?&t*(YB@&FLZtp{+v(iNl3Rn|3O+8ms~ViMU+sd@ znqhU6SCl{4Y2MyB_ZGg#`6`bg_{ppfbVpW5&AoSC5+7paop1I_>zg{00cLL^vU?H@ zk{%XCfjIEwQe+R~fDYq^VlC$jqKWC$kdaE;)`eAp`y@&L{1N54k%qyu@lxFgfkBiP zpwc!~AX~_0peX4nk*~c>*0&j*3B4i;Q$$8+ZOWCaWd%YbEliitNS6W|1t-b=ulF_2 z6$o&t7Yww+nclt}3}^cT3WrQvN5+9`$;!+Wj8hB>S{)Og^10uT4-pjfT%z-^lS$~hlxBTaACO?w!0CyLhHKm?tl4tBBShcUJOF^2zmrN$fqshjZ zWYq63#lA4&MR(h@YBm%7K_Sb($XFKJG5jbP27g_8M0ZU(YeR2~bVfJlBMrI1CD#Zy zlzi{9eAI^mN z;h#9i27t2x{1d?E<0ckxe$-6d;phD_{*tPkQmDO+4JIJwLe(|6s?iHkwN1r=>5GW? zz%xs6@#oE1Z^ZwsIy}q#oHxdBlFSw%&_iJPMtS)hf#hOm zDWPo_EvZBG{F9b!#7%5V>hP>vviv9A0sArV5Kw+0pD_nJpkA(#4k$zi6k-1RmfZm^ z=>V4+dxP!(o&P!GB{*C1tKa?6bih=pCDH*)*-N?u#;(*IunqO`Prz=(O)S{_sKIUz zu#NuoEr%08&X0tgnFzU(YXtHfK%Vc<>luMOTOiL?ORopykQgDZQJ zU~pJm#P?7h8d(IEDip4=xF=T#V!lVZnP`YBIF0QQV<29uIg8?$u?FA#c`0iR7d}&q z=Wq{~^*V3Bh1?IYVg#TD7t(?$nD8%Ogs;iYIYUxdvL0?$$QF#brsuCBi1wEkp^>XH z^F@a`G04^>wRct>rT_tfl^`Gg1ev9Hzyx4wq$FvDlcI+RA}v2~oz~;6-f#cC&2h=`AanjX zKIi$7oYhCkc>!}iWOACgw#hHpb>4WCoQIA>&I?UWv&q!;xSjLlwsK;5fLrel(oz#Y zx;koE;%Do1`!j%V%(ajGyItbjuea6yn2_f!O1zOJK5j}Jpi7+mgtkIiz02Dy(Q=&3 zoHv=A-F43XVGDf+&A#{LN6ESSSUEqTSA5>@zq0eTYb&qbM%SVR^H7@lfIfnti4!y& zr*yY*vgEZka5At?djKTB@*oZ0L{nzEY1;*MnYXuHW`fdwOapua;^CWeyj|7_ZI#6t z6n3iBB`EPllnDJ}CmjW&*3c`P>@wFZYNO5IpfQBz1(Q?z5vCqjY4`WcqvY(zoOhd? zy){lwn`+m2?NM@m??ldXP0k)V=g6P!-tK;soJ*PW2RhuLohBlc>kPZj9j~_C&MC~f zEIwzqNY0w0n(`S`TcWt&a9*4e775Nb}~8jQA4Ra zZn1NI^S8F!`UG>nw?<>h(#rA$w2YU!AJaw7@sK;+X!Un3H+#~ z^6KyR%lcvE0w%!-$4}G*Bnw8cYCNlnFJZ{y+*w9S%$?P0Ge4i3%ro=zIf+;7KgP7LDvZVuKs}_+Y{Dlj zt|+-IJ-`c{SYV$U1m1XiDGn!mYq7R=NRGfPrt#-JzrqZ()0tH?SKg>}x{3&+atTV# z&JJPLb>W)3F^XcWt4w_a57~}ClIbU z*W^Ru4oXCH)ochDFE+W6)-uTvHSeV=e?OjU0 zJ%|p|-cfmWd!K)$t@gGhcH{S|vHrtnP%DIW$rZfWM1Bap9Q6}oe7W(H5nC>UYGS&} z;txv6qWwM_@_QoEVrp0Br7JRpqYIV-JM<>mQmfc2hRp*?`byDn3`-SkY z&N&h~4e@&$9!yea)7MZM6C9o`Ooray1c8zgQ-m`T@xl-plTx@H6b91ZKwJ54@g z#T0>daTIZRnp$%e32!+3xkt6reruMae-@2Z+tnGbQhdo71=lm~#?TD>!wC1u5}Sk4 z!w4aP|6!J*j z{gSPT9C;V$W}@t4L}+Bs(J zF$uV{H!yfL&O|1C^%~4GIrHUA&fn>?`z*%{2QagGnZ}Hvs?iH1U;X1|^es}L^SHjSGM zNSSoFo;ha-(;*Z!K7joA;b90x#Lb_vUWD0=Xe8r}1czty2J&Ed4sVKa12IB()!@iN zA|eBvRI`wZ$ab~#FOW9CP$`EnNE$|DgkhtCU5cUnfLzC-)JG`+d<;JS8=8MKJ7M#7 zj0I)eHM(sme%G?GkPwaY z0N`O0Y~TZKGuOqSgmLA=tdn56NI0BSC$gXtot~3+(=Ofbhr6!*yap&BVz%QXUxkOd~%7^_Kzv?0~0oINB<0>Q! zk73mp50E#wI}vx)Lc_{~aDbw&gl@-LwvLapNH2cc`2&yL89*wjWl}l9 z_fd46V_r2KDDtste&OT1t>W@DhK=(`r*Om)+A)q!vpm7B8@$2p zb>7^!ePN*ZyEz?_tASr$omK1-;CH!n!yxeaC{Xv%a&`DWqMte|b!oh<{0tftP%}&urA+M1oUPAYJrKjB@o|9_W== zNNKYr5dlzD_8_RG1%7oqaWtWBr}Qryy9bTUL?hAG)1|E!3oXg_(CS=IP z5#fip!dV1R9E#A8C%4@V{q*l>2#CBwP-I4Ne9g-layM`hL*7(#)r+HrFl_a98Qvu! zK=x{icTMagf#u=A@*_aRX7xJPp0Rs=svIdGNX})JD3VjY0+L^8w1q8z%|HqJ^fb-NQpTs9q^9gf=YC7M2Z!4-nZ9g0anf70Vln{No38}r%92km) z>5qS|O?r&iy=I+gMzEL(_eBTWn7&H<@bMEdcTJ~~0e4jSalG~JgP3AczkBx8-OcOs zvy%OJb$=$)V9SPMSWdrW&S3Jc!i~z!L4_L}bFS_ON~0a(DM^@$chk)~jPh3ABY1$f zO=l*DYM+MbN_zELwc`Z%T9tuf;}t{mME{d)jOKa>KEy@(X?qK)DFzmrRc>>|5L_(p z5w(R^80u&niTSvsKRkbJUw(&4FEFuB{;F!M? zb!eMBf{=yLAaC^ZY!j_UN4!yIWT0)*|FmVD33~%8)8NDJdSr@Pml0{7OFhL3N&h4{ zm&)qHZ_jDqQKbM&!^Lbu3#8`@VDmL#%h6r}CXWEDMqb;`#v#K33V?iN_4%TiAUUMn zHbzHfLE2`xoXZ=p7}t}2Rht`Kt5qM@s*0(veI#?ZP1k9#J4ZI0PH_67iS&}Sg6JG0imyXUm;06S@d@2@%^;Bxv||LX1WwU0aB<5gCs# znLVRPo?vIFJ1JPAc^~Y>-B%P@`CyWiM3GtYT~ks`Ft( z60Aa~m-v=a8ld*}j%`g_ zv}d=n1r0)V&{jtEr>;~Y`H0~)EwmMr@Pz84)^E>-ev4)yJ}LFv6mM`$25I;t&e7CK z$Fp_(=3ke#R=v^%JFhl*kS?9}6>o08%(9Q%fy~VC=0r8f`qfd(Uw&L%`Pcl~)dWlYjKhx;akJ>2r2I`dF z4lioi2YUT&3MtaRR}7^Y>|;>7geCxefT$5tZ{7n*5-Z~r+22b0JPXXm`VO~Vc=1{syyy{3s(x&QW0~)#$qab0WeY;Ul zUbu}Clb0G+7+9$FUCUe{!D{6_ocH8vPdaq4Ug6GCG-gCLRMqANuqht6Jmv;Tj{-7x zPC6AVy7_?1`OgN|hV`hu+2tI()wTLFE}J9R;D}_L^w5Cd@10z$k6hte{Y{?B>WX-h zZag1^0_*_>EXQ9Da$fz8a?GQ05V1OD2)>wvyMvq5o*g*U04;_&1*^2ooE1%ti91b{ zg8pa!wUbL|&* zg_J|+X0g2+YXKgLS-ZBXhz;I&x#CMH!Gz3%V}`-2*6JO1tfEkc9Zqd8qts~3bl8A;pNLB3k54FRrRri0r?*De$eysa< zq3&<=zwUP|`wM(#>oa8ZMtL?-f?>aT6L58_A*fMLWJ!ZjsGe!9yt#2k8_51TyjQs{ zvD`STUgH=AL{&4j{}QnuJF9Z#?P6U&rbFFbL7bQJ8_?IaX`DZlz?B0I{Fq+_InTl@ zsRXa0>(6kIUP;OZdI}?W#{STobo`ak&l6-UbaS+nnuCv^?1vE~p#YfT5r;*%cY#t6 zHDHtKviN&Y0sA)q<5^%R)^@LcntCbbZ-Y{}w)<#`T7RZ$Uf&Llk+{Djvuz_{Gq#YD z-#N^Iy^8?4QK9m zuWsx()WZ3F)_8K}K9_YPIPnlT^DA;D4rPmSCfLPs{65W@_f>1o6jTBitTsP%J3A5k ze?yR6q2Hr%Fd`YhwSKqQ>w5J8iY*hNxRx!Qwr&wFlzKkqeAVPMQtz)Wk$PD1e6p>a zq6-O^1ly@-*cP@RARzZ8s)Nq6btr~3S zBNL0baCCbDiz&wt%3!<$I*7mFsbaJ)#>!lWy0HE;L{opIgG6dMUiky&KI@-LScEfC z5$fPzQ^E`a52|rVd@0aZ>6mK7m^y>6qgLoozMO;em$=&$R8dS?q!qfm0)B@{wRAg> zka7<_NxDNg0t&DgQ-87Qcm~O=cb}PUci7r5OTdKiuX$GYb`hblQs25rRy>e-_hW5m zo`KA2b$rgxA~|c@%Bh9=CF(U7DP! zqQKvn>`vb1&kOucxEG&N!f&eCr$aq?0|;qv;J?&Bk)h#tKW5Y1sck_4eZh0qdi(sG z-0z&zpO+r^z;)Jl?%a)Tr)MLh0iAV32D-jmG5&SLnHs*{l$!y^}vG7)p4LC>Q*WLa5FcT+B21C*Mgtvak6?bg2V}RGVVxBVyCPROuS#B zKKkzC7)g=u2|givJA+Sfw;TLReTZlQ&e6f)Lw!N2g5`U5&q>m<6GkYl7(mivr{V>l z&4ImzBL(H#MA=ts&@gRXBVI#ww@<*EzD;b?&&Xzx;4JPH!B8+~?f9fO(JHZj{yWr+ zeTF!>-D$6~1zVJc`ERy>w4ixz(y~Fw$N6>yBvrJIBod!#nfN=4)Cb73S4;rN(C@_f z#GK+qA%*_)A&dvVOVA2#dYOr&Zhu|68v;v4K+%G*0aJz!ZDYnEY!J8*y3mJU%gSRU zlOjgJLpT#Hq*zbh(`!tlRqfh62rs2S$*G+Zp~)_vB7q8$9o=ucO1~OiDC3$vieXY+ zu5LpydTipf-v`;pAS72ofeCE_?YjM|b36z_9X!@Pr4oVG3M9~4En39~3ADDCm zje;6IuV9pj8a%smzb|tP8Tfhlc#m~cvNyMW>VnXfaK3OiuN#B-0v}Fx4h#1C?AqXE zyBTaC6y7cdxX`Ic(t_*MoS#}TTj&|=UKUZA@JGu}iGbl>SHal`RzLX@87pj(w^tF2XP#l%kS(^ zc1#vh5@(Es)orPRcUF()*C!-};Rh03Q+6)7Wdo_zuxwHz5L#)ujs2SRI6{fgbad??b(~9J`gbTf+Wy~rf zl*OP?ND9^WK2i4`6?M$C{Wx-?}IYn{AhNk9a=L#qhw}`t3Va5Jn z-Ja%fR}(SaCU;;~pQdRgo<51_1k_AN9q{s2(nfkIh- z;c3L2er$s-C*zWpw`rB(C4`Z1QA5q<$AXH3He8HFw=bI$}Gjsy74Y7vT7gQWN#yNvJAD*7aQ%~m%>~ZAND*fcg z6AJF@n_P{{X}imx+%`#Y%f(++Q){ z1wihxu1!XxPhx0Se**}0@XVVthj3&BQ;D4d#Qp)g>ukm86VDA4{b95p!rZzBV?7f= z47=!A2hLoA?C77zP*mdX(D=iQzI+UpF|LA8;-!CooIc^pMSf35tUnT3-#LUp_!qnl z$DL}~K7muDWDs>jb?q@e1doyf&GgWv6|7~~Q^SGwOep~9FhRniXSl7jP*5Bdx%q9D z1z?0di(OU`L>c|A<0#7N&_&Cdz!umiK%WePdp4MqwGs%I8X|luD$AtIqBkjVqjZ|M z3EUO3S#`zvt8Sj9yc;+G|8mE5dncdR?{Si-~Ar|`N4?|7}BmmjPcO`zi`ttCb;ky{WeSHJbe%ws;WffS3 z%@v0_jqih-?<)=+JN^XRe4^pY8Gj5O{#bFS?}SHKJAup@Jacg7U{O?Jp&UjiXH{q@ z1wfD?69QHZ=HQtf;Geo9^hldj-B#x%qDn+}6K7OJjocQhg1(SAb5sT^?~k$48to5F zOz5^8kq{b*M+W(+?JI1!GXB*K)yC{2k}?p9G%a$)2;;daThP`;XoGce-(agSYQ?ck*ga zZo{~1c>-0wKIIJt%L^Oe-aG_CAQ$r2K9k&I-I^SRZV##eSO?XWFOm|CK!sE@ zwNcKJtIG>`d=^eTw~fKzpaTDzPYe8qZW;exb=et-AfqrmQ^;*{7oHK3)F+m3_q5cA?&L5IC zmm({GEFv_UZ$P@@2y1sCeET`akuD1~5i?fm?kmk9Bm%$Mc^D%T?7Oo+U_lXd=qMeq zU#vj9L>$NAyNLr6_K$55|N2W=Q4WnSs2BL&Om1YnHL?H(kN_bvS2p-Ag8q;10AN$N zAIya5SSD-MTWz>ewf7${|67t;UcU>Bh+L4?Ac<@qm|nT5tc#j9`X~D5*ZFSb`y#dZ zi6eS-D@S$wjr9JlAM4%+p^=s>$GG34_b)QNpA+f*H-hoK51ZY(LcKs4AwY-#oD;1U z3YD`1m;^cxqmKbF`;EFL0)^&}iMI$SAMR`cN>c+s5i=eLF$zk*#GnBF6!vDC(3d*n z>sAC6YJkv)Asln7>E}XHYvTC}M1Zh2_m9mG60#@Swz1YY*&5rGnuPV^V)7&QKhXUvZ>A;{GGl=P42WPR8zC29kUXqCeuE;#bQEJ&V=TXi^D! z5d*Z^Gg><3iXFOBO0+bz91W+VQ?&Ch*e60CPhrhhPw}bb+H+&ORNIKH4HasZF8j0X zEy^CBxa><4mc0}`fk|U*BNDu#=zzmoKBxi#_&wx$^15*)f!4tUh2CIS_+d>-Nx||S z&5N6U2tmklosj}r+m`a_PqHX116ORNEHH-fw6(nUt5(#f=l^qClOX+vi>cROpRses z1eijgqGbr3Ei{KOm@DY3NZ!wum~%90$wqyQKZSVDBPc86TB)NzL(eFc^eZJ83y-Gc z9Dq}7+Jo%%35v$ofz0ZPyj4TsA?>@4aip2T6F7Yd-uUzGoP)~GLI%ScYc=SOHt`S2itgvT5*S`0}A%SlT z{9p88Aml=~bNSbu3ifTtV9?@1uXFIv)#2lY;MnH|TH{jeI|}t;22F;!4>Jj|P=1C( zd9{2Q-SrzWD+un|W2bF9@>MY)mG7?H^^+*y9|X1PLks0*n*cZ4MBOus-EbhP$NLog zM-y3&W!%eR>GeLFFh-^ygIZ{# zjp83-wUAj+1V7Nri=704E_F&rg7h2tY&lYW(Z163G4Xo4!yccSsKd;LDXH*(srk3# zqBX0IkxEZaSm``D9h37{QC;Q%c<^VRLFCUXNWa z-p>X7Fz3?mRW)2e^su6nXTeSJ(9V?B{5LO_|JF=8W?-EtHQ}-UJ(g2| zk|+^iQD$rmdS4!4_vt?;C+bsft8HGx*)1T2<}=fi3ETC}fS&^fNitiVCUA4%mCX1S z$wz;bWK6N^r>_k&egwAs@A$8*GkNb(@Lu@Q$Ud?EzSV6|^~DdzH2yEc?Z($lYTbC+ zGX`*UlPOpW@g#uM+L&D`ZEhh3-n~x5!08QI3@|ZSdyz>SD+V-wJ*zYPxLIeALXn}4 z84zpYUtsqvxz}4gBIfwDul@?`eoAQ!VjeHF5%coI)`%e?fQUt1lQ|ycFlZW!SfB}# zIK~)QA!#%!Rd4OqLp-Jz%mIqY*OD6(1k8V#1MiAy3N4YPw$SlV+FGlhX8su@2K;-W zDc%ntFn<9g)W}g6fWSnIiUp=;JRXjIw$^Q4b8~ZZGTO z3SR69UJb1TF=RGj1x%%Xr(G7aq2lJyu!DKd;0x{&`<+_hC001~8HiVEAs(w)Ir7`; zwAN}GcD13^imJF!x$Fvmi zrxSiOM{ELSmY$EkIac7`Tz0W52;GCQ^ zr0+XJa<=$3L*rVt6k}CVc&W;D&?|*R`RYJ4{OoJ&j;!HhFFYph$bwJXz(Yz59;ja@ z;aTg~TlD@sDk*ef5NTzZD-?+NeD7bHL6yT1N=@diB2(Z5kx?E{t88)}nBTyZdO;nfFG~w{fNn1TLB|y=tW{FtZXUWv3Sz}mE zT&E%@(wTx*Zt8Fok-SiPSUCWW`Di)%+^5AKGpQ#8uhdLy$7}H?&7Zc8*jVch7G`*Z zt}Jg5CKKoK-Pow+26JuR4S&Br?v?gNHBa*HFrwZ2`E_jVu zpmZZLdV;g+CI2izu$6a(oliStsLm#Lv5Zbai`6JqZfbBtH3`&@l12Y}mSku3_;C}* zf8*N=W}0tO7Bi(wmFZOPn^aN`Qi*y2U)>JS5_&NQCIzg_))MGH`?Ap!NaRt@pfZd8 zW0m~CX#qI|uY_yrOQ)lfm|^Ba$bRIPvY(n)>q2)4ajQb((-q15?MTpa7)#GcH=cAiF<8;~dGQVp%a| zzpqQhG9JnY|E#jRgr?$&3qwULQ6XUrbIF)-W$WxAxl8SaINsYY5&xa%5X7$}2(B81W5i1vB=DXbOlaI%tGVfwF#~U2{9(GtA@O>V}0*vk2 zXren|grGPHZIz|q&}`WD-2S&C)wd&z(RgF%CbSXPr6@Ql^a+;52G+qp<3-%K{Tp)dMW(|Ts8@S~IDVp1jDP_C zY60GbY&@L()*TCv{Ugw!GiEZ4RhaC~{nyk$_$*iR zhL&Hs_;|7>n0W{dI5ei(le@>aJ-iaj`!HX%p0AKh&GJ(EzY;5o zG0RK;YHNcY^~Vy_s`bb7w0$;RTDs8KtjrY@n#K2wp8(sdCci=O7Jw22j6)wx;b^p! z_x=OzoO53Q(=vVtye^(#M!u|a%Mh+k{{x&5>;Vv?bh$de(JU*pmrCqdP5hKInEb8n zUgRyQBKUZI2iE$uOD?Y!@3(iiFU#X5aSG<`YKTd6O+^c+g)nu*)1 zw%mqW40g9!YvL1@|PGTDigk=&^bybsiE`ENN`bWsh0!F~$PYk`;uX=Z z&%kikTkiF@$P&hfrC7pfQ3d%!J^P&Q2@&|{;|k=Kx|{49N&)rbHj<&Sha%Yld?f(< z$PhFsxMG>tSt)@RejyZ2Y z{RcWBJ_biX|G^Hv`|S1GgK557qriygx%fvE5R4ule@H}{ARJLbeC+}(r0GEIEx@=Y z0T`Txiflo9I8>0Ja^woD0>;*Z>OVcPvW(*E*fON9<`q3Jsn8EvGCe1`Rc*c|k9tXD zL{jkeQlX1y%H=YvLdc^@O*Dx$EkzQ~)QPKg;`t`=wM=aFc;4B~Dr~vD!9Yvv3W{ z;H0G#>zhX+@#C;2qM6m6l-O;YUa#A@O}DWT7xh3KC)z1rS2|^rPI-WrK$GZ~>Qd&g zdffj)1SQA3AA=IGq{TbWRfR_B9!vzfRh7tOw}H5Vlsp4DgXCLWYSTtAPR6FL6o zM8@Badi-?>?JpEH!)2MPzZ^bRUC9Ks_zVs2B3Cfa`uQBpB`%zUi|Dy9O@KbAo?skd zG4P&(c~u8B(K#uuitz=WmA;N%Y+??#A2P53aZH`oKhff9cW`8yJNR&l;eUjs^xuI& zTbpTD?{Z*`uUon+*tvPLUccE{*3U)Q%6t(Zu2y@=s)Qr_>dzS=6LyN|8xGrJix#~L_gjDfpR+8^B%FaT(R{j4$ z%7H0M_WDEsqFIVV2{Z+4@ibxs24`CvAD%-F8GJ% zlGIj<`^PkXUBMo&?gbVg6eFPA38^Zp`GHRnkyy%-ERti0V z0MkEy6Sh>DqSdwO_y$Q(wOtZLYJknMAv}py+G4C$5@0RZ#KXFN56+WG>yYV0=z03E zIMW7acICrTc`z^WOv%cq?(!bb&*3?u1qDZCpyeeej}gXTQnhpJ?q=tbv`V1u2`051 zo4$dU>F2j=8Qg?-{yfJmT)~s0Oa(A(wuFp?Zj7BM08~A>7tCTghTU|VLDL7~G7SA! z?YsfP4F)G9gOwwnl!F2n1No*v*1+AHc7c3WL!`j#lB;34f@$Oc-to^yB)N$17}-rv zcWfF%%x@1~5&2raJxf|Z%&P04my>m>@r4m?X37=bX1FqFO+VH%Q)(fg`X1jRp=ODp@df`a!Z{4?iyvMQxs5l*akI&)kQ;LX0qg zsBXGwHzQj@cvyMi+c1UJu@&M4Nh@BnnQHrMpx_owz`PA!tdsj9T+I#>u4W4y8}_wK z2l{UCWpd5QMcXN6+4E#VD+{fhqYvDNt#sS~CsXzYiv0(ql^FnBZnAMhzR`p=TMoV@ z{A>Js5jAH+TY#RB05xaq3hdSIi1XhK=%oA&G7~X#F-kdxFJq*141GYbEf2 zy+0GDvOyDqi5-3)AuM@ebAoy?o$`Upt+KiX07_jvCIZv!3YM9>e{5&cJ8KP-ZNIw? z<1z#bU#Q9vU@Lly!--vI?e1nHiqQ@ASayT^6YtVIR@Zue-jI=Gw{E0=fiKXtJ`7La zgC6GAFslXy9u9nf^POx6uvUmxnaK%O3d^x5&611U7;NVLlLiqizH_ToQ|L5#!W4bG zItIL3%`vr@{D0|sJ&qQKHpdN|W(f6IcV^Dilh;xT&}nD4glQN6tmr?xSd&5r|{6s^AwNh)K@o}$5e?w3ofE&4E z2w-8M)sg|Wbh*yUtdZ+tWB4_}^#IHwzPCIi8$0rdy@o6+3dZ>ZDKeO%9?97Tb_TN* zMP>q)aXZ0B_Om!2;wqBIJ5gdKMMXUnm`jZc%zxOzD0g9%}>|_bz!Vdx%$8 zQrX?|HpXNJP}rYr2}q5o0-fda5zM7yM)0*DZKkx)@t5J00bn>S-$xG=Meu@KC;+4b z;4(*WifKN<9sOv;q6`p%nzoK~2I+7#%Zw}ssYljo3dR(HE6yko>JxUIN6j;2 zik#5E*4}eEeo2L<@0+x8sN1_x&%i<7goAWVI_A_Ujn^Q;nM2Z$1P~1douX|C2q1u^ zem#rFo>mz13@rsmA;q+b9(yb`bVa zqAnqIi8v!ZGH@@acdRj*0(Yh1o^DviIN1>lM!E;d`LY7Vd2^N1T8*2b!S3s&e?*g$ zqPa=qF?<4iz$7B>9#8$rlRG*E9_0<;TSPwcSQ#~Q0X>F|4;KhjW5kBg#)PhsBCTFZ zwOe^V9UOG)xGhs7mZDuFMv|AXeLKjNOQMC^cPHr>6yp{C+*wVBg8b$NJ%QY(iMPX*Eb`Gh@P&%Nc1RT zjtS)&sRpFL!RwI}^^CZptkkm3q*6l?)E6y63w2f~lmli1ANw?!%>)Q)J&cXfCgBi+ zM-hgmSfD|en^7s)?{XTe^qe*+^sLcqdB+KfyH?9h2kl6rSOdI6e1uvGhpRATymy5I%VIF~gN z12$qNq0j#K=EHzWk3(v_3!^zCADRh0#FhKD(|j{m1 zQoVplcK}T|X7e-#5n5!-IC7Qi~vLJ zT?oYD?pudAEad#*oRdt76E+rR6JWrI9&>R&HjkRP;1A zdIBBl*@1>uzD13EAh;MxQm}vreG_5)9>p;g`^Q~Ns#qjtIV#;m>uSUw5z@4qI1DX2 za4qWqadZlI#QxDwSf&iThp;?FETeLkBBg_ZuCco3gT%IAl<{my1Dsnh|Fg^Jum!w& zv6K-neOd}+3=is6&^lvW-7PYb3p94-K;n8NZOGEe))&hZ`f)7gRh+c{ot+6%6oAe3!&_k!17`~&d-1s zRt$a2g!ZOhUKUFu*vXxl9{M4X_7)d^?ixKm5e5mEC|l6qYKd|%4rK_{_>H`xuLf)W z#QrFt8C%9LV8q4&E`KwhbNgev40N#i*h~;ab@HqWgHpr*k5Ejc3Om+V?v^RHJC|IL zrtN#vj#MDaWCx~ZVeD<)tgg9-Z8Km%G_eM56a|V6j8H=A@Y2rzGqy_my873z@*n9r z;RRIM75^y`BLwp|gu1zrh6VbYXpKv4!j5`OKTsw57c+_}J>Wr?Y>i!o{XIP=g#2qV zW_C{r@3M1o=fFPhtZo4mNjaT}s{t?ww3GYMl#ysx=hzlyix1^twrgC;QQE~KNImJ( zj>I+RFKEg!_;*Ni(3YMq3pA$}C8U4U;px(v0j}J`va|7cq6&N%fO&KB9|r^Lrxs^=Fk zQe&95SLhG)Sx20JKIIy*Uf4^HX5AC$CxHM(@PR`gY?*Qo{2{xNxGM1;)-RjAJ&b@k zkUbF^qkEzepQ#%tCNo@YFY@Z*(SGEY9_d!#Ukw&M*mJ^DE&BwPIZa=Ku|9e~C*jxWgSu1l`%B31SRbzNr+@aO*vVS&)7a+^l2(y`PcB^!;1e~MRFcb70 z?g>UHVAuiAWEmnJp>4CQft#ws{j~_I!=nw78Kn$q8aQ44^%$!TA^;?;R~~+fV9Uap~x?bcDU=i6|AfV2dW=4Pfkt>GL}}%pkKg3h;vbwt)iGTYY}g{;xFX z!kgR_8`RanflZ&^V5^$5(f}I*o2B4FP3IJ&a&RgHnyCRO?8B0Q`$A$2h55G*@AwCc zk!`A&r)3!`)8N>HoUxx#kU?V}x+s0=YagiU;w}03P|kx5LQEtyI&_c_ycYH- zMC3EISuiDF+bYuynpT*~9lXR1HyJNu^9Hs`|Eh_{{KPHqeMncu#z0yE1L@QSwx%6A zS7-|c`WBVLZi?}9^_1%%JlflF3|!F3;dn#|K}=KNmfxo3#{q!A_y49Hf!zuEHe#cz zf6XcijfGI#y5c`YcueTO>{u7Zyi#@CBub3XJ5Ujc{TzE4zFJo_aFc41?F+ikT*23M zOt|F|Ar7iz8bXp>Omvi>6dH19q_4x3e+hfZrnrqr5Frs`u|h|^ur1nAYF=-LzdY0Kr>R&>@J3wkhoP#7MP5xW4Jl@SUWg%x0H? z-iBo0lohgH7o^1@1~#d12qpoipa8a`TG|7fGVrT7zkra*2w&X#>tN^)E8w{Wa1bw0 z(}%8wk>Jjx{u+)ff^TD~F#-BCe}>(Oy+wq^m2W)!FRmN8j7KW1p-MZt10Z%+Pn#x*}Mtk!K8f1 zeE96I$bp{Y3Hq~fVg6|+O z{K>Fj_l*cNRrYoG9XHQusGBnTS{(8wIVUxh{@tq zDLeEKx-U9)l{-Cu)&6;V(INK(#}f&DfAzEC1tKwjs;ZhHfnvXJy2i?o_TLBL0h&1*um$z!{O?&szt-zNq3%Wo`4lxgU zivj4jbJ4c<>Ai=xG5RUmcG1UTV+C{Ke5e5}+Xi6bI$UMH(yE86LzlMh)BnfYyTC_P zUH#t)BoHoff^vxpHEL|*J$NNzG(psfPB2=v@z%yZN~wY(BpL-IH~|@l(Wv;8s(l`` zwo)sKm0B*g4HxC2)qu5PsTH*983&bWiwITz-{0EjOeP_*wol)ek7l29W?$A`x4rh- zYww*&Vn^Tka2@hDQS==r`a;#(W4d)O7v|;|$sFSwPOt(KnoA=Hrh{XF5*M8P8i)%mIlEcDEh>&X3 zGD8!n&=SLJ(&Q=B%0RYH+p(dUHPRW0K~s8O=W4x~-<+CoTLZ&v4GhPp6l&kuGxz=7 zlmw*ncdeC()t~@};VUk6yK)ueD@Kv%51m%W(s;{IJHqvDOUmz2BByB{tssRXzV|)u2OCK^h30qCA4dt9t*Vp$*kBb5Qov9u(L?^U!gHCr#4GF}F!=_U zB1UxeL^1943Gu%I>)??hRhY;haf~r+IPp*E^QR4tKEX=RoD+%nqAb!NV_DllA(#>HUrRC?;p#F{#OzmKfmRKq{?d(ULprdnmO^)~y z6JGISVN`&d!apdw&e%4>MCEb23`bM=QhO)h-O>mBd;6wJt#`P%`Tm!E2~YT*rH(&O z@qhLnwU~5U25$oa98egJy_?a~r#A-mSR0FdH&q%F_xitM|7iRk7R15WS!%L!4d5B8 z)eq$2S%0lQT|W6zP{03ELXigTm_9yeAEs*&N|4KWmNJc1y5emN4Q3^Jrus#ex>E&rk8s~||1<4b-QR7a3 z$HZpQ4&!q?|C0Tsz6PD6ggH?TyC@D^Zb#C7PL66XY(ZvO!f>8x} zDB__=52ZYm>Y*ZB#_#q0EH0$%uhXATEt0k>6of??gPA(v{rC|d{^TXtp_xNYhiAcm zV>Pg&r^mDU%}BzZFiUHn^~Zg) zVbMD@Xg~E}hXy;nXnwoh3C9Uc9uW?+zM0>e7D70jHgf(A+4Isr;rOt7hvR@lh&qf{)un|l+iVeu{lTksH8x!9%O)z6 zio_hGeLb&P4l^wE=yqMb(aQ9vui4hg*R45iF21FXLFCwhDtclmNs!}LBZx_=*Zwj0JTDEiAK)aPXK6FJj zr`Nsb@?cktp_^x=yV=uqGpD_q*?V=f;jnOY*;;y#EjHmAKdqge_F<24`JiiY1U34OJCOmS`U6<0V=T(yDX8W$+8 zMmaR*Tb<5vDD%6{*=J>#?wZWErf^Hu!cMPGe>8P3)3mCxP18b5)1Ds_AGpTuZBF4B zv8hc*lzB`3_q{#Ir_)o~4jRVU=<)pKeZ{K7W|A}v!}ALNtaSYI%B>|xcN?VJAnAS& z>Hc(p5Zna7=!ao{<*nf$d25Ze&>J6) z{I+b^1{LT_{r#6{l8ehbC{6Pa`M;(slDWa9f3k;}*B=88! z0Np|VW0&y}Wjv3JWi9di(6K~QuWMlbo}0rX(bPvzB$|45oua9St@sU*tBKrSY`~1g zO7@k1H^{llRe!arukov2bWFPXpYTZaFI`Xdhr8;pan(Q2RrQAihyj0}*1u0bi(UPP zss2-_|7^goX|MlGSO0aYf8BQs{C!>h(GK;y31X+tbRxrMs{Z@YY0%&25zzNj)z`VI zfBS30%)|~=J5I!YEHL)~_lss480I)h9X?}a9JzS+n zs?u4VEB*De>hYitsZ=!{=siM>k}uVo-MQ9Z9hC<4aUQ|ms}rcTv~#W3yIQySwGQ#d z_;9+2+MrXwd9|yth|XW?YK&4N{qr_o(W(E3xJqAX?|&a}M~j_nYNv|eO4C8OIwvNo zQ(oe^Yx9wz_^@@BRuGB z{4l{Rv8mMv@0C87Gprh2$CQ-M%;aT|vKyqFtvDyBex_ON=VUgIWtxRk5=CEX9xk_* zcXXZB^2Reui|PbV^~L+_hk>Pf-rklfEj-Xl3pIObKBorFejP*Kie$eQ%6=_WINOn0 zqUX?5-2(_q?-wpRS8<4V&gE(7HB}alvPN|dPT8u^+}4cuG>TbYxGaFq<^id@I%wY) z{qvLF=>osYWt;VE=+m^^?djh)csRIexoz%m0NUJVha)kGVP_tW7_{Rhe(x3}-o_{9 zUti-ql-x*k4#?!M_D6(ClV@VR*wLBVI)Poj zvEc~(^U;6ggqp`%9l57JZ_Ha^iQn>!)dGl6r(Hcl%{q*cr=AUmH#T<=E-AZitJTzU?{3HEjWbXtoM%u$nuj(eETj^_I@aOJHJ-Pk9w_oCTH1{s|}c^ zMqa}$LW19UtwHTHB+PN4u(-;$+k3OWNx^L)3cRM!7XDj){3kXItTopW;>Q^5>e0F! zcCqjpj=iLXC)MV{`fIsD4+daek1aNoU(b@at~Ip~QipTJ04n5F@s9O63DvQc)v*_M`9_CI`v+Ca;H|w(u-ZjJOSwvxhFN^IKAO0 z=+wS&kSx2Cexr`%S-q%mZ_4>q-;yKQ7`7jPg<~sh2H=gw0$m+`f=8z0ne>S8mShtvK^L6h9`QAG5 zAfP$F?kcK_B#vIQa4gEbi5DX3-w(~yhCkpVa``r%S|W+MPk8Nd(>XTw)@f_YIAzv@ z4(lc0U=!EDL=vbUT}>nZ9*g;o)USBnpLXsAf-BKQ=F8S}m3fOH|8@9xH}^Yq?hoV4 z+?6J(_gT_O;^MhCx?gYV;#cpE>_A+zj@%oO2n}1Pyyq-VinCn^8>ujTQ5E}}g1n_| z^xnu>Aa1v03y9%Go-@4D^Mf~BXKqc|e#3v}F9DRfO+O86P;hYv3c_!tR4UgbrfSb~ z=!EIFMPj=&{wB{eUn+KrS;!WZrM=_f9YsPAIGh>C#d*!Z7tS0~Bn;YnkznqAp z{}5&GWSi+#{`U&3n zcNeDnVDUK1;cqC=!9_50HW zoS-vbHFof$5~7#9>&|zUyn?QpC1Xu57xVJT4a2J8^&J9qrpGDK~IkI5Cvn7k!Hq?S8&! zp%xWUA4%l2RVOO)w9Q%&RfY!GmTSSyGsn3n2DT9sUZM;FB{ZOi9@UG`fKdhhW=Xe| zQ6|!S>xR3T0vwkJGSI5_ya(<;9nyFfFQUEWMK#T%4C8b1H70Z#BMFb6_&JnIuXB#7 zzLN3H+x#`w_YfQ7;TfyN+QbB|X!j4k5W4eH1b`T%ydVZC!eu$Bp~j!y?o;2}qtggWz12>@Ae=aV-JnN!|dQ;9uHy{Wnt5u zJ*%9t%gh~-(3!OB&IITAO*6>&xjJ;_JGPXq;)G$@{EFL{PLr}jmWYI-k1L?itXr?o z^0J5cJOdL+Or^^NruLdiBPfOo6&8kFTE`@Yu8fxdW|(-1xc3L`1cx!Pp)2)6b%MiW z;SYfe|Mb+eI>qxD1!EF9WT-G+QU?QOQy-1lQkQ5EwpHB>cJZ0iCvvw;yB>bEE%NHU zS2J6zWEvp|rSl{E;42N2oqG`BN}lSnm7%*vz#uHbC&y~A+w(ko2l`G6aeC@erDryO zQ2#;lTz;=?YV1p_h?FUh{rvMwLNj%#AX`EDS0~07|LwQ(P#XUW3EO$8imoEa!0FC* z%z>_#a36v-Y~|H z_7UTxdI2T;&PID@SL-S@g!Fa!r!KqD*OLnX-g>bpcxVkC+Jc8IJc#j?h5zhXN{pT{R+uJp>e5QvLH9W;!joMHxg6OO+8C3CFm# z1((QFMU2Z`(@q>SUN`&1wKyeMLbta>f4TCxC+hNezHuA{{!tS zW6xE^{?vi?mC?_qhwhw$&7QmjkoJ}YiGf7#%})b8`#QH*L}DNArPQ%g#eG%L)dgao zy=00jMn1Nw8I!$shHV5RcD_LnRU2&YCDKbuayC^;L5lW~c#-tuT6-LafQ>J%WfE^; zKN$kHg~@?;#tsv(2kW~Ou<1YPPQX%!Isr4HF`o_Z1uSGVpgMI>3dI2#KnQeII&0=Z zKlkcLoo6T22KiQNk!+FineFa|6s`)eez#D4rsB!+re>@!M7?&VmsdZ+jZ<*AT&)DPt&W1cr-hND7W@>eit7jws8{@B9I)Xg7X zI~Y9A*tXry+j_j%Q=0Ho#Av5|UtC;>QL1T59;xP!rIyYqF0qtJh5i0)aRKRU4(QNp zBKPis@mc08#>n;_=_jnubyY@}ZGkbf>W{_2I`ZS5xG;}C)skg-J=Mb2Nc`a}o}}NJ zXBTO9nS4MAF(oKdn1c)1ICM677LTUUbX2?3=)pr_@KC}-IDVU2lzlRiE1y-1owSE) zb4TqFj)SFFG5gu#1*9@e7m;c_(HgZ3`c{3H3b)@m283#5_^NyeXH1^|uJU?U`}$qw z^)4`?<>U92$}5wPMioe))tyM}Q028c2ApBWwUr-mMxnl|EVgw?iYr!ehFXF2$x26r z#;5BECmdkjplMQZe&wJ&Pi1&lSw)V2%bc~29PR?V=rVwEe<1miS<)X)v%~RB*LAm^3O@9Q1)>A ze!<6S-xZcD3tRFFfyzniwIm_i|9II5azVFRqtk=Mb(YR49!DzrPPF&M#f_w*Z7tmMb^&Zey<@GKaN#rN80@*hd9X5>Wuib*AIwDjjjv5**pHLw3 zpB(`)>h_q}QHSb>>cj-2x!PcqJCp4_#eBS~*r>0T_=A4#DwXDg{3+rCL6yM_#z4F``pi&GfE*5+O@VwiEpsb;63?L@8UqZoq$>u9agIC; z@Sqaz4^MsVOIe^r^q)h!QYTrYUqyOD&)lX3Mp!`09-(LMm`LIscZzC3`G|0cMTwHcn};J;W1 z!S^J$D%p_=LTc@-u)PG|4(d&!T?qF2`8HLY`?w|f3rPsgL}0F`A~D5IvPG`lFhU(x zPsYSX7vznJMG6Y45~p$_cMkto6p5e{`88U8K)%qNcTVhtf>dw$_aD?K=#NS0YmHT2 zuT-X|Y2K|@W_gqQ%g^N6&`e8exGHveK}i*Dl}5`~_E){Vt7yI`wV$T<*i&lKD|>(z zunvgCzf_7`5LYE4#q2R?4Ma#N)o3X1>TuBc%l8eP&sfqGI-eOVbh3YPjUINS4y3YR z@a(Kd4V}FK1$16+HRfJnN&dG<96B$d8lltX_x}PqU+AZ9_cCo#;^FOCnEu2Wz!(7#0v!whW5=X86)FLWu0R}lrO+v;O z;3Ak>fIIxu9+AXRU|<4@=5b%qJe3C~?0#~_UNFG{KyP`~hKY|Q8&XzmtH-cIC`Qk| zs-Q3u|M4a|E*Hc&1Lx<$NH`w%ELpzYlBb27NIaSaJ|gjWo+bARPi)^Sv}C!BRq=a; zGAh*w7m1z9fgBeW1MyWXb>;r*?i6~pl+xG<3!kJ3KGCIq!O|3$=>;vIjQf3Gz zpJANeg>v=Ol>?7dCd*6ZLm7sk%IiHa1XW(|&Jgr{5N02|$tH=tZNV#hi4OlETM+x8 zePSTHj``Pso*nIj>>D!O9_@1jWe?^CvJXNt{~N@2wh^Ms!gMf;op;e?b@o)jQ=>hd z#8Zo&I6vwLo)_5HBA#09X)sTl{NFXd*sf>O(O3M%xaZrJbj3Y?%`@)F>0?s=)#evv zPzu@4c6Il#q`W5y{N==d4z-HI+JHlzvun4ax5pP@XG|@Uosq-%pCj@x5DqO$<$5#c z>Le#*8(bmekBy)QXU!g8RA~Guh9wN5b%<(v+#T7QIQsR`58CTI!>|9DpY!Z}Sp`+d zmnXS}b%kA6x5koX6D|3L(2JUHvgD5WmfR!kM&kD`vgF}5OCA$?Bk^Thl*EcT;dZ=K z!_;=w5Kgf3&02Qrrj>hMv%Ru6nTyEcvCL6{AXu(P{M?V*l)WlGvzDr>;yiAE#+lPfa?Zc^ndX+#WM!72X`vA(y zJ-;{TRsxHmc!VT7@oaI0rPJFo*7+~7h{g#npIWm5!izl!CHA0pi3qxs0aW^0IVI=n zuHIEZ-kUnTZ1P{m=|we|Cb1MvVkw$LX`;DUu%%CLSGC@M7rW8bpvJ{!P_tUz*9P;A z?DjrGzJwYI%JvLfI;Xf+o#TC?QXTsCCJ$AIuLvK$g7BECPhYQE@!9E-gV$DNx9Y-J zxy;3ofw6y1EYh!JOzgsbrLZukuS{qB-kmKr?t@j*ugKZQisoPvU@OGp|Ef-tf#@<# zL$h>0RPJe8B%b-FTXIjH$<_T?BvKR2kI_{OjbB=l3i}g3oLZd?*5H>;{(x>iYY4ax z2(WH{^QIYFzqKU4mBh)fjt=R{*vhxw2G;BL7748z2_@}otoT<%0{1et zk}rW)|1fABc$eO!M|?4pmD}I-YZ5{dIh_0FPY0=$PgQ9Bn|d$P*0|JpLG58gz0O!o zd)Q;Eeyg9gQkcjc_xZJ1-hX}e4#T#CL{kmr6>k`UomY?(WI2Cy#ZAVcGV{cgGIZFE z8a{kO^|h@d!Z1kH!E4V+4CTkaQg?sVy=J`A{K_k4aZKapTEVtK^Zogb8g_26W=p=##y)S!8=2;0-y<+558LCyWmNOtv#EA-a{QiSU`OB356np~VJ3&! zADUGaiLpg2T_cb&sj~I2Dfl+Kx71r$N1AIYwJLE73S|>dmwU$n|^ZhdP(qoJn7MqmF z{rZ1%7;B{h|JGFGk(-529y>FvIF z8x3oKr`B1+5ftRK=epn-KQU{M?Wc5We~F7L5gJm5z#&I`%CROeg+6HgXa{`Q9$C^D z{{Dt}sx>i`qZAi@E~rish1D!8Hi{kLf9-i^U$B zNM;G`g=94gBk=K3iJA9xG{NxA(ND5llK(?U0BiX87v8RpAF45Z3Gfh9huanFt<`_A zYq{F|7rT~g3on}ND2EJV6{{|LQ9&T7!8%?m@n7tJsxEtL`uxe#E1#8`_T ziIlxJ{f?y8cR6mPI`$`i0%Up-d!J)MUaXG2JtkiKLUq};`ZrT+T`zP^uAy1-=`FuA z4L>VQUjo0D>@1ei;McBYdo%bef;WR-;bVedd3^X)n02`S82kYN@E;*o4*$R8a^Ww5 zzb=5$;J0NtMQs}VT6eSF82qz&6a32K!>_{sN%$p^<3!U$7_Ik-#s0jc8!up#Qod^x zYC#gD03|z8c*-xmHk&vS}z-f<{CY^@fJkeNqx$bN2@>OWZoBe9q9K{vj} z$Q(cMCQHg2l`!sFc^aOldH`g;Qbl`^BINeGfM;;Q@5r9zBih4KtaGIZzW@xBm^zWx zVd`1xP;}T&cYWW~gFblsf1IJgg3<%4!Ykg&bz1Dbozh}Qn8tdOAOmSE!D{}`_WoUQ zkJH~NR^wb;oUpjafMuP?fXY2eEu*!9^4C4rFw&rU#z;rCSLPPMs+dju1)c$b8`)EV*$l z_xoxU5~?iY-<6JjmKmrm6V$Lm-Oz80Y!dQhSpyK!L=PsItq)YPCgr>Sm~~?xpJQOx>2&^Jaf_ zqwN2fT5rmp^MBFyfwuHsnho?jqC2va9dkI*?>jJl*_kk^T-e7%dt=;sK3}<$uchC*|?={?__az8wJ=wQ&Pg3h#Kh7q*vvEe1wg;O^-FAUFaCRq#2KlDe}xN~KD|~z<2ar`= z?(om`{}#3*DKp9Nw|7AUQ-y(ULP*oaO(w_ zH)|?cL+hacMW&A|v@=}gUo|U1sXU&NTNg68nB$7eGWu@UsMt%FW%zex#BK#*4o`u! z#AZ=@QzMtu)ur30DVoNLaPD_$g!#tL5usWIntx8_{4#CEPUIe2%@wtpop122^5p)|XF*uS zN-Ap*1~IgOEr=njO5_w^pT~uN9lJ=pR9!fBG3=^hv5WC`3iO}Y5F$5`xWVX;2mE=-=htxuIc;mluq>B5H|YW@ig?k`sOr!mtFE@^tJs}2)2ul z^Y6zrTRujFq$D-rrx=uVCb^6KARNqa-sNzdXWt3GRBGn|63vJ1aaRG!U}bh?Heq6V zTiUni{9o~4$S^0R8u>`B?Os7z_PQT6GjDsDlE9NZd74D4as*di!DJB1tv zl{~IEZ$_vbyNgIxd23Nwic;m;Quab|QZG|N#uju6-y(5HDs>XC&9i`5z13P&C##x& z1|CEE5&;%#ML(@Uz7qKto(1zUGt+mQ+bT`uo_tdmapcP5{rK-6fo-+wBg98J@!6UyQ3v}g1Jm_D2I1_-$23~AtXaafZZa%^K1%dQw=9bO}mpd$D9F%zZpB5 zC^`-NUy_}|htcNs=_TZA`$HzQm9f?;_ENz!OzA7Q?(o*Vv!k$(^0V zpx&L0q(m*ew;60qzk(lO#ku?1rjHeoP((*kW_Uo`?V0G#uhXQTasmu`_yYCH3 zsB@PTOkdKzODEkg?b5k5k(^7*UDnvSp5)_%g!{{J5#1kZA$*xiQp7DX{r6Qi1YCT9 zx}p*S(ANwWAz$CkhJa@O+9TOlH;%$~hMmS!l(_@tFUW&su;&@fMv4H8c7+oCqUE!E zd%e&*q_?xzOR(=soxSe8biRWlFZHNz$T|D%WeHkz8{#>h#W>oSC>`CTsx@5em^@C) zON=hA@Z!VX#WF-E+pl&(+hi+!i)?o@v91f098*&jVXs(=r?tz+dA#w{nNI;wFY^{^~_TUy;8KJl*lvH;H5Wm-y=~o8NWMUw_^5CH!^u z^_}=@?y1IK)sMnoB@;6EYfAM$=dTOVEhD5`nB?k@`99J*j6+XKV1Fd9e2j^K6q}Tp zgsx=y?P-py>ESr86s8~HG#d70#BV<}cQ58n&rjDl{Z=a&&=LA0{e)I4NGmu}7AE(40bylRD62}dPFDAUxf%{%=2)OUU z4dTAQDbes|XV&}M1lJ9!=4K4kNYl+YB`ysIZJb{;jcp0JzbmDYJiig2`Cj_m9bS{j z|EMjqkpgSPah@B((QI>QCwafnteO)i5Xo(t?PfF^*9m8OBOZd}zBl3zuVu_uGc+8~ z2HuEBHrreS-8R2mY5icl`JS(bHcwme%_Ymwzn*VL&I(R_<83!0ki$v3kYUL+ybr?Ud-5s#loX)L0_9wN{NxyxahQ6YH z8wr8oGH>#$|Dt~DakDzpy?z@Yz`7ehXWFfX8RO^Tla0?NJPeOU*_|L zb3G4Prp3rXhgveMSP7GIOtygJZsq!Ucm5HFZsumS5M{G@3zWo)ZdEO@^{p#%VlT8N zdqlS$zvAs4(YIgh^Fr+Pwp8@(i#BYHZhfrJ>$CI1D|Y3zuFQ#TXnns&^sVDpY$fxH zeKy3_w?+Wx0r;XSD8 zkI|CTFbe+=KKzeZSUOxHm|uSpnl+U&++Nj#GuxBr@;rQ}$FD?EHXC1pUr}WD>nPL@^ov=oU8bH?m-K%8iYEs9yiB&OfQT;@Im3PB& zpZGIYizjeh{9l`60l>Vx?akp3V!F0hOI(Xa7~`JN&>^}fFBH|;2nvdeeO4LUu<`vJ zE3@l2LllDAlJ{s%Wv^G2SP=6@oH+7+w+B>r!6{C^osHSoXj zJ^b&696ts9tyHWT<0eakt25aU%DWNTtwuQMsIf0~_E*~?rxrWunC&wAYt`{VA3S3L zksn%;{}GAkIZ=~rg4^a4H<3S_=zqKzhRIXz2R*(A5HEO#wMp9qr>MBg4ovb&b_yl8Fpt&5O51!C28PS z3BtHef?(VbT!H$3YfGm=vDT5%R=X5*XvWTG+^zdm6S;H0!Kn7~W;d!8srQNe^0jX4 zl-!y|`D$I4>H*a#0(?xNXZ8jsk{ERLnuS>wXNk;V&-qf|_rEH-vIsX%b^OwT>iBmH ztK-+?RhM!4_^(gjoYYD-CaD5XZ{qG$Cyp{a3j`|`vKA#}A&c2dy?aOb zaw^#1lfBn1lQmu3VB4_Hzc{#B(T)}Iw{?I^m3b*nPd-LAm`20Xr^_(ZWZY~S4wkQOe; z&M^a`IQqX{9FON)%+4uAff}B#HfO9B5>4U%|IiG`$uqu~4b8oH#e19urcdGncQ^8o z?rmhz-*fceEiE)-n^O&sJFKy|6Q~Tw7j85(PAIa!{z13)oXHjKy4%?_FhkK(#ta8r zQhtaMXuzb*<_J^87Ox|!-~Sq-+Pq#0IvA|iX^q6i9HD*pF?IQZqyNZ79q9jg9rWKI z`lH1HN4ORqj2R&Q_a(Np$^25puM_c0x?uxRzR0OnsLZ|Hs7I-}3Q^v-)(4b-(Wk7b!a2HvQRO`@#FkJ0`4Xscp1AJ+O$WwP2&(};Pu*I;}Dxz+fun+ zvQ8RtGU2VvZ^PU(vn=_9836$wnSSv`owk=kNxrm~383}C*_3uHwAr|S+fF0U;}(*u z^}+3WkJqBMYml69t#$zq!3P$^+S~6lR;w6To4v$}`-@zOMXh>eflzB)X}d9PKQg1= zt{MGy?{vF4djc)FO`qXdPH{Lf6-gkT(H6+s^X}*8#lC-K=N@mz!b~Pwd*apXKX@4? zLUDJ14W`QT4lnl+qxFZRmL~SHirPO&zWn=deyF&=ZtlOqOx-Emp{*RG94_K_+vKrh zh~gx>ka&WvFX}S5A7XiN8JvF?9L|VA&mDI)zZ!kH5bkDKX7NE4i%kA1Eh!(Rgvo=G z_x312$vLj?jmvZNup@Z`h5b9>njhs;aEDp3DoqU9eDPSAh(-pwMhm-(+AuLdvp%KA+%f0Dn!9s{)2 zxiEu3v#aa4wa!ee_+_RoE4Wo4^x`qPQsFR^P7aR*KOCLUJq5ErcLc_w^2y+a`$11$ z#-X^06X##Yxwd87*~v?w#sj5xwZN7BD3MWs2A+5!-N27|q=6Uv)4(^nYv5wn!0mnm zm#BeLtbzKGpzEL~jDSU!lpn05djhUoX1K6r7t~e9&H&rK05rD6?|!a>?ifKA`$sq3 zZ@tvIKir4zGN40#j#dBbxgT}V{DlVILza|3tmMnULmaYNk|J)GxSO;-1HP+y0eg4$ z1HR<$Zs03%@V!34k>@OfZ}%|QT!twHLkK07&4HCs~oz6Z5lkenh)+AGGmg%=kVa?Wu;I<(P zChGDB3`apWbtsVis?GJR$U&C-Yu7WzJmyS;e)uf#C=?q9-&(cPsgbH^YXu>oZt~1S z1qU@_80o1bMv}h)lEtyv9 zxE3akPEirZ3zQKQ<^n;hg;=FBgo&MNI5W)2r1ht(YY!bbPVvhxyS^QxT#5X-clw^J zVJnxbTPwtSC7rtzPTc&7^Zzn`?r~$D0Gw{k$lrt-!G6CG8$3Sj)LO|z?x5LMQ`uj= z5BAYy3=2KbX`C{fR%jJ28~`fZs~)?6-pDii!S^g)w~cvDgNYVx_(CEo5sIhY8E-N^3kOlKC(j1 zPqD+kX=$Bgvi|C(rS49S%fs=z6~@ag1AFSv)BVF6xx!=VM9XzLja<7wDE#T~9149= zy^`ZZS)>du_ME*`c(jW>{XWiEtu7;k&dsM`JS+;v!&qmV_H2;(qFpbYc8>`DcAMnE zD}?e1?LCR#ZKfXGeTJ=1={jQXrmZ00Z!iCA*>x&UV{6qqW{)-6p5^`^i=t-gEexvJ zg+X-5SO0F{-)L`qSkO3al^8Pif^U}v z-_ix`y8o3=eHjPBY=!z1gb-oliA&fY#{JxAM8ZZbyT1b%0_^mQxdE`*n8T|Mav$aA z-tOnBv&#KVjZ8I+mEylpC^dUy=aI1Q+=Ws*!!%O%LOs`-ZA@JkM2#6IQ;l@f7OR#s zU^xZ7*#gzPNrT`inABQKw-B_55C{U?J2Gz+(xoaCm!N)B>L_C5g)C>{cI~ea9Ce@g zeYPdL=j!qVa90xGpO5UMCLO9@tKEiKfoAA5r*~q0;%?ou@Pkh*%hh($(J5tK>XYy*- z2;~R(_Ll9pbq~WRc`_*^CB22ZMX3@1lN*5H&G*F%TF9gL=m(zk`SUPq&~X;Lv;+yz zQ8kv_qa7=Xlw72$K&+-f(wMEJEiF}C5On(F(rUImZFs9{#rp?UEp3|q)N5$Htm^Fb zDyRIFGq&J3IbFq7O{#BuE(JiUD*Y40)(pT}Gx7Vip#<7%iwU$}Yp^_S5scbYHJ^go zX|jOSV0q{C$;IrysM_#O)rt=es?JUdQst_g@wS5i2P3a)RfSxu_+NO|!5Ye{-#i-9 zKPjy3JY!lny!Axp9Iql%|D1iP(?38e4KI-L;8v9`u#|{SYECOhH$JrMpC4Hu^8`S6 z#3WJ`IEi*=R#_j7{oT11de`;?qlcyVi`5XIYu|$YspoC>+k?fM{NJ_&zk%pFbs2&b zGMN(MHOT9|$bXkI(0d8*s<)I>|ICLrLLcc}*wV$OG&6eFq>P#RKaC$JfU0)^MUCKO z)%zlQcY-R|m+)S-VoOi`)~aSm?K}YJUcmf8`nFK1L_{Rwy-4rU;g+(4&%URp;qz;Q zVJP>_%1PvW&`Nld9+1vh<=^7HnxACfdb@wiJX`wvL!po6T{CRU^qbQLD9QC&^_EE3 zsTy4i#6o0lv=o>uZS#(P@ncg=ZHAf$-ClA3P9B$MlVaUmF}ssTHR(R2KT$3fYr{J)T#<O!-Y#t>=*;=V8La`OU+%7){ zUKou390p`HV98m|XNwyxb-a+lq7|9tZ@)NT40elhevRxC32a6ayT0XT5gXbF4XG`K z4VC&AM;GZC#&Uq>zP5D&=NtX71ApAA_u=!c^v+U3;joG?sFVt*1eSm&}zJT^tORF&I{Q->WlP^l}wDCA3 zbUeP;2qF@S5E}dElXBIsg=zYA5*>^|c-UMWe=hhq=Ijd77PIL`eNH%DfqR2>8|xLm zZ>5RcF-LK!*eJo0z!l23;Q9}53BnM}=YfSC;?s0v=vt4%V9aF(;Up4`O2 z0iEZK!Mo;O+MTJ!7@wbB!6%2L+1SSe=YcUf~iF-%zPm2pI7k=EKc_G65qF6_m{Ez zpZ4WeY4Y)4BMS8V2V z7MWwJO#g!Fq?6U48TvFR(|er%KHGnnuGH@>{(B?uEyNPIoX(X0ns3KfXSa!8O}zq! zsuCD#TE+BFWDc6JeEhZ(e$qd2V3v{L#G{ts^lTrik7wI<;0q|U91Jd$N)x7w^^<8q z86avjay)38hBatvE-CD{kjieHr*|Nc{j7iL#RB_{IgJ0?68|?L&$yTJWLaXX{t5Qg?h}3)eUc@JD!d7O>zc})jT5QCk zw^kl>o(&3?@-F*HrtKNlJ5EYcYNrqRvjv8JPu~c;)X_uN|AND*u6aTNkBy)osCbj5 z7Fn4%-#qG8jZWxHX zfXaf@P@3QV)U_Z8W#MWv{Ck@Zl1CFa1UU^X%@W`{JM;~kDa*i1>$YVU4vdf|a<_gs zkpu?^CA|8(GEw(DKY7`UcM#Pe{Pb7dP`^;f4ov(Kqkx-2so_$4Z}ZM+btZn1y{8>* zBjh`AdCbJGv!BhxS53~uw=#C~rnAO6oA?F*ZDm>Ez(5XsNp0Q}E%X9pF z+tU)vLr42`w?!&SzjCmKQHyPa9ZEZDrE9S9r(I|4v6xzs4(E{8Dxt1)Muu9sG}3OL zk5Iogf?A66RjF^E*XTKs`{ol2W^jO@@FpcPIbbzEnSH+dDYwp=+3{}h(amSpAK13O zt~#D4&9oLIYr(<%?rr{yIo`MUFXnmQ&Wp6Ua!5CCvJ_C2Qq4R|2|2LTo$zeVkFDm2 zSzonbYt@S6K~>9x5v4ktdwl{o$Xn9l8XQy&gGxG=bmjuS>7SanW@z3uadOch}SEaOtM&_NGX;S!U|Zb(K=170+#AzOpenk%0zF|FlS66!pe-{NR&VqVO1ED6O%9C z!3~T@Qn!EUGAX5w_oJ}>WBPfsg5j7h910qlE?l)C0oQ77z4D=jJmoL1J~BI6{+B0( zRic=4pXOcL@1ut9$13 z2*+yj!ppOBvmP2+dH^RJ)E0!7_c>x#c-E)+j1#qm;ooHEsSx>N6N|#Xb)~X%!?DJa zH5H{<5BKabc1^_z*+l}VCQPtZt!*jbq0a3s$St41x)xL^T#5*1d1F3hF_lB+fBA&a zb&N&;-JS~I4JEN2W8^}9B9SbJBM>8goCFRf`gWS5eb7bkdVF4^;*9u z{0dmOaWYsK@N{P^EN$lm+(k=!rm?_%Kug;>fmzMcc1{Qvg_k-`=m{3W9XO$)dn_D( zZGZ*DKg%2acZY?aKQ2xnIN_^vg7V^u&(9utWOhsHundfR)E~CEW(aC0QU3NREUaod z)cb6tN#MrM33ko@1vo&O{jDz#Z44yvZ$C0=expj#JlKGeG{4HbN#Kh-cz2y*H61^p zF>84qy)gg$Z<$|2cV{=`HH{b^n%jzVu61^9!B2@dh>vGUG`f1?D(|HI+0Sq{CnaWR z9{1?9_DVd-`dZJ`Dqx zyD59_`)pYRzT_6*)X$-rKjMj5USingi|))?db|(+@;|?`C%N2Z>QO&vIoJ7^CV%}- z8()+2dACw^qwdODdI4|VY!#8WQ1(Z3SMKyf_?y$P&+-%bhIF3&+?`peYnNBLw;%6! zS61o@a`bB0clp`w+W|-Ot;+0&=&s)Nhx2Qn`hAw~=YFkOF()f^q&0eLm_{$=v$r3O zrUu)`HD~bgn|u`hcfX-PzwxZWN7<(8&6&70h&*30#0?91$saJJL=xkRM^u*`RUDf6 z6t7jW;$pR*e1w<1sM7wy(dS_S*5Uk_4)n2|o;cDP!*R4-ep6i2h(R}ynEy71^Yw?e z*dgs+r1v%h*WaKNU5Uti5-RAS@P>j=!6=J;AhK|jg+35pI?5s+D#B&_Uf)k~cM7?C zKJ}#BCxz0jMX4ve`>s!Sd;MU)+h*S-M`B8-?{%*47xAjTCnG%2P21n}efow(ab$Fu zoCFn*ErRbF#)-akYqYw>b^y-m&6zwnykbiZ!{6J-5PB8AFdJU%pPd@ucW**3x)=MS z;vy95@ro!@0A&hSc^_Yw2JssKi0oh2(U^j-Nbofz1Y7F%j`+W^8u%C|#?xPN(rGrD z?bmQ5OLBSPvTx=!930j{dHkEm1P4x(om<$z`5v#h`NzneTlPpM1xX>06tT)4IH|-x z4-E3rB~%uq?rLw^o@g0|)=@Ybjw%lDQY54dg3<3-o^UryhvVdkuFhNK^;a*|p8{uJ zTd!WWUajj?wY?ht>uCi(fI-#25kWhXeEgpmj)P_VvNP8qWWIp@;Z=kT6jT-N*|5}o zE5G264Oxm^W5Uo{6?@%;5RiiStAT-(+~89pY%oU!GxTY6 ze9{%{`qmYGz9#(aXF%(WkG1XC`EY!I9c$w?!^?*5>ehF|&snrmBK#ByKScq4Dt!Dv zeke~G# zW&9UESDF~EgAY$o3jlgK(Q-Ow;}h(!<#`rAw!cQL5|K-TQfavCoWjuD6|BFrmLm-9 z&759#0H|?ha#ELsF!;2;KLfr1Kd1Wm8J3A3aIig`!_HHCW5=h@X&u}5<#VW`$2Xx1yjyl|0e7Ks4D@4v>s}ze`~UzajSqFnUupS! zh|r|vHPX##`I~c1z+qoq{z9{!b^5(VJQfy@g@wcP`1_Q8*7$p;wZ%}dvuAxjH-Bc; zreU9@$Lfc~pv%9HQ0C}zcTHK~1W0Wr>Im=YCM=Ic{`hw=gZPb!&1mK-iQFp}a~j79 zR-CWtWtFSm;3y746`04AhT{rO!*A5;<=aMD0U2Fg!v%2YukWX+*H#dS^4EP)t~L6F zW}eQwXqY^yGZTfL$s5tHp+BS&iSjUDXl7MArH#KPbfzzv;|O>u_6LO;D(&{jvMGfP zCud5)c9DDe$6FNN`8CJ(Y+2C*f-s7Qa|+Qv{QhP7d3VU~l#>Eo(%BB(i!a9W%K9}7 zjfZo}&dq5UNG}ABx}$NRV6X0E7PV*fFEooY{WZQLwK62c`TmsCCZ9G9W!~v#po!es zf5!W?>QU$k4N*yrbfxI;31j7 zef0&dDBxIf7Sr@1{_{o-r~hjz3aNq_eZ@qj(eiq~%$kZueMn&#G&T<3=;bSSyk?xd zU?+yxXe=Q2SwZemvRboJA+}KF4aa>%{hLeu5^F}eHt0%?lvS-8KM$0D4)x@3V{U&+ zkD@{q)&uh}i=y|W9c&mI{cG}M|Av}>uAiwS41HYpp^u{< zs&sIDm6(JdL475XaffJ#RbzqDwy+GmpL}OwR;7hM7_e`I6PW+-?*kh%O`EPOQizya zp{An8I#zVaYI=Qf$4U~p-{Pyqmx=YA)uayOdE@&9Smj6pkgds@W${BP zF=W@bG?nij%e`myOj?KS;wf7G^B+n0nQG>L%)3oBlRS9EN7D|51WHHeNuUnc^|G

Q%pXF#xy@u9te*dzj_4+B+?pFZKn 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

}?c!9_ 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

B(GzYJo+< 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%0AlKW>*i7T* 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

6%y&ZG*xOx+i*7o}U!yO8 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�@m@HO7#P2TNC%7Xn0u+&oX6C~sQF|L;flp?ISAC8K{6FV3CPmwhUDTuu4 zDSB_gIkSD9V80h#FZaQj=z;v|33^jpFQYfuYVJtTy=pxJHemBJ2RHp8+%NXiCM(0{ zk9wDpcCZAq&y?}QuNnB-By;vytg1L?BY!^6m&9g^?q8Jtc*-sOD<}U{{EW5kC)jsG zVZ{<{(f@a^1d~*3W-x8VvIV%G9=V#CIKBU;ld`eZb;mMpz+uNbJ(A8X{l5)FUk1}| z!K*5~A=rP)pHKu{qE>GkJ8-LDFVNTwh25mELk(~k^f4H|p9U}rn9nF{-T1A9yUYl>yo=^DHB2J-4E z!S+T31mr`w^)^E{f@zl;=+Uv7cYkD4yi3qW8xkpgRACP`#3@eKSd5<*jebJVp*R{U zawGJ!g0C{*TVA#q2K&aU)cAV@U+ct6{=8sXwSf5savdZ?iX#5`Ow~!NGsqm`|{9lQuzzF?`_*y4ETj8q> z{4Y#=w#Gjp^}C(;P96gerVTgnx0(3Py$SLjUE-u);SVi|)Bo}Lw%`f<8h^i{--)kO z_*Dk}?|(Gu*LWrOwN8At!dDykXH0yy#*bF?JMo>TD*6rl_e^}}2R8kE1s`4Pq+j6= zEsoQF(kiq6HU42mzY|}n@T&~`zle|Zzs4^Se616ot?<py;o6(y#D`>f`jgO?->S@4243C*;IeD*P$~|K&?2{TlzG;A@@uY=y5j z@M}zbw#LsFyxWQIL{KZ`-@q?6@tyD4^p6*Obdi&Og+H_?PJizg&HmT;(TaX2zEa^= z8TdYC{goPjrlQ}8&sO+q1HXm!Yx&96_yLN3C%%)B7@*(42TgqEUv2vLl(YY$3!U^U z{Go+$`X`$B7L9*G@F6F@QsGw__$@CO{HxUX+ZFvze73?@8~E@aO!_tcGDW`=-^ox5 z&~M;>YvMcKwdp^m=wINZU*Qieh|~Xl6W^loYZd*1KNWK?msc=u(&lF&GzZygH(KRV z)Tq1hKz@|{r)-2=SgRjU#!#U$hQ>VcK+>8tOb}>zEh@IIv@7Xf=4B^MmP!!cjPp}! zerMc9Fm0mUNE}1z-@6@5;x>bIw9}?AOTcHuDHQCh3VWJ?{rrU|lhzCb7V~>Zqd)Yp z>dra`e`*!HqfYUMRbPEUQ_>n{+~NFCtMShYzQu`mD}1wo_g@Kox{Y^he3jrUo%krj zFM??|8hFpQfM?<<)*sztQ$IrR*-m^&;WG{VX=eQ)jZabZ*E;D}_>S5*{f|Cwcc0L& z@tenye=SbDTj84x{I+Y*{yv(1jel71l}>z=(H5ZJz@Kf_AKh)!KSl7_PJBq=GYx$1 zB?kXO8h?)9JLfy;SNM+kar(2&_Sb6sr(=bFC*G~_%?AEg!_EHJ_*VsA>BL8wlK}J^ zcnjykV)7T=Wz)Yz@Yzm$NZ~UL{ACxL^lSWh!FS&0q+j7X?u*kOx!h=ft;P>f^gHox zg>N?ScmCXvAGgNu8AJY6I`PqTMZbZ+%a7rU>o1l3zhl$?tl+bq_>jV98u-?84gQ5R zzDn?&HBR~!zN02i|NF20JZa4UyZ%~@A0hY_C*G~_%?5swS-)H32PpcT_-JoMzk$Da zi>>-({Ns9ft|JHTDJB21o%oQ#XBv3-Wk&ynH2w*}cg}Otukao7;`F~+3VdHpzsBDq z_!cMLt?iJUfr*d4Wz(Oc=y&2n3ZH4hc8A9$^QYc>8+!M8Z^ZiR0)@E;WbAJhLDf4kr-o%m>)qTj%8 z$TRAXcG&cf5PY^1A5!>C1AoJ{!0Y}CX?%*Je~y!Wh3}XXr+~qTj&pywu=d6!*J}{NE$^Y$raX@RNx$Cod09}ukpu9gnlR9t?04<)VXZ_A%sjV98u;nYVE$k%rpUj>KPvdnA3Et*_>LdO>CYHq^k1#U-!AwTC*G~_ z%?5tv4<1QcgZuWRez(S7DELYzKANQHH}GfD{?X$vy3MBlz|}&(6CYCeOani8u+jdI z#=k1~&RI_S6~1Fuoc_TkzED#)uw-hqTh)RDSW1Z?{@|2kIjD?pQ7mhfs=lP@AyHS{v}V^%O}zQ8ozmz z=szdkt?a^gJ`{K@f3+HaV5HFR#Jd%~*}!+we$e{Et?{o4zS4=0eyQj; z@V_$g(Kl@Rmk2)Fi4Q4!rhz|oBgC7C;bZF@%=dc?)wb;yH?`|DEggv zx576Y_;Y?_=wG+S?{SlVl}>z=spZiB2L6pKqyM5?Z2F%Ne6|xGQus^*e+%v3nEY$} zJ%aC?>7-xbJ7&h|ANQo8KWjC9gy378c(=kg8~6(zHtE;+6h*%iA4T{G={NB2oo>>< z*`|N<2+@B|d`RIl4g7Nt8TE%W{!zhqe$Pq2!gqWxPXFb!U$p$zYW(ejZ*k(?3g2wt zqny7r-mUQ$3ck{bj~-L>8~ES+#a#cqZqt9DNa%OsLkgd1;GZ32@GqqCp9;S79w+?@ z-*Hcz{#hozR^wk3e2WwBR`_NEe_8_l8oxyFl}>#0sG{G%-_QA1>!0W*oBr{NekVSp z@RIGMgQGS`W3$8?l}FYn)TOe{GLM5e@?tx;hPP7%T=gf>mRqqKOy)^ zCqBwZ4#>ZO|0(C+82uY<`tK2Zwi6#x_)G);)e+#e{T0&q%LLy!!%4rwcg%>>e;e)J z*!oA~`zrdKc(=kg8~A-U0nd}GoIl+fzvC*=e@=XqfgGUUz+Y#!Kf1xD|53qbJMog= z9p`Ti{0CDF`yr(9w+p`WyH5I5{T<(p)Bni|WBpXC@fQld#ff(-e6xZ7>{Vm@x;6g5 zl|sK0AN@knZ{S}r@zK|8`qv6R+ldb;e5Qf_5&d5=`PcaS1>ZT{Nx#B(Opnul^UqEF zukn)v-{Qo(6~5WP|KkkQujSXR@nTGGDia@FZ`1$b6{7!~_>jV98u-U( zf5zz7_!kA=d6$!Zh3~j4PXD~Cfse_*#?Kdgixclw_+|q?+Qhpxe!So-o%kq1F-X6G zU(fA%y8bzSqU&t>2PpcT_>jV98u+IkGx{&2@q31of1P(a=~wuUJLB~K{C;Eptkw8e z1>fStyA{6Kz~A{h)Be@?C4#SX;-d!@{RaLrv;OE>oBr{F&vxQN3ZH4_YXx8F#7A+h0OjAnubpqw-)hr;zu>c-_>jV98u;(g|ET#N()dY& z@4U@PzruIi7N@^$xhek|f2N|}iFYe}vw>e`;@ukm;V|;A(ut4mQ}i47gPCZ*)}PTe zHvP{EKHG^8DSW1Zx5|On^KVGwUln}kG$;KE-!Uyt|2*1nT7TAR{1U;pIPq?UZ#M7^ zMZjzMacle(MZXgtMN&rgzk$D&_KzOF(ZAUAk5=?M@garJH1Hw%|6={G@qHEjw>s%p z_>NoS^e_C5;lHWX_yYwZ|4zJH;hPQo8z-awnEy}XcL=`HiI4tM(Qn{aE;Zzj`H#i_ z`>5cvo%oQ#XBzk~=s(i^7t;891mF1`C;bZF@trvRTj+n&{HxXY%M|@iyj$U$4g4zu zfYarn_>NoR z^q)lgUCVE+#@{aZ7AM}V@XZFk<5ZJ=jlWRvl}>#0Gey6FZ!z)FkWK#pMZXgtQus^* z-@yHg*!b7@J>Me#I;T46SNM*par)0O>#x=LCj{T(#Jd%~*}y-_{VOehZjHZ3@Rd${ zl$VcT{2TapeMbAEuiErqCirY8KBVxO2L9=E;Pv=%3=GU*S8Z#OZG|@wFQN;l-l=oOrjwHyik)^@jd(Yy7iF(xe=PbpMbYoXyA{6K zz?YkNx5n?di2SQ`;-i+L-@p(4ooWBSY}fy&;Ip0hkiusg_=WvJzn0&S#@{aZ&I%{} z3g1x?r@v*OAwRVmf1%)8oOrjwHyijgvwpY6AGlEHcjBXeSM(eB%gy?ut8MyU6@0c6 zA5!>C1E11lu75QCe!+L%jIa{FSKK8e~_}|GaZZ0am9~OMA6Q8Z{)ds!~ z_h{1dkt`zzTRKU&f6#CP(3Gth6~Kdd(V zbDb~R^!HWt-{7QQ;Sb#qr++y8V|skHX#9?$6upoWU#ak`4E(0iz-#-eQsdVOzSfD) zR`_ZIe=YqZr`zlMY>mH6(eK1};=(b~Z{UZS_|8Ar^ba_f?T=1!(y#D`CdKJb@)+a0 zMdK$4KIFt#D*P$~e@DerNo&rr+h3{iX9~X7iO*K}Y6Jhr<)EM8sq}AUYy5|bekZoJLy;WL*;S$ ztIjm(*Z60Z{5$cL3ct$0&!1|H-%5?IQu6P_XDfWQfj@c>_`$mWHGYZU-A;Vx`-*-8 z-+G48{?6aq^iNUrPju3+@P{VG>HnY?_^<7w7L7kg(eK1pD*P$~zyDz)KC)8dKh5Fz zt99bD6~5ZQ|9*xczu6l9q2S$4eCK4IU*Qjx#p!S6{%(wZjlW;fFL-U=z+Opv*wXe*xfC^OF&@yq!Syb%Z?fNo zeY5&I%D%}{_Kko4`q*K}T2yRZX;;#JfmAYCDlzPvw^0a`{6xEvIIP_N_IlfhvyT4O zrqCncGvXAg_g&iPqkpbcjeH*O z^0aCWnDp;i_8_!w)-7xj@O=W7{MFJwXDaM$1N%KX7-)c@f3h`tilE(s*7TvhX?*34JF>I#orA3M{Vc7zIz60K~r`9SEj!#a#Y27+)~L# zPyRkn+Yux*+vo`n9)Y9fHH(=HK9;I1n704k2a-Z^ekS(RI*paf`G0H0%On}cmm`bc zkZLaS;AHo4?l)*G&iMNL^^4IL4o)F^|CJkxbCT+AM5+hoNkF=U8l<#ClDmV8ig7yo zY?Z&EXmiyi9wsl3oy2ZpI%yP$`>KnXX)}q%#DBK>D2;T^Q}^L~(2$Gzy_RIHek+=g zjP2>wHieY76Xtj5sV&ZM~ht#jFUI3 zks~ODf0GyTQZ{tmgkb8~ zWxSzg54jsSg8LS5--fk|OAN?^hukV>KEbT;D|lmku;0m^SCJZm|1Cnpy+zwy4`!nZ zq^r2jD!~%QP6dAxy6-Aq<2dBPn3%=4mVXMoPe}D51)po;p0dD}GPJ7gC>pZGhwCVd z_Emq2mw-VBNfuh1$j2djcaY?^XGI&wW$-8e zC~K@y*-TWXl59vRP3x@r&?t;FM z3+(m<)*}BDzN>M`zRs{BFR9J|NAV}}=OVv{Ru(;civGB%+t{na%!^zH(2s7(4cvLAx#@)WJB#`VC=mI+~x za6N&Z#vid;(Q+{0m~nX@U-)zv`xDyyn3^B(r_nz~GUk#O&7O)UV-CZk7wfYB`}~(xdWYyO!Nawbs-9GIDVV zE}5YuA+r@s3S@OeHz8}MTy}!|3da!tt!`ov`F1Tog@uWX-v^z0s;B6PYxx04n2ZQ& zH{5nO7BkUC+(8n%okZqR<{*I{oPnE3w0vSNcCGv|(E#GMhsh`scP4m}k>loA)jUsN zA;ge5L^0nt4!rUhMt;$d3-B@L3W^Hk)xNzFV`GaXD?}@Uhbvo-68++H=$9bVs4T&pi~FaRw({D!m^Nwbzvr*gpiX?yJ~G?nLYtbbKBzJB zYg+`=_*g{-`#~aU8vN%nsCrzQXcI`;kEqEWdG=m0+LekWNV{Njn=>4YNsQd2w%A z{#u>iY7s9FzrBppyYLBhf+e^r+t+wqmM?#!H*m}rWAD%-+HNm#O+UHy>H{$K<(Rx8yTJ-Y35@t9Wvf?m%xPL%C;+c