void native_dirmonitor_remove(Ref *r)
{
    FileMonitor *fm = Value_ptr(r->v[INDEX_FILEMONITOR_STRUCT]);

    if (fm != NULL) {
        fm->valid = FALSE;
        CancelIo(fm->hDir);
        refresh_dirmonitor(fm, TRUE);

        if (!HasOverlappedIoCompleted(&fm->overlapped)) {
            SleepEx(5, TRUE);
        }
        CloseHandle(fm->hDir);
        CloseHandle(fm->overlapped.hEvent);

        FileMonitor_del(fm);
        r->v[INDEX_FILEMONITOR_STRUCT] = VALUE_NULL;
    }
}

static u32 ser_read_internal( ser_handler id, u32 timeout )
{
    HANDLE hComm = id->hnd;
    DWORD readbytes = 0;
    DWORD dwRes = WaitForSingleObject( id->o.hEvent, timeout == SER_INF_TIMEOUT ? INFINITE : timeout );
    if( dwRes == WAIT_OBJECT_0 )
    {
        if( !GetOverlappedResult( hComm, &id->o, &readbytes, TRUE ) )
            readbytes = 0;
    }
    else if( dwRes == WAIT_TIMEOUT )
    {
        CancelIo( hComm );
        GetOverlappedResult( hComm, &id->o, &readbytes, TRUE );
        readbytes = 0;
    }
    ResetEvent( id->o.hEvent );
    return readbytes;
}

static __inline BOOL cancel_io(int _index)
{
	if ((_index < 0) || (_index >= MAX_FDS)) {
		return FALSE;
	}

	if ( (poll_fd[_index].fd < 0) || (poll_fd[_index].handle == INVALID_HANDLE_VALUE)
	  || (poll_fd[_index].handle == 0) || (poll_fd[_index].overlapped == NULL) ) {
		return TRUE;
	}
	if (CancelIoEx_Available) {
		return (*pCancelIoEx)(poll_fd[_index].handle, poll_fd[_index].overlapped);
	}
	if (_poll_fd[_index].thread_id == GetCurrentThreadId()) {
		return CancelIo(poll_fd[_index].handle);
	}
	usbi_warn(NULL, "Unable to cancel I/O that was started from another thread");
	return FALSE;
}

static void
ser_windows_close (struct serial *scb)
{
  struct ser_windows_state *state;

  /* Stop any pending selects.  */
  CancelIo ((HANDLE) _get_osfhandle (scb->fd));
  state = scb->state;
  CloseHandle (state->ov.hEvent);
  CloseHandle (state->except_event);

  if (scb->fd < 0)
    return;

  close (scb->fd);
  scb->fd = -1;

  xfree (scb->state);
}

VOID CFileMonitorRequest::StopCheck( ULONG_PTR aRequest )
{
    CFileMonitorRequest * req = (CFileMonitorRequest *)aRequest;
    if ( INVALID_HANDLE_VALUE != req->m_hMonitorPath )
    {
        CancelIo( req->m_hMonitorPath );
        for ( int i = 0 ; i < MONITOR_THREAD_STOP_MAX_RETRY_COUNT ; i++ )
        {
            if ( TRUE == HasOverlappedIoCompleted(&req->m_overlapped) )
                break;
            else
                SleepEx( 100 , TRUE );
        }        
        CloseHandle( req->m_hMonitorPath );
        req->m_hMonitorPath = INVALID_HANDLE_VALUE;

        req->DecrementWorkCount( req->m_parent );
    }
}

bool SerialPort::event(QEvent *e)
{
    if (e->type() != QEvent::User)
        return QObject::event(e);
    switch (static_cast<SerialEvent*>(e)->reason()){
    case EventComplete:{
            DWORD bytes;
            if (GetOverlappedResult(d->hPort, &d->over, &bytes, true)){
                if (d->m_state == Read){
                    d->m_buff.pack(&d->m_char, 1);
                    if (d->m_char == '\n')
                        emit read_ready();
                }
                if (d->m_state == Write){
                    emit write_ready();
                    d->m_state = Read;
                }
                if (d->m_state == Read){
                    d->m_state = StartRead;
                    SetEvent(d->hEvent);
                }
                break;
            }
            close();
            emit error();
            break;
        }
    case EventTimeout:{
            log(L_WARN, "IO timeout");
            CancelIo(d->hPort);
            close();
            emit error();
            break;
        }
    case EventError:{
            log(L_WARN, "IO error");
            close();
            emit error();
        }
    }
    return true;
}

