void RTMFPHandshake::receive(const SocketAddress& address, BinaryReader& request) {
if(!Session::receive(address, request))
return;
UInt8 marker = request.read8();
if(marker!=0x0b) {
ERROR("Marker handshake wrong : should be 0b and not ",Format<UInt8>("%.2x",marker));
return;
}
UInt16 time = request.read16();
UInt8 id = request.read8();
request.shrink(request.read16()); // length
BinaryWriter response(packet(),RTMFP_MAX_PACKET_SIZE);
response.clear(RTMFP_HEADER_SIZE+3); // header + type and size
UInt8 idResponse = handshakeHandler(id,address, request,response);
if (!idResponse)
return;
BinaryWriter(response.data() + RTMFP_HEADER_SIZE, 3).write8(idResponse).write16(response.size() - RTMFP_HEADER_SIZE - 3);
(UInt32&)farId = 0;
flush(0x0b, response.size());
}
void ackMessageHandler(UInt32 ackCount,UInt32 lostCount,BinaryReader& content,UInt32 available,UInt32 size) {
if(available==0 || content.read8()!=_type)
return;
qos.add(content.read32(),ackCount,lostCount,size);
}
UInt8 RTMFPHandshake::handshakeHandler(UInt8 id,const SocketAddress& address, BinaryReader& request,BinaryWriter& response) {
switch(id){
case 0x30: {
request.read7BitValue(); // = epdLen + 2 (useless)
UInt16 epdLen = request.read7BitValue()-1;
UInt8 type = request.read8();
string epd;
request.read(epdLen,epd);
string tag;
request.read(16,tag);
response.write7BitValue(tag.size()).write(tag);
if(type == 0x0f) {
const UInt8* peerId((const UInt8*)epd.c_str());
RTMFPSession* pSessionWanted = _sessions.findByPeer<RTMFPSession>(peerId);
if(pSessionWanted) {
if(pSessionWanted->failed())
return 0x00; // TODO no way in RTMFP to tell "died!"
/// Udp hole punching
UInt32 times = attempt(tag);
RTMFPSession* pSession(NULL);
if(times > 0 || address.host() == pSessionWanted->peer.address.host()) // try in first just with public address (excepting if the both peer are on the same machine)
pSession = _sessions.findByAddress<RTMFPSession>(address,Socket::DATAGRAM);
bool hasAnExteriorPeer(pSessionWanted->p2pHandshake(tag,address,times,pSession));
// public address
RTMFP::WriteAddress(response,pSessionWanted->peer.address, RTMFP::ADDRESS_PUBLIC);
DEBUG("P2P address initiator exchange, ",pSessionWanted->peer.address.toString());
if (hasAnExteriorPeer && pSession->peer.serverAddress.host()!=pSessionWanted->peer.address.host()) {
// the both peer see the server in a different way (and serverAddress.host()!= public address host written above),
// Means an exterior peer, but we can't know which one is the exterior peer
// so add an interiorAddress build with how see eachone the server on the both side
SocketAddress interiorAddress(pSession->peer.serverAddress.host(), pSessionWanted->peer.address.port());
RTMFP::WriteAddress(response,interiorAddress, RTMFP::ADDRESS_PUBLIC);
DEBUG("P2P address initiator exchange, ",interiorAddress.toString());
}
// local address
for(const SocketAddress& address : pSessionWanted->peer.localAddresses) {
RTMFP::WriteAddress(response,address, RTMFP::ADDRESS_LOCAL);
DEBUG("P2P address initiator exchange, ",address.toString());
}
// add the turn address (RelayServer) if possible and required
if (pSession && times>0) {
UInt8 timesBeforeTurn(0);
if(pSession->peer.parameters().getNumber("timesBeforeTurn",timesBeforeTurn) && timesBeforeTurn>=times) {
UInt16 port = invoker.relayer.relay(pSession->peer.address,pSessionWanted->peer.address,20); // 20 sec de timeout is enough for RTMFP!
if (port > 0) {
SocketAddress address(pSession->peer.serverAddress.host(), port);
RTMFP::WriteAddress(response, address, RTMFP::ADDRESS_REDIRECTION);
} // else ERROR already display by RelayServer class
}
}
return 0x71;
}
DEBUG("UDP Hole punching, session ", Util::FormatHex(peerId, ID_SIZE, LOG_BUFFER), " wanted not found")
set<SocketAddress> addresses;
peer.onRendezVousUnknown(peerId,addresses);
set<SocketAddress>::const_iterator it;
for(it=addresses.begin();it!=addresses.end();++it) {
if(it->host().isWildcard())
continue;
if(address == *it)
WARN("A client tries to connect to himself (same ", address.toString()," address)");
RTMFP::WriteAddress(response,*it,RTMFP::ADDRESS_REDIRECTION);
DEBUG("P2P address initiator exchange, ",it->toString());
}
return addresses.empty() ? 0 : 0x71;
}
if(type == 0x0a){
/// RTMFPHandshake
HelloAttempt& attempt = AttemptCounter::attempt<HelloAttempt>(tag);
Peer& peer(*_pPeer);
// Fill peer infos
peer.properties().clear();
string serverAddress;
Util::UnpackUrl(epd, serverAddress, (string&)peer.path,(string&)peer.query);
peer.setServerAddress(serverAddress);
Util::UnpackQuery(peer.query, peer.properties());
Exception ex;
set<SocketAddress> addresses;
peer.onHandshake(attempt.count+1,addresses);
if(!addresses.empty()) {
set<SocketAddress>::iterator it;
for(it=addresses.begin();it!=addresses.end();++it) {
if (it->host().isWildcard())
RTMFP::WriteAddress(response, peer.serverAddress, RTMFP::ADDRESS_REDIRECTION);
else
RTMFP::WriteAddress(response, *it, RTMFP::ADDRESS_REDIRECTION);
}
return 0x71;
}
// New RTMFPCookie
RTMFPCookie* pCookie = attempt.pCookie;
if (!pCookie) {
pCookie = new RTMFPCookie(*this, invoker, tag, _pPeer);
if (!pCookie->run(ex)) {
delete pCookie;
ERROR("RTMFPCookie creation, ", ex.error())
return 0;
}
_pPeer.reset(new Peer((Handler&)invoker)); // reset peer
_cookies.emplace(pCookie->value(), pCookie);
attempt.pCookie = pCookie;
}
// response
response.write8(COOKIE_SIZE);
response.write(pCookie->value(),COOKIE_SIZE);
// instance id (certificat in the middle)
response.write(_certificat,sizeof(_certificat));
return 0x70;
} else
UInt8 RTMFPHandshake::handshakeHandler(UInt8 id,const SocketAddress& address, BinaryReader& request,BinaryWriter& response) {
switch(id){
case 0x30: {
request.next(1);
UInt8 epdLen = request.read8()-1;
UInt8 type = request.read8();
string epd;
request.read(epdLen,epd);
string tag;
request.read(16,tag);
response.write8(tag.size()).write(tag);
if(type == 0x0f) {
const UInt8* peerId = (const UInt8*)epd.c_str();
RTMFPSession* pSessionWanted = _sessions.findByPeer<RTMFPSession>(peerId);
if(pSessionWanted) {
if(pSessionWanted->failed())
return 0x00; // TODO no way in RTMFP to tell "died!"
/// Udp hole punching
UInt32 times = attempt(tag);
RTMFPSession* pSession(NULL);
if(times > 0 || address.host() == pSessionWanted->peer.address.host())
pSession = _sessions.findByAddress<RTMFPSession>(address,Socket::DATAGRAM);
pSessionWanted->p2pHandshake(tag,address,times,pSession);
RTMFP::WriteAddress(response,pSessionWanted->peer.address, RTMFP::ADDRESS_PUBLIC);
DEBUG("P2P address initiator exchange, ",pSessionWanted->peer.address.toString());
for(const SocketAddress& address : pSessionWanted->peer.localAddresses) {
RTMFP::WriteAddress(response,address, RTMFP::ADDRESS_LOCAL);
DEBUG("P2P address initiator exchange, ",address.toString());
}
// add the turn address (RelayServer) if possible and required
if (pSession && times>0) {
UInt8 timesBeforeTurn(0);
if(pSession->peer.parameters().getNumber("timesBeforeTurn",timesBeforeTurn) && timesBeforeTurn>=times) {
UInt16 port = invoker.relayer.relay(pSession->peer.address,pSessionWanted->peer.address,20); // 20 sec de timeout is enough for RTMFP!
if (port > 0) {
string host;
SocketAddress::SplitLiteral(pSession->peer.serverAddress, host);
bool success(false);
Exception ex;
SocketAddress address;
EXCEPTION_TO_LOG(success=address.set(ex,host, port),"RTMFP turn impossible")
if (success)
RTMFP::WriteAddress(response, address, RTMFP::ADDRESS_REDIRECTION);
} // else ERROR already display by RelayServer class
}
}
return 0x71;
}
DEBUG("UDP Hole punching, session ", Util::FormatHex(peerId, ID_SIZE, LOG_BUFFER), " wanted not found")
set<SocketAddress> addresses;
peer.onRendezVousUnknown(peerId,addresses);
set<SocketAddress>::const_iterator it;
for(it=addresses.begin();it!=addresses.end();++it) {
if(it->host().isWildcard())
continue;
if(address == *it)
WARN("A client tries to connect to himself (same ", address.toString()," address)");
RTMFP::WriteAddress(response,*it,RTMFP::ADDRESS_REDIRECTION);
DEBUG("P2P address initiator exchange, ",it->toString());
}
return addresses.empty() ? 0 : 0x71;
}
void RTMFPSession::receive(const SocketAddress& address, BinaryReader& packet) {
if (!Session::receive(address, packet))
return;
// Read packet
UInt8 marker = packet.read8()|0xF0;
_timeSent = packet.read16();
// with time echo
if(marker == 0xFD) {
UInt16 time = RTMFP::TimeNow();
UInt16 timeEcho = packet.read16();
if(timeEcho>time) {
if(timeEcho-time<30)
time=0;
else
time += 0xFFFF-timeEcho;
timeEcho = 0;
}
peer.setPing((time-timeEcho)*RTMFP_TIMESTAMP_SCALE);
}
else if(marker != 0xF9)
WARN("RTMFPPacket marker unknown : ", Format<UInt8>("%02x",marker));
// Variables for request (0x10 and 0x11)
UInt8 flags;
RTMFPFlow* pFlow=NULL;
UInt64 stage=0;
UInt64 deltaNAck=0;
UInt8 type = packet.available()>0 ? packet.read8() : 0xFF;
bool answer = false;
// Can have nested queries
while(type!=0xFF) {
UInt16 size = packet.read16();
PacketReader message(packet.current(),size);
switch(type) {
case 0x0c :
fail("failed on client side");
break;
case 0x4c :
/// Session death!
_failed = true; // to avoid the fail signal!!
kill();
return;
/// KeepAlive
case 0x01 :
if(!peer.connected)
fail("Timeout connection client");
else
writeMessage(0x41,0);
case 0x41 :
_timesKeepalive=0;
break;
case 0x5e : {
// RTMFPFlow exception!
UInt64 id = message.read7BitLongValue();
RTMFPWriter* pRTMFPWriter = writer(id);
if(pRTMFPWriter)
pRTMFPWriter->fail("Writer rejected on session ",name());
else
WARN("RTMFPWriter ", id, " unfound for failed signal on session ", name());
break;
}
case 0x18 :
/// This response is sent when we answer with a Acknowledgment negative
// It contains the id flow
// I don't unsertand the usefulness...
//pFlow = &flow(message.read8());
//stage = pFlow->stageSnd();
// For the moment, we considerate it like a exception
fail("ack negative from server"); // send fail message immediatly
break;
case 0x51 : {
/// Acknowledgment
UInt64 id = message.read7BitLongValue();
RTMFPWriter* pRTMFPWriter = writer(id);
if(pRTMFPWriter)
pRTMFPWriter->acknowledgment(message);
else
WARN("RTMFPWriter ",id," unfound for acknowledgment on session ",name());
break;
}
/// Request
// 0x10 normal request
// 0x11 special request, in repeat case (following stage request)
case 0x10 : {
flags = message.read8();
UInt64 idFlow = message.read7BitLongValue();
stage = message.read7BitLongValue()-1;
deltaNAck = message.read7BitLongValue()-1;
if (_failed)
break;
map<UInt64,RTMFPFlow*>::const_iterator it = _flows.find(idFlow);
pFlow = it==_flows.end() ? NULL : it->second;
// Header part if present
if(flags & MESSAGE_HEADER) {
string signature;
message.read(message.read8(),signature);
if(!pFlow)
pFlow = createFlow(idFlow,signature);
if(message.read8()>0) {
// Fullduplex header part
if(message.read8()!=0x0A)
WARN("Unknown fullduplex header part for the flow ",idFlow)
else
message.read7BitLongValue(); // Fullduplex useless here! Because we are creating a new RTMFPFlow!
// Useless header part
UInt8 length=message.read8();
while(length>0 && message.available()) {
WARN("Unknown message part on flow ",idFlow);
message.next(length);
length=message.read8();
}
if(length>0)
ERROR("Bad header message part, finished before scheduled");
}
}
if(!pFlow) {
WARN("RTMFPFlow ",idFlow," unfound");
if (_pFlowNull)
((UInt64&)_pFlowNull->id) = idFlow;
pFlow = _pFlowNull;
}
}
case 0x11 : {
++stage;
++deltaNAck;
// has Header?
if(type==0x11)
flags = message.read8();
// Process request
if (pFlow && !_failed) {
bool wasConnected(peer.connected);
pFlow->receive(stage, deltaNAck, message, flags);
if (!wasConnected && peer.connected) {
for (auto& it : _flowWriters)
it.second->open();
}
}
break;
}
default :
ERROR("RTMFPMessage type '", Format<UInt8>("%02x", type), "' unknown");
}
// Next
packet.next(size);
type = packet.available()>0 ? packet.read8() : 0xFF;
// Commit RTMFPFlow (pFlow means 0x11 or 0x10 message)
if(pFlow && type!= 0x11) {
pFlow->commit();
if(pFlow->consumed()) {
if (pFlow->critical()) {
if (!peer.connected) {
// without connection, nothing must be sent!
for (auto& it : _flowWriters)
it.second->clear();
}
fail(); // If connection fails, log is already displayed, and so fail the whole session!
} else {
_flows.erase(pFlow->id);
delete pFlow;
}
}
pFlow=NULL;
}
}
