bool BridgeManager::ReceiveDump(int chipType, int chipId, FILE *file) const
{
bool success;
// Start file transfer
BeginDumpPacket beginDumpPacket(chipType, chipId);
success = SendPacket(&beginDumpPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to request dump!\n");
return (false);
}
DumpResponse dumpResponse;
success = ReceivePacket(&dumpResponse);
unsigned int dumpSize = dumpResponse.GetDumpSize();
if (!success)
{
InterfaceManager::PrintError("Failed to receive dump size!\n");
return (false);
}
unsigned int transferCount = dumpSize / ReceiveFilePartPacket::kDataSize;
if (transferCount % ReceiveFilePartPacket::kDataSize != 0)
transferCount++;
vector<char> buffer(kDumpBufferSize * ReceiveFilePartPacket::kDataSize, 0);
for (unsigned int i = 0; i < transferCount; i++)
{
DumpPartFileTransferPacket dumpPartPacket(i);
success = SendPacket(&dumpPartPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to request dump part #%i!\n", i);
return (false);
}
ReceiveFilePartPacket receiveFilePartPacket;
success = ReceivePacket(&receiveFilePartPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to receive dump part #%i!\n", i);
continue;
return (true);
}
if (buffer.size() + receiveFilePartPacket.GetReceivedSize() > kDumpBufferSize * ReceiveFilePartPacket::kDataSize)
{
// Write the buffer to the output file
fwrite(&buffer.front(), 1, buffer.size(), file);
buffer.clear();
}
// Copy the packet data into pitFile.
unsigned char* pDataBegin = receiveFilePartPacket.GetData();
unsigned char* pDataEnd = receiveFilePartPacket.GetData() + receiveFilePartPacket.GetReceivedSize();
buffer.insert(buffer.end(), pDataBegin, pDataEnd);
}
if (!buffer.empty())
{
// Write the buffer to the output file
fwrite(&buffer.front(), 1, buffer.size(), file);
}
// End file transfer
FileTransferPacket fileTransferPacket(FileTransferPacket::kRequestEnd);
success = SendPacket(&fileTransferPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to send request to end dump transfer!\n");
return (false);
}
ResponsePacket responsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(&responsePacket);
if (!success)
{
InterfaceManager::PrintError("Failed to receive end dump transfer verification!\n");
return (false);
}
return (true);
}
int BridgeManager::ReceivePitFile(vector<unsigned char> *pitBuffer) const
{
if (!pitBuffer)
return (0);
bool success;
// Start file transfer
PitFilePacket pitFilePacket(PitFilePacket::kRequestDump);
success = SendPacket(&pitFilePacket);
if (!success)
{
InterfaceManager::PrintError("Failed to request receival of PIT file!\n");
return (0);
}
PitFileResponse pitFileResponse;
success = ReceivePacket(&pitFileResponse);
int fileSize = pitFileResponse.GetFileSize();
if (!success)
{
InterfaceManager::PrintError("Failed to receive PIT file size!\n");
return (0);
}
int transferCount = fileSize / ReceiveFilePartPacket::kDataSize;
if (fileSize % ReceiveFilePartPacket::kDataSize != 0)
transferCount++;
vector<unsigned char> buffer(fileSize, 0);
// NOTE: The PIT file appears to always be padded out to exactly 4 kilobytes.
for (int i = 0; i < transferCount; i++)
{
DumpPartPitFilePacket requestPacket(i);
success = SendPacket(&requestPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to request PIT file part #%i!\n", i);
return (0);
}
ReceiveFilePartPacket receiveFilePartPacket;
success = ReceivePacket(&receiveFilePartPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to receive PIT file part #%i!\n", i);
return (0);
}
// Copy the whole packet data into the buffer.
unsigned char* pDataStart = receiveFilePartPacket.GetData();
unsigned char* pDataEnd = receiveFilePartPacket.GetData() + receiveFilePartPacket.GetReceivedSize();
buffer.insert(buffer.end(), pDataStart, pDataEnd);
}
// End file transfer
PitFilePacket pitFilePacket2(PitFilePacket::kRequestEndTransfer);
success = SendPacket(&pitFilePacket);
if (!success)
{
InterfaceManager::PrintError("Failed to send request to end PIT file transfer!\n");
return (0);
}
success = ReceivePacket(&pitFileResponse);
if (!success)
{
InterfaceManager::PrintError("Failed to receive end PIT file transfer verification!\n");
return (0);
}
*pitBuffer = buffer;
return (fileSize);
}
bool BridgeManager::ReceiveDump(unsigned int chipType, unsigned int chipId, FILE *file) const
{
bool success;
// Start file transfer
BeginDumpPacket *beginDumpPacket = new BeginDumpPacket(chipType, chipId);
success = SendPacket(beginDumpPacket);
delete beginDumpPacket;
if (!success)
{
Interface::PrintError("Failed to request dump!\n");
return (false);
}
DumpResponse *dumpResponse = new DumpResponse();
success = ReceivePacket(dumpResponse);
unsigned int dumpSize = dumpResponse->GetDumpSize();
delete dumpResponse;
if (!success)
{
Interface::PrintError("Failed to receive dump size!\n");
return (false);
}
unsigned int transferCount = dumpSize / ReceiveFilePartPacket::kDataSize;
if (transferCount % ReceiveFilePartPacket::kDataSize != 0)
transferCount++;
char *buffer = new char[kDumpBufferSize * ReceiveFilePartPacket::kDataSize];
unsigned int bufferOffset = 0;
for (unsigned int i = 0; i < transferCount; i++)
{
DumpPartFileTransferPacket *dumpPartPacket = new DumpPartFileTransferPacket(i);
success = SendPacket(dumpPartPacket);
delete dumpPartPacket;
if (!success)
{
Interface::PrintError("Failed to request dump part #%d!\n", i);
delete [] buffer;
return (false);
}
ReceiveFilePartPacket *receiveFilePartPacket = new ReceiveFilePartPacket();
success = ReceivePacket(receiveFilePartPacket);
if (!success)
{
Interface::PrintError("Failed to receive dump part #%d!\n", i);
continue;
delete receiveFilePartPacket;
delete [] buffer;
return (true);
}
if (bufferOffset + receiveFilePartPacket->GetReceivedSize() > kDumpBufferSize * ReceiveFilePartPacket::kDataSize)
{
// Write the buffer to the output file
// bytesWritten is discarded (it's just there to stop GCC warnings)
int bytesWritten = fwrite(buffer, 1, bufferOffset, file);
bufferOffset = 0;
}
// Copy the packet data into pitFile.
memcpy(buffer + bufferOffset, receiveFilePartPacket->GetData(), receiveFilePartPacket->GetReceivedSize());
bufferOffset += receiveFilePartPacket->GetReceivedSize();
delete receiveFilePartPacket;
}
if (bufferOffset != 0)
{
// Write the buffer to the output file
// bytesWritten is discarded (it's just there to stop GCC warnings)
int bytesWritten = fwrite(buffer, 1, bufferOffset, file);
}
delete [] buffer;
// End file transfer
FileTransferPacket *fileTransferPacket = new FileTransferPacket(FileTransferPacket::kRequestEnd);
success = SendPacket(fileTransferPacket);
delete fileTransferPacket;
if (!success)
{
Interface::PrintError("Failed to send request to end dump transfer!\n");
return (false);
}
ResponsePacket *responsePacket = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(responsePacket);
delete responsePacket;
if (!success)
{
Interface::PrintError("Failed to receive end dump transfer verification!\n");
return (false);
}
return (true);
}
int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
{
*pitBuffer = nullptr;
bool success;
// Start file transfer
PitFilePacket *pitFilePacket = new PitFilePacket(PitFilePacket::kRequestDump);
success = SendPacket(pitFilePacket);
delete pitFilePacket;
if (!success)
{
Interface::PrintError("Failed to request receival of PIT file!\n");
return (0);
}
PitFileResponse *pitFileResponse = new PitFileResponse();
success = ReceivePacket(pitFileResponse);
unsigned int fileSize = pitFileResponse->GetFileSize();
delete pitFileResponse;
if (!success)
{
Interface::PrintError("Failed to receive PIT file size!\n");
return (0);
}
unsigned int transferCount = fileSize / ReceiveFilePartPacket::kDataSize;
if (fileSize % ReceiveFilePartPacket::kDataSize != 0)
transferCount++;
unsigned char *buffer = new unsigned char[fileSize];
int offset = 0;
// NOTE: The PIT file appears to always be padded out to exactly 4 kilobytes.
for (unsigned int i = 0; i < transferCount; i++)
{
DumpPartPitFilePacket *requestPacket = new DumpPartPitFilePacket(i);
success = SendPacket(requestPacket);
delete requestPacket;
if (!success)
{
Interface::PrintError("Failed to request PIT file part #%d!\n", i);
delete [] buffer;
return (0);
}
ReceiveFilePartPacket *receiveFilePartPacket = new ReceiveFilePartPacket();
success = ReceivePacket(receiveFilePartPacket);
if (!success)
{
Interface::PrintError("Failed to receive PIT file part #%d!\n", i);
delete receiveFilePartPacket;
delete [] buffer;
return (0);
}
// Copy the whole packet data into the buffer.
memcpy(buffer + offset, receiveFilePartPacket->GetData(), receiveFilePartPacket->GetReceivedSize());
offset += receiveFilePartPacket->GetReceivedSize();
delete receiveFilePartPacket;
}
// End file transfer
pitFilePacket = new PitFilePacket(PitFilePacket::kRequestEndTransfer);
success = SendPacket(pitFilePacket);
delete pitFilePacket;
if (!success)
{
Interface::PrintError("Failed to send request to end PIT file transfer!\n");
delete [] buffer;
return (0);
}
pitFileResponse = new PitFileResponse();
success = ReceivePacket(pitFileResponse);
delete pitFileResponse;
if (!success)
{
Interface::PrintError("Failed to receive end PIT file transfer verification!\n");
delete [] buffer;
return (0);
}
*pitBuffer = buffer;
return (fileSize);
}
int BridgeManager::ReceivePitFile(unsigned char **pitBuffer) const
{
*pitBuffer = nullptr;
bool success;
// Start file transfer
PitFilePacket *pitFilePacket = new PitFilePacket(PitFilePacket::kRequestDump);
success = SendPacket(pitFilePacket);
delete pitFilePacket;
if (!success)
{
Interface::PrintError("Failed to request receival of PIT file!\n");
return (0);
}
PitFileResponse *pitFileResponse = new PitFileResponse();
success = ReceivePacket(pitFileResponse);
unsigned int fileSize = pitFileResponse->GetFileSize();
delete pitFileResponse;
if (!success)
{
Interface::PrintError("Failed to receive PIT file size!\n");
return (0);
}
unsigned int transferCount = fileSize / ReceiveFilePartPacket::kDataSize;
if (fileSize % ReceiveFilePartPacket::kDataSize != 0)
transferCount++;
unsigned char *buffer = new unsigned char[fileSize];
int offset = 0;
for (unsigned int i = 0; i < transferCount; i++)
{
DumpPartPitFilePacket *requestPacket = new DumpPartPitFilePacket(i);
success = SendPacket(requestPacket);
delete requestPacket;
if (!success)
{
Interface::PrintError("Failed to request PIT file part #%d!\n", i);
delete [] buffer;
return (0);
}
int receiveEmptyTransferFlags = (i == transferCount - 1) ? kEmptyTransferAfter : kEmptyTransferNone;
ReceiveFilePartPacket *receiveFilePartPacket = new ReceiveFilePartPacket();
//***** FIX BUG *****
success = ReceivePacket(receiveFilePartPacket, kDefaultTimeoutEmptyTransfer, receiveEmptyTransferFlags);
if (!success)
{
Interface::PrintError("Failed to receive PIT file part #%d!\n", i);
delete receiveFilePartPacket;
delete [] buffer;
return (0);
}
// Copy the whole packet data into the buffer.
memcpy(buffer + offset, receiveFilePartPacket->GetData(), receiveFilePartPacket->GetReceivedSize());
offset += receiveFilePartPacket->GetReceivedSize();
delete receiveFilePartPacket;
}
// End file transfer
pitFilePacket = new PitFilePacket(PitFilePacket::kRequestEndTransfer);
success = SendPacket(pitFilePacket);
delete pitFilePacket;
if (!success)
{
Interface::PrintError("Failed to send request to end PIT file transfer!\n");
delete [] buffer;
return (0);
}
pitFileResponse = new PitFileResponse();
success = ReceivePacket(pitFileResponse);
delete pitFileResponse;
if (!success)
{
Interface::PrintError("Failed to receive end PIT file transfer verification!\n");
delete [] buffer;
return (0);
}
*pitBuffer = buffer;
return (fileSize);
}
