bool BridgeManager::SendFile(FILE *file, int destination, int fileIdentifier) const
{
if (destination != EndFileTransferPacket::kDestinationModem && destination != EndFileTransferPacket::kDestinationPhone)
{
InterfaceManager::PrintError("ERROR: Attempted to send file to unknown destination!\n");
return (false);
}
if (destination == EndFileTransferPacket::kDestinationModem && fileIdentifier != -1)
{
InterfaceManager::PrintError("ERROR: The modem file does not have an identifier!\n");
return (false);
}
FileTransferPacket flashFileTransferPacket(FileTransferPacket::kRequestFlash);
bool success = SendPacket(&flashFileTransferPacket);
if (!success)
{
InterfaceManager::PrintError("Failed to initialise transfer!\n");
return (false);
}
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
rewind(file);
ResponsePacket fileTransferResponse(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(&fileTransferResponse);
if (!success)
{
InterfaceManager::PrintError("Failed to confirm transfer initialisation!\n");
return (false);
}
int sequenceCount = fileSize / (kMaxSequenceLength * SendFilePartPacket::kDefaultPacketSize);
int lastSequenceSize = kMaxSequenceLength;
int partialPacketLength = fileSize % SendFilePartPacket::kDefaultPacketSize;
if (fileSize % (kMaxSequenceLength * SendFilePartPacket::kDefaultPacketSize) != 0)
{
sequenceCount++;
int lastSequenceBytes = fileSize % (kMaxSequenceLength * SendFilePartPacket::kDefaultPacketSize);
lastSequenceSize = lastSequenceBytes / SendFilePartPacket::kDefaultPacketSize;
if (partialPacketLength != 0)
lastSequenceSize++;
}
long bytesTransferred = 0;
int currentPercent;
int previousPercent = 0;
InterfaceManager::Print("0%%");
for (int sequenceIndex = 0; sequenceIndex < sequenceCount; sequenceIndex++)
{
// Min(lastSequenceSize, 131072)
bool isLastSequence = sequenceIndex == sequenceCount - 1;
int sequenceSize = (isLastSequence) ? lastSequenceSize : kMaxSequenceLength;
FlashPartFileTransferPacket *beginFileTransferPacket = new FlashPartFileTransferPacket(0, 2 * sequenceSize);
success = SendPacket(beginFileTransferPacket);
delete beginFileTransferPacket;
if (!success)
{
InterfaceManager::PrintError("\nFailed to begin file transfer sequence!\n");
return (false);
}
ResponsePacket fileTransferResponse(ResponsePacket::kResponseTypeFileTransfer);
bool success = ReceivePacket(&fileTransferResponse);
if (!success)
{
InterfaceManager::PrintError("\nFailed to confirm beginning of file transfer sequence!\n");
return (false);
}
SendFilePartPacket *sendFilePartPacket;
SendFilePartResponse *sendFilePartResponse;
for (int filePartIndex = 0; filePartIndex < sequenceSize; filePartIndex++)
{
// Send
sendFilePartPacket = new SendFilePartPacket(file);
success = SendPacket(sendFilePartPacket);
delete sendFilePartPacket;
if (!success)
{
InterfaceManager::PrintError("\nFailed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
int receivedPartIndex = sendFilePartResponse->GetPartIndex();
if (verbose)
{
const unsigned char *data = sendFilePartResponse->GetData();
InterfaceManager::Print("File Part #%i... Response: %X %X %X %X %X %X %X %X \n", filePartIndex,
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
}
delete sendFilePartResponse;
if (!success)
{
InterfaceManager::PrintError("\nFailed to receive file part response!\n");
for (int retry = 0; retry < 4; retry++)
{
InterfaceManager::PrintError("\nRetrying...");
// Send
sendFilePartPacket = new SendFilePartPacket(file);
success = SendPacket(sendFilePartPacket);
delete sendFilePartPacket;
if (!success)
{
InterfaceManager::PrintError("\nFailed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
int receivedPartIndex = sendFilePartResponse->GetPartIndex();
if (verbose)
{
const unsigned char *data = sendFilePartResponse->GetData();
InterfaceManager::Print("File Part #%i... Response: %X %X %X %X %X %X %X %X \n", filePartIndex,
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
}
delete sendFilePartResponse;
if (receivedPartIndex != filePartIndex)
{
InterfaceManager::PrintError("\nERROR: Expected file part index: %i Received: %i\n",
filePartIndex, receivedPartIndex);
return (false);
}
if (success)
break;
}
if (!success)
return (false);
}
if (receivedPartIndex != filePartIndex)
{
InterfaceManager::PrintError("\nERROR: Expected file part index: %i Received: %i\n",
filePartIndex, receivedPartIndex);
return (false);
}
bytesTransferred += SendFilePartPacket::kDefaultPacketSize;
if (bytesTransferred > fileSize)
bytesTransferred = fileSize;
currentPercent = (int)(100.0f * ((float)bytesTransferred / (float)fileSize));
if (!verbose)
{
if (currentPercent != previousPercent)
{
if (previousPercent < 10)
InterfaceManager::Print("\b\b%i%%", currentPercent);
else
InterfaceManager::Print("\b\b\b%i%%", currentPercent);
}
}
previousPercent = currentPercent;
}
int lastFullPacketIndex = 2 * ((isLastSequence && partialPacketLength != 0) ? sequenceSize - 1 : sequenceSize);
if (destination == EndFileTransferPacket::kDestinationPhone)
{
EndPhoneFileTransferPacket *endPhoneFileTransferPacket = new EndPhoneFileTransferPacket(
(isLastSequence) ? partialPacketLength : 0, lastFullPacketIndex, 0, 0, fileIdentifier, isLastSequence);
success = SendPacket(endPhoneFileTransferPacket, 3000);
delete endPhoneFileTransferPacket;
if (!success)
{
InterfaceManager::PrintError("\nFailed to end phone file transfer sequence!\n");
return (false);
}
}
else // destination == EndFileTransferPacket::kDestinationModem
{
EndModemFileTransferPacket *endModemFileTransferPacket = new EndModemFileTransferPacket(
(isLastSequence) ? partialPacketLength : 0, lastFullPacketIndex, 0, 0, isLastSequence);
success = SendPacket(endModemFileTransferPacket, 3000);
delete endModemFileTransferPacket;
if (!success)
{
InterfaceManager::PrintError("\nFailed to end modem file transfer sequence!\n");
return (false);
}
}
ResponsePacket fileTransferResponse2(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(&fileTransferResponse2, 30000);
if (!success)
{
InterfaceManager::PrintError("\nFailed to confirm end of file transfer sequence!\n");
return (false);
}
}
if (!verbose)
InterfaceManager::Print("\n");
return (true);
}
bool BridgeManager::SendFile(FILE *file, unsigned int destination, unsigned int chipIdentifier, unsigned int fileIdentifier) const
{
if (destination != EndFileTransferPacket::kDestinationModem && destination != EndFileTransferPacket::kDestinationPhone)
{
Interface::PrintError("Attempted to send file to unknown destination!\n");
return (false);
}
if (destination == EndFileTransferPacket::kDestinationModem && fileIdentifier != 0xFFFFFFFF)
{
Interface::PrintError("The modem file does not have an identifier!\n");
return (false);
}
FileTransferPacket *flashFileTransferPacket = new FileTransferPacket(FileTransferPacket::kRequestFlash);
bool success = SendPacket(flashFileTransferPacket);
delete flashFileTransferPacket;
if (!success)
{
Interface::PrintError("Failed to initialise file transfer!\n");
return (false);
}
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
rewind(file);
ResponsePacket *fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(fileTransferResponse);
delete fileTransferResponse;
if (!success)
{
Interface::PrintError("Failed to confirm transfer initialisation!\n");
return (false);
}
// Transfer is a Double loop of Sequences (Outer) and Packets/FileParts (inner)
unsigned int sequenceCount = fileSize / (kMaxSequenceLength * SendFilePartPacket::kDefaultPacketSize);
unsigned int lastSequenceSize = kMaxSequenceLength;
unsigned int partialPacketByteCount = fileSize % SendFilePartPacket::kDefaultPacketSize;
if (verbose)
Interface::Print("fileSize: %d kMaxSequenceLength: %d kDefaultPacketSize: %d sequenceCount: %d lastSequenceSize: %d partialPacketByteCount: %d\n",
fileSize, kMaxSequenceLength, SendFilePartPacket::kDefaultPacketSize, sequenceCount, lastSequenceSize, partialPacketByteCount);
if (fileSize % (kMaxSequenceLength * SendFilePartPacket::kDefaultPacketSize) != 0)
{
sequenceCount++;
int lastSequenceBytes = fileSize % (kMaxSequenceLength * SendFilePartPacket::kDefaultPacketSize);
lastSequenceSize = lastSequenceBytes / SendFilePartPacket::kDefaultPacketSize;
if (partialPacketByteCount != 0)
lastSequenceSize++;
}
long bytesTransferred = 0;
unsigned int currentPercent;
unsigned int previousPercent = 0;
Interface::Print("0%%");
for (unsigned int sequenceIndex = 0; sequenceIndex < sequenceCount; sequenceIndex++)
{
// Min(lastSequenceSize, 131072)
bool isLastSequence = sequenceIndex == sequenceCount - 1;
unsigned int sequenceSize = (isLastSequence) ? lastSequenceSize : kMaxSequenceLength;
// This is the number of data bytes transferred in this sequence, not including the zero-pad on the final packet (Just the image data)
unsigned int sequenceByteCount =
((isLastSequence) ? (lastSequenceSize - 1) : kMaxSequenceLength) * SendFilePartPacket::kDefaultPacketSize +
((isLastSequence) ? partialPacketByteCount : 0);
FlashPartFileTransferPacket *beginFileTransferPacket = new FlashPartFileTransferPacket(0, 2 * sequenceSize);
success = SendPacket(beginFileTransferPacket);
delete beginFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to begin file transfer sequence!\n");
return (false);
}
fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
bool success = ReceivePacket(fileTransferResponse);
delete fileTransferResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to confirm beginning of file transfer sequence!\n");
return (false);
}
SendFilePartPacket *sendFilePartPacket;
SendFilePartResponse *sendFilePartResponse;
for (unsigned int filePartIndex = 0; filePartIndex < sequenceSize; filePartIndex++)
{
// Send
// The final (short) packet data is zero-padded, so we do not need to specify the byte count,
// even though it is an option for SendFilePartPacket
sendFilePartPacket = new SendFilePartPacket(file);
success = SendPacket(sendFilePartPacket);
delete sendFilePartPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
int receivedPartIndex = sendFilePartResponse->GetPartIndex();
if (verbose)
{
const unsigned char *data = sendFilePartResponse->GetData();
Interface::Print("(%3d%%) Seq: %d/%d File Part #%d/%d... Response: %X %X %X %X %X %X %X %X \n",
currentPercent, sequenceIndex+1, sequenceCount, filePartIndex+1, sequenceSize,
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
}
delete sendFilePartResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to receive file part response!\n");
for (int retry = 0; retry < 4; retry++)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Retrying...");
// Send
sendFilePartPacket = new SendFilePartPacket(file);
success = SendPacket(sendFilePartPacket);
delete sendFilePartPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
unsigned int receivedPartIndex = sendFilePartResponse->GetPartIndex();
if (verbose)
{
const unsigned char *data = sendFilePartResponse->GetData();
Interface::Print("(%3d%%) Seq: %d/%d File Part #%d/%d... Response: %X %X %X %X %X %X %X %X \n",
currentPercent, sequenceIndex, sequenceCount, filePartIndex, sequenceSize,
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
}
delete sendFilePartResponse;
if (receivedPartIndex != filePartIndex)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Expected file part index: %d Received: %d\n", filePartIndex, receivedPartIndex);
return (false);
}
if (success)
break;
}
if (!success)
return (false);
}
if (receivedPartIndex != filePartIndex)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Expected file part index: %d Received: %d\n", filePartIndex, receivedPartIndex);
return (false);
}
bytesTransferred += SendFilePartPacket::kDefaultPacketSize;
if (bytesTransferred > fileSize)
bytesTransferred = fileSize;
currentPercent = (int)(100.0f * ((float)bytesTransferred / (float)fileSize));
if (currentPercent != previousPercent)
{
if (!verbose)
{
if (previousPercent < 10)
Interface::Print("\b\b%d%%", currentPercent);
else
Interface::Print("\b\b\b%d%%", currentPercent);
}
}
previousPercent = currentPercent;
}
if (destination == EndFileTransferPacket::kDestinationPhone)
{
EndPhoneFileTransferPacket *endPhoneFileTransferPacket = new EndPhoneFileTransferPacket(sequenceByteCount, 0, chipIdentifier,
fileIdentifier, isLastSequence);
success = SendPacket(endPhoneFileTransferPacket, 3000);
delete endPhoneFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to end phone file transfer sequence!\n");
return (false);
}
}
else // destination == EndFileTransferPacket::kDestinationModem
{
EndModemFileTransferPacket *endModemFileTransferPacket = new EndModemFileTransferPacket(sequenceByteCount, 0, chipIdentifier, isLastSequence);
success = SendPacket(endModemFileTransferPacket, 3000);
delete endModemFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to end modem file transfer sequence!\n");
return (false);
}
}
fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(fileTransferResponse, 30000);
delete fileTransferResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to confirm end of file transfer sequence!\n");
return (false);
}
}
if (!verbose)
Interface::Print("\n");
return (true);
}
bool BridgeManager::SendFile(FILE *file, unsigned int destination, unsigned int deviceType, unsigned int fileIdentifier) const
{
if (destination != EndFileTransferPacket::kDestinationModem && destination != EndFileTransferPacket::kDestinationPhone)
{
Interface::PrintError("Attempted to send file to unknown destination!\n");
return (false);
}
if (destination == EndFileTransferPacket::kDestinationModem && fileIdentifier != 0xFFFFFFFF)
{
Interface::PrintError("The modem file does not have an identifier!\n");
return (false);
}
FileTransferPacket *flashFileTransferPacket = new FileTransferPacket(FileTransferPacket::kRequestFlash);
bool success = SendPacket(flashFileTransferPacket);
delete flashFileTransferPacket;
if (!success)
{
Interface::PrintError("Failed to initialise file transfer!\n");
return (false);
}
fseek(file, 0, SEEK_END);
long fileSize = ftell(file);
rewind(file);
ResponsePacket *fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(fileTransferResponse);
delete fileTransferResponse;
if (!success)
{
Interface::PrintError("Failed to confirm transfer initialisation!\n");
return (false);
}
unsigned int sequenceCount = fileSize / (fileTransferSequenceMaxLength * fileTransferPacketSize);
unsigned int lastSequenceSize = fileTransferSequenceMaxLength;
unsigned int partialPacketByteCount = fileSize % fileTransferPacketSize;
if (fileSize % (fileTransferSequenceMaxLength * fileTransferPacketSize) != 0)
{
sequenceCount++;
int lastSequenceBytes = fileSize % (fileTransferSequenceMaxLength * fileTransferPacketSize);
lastSequenceSize = lastSequenceBytes / fileTransferPacketSize;
if (partialPacketByteCount != 0)
lastSequenceSize++;
}
long bytesTransferred = 0;
unsigned int currentPercent;
unsigned int previousPercent = 0;
Interface::Print("0%%");
for (unsigned int sequenceIndex = 0; sequenceIndex < sequenceCount; sequenceIndex++)
{
bool isLastSequence = (sequenceIndex == sequenceCount - 1);
unsigned int sequenceSize = (isLastSequence) ? lastSequenceSize : fileTransferSequenceMaxLength;
unsigned int sequenceByteCount;
if (isLastSequence)
sequenceByteCount = ((partialPacketByteCount) ? lastSequenceSize - 1 : lastSequenceSize) * fileTransferPacketSize + partialPacketByteCount;
else
sequenceByteCount = fileTransferSequenceMaxLength * fileTransferPacketSize;
FlashPartFileTransferPacket *beginFileTransferPacket = new FlashPartFileTransferPacket(sequenceByteCount);
success = SendPacket(beginFileTransferPacket);
delete beginFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to begin file transfer sequence!\n");
return (false);
}
fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
bool success = ReceivePacket(fileTransferResponse);
delete fileTransferResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to confirm beginning of file transfer sequence!\n");
return (false);
}
SendFilePartPacket *sendFilePartPacket;
SendFilePartResponse *sendFilePartResponse;
for (unsigned int filePartIndex = 0; filePartIndex < sequenceSize; filePartIndex++)
{
// Send
sendFilePartPacket = new SendFilePartPacket(file, fileTransferPacketSize);
success = SendPacket(sendFilePartPacket);
delete sendFilePartPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
int receivedPartIndex = sendFilePartResponse->GetPartIndex();
delete sendFilePartResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to receive file part response!\n");
for (int retry = 0; retry < 4; retry++)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Retrying...");
// Send
sendFilePartPacket = new SendFilePartPacket(file, fileTransferPacketSize);
success = SendPacket(sendFilePartPacket);
delete sendFilePartPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
unsigned int receivedPartIndex = sendFilePartResponse->GetPartIndex();
delete sendFilePartResponse;
if (receivedPartIndex != filePartIndex)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Expected file part index: %d Received: %d\n", filePartIndex, receivedPartIndex);
return (false);
}
if (success)
break;
}
if (!success)
return (false);
}
if (receivedPartIndex != filePartIndex)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Expected file part index: %d Received: %d\n", filePartIndex, receivedPartIndex);
return (false);
}
bytesTransferred += fileTransferPacketSize;
if (bytesTransferred > fileSize)
bytesTransferred = fileSize;
currentPercent = (int)(100.0f * ((float)bytesTransferred / (float)fileSize));
if (currentPercent != previousPercent)
{
if (!verbose)
{
if (previousPercent < 10)
Interface::Print("\b\b%d%%", currentPercent);
else
Interface::Print("\b\b\b%d%%", currentPercent);
}
else
{
Interface::Print("\n%d%%\n", currentPercent);
}
}
previousPercent = currentPercent;
}
if (destination == EndFileTransferPacket::kDestinationPhone)
{
EndPhoneFileTransferPacket *endPhoneFileTransferPacket = new EndPhoneFileTransferPacket(sequenceByteCount, 0, deviceType, fileIdentifier, isLastSequence);
success = SendPacket(endPhoneFileTransferPacket, 3000);
delete endPhoneFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to end phone file transfer sequence!\n");
return (false);
}
}
else // destination == EndFileTransferPacket::kDestinationModem
{
EndModemFileTransferPacket *endModemFileTransferPacket = new EndModemFileTransferPacket(sequenceByteCount, 0, deviceType, isLastSequence);
success = SendPacket(endModemFileTransferPacket, 3000);
delete endModemFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to end modem file transfer sequence!\n");
return (false);
}
}
fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(fileTransferResponse, fileTransferSequenceTimeout);
delete fileTransferResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to confirm end of file transfer sequence!\n");
return (false);
}
}
if (!verbose)
Interface::Print("\n");
return (true);
}
bool BridgeManager::SendFile(FILE *file, unsigned int destination, unsigned int deviceType, unsigned int fileIdentifier) const
{
if (destination != EndFileTransferPacket::kDestinationModem && destination != EndFileTransferPacket::kDestinationPhone)
{
Interface::PrintError("Attempted to send file to unknown destination!\n");
return (false);
}
if (destination == EndFileTransferPacket::kDestinationModem && fileIdentifier != 0xFFFFFFFF)
{
Interface::PrintError("The modem file does not have an identifier!\n");
return (false);
}
FileTransferPacket *flashFileTransferPacket = new FileTransferPacket(FileTransferPacket::kRequestFlash);
bool success = SendPacket(flashFileTransferPacket);
delete flashFileTransferPacket;
if (!success)
{
Interface::PrintError("Failed to initialise file transfer!\n");
return (false);
}
FileSeek(file, 0, SEEK_END);
unsigned int fileSize = (unsigned int)FileTell(file);
FileRewind(file);
ResponsePacket *fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(fileTransferResponse);
delete fileTransferResponse;
if (!success)
{
Interface::PrintError("Failed to confirm transfer initialisation!\n");
return (false);
}
unsigned int sequenceCount = fileSize / (fileTransferSequenceMaxLength * fileTransferPacketSize);
unsigned int lastSequenceSize = fileTransferSequenceMaxLength;
unsigned int partialPacketByteCount = fileSize % fileTransferPacketSize;
if (fileSize % (fileTransferSequenceMaxLength * fileTransferPacketSize) != 0)
{
sequenceCount++;
int lastSequenceBytes = fileSize % (fileTransferSequenceMaxLength * fileTransferPacketSize);
lastSequenceSize = lastSequenceBytes / fileTransferPacketSize;
if (partialPacketByteCount != 0)
lastSequenceSize++;
}
unsigned int bytesTransferred = 0;
unsigned int currentPercent;
unsigned int previousPercent = 0;
Interface::Print("0%%");
for (unsigned int sequenceIndex = 0; sequenceIndex < sequenceCount; sequenceIndex++)
{
bool isLastSequence = (sequenceIndex == sequenceCount - 1);
unsigned int sequenceSize = (isLastSequence) ? lastSequenceSize : fileTransferSequenceMaxLength;
unsigned int sequenceTotalByteCount = sequenceSize * fileTransferPacketSize;
FlashPartFileTransferPacket *beginFileTransferPacket = new FlashPartFileTransferPacket(sequenceTotalByteCount);
success = SendPacket(beginFileTransferPacket);
delete beginFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to begin file transfer sequence!\n");
return (false);
}
fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
bool success = ReceivePacket(fileTransferResponse);
delete fileTransferResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to confirm beginning of file transfer sequence!\n");
return (false);
}
for (unsigned int filePartIndex = 0; filePartIndex < sequenceSize; filePartIndex++)
{
// NOTE: This empty transfer thing is entirely ridiculous, but sadly it seems to be required.
int sendEmptyTransferFlags = (filePartIndex == 0) ? kEmptyTransferNone : kEmptyTransferBefore;
// Send
SendFilePartPacket *sendFilePartPacket = new SendFilePartPacket(file, fileTransferPacketSize);
success = SendPacket(sendFilePartPacket, kDefaultTimeoutSend, sendEmptyTransferFlags);
delete sendFilePartPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to send file part packet!\n");
return (false);
}
// Response
SendFilePartResponse *sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
int receivedPartIndex = sendFilePartResponse->GetPartIndex();
delete sendFilePartResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to receive file part response!\n");
for (int retry = 0; retry < 4; retry++)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Retrying...");
// Send
sendFilePartPacket = new SendFilePartPacket(file, fileTransferPacketSize);
success = SendPacket(sendFilePartPacket, kDefaultTimeoutSend, sendEmptyTransferFlags);
delete sendFilePartPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to send file part packet!\n");
return (false);
}
// Response
sendFilePartResponse = new SendFilePartResponse();
success = ReceivePacket(sendFilePartResponse);
unsigned int receivedPartIndex = sendFilePartResponse->GetPartIndex();
delete sendFilePartResponse;
if (receivedPartIndex != filePartIndex)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Expected file part index: %d Received: %d\n", filePartIndex, receivedPartIndex);
return (false);
}
if (success)
break;
}
if (!success)
return (false);
}
if (receivedPartIndex != filePartIndex)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Expected file part index: %d Received: %d\n", filePartIndex, receivedPartIndex);
return (false);
}
bytesTransferred += fileTransferPacketSize;
if (bytesTransferred > fileSize)
bytesTransferred = fileSize;
currentPercent = (unsigned int)(100.0 * ((double)bytesTransferred / (double)fileSize));
if (currentPercent != previousPercent)
{
if (!verbose)
{
if (previousPercent < 10)
Interface::Print("\b\b%d%%", currentPercent);
else
Interface::Print("\b\b\b%d%%", currentPercent);
}
else
{
Interface::Print("\n%d%%\n", currentPercent);
}
}
previousPercent = currentPercent;
}
unsigned int sequenceEffectiveByteCount = (isLastSequence && partialPacketByteCount != 0) ?
fileTransferPacketSize * (lastSequenceSize - 1) + partialPacketByteCount : sequenceTotalByteCount;
if (destination == EndFileTransferPacket::kDestinationPhone)
{
EndPhoneFileTransferPacket *endPhoneFileTransferPacket = new EndPhoneFileTransferPacket(sequenceEffectiveByteCount, 0, deviceType, fileIdentifier, isLastSequence);
//***** SEND FILE END *****
//success = SendPacket(endPhoneFileTransferPacket, kDefaultTimeoutSend, kEmptyTransferBeforeAndAfter);
success = SendPacket(endPhoneFileTransferPacket);//SH-G7108
delete endPhoneFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to end phone file transfer sequence!\n");
return (false);
}
}
else // destination == EndFileTransferPacket::kDestinationModem
{
EndModemFileTransferPacket *endModemFileTransferPacket = new EndModemFileTransferPacket(sequenceEffectiveByteCount, 0, deviceType, isLastSequence);
success = SendPacket(endModemFileTransferPacket, kDefaultTimeoutSend, kEmptyTransferBeforeAndAfter);
delete endModemFileTransferPacket;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to end modem file transfer sequence!\n");
return (false);
}
}
fileTransferResponse = new ResponsePacket(ResponsePacket::kResponseTypeFileTransfer);
success = ReceivePacket(fileTransferResponse, fileTransferSequenceTimeout);
delete fileTransferResponse;
if (!success)
{
Interface::PrintErrorSameLine("\n");
Interface::PrintError("Failed to confirm end of file transfer sequence!\n");
return (false);
}
}
if (!verbose)
Interface::Print("\n");
return (true);
}
