TEST: Upgrade pion to v3.2.9. (#3567)

------

Co-authored-by: chundonglinlin <chundonglinlin@163.com>

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/.gitignore

@@ -1,2 +1,25 @@
-# vim temporary files
+### JetBrains IDE ###
+#####################
+.idea/
+
+### Emacs Temporary Files ###
+#############################
+*~
+
+### Folders ###
+###############
+bin/
+vendor/
+node_modules/
+
+### Files ###
+#############
+*.ivf
+*.ogg
+tags
+cover.out
 *.sw[poe]
+*.wasm
+examples/sfu-ws/cert.pem
+examples/sfu-ws/key.pem
+wasm_exec.js

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/.golangci.yml

@@ -3,6 +3,117 @@ linters-settings:
     check-shadowing: true
   misspell:
     locale: US
+  exhaustive:
+    default-signifies-exhaustive: true
+  gomodguard:
+    blocked:
+      modules:
+        - github.com/pkg/errors:
+            recommendations:
+            - errors
+
+linters:
+  enable:
+    - asciicheck       # Simple linter to check that your code does not contain non-ASCII identifiers
+    - bidichk          # Checks for dangerous unicode character sequences
+    - bodyclose        # checks whether HTTP response body is closed successfully
+    - contextcheck     # check the function whether use a non-inherited context
+    - deadcode         # Finds unused code
+    - decorder         # check declaration order and count of types, constants, variables and functions
+    - depguard         # Go linter that checks if package imports are in a list of acceptable packages
+    - dogsled          # Checks assignments with too many blank identifiers (e.g. x, _, _, _, := f())
+    - dupl             # Tool for code clone detection
+    - durationcheck    # check for two durations multiplied together
+    - errcheck         # Errcheck is a program for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases
+    - errchkjson       # Checks types passed to the json encoding functions. Reports unsupported types and optionally reports occations, where the check for the returned error can be omitted.
+    - errname          # Checks that sentinel errors are prefixed with the `Err` and error types are suffixed with the `Error`.
+    - errorlint        # errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13.
+    - exhaustive       # check exhaustiveness of enum switch statements
+    - exportloopref    # checks for pointers to enclosing loop variables
+    - forcetypeassert  # finds forced type assertions
+    - gci              # Gci control golang package import order and make it always deterministic.
+    - gochecknoglobals # Checks that no globals are present in Go code
+    - gochecknoinits   # Checks that no init functions are present in Go code
+    - gocognit         # Computes and checks the cognitive complexity of functions
+    - goconst          # Finds repeated strings that could be replaced by a constant
+    - gocritic         # The most opinionated Go source code linter
+    - godox            # Tool for detection of FIXME, TODO and other comment keywords
+    - goerr113         # Golang linter to check the errors handling expressions
+    - gofmt            # Gofmt checks whether code was gofmt-ed. By default this tool runs with -s option to check for code simplification
+    - gofumpt          # Gofumpt checks whether code was gofumpt-ed.
+    - goheader         # Checks is file header matches to pattern
+    - goimports        # Goimports does everything that gofmt does. Additionally it checks unused imports
+    - gomoddirectives  # Manage the use of 'replace', 'retract', and 'excludes' directives in go.mod.
+    - gomodguard       # Allow and block list linter for direct Go module dependencies. This is different from depguard where there are different block types for example version constraints and module recommendations.
+    - goprintffuncname # Checks that printf-like functions are named with `f` at the end
+    - gosec            # Inspects source code for security problems
+    - gosimple         # Linter for Go source code that specializes in simplifying a code
+    - govet            # Vet examines Go source code and reports suspicious constructs, such as Printf calls whose arguments do not align with the format string
+    - grouper          # An analyzer to analyze expression groups.
+    - importas         # Enforces consistent import aliases
+    - ineffassign      # Detects when assignments to existing variables are not used
+    - misspell         # Finds commonly misspelled English words in comments
+    - nakedret         # Finds naked returns in functions greater than a specified function length
+    - nilerr           # Finds the code that returns nil even if it checks that the error is not nil.
+    - nilnil           # Checks that there is no simultaneous return of `nil` error and an invalid value.
+    - noctx            # noctx finds sending http request without context.Context
+    - predeclared      # find code that shadows one of Go's predeclared identifiers
+    - revive           # golint replacement, finds style mistakes
+    - staticcheck      # Staticcheck is a go vet on steroids, applying a ton of static analysis checks
+    - structcheck      # Finds unused struct fields
+    - stylecheck       # Stylecheck is a replacement for golint
+    - tagliatelle      # Checks the struct tags.
+    - tenv             # tenv is analyzer that detects using os.Setenv instead of t.Setenv since Go1.17
+    - tparallel        # tparallel detects inappropriate usage of t.Parallel() method in your Go test codes
+    - typecheck        # Like the front-end of a Go compiler, parses and type-checks Go code
+    - unconvert        # Remove unnecessary type conversions
+    - unparam          # Reports unused function parameters
+    - unused           # Checks Go code for unused constants, variables, functions and types
+    - varcheck         # Finds unused global variables and constants
+    - wastedassign     # wastedassign finds wasted assignment statements
+    - whitespace       # Tool for detection of leading and trailing whitespace
+  disable:
+    - containedctx     # containedctx is a linter that detects struct contained context.Context field
+    - cyclop           # checks function and package cyclomatic complexity
+    - exhaustivestruct # Checks if all struct's fields are initialized
+    - forbidigo        # Forbids identifiers
+    - funlen           # Tool for detection of long functions
+    - gocyclo          # Computes and checks the cyclomatic complexity of functions
+    - godot            # Check if comments end in a period
+    - gomnd            # An analyzer to detect magic numbers.
+    - ifshort          # Checks that your code uses short syntax for if-statements whenever possible
+    - ireturn          # Accept Interfaces, Return Concrete Types
+    - lll              # Reports long lines
+    - maintidx         # maintidx measures the maintainability index of each function.
+    - makezero         # Finds slice declarations with non-zero initial length
+    - maligned         # Tool to detect Go structs that would take less memory if their fields were sorted
+    - nestif           # Reports deeply nested if statements
+    - nlreturn         # nlreturn checks for a new line before return and branch statements to increase code clarity
+    - nolintlint       # Reports ill-formed or insufficient nolint directives
+    - paralleltest     # paralleltest detects missing usage of t.Parallel() method in your Go test
+    - prealloc         # Finds slice declarations that could potentially be preallocated
+    - promlinter       # Check Prometheus metrics naming via promlint
+    - rowserrcheck     # checks whether Err of rows is checked successfully
+    - sqlclosecheck    # Checks that sql.Rows and sql.Stmt are closed.
+    - testpackage      # linter that makes you use a separate _test package
+    - thelper          # thelper detects golang test helpers without t.Helper() call and checks the consistency of test helpers
+    - varnamelen       # checks that the length of a variable's name matches its scope
+    - wrapcheck        # Checks that errors returned from external packages are wrapped
+    - wsl              # Whitespace Linter - Forces you to use empty lines!
+
+issues:
+  exclude-use-default: false
+  exclude-rules:
+    # Allow complex tests, better to be self contained
+    - path: _test\.go
+      linters:
+        - gocognit
+
+    # Allow complex main function in examples
+    - path: examples
+      text: "of func `main` is high"
+      linters:
+        - gocognit
 
 run:
   skip-dirs-use-default: false

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/AUTHORS.txt

@@ -0,0 +1,17 @@
+# Thank you to everyone that made Pion possible. If you are interested in contributing
+# we would love to have you https://github.com/pion/webrtc/wiki/Contributing
+#
+# This file is auto generated, using git to list all individuals contributors.
+# see `.github/generate-authors.sh` for the scripting
+Atsushi Watanabe <atsushi.w@ieee.org>
+backkem <mail@backkem.me>
+Benny Daon <benny@tuzig.com>
+Chinmay Kousik <chinmaykousik1@gmail.com>
+Eric Daniels <eric@erdaniels.com>
+Hugo Arregui <hugo.arregui@gmail.com>
+Hugo Arregui <hugo@decentraland.org>
+John Bradley <jrb@turrettech.com>
+Norman Rasmussen <norman@rasmussen.co.za>
+Sean DuBois <seaduboi@amazon.com>
+Sean DuBois <sean@siobud.com>
+Yutaka Takeda <yt0916@gmail.com>

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/README.md

@@ -33,13 +33,5 @@ If you need commercial support or don't want to use public methods you can conta
 ### Contributing
 Check out the **[contributing wiki](https://github.com/pion/webrtc/wiki/Contributing)** to join the group of amazing people making this project possible:
 
-* [John Bradley](https://github.com/kc5nra) - *Original Author*
-* [Sean DuBois](https://github.com/Sean-Der) - *Original Author*
-* [Michiel De Backker](https://github.com/backkem) - *Public API*
-* [Yutaka Takeda](https://github.com/enobufs) - *PR-SCTP*
-* [Hugo Arregui](https://github.com/hugoArregui)
-* [Atsushi Watanabe](https://github.com/at-wat)
-* [Norman Rasmussen](https://github.com/normanr) - *Fix Empty DataChannel messages*
-
 ### License
 MIT License - see [LICENSE](LICENSE) for full text

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/datachannel.go

@@ -2,13 +2,15 @@
 package datachannel
 
 import (
+	"errors"
 	"fmt"
 	"io"
+	"sync"
 	"sync/atomic"
+	"time"
 
 	"github.com/pion/logging"
 	"github.com/pion/sctp"
-	"github.com/pkg/errors"
 )
 
 const receiveMTU = 8192
@@ -19,6 +21,11 @@ type Reader interface {
 	ReadDataChannel([]byte) (int, bool, error)
 }
 
+// ReadDeadliner extends an io.Reader to expose setting a read deadline.
+type ReadDeadliner interface {
+	SetReadDeadline(time.Time) error
+}
+
 // Writer is an extended io.Writer
 // that also allows indicating if a message is text.
 type Writer interface {
@@ -45,6 +52,10 @@ type DataChannel struct {
 	bytesSent        uint64
 	bytesReceived    uint64
 
+	mu                      sync.Mutex
+	onOpenCompleteHandler   func()
+	openCompleteHandlerOnce sync.Once
+
 	stream *sctp.Stream
 	log    logging.LeveledLogger
 }
@@ -97,22 +108,28 @@ func Client(stream *sctp.Stream, config *Config) (*DataChannel, error) {
 	if !config.Negotiated {
 		rawMsg, err := msg.Marshal()
 		if err != nil {
-			return nil, fmt.Errorf("failed to marshal ChannelOpen %v", err)
+			return nil, fmt.Errorf("failed to marshal ChannelOpen %w", err)
 		}
 
 		if _, err = stream.WriteSCTP(rawMsg, sctp.PayloadTypeWebRTCDCEP); err != nil {
-			return nil, fmt.Errorf("failed to send ChannelOpen %v", err)
+			return nil, fmt.Errorf("failed to send ChannelOpen %w", err)
 		}
 	}
 	return newDataChannel(stream, config)
 }
 
 // Accept is used to accept incoming data channels over SCTP
-func Accept(a *sctp.Association, config *Config) (*DataChannel, error) {
+func Accept(a *sctp.Association, config *Config, existingChannels ...*DataChannel) (*DataChannel, error) {
 	stream, err := a.AcceptStream()
 	if err != nil {
 		return nil, err
 	}
+	for _, ch := range existingChannels {
+		if ch.StreamIdentifier() == stream.StreamIdentifier() {
+			ch.stream.SetDefaultPayloadType(sctp.PayloadTypeWebRTCBinary)
+			return ch, nil
+		}
+	}
 
 	stream.SetDefaultPayloadType(sctp.PayloadTypeWebRTCBinary)
 
@@ -126,19 +143,19 @@ func Accept(a *sctp.Association, config *Config) (*DataChannel, error) {
 
 // Server accepts a data channel over an SCTP stream
 func Server(stream *sctp.Stream, config *Config) (*DataChannel, error) {
-	buffer := make([]byte, receiveMTU) // TODO: Can probably be smaller
+	buffer := make([]byte, receiveMTU)
 	n, ppi, err := stream.ReadSCTP(buffer)
 	if err != nil {
 		return nil, err
 	}
 
 	if ppi != sctp.PayloadTypeWebRTCDCEP {
-		return nil, fmt.Errorf("unexpected packet type: %s", ppi)
+		return nil, fmt.Errorf("%w %s", ErrInvalidPayloadProtocolIdentifier, ppi)
 	}
 
 	openMsg, err := parseExpectDataChannelOpen(buffer[:n])
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to parse DataChannelOpen packet")
+		return nil, fmt.Errorf("failed to parse DataChannelOpen packet %w", err)
 	}
 
 	config.ChannelType = openMsg.ChannelType
@@ -174,11 +191,10 @@ func (c *DataChannel) Read(p []byte) (int, error) {
 func (c *DataChannel) ReadDataChannel(p []byte) (int, bool, error) {
 	for {
 		n, ppi, err := c.stream.ReadSCTP(p)
-		if err == io.EOF {
+		if errors.Is(err, io.EOF) {
 			// When the peer sees that an incoming stream was
 			// reset, it also resets its corresponding outgoing stream.
-			closeErr := c.stream.Close()
-			if closeErr != nil {
+			if closeErr := c.stream.Close(); closeErr != nil {
 				return 0, false, closeErr
 			}
 		}
@@ -186,30 +202,28 @@ func (c *DataChannel) ReadDataChannel(p []byte) (int, bool, error) {
 			return 0, false, err
 		}
 
-		var isString bool
-		switch ppi {
-		case sctp.PayloadTypeWebRTCDCEP:
-			err = c.handleDCEP(p[:n])
-			if err != nil {
+		if ppi == sctp.PayloadTypeWebRTCDCEP {
+			if err = c.handleDCEP(p[:n]); err != nil {
 				c.log.Errorf("Failed to handle DCEP: %s", err.Error())
-				continue
 			}
 			continue
-		case sctp.PayloadTypeWebRTCString, sctp.PayloadTypeWebRTCStringEmpty:
-			isString = true
-		}
-		switch ppi {
-		case sctp.PayloadTypeWebRTCBinaryEmpty, sctp.PayloadTypeWebRTCStringEmpty:
+		} else if ppi == sctp.PayloadTypeWebRTCBinaryEmpty || ppi == sctp.PayloadTypeWebRTCStringEmpty {
 			n = 0
 		}
 
 		atomic.AddUint32(&c.messagesReceived, 1)
 		atomic.AddUint64(&c.bytesReceived, uint64(n))
 
+		isString := ppi == sctp.PayloadTypeWebRTCString || ppi == sctp.PayloadTypeWebRTCStringEmpty
 		return n, isString, err
 	}
 }
 
+// SetReadDeadline sets a deadline for reads to return
+func (c *DataChannel) SetReadDeadline(t time.Time) error {
+	return c.stream.SetReadDeadline(t)
+}
+
 // MessagesSent returns the number of messages sent
 func (c *DataChannel) MessagesSent() uint32 {
 	return atomic.LoadUint32(&c.messagesSent)
@@ -220,6 +234,29 @@ func (c *DataChannel) MessagesReceived() uint32 {
 	return atomic.LoadUint32(&c.messagesReceived)
 }
 
+// OnOpen sets an event handler which is invoked when
+// a DATA_CHANNEL_ACK message is received.
+// The handler is called only on thefor the channel opened
+// https://datatracker.ietf.org/doc/html/draft-ietf-rtcweb-data-protocol-09#section-5.2
+func (c *DataChannel) OnOpen(f func()) {
+	c.mu.Lock()
+	c.openCompleteHandlerOnce = sync.Once{}
+	c.onOpenCompleteHandler = f
+	c.mu.Unlock()
+}
+
+func (c *DataChannel) onOpenComplete() {
+	c.mu.Lock()
+	hdlr := c.onOpenCompleteHandler
+	c.mu.Unlock()
+
+	if hdlr != nil {
+		go c.openCompleteHandlerOnce.Do(func() {
+			hdlr()
+		})
+	}
+}
+
 // BytesSent returns the number of bytes sent
 func (c *DataChannel) BytesSent() uint64 {
 	return atomic.LoadUint64(&c.bytesSent)
@@ -238,29 +275,18 @@ func (c *DataChannel) StreamIdentifier() uint16 {
 func (c *DataChannel) handleDCEP(data []byte) error {
 	msg, err := parse(data)
 	if err != nil {
-		return errors.Wrap(err, "Failed to parse DataChannel packet")
+		return fmt.Errorf("failed to parse DataChannel packet %w", err)
 	}
 
 	switch msg := msg.(type) {
-	case *channelOpen:
-		c.log.Debug("Received DATA_CHANNEL_OPEN")
-		err = c.writeDataChannelAck()
-		if err != nil {
-			return fmt.Errorf("failed to ACK channel open: %v", err)
-		}
-		// Note: DATA_CHANNEL_OPEN message is handled inside Server() method.
-		// Therefore, the message will not reach here.
-
 	case *channelAck:
 		c.log.Debug("Received DATA_CHANNEL_ACK")
-		err = c.commitReliabilityParams()
-		if err != nil {
+		if err = c.commitReliabilityParams(); err != nil {
 			return err
 		}
-		// TODO: handle ChannelAck (https://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-09#section-5.2)
-
+		c.onOpenComplete()
 	default:
-		return fmt.Errorf("unhandled DataChannel message %v", msg)
+		return fmt.Errorf("%w %v", ErrInvalidMessageType, msg)
 	}
 
 	return nil
@@ -306,12 +332,11 @@ func (c *DataChannel) writeDataChannelAck() error {
 	ack := channelAck{}
 	ackMsg, err := ack.Marshal()
 	if err != nil {
-		return fmt.Errorf("failed to marshal ChannelOpen ACK: %v", err)
+		return fmt.Errorf("failed to marshal ChannelOpen ACK: %w", err)
 	}
 
-	_, err = c.stream.WriteSCTP(ackMsg, sctp.PayloadTypeWebRTCDCEP)
-	if err != nil {
-		return fmt.Errorf("failed to send ChannelOpen ACK: %v", err)
+	if _, err = c.stream.WriteSCTP(ackMsg, sctp.PayloadTypeWebRTCDCEP); err != nil {
+		return fmt.Errorf("failed to send ChannelOpen ACK: %w", err)
 	}
 
 	return err
@@ -372,7 +397,7 @@ func (c *DataChannel) commitReliabilityParams() error {
 	case ChannelTypePartialReliableTimedUnordered:
 		c.stream.SetReliabilityParams(true, sctp.ReliabilityTypeTimed, c.Config.ReliabilityParameter)
 	default:
-		return fmt.Errorf("invalid ChannelType: %v ", c.Config.ChannelType)
+		return fmt.Errorf("%w %v", ErrInvalidChannelType, c.Config.ChannelType)
 	}
 	return nil
 }

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/errors.go

@@ -0,0 +1,24 @@
+package datachannel
+
+import "errors"
+
+var (
+	// ErrDataChannelMessageTooShort means that the data isn't long enough to be a valid DataChannel message
+	ErrDataChannelMessageTooShort = errors.New("DataChannel message is not long enough to determine type")
+
+	// ErrInvalidPayloadProtocolIdentifier means that we got a DataChannel messages with a Payload Protocol Identifier
+	// we don't know how to handle
+	ErrInvalidPayloadProtocolIdentifier = errors.New("DataChannel message Payload Protocol Identifier is value we can't handle")
+
+	// ErrInvalidChannelType means that the remote requested a channel type that we don't support
+	ErrInvalidChannelType = errors.New("invalid Channel Type")
+
+	// ErrInvalidMessageType is returned when a DataChannel Message has a type we don't support
+	ErrInvalidMessageType = errors.New("invalid Message Type")
+
+	// ErrExpectedAndActualLengthMismatch is when the declared length and actual length don't match
+	ErrExpectedAndActualLengthMismatch = errors.New("expected and actual length do not match")
+
+	// ErrUnexpectedDataChannelType is when a message type does not match the expected type
+	ErrUnexpectedDataChannelType = errors.New("expected and actual message type does not match")
+)

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/go.mod

@@ -1,11 +0,0 @@
-module github.com/pion/datachannel
-
-require (
-	github.com/pion/logging v0.2.2
-	github.com/pion/sctp v1.7.10
-	github.com/pion/transport v0.10.1
-	github.com/pkg/errors v0.9.1
-	github.com/stretchr/testify v1.6.1
-)
-
-go 1.13

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/go.sum

@@ -1,38 +0,0 @@
-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/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/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/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
-github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/sctp v1.7.10 h1:o3p3/hZB5Cx12RMGyWmItevJtZ6o2cpuxaw6GOS4x+8=
-github.com/pion/sctp v1.7.10/go.mod h1:EhpTUQu1/lcK3xI+eriS6/96fWetHGCvBi9MSsnaBN0=
-github.com/pion/transport v0.10.1 h1:2W+yJT+0mOQ160ThZYUx5Zp2skzshiNgxrNE9GUfhJM=
-github.com/pion/transport v0.10.1/go.mod h1:PBis1stIILMiis0PewDw91WJeLJkyIMcEk+DwKOzf4A=
-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/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/message.go

@@ -2,8 +2,6 @@ package datachannel
 
 import (
 	"fmt"
-
-	"github.com/pkg/errors"
 )
 
 // message is a parsed DataChannel message
@@ -35,7 +33,7 @@ func (t messageType) String() string {
 // parse accepts raw input and returns a DataChannel message
 func parse(raw []byte) (message, error) {
 	if len(raw) == 0 {
-		return nil, errors.Errorf("DataChannel message is not long enough to determine type ")
+		return nil, ErrDataChannelMessageTooShort
 	}
 
 	var msg message
@@ -45,7 +43,7 @@ func parse(raw []byte) (message, error) {
 	case dataChannelAck:
 		msg = &channelAck{}
 	default:
-		return nil, errors.Errorf("Unknown MessageType %v", messageType(raw[0]))
+		return nil, fmt.Errorf("%w %v", ErrInvalidMessageType, messageType(raw[0]))
 	}
 
 	if err := msg.Unmarshal(raw); err != nil {
@@ -59,11 +57,11 @@ func parse(raw []byte) (message, error) {
 // or throws an error
 func parseExpectDataChannelOpen(raw []byte) (*channelOpen, error) {
 	if len(raw) == 0 {
-		return nil, errors.Errorf("the DataChannel message is not long enough to determine type")
+		return nil, ErrDataChannelMessageTooShort
 	}
 
 	if actualTyp := messageType(raw[0]); actualTyp != dataChannelOpen {
-		return nil, errors.Errorf("expected DataChannelOpen but got %s", actualTyp)
+		return nil, fmt.Errorf("%w expected(%s) actual(%s)", ErrUnexpectedDataChannelType, actualTyp, dataChannelOpen)
 	}
 
 	msg := &channelOpen{}
@@ -73,22 +71,3 @@ func parseExpectDataChannelOpen(raw []byte) (*channelOpen, error) {
 
 	return msg, nil
 }
-
-// parseExpectDataChannelAck parses a DataChannelAck message
-// or throws an error
-// func parseExpectDataChannelAck(raw []byte) (*channelAck, error) {
-// 	if len(raw) == 0 {
-// 		return nil, errors.Errorf("the DataChannel message is not long enough to determine type")
-// 	}
-//
-// 	if actualTyp := messageType(raw[0]); actualTyp != dataChannelAck {
-// 		return nil, errors.Errorf("expected DataChannelAck but got %s", actualTyp)
-// 	}
-//
-// 	msg := &channelAck{}
-// 	if err := msg.Unmarshal(raw); err != nil {
-// 		return nil, err
-// 	}
-//
-// 	return msg, nil
-// }

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/message_channel_open.go

@@ -2,15 +2,15 @@ package datachannel
 
 import (
 	"encoding/binary"
-
-	"github.com/pkg/errors"
+	"fmt"
 )
 
 /*
 channelOpen represents a DATA_CHANNEL_OPEN Message
 
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+	0                   1                   2                   3
+	0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 |  Message Type |  Channel Type |            Priority           |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -104,7 +104,7 @@ func (c *channelOpen) Marshal() ([]byte, error) {
 // Unmarshal populates the struct with the given raw data
 func (c *channelOpen) Unmarshal(raw []byte) error {
 	if len(raw) < channelOpenHeaderLength {
-		return errors.Errorf("Length of input is not long enough to satisfy header %d", len(raw))
+		return fmt.Errorf("%w expected(%d) actual(%d)", ErrExpectedAndActualLengthMismatch, channelOpenHeaderLength, len(raw))
 	}
 	c.ChannelType = ChannelType(raw[1])
 	c.Priority = binary.BigEndian.Uint16(raw[2:])
@@ -113,8 +113,8 @@ func (c *channelOpen) Unmarshal(raw []byte) error {
 	labelLength := binary.BigEndian.Uint16(raw[8:])
 	protocolLength := binary.BigEndian.Uint16(raw[10:])
 
-	if len(raw) != int(channelOpenHeaderLength+labelLength+protocolLength) {
-		return errors.Errorf("Label + Protocol length don't match full packet length")
+	if expectedLen := int(channelOpenHeaderLength + labelLength + protocolLength); len(raw) != expectedLen {
+		return fmt.Errorf("%w expected(%d) actual(%d)", ErrExpectedAndActualLengthMismatch, expectedLen, len(raw))
 	}
 
 	c.Label = raw[channelOpenHeaderLength : channelOpenHeaderLength+labelLength]

trunk/3rdparty/srs-bench/vendor/github.com/pion/datachannel/renovate.json

@@ -1,15 +1,27 @@
 {
   "extends": [
-    "config:base"
+    "config:base",
+    ":disableDependencyDashboard"
   ],
   "postUpdateOptions": [
     "gomodTidy"
   ],
   "commitBody": "Generated by renovateBot",
   "packageRules": [
+    {
+      "matchUpdateTypes": ["minor", "patch", "pin", "digest"],
+      "automerge": true
+    },
     {
       "packagePatterns": ["^golang.org/x/"],
       "schedule": ["on the first day of the month"]
     }
+  ],
+  "ignorePaths": [
+    ".github/workflows/generate-authors.yml",
+    ".github/workflows/lint.yaml",
+    ".github/workflows/renovate-go-mod-fix.yaml",
+    ".github/workflows/test.yaml",
+    ".github/workflows/tidy-check.yaml"
   ]
 }