BOOL DoRead(PCLIENT pClient)
{
    SetLastError(NO_ERROR);
    DWORD nBytes = 0;
    BOOL b = ReadFile(pClient->hPipe, &pClient->Message, sizeof(pClient->Message),
                      &nBytes, pClient);

    DWORD error = GetLastError();

    if (b && error == NO_ERROR) {
        return TRUE;
    }
    if (error == ERROR_BROKEN_PIPE) {
        pClient->LogMessageV("<!-- **** ReadFile 002 *** ERROR_BROKEN_PIPE [%d] -->\n", nBytes);
        CloseConnection(pClient);
        return TRUE;
    }
    else if (error == ERROR_INVALID_HANDLE) {
        // ?
        pClient->LogMessageV("<!-- **** ReadFile 002 *** ERROR_INVALID_HANDLE -->\n");
        // I have no idea why this happens.  Our remedy is to drop the connection.
        return TRUE;
    }
    else if (error != ERROR_IO_PENDING) {
        if (b) {
            pClient->LogMessageV("<!-- **** ReadFile 002 succeeded: %d -->\n", error);
        }
        else {
            pClient->LogMessageV("<!-- **** ReadFile 002 failed: %d -->\n", error);
        }
        CloseConnection(pClient);
    }
    return TRUE;
}

NS_IMETHODIMP
WebSocket::OnServerClose(nsISupports *aContext, uint16_t aCode,
                           const nsACString &aReason)
{
  NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");

  MOZ_ASSERT(mReadyState != WebSocket::CONNECTING,
             "Received server close before connected?");
  MOZ_ASSERT(mReadyState != WebSocket::CLOSED,
             "Received server close after already closed!");

  // store code/string for onclose DOM event
  mCloseEventCode = aCode;
  CopyUTF8toUTF16(aReason, mCloseEventReason);

  if (mReadyState == WebSocket::OPEN) {
    // Server initiating close.
    // RFC 6455, 5.5.1: "When sending a Close frame in response, the endpoint
    // typically echos the status code it received".
    // But never send certain codes, per section 7.4.1
    if (aCode == 1005 || aCode == 1006 || aCode == 1015) {
      CloseConnection(0, EmptyCString());
    } else {
      CloseConnection(aCode, aReason);
    }
  } else {
    // We initiated close, and server has replied: OnStop does rest of the work.
    MOZ_ASSERT(mReadyState == WebSocket::CLOSING, "unknown state");
  }

  return NS_OK;
}

BOOL CTransmission::OpenConnection() {
    if (this->isConnected == true && m_pServer != nullptr) {
        return TRUE;
    }

    if (this->m_pListener == nullptr) {
        return FALSE;
    }

    if (m_pServer != nullptr) {
        CloseConnection();
    }

    this->m_pServer = new CTcpServerPtr(this->m_pListener);

    if ((*m_pServer) == nullptr) {
        return FALSE;
    }

    ((this->m_pServer)->Get())->SetWorkerThreadCount(1);
    BOOL state = (*m_pServer)->Start(L"0.0.0.0", 55999);

    if (state == FALSE) {
        EnSocketError error = (*m_pServer)->GetLastError();
        CloseConnection();

    } else {
        this->isConnected = true;
    }

    return  state;
}

void WebSocketWorker::doRead()
{
    if (!m_isRunning)
        return;

    if (!m_webSocketServer.IsRunning() || !m_socket->isOpen())
    {
        CloseConnection();
        return;
    }

    if (m_webSocketMode)
    {
        ProcessFrames(m_socket);
    }
    else
    {
        if (!ProcessHandshake(m_socket))
            SendClose(kCloseProtocolError);
    }

    if (!m_webSocketMode)
    {
        LOG(VB_HTTP, LOG_WARNING, "WebSocketServer: Timed out waiting for connection upgrade");
        CloseConnection();
    }
}

void UnregisterServer(void)
{
	if (con_state != MSCS_REGISTERED)
	{
		con_state = MSCS_NONE;
		CloseConnection();
		return;
	}

	con_state = MSCS_NONE;

	CONS_Printf("Unregistering this server to the master server...\n");

	if (MS_Connect(registered_server.ip, registered_server.port, 0))
	{
		CONS_Printf("cannot connect to the master server\n");
		return;
	}

	if (RemoveFromMasterSever() < 0)
		CONS_Printf("cannot remove this server from the master server\n");

	CloseConnection();
	MSCloseUDPSocket();
	MSLastPing = 0;
}

