void Connection::sendData(const Buffer *buffer) {
std::cout << "Connection::sendData" << std::endl;
std::cout << std::to_string(_isSending) << " - " << _sendQueue.size() << std::endl;
_sendQueue.push_back(buffer);
startWriting();
}
void K3b::Iso9660ImageWritingJob::start()
{
d->canceled = d->finished = false;
d->currentCopy = 1;
jobStarted();
if( m_simulate )
m_verifyData = false;
emit newTask( i18n("Preparing data") );
if( !QFile::exists( m_imagePath ) ) {
emit infoMessage( i18n("Could not find image %1", m_imagePath), K3b::Job::MessageError );
jobFinished( false );
return;
}
KIO::filesize_t mb = K3b::imageFilesize( m_imagePath )/1024ULL/1024ULL;
// very rough test but since most dvd images are 4,x or 8,x GB it should be enough
d->isDvdImage = ( mb > 900ULL );
startWriting();
}
void Connection::internOnDataWritten(const boost::system::error_code &ec, std::size_t bytesTransferred) {
std::cout << "Connection::internOnDataWritten" << std::endl;
_isSending = false; //TODO mutex ?
if (!ec) {
_sendQueue.erase(_sendQueue.begin());
onDataWritten(bytesTransferred);
if (_sendQueue.size() > 0) {
startWriting();
}
} else {
//if we are closing -> ignore error
if (!_isClosing) {
internOnError(ec, ERROR_SOURCE_WRITE);
}
}
}
/*******************************************************************************
* Name of Function: writerHandler
* Purpose: writes the writer output file till maximum item
* Parameters: pointer to arguments as void
* Return Value: void
* Calls to: startWriting, writeData, finishWriting
* Called from: main
* Method: 1. get mutually exclusive access to writer output file
* 2. writes 5 items
* 3. release the shared writer file
* 4. repeats this process till max iteration(20) for each
* writer
******************************************************************************/
void *writerHandler (void *args)
{
struct writer_struct *writer;
int i;
writer = (struct writer_struct *)args;
/* write till max iterations for each writer */
for(i=1;i<=MAX_ITERATIONS;i++)
{
printf("%ld W%d waiting-for-lock\n", timeElapsed(), writer->w_id);
startWriting(writer->monitor, writer->w_id);
printf("%ld W%d lock-acquired\n", timeElapsed(), writer->w_id);
writeData(writer->w_id, &(writer->w_item));
finishWriting(writer->monitor);
printf("%ld W%d lock-released\n",timeElapsed(), writer->w_id);
}
return;
}
/*
FUNCTION: ReadFromPort
DATE: 11/28/2015
REVISIONS: v4 12/2/2015 - wait state added
DESIGNER: Allen & Dylan & Thomas
PROGRAMMER: Allen & Dylan
INTERFACE: static DWORD WINAPI ReadFromPort(LPVOID lpParam)
LPVOID lpParam : parameter passed to the thread; intended to be a communications handle
RETURNS: 1
NOTES: This function is intended to be called on a separate thread.
It has the event driven code to monitor the serial port for INCOMING communications.
It will send messages to the main window (via WndProc) for OUTGOING communications.
*/
static DWORD WINAPI ReadFromPort(LPVOID lpParam) {
OVERLAPPED overlapped = { 0 };
HANDLE hnd = 0;
BOOL fWaitingOnRead = FALSE;
overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
CHAR buffer[PACKETLENGTH] = "";
DWORD dwEvent;
SetCommMask(lpParam, EV_RXCHAR);
while (true) {
switch (state) {
// Waiting for ENQ ACKnowledgment
case WENQACK:
if (!fWaitingOnRead) {
if (!WaitCommEvent(lpParam, &dwEvent, &overlapped)) {
if (GetLastError() == ERROR_IO_PENDING) {
fWaitingOnRead = TRUE;
}
}
}
else {
if (Wait(overlapped.hEvent, TIMEOUT)) {
if (!ReadFile(lpParam, buffer, 1, NULL, &overlapped)) {
WaitForSingleObject(overlapped.hEvent, TIMEOUT);
};
OutputDebugString("Finished reading in WENQACK\n");
if (buffer[0] == ACK) {
SendMessage(hMain, WM_COMMAND, ACK_REC, NULL);
}
else {
OutputDebugString("Was not ACK, was ");
OutputDebugString(buffer);
OutputDebugString("\n");
state = WAIT;
}
fWaitingOnRead = FALSE;
}
else {
state = IDLE;
}
}
break;
// Waiting for ACKnowledgment for a packet
case WACK:
if (!fWaitingOnRead) {
if (!WaitCommEvent(lpParam, &dwEvent, &overlapped)) {
if (GetLastError() == ERROR_IO_PENDING) {
fWaitingOnRead = TRUE;
}
}
}
else {
if (Wait(overlapped.hEvent, TIMEOUT)) {
ReadFile(lpParam, &buffer, 1, NULL, &overlapped);
if (buffer[0] == ACK) {
SendMessage(hMain, WM_COMMAND, ACK_REC, NULL);
buffer[0] = 0;
}
fWaitingOnRead = FALSE;
}
else {
state = WAIT;
}
}
break;
// a backoff state, can only become a receiver for some time
case WAIT:
// default state, can move to sending or receiving
case IDLE:
if (!fWaitingOnRead) {
if ((state == WAIT || state == IDLE) && !WaitCommEvent(lpParam, &dwEvent, &overlapped)) {
if (GetLastError() == ERROR_IO_PENDING) {
fWaitingOnRead = TRUE;
}
}
}
else {
if ((state == WAIT || state == IDLE) && Wait(overlapped.hEvent, TIMEOUT)) {
ReadFile(lpParam, &buffer, 1, NULL, &overlapped);
if (buffer[0] == ENQ) {
startWriting();
SendAck(lpParam);
finishWriting();
state = RECEIVING;
}
// this is what you call a hack to get around race conditions
else if ((state == WENQACK || state == WACK) && buffer[0] == ACK) {
SendMessage(hMain, WM_COMMAND, ACK_REC, NULL);
}
fWaitingOnRead = FALSE;
}
else {
state = IDLE;
}
}
break;
// anticipating a packet
case RECEIVING:
if (!fWaitingOnRead) {
if (!WaitCommEvent(lpParam, &dwEvent, &overlapped)) {
if (GetLastError() == ERROR_IO_PENDING) {
fWaitingOnRead = TRUE;
}
}
}
else {
if (Wait(overlapped.hEvent, INFINITE)) {
receiveBuffer = ReceivePacket(lpParam, overlapped);
if (ErrorCheck(receiveBuffer) || 1) {
//DoNonReadingStuff(receiveBuffer);
Depacketize(receiveBuffer);
startWriting();
SendAck(lpParam);
finishWriting();
packetsReceived++;
SetStatistics();
// open the file for writing and reading
hnd = CreateFile(FileName, FILE_APPEND_DATA | GENERIC_WRITE | GENERIC_READ, NULL, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
startWriting();
if (WritePacketToFile(receiveBuffer, hnd)) {
UpdateWindowFromFile(hReceive, hnd);
}
finishWriting();
CloseHandle(hnd);
fWaitingOnRead = FALSE;
state = IDLE;
buffer[0] = 0;
free(receiveBuffer);
}
}
else {
state = IDLE;
}
}
break;
}
// if a packet is in the queue and the process is in idle, attempt to send
if (state == IDLE && packetBuffer[currentPacket][0] != 0) {
SendMessage(hMain, WM_COMMAND, ASN_ENQ, NULL);
}
}
return 1;
}
/*
FUNCTION: WndProc
DATE: 12/2/2015
REVISIONS: v3 - changed all IO operations to overlapped
DESIGNER: Dylan & Allen & Thomas
PROGRAMMER: Dylan & Allen
INTERFACE: LRESULT CALLBACK WndProc (HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
HWND hwnd : handle to the the main window
UINT Message : message sent from the message loop to the window
WPARAM wParam : parameters to the message
LPARAM lParam : parameters to the message
RETURNS: The default window procedure or 0
NOTES: Handles all button presses from the main window as well as
events from the serial port reading thread
*/
LRESULT CALLBACK WndProc (HWND hwnd, UINT Message,
WPARAM wParam, LPARAM lParam)
{
switch (Message)
{
case WM_CREATE:
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case ASN_ENQ:
if (state != IDLE && state != WAIT) {
OutputDebugString("ENQ but not idling\n");
break;
}
startWriting();
// send ENQ to the serial port and assume it never fails
WriteFile(hComm, enq, 1, NULL, &OVERLAPPED());
state = WENQACK;
OutputDebugString("ENQ sent\n");
finishWriting();
break;
case ASN_SET:
startWriting();
if (!CommConfigDialog(TEXT("com1"), hMain, &cc)) {
return FALSE;
}
else {
SetCommConfig(hComm, &cc, cc.dwSize);
PurgeComm(hComm, PURGE_RXCLEAR);
}
finishWriting();
break;
case ASN_CON:
OpenFileDialog();
break;
case ASN_CLR:
ClearTextBoxes();
break;
case ASN_QUIT:
PostQuitMessage(0);
break;
case ASN_HLP:
break;
case ASN_OPN:
OpenFileDialog();
break;
case ACK_REC:
if (state != WACK && state != WENQACK) {
OutputDebugString("ACK received but not waiting for ACK before sending a packet\n");
break;
}
if (state == WENQACK) {
OutputDebugString("ACK received\n");
acksReceived++;
SetStatistics();
if (packetBuffer[currentPacket][0] != 0) {
OVERLAPPED overlapped = { 0 };
overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
startWriting();
if (!WriteFile(hComm, packetBuffer[currentPacket++], PACKETLENGTH, NULL, &overlapped)) {
WaitForSingleObject(overlapped.hEvent, TIMEOUT);
}
OutputDebugString("Sent a packet\n");
packetsSent++;
SetStatistics();
// ENQ the line to send the next packet
// THIS SHOULD BE REPLACED BY THE APPROPRIATE PRIORTIY PROTOCOL
/*
if (packetBuffer[currentPacket][0] != 0) {
WriteFile(hComm, enq, 1, NULL, NULL);
}
*/
finishWriting();
}
OutputDebugString("Going to WACK state\n");
state = WACK;
break;
}
if (state == WACK) {
OutputDebugString("Packet confirmed received\n");
OutputDebugString("Going to WAIT state\n");
state = WAIT;
packsAcked++;
acksReceived++;
SetStatistics();
}
break;
}
break; // end WM_COMMAND
case WM_CHAR:
break;
case WM_SIZE:
break;
case WM_DESTROY: // Terminate program
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, Message, wParam, lParam);
}
return 0;
}
