Пример #1
0
void SMOnlineRoom::UpdateClients() {
    int length = 0;
    for (unsigned int x = 0; x < m_clients.size(); ++x)
    {
        if (!m_clients[x])
        {
            LOG->Write("Error: Trying to update NULL client");
            RemoveClient(x);
            continue;
        }

        try
        {
            do
            {
                //As long as we keep getting data from the socket, keep processing it
                length = m_clients[x]->Update(m_packet);
                if (length > 0)
                    ParseData(m_packet, x);
                //Check for NULL incase the client switched rooms
            } while ((length > 0) && (x < m_clients.size()) && (m_clients[x]));
        }
        catch (ClientError&)
        {
            RemoveClient(x);
        }
    }
}
Пример #2
0
 void OnSelect(SocketHandle handle, Network::ISelector::SelectType selectType)
 {
   try
   {
     ClientPool::iterator Iter = Clients.find(handle);
     assert(Iter != Clients.end() && "Client not found");
     if (Iter == Clients.end())
       return;
     switch (selectType)
     {
     case Network::ISelector::stRead :
       {
         try
         {
           Iter->second->RecvData();
         }
         catch (...)
         {
           RemoveClient(Iter);
           throw;
         }
       }
       return;
     case Network::ISelector::stClose :
         RemoveClient(Iter);
       return;
     default :
       break;
     }
   }
   catch (std::exception const &e)
   {
     Common::Log::GetLogInst() << e.what();
   }
 }