void
FCGXStream::FillBuffer()
{
    if (mFD == INVALID_SOCKET)
        return;

    mRecvOut = 0;
    int amt;
    do {
       amt = recv(mFD, (char*)mRecvBuf + mRecvIn, FCGXBUFSIZE - mRecvIn, 0);
    } while (amt < 0 &&
#ifdef _WIN32
        WSAGetLastError() == WSAEINTR
#else
        errno == EINTR
#endif
        );
    if (amt < 0) {
        LogFatal("FCGXStream::FillBuffer(): Could not read data from socket");
        CloseConnection(true);
    } else if (amt == 0) {
        LogFatal("Unexpected connection close.");
        CloseConnection(true);
    } else {
        mRecvIn += amt;
    }
}

int ClientNetwork::ReceivePacketNonBlocking( char *recvbuf, unsigned int BufferSize )
{
	int WriteIndex = 0;
	int SumRead = 0;
	int RequiredRead = 0;
	do{
TRY_MORE_READ_ON_LACK_OF_DATA:
//		unsigned int Start = GetTimer();
		if( WriteIndex == 0 )
			iResult = recv( ConnectSocket, &recvbuf[WriteIndex], sizeof( NetworkPacketHeader ), 0 );
		else
		{
			int SpaceLeftInOurBuffer = BufferSize - WriteIndex;
			int RemainingToRead = RequiredRead - SumRead;
			int ActualRead = RemainingToRead;
			if( ActualRead > SpaceLeftInOurBuffer )
				ActualRead = SpaceLeftInOurBuffer;
			iResult = recv( ConnectSocket, &recvbuf[WriteIndex], ActualRead, 0 );
		}

		if ( iResult == 0 )
		{
			printf( "Connection closed\n" );
			CloseConnection();
	//		exit(1);
			return iResult;
		}
		else if( iResult < 0 )
		{
			int iResult2 = WSAGetLastError();
			if( iResult2 == WSAEWOULDBLOCK )
			{
				Sleep( 1 );
				printf( "Need more data from server\n" );
				goto TRY_MORE_READ_ON_LACK_OF_DATA;
//				return 0;
			}
			printf( "recv failed: %d - %d\n", iResult, iResult2 );
			CloseConnection();
	//		exit(1);
			return iResult;
		}
		if( WriteIndex == 0 )
		{
			NetworkPacketHeader *ph = (NetworkPacketHeader *)recvbuf;
			RequiredRead = (int)ph->PacketSize;
			if( (int)BufferSize < RequiredRead )
			{
				assert( false );
				return 0;
			}
		}
		WriteIndex += iResult;
		SumRead += iResult;
//		unsigned int End = GetTimer();
//		printf("network packet fragment size %d, received in %d seconds\n", iResult, End - Start );
	}while( SumRead < RequiredRead && BufferSize - WriteIndex > 0 );
    return SumRead;
}

DWORD WINAPI WorkerThread(LPVOID pvVoid)
{
    PCLIENT pClient;
    BOOL b;
    LPOVERLAPPED lpo;
    DWORD nBytes;
    HANDLE hCompletionPort = (HANDLE)pvVoid;

    for (BOOL fKeepLooping = TRUE; fKeepLooping;) {
        pClient = NULL;
        lpo = NULL;
        nBytes = 0;
        b = GetQueuedCompletionStatus(hCompletionPort,
                                      &nBytes, (PULONG_PTR)&pClient, &lpo, INFINITE);

        if (!b) {
            if (pClient) {
                if (GetLastError() == ERROR_BROKEN_PIPE) {
                    pClient->LogMessageV("<!-- Client closed pipe. -->");
                }
                else {
                    pClient->LogMessageV("<!-- *** GetQueuedCompletionStatus failed %d -->",
                                         GetLastError());
                }
                CloseConnection(pClient);
            }
            continue;
        }

        if (pClient->fAwaitingAccept) {
            BOOL fAgain = TRUE;
            while (fAgain) {
                LONG nClient = InterlockedIncrement(&s_nTotalClients);
                InterlockedIncrement(&s_nActiveClients);
                pClient->fAwaitingAccept = FALSE;

                PCLIENT pNew = CreatePipeConnection(hCompletionPort, nClient);

                fAgain = FALSE;
                if (pNew != NULL) {
                    fAgain = !pNew->fAwaitingAccept;
                    DoRead(pNew);
                }
            }
        }
        else {
            if (nBytes <= offsetof(TBLOG_MESSAGE, szMessage)) {
                pClient->LogMessageV("</t:Process>\n");
                CloseConnection(pClient);
                continue;
            }
            pClient->LogMessage(&pClient->Message, nBytes);
        }

        DoRead(pClient);
    }
    return 0;
}

