THENG
/
ZLMediaKit
mirror of https://gitcode.com/gh_mirrors/zlme/ZLMediaKit.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixed ice candidate error

This commit is contained in:
cqm 2023-03-02 11:54:22 +08:00
parent 91efab281e
commit 42370aa312
5 changed files with 69 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
webrtc/IceServer.cpp
View File

@ -26,6 +26,10 @@ namespace RTC
{
/* Static. */
/* Instance methods. */
bool isSameTuple(const TransportTuple* tuple1, const TransportTuple* tuple2) {
return tuple1 == tuple2;
// return memcmp(tuple1, tuple2, sizeof(RTC::TransportTuple)) == 0);
}
IceServer::IceServer(Listener* listener, const std::string& usernameFragment, const std::string& password)
: listener(listener), usernameFragment(usernameFragment), password(password)
@ -198,8 +202,12 @@ namespace RTC
// Create a success response.
RTC::StunPacket* response = packet->CreateSuccessResponse();
sockaddr_storage peerAddr;
socklen_t addr_len = sizeof(peerAddr);
getpeername(tuple->getSock()->rawFD(), (struct sockaddr *)&peerAddr, &addr_len);
// Add XOR-MAPPED-ADDRESS.
response->SetXorMappedAddress(tuple);
response->SetXorMappedAddress((struct sockaddr *)&peerAddr);
// Authenticate the response.
if (this->oldPassword.empty())
@ -260,9 +268,9 @@ namespace RTC
for (; it != this->tuples.end(); ++it)
{
RTC::TransportTuple* storedTuple = std::addressof(*it);
RTC::TransportTuple* storedTuple = *it;
if (memcmp(storedTuple, tuple, sizeof (RTC::TransportTuple)) == 0)
if (isSameTuple(storedTuple,tuple))
{
removedTuple = storedTuple;
@ -287,7 +295,7 @@ namespace RTC
// Mark the first tuple as selected tuple (if any).
if (this->tuples.begin() != this->tuples.end())
{
SetSelectedTuple(std::addressof(*this->tuples.begin()));
SetSelectedTuple(*this->tuples.begin());
}
// Or just emit 'disconnected'.
else
@ -477,9 +485,9 @@ namespace RTC
MS_TRACE();
// Add the new tuple at the beginning of the list.
this->tuples.push_front(*tuple);
this->tuples.push_front(tuple);
auto* storedTuple = std::addressof(*this->tuples.begin());
auto* storedTuple = tuple; //std::addressof(*this->tuples.begin());
// Return the address of the inserted tuple.
return storedTuple;
@ -495,15 +503,15 @@ namespace RTC
return nullptr;
// Check the current selected tuple.
if (memcmp(selectedTuple, tuple, sizeof (RTC::TransportTuple)) == 0)
if (isSameTuple(selectedTuple, tuple))
return this->selectedTuple;
// Otherwise check other stored tuples.
for (const auto& it : this->tuples)
{
auto* storedTuple = const_cast<RTC::TransportTuple*>(std::addressof(it));
auto* storedTuple = const_cast<RTC::TransportTuple*>(it);
if (memcmp(storedTuple, tuple, sizeof (RTC::TransportTuple)) == 0)
if (isSameTuple(storedTuple, tuple))
return storedTuple;
}

7
webrtc/IceServer.hpp
View File

@ -20,6 +20,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#define MS_RTC_ICE_SERVER_HPP
#include "StunPacket.hpp"
#include "Network/Session.h"
#include "logger.h"
#include "Utils.hpp"
#include <list>
@ -27,11 +28,11 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <functional>
#include <memory>
using _TransportTuple = struct sockaddr;
//using _TransportTuple = struct sockaddr;
namespace RTC
{
using TransportTuple = _TransportTuple;
using TransportTuple = toolkit::Session;
class IceServer
{
public:
@ -125,7 +126,7 @@ namespace RTC
std::string oldUsernameFragment;
std::string oldPassword;
IceState state{ IceState::NEW };
std::list<RTC::TransportTuple> tuples;
std::list<RTC::TransportTuple*> tuples;
RTC::TransportTuple* selectedTuple{ nullptr };
//最大不超过mtu
static constexpr size_t StunSerializeBufferSize{ 1600 };

6
webrtc/WebRtcSession.cpp
View File

@ -94,7 +94,7 @@ void WebRtcSession::onRecv_l(const char *data, size_t len) {
}
_ticker.resetTime();
CHECK(_transport);
_transport->inputSockData((char *)data, len, (struct sockaddr *)&_peer_addr);
_transport->inputSockData((char *)data, len, this);// (struct sockaddr *)&_peer_addr);
}
void WebRtcSession::onRecv(const Buffer::Ptr &buffer) {
@ -114,9 +114,11 @@ void WebRtcSession::onError(const SockException &err) {
if (!_transport) {
return;
}
auto self = shared_from_this();
auto transport = std::move(_transport);
getPoller()->async([transport] {
getPoller()->async([transport, self] {
//延时减引用，防止使用transport对象时，销毁对象
transport->RemoveTuple(self.get());
}, false);
}

59
webrtc/WebRtcTransport.cpp
View File

@ -75,6 +75,18 @@ static void translateIPFromEnv(std::vector<std::string> &v) {
}
}
const char* sockTypeStr(Session* session) {
if (session) {
switch (session->getSock()->sockType()) {
case SockNum::Sock_TCP:
return "tcp";
case SockNum::Sock_UDP:
return "udp";
}
}
return "unknown";
}
WebRtcTransport::WebRtcTransport(const EventPoller::Ptr &poller) {
_poller = poller;
_identifier = "zlm_" + to_string(++s_key);
@ -109,16 +121,17 @@ void WebRtcTransport::OnIceServerSendStunPacket(
sendSockData((char *)packet->GetData(), packet->GetSize(), tuple);
}
void WebRtcTransport::OnIceServerSelectedTuple(const RTC::IceServer *iceServer, RTC::TransportTuple *tuple) {
InfoL;
void WebRtcTransportImp::OnIceServerSelectedTuple(const RTC::IceServer *iceServer, RTC::TransportTuple *tuple) {
InfoL << getIdentifier() << " select tuple " << sockTypeStr(tuple) << " " << tuple->get_peer_ip() << ":" << tuple->get_peer_port();
_selected_session = tuple->shared_from_this();
}
void WebRtcTransport::OnIceServerConnected(const RTC::IceServer *iceServer) {
InfoL;
InfoL << getIdentifier();
}
void WebRtcTransport::OnIceServerCompleted(const RTC::IceServer *iceServer) {
InfoL;
InfoL << getIdentifier();
if (_answer_sdp->media[0].role == DtlsRole::passive) {
_dtls_transport->Run(RTC::DtlsTransport::Role::SERVER);
} else {
@ -127,7 +140,7 @@ void WebRtcTransport::OnIceServerCompleted(const RTC::IceServer *iceServer) {
}
void WebRtcTransport::OnIceServerDisconnected(const RTC::IceServer *iceServer) {
InfoL;
InfoL << getIdentifier();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -153,16 +166,16 @@ void WebRtcTransport::OnDtlsTransportSendData(
}
void WebRtcTransport::OnDtlsTransportConnecting(const RTC::DtlsTransport *dtlsTransport) {
InfoL;
InfoL << getIdentifier();
}
void WebRtcTransport::OnDtlsTransportFailed(const RTC::DtlsTransport *dtlsTransport) {
InfoL;
InfoL << getIdentifier();
onShutdown(SockException(Err_shutdown, "dtls transport failed"));
}
void WebRtcTransport::OnDtlsTransportClosed(const RTC::DtlsTransport *dtlsTransport) {
InfoL;
InfoL << getIdentifier();
onShutdown(SockException(Err_shutdown, "dtls close notify received"));
}
@ -178,7 +191,7 @@ void WebRtcTransport::OnDtlsTransportApplicationDataReceived(
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef ENABLE_SCTP
void WebRtcTransport::OnSctpAssociationConnecting(RTC::SctpAssociation *sctpAssociation) {
TraceL;
TraceL << getIdentifier();
}
void WebRtcTransport::OnSctpAssociationConnected(RTC::SctpAssociation *sctpAssociation) {
@ -293,7 +306,7 @@ static bool isDtls(char *buf) {
}
static string getPeerAddress(RTC::TransportTuple *tuple) {
return SockUtil::inet_ntoa(tuple);
return tuple->get_peer_ip();// SockUtil::inet_ntoa(tuple);
}
void WebRtcTransport::inputSockData(char *buf, int len, RTC::TransportTuple *tuple) {
@ -409,24 +422,27 @@ void WebRtcTransportImp::onDestory() {
}
void WebRtcTransportImp::onSendSockData(Buffer::Ptr buf, bool flush, RTC::TransportTuple *tuple) {
if (tuple == nullptr) {
if (!_selected_session) {
WarnL << "send data failed:" << buf->size();
return;
}
tuple = _selected_session.get();
}
// 一次性发送一帧的rtp数据，提高网络io性能
if (_selected_session->getSock()->sockType() == SockNum::Sock_TCP) {
if (tuple->getSock()->sockType() == SockNum::Sock_TCP) {
// 增加tcp两字节头
auto len = buf->size();
char tcp_len[2] = { 0 };
tcp_len[0] = (len >> 8) & 0xff;
tcp_len[1] = len & 0xff;
_selected_session->SockSender::send(tcp_len, 2);
tuple->SockSender::send(tcp_len, 2);
}
_selected_session->send(std::move(buf));
tuple->send(std::move(buf));
if (flush) {
_selected_session->flushAll();
tuple->flushAll();
}
}
@ -1048,15 +1064,16 @@ void WebRtcTransportImp::onShutdown(const SockException &ex) {
}
}
void WebRtcTransportImp::RemoveTuple(RTC::TransportTuple* tuple)
{
InfoL << getIdentifier() << " RemoveTuple " << tuple->get_peer_ip() << ":" << tuple->get_peer_port();
this->_history_sessions.erase(tuple);
this->_ice_server->RemoveTuple(tuple);
}
void WebRtcTransportImp::setSession(Session::Ptr session) {
_history_sessions.emplace(session.get(), session);
if (_selected_session) {
InfoL << "rtc network changed: " << _selected_session->get_peer_ip() << ":"
<< _selected_session->get_peer_port() << " -> " << session->get_peer_ip() << ":"
<< session->get_peer_port() << ", id:" << getIdentifier();
}
_selected_session = std::move(session);
_selected_session->setSendFlushFlag(false);
session->setSendFlushFlag(false);
unrefSelf();
}

5
webrtc/WebRtcTransport.h
View File

@ -130,7 +130,6 @@ protected:
protected:
//// ice相关的回调 ///
void OnIceServerSendStunPacket(const RTC::IceServer *iceServer, const RTC::StunPacket *packet, RTC::TransportTuple *tuple) override;
void OnIceServerSelectedTuple(const RTC::IceServer *iceServer, RTC::TransportTuple *tuple) override;
void OnIceServerConnected(const RTC::IceServer *iceServer) override;
void OnIceServerCompleted(const RTC::IceServer *iceServer) override;
void OnIceServerDisconnected(const RTC::IceServer *iceServer) override;
@ -170,11 +169,11 @@ private:
protected:
RtcSession::Ptr _offer_sdp;
RtcSession::Ptr _answer_sdp;
std::shared_ptr<RTC::IceServer> _ice_server;
private:
std::string _identifier;
EventPoller::Ptr _poller;
std::shared_ptr<RTC::IceServer> _ice_server;
std::shared_ptr<RTC::DtlsTransport> _dtls_transport;
std::shared_ptr<RTC::SrtpSession> _srtp_session_send;
std::shared_ptr<RTC::SrtpSession> _srtp_session_recv;
@ -249,7 +248,9 @@ public:
void createRtpChannel(const std::string &rid, uint32_t ssrc, MediaTrack &track);
void RemoveTuple(RTC::TransportTuple* tuple);
protected:
void OnIceServerSelectedTuple(const RTC::IceServer *iceServer, RTC::TransportTuple *tuple) override;
WebRtcTransportImp(const EventPoller::Ptr &poller,bool preferred_tcp = false);
void OnDtlsTransportApplicationDataReceived(const RTC::DtlsTransport *dtlsTransport, const uint8_t *data, size_t len) override;
void onStartWebRTC() override;