bool read(DWORD bytes_to_read)
{
	if (m_io_status == IOSTATUS_NOOP|m_io_status == IOSTATUS_COMPLETED)
	{
		// reset counters and start reading
		::ZeroMemory( get_overlapped(), sizeof(OVERLAPPED)); //reset overlapped
		m_bytes_done = 0;			// how many bytes we've received
		m_bytes_left = bytes_to_read;	// how many bytes we have left to receive
	}
	else if (m_io_status == IOSTATUS_PENDING|m_io_status == IOSTATUS_COMPLETED_SYNCHRONOUSLY)
	{
		DWORD async_done = (DWORD) get_overlapped()->InternalHigh;
		m_bytes_done += async_done;
		m_bytes_left -= async_done;
		
		if ( 0 == m_bytes_left)
		{
			// reading is completed
			m_io_status = IOSTATUS_COMPLETED;
			return true;
		}
		else if (m_io_status == IOSTATUS_PENDING)
		{
			// continue reading asynchronous results
			return true;
		}
		else
		{
			// queue next overlapped operation
		}
	}
	else
	{
		m_io_status = IOSTATUS_ERROR;
		return false;
	}
	
	// queue next overlapped operation
	if ( read((LPBYTE)m_buffer + m_bytes_done, m_bytes_left) )
	{
		// completed synchronously
		m_io_status = IOSTATUS_COMPLETED_SYNCHRONOUSLY;
		return true;
	}
	else
	{
		DWORD err = ::GetLastError(); 
		if (err == ERROR_IO_PENDING )
		{
			// operation will complete in the future
			m_io_status = IOSTATUS_PENDING;
			return true;
		}  
		else
		{
			m_io_status = IOSTATUS_ERROR;
			return false;
		}
	} 
}

	while ( read((LPBYTE)m_buffer + m_bytes_done, m_bytes_left) )
	{
		// completed synchronously
		m_io_status = IOSTATUS_COMPLETED_SYNCHRONOUSLY;

		DWORD async_done = (DWORD) get_overlapped()->InternalHigh;
		m_bytes_done += async_done;
		m_bytes_left -= async_done;
		
		if ( 0 == m_bytes_left)
		{
			// reading is completed
			m_io_status = IOSTATUS_COMPLETED;
			return true;
		}
	}

	DWORD err = ::GetLastError(); 
	if (err == ERROR_IO_PENDING )
	{
		// operation will complete in the future
		m_io_status = IOSTATUS_PENDING;
		return true;
	}  
	else
	{
		m_io_status = IOSTATUS_ERROR;
		return false;
	}

static DWORD WINAPI worker_thread_proc(LPVOID lParam)
{
	Socket_overlapped_acceptor& acceptor =reinterpret_cast<Socket_overlapped_acceptorgt;(lParam);
	DWORD num_bytes = 0;
	ULONG_PTR comp_key = 0;
	OVERLAPPED* poverlapped = NULL;


	while ( false == acceptor.m_exit_pool_thread_flag /* in addition to ::PostQueuedCompletionStatus(m_completion_port, 0, CK_EXIT_THREAD, NULL) for all the threads*/)
	{
		BOOL fOk = ::GetQueuedCompletionStatus(acceptor.m_completion_port, &num_bytes, &comp_key, &poverlapped, IOCP_TIMEOUT);

		if(fOk)
		{
			...
			...
			if (comp_key == CK_READ)
			{
				bool queue_next_overlapped_request = true;
				_ASSERT(poverlapped);
				Client_proxy_connector* connector = static_cast<Client_proxy_connector*>(poverlapped);
				Lock lock(&connector->m_cs);

				do
				{

					// Call of the function "connector->read()" returns false, if there has been an I/O error.
					// Read operation returns true in two cases:
					//	- socket connector has read all the data requested (reading is completed).
					//	- socket connector has partially read data; there are some data left (I/O pending).

					if(false == connector->read(CONNECTOR_PACKET_SIZE))
					{
						LOG("Failed reading data from the connector.");
						acceptor.release_client(connector);
						break;
					}
					else if(true == connector->is_io_completed() )
					{
						if (connector->is_on_command())
						{
							// The command is OK. Proceed the command and read next one.

						}
						else
						{
							LOG("Error: invalid command.");
							acceptor.release_client(connector);
							break;
						}
					}
					else
					{
						// IO pending. Wait for IO completion on ::GetQueuedCompletionStatus(...)
						queue_next_overlapped_request = false;
					}
				}
				while (true == queue_next_overlapped_request);
			}
			...
			...
		}
		else
		{
			// TO DO on error
		}
	}
	return (0);
}