pax_global_header00006660000000000000000000000064147257524420014526gustar00rootroot0000000000000052 comment=687754f965a2cda0420848905505ec11bedc25b6 datachannel-1.5.10/000077500000000000000000000000001472575244200140545ustar00rootroot00000000000000datachannel-1.5.10/.github/000077500000000000000000000000001472575244200154145ustar00rootroot00000000000000datachannel-1.5.10/.github/.gitignore000066400000000000000000000001561472575244200174060ustar00rootroot00000000000000# SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT .goassets datachannel-1.5.10/.github/fetch-scripts.sh000077500000000000000000000016001472575244200205260ustar00rootroot00000000000000#!/bin/sh # # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT set -eu SCRIPT_PATH="$(realpath "$(dirname "$0")")" GOASSETS_PATH="${SCRIPT_PATH}/.goassets" GOASSETS_REF=${GOASSETS_REF:-master} if [ -d "${GOASSETS_PATH}" ]; then if ! git -C "${GOASSETS_PATH}" diff --exit-code; then echo "${GOASSETS_PATH} has uncommitted changes" >&2 exit 1 fi git -C "${GOASSETS_PATH}" fetch origin git -C "${GOASSETS_PATH}" checkout ${GOASSETS_REF} git -C "${GOASSETS_PATH}" reset --hard origin/${GOASSETS_REF} else git clone -b ${GOASSETS_REF} https://github.com/pion/.goassets.git "${GOASSETS_PATH}" fi datachannel-1.5.10/.github/install-hooks.sh000077500000000000000000000012421472575244200205410ustar00rootroot00000000000000#!/bin/sh # # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT SCRIPT_PATH="$(realpath "$(dirname "$0")")" . ${SCRIPT_PATH}/fetch-scripts.sh cp "${GOASSETS_PATH}/hooks/commit-msg.sh" "${SCRIPT_PATH}/../.git/hooks/commit-msg" cp "${GOASSETS_PATH}/hooks/pre-commit.sh" "${SCRIPT_PATH}/../.git/hooks/pre-commit" cp "${GOASSETS_PATH}/hooks/pre-push.sh" "${SCRIPT_PATH}/../.git/hooks/pre-push" datachannel-1.5.10/.github/workflows/000077500000000000000000000000001472575244200174515ustar00rootroot00000000000000datachannel-1.5.10/.github/workflows/api.yaml000066400000000000000000000011141472575244200211030ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: API on: pull_request: jobs: check: uses: pion/.goassets/.github/workflows/api.reusable.yml@master datachannel-1.5.10/.github/workflows/codeql-analysis.yml000066400000000000000000000013201472575244200232600ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: CodeQL on: workflow_dispatch: schedule: - cron: '23 5 * * 0' pull_request: branches: - master paths: - '**.go' jobs: analyze: uses: pion/.goassets/.github/workflows/codeql-analysis.reusable.yml@master datachannel-1.5.10/.github/workflows/lint.yaml000066400000000000000000000011151472575244200213010ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: Lint on: pull_request: jobs: lint: uses: pion/.goassets/.github/workflows/lint.reusable.yml@master datachannel-1.5.10/.github/workflows/release.yml000066400000000000000000000012501472575244200216120ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: Release on: push: tags: - 'v*' jobs: release: uses: pion/.goassets/.github/workflows/release.reusable.yml@master with: go-version: "1.22" # auto-update/latest-go-version datachannel-1.5.10/.github/workflows/renovate-go-sum-fix.yaml000066400000000000000000000012671472575244200241570ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: Fix go.sum on: push: branches: - renovate/* jobs: fix: uses: pion/.goassets/.github/workflows/renovate-go-sum-fix.reusable.yml@master secrets: token: ${{ secrets.PIONBOT_PRIVATE_KEY }} datachannel-1.5.10/.github/workflows/reuse.yml000066400000000000000000000011511472575244200213150ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: REUSE Compliance Check on: push: pull_request: jobs: lint: uses: pion/.goassets/.github/workflows/reuse.reusable.yml@master datachannel-1.5.10/.github/workflows/test.yaml000066400000000000000000000023271472575244200213200ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: Test on: push: branches: - master pull_request: jobs: test: uses: pion/.goassets/.github/workflows/test.reusable.yml@master strategy: matrix: go: ["1.23", "1.22"] # auto-update/supported-go-version-list fail-fast: false with: go-version: ${{ matrix.go }} secrets: inherit test-i386: uses: pion/.goassets/.github/workflows/test-i386.reusable.yml@master strategy: matrix: go: ["1.23", "1.22"] # auto-update/supported-go-version-list fail-fast: false with: go-version: ${{ matrix.go }} test-wasm: uses: pion/.goassets/.github/workflows/test-wasm.reusable.yml@master with: go-version: "1.23" # auto-update/latest-go-version secrets: inherit datachannel-1.5.10/.github/workflows/tidy-check.yaml000066400000000000000000000013021472575244200223550ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # If this repository should have package specific CI config, # remove the repository name from .goassets/.github/workflows/assets-sync.yml. # # If you want to update the shared CI config, send a PR to # https://github.com/pion/.goassets instead of this repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT name: Go mod tidy on: pull_request: push: branches: - master jobs: tidy: uses: pion/.goassets/.github/workflows/tidy-check.reusable.yml@master with: go-version: "1.22" # auto-update/latest-go-version datachannel-1.5.10/.gitignore000066400000000000000000000006321472575244200160450ustar00rootroot00000000000000# SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT ### 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 datachannel-1.5.10/.golangci.yml000066400000000000000000000173021472575244200164430ustar00rootroot00000000000000# SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT run: timeout: 5m linters-settings: govet: enable: - shadow misspell: locale: US exhaustive: default-signifies-exhaustive: true gomodguard: blocked: modules: - github.com/pkg/errors: recommendations: - errors forbidigo: forbid: - ^fmt.Print(f|ln)?$ - ^log.(Panic|Fatal|Print)(f|ln)?$ - ^os.Exit$ - ^panic$ - ^print(ln)?$ 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 - decorder # check declaration order and count of types, constants, variables and functions - 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 - forbidigo # Forbids identifiers - 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 - err113 # 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 - 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 - 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 - wastedassign # wastedassign finds wasted assignment statements - whitespace # Tool for detection of leading and trailing whitespace disable: - depguard # Go linter that checks if package imports are in a list of acceptable packages - containedctx # containedctx is a linter that detects struct contained context.Context field - cyclop # checks function and package cyclomatic complexity - 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. - 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 - nakedret # Finds naked returns in functions greater than a specified function length - 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-dirs-use-default: false exclude-rules: # Allow complex tests and examples, better to be self contained - path: (examples|main\.go|_test\.go) linters: - forbidigo - gocognit # Allow forbidden identifiers in CLI commands - path: cmd linters: - forbidigo datachannel-1.5.10/.goreleaser.yml000066400000000000000000000001711472575244200170040ustar00rootroot00000000000000# SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT builds: - skip: true datachannel-1.5.10/.reuse/000077500000000000000000000000001472575244200152555ustar00rootroot00000000000000datachannel-1.5.10/.reuse/dep5000066400000000000000000000010621472575244200160340ustar00rootroot00000000000000Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: Pion Source: https://github.com/pion/ Files: README.md DESIGN.md **/README.md AUTHORS.txt renovate.json go.mod go.sum **/go.mod **/go.sum .eslintrc.json package.json examples.json sfu-ws/flutter/.gitignore sfu-ws/flutter/pubspec.yaml c-data-channels/webrtc.h examples/examples.json Copyright: 2023 The Pion community License: MIT Files: testdata/fuzz/* **/testdata/fuzz/* api/*.txt Copyright: 2023 The Pion community License: CC0-1.0 datachannel-1.5.10/LICENSE000066400000000000000000000021051472575244200150570ustar00rootroot00000000000000MIT License Copyright (c) 2023 The Pion community 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. datachannel-1.5.10/LICENSES/000077500000000000000000000000001472575244200152615ustar00rootroot00000000000000datachannel-1.5.10/LICENSES/MIT.txt000066400000000000000000000020661472575244200164570ustar00rootroot00000000000000MIT License Copyright (c) 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. datachannel-1.5.10/README.md000066400000000000000000000037461472575244200153450ustar00rootroot00000000000000