Пример #3
0
void TestClient::Shutdown()
{
	m_bRun = false;
	while (ConvertIntToDWORD(m_ExitCount) != m_InitData.ThreadNum * 2 + 1)
		Sleep(10);
	for (int i = 0; i < MAX_CLIENT_THREAD; ++i)
	{
		while (m_NewRecvList[i].HasItem())
			RemoveClient(m_NewRecvList[i].GetItem());
		while (m_NewSendList[i].HasItem())
			RemoveClient(m_NewSendList[i].GetItem());
	}
}
Пример #4
0
static void ClientDataRX (int fd, void *userData)
{
    RADSOCK_ID          client = (RADSOCK_ID)userData;
    int                 retVal;
    ULONG               dateTime;

    retVal = datafeedSyncStartOfFrame(client);
    switch (retVal)
    {
        case ERROR:
            /* problems! - bail out */
            statusUpdateMessage("ClientDataRX: socket error during sync - disconnecting");
            radMsgLog (PRI_HIGH, "ClientDataRX: socket error during sync - disconnecting");
            RemoveClient(client);
            break;

        case ERROR_ABORT:
            // This guy has bailed out:
            statusUpdateMessage("ClientDataRX: socket far-end closed");
            radMsgLog (PRI_MEDIUM, "ClientDataRX: socket far-end closed");
            RemoveClient(client);
            break;
            
        case FALSE:
            radMsgLog (PRI_STATUS, "ClientDataRX: RX sync failure - ignoring");
            break;
    
        case DF_RQST_ARCHIVE_PKT_TYPE:
            // OK, read the unix time sent to retrieve the record:
            if (radSocketReadExact(client, (void *)&dateTime, sizeof(dateTime)) 
                != sizeof (dateTime))
            {
                statusUpdateMessage("ClientDataRX: socket read error - disconnecting");
                radMsgLog (PRI_HIGH, "ClientDataRX: socket read error - disconnecting");
                RemoveClient(client);
                break;
            }
    
            // Convert from network byte order:
            dateTime = ntohl(dateTime);
    
            // Now we have the date and time, get busy:
            SendNextArchiveRecord(client, dateTime);
            break;
    }

    return;
}
Пример #5
0
/** Destroy a confirm dialog. */
void DestroyConfirmDialog(DialogType *dp) {

   int x;

   Assert(dp);

   /* This will take care of destroying the dialog window since
    * its parent will be destroyed. */
   RemoveClient(dp->node);

   for(x = 0; x < dp->lineCount; x++) {
      Release(dp->message[x]);
   }
   Release(dp->message);

   if(dp->next) {
      dp->next->prev = dp->prev;
   }
   if(dp->prev) {
      dp->prev->next = dp->next;
   } else {
      dialogList = dp->next;
   }
   Release(dp);

}
Пример #6
0
/*
        Обрабатывает входящий пакет
        Для вызова нужно заблокировать мютекс
        pthread_mutex_lock(pinf->mutex);
*/
void ReadMSG(PTINF *pinf, MSG msg)
{
        /*
                Эта функция обрабатывает сообщени. 
                Если клиент известный, то отправляем ему его-же сообщение и удаляем его.
                (При подключении, в функции CheckNewClients, сервер отправляет время)
        */
        socklen_t sl;
        SADDR addr;
        int sid = msg.sid;
        time_t now_time;

        if(sid < 0 || sid >= MAX_PTH_CLIENTS){
                printf("Unkown client: %d\n", sid);
                return;
        }
        sl = SADDR_SIZE;
        CopySADDR(*pinf->addr[sid], &addr);
        time(&now_time);
        //printf("%s\t%s(%d): %s\n", ctime(&now_time), inet_ntoa(addr.sin_addr), htons(addr.sin_port), msg.data_str);
        
        if(sendto(pinf->sock_d, &msg, MSG_SIZE, 0, (struct sockaddr *) &addr, sl) < 0)
                perror("Error re-send");
        RemoveClient(pinf, sid);
}
Пример #7
0
void CameraObject::Release( View * view )
{
    if( view->GetType() == THREED_VIEW_TYPE )
    {     
        PerViewElementCont::iterator it = m_perViewElements.find( view );
        if( it != m_perViewElements.end() )
        {
            PerViewElements & perView = (*it).second;
            view->GetRenderer()->RemoveViewProp( perView.cameraActor );
            perView.cameraActor->Delete();
            view->GetRenderer()->RemoveViewProp( perView.cameraAxesActor );
            perView.cameraAxesActor->Delete();
            view->GetRenderer()->RemoveViewProp( perView.cameraTrackerAxesActor );
            perView.cameraTrackerAxesActor->Delete();
            view->GetRenderer()->RemoveViewProp( perView.cameraImageActor );
            perView.cameraImageActor->Delete();
            if( perView.cameraBackup )
            {
                ReleaseControl( 0 );
            }
            ClearDrawingOneView( view, perView );
            m_perViewElements.erase( it );
            disconnect( this, SIGNAL(ObjectModified()), view, SLOT(NotifyNeedRender()) );

            RemoveClient();
            view->RemoveInteractionObject(this);
        }
    }
}
Пример #8
0
void CDiscArena::Reset( void )
{
	// Remove all clients in the queue
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex( i );

		if (pPlayer && (pPlayer->m_pCurrentArena == this) && pPlayer->m_bHasDisconnected != TRUE )
		{
			RemoveClient( pPlayer );

			// Move her into spectator mode
			//MoveToSpectator( pPlayer );
		}
	}

	m_pPlayerQueue = NULL;
	m_iPlayers = 0;
	m_flTimeLimitOver = 0;
	m_bShownTimeWarning = FALSE;
	m_iArenaState = ARENA_WAITING_FOR_PLAYERS;
	memset( m_hCombatants, 0, sizeof( m_hCombatants ) );

	SetThink( NULL );
	pev->nextthink = 0;
}
Пример #9
0
static void
PurgeStaleClients()
{
    if (ipcClientCount == 0)
        return;

    LOG(("PurgeStaleClients [num-clients=%u]\n", ipcClientCount));
    //
    // walk the list of supposedly active clients, and verify the existance of
    // their respective message windows.
    //
    char wName[IPC_CLIENT_WINDOW_NAME_MAXLEN];
    for (int i=ipcClientCount-1; i>=0; --i) {
        ipcClient *client = &ipcClientArray[i];

        LOG(("  checking client at index %u [client-id=%u pid=%u]\n", 
            i, client->ID(), client->PID()));

        IPC_GetClientWindowName(client->PID(), wName);

        // XXX dougt has ideas about how to make this better

        HWND hwnd = FindWindow(IPC_CLIENT_WINDOW_CLASS, wName);
        if (!hwnd) {
            LOG(("  client window not found; removing client!\n"));
            RemoveClient(client);
        }
    }
}
Пример #10
0
    ~iWARPEM_Multiplexed_Endpoint_t()
    {
        bzero( &mRouterInfo, sizeof( iWARPEM_Router_Info_t ));

        // go over all active EPs and flush/destroy them
        for( int i=0; i < mMaxClientCount; i++ )
            if( IsValidClient( i ) )
                RemoveClient( i );

        delete mClientEPs;
        delete mSendBuffer;
        delete mReceiveBuffer;
        pthread_spin_destroy( &mAccessLock );

        BegLogLine( FXLOG_IT_API_O_SOCKETS_MULTIPLEX_LOG )
                << "Destroyed multiplexed router endpoint."
                << " socket: " << mRouterConnFd
                << EndLogLine;

#ifdef MULTIPLEX_STATISTICS
        BegLogLine( 1 )
                << "average message count per send buffer:" << mMsgAvg
                << EndLogLine;
#endif
    }
