Skip to content

GitLab

Commit 632944ba authored by tavit ohanian's avatar tavit ohanian
Browse files
Options

Merge branch 'port-2021-07-02'

parents 56882028 38872889
Pipeline #676 passed with stages
      in 14 seconds
      Show whitespace changes
      Inline Side-by-side
      Showing with 1026 additions and 1 deletion
      .gitlab-ci.yml 0 → 100644
      View file @ 632944ba
      stages:
      - build
      - test
      variables:
      BUILD_DIR: "/tmp/$CI_CONCURRENT_PROJECT_ID"
      before_script:
      - mkdir -p $BUILD_DIR/src
      - cd $BUILD_DIR/src
      - if [ -d $CI_PROJECT_DIR ]
      - then
      - echo "soft link $CI_PROJECT_DIR exists"
      - else
      - echo "creating soft link $CI_PROJECT_DIR"
      - ln -s $CI_PROJECT_DIR
      - fi
      - cd $CI_PROJECT_DIR
      build:
      stage: build
      tags:
      - testing
      script:
      - echo $CI_JOB_STAGE
      - go build
      test:
      stage: test
      tags:
      - testing
      script:
      - echo $CI_JOB_STAGE
      - go test -cover
      coverage: '/coverage: \d+.\d+% of statements/'
      .travis.yml 0 → 100644
      View file @ 632944ba
      os:
      - linux
      language: go
      go:
      - 1.13.x
      env:
      global:
      - GOTFLAGS="-race"
      matrix:
      - BUILD_DEPTYPE=gomod
      # disable travis install
      install:
      - true
      script:
      - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
      cache:
      directories:
      - $GOPATH/pkg/mod
      - $HOME/.cache/go-build
      notifications:
      email: false
      LICENSE 0 → 100644
      View file @ 632944ba
      The MIT License (MIT)
      Copyright (c) 2016 Jeromy Johnson
      Permission is hereby granted, free of charge, to any person obtaining a copy
      of this software and associated documentation files (the "Software"), to deal
      in the Software without restriction, including without limitation the rights
      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      copies of the Software, and to permit persons to whom the Software is
      furnished to do so, subject to the following conditions:
      The above copyright notice and this permission notice shall be included in
      all copies or substantial portions of the Software.
      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
      THE SOFTWARE.
      README.md
      View file @ 632944ba
      # go-reuseport-transport # go-reuseport-transport
      dms3 p2p go-reuseport-transport [![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai)
      \ No newline at end of file [![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](https://libp2p.io/)
      [![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
      [![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)
      [![GoDoc](https://godoc.org/github.com/libp2p/go-reuseport-transport?status.svg)](https://godoc.org/github.com/libp2p/go-reuseport-transport)
      [![Build Status](https://travis-ci.org/libp2p/go-reuseport-transport.svg?branch=master)](https://travis-ci.org/libp2p/go-reuseport-transport)
      > Basic reuseport TCP transport
      This package provides a basic transport for automatically (and intelligently) reusing TCP ports.
      To use, construct a new `Transport` (the zero value is safe to use) and configure any listeners (`tr.Listen(...)`).
      Then, when dialing (`tr.Dial(...)`), the transport will attempt to reuse the ports it's currently listening on, choosing the best one depending on the destination address.
      NOTE: Currently, we don't make any attempts to prevent two reusport transports from interfering with each other (reusing each other's ports). However, we reserve the right to fix this in the future.
      ## Install
      `go-reuseport-transport` is a standard Go module which can be installed with:
      ```sh
      go get github.com/libp2p/go-reuseport-transport
      ```
      This repo is [gomod](https://github.com/golang/go/wiki/Modules)-compatible, and users of
      go 1.11 and later with modules enabled will automatically pull the latest tagged release
      by referencing this package. Upgrades to future releases can be managed using `go get`,
      or by editing your `go.mod` file as [described by the gomod documentation](https://github.com/golang/go/wiki/Modules#how-to-upgrade-and-downgrade-dependencies).
      ## Current use in libp2p
      This package is *currently* used by the [go-tcp-transport](https://github.com/libp2p/go-tcp-transport) libp2p transport and will likely be used by more libp2p transports in the future.
      ## Contribute
      Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/go-reuseport-transport/issues)!
      This repository falls under the libp2p [Code of Conduct](https://github.com/libp2p/community/blob/master/code-of-conduct.md).
      ### Want to hack on libp2p?
      [![](https://cdn.rawgit.com/libp2p/community/master/img/contribute.gif)](https://github.com/libp2p/community/blob/master/CONTRIBUTE.md)
      ## License
      MIT
      ---
      The last gx published version of this module was: 0.2.3: QmTmbamDjDWgHe8qeMt7ZpaeNpTj349JpFKuwTF321XavT
      codecov.yml 0 → 100644
      View file @ 632944ba
      coverage:
      range: "50...100"
      comment: off
      dial.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "context"
      "net"
      ma "github.com/multiformats/go-multiaddr"
      manet "github.com/multiformats/go-multiaddr/net"
      "gitlab.dms3.io/p2p/go-reuseport"
      )
      type dialer interface {
      Dial(network, addr string) (net.Conn, error)
      DialContext(ctx context.Context, network, addr string) (net.Conn, error)
      }
      // Dial dials the given multiaddr, reusing ports we're currently listening on if
      // possible.
      //
      // Dial attempts to be smart about choosing the source port. For example, If
      // we're dialing a loopback address and we're listening on one or more loopback
      // ports, Dial will randomly choose one of the loopback ports and addresses and
      // reuse it.
      func (t *Transport) Dial(raddr ma.Multiaddr) (manet.Conn, error) {
      return t.DialContext(context.Background(), raddr)
      }
      // DialContext is like Dial but takes a context.
      func (t *Transport) DialContext(ctx context.Context, raddr ma.Multiaddr) (manet.Conn, error) {
      network, addr, err := manet.DialArgs(raddr)
      if err != nil {
      return nil, err
      }
      var d dialer
      switch network {
      case "tcp4":
      d = t.v4.getDialer(network)
      case "tcp6":
      d = t.v6.getDialer(network)
      default:
      return nil, ErrWrongProto
      }
      conn, err := d.DialContext(ctx, network, addr)
      if err != nil {
      return nil, err
      }
      maconn, err := manet.WrapNetConn(conn)
      if err != nil {
      conn.Close()
      return nil, err
      }
      return maconn, nil
      }
      func (n *network) getDialer(network string) dialer {
      n.mu.RLock()
      d := n.dialer
      n.mu.RUnlock()
      if d == nil {
      n.mu.Lock()
      defer n.mu.Unlock()
      if n.dialer == nil {
      n.dialer = n.makeDialer(network)
      }
      d = n.dialer
      }
      return d
      }
      func (n *network) makeDialer(network string) dialer {
      if !reuseport.Available() {
      log.Debug("reuseport not available")
      return &net.Dialer{}
      }
      var unspec net.IP
      switch network {
      case "tcp4":
      unspec = net.IPv4zero
      case "tcp6":
      unspec = net.IPv6unspecified
      default:
      panic("invalid network: must be either tcp4 or tcp6")
      }
      // How many ports are we listening on.
      var port = 0
      for l := range n.listeners {
      newPort := l.Addr().(*net.TCPAddr).Port
      switch {
      case newPort == 0: // Any port, ignore (really, we shouldn't get this case...).
      case port == 0: // Haven't selected a port yet, choose this one.
      port = newPort
      case newPort == port: // Same as the selected port, continue...
      default: // Multiple ports, use the multi dialer
      return newMultiDialer(unspec, n.listeners)
      }
      }
      // None.
      if port == 0 {
      return &net.Dialer{}
      }
      // One. Always dial from the single port we're listening on.
      laddr := &net.TCPAddr{
      IP: unspec,
      Port: port,
      }
      return (*singleDialer)(laddr)
      }
      go.sum 0 → 100644
      View file @ 632944ba
      github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
      github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
      github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
      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=
      github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=
      github.com/google/gopacket v1.1.19/go.mod h1:iJ8V8n6KS+z2U1A8pUwu8bW5SyEMkXJB8Yo/Vo+TKTo=
      github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
      github.com/ipfs/go-cid v0.0.7 h1:ysQJVJA3fNDF1qigJbsSQOdjhVLsOEoPdh0+R97k3jY=
      github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I=
      github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
      github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
      github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
      github.com/kr/pty v1.1.1/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/libp2p/go-maddr-filter v0.1.0/go.mod h1:VzZhTXkMucEGGEOSKddrwGiOv0tUhgnKqNEmIAz/bPU=
      github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
      github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
      github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771 h1:MHkK1uRtFbVqvAgvWxafZe54+5uBxLluGylDiKgdhwo=
      github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
      github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
      github.com/mr-tron/base58 v1.1.3 h1:v+sk57XuaCKGXpWtVBX8YJzO7hMGx4Aajh4TQbdEFdc=
      github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
      github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
      github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=
      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.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u0xW5UouOmQQrn6a3Y=
      github.com/multiformats/go-multiaddr v0.3.3 h1:vo2OTSAqnENB2rLk79pLtr+uhj+VAzSe3uef5q0lRSs=
      github.com/multiformats/go-multiaddr v0.3.3/go.mod h1:lCKNGP1EQ1eZ35Za2wlqnabm9xQkib3fyB+nZXHLag0=
      github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=
      github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
      github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
      github.com/multiformats/go-multihash v0.0.14 h1:QoBceQYQQtNUuf6s7wHxnE2c8bhbMqhfGzNI032se/I=
      github.com/multiformats/go-multihash v0.0.14/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
      github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
      github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY=
      github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
      github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
      github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
      github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
      github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
      github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
      github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
      github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
      github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
      github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
      github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
      github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
      github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
      github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
      gitlab.dms3.io/dms3/public/go-log v0.0.1 h1:jqz2g8pVdPW+Sy8CCo4rYfGEjktGhCBfgIb3oeY6yx8=
      gitlab.dms3.io/dms3/public/go-log v0.0.1/go.mod h1:OsyF7lVYe47r03v1ZCbrmz0byeGUWB0Y219jN1DJx3s=
      gitlab.dms3.io/p2p/go-netroute v0.0.1 h1:SJH1/YgST5q8823T0q/vj6OMaZ71dw+acgdJVQPbFtc=
      gitlab.dms3.io/p2p/go-netroute v0.0.1/go.mod h1:Ppim8kqanv6FEn5EL8G1mFRvdKG6i1ubfyK/vqfCMd8=
      gitlab.dms3.io/p2p/go-reuseport v0.0.1 h1:2UyE9NOwOMgSx8Shitp9FM+QgUSC7y4SAvlnKpho0Xc=
      gitlab.dms3.io/p2p/go-reuseport v0.0.1/go.mod h1:T+dBjUvmAjEDJXLvO3lynKdo0cHmZ2uTRKGDnT6huZY=
      gitlab.dms3.io/p2p/go-sockaddr v0.0.1 h1:VupmB55WkCvJxOveddXzkKadW/jtb9JEeA0Q572AWL4=
      gitlab.dms3.io/p2p/go-sockaddr v0.0.1/go.mod h1:g7iIq8MDEq2jtHLw5AlFNjEqAuer7C11HT0A77TlMik=
      go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
      go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
      go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
      go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
      go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
      go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
      go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
      go.uber.org/zap v1.16.0 h1:uFRZXykJGK9lLY4HtgSw44DnIcAM+kRBP7x5m+NpAOM=
      go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ=
      golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
      golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
      golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8 h1:1wopBVtVdWnn03fZelqdXTqk7U7zPQCb+T4rbU9ZEoU=
      golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
      golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8=
      golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
      golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
      golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k=
      golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
      golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
      golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
      golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
      golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ=
      golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
      golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
      golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6 h1:0PC75Fz/kyMGhL0e1QnypqK2kQMqKt9csD1GnMJR+Zk=
      golang.org/x/net v0.0.0-20210423184538-5f58ad60dda6/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
      golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
      golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
      golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
      golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
      golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
      golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
      golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
      golang.org/x/sys v0.0.0-20210426080607-c94f62235c83 h1:kHSDPqCtsHZOg0nVylfTo20DDhE9gG4Y0jn7hKQ0QAM=
      golang.org/x/sys v0.0.0-20210426080607-c94f62235c83/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
      golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
      golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
      golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
      golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
      golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
      golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
      golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
      golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
      golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7 h1:EBZoQjiKKPaLbPrbpssUfuHtwM6KV/vb4U85g/cigFY=
      golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
      golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
      golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
      gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
      gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
      gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
      gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
      gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
      gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
      gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
      honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
      honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
      listen.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "net"
      ma "github.com/multiformats/go-multiaddr"
      manet "github.com/multiformats/go-multiaddr/net"
      "gitlab.dms3.io/p2p/go-reuseport"
      )
      type listener struct {
      manet.Listener
      network *network
      }
      func (l *listener) Close() error {
      l.network.mu.Lock()
      delete(l.network.listeners, l)
      l.network.dialer = nil
      l.network.mu.Unlock()
      return l.Listener.Close()
      }
      // Listen listens on the given multiaddr.
      //
      // If reuseport is supported, it will be enabled for this listener and future
      // dials from this transport may reuse the port.
      //
      // Note: You can listen on the same multiaddr as many times as you want
      // (although only *one* listener will end up handling the inbound connection).
      func (t *Transport) Listen(laddr ma.Multiaddr) (manet.Listener, error) {
      nw, naddr, err := manet.DialArgs(laddr)
      if err != nil {
      return nil, err
      }
      var n *network
      switch nw {
      case "tcp4":
      n = &t.v4
      case "tcp6":
      n = &t.v6
      default:
      return nil, ErrWrongProto
      }
      if !reuseport.Available() {
      return manet.Listen(laddr)
      }
      nl, err := reuseport.Listen(nw, naddr)
      if err != nil {
      return manet.Listen(laddr)
      }
      if _, ok := nl.Addr().(*net.TCPAddr); !ok {
      nl.Close()
      return nil, ErrWrongProto
      }
      malist, err := manet.WrapNetListener(nl)
      if err != nil {
      nl.Close()
      return nil, err
      }
      list := &listener{
      Listener: malist,
      network: n,
      }
      n.mu.Lock()
      defer n.mu.Unlock()
      if n.listeners == nil {
      n.listeners = make(map[*listener]struct{})
      }
      n.listeners[list] = struct{}{}
      n.dialer = nil
      return list, nil
      }
      multidialer.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "context"
      "fmt"
      "math/rand"
      "net"
      "gitlab.dms3.io/p2p/go-netroute"
      )
      type multiDialer struct {
      listeningAddresses []*net.TCPAddr
      loopback []*net.TCPAddr
      unspecified []*net.TCPAddr
      fallback net.TCPAddr
      }
      func (d *multiDialer) Dial(network, addr string) (net.Conn, error) {
      return d.DialContext(context.Background(), network, addr)
      }
      func randAddr(addrs []*net.TCPAddr) *net.TCPAddr {
      if len(addrs) > 0 {
      return addrs[rand.Intn(len(addrs))]
      }
      return nil
      }
      // DialContext dials a target addr.
      // Dialing preference is
      // * If there is a listener on the local interface the OS expects to use to route towards addr, use that.
      // * If there is a listener on a loopback address, addr is loopback, use that.
      // * If there is a listener on an undefined address (0.0.0.0 or ::), use that.
      // * Use the fallback IP specified during construction, with a port that's already being listened on, if one exists.
      func (d *multiDialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
      tcpAddr, err := net.ResolveTCPAddr(network, addr)
      if err != nil {
      return nil, err
      }
      ip := tcpAddr.IP
      if !ip.IsLoopback() && !ip.IsGlobalUnicast() {
      return nil, fmt.Errorf("undialable IP: %s", ip)
      }
      if router, err := netroute.New(); err == nil {
      if _, _, preferredSrc, err := router.Route(ip); err == nil {
      for _, optAddr := range d.listeningAddresses {
      if optAddr.IP.Equal(preferredSrc) {
      return reuseDial(ctx, optAddr, network, addr)
      }
      }
      }
      }
      if ip.IsLoopback() && len(d.loopback) > 0 {
      return reuseDial(ctx, randAddr(d.loopback), network, addr)
      }
      if len(d.unspecified) == 0 {
      return reuseDial(ctx, &d.fallback, network, addr)
      }
      return reuseDial(ctx, randAddr(d.unspecified), network, addr)
      }
      func newMultiDialer(unspec net.IP, listeners map[*listener]struct{}) (m dialer) {
      addrs := make([]*net.TCPAddr, 0)
      loopback := make([]*net.TCPAddr, 0)
      unspecified := make([]*net.TCPAddr, 0)
      existingPort := 0
      for l := range listeners {
      addr := l.Addr().(*net.TCPAddr)
      addrs = append(addrs, addr)
      if addr.IP.IsLoopback() {
      loopback = append(loopback, addr)
      } else if addr.IP.IsGlobalUnicast() && existingPort == 0 {
      existingPort = addr.Port
      } else if addr.IP.IsUnspecified() {
      unspecified = append(unspecified, addr)
      }
      }
      m = &multiDialer{
      listeningAddresses: addrs,
      loopback: loopback,
      unspecified: unspecified,
      fallback: net.TCPAddr{IP: unspec, Port: existingPort},
      }
      return
      }
      reuseport.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "context"
      "net"
      reuseport "gitlab.dms3.io/p2p/go-reuseport"
      )
      var fallbackDialer net.Dialer
      // Dials using reuseport and then redials normally if that fails.
      func reuseDial(ctx context.Context, laddr *net.TCPAddr, network, raddr string) (con net.Conn, err error) {
      if laddr == nil {
      return fallbackDialer.DialContext(ctx, network, raddr)
      }
      d := net.Dialer{
      LocalAddr: laddr,
      Control: reuseport.Control,
      }
      con, err = d.DialContext(ctx, network, raddr)
      if err == nil {
      return con, nil
      }
      if reuseErrShouldRetry(err) && ctx.Err() == nil {
      // We could have an existing socket open or we could have one
      // stuck in TIME-WAIT.
      log.Debugf("failed to reuse port, will try again with a random port: %s", err)
      con, err = fallbackDialer.DialContext(ctx, network, raddr)
      }
      return con, err
      }
      reuseport_plan9.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "net"
      "os"
      )
      const (
      EADDRINUSE = "address in use"
      ECONNREFUSED = "connection refused"
      )
      // reuseErrShouldRetry diagnoses whether to retry after a reuse error.
      // if we failed to bind, we should retry. if bind worked and this is a
      // real dial error (remote end didnt answer) then we should not retry.
      func reuseErrShouldRetry(err error) bool {
      if err == nil {
      return false // hey, it worked! no need to retry.
      }
      // if it's a network timeout error, it's a legitimate failure.
      if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
      return false
      }
      e, ok := err.(*net.OpError)
      if !ok {
      return true
      }
      e1, ok := e.Err.(*os.PathError)
      if !ok {
      return true
      }
      switch e1.Err.Error() {
      case EADDRINUSE:
      return true
      case ECONNREFUSED:
      return false
      default:
      return true // optimistically default to retry.
      }
      }
      reuseport_posix.go 0 → 100644
      View file @ 632944ba
      // +build !plan9
      package tcpreuse
      import (
      "net"
      "syscall"
      )
      // reuseErrShouldRetry diagnoses whether to retry after a reuse error.
      // if we failed to bind, we should retry. if bind worked and this is a
      // real dial error (remote end didnt answer) then we should not retry.
      func reuseErrShouldRetry(err error) bool {
      if err == nil {
      return false // hey, it worked! no need to retry.
      }
      // if it's a network timeout error, it's a legitimate failure.
      if nerr, ok := err.(net.Error); ok && nerr.Timeout() {
      return false
      }
      errno, ok := err.(syscall.Errno)
      if !ok { // not an errno? who knows what this is. retry.
      return true
      }
      switch errno {
      case syscall.EADDRINUSE, syscall.EADDRNOTAVAIL:
      return true // failure to bind. retry.
      case syscall.ECONNREFUSED:
      return false // real dial error
      default:
      return true // optimistically default to retry.
      }
      }
      reuseport_test.go 0 → 100644
      View file @ 632944ba
      // +build !plan9
      package tcpreuse
      import (
      "net"
      "syscall"
      "testing"
      )
      type netTimeoutErr struct {
      timeout bool
      }
      func (e netTimeoutErr) Error() string {
      return ""
      }
      func (e netTimeoutErr) Timeout() bool {
      return e.timeout
      }
      func (e netTimeoutErr) Temporary() bool {
      panic("not checked")
      }
      func TestReuseError(t *testing.T) {
      var nte1 net.Error = &netTimeoutErr{true}
      var nte2 net.Error = &netTimeoutErr{false}
      cases := map[error]bool{
      nil: false,
      syscall.EADDRINUSE: true,
      syscall.EADDRNOTAVAIL: true,
      syscall.ECONNREFUSED: false,
      nte1: false,
      nte2: true, // this ones a little weird... we should check neterror.Temporary() too
      // test 'default' to true
      syscall.EBUSY: true,
      }
      for k, v := range cases {
      if reuseErrShouldRetry(k) != v {
      t.Fatalf("expected %t for %#v", v, k)
      }
      }
      }
      singledialer.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "context"
      "net"
      )
      type singleDialer net.TCPAddr
      func (d *singleDialer) Dial(network, address string) (net.Conn, error) {
      return d.DialContext(context.Background(), network, address)
      }
      func (d *singleDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
      return reuseDial(ctx, (*net.TCPAddr)(d), network, address)
      }
      transport.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "errors"
      "sync"
      logging "gitlab.dms3.io/dms3/public/go-log"
      )
      var log = logging.Logger("reuseport-transport")
      // ErrWrongProto is returned when dialing a protocol other than tcp.
      var ErrWrongProto = errors.New("can only dial TCP over IPv4 or IPv6")
      // Transport is a TCP reuse transport that reuses listener ports.
      type Transport struct {
      v4 network
      v6 network
      }
      type network struct {
      mu sync.RWMutex
      listeners map[*listener]struct{}
      dialer dialer
      }
      transport_test.go 0 → 100644
      View file @ 632944ba
      package tcpreuse
      import (
      "net"
      "testing"
      ma "github.com/multiformats/go-multiaddr"
      manet "github.com/multiformats/go-multiaddr/net"
      )
      var loopbackV4, _ = ma.NewMultiaddr("/ip4/127.0.0.1/tcp/0")
      var loopbackV6, _ = ma.NewMultiaddr("/ip6/::1/tcp/0")
      var unspecV6, _ = ma.NewMultiaddr("/ip6/::/tcp/0")
      var unspecV4, _ = ma.NewMultiaddr("/ip4/0.0.0.0/tcp/0")
      var globalV4 ma.Multiaddr
      var globalV6 ma.Multiaddr
      func init() {
      addrs, err := manet.InterfaceMultiaddrs()
      if err != nil {
      return
      }
      for _, addr := range addrs {
      if !manet.IsIP6LinkLocal(addr) && !manet.IsIPLoopback(addr) {
      tcp, _ := ma.NewMultiaddr("/tcp/0")
      switch addr.Protocols()[0].Code {
      case ma.P_IP4:
      if globalV4 == nil {
      globalV4 = addr.Encapsulate(tcp)
      }
      case ma.P_IP6:
      if globalV6 == nil {
      globalV6 = addr.Encapsulate(tcp)
      }
      }
      }
      }
      }
      func acceptOne(t *testing.T, listener manet.Listener) <-chan interface{} {
      t.Helper()
      done := make(chan interface{}, 1)
      go func() {
      defer close(done)
      done <- nil
      c, err := listener.Accept()
      if err != nil {
      t.Error(err)
      return
      }
      c.Close()
      }()
      <-done
      return done
      }
      func dialOne(t *testing.T, tr *Transport, listener manet.Listener, expected ...int) int {
      t.Helper()
      done := acceptOne(t, listener)
      c, err := tr.Dial(listener.Multiaddr())
      if err != nil {
      t.Fatal(err)
      }
      port := c.LocalAddr().(*net.TCPAddr).Port
      <-done
      c.Close()
      if len(expected) == 0 {
      return port
      }
      for _, p := range expected {
      if p == port {
      return port
      }
      }
      t.Errorf("dialed %s from %v. expected to dial from port %v", listener.Multiaddr(), c.LocalAddr(), expected)
      return 0
      }
      func TestNoneAndSingle(t *testing.T) {
      var trA Transport
      var trB Transport
      listenerA, err := trA.Listen(loopbackV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerA.Close()
      dialOne(t, &trB, listenerA)
      listenerB, err := trB.Listen(loopbackV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB.Close()
      dialOne(t, &trB, listenerA, listenerB.Addr().(*net.TCPAddr).Port)
      }
      func TestTwoLocal(t *testing.T) {
      var trA Transport
      var trB Transport
      listenerA, err := trA.Listen(loopbackV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerA.Close()
      listenerB1, err := trB.Listen(loopbackV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB1.Close()
      listenerB2, err := trB.Listen(loopbackV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB2.Close()
      dialOne(t, &trB, listenerA,
      listenerB1.Addr().(*net.TCPAddr).Port,
      listenerB2.Addr().(*net.TCPAddr).Port)
      }
      func TestGlobalPreferenceV4(t *testing.T) {
      if globalV4 == nil {
      t.Skip("no global IPv4 addresses configured")
      return
      }
      t.Logf("when listening on %v, should prefer %v over %v", loopbackV4, loopbackV4, globalV4)
      testPrefer(t, loopbackV4, loopbackV4, globalV4)
      t.Logf("when listening on %v, should prefer %v over %v", loopbackV4, unspecV4, globalV4)
      testPrefer(t, loopbackV4, unspecV4, globalV4)
      t.Logf("when listening on %v, should prefer %v over %v", globalV4, unspecV4, loopbackV4)
      testPrefer(t, globalV4, unspecV4, loopbackV4)
      }
      func TestGlobalPreferenceV6(t *testing.T) {
      if globalV6 == nil {
      t.Skip("no global IPv6 addresses configured")
      return
      }
      testPrefer(t, loopbackV6, loopbackV6, globalV6)
      testPrefer(t, loopbackV6, unspecV6, globalV6)
      testPrefer(t, globalV6, unspecV6, loopbackV6)
      }
      func TestLoopbackPreference(t *testing.T) {
      testPrefer(t, loopbackV4, loopbackV4, unspecV4)
      testPrefer(t, loopbackV6, loopbackV6, unspecV6)
      }
      func testPrefer(t *testing.T, listen, prefer, avoid ma.Multiaddr) {
      var trA Transport
      var trB Transport
      listenerA, err := trA.Listen(listen)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerA.Close()
      listenerB1, err := trB.Listen(avoid)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB1.Close()
      dialOne(t, &trB, listenerA, listenerB1.Addr().(*net.TCPAddr).Port)
      listenerB2, err := trB.Listen(prefer)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB2.Close()
      dialOne(t, &trB, listenerA, listenerB2.Addr().(*net.TCPAddr).Port)
      // Closing the listener should reset the dialer.
      listenerB2.Close()
      dialOne(t, &trB, listenerA, listenerB1.Addr().(*net.TCPAddr).Port)
      }
      func TestV6V4(t *testing.T) {
      testUseFirst(t, loopbackV4, loopbackV4, loopbackV6)
      testUseFirst(t, loopbackV6, loopbackV6, loopbackV4)
      }
      func TestGlobalToGlobal(t *testing.T) {
      if globalV4 == nil {
      t.Skip("no globalV4 addresses configured")
      return
      }
      testUseFirst(t, globalV4, globalV4, loopbackV4)
      testUseFirst(t, globalV6, globalV6, loopbackV6)
      }
      func testUseFirst(t *testing.T, listen, use, never ma.Multiaddr) {
      var trA Transport
      var trB Transport
      listenerA, err := trA.Listen(globalV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerA.Close()
      listenerB1, err := trB.Listen(loopbackV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB1.Close()
      // It works (random port)
      dialOne(t, &trB, listenerA)
      listenerB2, err := trB.Listen(globalV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB2.Close()
      // Uses globalV4 port.
      dialOne(t, &trB, listenerA, listenerB2.Addr().(*net.TCPAddr).Port)
      // Closing the listener should reset the dialer.
      listenerB2.Close()
      // It still works.
      dialOne(t, &trB, listenerA)
      }
      func TestDuplicateGlobal(t *testing.T) {
      if globalV4 == nil {
      t.Skip("no globalV4 addresses configured")
      return
      }
      var trA Transport
      var trB Transport
      listenerA, err := trA.Listen(globalV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerA.Close()
      listenerB1, err := trB.Listen(globalV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB1.Close()
      listenerB2, err := trB.Listen(globalV4)
      if err != nil {
      t.Fatal(err)
      }
      defer listenerB2.Close()
      // Check which port we're using
      port := dialOne(t, &trB, listenerA)
      // Check consistency
      for i := 0; i < 10; i++ {
      dialOne(t, &trB, listenerA, port)
      }
      }
      Markdown is supported
      0% or .
      You are about to add 0 people to the discussion. Proceed with caution.
      Finish editing this message first!
      Please register or to comment