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 OnStart()
{
asd::Engine::GetFile()->AddRootDirectory(asd::ToAString("Data/Texture.pack").c_str());
for (auto loop = 0; loop < 2; loop++)
{
//普通に読み込んだバイナリ
BinaryReader reader;
auto data = GetBinaryData(asd::ToAString("Data/Texture/Surface/Tile_Normal.png"));
reader.ReadIn(data.begin(), data.end());
//ファイル機能で読み込んだバイナリ
auto staticFile = asd::Engine::GetFile()->CreateStaticFile(asd::ToAString("Surface/Tile_Normal.png").c_str());
auto staticFileData = staticFile->GetBuffer();
int cnt = 0;
while (!reader.IsEmpty())
{
int8_t byteFromRaw = reader.Get<int8_t>();
int8_t byteFromFile = staticFileData[cnt++];
ASSERT_EQ(byteFromRaw, byteFromFile);
}
ASSERT_EQ(cnt, staticFileData.size());
}
}
void OnStart()
{
//普通に読み込んだバイナリ
BinaryReader reader;
auto data = GetBinaryData(asd::ToAString("Data/Texture/Surface/Tile_Normal.png"));
reader.ReadIn(data.begin(), data.end());
//ファイル機能で読み込んだバイナリ
asd::Engine::GetFile()->AddRootPackage(asd::ToAString("Data/Texture.pack").c_str());
auto streamFile = asd::Engine::GetFile()->CreateStreamFile(asd::ToAString("Surface/Tile_Normal.png").c_str());
std::vector<uint8_t> buffer;
streamFile->Read(buffer, streamFile->GetSize());
int cnt = 0;
while (!reader.IsEmpty())
{
auto byteFromRaw = reader.Get<uint8_t>();
auto byteFromFile = buffer[cnt++];
ASSERT_EQ(byteFromRaw, byteFromFile);
}
ASSERT_EQ(cnt, buffer.size());
}
void OutPoint::unserialize(BinaryReader & br)
{
if (br.getSizeRemaining() < 32)
throw BlockDeserializingException();
br.get_BinaryData(txHash_, 32);
txOutIndex_ = br.get_uint32_t();
}
Record::Record(Guid &id, long long length, BinaryReader &reader,
DatabaseImpl *_database) : reader(reader), database(_database)
{
this->id = id;
this->length = length;
long childrenSize;
reader >> childrenSize;
long long childrenStartPosition;
reader >> childrenStartPosition;
dataPosition = reader.Position();
reader.Position(childrenStartPosition);
vchildren.reserve(childrenSize);
for(int i =0;i < childrenSize;i++)
{
long long startPosition = reader.Position();
Guid childId;
reader >> childId;
long long childLength;
reader >> childLength;
IRecord *childRecord = new Record(childId,childLength,reader,_database);
vchildren.push_back(childRecord);
reader.Position(startPosition+childLength);
database->AddRecord(childRecord);
}
}
void WS::Unmask(BinaryReader& reader) {
UInt32 i;
UInt8 mask[4];
reader.read(sizeof(mask),mask);
UInt8* bytes = (UInt8*)reader.current();
for(i=0;i<reader.available();++i)
bytes[i] ^= mask[i%4];
}
void ReadData() {
if(reader_) {
while(((available_ - position_) < windowSize_) &&
(reader_->IsEOF() == false)) {
buffer_[BufferOffset(available_)] = reader_->ReadByte();
available_++;
}
}
}
void BmpImage::toGrayscale()
{
if (bitsPerPixel != 8 && bitsPerPixel != 24)
return;
int w = rowBytes();
int avg;
if (bitsPerPixel == 24)
{
ByteBuffer* bmpBuffer = new ByteBuffer(bitmapSize, bmpBits);
BinaryReader* reader = new BinaryReader(bmpBuffer);
byte blue, green, red;
for (unsigned int i = 0; i < height; i++)
{
for (unsigned int j = 0; j < width; j++)
{
blue = reader->readByte(i*w+j*3);
green = reader->readByte(i*w+j*3+1);
red = reader->readByte(i*w+j*3+2);
avg = (red + green + blue)/3;
avg = (avg << 16) | (avg << 8) | (avg);
bmpBuffer->seek(i*w+j*3);
bmpBuffer->addRGB(avg);
}
}
bmpBits = bmpBuffer->getBytes();
return;
}
int colorTableIndex;
for (unsigned int i = 0; i < height; i++)
{
for (unsigned int j = 0; j < width; j++)
{
colorTableIndex = bmpBits[i*w+j];
avg = (colorPalette[colorTableIndex] & 0x00FF0000) >> 16;
avg += (colorPalette[colorTableIndex] & 0x0000FF00) >> 8;
avg += (colorPalette[colorTableIndex] & 0x000000FF);
avg /= 3;
bmpBits[i*w+j] = avg;
}
}
for (int k = 0; k < colorPaletteSize; k++)
{
colorPalette[k] = (k << 16) | (k << 8) | (k);
}
}
void PositionPacket::readRawPacket(BinaryReader& stream) {
stream.read(reinterpret_cast<char*>(&mNotUsed1), sizeof(mNotUsed1));
stream >> mGyro1 >> mTemp1 >> mAccel1X >> mAccel1Y >> mGyro2 >> mTemp2 >>
mAccel2X >> mAccel2Y >> mGyro3 >> mTemp3 >> mAccel3X >> mAccel3Y;
stream.read(reinterpret_cast<char*>(&mNotUsed2), sizeof(mNotUsed2));
stream >> mGPSTimestamp;
stream.read(reinterpret_cast<char*>(&mNotUsed3), sizeof(mNotUsed3));
stream.read(reinterpret_cast<char*>(&mNMEASentence), sizeof(mNMEASentence));
stream.read(reinterpret_cast<char*>(&mNotUsed4), sizeof(mNotUsed4));
}
void ReadHeader(const BinaryReader& rd, bool bParent) override {
HashValue h;
rd >> Ver >> PrevBlockHash >> h;
m_merkleRoot = h;
Height = (uint32_t)rd.ReadInt64();
Timestamp = DateTime::from_time_t(rd.ReadUInt64());
rd >> Nonce1 >> Nonce2 >> Nonce3 >> Nonce;
rd.ReadStruct(MinerId);
DifficultyTargetBits = rd.ReadUInt32();
}
BinaryReader<T> &operator>>(BinaryReader<T> &reader, Bone &b)
{
b.name=reader.getString(15);
reader
>> b.frame
>> b.pos
>> b.q
;
reader.getBytes(b.cInterpolationX, 16);
reader.getBytes(b.cInterpolationY, 16);
reader.getBytes(b.cInterpolationZ, 16);
reader.getBytes(b.cInterpolationRot, 16);
return reader;
}
AffLoader::AffLoader(std::vector<uint8_t> &data)
{
BinaryReader reader;
reader.ReadIn(data.begin(), data.end());
auto header = AffHeader::Get(reader);
auto table = AffIndexTable::Get(reader);
auto indexes = table.GetIndexes();
auto fontNum = header.GetFontCount();
for (int16_t i = 0; i < fontNum; ++i)
{
auto charactor = distance(indexes.begin(), find(indexes.begin(), indexes.end(), i));
result[charactor] = GlyphData::Get(reader, charactor);
}
}
BinaryReader<T> &operator>>(BinaryReader<T> &reader, Morph &m)
{
m.name=reader.getString(15);
reader
>> m.frame
>> m.influence
;
return reader;
}
void ReadModelArray( Array< _type_ > & out, const char * string, const BinaryReader & bin, const int numElements )
{
if ( string != NULL && string[0] != '\0' && numElements > 0 )
{
if ( !bin.ReadArray( out, numElements ) )
{
StringUtils::StringTo( out, string );
}
}
}
bool Model_IO::Load(const std::vector<uint8_t>& data, const achar* path)
{
Meshes.clear();
BinaryReader reader;
reader.ReadIn(data.begin(), data.end());
// ヘッダーチェック
uint8_t header_true [] = "MDL";
for (int32_t i = 0; i < 4; i++)
{
auto h = reader.Get<uint8_t>();
if (header_true[i] != h) return false;
}
// バージョン
int32_t version = reader.Get<int32_t>();
// ボーン
LoadDeformer(Deformer_, reader, path, version);
// メッシュ
LoadMeshes(Meshes, reader, path);
// アニメーション
int32_t sourceCount = reader.Get<int32_t>();
AnimationSources.resize(sourceCount);
for (int32_t i = 0; i < sourceCount; i++)
{
LoadAnimationSource(AnimationSources[i], reader, path);
}
int32_t clipCount = reader.Get<int32_t>();
AnimationClips.resize(clipCount);
for (int32_t i = 0; i < clipCount; i++)
{
LoadAnimationClip(AnimationClips[i], reader, path);
}
return true;
}
uint Packet::getMessageLength(ushort lengthType, BinaryReader& reader)
{
uint length = 0;
switch(lengthType)
{
case 1:
length = static_cast<uint>(reader.readByte());
break;
case 2:
length = reader.readUShort();
break;
case 3:
length = static_cast<uint>(
((reader.readByte() & 255) << 16) +
((reader.readByte() & 255) << 8) +
(reader.readByte() & 255));
break;
default:
break;
}
return length;
}
void read_tga_uncompressed(BinaryReader& br, uint32_t width, uint32_t height, uint8_t channels, ImageData& image)
{
if (channels == 2)
{
uint32_t i = 0;
for (uint32_t h = 0; h < height; h++)
{
for (uint32_t w = 0; w < width; w++)
{
uint16_t data;
br.read(data);
image.data[i + 0] = (data & 0x7c) >> 10;
image.data[i + 1] = (data & 0x3e) >> 5;
image.data[i + 2] = (data & 0x1f);
i += 3;
}
}
}
void FlowWriter::flush(PacketWriter& writer,UInt64 stage,UInt8 flags,bool header,BinaryReader& reader,UInt16 size) {
if(_stageAck==0 && header)
flags |= MESSAGE_HEADER;
if(size==0)
flags |= MESSAGE_ABANDONMENT;
if(_closed && _messages.size()==1) // On LAST message
flags |= MESSAGE_END;
// TRACE("FlowWriter %u stage %u",id,stage);
writer.write8(flags);
if(header) {
writer.write7BitLongValue(id);
writer.write7BitLongValue(stage);
writer.write7BitLongValue(stage-_stageAck);
// signature
if(_stageAck==0) {
writer.writeString8(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) {
reader.readRaw(writer.begin()+writer.position(),size);
writer.next(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);
}
Blob XptMessage::ReadBlob16(const BinaryReader& rd) {
return rd.ReadBytes(rd.ReadUInt16());
}
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;
}
}
void ReadHeader(BinaryReader& reader) {
indexBits_ = MIN_DICT_SIZE + reader.ReadBits(MIN_DICT_SIZE_BITS);
freeze_ = reader.ReadBit();
}
void BinaryReaderWriterTest::read(BinaryReader& reader)
{
bool b;
reader >> b;
assert (b);
reader >> b;
assert (!b);
char c;
reader >> c;
assert (c == 'a');
short shortv;
reader >> shortv;
assert (shortv == -100);
unsigned short ushortv;
reader >> ushortv;
assert (ushortv == 50000);
int intv;
reader >> intv;
assert (intv == -123456);
unsigned uintv;
reader >> uintv;
assert (uintv == 123456);
long longv;
reader >> longv;
assert (longv == -1234567890);
unsigned long ulongv;
reader >> ulongv;
assert (ulongv == 1234567890);
#if defined(POCO_HAVE_INT64)
Int64 int64v;
reader >> int64v;
assert (int64v == -1234567890);
UInt64 uint64v;
reader >> uint64v;
assert (uint64v == 1234567890);
#endif
float floatv;
reader >> floatv;
assert (floatv == 1.5);
double doublev;
reader >> doublev;
assert (doublev == -1.5);
std::string str;
reader >> str;
assert (str == "foo");
reader >> str;
assert (str == "");
reader >> str;
assert (str == "bar");
reader >> str;
assert (str == "");
UInt32 uint32v;
reader.read7BitEncoded(uint32v);
assert (uint32v == 100);
reader.read7BitEncoded(uint32v);
assert (uint32v == 1000);
reader.read7BitEncoded(uint32v);
assert (uint32v == 10000);
reader.read7BitEncoded(uint32v);
assert (uint32v == 100000);
reader.read7BitEncoded(uint32v);
assert (uint32v == 1000000);
#if defined(POCO_HAVE_INT64)
reader.read7BitEncoded(uint64v);
assert (uint64v == 100);
reader.read7BitEncoded(uint64v);
assert (uint64v == 1000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 10000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 100000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 1000000);
#endif
reader.readRaw(3, str);
assert (str == "RAW");
}
void ReadHeader(BinaryReader& reader) {
offsetBits_ = reader.ReadBits(HEADER_OFFSET_BITS) + MIN_OFFSET_BITS;
lengthBits_ = reader.ReadBits(HEADER_LENGTH_BITS) + MIN_LENGTH_BITS;
}
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
static void Read(BinaryReader& reader, TestEntry& dst)
{
dst.value = reader.ReadInt32("value");
}
bool BmpImage::init()
{
initValuesToDefault();
BinaryReader* reader = new BinaryReader(this->image);
reader->reset();
/* read the file data header */
// read the type of the file
reader->seek(FILE_TYPE_OFFSET);
fileType = reader->readWord();
switch (fileType)
{
case BMPBITMAP:
break;
case BMPARRAY:
case BMPCLRICON:
case BMPCLRPOINTER:
case BMPICON:
case BMPPOINTER:
return false;
default:
{
fileType = NOT_BMP; // exception should be thrown
return false;
}
}
// read the file size in bytes
fileSize = reader->readDword();
// read the two hot spots, reserved 1 & reserved 2
Xhot = reader->readWord();
Yhot = reader->readWord();
bitmapOffset = reader->readDword();
/* read the bitmap header now */
headerSize = reader->readDword();
if (headerSize < BMPOLDANYHDRSIZE ||
(headerSize > BMPNEWOS2HDRSIZE && headerSize != BMPNEWWINV4HDRSIZE))
{
fileType = NOT_BMP; // exception should be thrown
return false;
}
// read the rest of the header and the palette if any
if (headerSize == BMPOLDANYHDRSIZE) // we have an old BMP file format
{
version = BMPOLD;
width = (word) reader->readWord();
height = (word) reader->readWord();
planes = reader->readWord();
bitsPerPixel = reader->readWord();
if (bitsPerPixel != 1 || bitsPerPixel != 4 || bitsPerPixel != 8 ||
bitsPerPixel != 24)
{
fileType = NOT_BMP; // exception should be thrown
return false;
}
colorPaletteSize = bitsPerPixel == 24 ? 0 : 1 << bitsPerPixel;
int numberOfEntries = (bitmapOffset - BMPFILEHDRSIZE -
BMPOLDANYHDRSIZE) / BMPOLDPALETTESIZE;
if (colorPaletteSize != numberOfEntries)
{
fileType = NOT_BMP; // exception should be thrown
return false;
}
// read the palette
if (colorPaletteSize != 0)
{
colorPalette = new unsigned long[colorPaletteSize];
for (int i = 0; i < colorPaletteSize; i++)
{
colorPalette[i] = reader->readRGB();
}
}
bitmapSize = rowBytes() * height;
}
else // new BMP file format
{
switch (headerSize)
{
case BMPNEWWINHDRSIZE:
{
version = BMPWINNEW;
break;
}
case BMPNEWOS2HDRSIZE:
{
version = BMPOS2NEW;
break;
}
case BMPNEWWINV4HDRSIZE:
{
version = BMPWIN4NEW;
break;
}
default:
{
version = BMPUNKNOWN;
break;
}
}
width = reader->readDword();
height = reader->readDword();
planes = reader->readWord();
bitsPerPixel = reader->readWord();
compression = reader->readDword();
bitmapSize = reader->readDword();
horizResolution = (long) reader->readDword();
vertResolution = (long) reader->readDword();
colorsUsed = reader->readDword();
colorsImportant = reader->readDword();
bitmapSize = (bitmapSize) ? bitmapSize : rowBytes() * height;
// if the image is an OS2 bitmap
if (headerSize == BMPNEWOS2HDRSIZE)
{
units = reader->readWord();
reserved = reader->readWord();
recording = reader->readWord();
rendering = reader->readWord();
size1 = reader->readDword();
size2 = reader->readDword();
identifier = reader->readDword();
}
// read the palette
// seek to the color palette
reader->seek(BMPFILEHDRSIZE + headerSize);
// rle compression not supported
if (compression == 3 && (bitsPerPixel == 16 || bitsPerPixel == 32))
{
// should throw exception
return false;
}
// compute the number of color table entries
colorPaletteSize = bitsPerPixel > 8 ? 0 : 1 << bitsPerPixel;
int numberOfEntries = (bitmapOffset - BMPFILEHDRSIZE -
headerSize) / BMPNEWPALETTESIZE;
if (colorPaletteSize != numberOfEntries)
{
fileType = NOT_BMP; // exception should be thrown
return false;
}
// read the palette
if (colorPaletteSize != 0)
{
colorPalette = new unsigned long[colorPaletteSize];
for (int i = 0; i < colorPaletteSize; i++)
{
colorPalette[i] = reader->readDword();
}
}
}
// shold read the data bits & lose the padding
bmpBits = &image->getBytes()[bitmapOffset];
// calculate the file size if not given
if (fileSize == 0)
{
fileSize = BMPFILEHDRSIZE;
fileSize += headerSize;
int paletteSize = (version == BMPOLD) ? BMPOLDPALETTESIZE : BMPNEWPALETTESIZE;
fileSize += colorPaletteSize*paletteSize;
fileSize += bitmapSize;
}
delete reader;
return true;
}
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 DataTest::readFromBLOB(BinaryReader& reader)
{
bool b = false;
reader >> b;
assert (b);
reader >> b;
assert (!b);
char c = ' ';
reader >> c;
assert (c == 'a');
short shortv = 0;
reader >> shortv;
assert (shortv == -100);
unsigned short ushortv = 0;
reader >> ushortv;
assert (ushortv == 50000);
int intv = 0;
reader >> intv;
assert (intv == -123456);
unsigned uintv = 0;
reader >> uintv;
assert (uintv == 123456);
long longv = 0;
reader >> longv;
assert (longv == -1234567890);
unsigned long ulongv = 0;
reader >> ulongv;
assert (ulongv == 1234567890);
Int64 int64v = 0;
reader >> int64v;
assert (int64v == -1234567890);
UInt64 uint64v = 0;
reader >> uint64v;
assert (uint64v == 1234567890);
float floatv = 0.0;
reader >> floatv;
assert (floatv == 1.5);
double doublev = 0.0;
reader >> doublev;
assert (doublev == -1.5);
std::string str;
reader >> str;
assert (str == "foo");
reader >> str;
assert (str == "");
reader >> str;
assert (str == "bar");
reader >> str;
assert (str == "");
UInt32 uint32v;
reader.read7BitEncoded(uint32v);
assert (uint32v == 100);
reader.read7BitEncoded(uint32v);
assert (uint32v == 1000);
reader.read7BitEncoded(uint32v);
assert (uint32v == 10000);
reader.read7BitEncoded(uint32v);
assert (uint32v == 100000);
reader.read7BitEncoded(uint32v);
assert (uint32v == 1000000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 100);
reader.read7BitEncoded(uint64v);
assert (uint64v == 1000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 10000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 100000);
reader.read7BitEncoded(uint64v);
assert (uint64v == 1000000);
reader.readRaw(3, str);
assert (str == "RAW");
}
String XptMessage::ReadString16(const BinaryReader& rd) {
uint16_t len = rd.ReadUInt16();
return Encoding::UTF8.GetChars(rd.ReadBytes(len));
}