/* Sets up the TMDIFrame by constructing and creating its TMDIClient. */
void TMDIFrame::SetupWindow()
{
  HMENU FrameMenu;
  RECT R;

  InitClientWindow();
  RemoveClient();   // remove ClientWnd from OWL child list
  FrameMenu = GetMenu(HWindow);
  ClientWnd->ClientAttr->hWindowMenu = GetSubMenu(FrameMenu, ChildMenuPos);
  GetClientRect(HWindow, &R);
  if ( ClientWnd->Attr.X == CW_USEDEFAULT )
  {
    ClientWnd->Attr.X = R.left;
    ClientWnd->Attr.Y = R.top;
  }
  if ( ClientWnd->Attr.W == CW_USEDEFAULT )
  {
    ClientWnd->Attr.W = R.right - R.left;
    ClientWnd->Attr.H = R.bottom - R.top;
  }

  // allow client area to grow scroll bars if necessary.
  ClientWnd->Attr.Style |= WS_VSCROLL + WS_HSCROLL;

  if ( ClientWnd->Create() )
    TWindow::SetupWindow();
  else
    Status = EM_INVALIDCLIENT;
}
Пример #12
0
void CSyncer::InstallClientDiff(const string& diff) 
{
	istringstream i(diff);

	int client;
	string name;
	bool wasRemove;
	int count;	

	while (i >> client) {
		i >> wasRemove;

		//Handle remove if so
		if (wasRemove) {
			RemoveClient(client);
			return;
		}

		// Alas, it was not..
		i >> count;
		for (int a = 0; a < count; ++a) {
			i >> name;
			map<string, DisabledUnit>::iterator found = disabledUnits.find(name);
			if (found != disabledUnits.end()) {
				disabledUnits[name].clients.insert(client);
			}
			else {
				DisabledUnit mu;
				mu.clients.insert(client);
				disabledUnits[name] = mu;
			}
		}
	}
}
Пример #13
0
bool ClientController::DeleteClient(const Client &client)
{
    if(!(UserSingleton::GetInstance().GetPermissions() & PLM::PermissionsFlag::WRITE_CLIENTS))
    {
        return false;
    }

    QSqlQuery query = GetDb().CreateQuery();
    query.prepare("DELETE FROM \"Client\" WHERE \"ClientId\"=:clientId");
    query.bindValue(":clientId", client.GetClientId());

    if(!query.exec())
    {
        return false;
    }

    if(!DeleteContact(client))
    {
        return false;
    }

    qint32 clientId = client.GetClientId();
    RemoveClient(clientId);

    return true;
}
Пример #14
0
void Server::PostSend(Client* client, Packet* packet)
{
    assert(client);
    assert(packet);

    WSABUF recvBufferDescriptor;
    recvBufferDescriptor.buf = reinterpret_cast<char*>(packet->GetData());
    recvBufferDescriptor.len = packet->GetSize();

    DWORD sendFlags = 0;

    IOEvent* event = IOEvent::Create(IOEvent::SEND, client, packet);
    assert(event);

    StartThreadpoolIo(client->GetTPIO());

    if (WSASend(client->GetSocket(), &recvBufferDescriptor, 1, NULL, sendFlags,
                &event->GetOverlapped(), NULL) == SOCKET_ERROR)
    {
        int error = WSAGetLastError();

        if (error != ERROR_IO_PENDING)
        {
            CancelThreadpoolIo(client->GetTPIO());

            ERROR_CODE(error, "WSASend() failed.");

            RemoveClient(client);
        }
    }
    else
    {
        // In this case, the completion callback will have already been scheduled to be called.
    }
}
Пример #15
0
static void
ProcessMsg(HWND hwnd, PRUint32 pid, const ipcMessage *msg)
{
    LOG(("ProcessMsg [pid=%u len=%u]\n", pid, msg->MsgLen()));

    ipcClient *client = GetClientByPID(pid);

    if (client) {
        //
        // if this is an IPCM "client hello" message, then reset the client
        // instance object.
        //
        if (msg->Target().Equals(IPCM_TARGET) &&
            IPCM_GetType(msg) == IPCM_MSG_REQ_CLIENT_HELLO) {
            RemoveClient(client);
            client = NULL;
        }
    }

    if (client == NULL) {
        client = AddClient(hwnd, pid);
        if (!client)
            return;
    }

    IPC_DispatchMsg(client, msg);
}
Пример #16
0
SMOnlineRoom::~SMOnlineRoom()
{
    while (m_clients.size() > 0)
        RemoveClient(m_clients.size()-1);

    while (m_joinrooms.size() > 0)
        UnjoinToRoom(m_joinrooms[m_joinrooms.size()-1]->m_title);
}
Пример #17
0
void Server::AddClient(Client* client)
{
    assert(client);

    // The socket sAcceptSocket does not inherit the properties of the socket associated with
    // sListenSocket parameter until SO_UPDATE_ACCEPT_CONTEXT is set on the socket.
    if (setsockopt(client->GetSocket(), SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
                   reinterpret_cast<const char*>(&m_listenSocket),
                   sizeof(m_listenSocket)) == SOCKET_ERROR)
    {
        ERROR_CODE(WSAGetLastError(), "setsockopt() for AcceptEx() failed.");

        RemoveClient(client);
    }
    else
    {
        client->SetState(Client::ACCEPTED);

        // Connect the socket to IOCP
        TP_IO* pTPIO = CreateThreadpoolIo(reinterpret_cast<HANDLE>(client->GetSocket()),
                                          Server::IoCompletionCallback, NULL, NULL);
        if (pTPIO == NULL)
        {
            ERROR_CODE(GetLastError(), "CreateThreadpoolIo failed for a client.");

            RemoveClient(client);
        }
        else
        {
            std::string ip;
            u_short port = 0;
            Network::GetRemoteAddress(client->GetSocket(), ip, port);
            TRACE("[%d] Accept succeeded. client address : ip[%s], port[%d]", GetCurrentThreadId(),
                  ip.c_str(), port);

            client->SetTPIO(pTPIO);

            EnterCriticalSection(&m_CSForClients);
            m_Clients.push_back(client);
            LeaveCriticalSection(&m_CSForClients);

            PostRecv(client);
        }
    }
}
Пример #18
0
void TestClient::SendThread()
{
	vector<ClientData*> clientList;
	UINT halfTick = m_InitData.Timeout >> 1;
	NetCmd nc;
	nc.SetCmdSize(sizeof(nc));
	nc.SetCmdType(ConvertDWORDToWORD(m_InitData.CmdHearbeat));
	long threadIdx = ::InterlockedIncrement(&m_SendIndex) - 1;
	SafeList<ClientData*> &sendList = m_NewSendList[threadIdx];
	Timer t;
	t.Begin();
	while (m_bRun)
	{
		while (sendList.HasItem())
			clientList.push_back(sendList.GetItem());
		
		UINT tick = GetTickCount();
		for (UINT i = 0; i < clientList.size();)
		{
			ClientData *pc = clientList[i];
			if (pc->InsideRemoved)
			{
				RemoveClient(pc);
				ListRemoveAt(clientList, i);
				continue;
			}
			if (tick - pc->SendTick > halfTick)
			{
				int nret = send(pc->Socket, (const char*)&nc, nc.CmdSize, 0);
				if (nret != nc.CmdSize)
				{
					Log(L"send hearbeat err:%d, lastErr:%d", nret, WSAGetLastError());
				}
				pc->SendTick = tick;
			}
			++i;
		}
		m_SendData[threadIdx].Num = clientList.size();
		m_SendData[threadIdx].Delta = t.Intecept();
		Sleep(m_InitData.SleepTime);
	}
	for (UINT i = 0; i < clientList.size(); ++i)
		RemoveClient(clientList[i]);
	::InterlockedIncrement(&m_ExitCount);
}
Пример #19
0
//============================================================================
//		NMessageServer::DisconnectClient : Disconnect a client.
//----------------------------------------------------------------------------
void NMessageServer::DisconnectClient(NEntityID clientID)
{	StLock		acquireLock(mLock);



	// Disconnect the client
	ClientDisconnected(clientID);
	RemoveClient(      clientID);
}
Пример #20
0
/** Handle an unmap notify event. */
void HandleUnmapNotify(const XUnmapEvent *event)
{
   ClientNode *np;
   XEvent e;

   Assert(event);

   if(event->window != event->event) {
      /* Allow ICCCM synthetic UnmapNotify events through. */
      if (event->event != rootWindow || !event->send_event) {
         return;
      }
   }

   np = FindClientByWindow(event->window);
   if(np) {

      /* Grab the server to prevent the client from destroying the
       * window after we check for a DestroyNotify. */
      GrabServer();

      if(np->controller) {
         (np->controller)(1);
      }

      if(JXCheckTypedWindowEvent(display, np->window, DestroyNotify, &e)) {
         UpdateTime(&e);
         RemoveClient(np);
      } else if((np->state.status & STAT_MAPPED) || event->send_event) {
         if(!(np->state.status & STAT_HIDDEN)) {
            np->state.status &= ~STAT_MAPPED;
            JXUngrabButton(display, AnyButton, AnyModifier, np->window);
            GravitateClient(np, 1);
            JXReparentWindow(display, np->window, rootWindow, np->x, np->y);
            WriteState(np);
            JXRemoveFromSaveSet(display, np->window);
            RemoveClient(np);
         }
      }
      UngrabServer();

   }
}
/* Constructor for a TMDIFrame which is being used in a DLL as an alias
   for a non-OWL window */
