serial port Writefile: sometimes 998 ERROR_NOACCESS

Hi,

I`ve noticed an 998 ERROR_NOACCESS error during a WriteFile method.
This error occurs only sometimes - e.g. after 15min where the prog is
running without problems...

I`m not sure, because the explanation of this error is pretty small,
to which memory I didn`t have an access (to the memory with the data
writing to the serial port | or to the serial-port handle)?

If installed two threads, one who is responsible for collecting the
data to tx by the com port and another thread which will transmit
these data. As data I`m using a huge CByteArray located at the heap.

//Data to tx by usb

void CASoc::RxData(ADATA *ptr)
{
CByteArray *pData = new CByteArray;
pData->SetSize(SIZE_OF_ARRAY);
memcpy(pData->GetData(), &ptr->Data[0], SIZE_OF_ARRAY);

::PostThreadMessage(m_ThreadIDs[0], UWM_GET_NEW_DATA,(WPARAM)pData,
SIZE_OF_ARRAY);
}

//thread which collects these data into a clist queue (according to
the example queue from Mr. Newcomer)

void CDmxCollectThread::OnGetNewData(WPARAM wParam, LPARAM lParam)
{
    TRACE(_T("collect thread: new data\n"));

    CByteArray *pData = (CByteArray *)wParam;

    //collect them in a list or queue
    if(!q.AddTail(pData))
               { /* failed */
        TRACE(_T("queue is full\n"));
        delete pData;
        return;
               } /* failed */
    else
    {
        //show size of queue
        TRACE(_T("queue size: %d\n"), q.GetSize());
        long n = InterlockedIncrement(&count);
    }
}

//thread which will tx these data

void CDmxWriterThread::WriteData(Queue *q)
{
    BOOL running = TRUE;
    DWORD bytesWritten;

    OVERLAPPED ovl = {0};
                ovl.hEvent = WriteEvent;

    /* writer thread */
    while(running)
    {
        //check if shutdown event occurred
        DWORD result = ::WaitForSingleObject(ShutdownEvent, 1); //wenn dann
multiple object

        switch(result)
        { /* result */
        case WAIT_OBJECT_0:
            //shutdown event occure

            ::CancelIo(hCom);
            //nur wenn daten available sind, ist die map noch nicht gel=F6scht!
            while(q->GetSize() > 0)
            {
                LPVOID p =q->RemoveHead();
                CByteArray *pData = (CByteArray *) p;
                delete pData;
            }

            PostQuitMessage(0);
            running = FALSE;

        default:
            //go ahead if no shutdown event occurred
            break;
        }

        //check if new data available in the queue
        if(q->GetSize() == 0)
            continue;

        else
        {
            LPVOID p = q->RemoveHead();
            long n = InterlockedDecrement(pcnt);
            CByteArray *pData = (CByteArray *) p;

            UINT count = pData->GetCount();
            UINT size = pData->GetSize();

            BOOL ok = ::WriteFile(hCom, // handle
 
pData, // 8-bit data
                                                             pData-


 
&bytesWritten, // amount written
 
&ovl); // overlapped structure
            if(!ok)
            { /* failed */
                DWORD err = ::GetLastError();
                if(err != ERROR_IO_PENDING)
                { /* serious error */
/* sometimes a serious error 998 (GestLastError()) occurred */
=09
AfxMessageBox(_T("serious error\n"));
                                      delete pData;
                                      return;

                }
                //transfer is pending
                // By using WFMO and having the shutdown event be first, this
allows us
               // to break out of the wait to shut the thread down cleanly
               HANDLE waiters[2];
               waiters[0] = ShutdownEvent;
               waiters[1] = WriteEvent;
               DWORD reason = ::WaitForMultipleObjects(2, waiters, FALSE,
INFINITE);
               switch(reason)
               { /* waitfor */
               case WAIT_OBJECT_0: // it was the shutdown event
                   // shutting down

                   delete pData;

                   return;

               case WAIT_OBJECT_0 + 1:
                // data complete
                { /* write complete */
                    BOOL ok = ::GetOverlappedResult(hCom, &ovl, &bytesWritten, TRUE);
                    if(!ok)
                    { /* failed */
                        //parms->notifyee->PostMessage(UWM_WRITER_SHUTTING_DOWN,
(WPARAM)::GetLastError());
                        //PostQuitMessage(0);
                        //delete s;
                        DWORD err = ::GetLastError();
                        delete pData;
                        return;
                    } /* failed */
                    //delete s;

                } /* write complete */
                    break;

                default:
                { /* trouble */
                    DWORD err = ::GetLastError();
                    ASSERT(FALSE);
                    //parms->notifyee->PostMessage(UWM_WRITER_SHUTTING_DOWN,
(WPARAM)err);
                    //PostQuitMessage(0);
                    delete pData;
                    return;
                } /* trouble */

               }
            }
            else
            { /* successful write */
                delete pData;
                TRACE(_T("successfull written to the lpc\n"));
            } /* successful write */

        }
    }
}

I didn`t code the last part of this function (after the "serious error
section" so far, because it is never called (at the moment)...

best regards
Hans