Files
uu-remote-linux/vendor/webrtc/src/error.rs
T
VallierDevandClaude Opus 5.5 ebef246486 Port mapping: advertise and accept 256 KB data-channel messages
The viewer assumed webrtc-rs's missing a=max-message-size meant 64 KB and
refused larger port-mapping frames, stalling uploads after the first
frame. Advertise 262144 in the answer sent to the viewer and vendor webrtc
with a 256 KB data-channel receive buffer (upstream u16::MAX). Verified
with the official Mac viewer: 20 MB upload 10 MB/s, 20 MB download and
5 concurrent downloads, checksums match. Docs and v0.1.4 notes.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-15 08:14:24 +08:00

464 lines
19 KiB
Rust

use std::future::Future;
use std::num::ParseIntError;
use std::pin::Pin;
use std::string::FromUtf8Error;
use rcgen::RcgenError;
use thiserror::Error;
use tokio::sync::mpsc::error::SendError as MpscSendError;
use crate::peer_connection::sdp::sdp_type::RTCSdpType;
use crate::peer_connection::signaling_state::RTCSignalingState;
use crate::rtp_transceiver::rtp_receiver;
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Error, Debug, PartialEq)]
#[non_exhaustive]
pub enum Error {
/// ErrUnknownType indicates an error with Unknown info.
#[error("unknown")]
ErrUnknownType,
/// ErrConnectionClosed indicates an operation executed after connection
/// has already been closed.
#[error("connection closed")]
ErrConnectionClosed,
/// ErrDataChannelNotOpen indicates an operation executed when the data
/// channel is not (yet) open.
#[error("data channel not open")]
ErrDataChannelNotOpen,
/// ErrCertificateExpired indicates that an x509 certificate has expired.
#[error("x509Cert expired")]
ErrCertificateExpired,
/// ErrNoTurnCredentials indicates that a TURN server URL was provided
/// without required credentials.
#[error("turn server credentials required")]
ErrNoTurnCredentials,
/// ErrTurnCredentials indicates that provided TURN credentials are partial
/// or malformed.
#[error("invalid turn server credentials")]
ErrTurnCredentials,
/// ErrExistingTrack indicates that a track already exists.
#[error("track already exists")]
ErrExistingTrack,
/// ErrPrivateKeyType indicates that a particular private key encryption
/// chosen to generate a certificate is not supported.
#[error("private key type not supported")]
ErrPrivateKeyType,
/// ErrModifyingPeerIdentity indicates that an attempt to modify
/// PeerIdentity was made after PeerConnection has been initialized.
#[error("peerIdentity cannot be modified")]
ErrModifyingPeerIdentity,
/// ErrModifyingCertificates indicates that an attempt to modify
/// Certificates was made after PeerConnection has been initialized.
#[error("certificates cannot be modified")]
ErrModifyingCertificates,
/// ErrNonCertificate indicates that there is no certificate
#[error("no certificate")]
ErrNonCertificate,
/// ErrModifyingBundlePolicy indicates that an attempt to modify
/// BundlePolicy was made after PeerConnection has been initialized.
#[error("bundle policy cannot be modified")]
ErrModifyingBundlePolicy,
/// ErrModifyingRTCPMuxPolicy indicates that an attempt to modify
/// RTCPMuxPolicy was made after PeerConnection has been initialized.
#[error("rtcp mux policy cannot be modified")]
ErrModifyingRTCPMuxPolicy,
/// ErrModifyingICECandidatePoolSize indicates that an attempt to modify
/// ICECandidatePoolSize was made after PeerConnection has been initialized.
#[error("ice candidate pool size cannot be modified")]
ErrModifyingICECandidatePoolSize,
/// ErrStringSizeLimit indicates that the character size limit of string is
/// exceeded. The limit is hardcoded to 65535 according to specifications.
#[error("data channel label exceeds size limit")]
ErrStringSizeLimit,
/// ErrMaxDataChannelID indicates that the maximum number ID that could be
/// specified for a data channel has been exceeded.
#[error("maximum number ID for datachannel specified")]
ErrMaxDataChannelID,
/// ErrNegotiatedWithoutID indicates that an attempt to create a data channel
/// was made while setting the negotiated option to true without providing
/// the negotiated channel ID.
#[error("negotiated set without channel id")]
ErrNegotiatedWithoutID,
/// ErrRetransmitsOrPacketLifeTime indicates that an attempt to create a data
/// channel was made with both options max_packet_life_time and max_retransmits
/// set together. Such configuration is not supported by the specification
/// and is mutually exclusive.
#[error("both max_packet_life_time and max_retransmits was set")]
ErrRetransmitsOrPacketLifeTime,
/// ErrCodecNotFound is returned when a codec search to the Media Engine fails
#[error("codec not found")]
ErrCodecNotFound,
/// ErrNoRemoteDescription indicates that an operation was rejected because
/// the remote description is not set
#[error("remote description is not set")]
ErrNoRemoteDescription,
/// ErrIncorrectSDPSemantics indicates that the PeerConnection was configured to
/// generate SDP Answers with different SDP Semantics than the received Offer
#[error("offer SDP semantics does not match configuration")]
ErrIncorrectSDPSemantics,
/// ErrIncorrectSignalingState indicates that the signaling state of PeerConnection is not correct
#[error("operation can not be run in current signaling state")]
ErrIncorrectSignalingState,
/// ErrProtocolTooLarge indicates that value given for a DataChannelInit protocol is
/// longer then 65535 bytes
#[error("protocol is larger then 65535 bytes")]
ErrProtocolTooLarge,
/// ErrSenderNotCreatedByConnection indicates remove_track was called with a RtpSender not created
/// by this PeerConnection
#[error("RtpSender not created by this PeerConnection")]
ErrSenderNotCreatedByConnection,
/// ErrSenderInitialTrackIdAlreadySet indicates a second call to
/// [`RtpSender::set_initial_track_id`] which is not allowed.
#[error("RtpSender's initial_track_id has already been set")]
ErrSenderInitialTrackIdAlreadySet,
/// ErrSessionDescriptionNoFingerprint indicates set_remote_description was called with a SessionDescription that has no
/// fingerprint
#[error("set_remote_description called with no fingerprint")]
ErrSessionDescriptionNoFingerprint,
/// ErrSessionDescriptionInvalidFingerprint indicates set_remote_description was called with a SessionDescription that
/// has an invalid fingerprint
#[error("set_remote_description called with an invalid fingerprint")]
ErrSessionDescriptionInvalidFingerprint,
/// ErrSessionDescriptionConflictingFingerprints indicates set_remote_description was called with a SessionDescription that
/// has an conflicting fingerprints
#[error("set_remote_description called with multiple conflicting fingerprint")]
ErrSessionDescriptionConflictingFingerprints,
/// ErrSessionDescriptionMissingIceUfrag indicates set_remote_description was called with a SessionDescription that
/// is missing an ice-ufrag value
#[error("set_remote_description called with no ice-ufrag")]
ErrSessionDescriptionMissingIceUfrag,
/// ErrSessionDescriptionMissingIcePwd indicates set_remote_description was called with a SessionDescription that
/// is missing an ice-pwd value
#[error("set_remote_description called with no ice-pwd")]
ErrSessionDescriptionMissingIcePwd,
/// ErrSessionDescriptionConflictingIceUfrag indicates set_remote_description was called with a SessionDescription that
/// contains multiple conflicting ice-ufrag values
#[error("set_remote_description called with multiple conflicting ice-ufrag values")]
ErrSessionDescriptionConflictingIceUfrag,
/// ErrSessionDescriptionConflictingIcePwd indicates set_remote_description was called with a SessionDescription that
/// contains multiple conflicting ice-pwd values
#[error("set_remote_description called with multiple conflicting ice-pwd values")]
ErrSessionDescriptionConflictingIcePwd,
/// ErrNoSRTPProtectionProfile indicates that the DTLS handshake completed and no SRTP Protection Profile was chosen
#[error("DTLS Handshake completed and no SRTP Protection Profile was chosen")]
ErrNoSRTPProtectionProfile,
/// ErrFailedToGenerateCertificateFingerprint indicates that we failed to generate the fingerprint used for comparing certificates
#[error("failed to generate certificate fingerprint")]
ErrFailedToGenerateCertificateFingerprint,
/// ErrNoCodecsAvailable indicates that operation isn't possible because the MediaEngine has no codecs available
#[error("operation failed no codecs are available")]
ErrNoCodecsAvailable,
/// ErrUnsupportedCodec indicates the remote peer doesn't support the requested codec
#[error("unable to start track, codec is not supported by remote")]
ErrUnsupportedCodec,
/// ErrSenderWithNoCodecs indicates that a RTPSender was created without any codecs. To send media the MediaEngine needs at
/// least one configured codec.
#[error("unable to populate media section, RTPSender created with no codecs")]
ErrSenderWithNoCodecs,
/// ErrRTPSenderNewTrackHasIncorrectKind indicates that the new track is of a different kind than the previous/original
#[error("new track must be of the same kind as previous")]
ErrRTPSenderNewTrackHasIncorrectKind,
/// ErrRTPSenderDataSent indicates that the sequence number transformer tries to be enabled after the data sending began
#[error("Sequence number transformer must be enabled before sending data")]
ErrRTPSenderDataSent,
/// ErrRTPSenderSeqTransEnabled indicates that the sequence number transformer has been already enabled
#[error("Sequence number transformer has been already enabled")]
ErrRTPSenderSeqTransEnabled,
/// ErrUnbindFailed indicates that a TrackLocal was not able to be unbind
#[error("failed to unbind TrackLocal from PeerConnection")]
ErrUnbindFailed,
/// ErrNoPayloaderForCodec indicates that the requested codec does not have a payloader
#[error("the requested codec does not have a payloader")]
ErrNoPayloaderForCodec,
/// ErrRegisterHeaderExtensionInvalidDirection indicates that a extension was registered with different
/// directions for two different calls.
#[error("a header extension must be registered with the same direction each time")]
ErrRegisterHeaderExtensionInvalidDirection,
/// ErrRegisterHeaderExtensionNoFreeID indicates that there was no extension ID available which
/// in turn means that all 15 available id(1 through 14) have been used.
#[error("no header extension ID was free to use(this means the maximum of 15 extensions have been registered)")]
ErrRegisterHeaderExtensionNoFreeID,
/// ErrSimulcastProbeOverflow indicates that too many Simulcast probe streams are in flight and the requested SSRC was ignored
#[error("simulcast probe limit has been reached, new SSRC has been discarded")]
ErrSimulcastProbeOverflow,
#[error("enable detaching by calling webrtc.DetachDataChannels()")]
ErrDetachNotEnabled,
#[error("datachannel not opened yet, try calling Detach from OnOpen")]
ErrDetachBeforeOpened,
#[error("the DTLS transport has not started yet")]
ErrDtlsTransportNotStarted,
#[error("failed extracting keys from DTLS for SRTP")]
ErrDtlsKeyExtractionFailed,
#[error("failed to start SRTP")]
ErrFailedToStartSRTP,
#[error("failed to start SRTCP")]
ErrFailedToStartSRTCP,
#[error("attempted to start DTLSTransport that is not in new state")]
ErrInvalidDTLSStart,
#[error("peer didn't provide certificate via DTLS")]
ErrNoRemoteCertificate,
#[error("identity provider is not implemented")]
ErrIdentityProviderNotImplemented,
#[error("remote certificate does not match any fingerprint")]
ErrNoMatchingCertificateFingerprint,
#[error("unsupported fingerprint algorithm")]
ErrUnsupportedFingerprintAlgorithm,
#[error("ICE connection not started")]
ErrICEConnectionNotStarted,
#[error("unknown candidate type")]
ErrICECandidateTypeUnknown,
#[error("cannot convert ice.CandidateType into webrtc.ICECandidateType, invalid type")]
ErrICEInvalidConvertCandidateType,
#[error("ICEAgent does not exist")]
ErrICEAgentNotExist,
#[error("unable to convert ICE candidates to ICECandidates")]
ErrICECandidatesConversionFailed,
#[error("unknown ICE Role")]
ErrICERoleUnknown,
#[error("unknown protocol")]
ErrICEProtocolUnknown,
#[error("gatherer not started")]
ErrICEGathererNotStarted,
#[error("unknown network type")]
ErrNetworkTypeUnknown,
#[error("new sdp does not match previous offer")]
ErrSDPDoesNotMatchOffer,
#[error("new sdp does not match previous answer")]
ErrSDPDoesNotMatchAnswer,
#[error("provided value is not a valid enum value of type SDPType")]
ErrPeerConnSDPTypeInvalidValue,
#[error("invalid state change op")]
ErrPeerConnStateChangeInvalid,
#[error("unhandled state change op")]
ErrPeerConnStateChangeUnhandled,
#[error("invalid SDP type supplied to SetLocalDescription()")]
ErrPeerConnSDPTypeInvalidValueSetLocalDescription,
#[error("remoteDescription contained media section without mid value")]
ErrPeerConnRemoteDescriptionWithoutMidValue,
#[error("remoteDescription has not been set yet")]
ErrPeerConnRemoteDescriptionNil,
#[error("single media section has an explicit SSRC")]
ErrPeerConnSingleMediaSectionHasExplicitSSRC,
#[error("could not add transceiver for remote SSRC")]
ErrPeerConnRemoteSSRCAddTransceiver,
#[error("mid RTP Extensions required for Simulcast")]
ErrPeerConnSimulcastMidRTPExtensionRequired,
#[error("stream id RTP Extensions required for Simulcast")]
ErrPeerConnSimulcastStreamIDRTPExtensionRequired,
#[error("incoming SSRC failed Simulcast probing")]
ErrPeerConnSimulcastIncomingSSRCFailed,
#[error("failed collecting stats")]
ErrPeerConnStatsCollectionFailed,
#[error("add_transceiver_from_kind only accepts one RTPTransceiverInit")]
ErrPeerConnAddTransceiverFromKindOnlyAcceptsOne,
#[error("add_transceiver_from_track only accepts one RTPTransceiverInit")]
ErrPeerConnAddTransceiverFromTrackOnlyAcceptsOne,
#[error("add_transceiver_from_kind currently only supports recvonly")]
ErrPeerConnAddTransceiverFromKindSupport,
#[error("add_transceiver_from_track currently only supports sendonly and sendrecv")]
ErrPeerConnAddTransceiverFromTrackSupport,
#[error("TODO set_identity_provider")]
ErrPeerConnSetIdentityProviderNotImplemented,
#[error("write_rtcp failed to open write_stream")]
ErrPeerConnWriteRTCPOpenWriteStream,
#[error("cannot find transceiver with mid")]
ErrPeerConnTransceiverMidNil,
#[error("DTLSTransport must not be nil")]
ErrRTPReceiverDTLSTransportNil,
#[error("Receive has already been called")]
ErrRTPReceiverReceiveAlreadyCalled,
#[error("unable to find stream for Track with SSRC")]
ErrRTPReceiverWithSSRCTrackStreamNotFound,
#[error("no trackStreams found for SSRC")]
ErrRTPReceiverForSSRCTrackStreamNotFound,
#[error("no trackStreams found for RID")]
ErrRTPReceiverForRIDTrackStreamNotFound,
#[error("invalid RTP Receiver transition from {from} to {to}")]
ErrRTPReceiverStateChangeInvalid {
from: rtp_receiver::State,
to: rtp_receiver::State,
},
#[error("Track must not be nil")]
ErrRTPSenderTrackNil,
#[error("RTPSender must not be nil")]
ErrRTPSenderNil,
#[error("RTPReceiver must not be nil")]
ErrRTPReceiverNil,
#[error("DTLSTransport must not be nil")]
ErrRTPSenderDTLSTransportNil,
#[error("Send has already been called")]
ErrRTPSenderSendAlreadyCalled,
#[error("errRTPSenderTrackNil")]
ErrRTPTransceiverCannotChangeMid,
#[error("invalid state change in RTPTransceiver.setSending")]
ErrRTPTransceiverSetSendingInvalidState,
#[error("unsupported codec type by this transceiver")]
ErrRTPTransceiverCodecUnsupported,
#[error("DTLS not established")]
ErrSCTPTransportDTLS,
#[error("add_transceiver_sdp() called with 0 transceivers")]
ErrSDPZeroTransceivers,
#[error("invalid Media Section. Media + DataChannel both enabled")]
ErrSDPMediaSectionMediaDataChanInvalid,
#[error(
"invalid Media Section. Can not have multiple tracks in one MediaSection in UnifiedPlan"
)]
ErrSDPMediaSectionMultipleTrackInvalid,
#[error("set_answering_dtlsrole must DTLSRoleClient or DTLSRoleServer")]
ErrSettingEngineSetAnsweringDTLSRole,
#[error("can't rollback from stable state")]
ErrSignalingStateCannotRollback,
#[error(
"invalid proposed signaling state transition from {} applying {} {}",
from,
if *is_local { "local" } else { "remote" },
applying
)]
ErrSignalingStateProposedTransitionInvalid {
from: RTCSignalingState,
applying: RTCSdpType,
is_local: bool,
},
#[error("cannot convert to StatsICECandidatePairStateSucceeded invalid ice candidate state")]
ErrStatsICECandidateStateInvalid,
#[error("ICETransport can only be called in ICETransportStateNew")]
ErrICETransportNotInNew,
#[error("bad Certificate PEM format")]
ErrCertificatePEMFormatError,
#[error("SCTP is not established")]
ErrSCTPNotEstablished,
#[error("DataChannel is not opened")]
ErrClosedPipe,
#[error("Interceptor is not bind")]
ErrInterceptorNotBind,
#[error("excessive retries in CreateOffer")]
ErrExcessiveRetries,
#[error("not long enough to be a RTP Packet")]
ErrRTPTooShort,
#[error("{0}")]
Util(#[from] util::Error),
#[error("{0}")]
Ice(#[from] ice::Error),
#[error("{0}")]
Srtp(#[from] srtp::Error),
#[error("{0}")]
Dtls(#[from] dtls::Error),
#[error("{0}")]
Data(#[from] data::Error),
#[error("{0}")]
Sctp(#[from] sctp::Error),
#[error("{0}")]
Sdp(#[from] sdp::Error),
#[error("{0}")]
Interceptor(#[from] interceptor::Error),
#[error("{0}")]
Rtcp(#[from] rtcp::Error),
#[error("{0}")]
Rtp(#[from] rtp::Error),
#[error("utf-8 error: {0}")]
Utf8(#[from] FromUtf8Error),
#[error("{0}")]
RcGen(#[from] RcgenError),
#[error("mpsc send: {0}")]
MpscSend(String),
#[error("parse int: {0}")]
ParseInt(#[from] ParseIntError),
#[error("parse url: {0}")]
ParseUrl(#[from] url::ParseError),
/// Error parsing a given PEM string.
#[error("invalid PEM: {0}")]
InvalidPEM(String),
#[allow(non_camel_case_types)]
#[error("{0}")]
new(String),
}
pub type OnErrorHdlrFn =
Box<dyn (FnMut(Error) -> Pin<Box<dyn Future<Output = ()> + Send + 'static>>) + Send + Sync>;
// Because Tokio SendError is parameterized, we sadly lose the backtrace.
impl<T> From<MpscSendError<T>> for Error {
fn from(e: MpscSendError<T>) -> Self {
Error::MpscSend(e.to_string())
}
}
impl From<Error> for interceptor::Error {
fn from(e: Error) -> Self {
// this is a bit lol, but we do preserve the stack trace
interceptor::Error::Util(util::Error::from_std(e))
}
}
impl PartialEq<ice::Error> for Error {
fn eq(&self, other: &ice::Error) -> bool {
if let Error::Ice(e) = self {
return e == other;
}
false
}
}
/// flatten_errs flattens multiple errors into one
pub fn flatten_errs(errs: Vec<impl Into<Error>>) -> Result<()> {
if errs.is_empty() {
Ok(())
} else {
let errs_strs: Vec<String> = errs.into_iter().map(|e| e.into().to_string()).collect();
Err(Error::new(errs_strs.join("\n")))
}
}