TMDIFrame::TMDIFrame(HWND AnHWindow, HWND ClientHWnd, PTModule AModule)
          : TWindow(AnHWindow, AModule)
{
// Attr.Menu set in TWindow's constructor
  ChildMenuPos = 0;
  ActiveChild = NULL;
  ClientWnd = new TMDIClient(this, ClientHWnd);
  RemoveClient();   // remove ClientWnd from OWL child list
  SetFlags(WB_MDIFRAME | WB_ALIAS, TRUE);
}
Пример #22
0
int UserRoom::RemoveClientByStream(css_stream_t* stream)
{
	UserClient* tmp = clients_;
	while (tmp){
		if (tmp->stream() == stream){
			return RemoveClient(tmp);
		}
		tmp = tmp->next();
	}
	return -1;
}
Пример #23
0
 void OnIdle()
 {
   try
   {
     for (ClientPool::iterator i = Clients.begin() ; i != Clients.end() ; )
     {
       if (i->second->CanClose())
         RemoveClient(i++);
       else
       {
         try
         {
           i->second->OnIdle();
           if (i->second->CanClose())
             RemoveClient(i++);
           else
             ++i;
         }
         catch (std::exception const &e)
         {
           Clients.erase(i++);
           Common::Log::GetLogInst() << e.what();
         }
       }
     }
     
     if (Clients.size() >= MaxConnections)
       return;
     
     ClientItemPtr Client = AcceptedClients->Pop();
     if (!Client.get())
       return;
     
     Selector.AddSocket(Client->GetHandle(), Network::ISelector::stRead | Network::ISelector::stClose);
     Clients[Client->GetHandle()] = Client;
   }
   catch (std::exception const &e)
   {
     Common::Log::GetLogInst() << e.what();
   }
 }
