bool RemoteBlockReader::readTrailingEmptyPacket() {
shared_ptr<PacketHeader> trailingHeader = readPacketHeader();
if (!trailingHeader->isLastPacketInBlock() || trailingHeader->getDataLen() != 0) {
return false;
}
return true;
}
void
RTMP::update()
{
if (!connected()) {
_handShaker->call();
if (_handShaker->error()) {
_error = true;
}
if (!_handShaker->success()) return;
_connected = true;
}
const size_t reads = 10;
for (size_t i = 0; i < reads; ++i) {
/// No need to continue reading (though it should do no harm).
if (error()) return;
RTMPPacket p;
// If we haven't finished reading a packet, retrieve it; otherwise
// use an empty one.
if (_incompletePacket.get()) {
log_debug("Doing incomplete packet");
p = *_incompletePacket;
_incompletePacket.reset();
}
else {
if (!readPacketHeader(p)) continue;
}
// Get the payload if possible.
if (hasPayload(p) && !readPacketPayload(p)) {
// If the payload is not completely readable, store it and
// continue.
_incompletePacket.reset(new RTMPPacket(p));
continue;
}
// Store a copy of the packet for later additions and as a reference for
// future sends.
RTMPPacket& stored = storePacket(CHANNELS_IN, p.header.channel, p);
// If the packet is complete, the stored packet no longer needs to
// keep the data alive.
if (isReady(p)) {
clearPayload(stored);
handlePacket(p);
return;
}
}
}
void RemoteBlockReader::readNextPacket() {
assert(position >= size);
lastHeader = readPacketHeader();
int dataSize = lastHeader->getDataLen();
int64_t pendingAhead = 0;
if (!lastHeader->sanityCheck(lastSeqNo)) {
THROW(HdfsIOException, "RemoteBlockReader: Packet failed on sanity check for block %s from Datanode %s.",
binfo.toString().c_str(), datanode.formatAddress().c_str());
}
assert(dataSize > 0 || lastHeader->getPacketLen() == sizeof(int32_t));
if (dataSize > 0) {
int chunks = (dataSize + chunkSize - 1) / chunkSize;
int checksumLen = chunks * checksumSize;
size = checksumLen + dataSize;
assert(size == lastHeader->getPacketLen() - static_cast<int>(sizeof(int32_t)));
buffer.resize(size);
in->readFully(&buffer[0], size, readTimeout);
lastSeqNo = lastHeader->getSeqno();
if (lastHeader->getPacketLen() != static_cast<int>(sizeof(int32_t)) + dataSize + checksumLen) {
THROW(HdfsIOException, "Invalid Packet, packetLen is %d, dataSize is %d, checksum size is %d",
lastHeader->getPacketLen(), dataSize, checksumLen);
}
if (verify) {
verifyChecksum(chunks);
}
/*
* skip checksum
*/
position = checksumLen;
/*
* the first packet we get may start at the position before we required
*/
pendingAhead = cursor - lastHeader->getOffsetInBlock();
pendingAhead = pendingAhead > 0 ? pendingAhead : 0;
position += pendingAhead;
}
/*
* we reach the end of the range we required, send status to datanode
* if datanode do not sending data anymore.
*/
if (cursor + dataSize - pendingAhead >= endOffset && readTrailingEmptyPacket()) {
sendStatus();
}
}
void DataBus::PacketParser::processReceivedData(const QByteArray &data)
{
// Add data to buffer
m_buffer.append(data);
// Execute state machine
bool finished = false;
while (finished == false)
{
switch (m_state)
{
case State_WaitForStartOfFrame:
{
finished = waitForStartOfFrame();
break;
}
case State_ReadPacketHeader:
{
finished = readPacketHeader();
break;
}
case State_ReadPacketPayload:
{
finished = readPacketPayload();
break;
}
case State_WaitForEndOfFrame:
{
finished = waitForEndOfFrame();
break;
}
default:
{
// Error, reinitialize the state machine
m_state = State_WaitForStartOfFrame;
finished = false;
break;
}
}
}
}
/**
* Utility function for receiving messages from the ASIM.
*
* @param buf The output buffer the message will be written into
* @param bufSize The size of the output buffer
*
* @return An int containing the number of bytes actually read, -1 indicates
* an error condition has occured.
*/
int Spa1Asim::recvFromAsim(unsigned char* buf, size_t bufSize, bool blocking)
{
#ifndef WIN32
if (ioctl(i2cFd, I2C_SLAVE, i2cAddress) < 0)
{
printf("SPA-1 Manager: Error setting i2c address in recv\n");
}
#endif
short length = 0;
int bytesRead = 0;
bytesRead = readPacketHeader(buf, blocking);
if (bytesRead == 0)
{
return 0;
}
if (bytesRead == -1)
{
return bytesRead;
}
memcpy(&length, &buf[1], 2);
if ((unsigned short)(length + SPA1_HEADER_SIZE) > bufSize || length > MAX_PACKET_PAYLOAD)
{
return -1;
}
bytesRead += read(i2cFd, &buf[3], length);
return bytesRead;
}
/**
* Utility function for receiving messages from the ASIM in a blocking manner.
*
* @param buf The output buffer the message will be written into
* @param bufSize The size of the output buffer
*
* @return An int containing the number of bytes actually read, -1 indicates
* an error condition has occured.
*/
int Spa1Asim::recvXtedsFromAsim()
{
#ifndef WIN32
if (ioctl(i2cFd, I2C_SLAVE, i2cAddress) < 0)
{
printf("SPA-1 Manager: Error setting i2c address in recv\n");
}
#endif
short length = 0;
int bytesRead = 0;
unsigned char headerBuf[3];
usleep(1000);
readPacketHeader(headerBuf, true);
memcpy(&length, &headerBuf[1], 2);
debug_f(4, "Read xTEDS Header: 0x%02x w/ length: %i\n", headerBuf[0], length);
xTEDS = new char[length + 1];
memset(xTEDS, 0, length + 1);
usleep(1000);
if (length <= MAX_PACKET_PAYLOAD)
{
bytesRead = read(i2cFd, &xTEDS[3], length);
}
else
{
// loop and reassemble packets
int index = 0;
int numberPackets = length / MAX_PACKET_PAYLOAD;
int lastPacketLength = length % MAX_PACKET_PAYLOAD;
// read the rest of the first packet
bytesRead = read(i2cFd, &xTEDS[index], MAX_PACKET_PAYLOAD);
debug_f(4, "Read %i bytes of xTEDS\n", bytesRead);
index += MAX_PACKET_PAYLOAD;
// read all the other packets
for (int packet = 1; packet < numberPackets; ++packet)
{
usleep(1000);
readPacketHeader(headerBuf, true);
debug_f(4, "Read xTEDS Header: 0x%02x 0x%02x 0x%02x\n", headerBuf[0], headerBuf[1], headerBuf[2]);
usleep(1000);
bytesRead += read (i2cFd, &xTEDS[index], MAX_PACKET_PAYLOAD);
debug_f(4, "Read %i bytes of xTEDS\n", bytesRead);
index += MAX_PACKET_PAYLOAD;
}
// read the last packet
if (lastPacketLength > 0)
{
usleep(1000);
readPacketHeader(headerBuf, true);
debug_f(4, "Read xTEDS Header: 0x%02x 0x%02x 0x%02x\n", headerBuf[0], headerBuf[1], headerBuf[2]);
usleep(1000);
bytesRead += read (i2cFd, &xTEDS[index], lastPacketLength);
debug_f(4, "Read %i bytes of xTEDS\n", bytesRead);
}
}
return bytesRead;
}
alt_u32 RS232_ISR(void* up_dev) {
if(queue_lock == 1) return alt_ticks_per_second()/1000;
alt_up_rs232_dev *serial_dev = ((struct alt_up_dev*)up_dev)->RS232_dev;
unsigned char* cert;
int i = 0;
int len = 0;
switch(*(com.stateMachine)) {
case startInit:
cert = sendStartInit();
sendRS232(serial_dev, cert, 3);
free(cert);
cert = NULL;
com.failReceive = 0;
return alt_ticks_per_second()/20;
case waitStart:
i = 0;
if((len = alt_up_rs232_get_used_space_in_read_FIFO(serial_dev)) >= 3) {
do {
while (alt_up_rs232_get_used_space_in_read_FIFO(serial_dev) == 0);
alt_up_rs232_read_data(serial_dev, &com.data[i], &com.parity);
i++;
} while(i < 3);
if(checkStartAck(com.data[0]) == 1) {
setStates(sendStates);
} else
setStates(startInit);
} else {
com.failReceive++;
if(com.failReceive > 10)
setStates(startInit);
}
return alt_ticks_per_second()/20;
case checkClient:
i = 0;
if((len = alt_up_rs232_get_used_space_in_read_FIFO(serial_dev)) >= 3) {
do {
while (alt_up_rs232_get_used_space_in_read_FIFO(serial_dev) == 0);
alt_up_rs232_read_data(serial_dev, &com.data[i], &com.parity);
i++;
} while(i < 3);
if(checkAck(com.data) == 1) {
if(getBit(com.data[0], 1) == 1) {
setStates(sendAck0);
com.num_packets = ((int)(com.data[1] << 8))+(int)com.data[2];
printf("num of packets will be receiving: %d\n", com.num_packets);
} else
setStates(sendStates);
} else
setStates(sendStates);
} else {
com.failReceive++;
if(com.failReceive > 100) {
reset(serial_dev);
}
}
return alt_ticks_per_second()/20;
case sendStates:
cert = sendStats();
sendRS232(serial_dev, cert, 3);
free(cert);
cert = NULL;
com.failReceive = 0;
return alt_ticks_per_second()/20;
case sendAck0:
cert = sendAck();
sendRS232(serial_dev, cert, 3);
if(cert[1] != 0)
printf("sth is wrong");
free(cert);
cert = NULL;
com.failReceive = 0;
return alt_ticks_per_second()/20;
case receiveData0:
if((len = alt_up_rs232_get_used_space_in_read_FIFO(serial_dev)) > 2) {
//read first 2 bytes for header information
alt_up_rs232_read_data(serial_dev, &com.data[0], &com.parity);
alt_up_rs232_read_data(serial_dev, &com.data[1], &com.parity);
struct Packet* p = readPacketHeader(com.data[0], com.data[1]);
i = 0;
do {
while (alt_up_rs232_get_used_space_in_read_FIFO(serial_dev) == 0);
alt_up_rs232_read_data(serial_dev, &(p->data[i+HEADERSIZE]), &com.parity);
// printf("%c", p->data[i+HEADERSIZE]);
i++;
} while(p->data_size > i );
//printf("\n");
enqueue(com.receivePackets, (void*)p);
com.index_packets++;
setStates(sendAck0);
} else {
com.failReceive++;
if(com.failReceive > 100) {
reset(serial_dev);
}
}
return alt_ticks_per_second()/20;
case waitClient:
i = 0;
if((len = alt_up_rs232_get_used_space_in_read_FIFO(serial_dev)) >= 3) {
do {
while (alt_up_rs232_get_used_space_in_read_FIFO(serial_dev) == 0);
alt_up_rs232_read_data(serial_dev, &com.data[i], &com.parity);
i++;
} while(i < 3);
if(checkAck(com.data) == 1) {
setStates(sendData0);
} else {
com.failReceive++;
if(com.failReceive > 100)
setStates(sendStates);
}
} else {
com.failReceive++;
if(com.failReceive > 100) {
reset(serial_dev);
}
}
return alt_ticks_per_second()/20;
case sendData0:
if(com.packetBuf == NULL) {
if((com.packetBuf = (struct Packet*)dequeue(com.sendPackets))==NULL) {
printf("Packet sending fail, queue is empty");
setStates(sendStates);
return alt_ticks_per_second()/50;
}
} setAck(com.packetBuf, com.host_ack);
for(i = 0; i< com.packetBuf->data_size+HEADERSIZE; i++) {
alt_up_rs232_write_data(serial_dev, com.packetBuf->data[i]);
}
setStates(waitAck0);
com.failReceive = 0;
return alt_ticks_per_second()/20;
case waitAck0:
i = 0;
if((len = alt_up_rs232_get_used_space_in_read_FIFO(serial_dev)) >= 3) {
do {
while (alt_up_rs232_get_used_space_in_read_FIFO(serial_dev) == 0);
alt_up_rs232_read_data(serial_dev, &com.data[i], &com.parity);
i++;
} while(i < 3);
if(checkAck(com.data) == 1) {
com.index_send_packets++;
killPacket(&(com.packetBuf));
if(com.index_send_packets < com.num_send_packets)
setStates(sendData0);
else {
com.index_send_packets = com.num_send_packets = 0;
setStates(sendStates);
com.isRdySend = 0;
}
} else {
setStates(sendData0);
}
} else {
com.failReceive++;
if(com.failReceive > 100) {
reset(serial_dev);
}
}
return alt_ticks_per_second()/20;
default:
break;
}
return alt_ticks_per_second()/20;
}