Pion Data Channels

A Go implementation of WebRTC Data Channels

Pion Data Channels Slack Widget
GitHub Workflow Status Go Reference Coverage Status Go Report Card License: MIT


### Roadmap The library is used as a part of our WebRTC implementation. Please refer to that [roadmap](https://github.com/pion/webrtc/issues/9) to track our major milestones. ### Community Pion has an active community on the [Slack](https://pion.ly/slack). Follow the [Pion Twitter](https://twitter.com/_pion) for project updates and important WebRTC news. We are always looking to support **your projects**. Please reach out if you have something to build! If you need commercial support or don't want to use public methods you can contact us at [team@pion.ly](mailto:team@pion.ly) ### Contributing Check out the [contributing wiki](https://github.com/pion/webrtc/wiki/Contributing) to join the group of amazing people making this project possible ### License MIT License - see [LICENSE](LICENSE) for full text datachannel-1.5.10/codecov.yml000066400000000000000000000007151472575244200162240ustar00rootroot00000000000000# # DO NOT EDIT THIS FILE # # It is automatically copied from https://github.com/pion/.goassets repository. # # SPDX-FileCopyrightText: 2023 The Pion community # SPDX-License-Identifier: MIT coverage: status: project: default: # Allow decreasing 2% of total coverage to avoid noise. threshold: 2% patch: default: target: 70% only_pulls: true ignore: - "examples/*" - "examples/**/*" datachannel-1.5.10/datachannel.go000066400000000000000000000300541472575244200166470ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT // Package datachannel implements WebRTC Data Channels package datachannel import ( "errors" "fmt" "io" "sync" "sync/atomic" "time" "github.com/pion/logging" "github.com/pion/sctp" ) const receiveMTU = 8192 // Reader is an extended io.Reader // that also returns if the message is text. 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 { WriteDataChannel([]byte, bool) (int, error) } // WriteDeadliner extends an io.Writer to expose setting a write deadline. type WriteDeadliner interface { SetWriteDeadline(time.Time) error } // ReadWriteCloser is an extended io.ReadWriteCloser // that also implements our Reader and Writer. type ReadWriteCloser interface { io.Reader io.Writer Reader Writer io.Closer } // ReadWriteCloserDeadliner is an extended ReadWriteCloser // that also implements r/w deadline. type ReadWriteCloserDeadliner interface { ReadWriteCloser ReadDeadliner WriteDeadliner } // DataChannel represents a data channel type DataChannel struct { Config // stats messagesSent uint32 messagesReceived uint32 bytesSent uint64 bytesReceived uint64 mu sync.Mutex onOpenCompleteHandler func() openCompleteHandlerOnce sync.Once stream *sctp.Stream log logging.LeveledLogger } // Config is used to configure the data channel. type Config struct { ChannelType ChannelType Negotiated bool Priority uint16 ReliabilityParameter uint32 Label string Protocol string LoggerFactory logging.LoggerFactory } func newDataChannel(stream *sctp.Stream, config *Config) *DataChannel { return &DataChannel{ Config: *config, stream: stream, log: config.LoggerFactory.NewLogger("datachannel"), } } // Dial opens a data channels over SCTP func Dial(a *sctp.Association, id uint16, config *Config) (*DataChannel, error) { stream, err := a.OpenStream(id, sctp.PayloadTypeWebRTCBinary) if err != nil { return nil, err } dc, err := Client(stream, config) if err != nil { return nil, err } return dc, nil } // Client opens a data channel over an SCTP stream func Client(stream *sctp.Stream, config *Config) (*DataChannel, error) { msg := &channelOpen{ ChannelType: config.ChannelType, Priority: config.Priority, ReliabilityParameter: config.ReliabilityParameter, Label: []byte(config.Label), Protocol: []byte(config.Protocol), } if !config.Negotiated { rawMsg, err := msg.Marshal() if err != nil { 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 %w", err) } } return newDataChannel(stream, config), nil } // Accept is used to accept incoming data channels over SCTP 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) dc, err := Server(stream, config) if err != nil { return nil, err } return dc, nil } // Server accepts a data channel over an SCTP stream func Server(stream *sctp.Stream, config *Config) (*DataChannel, error) { buffer := make([]byte, receiveMTU) n, ppi, err := stream.ReadSCTP(buffer) if err != nil { return nil, err } if ppi != sctp.PayloadTypeWebRTCDCEP { return nil, fmt.Errorf("%w %s", ErrInvalidPayloadProtocolIdentifier, ppi) } openMsg, err := parseExpectDataChannelOpen(buffer[:n]) if err != nil { return nil, fmt.Errorf("failed to parse DataChannelOpen packet %w", err) } config.ChannelType = openMsg.ChannelType config.Priority = openMsg.Priority config.ReliabilityParameter = openMsg.ReliabilityParameter config.Label = string(openMsg.Label) config.Protocol = string(openMsg.Protocol) dataChannel := newDataChannel(stream, config) err = dataChannel.writeDataChannelAck() if err != nil { return nil, err } err = dataChannel.commitReliabilityParams() if err != nil { return nil, err } return dataChannel, nil } // Read reads a packet of len(p) bytes as binary data func (c *DataChannel) Read(p []byte) (int, error) { n, _, err := c.ReadDataChannel(p) return n, err } // ReadDataChannel reads a packet of len(p) bytes func (c *DataChannel) ReadDataChannel(p []byte) (int, bool, error) { for { n, ppi, err := c.stream.ReadSCTP(p) if errors.Is(err, io.EOF) { // When the peer sees that an incoming stream was // reset, it also resets its corresponding outgoing stream. if closeErr := c.stream.Close(); closeErr != nil { return 0, false, closeErr } } if err != nil { return 0, false, err } if ppi == sctp.PayloadTypeWebRTCDCEP { if err = c.handleDCEP(p[:n]); err != nil { c.log.Errorf("Failed to handle DCEP: %s", err.Error()) } continue } 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) } // SetWriteDeadline sets a deadline for writes to return, // only available if the BlockWrite is enabled for sctp func (c *DataChannel) SetWriteDeadline(t time.Time) error { return c.stream.SetWriteDeadline(t) } // MessagesSent returns the number of messages sent func (c *DataChannel) MessagesSent() uint32 { return atomic.LoadUint32(&c.messagesSent) } // MessagesReceived returns the number of messages received 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) } // BytesReceived returns the number of bytes received func (c *DataChannel) BytesReceived() uint64 { return atomic.LoadUint64(&c.bytesReceived) } // StreamIdentifier returns the Stream identifier associated to the stream. func (c *DataChannel) StreamIdentifier() uint16 { return c.stream.StreamIdentifier() } func (c *DataChannel) handleDCEP(data []byte) error { msg, err := parse(data) if err != nil { return fmt.Errorf("failed to parse DataChannel packet %w", err) } switch msg := msg.(type) { case *channelAck: if err := c.commitReliabilityParams(); err != nil { return err } c.onOpenComplete() default: return fmt.Errorf("%w, wanted ACK got %v", ErrUnexpectedDataChannelType, msg) } return nil } // Write writes len(p) bytes from p as binary data func (c *DataChannel) Write(p []byte) (n int, err error) { return c.WriteDataChannel(p, false) } // WriteDataChannel writes len(p) bytes from p func (c *DataChannel) WriteDataChannel(p []byte, isString bool) (n int, err error) { // https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-12#section-6.6 // SCTP does not support the sending of empty user messages. Therefore, // if an empty message has to be sent, the appropriate PPID (WebRTC // String Empty or WebRTC Binary Empty) is used and the SCTP user // message of one zero byte is sent. When receiving an SCTP user // message with one of these PPIDs, the receiver MUST ignore the SCTP // user message and process it as an empty message. var ppi sctp.PayloadProtocolIdentifier switch { case !isString && len(p) > 0: ppi = sctp.PayloadTypeWebRTCBinary case !isString && len(p) == 0: ppi = sctp.PayloadTypeWebRTCBinaryEmpty case isString && len(p) > 0: ppi = sctp.PayloadTypeWebRTCString case isString && len(p) == 0: ppi = sctp.PayloadTypeWebRTCStringEmpty } atomic.AddUint32(&c.messagesSent, 1) atomic.AddUint64(&c.bytesSent, uint64(len(p))) if len(p) == 0 { _, err := c.stream.WriteSCTP([]byte{0}, ppi) return 0, err } return c.stream.WriteSCTP(p, ppi) } func (c *DataChannel) writeDataChannelAck() error { ack := channelAck{} ackMsg, err := ack.Marshal() if err != nil { return fmt.Errorf("failed to marshal ChannelOpen ACK: %w", err) } if _, err = c.stream.WriteSCTP(ackMsg, sctp.PayloadTypeWebRTCDCEP); err != nil { return fmt.Errorf("failed to send ChannelOpen ACK: %w", err) } return err } // Close closes the DataChannel and the underlying SCTP stream. func (c *DataChannel) Close() error { // https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-13#section-6.7 // Closing of a data channel MUST be signaled by resetting the // corresponding outgoing streams [RFC6525]. This means that if one // side decides to close the data channel, it resets the corresponding // outgoing stream. When the peer sees that an incoming stream was // reset, it also resets its corresponding outgoing stream. Once this // is completed, the data channel is closed. Resetting a stream sets // the Stream Sequence Numbers (SSNs) of the stream back to 'zero' with // a corresponding notification to the application layer that the reset // has been performed. Streams are available for reuse after a reset // has been performed. return c.stream.Close() } // BufferedAmount returns the number of bytes of data currently queued to be // sent over this stream. func (c *DataChannel) BufferedAmount() uint64 { return c.stream.BufferedAmount() } // BufferedAmountLowThreshold returns the number of bytes of buffered outgoing // data that is considered "low." Defaults to 0. func (c *DataChannel) BufferedAmountLowThreshold() uint64 { return c.stream.BufferedAmountLowThreshold() } // SetBufferedAmountLowThreshold is used to update the threshold. // See BufferedAmountLowThreshold(). func (c *DataChannel) SetBufferedAmountLowThreshold(th uint64) { c.stream.SetBufferedAmountLowThreshold(th) } // OnBufferedAmountLow sets the callback handler which would be called when the // number of bytes of outgoing data buffered is lower than the threshold. func (c *DataChannel) OnBufferedAmountLow(f func()) { c.stream.OnBufferedAmountLow(f) } func (c *DataChannel) commitReliabilityParams() error { switch c.Config.ChannelType { case ChannelTypeReliable: c.stream.SetReliabilityParams(false, sctp.ReliabilityTypeReliable, c.Config.ReliabilityParameter) case ChannelTypeReliableUnordered: c.stream.SetReliabilityParams(true, sctp.ReliabilityTypeReliable, c.Config.ReliabilityParameter) case ChannelTypePartialReliableRexmit: c.stream.SetReliabilityParams(false, sctp.ReliabilityTypeRexmit, c.Config.ReliabilityParameter) case ChannelTypePartialReliableRexmitUnordered: c.stream.SetReliabilityParams(true, sctp.ReliabilityTypeRexmit, c.Config.ReliabilityParameter) case ChannelTypePartialReliableTimed: c.stream.SetReliabilityParams(false, sctp.ReliabilityTypeTimed, c.Config.ReliabilityParameter) case ChannelTypePartialReliableTimedUnordered: c.stream.SetReliabilityParams(true, sctp.ReliabilityTypeTimed, c.Config.ReliabilityParameter) default: return fmt.Errorf("%w %v", ErrInvalidChannelType, c.Config.ChannelType) } return nil } datachannel-1.5.10/datachannel_test.go000066400000000000000000000560761472575244200177220ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT package datachannel import ( "encoding/binary" "io" "os" "reflect" "testing" "time" "github.com/pion/logging" "github.com/pion/sctp" "github.com/pion/transport/v3/test" "github.com/stretchr/testify/assert" ) // Check we implement our ReadWriteCloser var _ ReadWriteCloser = (*DataChannel)(nil) func bridgeProcessAtLeastOne(br *test.Bridge) { nSum := 0 for { time.Sleep(10 * time.Millisecond) n := br.Tick() nSum += n if br.Len(0) == 0 && br.Len(1) == 0 && nSum > 0 { break } } } func createNewAssociationPair(br *test.Bridge) (*sctp.Association, *sctp.Association, error) { var a0, a1 *sctp.Association var err0, err1 error loggerFactory := logging.NewDefaultLoggerFactory() handshake0Ch := make(chan bool) handshake1Ch := make(chan bool) go func() { a0, err0 = sctp.Client(sctp.Config{ NetConn: br.GetConn0(), LoggerFactory: loggerFactory, }) handshake0Ch <- true }() go func() { a1, err1 = sctp.Client(sctp.Config{ NetConn: br.GetConn1(), LoggerFactory: loggerFactory, }) handshake1Ch <- true }() a0handshakeDone := false a1handshakeDone := false loop1: for i := 0; i < 100; i++ { time.Sleep(10 * time.Millisecond) br.Tick() select { case a0handshakeDone = <-handshake0Ch: if a1handshakeDone { break loop1 } case a1handshakeDone = <-handshake1Ch: if a0handshakeDone { break loop1 } default: } } if err0 != nil { return nil, nil, err0 } if err1 != nil { return nil, nil, err1 } return a0, a1, nil } func closeAssociationPair(br *test.Bridge, a0, a1 *sctp.Association) { close0Ch := make(chan bool) close1Ch := make(chan bool) go func() { //nolint:errcheck,gosec a0.Close() close0Ch <- true }() go func() { //nolint:errcheck,gosec a1.Close() close1Ch <- true }() a0closed := false a1closed := false loop1: for i := 0; i < 100; i++ { time.Sleep(10 * time.Millisecond) br.Tick() select { case a0closed = <-close0Ch: if a1closed { break loop1 } case a1closed = <-close1Ch: if a0closed { break loop1 } default: } } } func prOrderedTest(t *testing.T, channelType ChannelType) { // Limit runtime in case of deadlocks lim := test.TimeOut(time.Second * 10) defer lim.Stop() sbuf := make([]byte, 1000) rbuf := make([]byte, 2000) br := test.NewBridge() loggerFactory := logging.NewDefaultLoggerFactory() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: channelType, ReliabilityParameter: 0, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.Nil(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.Nil(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) assert.True(t, reflect.DeepEqual(dc0.Config, *cfg), "local config should match") assert.True(t, reflect.DeepEqual(dc1.Config, *cfg), "remote config should match") err = dc0.commitReliabilityParams() assert.NoError(t, err, "should succeed") err = dc1.commitReliabilityParams() assert.NoError(t, err, "should succeed") var n int binary.BigEndian.PutUint32(sbuf, 1) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "WriteDataChannel() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") binary.BigEndian.PutUint32(sbuf, 2) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "WriteDataChannel() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") time.Sleep(100 * time.Millisecond) br.Drop(0, 0, 1) // drop the first packet on the wire time.Sleep(100 * time.Millisecond) bridgeProcessAtLeastOne(br) var isString bool n, isString, err = dc1.ReadDataChannel(rbuf) assert.Nil(t, err, "Read() should succeed") assert.True(t, isString, "should return isString being true") assert.Equal(t, uint32(2), binary.BigEndian.Uint32(rbuf[:n]), "data should match") //nolint:errcheck,gosec dc0.Close() //nolint:errcheck,gosec dc1.Close() bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) } func prUnorderedTest(t *testing.T, channelType ChannelType) { sbuf := make([]byte, 1000) rbuf := make([]byte, 2000) br := test.NewBridge() loggerFactory := logging.NewDefaultLoggerFactory() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: channelType, ReliabilityParameter: 0, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.Nil(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.Nil(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) assert.True(t, reflect.DeepEqual(dc0.Config, *cfg), "local config should match") assert.True(t, reflect.DeepEqual(dc1.Config, *cfg), "remote config should match") err = dc0.commitReliabilityParams() assert.NoError(t, err, "should succeed") err = dc1.commitReliabilityParams() assert.NoError(t, err, "should succeed") var n int binary.BigEndian.PutUint32(sbuf, 1) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") binary.BigEndian.PutUint32(sbuf, 2) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") binary.BigEndian.PutUint32(sbuf, 3) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") time.Sleep(100 * time.Millisecond) br.Drop(0, 0, 1) // drop the first packet on the wire err = br.Reorder(0) // reorder the rest of the packet assert.Nil(t, err, "reorder failed") bridgeProcessAtLeastOne(br) var isString bool n, isString, err = dc1.ReadDataChannel(rbuf) assert.Nil(t, err, "Read() should succeed") assert.True(t, isString, "should return isString being true") assert.Equal(t, uint32(3), binary.BigEndian.Uint32(rbuf[:n]), "data should match") n, isString, err = dc1.ReadDataChannel(rbuf) assert.Nil(t, err, "Read() should succeed") assert.True(t, isString, "should return isString being true") assert.Equal(t, uint32(2), binary.BigEndian.Uint32(rbuf[:n]), "data should match") //nolint:errcheck,gosec dc0.Close() //nolint:errcheck,gosec dc1.Close() bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) } func TestDataChannel(t *testing.T) { loggerFactory := logging.NewDefaultLoggerFactory() sbuf := make([]byte, 1000) rbuf := make([]byte, 1500) t.Run("ChannelTypeReliableOrdered", func(t *testing.T) { // Limit runtime in case of deadlocks lim := test.TimeOut(time.Second * 10) defer lim.Stop() br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 123, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.Nil(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.Nil(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) assert.True(t, reflect.DeepEqual(dc0.Config, *cfg), "local config should match") assert.True(t, reflect.DeepEqual(dc1.Config, *cfg), "remote config should match") br.ReorderNextNWrites(0, 2) // reordering on the wire var n int binary.BigEndian.PutUint32(sbuf, uint32(1)) n, err = dc0.Write(sbuf) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") binary.BigEndian.PutUint32(sbuf, uint32(2)) n, err = dc0.Write(sbuf) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") assert.Nil(t, err, "reorder failed") bridgeProcessAtLeastOne(br) n, err = dc1.Read(rbuf) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, uint32(1), binary.BigEndian.Uint32(rbuf[:n]), "data should match") n, err = dc1.Read(rbuf) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, uint32(2), binary.BigEndian.Uint32(rbuf[:n]), "data should match") //nolint:errcheck,gosec dc0.Close() //nolint:errcheck,gosec dc1.Close() bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) }) t.Run("ChannelTypeReliableUnordered", func(t *testing.T) { // Limit runtime in case of deadlocks lim := test.TimeOut(time.Second * 10) defer lim.Stop() sbuf := make([]byte, 1000) rbuf := make([]byte, 1500) br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliableUnordered, ReliabilityParameter: 123, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.Nil(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.Nil(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) assert.True(t, reflect.DeepEqual(dc0.Config, *cfg), "local config should match") assert.True(t, reflect.DeepEqual(dc1.Config, *cfg), "remote config should match") // reliability parameters are committed after data channel open ACK is received on client side, // wait for open to be completed openCompleted := make(chan bool) dc0.OnOpen(func() { close(openCompleted) }) var n int // write a message as ReadChannel loops till user data is read bridgeProcessAtLeastOne(br) binary.BigEndian.PutUint32(sbuf, 10) n, err = dc1.WriteDataChannel(sbuf, true) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") // read data channel open ACK and the user message sent above bridgeProcessAtLeastOne(br) _, _, err = dc0.ReadDataChannel(rbuf) assert.NoError(t, err) select { case <-time.After(time.Second * 10): assert.FailNow(t, "OnOpen() failed to fire 10s") case <-openCompleted: } // test unordered messages binary.BigEndian.PutUint32(sbuf, 1) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") binary.BigEndian.PutUint32(sbuf, 2) n, err = dc0.WriteDataChannel(sbuf, true) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") time.Sleep(100 * time.Millisecond) err = br.Reorder(0) // reordering on the wire assert.Nil(t, err, "reorder failed") bridgeProcessAtLeastOne(br) var isString bool n, isString, err = dc1.ReadDataChannel(rbuf) assert.Nil(t, err, "Read() should succeed") assert.True(t, isString, "should return isString being true") assert.Equal(t, uint32(2), binary.BigEndian.Uint32(rbuf[:n]), "data should match") n, isString, err = dc1.ReadDataChannel(rbuf) assert.Nil(t, err, "Read() should succeed") assert.True(t, isString, "should return isString being true") assert.Equal(t, uint32(1), binary.BigEndian.Uint32(rbuf[:n]), "data should match") //nolint:errcheck,gosec dc0.Close() //nolint:errcheck,gosec dc1.Close() bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) }) t.Run("ChannelTypePartialReliableRexmit", func(t *testing.T) { prOrderedTest(t, ChannelTypePartialReliableRexmit) }) t.Run("ChannelTypePartialReliableRexmitUnordered", func(t *testing.T) { prUnorderedTest(t, ChannelTypePartialReliableRexmitUnordered) }) t.Run("ChannelTypePartialReliableTimed", func(t *testing.T) { prOrderedTest(t, ChannelTypePartialReliableTimed) }) t.Run("ChannelTypePartialReliableTimedUnordered", func(t *testing.T) { prUnorderedTest(t, ChannelTypePartialReliableTimedUnordered) }) } func TestDataChannelBufferedAmount(t *testing.T) { var nCbs int sData := make([]byte, 1000) rData := make([]byte, 1000) br := test.NewBridge() loggerFactory := logging.NewDefaultLoggerFactory() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } dc0, err := Dial(a0, 100, &Config{ Label: "data", LoggerFactory: loggerFactory, }) assert.Nil(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.Nil(t, err, "Accept() should succeed") for dc0.BufferedAmount() > 0 { bridgeProcessAtLeastOne(br) } n, err := dc0.Write([]byte{}) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, 0, n, "data length should match") assert.Equal(t, uint64(1), dc0.BufferedAmount(), "incorrect bufferedAmount") n, err = dc0.Write([]byte{0}) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, 1, n, "data length should match") assert.Equal(t, uint64(2), dc0.BufferedAmount(), "incorrect bufferedAmount") bridgeProcessAtLeastOne(br) n, err = dc1.Read(rData) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, n, 0, "received length should match") n, err = dc1.Read(rData) assert.Nil(t, err, "Read() should succeed") assert.Equal(t, n, 1, "received length should match") dc0.SetBufferedAmountLowThreshold(1500) assert.Equal(t, uint64(1500), dc0.BufferedAmountLowThreshold(), "incorrect bufferedAmountLowThreshold") dc0.OnBufferedAmountLow(func() { nCbs++ }) // Write 10 1000-byte packets (total 10,000 bytes) for i := 0; i < 10; i++ { var n int n, err = dc0.Write(sData) assert.Nil(t, err, "Write() should succeed") assert.Equal(t, len(sData), n, "data length should match") assert.Equal(t, uint64(len(sData)*(i+1)+2), dc0.BufferedAmount(), "incorrect bufferedAmount") } go func() { for { n, err := dc1.Read(rData) if err != nil { break } assert.Equal(t, n, len(rData), "received length should match") } }() since := time.Now() for { br.Tick() time.Sleep(10 * time.Millisecond) if time.Since(since).Seconds() > 0.5 { break } } //nolint:errcheck,gosec dc0.Close() //nolint:errcheck,gosec dc1.Close() bridgeProcessAtLeastOne(br) assert.True(t, nCbs > 0, "should make at least one callback") closeAssociationPair(br, a0, a1) } func TestStats(t *testing.T) { loggerFactory := logging.NewDefaultLoggerFactory() sbuf := make([]byte, 1000) rbuf := make([]byte, 1500) br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 123, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.NoError(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) var bytesSent uint64 var n int n, err = dc0.Write(sbuf) assert.NoError(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") bytesSent += uint64(n) assert.Equal(t, dc0.BytesSent(), bytesSent) assert.Equal(t, dc0.MessagesSent(), uint32(1)) n, err = dc0.Write(sbuf) assert.NoError(t, err, "Write() should succeed") assert.Equal(t, len(sbuf), n, "data length should match") bytesSent += uint64(n) assert.Equal(t, dc0.BytesSent(), bytesSent) assert.Equal(t, dc0.MessagesSent(), uint32(2)) n, err = dc0.Write([]byte{0}) assert.NoError(t, err, "Write() should succeed") assert.Equal(t, 1, n, "data length should match") bytesSent += uint64(n) assert.Equal(t, dc0.BytesSent(), bytesSent) assert.Equal(t, dc0.MessagesSent(), uint32(3)) n, err = dc0.Write([]byte{}) assert.NoError(t, err, "Write() should succeed") assert.Equal(t, 0, n, "data length should match") assert.Equal(t, dc0.BytesSent(), bytesSent) assert.Equal(t, dc0.MessagesSent(), uint32(4)) bridgeProcessAtLeastOne(br) var bytesRead uint64 n, err = dc1.Read(rbuf) assert.NoError(t, err, "Read() should succeed") bytesRead += uint64(n) assert.Equal(t, dc1.BytesReceived(), bytesRead) assert.Equal(t, dc1.MessagesReceived(), uint32(1)) n, err = dc1.Read(rbuf) assert.NoError(t, err, "Read() should succeed") bytesRead += uint64(n) assert.Equal(t, dc1.BytesReceived(), bytesRead) assert.Equal(t, dc1.MessagesReceived(), uint32(2)) n, err = dc1.Read(rbuf) assert.NoError(t, err, "Read() should succeed") bytesRead += uint64(n) assert.Equal(t, n, 1) assert.Equal(t, dc1.BytesReceived(), bytesRead) assert.Equal(t, dc1.MessagesReceived(), uint32(3)) n, err = dc1.Read(rbuf) assert.NoError(t, err, "Read() should succeed") assert.Equal(t, n, 0) assert.Equal(t, dc1.BytesReceived(), bytesRead) assert.Equal(t, dc1.MessagesReceived(), uint32(4)) assert.NoError(t, dc0.Close()) assert.NoError(t, dc1.Close()) bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) } func TestDataChannelAcceptWrite(t *testing.T) { loggerFactory := logging.NewDefaultLoggerFactory() br := test.NewBridge() in := []byte("HELLO WORLD") out := make([]byte, 100) a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 123, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.NoError(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) n, err := dc1.WriteDataChannel(in, true) assert.Nil(t, err) assert.Equal(t, len(in), n) bridgeProcessAtLeastOne(br) n, isString, err := dc0.ReadDataChannel(out) assert.NoError(t, err) assert.True(t, isString) assert.Equal(t, len(in), n) assert.Equal(t, in, out[:n]) assert.NoError(t, dc0.Close()) assert.NoError(t, dc1.Close()) bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) } func TestOnOpen(t *testing.T) { loggerFactory := logging.NewDefaultLoggerFactory() br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) assert.NoError(t, err) dc0, err := Dial(a0, 100, &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 123, Label: "data", LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) openCompleted := make(chan bool) dc0.OnOpen(func() { close(openCompleted) }) in := []byte("HELLO WORLD") out := make([]byte, 100) bridgeProcessAtLeastOne(br) _, err = dc1.WriteDataChannel(in, true) assert.NoError(t, err) bridgeProcessAtLeastOne(br) _, _, err = dc0.ReadDataChannel(out) assert.NoError(t, err) select { case <-time.After(time.Second * 10): assert.FailNow(t, "OnOpen() failed to fire 10s") case <-openCompleted: } assert.NoError(t, dc0.Close()) assert.NoError(t, dc1.Close()) bridgeProcessAtLeastOne(br) closeAssociationPair(br, a0, a1) } func TestReadDeadline(t *testing.T) { loggerFactory := logging.NewDefaultLoggerFactory() br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 123, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.NoError(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) _, err = Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) err = dc0.SetReadDeadline(time.Now().Add(200 * time.Millisecond)) assert.NoError(t, err, "SetReadDeadline() should succeed") _, err = dc0.Read(make([]byte, 1500)) assert.ErrorIs(t, err, os.ErrDeadlineExceeded) } func TestClose(t *testing.T) { loggerFactory := logging.NewDefaultLoggerFactory() t.Run("RemoteClose", func(t *testing.T) { br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 0, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.NoError(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) assert.Equal(t, dc0.StreamIdentifier(), dc1.StreamIdentifier()) // Call bridgeProcessOne when reads are required err = dc1.SetReadDeadline(time.Now().Add(2 * time.Second)) assert.NoError(t, err) time.AfterFunc(100*time.Millisecond, func() { _ = dc0.Close() bridgeProcessAtLeastOne(br) }) _, err = dc1.Read(make([]byte, 1500)) assert.ErrorIs(t, err, io.EOF) bridgeProcessAtLeastOne(br) _, err = dc0.Read(make([]byte, 1500)) assert.ErrorIs(t, err, io.EOF) }) t.Run("CloseWhenReadActive", func(t *testing.T) { br := test.NewBridge() a0, a1, err := createNewAssociationPair(br) if !assert.Nil(t, err, "failed to create associations") { assert.FailNow(t, "failed due to earlier error") } cfg := &Config{ ChannelType: ChannelTypeReliable, ReliabilityParameter: 0, Label: "data", LoggerFactory: loggerFactory, } dc0, err := Dial(a0, 100, cfg) assert.NoError(t, err, "Dial() should succeed") bridgeProcessAtLeastOne(br) dc1, err := Accept(a1, &Config{ LoggerFactory: loggerFactory, }) assert.NoError(t, err, "Accept() should succeed") bridgeProcessAtLeastOne(br) assert.Equal(t, dc0.StreamIdentifier(), dc1.StreamIdentifier()) defer func() { _ = dc0.Close() }() err = dc1.SetReadDeadline(time.Now().Add(2 * time.Second)) assert.NoError(t, err) go func() { _, closeErr := dc0.Read(make([]byte, 1500)) assert.ErrorIs(t, closeErr, io.EOF) // Call bridgeProcessOne when reads are required, // Here, dc1 would need to read the returning close message bridgeProcessAtLeastOne(br) }() time.AfterFunc(100*time.Millisecond, func() { closeErr := dc1.Close() assert.NoError(t, closeErr, "Close() should succeed") bridgeProcessAtLeastOne(br) }) _, err = dc1.Read(make([]byte, 1500)) assert.ErrorIs(t, err, io.EOF) }) } datachannel-1.5.10/errors.go000066400000000000000000000024451472575244200157240ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT 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") ) datachannel-1.5.10/go.mod000066400000000000000000000006501472575244200151630ustar00rootroot00000000000000module github.com/pion/datachannel require ( github.com/pion/logging v0.2.2 github.com/pion/sctp v1.8.35 github.com/pion/transport/v3 v3.0.7 github.com/stretchr/testify v1.10.0 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/kr/text v0.2.0 // indirect github.com/pion/randutil v0.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) go 1.20 datachannel-1.5.10/go.sum000066400000000000000000000036231472575244200152130ustar00rootroot00000000000000github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= 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/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= 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.8.35 h1:qwtKvNK1Wc5tHMIYgTDJhfZk7vATGVHhXbUDfHbYwzA= github.com/pion/sctp v1.8.35/go.mod h1:EcXP8zCYVTRy3W9xtOF7wJm1L1aXfKRQzaM33SjQlzg= github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0= github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo= 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/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys= 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/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= datachannel-1.5.10/message.go000066400000000000000000000036671472575244200160430ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT package datachannel import ( "fmt" ) // message is a parsed DataChannel message type message interface { Marshal() ([]byte, error) Unmarshal([]byte) error String() string } // messageType is the first byte in a DataChannel message that specifies type type messageType byte // DataChannel Message Types const ( dataChannelAck messageType = 0x02 dataChannelOpen messageType = 0x03 ) func (t messageType) String() string { switch t { case dataChannelAck: return "DataChannelAck" case dataChannelOpen: return "DataChannelOpen" default: return fmt.Sprintf("Unknown MessageType: %d", t) } } // parse accepts raw input and returns a DataChannel message func parse(raw []byte) (message, error) { if len(raw) == 0 { return nil, ErrDataChannelMessageTooShort } var msg message switch messageType(raw[0]) { case dataChannelOpen: msg = &channelOpen{} case dataChannelAck: msg = &channelAck{} default: return nil, fmt.Errorf("%w %v", ErrInvalidMessageType, messageType(raw[0])) } if err := msg.Unmarshal(raw); err != nil { return nil, err } return msg, nil } // parseExpectDataChannelOpen parses a DataChannelOpen message // or throws an error func parseExpectDataChannelOpen(raw []byte) (*channelOpen, error) { if len(raw) == 0 { return nil, ErrDataChannelMessageTooShort } if actualTyp := messageType(raw[0]); actualTyp != dataChannelOpen { return nil, fmt.Errorf("%w expected(%s) actual(%s)", ErrUnexpectedDataChannelType, actualTyp, dataChannelOpen) } msg := &channelOpen{} if err := msg.Unmarshal(raw); err != nil { return nil, err } return msg, nil } // TryMarshalUnmarshal attempts to marshal and unmarshal a message. Added for fuzzing. func TryMarshalUnmarshal(msg []byte) int { message, err := parse(msg) if err != nil { return 0 } _, err = message.Marshal() if err != nil { return 0 } return 1 } datachannel-1.5.10/message_channel_ack.go000066400000000000000000000012451472575244200203370ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT package datachannel // channelAck is used to ACK a DataChannel open type channelAck struct{} const ( channelOpenAckLength = 4 ) // Marshal returns raw bytes for the given message func (c *channelAck) Marshal() ([]byte, error) { raw := make([]byte, channelOpenAckLength) raw[0] = uint8(dataChannelAck) return raw, nil } // Unmarshal populates the struct with the given raw data func (c *channelAck) Unmarshal(_ []byte) error { // Message type already checked in Parse and there is no further data return nil } func (c channelAck) String() string { return "ACK" } datachannel-1.5.10/message_channel_open.go000066400000000000000000000135521472575244200205460ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT package datachannel import ( "encoding/binary" "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 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Message Type | Channel Type | Priority | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Reliability Parameter | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Label Length | Protocol Length | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | | Label | | | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | | | Protocol | | | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ type channelOpen struct { ChannelType ChannelType Priority uint16 ReliabilityParameter uint32 Label []byte Protocol []byte } const ( channelOpenHeaderLength = 12 ) // ChannelType determines the reliability of the WebRTC DataChannel type ChannelType byte // ChannelType enums const ( // ChannelTypeReliable determines the Data Channel provides a // reliable in-order bi-directional communication. ChannelTypeReliable ChannelType = 0x00 // ChannelTypeReliableUnordered determines the Data Channel // provides a reliable unordered bi-directional communication. ChannelTypeReliableUnordered ChannelType = 0x80 // ChannelTypePartialReliableRexmit determines the Data Channel // provides a partially-reliable in-order bi-directional communication. // User messages will not be retransmitted more times than specified in the Reliability Parameter. ChannelTypePartialReliableRexmit ChannelType = 0x01 // ChannelTypePartialReliableRexmitUnordered determines // the Data Channel provides a partial reliable unordered bi-directional communication. // User messages will not be retransmitted more times than specified in the Reliability Parameter. ChannelTypePartialReliableRexmitUnordered ChannelType = 0x81 // ChannelTypePartialReliableTimed determines the Data Channel // provides a partial reliable in-order bi-directional communication. // User messages might not be transmitted or retransmitted after // a specified life-time given in milli- seconds in the Reliability Parameter. // This life-time starts when providing the user message to the protocol stack. ChannelTypePartialReliableTimed ChannelType = 0x02 // The Data Channel provides a partial reliable unordered bi-directional // communication. User messages might not be transmitted or retransmitted // after a specified life-time given in milli- seconds in the Reliability Parameter. // This life-time starts when providing the user message to the protocol stack. ChannelTypePartialReliableTimedUnordered ChannelType = 0x82 ) func (c ChannelType) String() string { switch c { case ChannelTypeReliable: case ChannelTypeReliableUnordered: return "ReliableUnordered" case ChannelTypePartialReliableRexmit: return "PartialReliableRexmit" case ChannelTypePartialReliableRexmitUnordered: return "PartialReliableRexmitUnordered" case ChannelTypePartialReliableTimed: return "PartialReliableTimed" case ChannelTypePartialReliableTimedUnordered: return "PartialReliableTimedUnordered" } return "Unknown" } // ChannelPriority enums const ( ChannelPriorityBelowNormal uint16 = 128 ChannelPriorityNormal uint16 = 256 ChannelPriorityHigh uint16 = 512 ChannelPriorityExtraHigh uint16 = 1024 ) // Marshal returns raw bytes for the given message func (c *channelOpen) Marshal() ([]byte, error) { labelLength := len(c.Label) protocolLength := len(c.Protocol) totalLen := channelOpenHeaderLength + labelLength + protocolLength raw := make([]byte, totalLen) raw[0] = uint8(dataChannelOpen) raw[1] = byte(c.ChannelType) binary.BigEndian.PutUint16(raw[2:], c.Priority) binary.BigEndian.PutUint32(raw[4:], c.ReliabilityParameter) binary.BigEndian.PutUint16(raw[8:], uint16(labelLength)) binary.BigEndian.PutUint16(raw[10:], uint16(protocolLength)) endLabel := channelOpenHeaderLength + labelLength copy(raw[channelOpenHeaderLength:endLabel], c.Label) copy(raw[endLabel:endLabel+protocolLength], c.Protocol) return raw, nil } // Unmarshal populates the struct with the given raw data func (c *channelOpen) Unmarshal(raw []byte) error { if len(raw) < channelOpenHeaderLength { return fmt.Errorf("%w expected(%d) actual(%d)", ErrExpectedAndActualLengthMismatch, channelOpenHeaderLength, len(raw)) } c.ChannelType = ChannelType(raw[1]) c.Priority = binary.BigEndian.Uint16(raw[2:]) c.ReliabilityParameter = binary.BigEndian.Uint32(raw[4:]) labelLength := binary.BigEndian.Uint16(raw[8:]) protocolLength := binary.BigEndian.Uint16(raw[10:]) if expectedLen := channelOpenHeaderLength + int(labelLength) + int(protocolLength); len(raw) != expectedLen { return fmt.Errorf("%w expected(%d) actual(%d)", ErrExpectedAndActualLengthMismatch, expectedLen, len(raw)) } c.Label = raw[channelOpenHeaderLength : channelOpenHeaderLength+labelLength] c.Protocol = raw[channelOpenHeaderLength+labelLength : channelOpenHeaderLength+labelLength+protocolLength] return nil } func (c channelOpen) String() string { return fmt.Sprintf("Open ChannelType(%s) Priority(%v) ReliabilityParameter(%d) Label(%s) Protocol(%s)", c.ChannelType, c.Priority, c.ReliabilityParameter, string(c.Label), string(c.Protocol)) } datachannel-1.5.10/message_test.go000066400000000000000000000051471472575244200170750ustar00rootroot00000000000000// SPDX-FileCopyrightText: 2023 The Pion community // SPDX-License-Identifier: MIT package datachannel import ( "testing" "github.com/stretchr/testify/assert" ) func TestChannelOpenMarshal(t *testing.T) { msg := channelOpen{ ChannelType: ChannelTypeReliable, Priority: 0, ReliabilityParameter: 0, Label: []byte("foo"), Protocol: []byte("bar"), } rawMsg, err := msg.Marshal() if err != nil { t.Errorf("Failed to marshal: %v", err) return } result := []byte{ 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, } if len(rawMsg) != len(result) { t.Errorf("%q != %q", rawMsg, result) return } for i, v := range rawMsg { if v != result[i] { t.Errorf("%q != %q", rawMsg, result) break } } } func TestChannelAckMarshal(t *testing.T) { msg := channelAck{} rawMsg, err := msg.Marshal() if err != nil { t.Errorf("Failed to marshal: %v", err) return } result := []byte{0x02, 0x00, 0x00, 0x00} if len(rawMsg) != len(result) { t.Errorf("%q != %q", rawMsg, result) return } for i, v := range rawMsg { if v != result[i] { t.Errorf("%q != %q", rawMsg, result) break } } } func TestChannelOpenUnmarshal(t *testing.T) { rawMsg := []byte{ 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x03, 0x66, 0x6f, 0x6f, 0x62, 0x61, 0x72, } msgUncast, err := parse(rawMsg) msg, ok := msgUncast.(*channelOpen) assert.True(t, ok, "Failed to cast to ChannelOpen") assert.NoError(t, err, "Unmarshal failed, ChannelOpen") assert.Equal(t, msg.ChannelType, ChannelTypeReliable, "ChannelType should be 0") assert.Equal(t, msg.Priority, uint16(0), "Priority should be 0") assert.Equal(t, msg.ReliabilityParameter, uint32(0), "ReliabilityParameter should be 0") assert.Equal(t, msg.Label, []uint8("foo"), "msg Label should be 'foo'") assert.Equal(t, msg.Protocol, []uint8("bar"), "msg protocol should be 'bar'") } func TestChannelAckUnmarshal(t *testing.T) { rawMsg := []byte{0x02} msgUncast, err := parse(rawMsg) if err != nil { t.Errorf("Failed to parse: %v", err) return } _, ok := msgUncast.(*channelAck) assert.True(t, ok, "Failed to cast to ChannelAck") } func TestChannelString(t *testing.T) { channelString := channelOpen{ ChannelType: ChannelTypeReliable, Priority: 0, ReliabilityParameter: 0, Label: []byte("foo"), Protocol: []byte("bar"), }.String() assert.Equal(t, channelString, "Open ChannelType(Unknown) Priority(0) ReliabilityParameter(0) Label(foo) Protocol(bar)") assert.Equal(t, channelAck{}.String(), "ACK") } datachannel-1.5.10/renovate.json000066400000000000000000000001731472575244200165730ustar00rootroot00000000000000{ "$schema": "https://docs.renovatebot.com/renovate-schema.json", "extends": [ "github>pion/renovate-config" ] }