void PositionPacket::writeRawPacket(BinaryWriter& stream) const {
stream.write(reinterpret_cast<const char*>(&mNotUsed1), sizeof(mNotUsed1));
stream << mGyro1 << mTemp1 << mAccel1X << mAccel1Y << mGyro2 << mTemp2 <<
mAccel2X << mAccel2Y << mGyro3 << mTemp3 << mAccel3X << mAccel3Y;
stream.write(reinterpret_cast<const char*>(&mNotUsed2), sizeof(mNotUsed2));
stream << mGPSTimestamp;
stream.write(reinterpret_cast<const char*>(&mNotUsed3), sizeof(mNotUsed3));
stream.write(reinterpret_cast<const char*>(&mNMEASentence),
sizeof(mNMEASentence));
stream.write(reinterpret_cast<const char*>(&mNotUsed4), sizeof(mNotUsed4));
}
/*
* 解析結果をバイナリ形式のファイルに出力する。
* 内部コードを別ファイルにする用途で使用する。
*
* 各アセンブリは以下のフォーマット形式で保存される
* [AssemblyName : string ] アセンブリの名前
* [StackFrame : u32 ] スタックフレーム
* [Address : u32 ] 関数アドレス
* [Args : u32 ] 関数パラメータ数
* [CodeSize : u32 ] コード領域サイズ
* [Code : byte[ContentSize]] コード領域
*/
VMAssembleOutput::VMAssembleOutput( IAssembleReader* reader , const char* fileName ){
BinaryWriter bw;
int index = 0;
AsmInfo* assemblyInfo = reader->getAssembly(0);
while( assemblyInfo ){
bw.writeString( assemblyInfo->name() );
bw.writeUInt32( assemblyInfo->stackFrame() );
bw.writeUInt32( assemblyInfo->addr() );
bw.writeUInt32( assemblyInfo->Args() );
bw.writeUInt32( assemblyInfo->CodeSize() );
for( size_t i = 0 ; i < assemblyInfo->CodeSize() ; i++ ){
bw.write( assemblyInfo->getCommand(i) );
}
assemblyInfo = reader->getAssembly(++index);
}
CStream stream = bw.getStream();
FILE* fp = NULL;
fopen_s( &fp , fileName , "wb" );
assert( fp );
while( stream->hasNext() ){
unsigned char content[1];
content[0] = static_cast<unsigned char>( stream->getByte() );
fwrite( content , sizeof( unsigned char ) , sizeof( content ) , fp );
}
fclose( fp );
}
void RTMFPWriter::flush(BinaryWriter& writer,UInt64 stage,UInt8 flags,bool header,const RTMFPMessage& message, UInt32 offset, UInt16 size) {
if(_stageAck==0 && header)
flags |= MESSAGE_HEADER;
if(size==0)
flags |= MESSAGE_ABANDONMENT;
if(state()==CLOSED && _messages.size()==1) // On LAST message
flags |= MESSAGE_END;
// TRACE("RTMFPWriter ",id," stage ",stage);
writer.write8(flags);
if(header) {
writer.write7BitLongValue(id);
writer.write7BitLongValue(stage);
writer.write7BitLongValue(stage-_stageAck);
// signature
if(_stageAck==0) {
writer.write8((UInt8)signature.size()).write(signature);
// No write this in the case where it's a new flow!
if(flowId>0) {
writer.write8(1+Util::Get7BitValueSize(flowId)); // following size
writer.write8(0x0a); // Unknown!
writer.write7BitLongValue(flowId);
}
writer.write8(0); // marker of end for this part
}
}
if (size == 0)
return;
if (offset < message.frontSize()) {
UInt8 count = message.frontSize()-offset;
if (size<count)
count = (UInt8)size;
writer.write(message.front()+offset,count);
size -= count;
if (size == 0)
return;
offset += count;
}
writer.write(message.body()+offset-message.frontSize(), 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
void Physics::write(BinaryWriter & output) const
{
output.write(centerOfMass);
output.write(mass);
}