static HANDLE open_device(const char *path, BOOL enumerate)
{
	HANDLE handle;
	DWORD desired_access = (enumerate)? 0: (GENERIC_WRITE | GENERIC_READ);
	DWORD share_mode = (enumerate)?
	                      FILE_SHARE_READ|FILE_SHARE_WRITE:
	                      FILE_SHARE_READ;

	handle = CreateFileA(path,
		desired_access,
		share_mode,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_OVERLAPPED,/*FILE_ATTRIBUTE_NORMAL,*/
		0);

  CancelIo(handle);

	return handle;
}

void SerialPort::writeLine(const char *data, unsigned read_time)
{
    if (d->hPort == INVALID_HANDLE_VALUE){
        emit error();
        return;
    }
    switch (d->m_state){
    case Read:
    case Write:
        CancelIo(d->hPort);
        break;
    default:
        break;
    }
    d->m_state		= StartWrite;
    d->m_line		= data;
    d->m_read_time	= read_time;
    FlushFileBuffers(d->hPort);
    SetEvent(d->hEvent);
}

static void
win32iocp_cancel (struct event *ev, unsigned int rw_flags)
{
    if (!pCancelIoEx) {
	CancelIo(ev->fd);
	rw_flags = (EVENT_READ | EVENT_WRITE);
    }
    if ((rw_flags & EVENT_READ) && ev->w.iocp.rov) {
	if (pCancelIoEx) pCancelIoEx(ev->fd, (OVERLAPPED *) ev->w.iocp.rov);
	ev->w.iocp.rov->ev = NULL;
	ev->w.iocp.rov = NULL;
	ev->flags &= ~EVENT_RPENDING;
    }
    if ((rw_flags & EVENT_WRITE) && ev->w.iocp.wov) {
	if (pCancelIoEx) pCancelIoEx(ev->fd, (OVERLAPPED *) ev->w.iocp.wov);
	ev->w.iocp.wov->ev = NULL;
	ev->w.iocp.wov = NULL;
	ev->flags &= ~EVENT_WPENDING;
    }
}

/*!
Closes a serial port.  This function has no effect if the serial port associated with the class
is not currently open.
*/
void QextSerialPort::close()
{
    QMutexLocker lock(mutex);
    if (isOpen()) {
        flush();
        QIODevice::close(); // mark ourselves as closed
        CancelIo(Win_Handle);
        if (CloseHandle(Win_Handle))
            Win_Handle = INVALID_HANDLE_VALUE;
        if (winEventNotifier)
            winEventNotifier->deleteLater();

        _bytesToWrite = 0;

        foreach(OVERLAPPED* o, pendingWrites) {
            CloseHandle(o->hEvent);
            delete o;
        }
        pendingWrites.clear();
    }

// Returns errcode (or 0 if successful)
DWORD FinishCommand(BOOL boolresult)
{
	DWORD errcode;
	DWORD waitcode;

#ifdef VERBOSE_FUNCTION_DEVICE
	PrintLog("CDVDiso device: FinishCommand()");
#endif /* VERBOSE_FUNCTION_DEVICE */

	if (boolresult == TRUE)
	{
		ResetEvent(waitevent.hEvent);
		return(0);
	} // ENDIF- Device is ready? Say so.

	errcode = GetLastError();
	if (errcode == ERROR_IO_PENDING)
	{
#ifdef VERBOSE_FUNCTION_DEVICE
		PrintLog("CDVDiso device:   Waiting for completion.");
#endif /* VERBOSE_FUNCTION_DEVICE */
		waitcode = WaitForSingleObject(waitevent.hEvent, 10 * 1000); // 10 sec wait
		if ((waitcode == WAIT_FAILED) || (waitcode == WAIT_ABANDONED))
		{
			errcode = GetLastError();
		}
		else if (waitcode == WAIT_TIMEOUT)
		{
			errcode = 21;
			CancelIo(devicehandle); // Speculative Line
		}
		else
		{
			ResetEvent(waitevent.hEvent);
			return(0); // Success!
		} // ENDIF- Trouble waiting? (Or doesn't finish in 5 seconds?)
	} // ENDIF- Should we wait for the call to finish?

	ResetEvent(waitevent.hEvent);
	return(errcode);
} // END DeviceCommand()

/*
 * Disconnect, but do not close, a pipe handle; and deregister
 * any pending waiter threads from its event handles.
 *
 * XXX: This must be called from primary thread, or lock held if not!
 */
void
pipe_disconnect(pipe_instance_t *pp)
{

    TRACE0(ENTER, "Entering pipe_disconnect");

    if (pp == NULL)
	return;
    /*
     * Cancel pending I/O before deregistering the callback,
     * and disconnect the pipe, to avoid race conditions.
     * We also reset the event(s) to avoid being signalled for
     * things which haven't actually happened yet.
     *
     * XXX: To avoid races during shutdown, we may have to
     * NULL out the second argument to UnregisterWaitEx().
     * We can't, however, do that from a service thread.
     */
    if (pp->cwait != NULL) {
        UnregisterWaitEx(pp->cwait, pp->cevent);
	ResetEvent(pp->cevent);
	pp->cwait = NULL;
    }
    if (pp->rwait != NULL) {
        UnregisterWaitEx(pp->rwait, pp->revent);
	ResetEvent(pp->revent);
	pp->rwait = NULL;
    }

    if (pp->pipe != NULL) {
        CancelIo(pp->pipe);
	if (pp->state == PIPE_STATE_CONNECTED ||
	    pp->state == PIPE_STATE_LISTEN) {
	    DisconnectNamedPipe(pp->pipe);
	}
    }

    pp->state = PIPE_STATE_INIT;

    TRACE0(ENTER, "Leaving pipe_disconnect");
}

// put back the IODesc to the free list and cancel all IO and put back FD
bool IOProcessorUnregisterSocket(FD& fd)
{
	IODesc*		iod;
	BOOL		ret;

	Log_Trace("fd = %d", fd.index);

	iod = &iods[fd.index];
	iod->next = freeIods;
	freeIods = iod;

	ret = CancelIo((HANDLE)fd.sock);
	if (ret == 0)
	{
		ret = WSAGetLastError();
		Log_Trace("CancelIo error %d", ret);
		return false;
	}

	return true;
}

void Socket::CloseSocket()
{
	if (m_s != INVALID_SOCKET)
	{
#ifdef USE_WINDOWS_STYLE_SOCKETS
# if defined(USE_WINDOWS8_API)
		BOOL result = CancelIoEx((HANDLE) m_s, NULL);
		assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));
		CheckAndHandleError_int("closesocket", closesocket(m_s));
# else
		BOOL result = CancelIo((HANDLE) m_s);
		assert(result || (!result && GetLastError() == ERROR_NOT_FOUND));
		CheckAndHandleError_int("closesocket", closesocket(m_s));
# endif
#else
		CheckAndHandleError_int("close", close(m_s));
#endif
		m_s = INVALID_SOCKET;
		SocketChanged();
	}
}

    /// Stops monitoring a directory.
    void DestroyWatch(WatchStruct* pWatch)
    {
        if (pWatch)
        {
            pWatch->mStopNow = TRUE;

            CancelIo(pWatch->mDirHandle);

            RefreshWatch(pWatch, true);

            if (!HasOverlappedIoCompleted(&pWatch->mOverlapped))
            {
                SleepEx(5, TRUE);
            }

            CloseHandle(pWatch->mOverlapped.hEvent);
            CloseHandle(pWatch->mDirHandle);
            delete pWatch->mDirName;
            HeapFree(GetProcessHeap(), 0, pWatch);
        }
    }

