void* sendPackets(void* data) {
// Send Header
Header* h = initHeader(filename, "dave");
char* h_s = serializeHeader(h);
sendto(sock, h_s, strlen(h_s), 0, (struct sockaddr *) &servAddr, sizeof(servAddr));
// Send the packets
for (;;) {
if (!isEmpty(ph)) {
char *s;
Packet* p = malloc(sizeof(Packet));
getLock(ph);
p = removePacket(ph, p); // Get packet
unlock(ph);
s = serializePacket(p); // Convert into sendable char array
sendto(sock, s, strlen(s), 0, (struct sockaddr *) &servAddr, sizeof(servAddr));
if (p->fragment == DUMMY_FRAG_NUM) {
printf("Done Sending!!\n");
pthread_exit(0);
}
}
}
}
void
MissingFramePacket::serialize(OutputStream& outputStream) throw (SerializationException&) {
UInt bodySize = getBodySerializationSize();
m_packetHeader->setMessageSize(bodySize);
serializeHeader(outputStream);
serializeBody(outputStream);
}
void
GetPartitionRequestPacket::serialize(OutputStream& outputStream) throw (SerializationException&) {
UInt bodySize = getBodySerializationSize();
((MedusaHeader*) m_packetHeader)->m_messageSize = bodySize;
serializeHeader(outputStream);
serializeBody(outputStream);
}
RequestCoordinatorPacket::serialize(OutputStream& outputStream) THROW(SerializationException&) {
UInt bodySize = getBodySerializationSize();
((SthenoHeader*) m_packetHeader)->m_messageSize = bodySize;
serializeHeader(outputStream);
//ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)RequestCellPacket::serialize():serialized header!len=%lu\n", outputStream.total_length());
serializeBody(outputStream);
//ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)RequestCellPacket::serialize():serialized body!len=%lu\n", outputStream.total_length());
}
ssize_t SyncRequestPacket::serializePacket(uint8_t* data,
uint32_t length) {
ssize_t offset = serializeHeader(data, length);
if (offset > 0) {
SERIALIZE_INT64(clientTxLocalTime);
}
return offset;
}
void PacketGS_PlayerLogin::serialize(Crypt *pCrypt, CRC_32 *pCRC)
{
ByteBuffer internalBuffer;
internalBuffer << m_playerID;
serializeHeader(pCrypt, internalBuffer.size(), pCRC->ComputeCRC32(internalBuffer.contents(), internalBuffer.size()));
m_pBuffer->append(internalBuffer);
}
ssize_t MasterAnnouncementPacket::serializePacket(uint8_t* data,
uint32_t length) {
ssize_t offset = serializeHeader(data, length);
if (offset > 0) {
uint64_t packed = packDeviceID(deviceID, devicePriority);
SERIALIZE_INT64(packed);
}
return offset;
}
ssize_t WhoIsMasterRequestPacket::serializePacket(uint8_t* data,
uint32_t length) {
ssize_t offset = serializeHeader(data, length);
if (offset > 0) {
uint64_t packed = packDeviceID(senderDeviceID, senderDevicePriority);
SERIALIZE_INT64(packed);
}
return offset;
}
void PacketGS_SaveCustomData::serialize(Crypt *pCrypt, CRC_32 *pCRC)
{
ByteBuffer internalBuffer;
internalBuffer << m_key;
internalBuffer.append(m_rData);
serializeHeader(pCrypt, internalBuffer.size(), pCRC->ComputeCRC32(internalBuffer.contents(), internalBuffer.size()));
m_pBuffer->append(internalBuffer);
}
ssize_t SyncResponsePacket::serializePacket(uint8_t* data,
uint32_t length) {
ssize_t offset = serializeHeader(data, length);
if (offset > 0) {
SERIALIZE_INT64(clientTxLocalTime);
SERIALIZE_INT64(masterRxCommonTime);
SERIALIZE_INT64(masterTxCommonTime);
SERIALIZE_INT32(nak);
}
return offset;
}
void
P3DiscoveryQueryReplyPacket::serialize(OutputStream& outputStream)
throw (SerializationException&) {
//printf("P3DiscoveryQueryReplyPacket::serialize 1\n");
UInt bodySize = getBodySerializationSize();
//printf("P3DiscoveryQueryReplyPacket::serialize 2\n");
m_packetHeader->setMessageSize(bodySize);
//printf("P3DiscoveryQueryReplyPacket::serialize 3\n");
serializeHeader(outputStream);
//printf("P3DiscoveryQueryReplyPacket::serialize 4\n");
serializeBody(outputStream);
//printf("P3DiscoveryQueryReplyPacket::serialize 5\n");
}
/**
Converts the info message into a stream of bytes to memory pointed to by destinationPtr
Number of bytes streamed is equal to getSizeOfInfoMessage()
@param im the infoMessage to serialize
@param destinationPtr where to copy the stream of bytes to
@pre destinationPtr points to a region of memory at least getSizeOfInfoMessage() bytes in size
*/
void serializeInfoMessage(struct infoMessage* im, unsigned char* destinationPtr)
{
serializeHeader((&(im->header)), destinationPtr);
destinationPtr += (HEADER_SIZE);
*destinationPtr++ = im->deviceType;
*destinationPtr++ = im->numParameters;
int i;
for (i=0; i < im->numParameters; i++) //for each KVP:
{
*destinationPtr++ = im->kvps[i].oid; //object identifier
*destinationPtr++ = (im->kvps[i].value) & 0xFF; //LSB of value
*destinationPtr++ = (im->kvps[i].value) >> 8; //MSB of value
}
}
void
SthenoPacket::serialize(OutputStream& outputStream) throw (SerializationException&) {
//ACE_DEBUG((LM_DEBUG,
//ACE_TEXT("(%T) SthenoPacket::serialize()!\n")));
UInt bodySize = getBodySerializationSize();
//ACE_DEBUG((LM_DEBUG,
//ACE_TEXT("(%T) SthenoPacket::serialize(): after body size=%u!\n"), bodySize));
getPacketHeader()->m_messageSize = bodySize;
/*ACE_DEBUG((LM_DEBUG,
ACE_TEXT("(%T) SthenoPacket::serialize():serializing header!\n")));*/
serializeHeader(outputStream);
//ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)SthenoPacket::serialize():serialized header len=%lu!\n", outputStream.total_length());
serializeBody(outputStream);
//ACE_DEBUG((LM_DEBUG,ACE_TEXT("(%t|%T)SthenoPacket::serialize():serialized body!len=%lu\n", outputStream.total_length());
}
UInt8 DeltaThetaVector::serialize(UInt8* pBuf, UInt8 size)
{
UInt8 ret = 0;
if (size >= DELTA_THETA_VECTOR_STATIC_SIZE)
{
serializeHeader(pBuf, size);
putFloat32(&pBuf[DELTA_THETA_VECTOR_X_OFFSET], m_x);
putFloat32(&pBuf[DELTA_THETA_VECTOR_Y_OFFSET], m_y);
putFloat32(&pBuf[DELTA_THETA_VECTOR_Z_OFFSET], m_z);
ret = m_fieldLength;
}
return ret;
}
uint16_t
Packet::serialize(const Message* msg, uint8_t* bfr, uint16_t size)
{
unsigned total = msg->getSerializationSize();
if (total > DUNE_IMC_CONST_MAX_SIZE)
throw InvalidMessageSize(total);
uint16_t n = total;
uint8_t* ptr = bfr;
if (size < n)
throw BufferTooShort();
ptr += serializeHeader(msg, bfr, size);
msg->serializeFields(ptr);
uint16_t crc = Algorithms::CRC16::compute(bfr, n - DUNE_IMC_CONST_FOOTER_SIZE);
IMC::serialize(crc, (bfr + (n - DUNE_IMC_CONST_FOOTER_SIZE)));
return n;
}
/**
* The object is serialized using the messageCallack.
* @note This function may return immediately.
*/
virtual BareMessage * isend(const void * object, const void * user_ptr = nullptr ){
uint64_t msg_size = headerSize() + messageCallback->serializeMessageLen(object);
char * payload = (char*) malloc(msg_size);
assert(payload);
uint64_t pos = 0;
// memset(payload, 255, msg_size);
serializeHeader(payload, pos, msg_size);
assert(headerSize() == pos);
messageCallback->serializeMessage(object, payload, pos);
assert(pos == msg_size);
BareMessage * msg = new BareMessage(payload, msg_size, user_ptr);
isend(msg);
return msg;
}
ssize_t TimeServicePacketHeader::serializePacket(uint8_t* data,
uint32_t length) {
ssize_t ret, tmp;
ret = serializeHeader(data, length);
if (ret < 0)
return ret;
data += ret;
length -= ret;
switch (packetType) {
case TIME_PACKET_WHO_IS_MASTER_REQUEST:
tmp =((WhoIsMasterRequestPacket*)(this))->serializePacket(data,
length);
break;
case TIME_PACKET_WHO_IS_MASTER_RESPONSE:
tmp =((WhoIsMasterResponsePacket*)(this))->serializePacket(data,
length);
break;
case TIME_PACKET_SYNC_REQUEST:
tmp =((SyncRequestPacket*)(this))->serializePacket(data, length);
break;
case TIME_PACKET_SYNC_RESPONSE:
tmp =((SyncResponsePacket*)(this))->serializePacket(data, length);
break;
case TIME_PACKET_MASTER_ANNOUNCEMENT:
tmp =((MasterAnnouncementPacket*)(this))->serializePacket(data,
length);
break;
default:
return -1;
}
if (tmp < 0)
return tmp;
return ret + tmp;
}
void UDP_Socket::serializeAndSend(char* message)
{
for (int i = 0; i < REPEAT_SENDS; i++)
{
int headerLength = serializeHeader(mSendingPacket);
printf("htonLength: %d \n headerSize: %d\n", headerLength, serializedPacketHeaderSize);
int sendingBufferSize = addPacketData(mSendingPacket, message, headerLength);
int sent_bytes = sendto(socketHandle, sendingBuffer, sendingBufferSize, 0, (sockaddr*)&destination, sizeof(sockaddr_in));
printf("Sent_bytes: %d\n", sent_bytes);
#if PLATFORM == WINDOWS
if (DEBUG)
{
//Check if there is an error on the send call.
if (sent_bytes == SOCKET_ERROR)
{
//Print the error.
printf("Sendto has failed with error: %d\n", WSAGetLastError());
Sleep(1000);
}
}
#endif
}
}
void FTDataPrebindReplyPacket::serialize(OutputStream& outputStream) THROW(SerializationException&) {
UInt bodySize = getBodySerializationSize();
m_packetHeader->setMessageSize(bodySize);
serializeHeader(outputStream);
serializeBody(outputStream);
}