Пример #24
0
/** Release client windows. */
void ShutdownClients(void)
{

   int x;

   for(x = 0; x < LAYER_COUNT; x++) {
      while(nodeTail[x]) {
         RemoveClient(nodeTail[x]);
      }
   }

}
Пример #25
0
void CloseSession( PCLIENT pc )
{
	if( pc->ssl_session )
	{
		//matrixSslDeleteSessionId(pc->ssl_session->sid);

		Release( pc->ssl_session );
		pc->ssl_session = NULL;
	}
	if( !( pc->dwFlags & ( CF_CLOSED|CF_CLOSING ) ) )
		RemoveClient( pc );

}
Пример #26
0
/** Handle a destroy notify event. */
char HandleDestroyNotify(const XDestroyWindowEvent *event)
{
   ClientNode *np;
   np = FindClientByWindow(event->window);
   if(np) {
      if(np->controller) {
         (np->controller)(1);
      }
      RemoveClient(np);
      return 1;
   } else {
      return HandleDockDestroy(event->window);
   }
}
Пример #27
0
// 与服务器断开连接
bool CNetProc::Close(const char* ip, const int port)
{
    std::string key = format_key(ip, port);

    CBoostGuard lock(&m_clientLock);
    if (-1 == GetClientHandle(key))
    {
        return true;
    }

    lt_client_disconnect(GetClientHandle(key));
    RemoveClient(key);

    return true;
}
Пример #28
0
void Server::OnClose(IOEvent* event)
{
    assert(event);

    TRACE("Client's socket has been closed.");

    // If whatever game logics about this event are fast enough, we can manage them here but I
    // assume they are slow.
    if (!m_ShuttingDown &&
        !TrySubmitThreadpoolCallback(Server::WorkerRemoveClient, event->GetClient(), &m_ClientTPENV))
    {
        ERROR_CODE(GetLastError(), "can't start WorkerRemoveClient. call it directly.");

        RemoveClient(event->GetClient());
    }
}
Пример #29
0
/**
 * Register Client
 */