unsigned __stdcall ClientThread(void *pVoid)
{
	int nRet;
	BYTE buf[1024];
	LPREQUEST lpReq = (LPREQUEST)pVoid;

	//
	// Count this client
	//
	IncrementClientCount();

	//
	// Recv the request data
	//
	if (!RecvRequest(lpReq, buf, sizeof(buf)))
	{
		CloseConnection(lpReq);
		free(lpReq);
		DecrementClientCount();
		return 0;
	}

	//
	// Parse the request info
	//
	nRet = ParseRequest(lpReq, buf);
	if (nRet)
	{
		SendError(lpReq, nRet);
		CloseConnection(lpReq);
		free(lpReq);
		DecrementClientCount();
		return 0;
	}

	//
	// Send the file to the client
	//
	SendFile(lpReq);

	//
	// Clean up
	CloseConnection(lpReq);
	free(pVoid);

	//
	// Subtract this client
	//
	DecrementClientCount();
	return 0;
}

// creates a connection and destroys it again
enum TVerdict TE_RConnectionTest301::doTestStepL(void)
{
	TInt err;

	RConnection activeConn;
	RConnection conn;
	RSocketServ ss;

	TRequestStatus status;
	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);
	TESTEL(KErrNone == err, err);
	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);
	TESTEL(KErrNone == err, err);
	CleanupClosePushL(conn);

	err = OpenConnection(activeConn, ss);
	TESTEL(KErrNone == err, err);
	CleanupClosePushL(activeConn);

	err = StartConnectionWithOverrides(conn, 1);
	TESTEL(KErrNone == err, err);

	// issue request
	AllInterfaceNotification(conn, status, info);

	// start another different connection to complete request if it hasn't already done so
	err = StartConnectionWithOverrides(activeConn, 6);
	TESTEL(KErrNone == err, err);

	// wait for completion
	User::WaitForRequest(status);

	// check for correct value
	TESTEL(status.Int() == KErrInUse, status.Int());

	CloseConnection(activeConn);
	CleanupStack::Pop();

	CloseConnection(conn);
	CleanupStack::Pop();

	CloseSocketServer(ss);
	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest301

int
GetUrl(char *url, char **reply_ret, int *len_ret)
{
    char *hostname, *path;
    int port;
    XtransConnInfo trans;
    int status = 0;

    if (ParseHttpUrl(url, &hostname, &port, &path) != 0)
	return 1;		/* invalid URL */

    trans = OpenConnection(hostname, port);
    if (trans == NULL) {
	status = 1;		/* connection failed */
	goto end;
    }

    SendGetRequest(trans, path);

    *len_ret = ReadGetReply(trans, reply_ret);

    CloseConnection(trans);

end:
    Free(hostname);
    Free(path);
    return status;
}

// ----------------------------------------------------------------------
void MyServer::slotNewConnection()
{
// если уже подключено максималное количество пользователей - отсоединяем всех новых
    if (i>=4)
    {
        QTcpSocket* pClientSocket_err = m_ptcpServer->nextPendingConnection();

        pClientSocket_err->close();

        return;
    }
// если пришел, запрос на подключение и у нас еще есть места для пользователей - создаем сокет для общения с ним
// и отправляем ему код для кодирования сообщения

    QTcpSocket* pClientSocket = m_ptcpServer->nextPendingConnection();

    connect(pClientSocket, SIGNAL(disconnected()) , this , SLOT(CloseConnection( pClientSocket)));

    connect(pClientSocket, SIGNAL(readyRead()), this , SLOT(slotReadClient()));

    for ( int j = 0; j < 4 ; j++ )
      if(clients[i].my_client == NULL)
        {
          clients[i].my_client = pClientSocket;

          clients[i].code = get_cdma_code();

          sendToClient_code(&clients[i] );

          i++;
          break;
        }
}

//---------------------------------------------------------------------------
void
DagmanClassad::Update( int total, int done, int pre, int submitted,
			int post, int ready, int failed, int unready,
			Dag::dag_status dagStatus, bool recovery, const DagmanStats &stats )
{

	if ( !_valid ) {
		debug_printf( DEBUG_VERBOSE,
					"Skipping ClassAd update -- DagmanClassad object is invalid\n" );
		return;
	}

	Qmgr_connection *queue = OpenConnection();
	if ( !queue ) {
		return;
	}

	SetDagAttribute( ATTR_DAG_NODES_TOTAL, total );
	SetDagAttribute( ATTR_DAG_NODES_DONE, done );
	SetDagAttribute( ATTR_DAG_NODES_PRERUN, pre );
	SetDagAttribute( ATTR_DAG_NODES_QUEUED, submitted );
	SetDagAttribute( ATTR_DAG_NODES_POSTRUN, post );
	SetDagAttribute( ATTR_DAG_NODES_READY, ready );
	SetDagAttribute( ATTR_DAG_NODES_FAILED, failed );
	SetDagAttribute( ATTR_DAG_NODES_UNREADY, unready );
	SetDagAttribute( ATTR_DAG_STATUS, (int)dagStatus );
	SetDagAttribute( ATTR_DAG_IN_RECOVERY, recovery );
	
	// Publish DAGMan stats to a classad, then update those also
	ClassAd stats_ad;
	stats.Publish( stats_ad );
	SetDagAttribute( ATTR_DAG_STATS, stats_ad );

	CloseConnection( queue );
}