void uv_tcp_close(uv_tcp_t* tcp) {
  int non_ifs_lsp;
  int close_socket = 1;

  /*
   * In order for winsock to do a graceful close there must not be
   * any pending reads.
   */
  if (tcp->flags & UV_HANDLE_READ_PENDING) {
    /* Just do shutdown on non-shared sockets, which ensures graceful close. */
    if (!(tcp->flags & UV_HANDLE_SHARED_TCP_SOCKET)) {
      shutdown(tcp->socket, SD_SEND);
      tcp->flags |= UV_HANDLE_SHUT;
    } else {
      /* Check if we have any non-IFS LSPs stacked on top of TCP */
      non_ifs_lsp = (tcp->flags & UV_HANDLE_IPV6) ? uv_tcp_non_ifs_lsp_ipv6 :
        uv_tcp_non_ifs_lsp_ipv4;

      if (!non_ifs_lsp) {
        /* 
         * Shared socket with no non-IFS LSPs, request to cancel pending I/O.
         * The socket will be closed inside endgame.
         */
        CancelIo((HANDLE)tcp->socket);
        close_socket = 0;
      }
    }
  }

  tcp->flags &= ~(UV_HANDLE_READING | UV_HANDLE_LISTENING);

  if (close_socket) {
    closesocket(tcp->socket);
    tcp->flags |= UV_HANDLE_TCP_SOCKET_CLOSED;
  }

  if (tcp->reqs_pending == 0) {
    uv_want_endgame(tcp->loop, (uv_handle_t*)tcp);
  }
}

int async_pipe_close(async_pipe_t pipe)
{
	int err;

	Win32Pipe* o = (Win32Pipe*)pipe;
	
	// cancel ip
	CancelIo(o->pipe);

	// close pipe object
	assert(0 == o->ref);
	CloseHandle(o->pipe);
	err = (int)GetLastError();

	// close event object
	if(o->overlap.hEvent)
		CloseHandle(o->overlap.hEvent);

	// free
	GlobalFree(o);
	return err;
}