HRESULT CDIL_CAN_i_VIEW::CAN_RegisterClient(
    BOOL    Register,
    DWORD&  ClientID,
    char*   ClientName )
{
    USES_CONVERSION;
    HRESULT hResult = S_FALSE;

    EnterCriticalSection(&m_Mutex);

    if (Register)
    {
        if (m_Clients.size() < MAX_CLIENT_ALLOWED)
        {
            pClient_t pClient= GetClient(ClientName);
            if (!pClient)
            {
                pClient = new Client(ClientName);
                ClientID = pClient->m_ClientID;
                AddClient( pClient );
                hResult = S_OK;
            }
            else
            {
                ClientID = pClient->m_ClientID;
                hResult = ERR_CLIENT_EXISTS;
            }
        }
        else
        {
            hResult = ERR_NO_MORE_CLIENT_ALLOWED;
        }
    }
    else
    {
        if (RemoveClient(ClientID))
        {
            hResult = S_OK;
        }
        else
        {
            hResult = ERR_NO_CLIENT_EXIST;
        }
    }
    LeaveCriticalSection(&m_Mutex);
    return hResult;
}
Пример #30
0
/** Callback to kill a client after a confirm dialog. */
void KillClientHandler(ClientNode *np)
{

   Assert(np);

   if(np == activeClient) {
      FocusNextStacked(np);
   }

   GrabServer();
   JXKillClient(display, np->window);
   JXSync(display, True);
   UngrabServer();

   RemoveClient(np);

}