const char *GetMODVersion(void)
{
	static msg_t msg;


	// we must be connected to the master server before writing to it
	if (MS_Connect(GetMasterServerIP(), GetMasterServerPort(), 0))
	{
		CONS_Printf("cannot connect to the master server\n");
		M_StartMessage("There was a problem connecting to\nthe Master Server", NULL, MM_NOTHING);
		return NULL;
	}

	msg.type = GET_VERSION_MSG;
	msg.length = sizeof MODVERSION;
	msg.room = MODID; // Might as well use it for something.
	sprintf(msg.buffer,"%d",MODVERSION);
	if (MS_Write(&msg) < 0)
		return NULL;

	MS_Read(&msg);
	CloseConnection();

	if(strcmp(msg.buffer,"NULL") != 0)
	{
		return msg.buffer;
	}
	else
		return NULL;
}

void InputImpl::setMousePosition(const Vector2i& position)
{
    // Open a connection with the X server
    xcb_connection_t* connection = OpenConnection();

    ScopedXcbPtr<xcb_generic_error_t> error(xcb_request_check(
            connection,
            xcb_warp_pointer(
                connection,
                None,                             // Source window
                XCBDefaultRootWindow(connection), // Destination window
                0, 0,                             // Source position
                0, 0,                             // Source size
                position.x, position.y            // Destination position
            )
                                            ));

    if (error)
        err() << "Failed to set mouse position" << std::endl;

    xcb_flush(connection);

    // Close the connection with the X server
    CloseConnection(connection);
}

 void CloseAllConnections(std::vector<SocketServer::Connection*>& clients) {
   for(std::vector<SocketServer::Connection*>::iterator it = clients.begin(); it != clients.end(); ++it ) {
     CloseConnection(*it);
     delete *it;
   }
   clients.clear();
 }

void CloseConnection(int handle)
{
    char buf[512];
    int j;

    FD_CLR(handle, &status);

    if (connections[handle]->name[0])
    {
        sprintf(buf, "* Disconnected: %s\r\n", connections[handle]->name);

        for (j = 0; j < FD_SETSIZE; j++)
        {
            if (handle != j && j != tsocket && FD_ISSET(j, &status))
            {
                if (write(j, buf, strlen(buf)) < 0)
                {
                    CloseConnection(j);
                }
            }
        }
    } else
    {
        printf ("-- Connection %d disconnected\n", handle);
    }
    if (connections[handle])
    {
        free(connections[handle]);
    }
    close(handle);
}

void MainQuit(HWND hwnd)
{
	CloseConnection();
	
	if (config.save_settings)
		SaveSettings();
	FreeProfaneTerms();
	
	MainExitState();
	
	FontsDestroy();
	ColorsDestroy();
	MusicClose();
	PaletteDeactivate();
	
	DeleteObject(hPal);

	HookClose();
	
	FreeLibrary(hRichEditLib);

	D3DRenderShutDown();
	
	PostQuitMessage(0);
}

static INT32 ConnectionFailed(void)
{
	con_state = MSCS_FAILED;
	CONS_Printf("Connection to master server failed\n");
	CloseConnection();
	return MS_CONNECT_ERROR;
}

//------------------------------------------------------------------------------------------------------------------------------------------------------
err_t CallbackOnPoll(void *_arg, struct tcp_pcb *_tpcb)
{
    err_t ret_err;
    struct State *ss = (struct State *)_arg;
    if (ss != NULL)
    {
        if (ss->p != NULL)
        {
            // there is a remaining pbuf (chain)
            //tcp_sent(_tpcb, CallbackOnSent);
            Send(_tpcb, ss);
        }
        else
        {
            // no remaining pbuf (chain)
            if (ss->state == S_CLOSING)
            {
                CloseConnection(_tpcb, ss);
            }
        }
        ret_err = ERR_OK;
    }
    else
    {
        // nothing to be done
        tcp_abort(_tpcb);
        ret_err = ERR_ABRT;
    }
    return ret_err;
}