/*-----------------------------------------------------------------------------
--	FUNCTION:		server_download
--
--	DATE:			2009-03-29
--
--	REVISIONS:		March 29 - Jerrod, Added a sleep after each packet send so 
--							   that the client can keep up with us.
--
--	DESIGNER(S):	Jaymz Boilard
--	PROGRAMMER(S):	Jaymz Boilard & Jerrod Hudson
--
--	INTERFACE:		server_download(WPARAM wParam, PTSTR fileName)
--
--	RETURNS:		void
--
--	NOTES: The server's response when prompted by the client to service a
--	download request.  It opens the file, reading & sending packets until
--	we reach end of file.
-----------------------------------------------------------------------------*/
void server_download(WPARAM wParam, PTSTR fileName)
{
	char outBuf[FILE_BUFF_SIZE];
	DWORD bytesRead;
	HANDLE hFile;
	DWORD Flags = 0;

	/* Open the file */
	if((hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, NULL)) == INVALID_HANDLE_VALUE)
	{
		MessageBox(ghWndMain, (LPCSTR)"Error opening file!",
			(LPCSTR)"Error!", MB_OK | MB_ICONSTOP);
		return;
	}

	while(TRUE)
	{
		memset(outBuf,'\0',FILE_BUFF_SIZE);
		ReadFile(hFile, outBuf, FILE_BUFF_SIZE, &bytesRead, NULL);
		if(bytesRead == 0)
		{
			/* End of file, close & exit. */
			send(wParam, "Last Pkt\0", 9, 0);
			CancelIo(hFile);
			break;
		}

		if(send(wParam, outBuf, bytesRead, 0) == -1)
		{
			if (WSAGetLastError() != WSAEWOULDBLOCK)
			{
				MessageBox(ghWndMain, (LPCSTR)"send() failed.",
					(LPCSTR)"Error!", MB_OK | MB_ICONSTOP);
				closesocket(wParam);
			}
		}
		Sleep(1); /* Give the client some time to catch up with us */
	}
}

////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::RemoveStaleClient
// 
// DESCRIPTION:	Client has died on us, close socket and remove context from our list
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// 
////////////////////////////////////////////////////////////////////////////////
void CIOCPServer::RemoveStaleClient(ClientContext* pContext, BOOL bGraceful)
{
    CLock cs(m_cs, "RemoveStaleClient");

	TRACE("CIOCPServer::RemoveStaleClient\n");

    LINGER lingerStruct;

    //
    // If we're supposed to abort the connection, set the linger value
    // on the socket to 0.
    //

    if (!bGraceful ) 
	{
        lingerStruct.l_onoff = 1;
        lingerStruct.l_linger = 0;
        setsockopt(pContext->m_Socket, SOL_SOCKET, SO_LINGER,
                    (char *)&lingerStruct, sizeof(lingerStruct));
    }

    //
    // Free context structures
	if (m_listContexts.Find(pContext)) 
	{
		// Now close the socket handle.  This will do an abortive or  graceful close, as requested.  
		CancelIo((HANDLE) pContext->m_Socket);

		closesocket(pContext->m_Socket );
		pContext->m_Socket = INVALID_SOCKET;

        while (!HasOverlappedIoCompleted((LPOVERLAPPED)pContext))
                Sleep(0);

		m_pNotifyProc((LPVOID) m_pFrame, pContext, NC_CLIENT_DISCONNECT);

		MoveToFreePool(pContext);
	}
}

int wiiuse_io_read(struct wiimote_t* wm) {
	DWORD b, r;

	if (!wm || !WIIMOTE_IS_CONNECTED(wm))
		return 0;

	if (!ReadFile(wm->dev_handle, wm->event_buf, sizeof(wm->event_buf), &b, &wm->hid_overlap)) {
		/* partial read */
		b = GetLastError();

		if ((b == ERROR_HANDLE_EOF) || (b == ERROR_DEVICE_NOT_CONNECTED)) {
			/* remote disconnect */
			wiiuse_disconnected(wm);
			return 0;
		}

		r = WaitForSingleObject(wm->hid_overlap.hEvent, wm->timeout);
		if (r == WAIT_TIMEOUT) {
			/* timeout - cancel and continue */

			if (*wm->event_buf)
				WIIUSE_WARNING("Packet ignored.  This may indicate a problem (timeout is %i ms).", wm->timeout);

			CancelIo(wm->dev_handle);
			ResetEvent(wm->hid_overlap.hEvent);
			return 0;
		} else if (r == WAIT_FAILED) {
			WIIUSE_WARNING("A wait error occured on reading from wiimote %i.", wm->unid);
			return 0;
		}

		if (!GetOverlappedResult(wm->dev_handle, &wm->hid_overlap, &b, 0))
			return 0;
	}

	ResetEvent(wm->hid_overlap.hEvent);
	return 1;
}