/** Send a delete message to a client. */
void DeleteClient(ClientNode *np)
{
Assert(np);
ReadWMProtocols(np->window, &np->state);
if(np->state.status & STAT_DELETE) {
SendClientMessage(np->window, ATOM_WM_PROTOCOLS, ATOM_WM_DELETE_WINDOW);
} else {
KillClient(np);
}
}
void __fastcall TfrmMain::tcpServerExecute(TIdPeerThread *AThread)
{
TSimpleClient *Client;
AnsiString Com; // System command
AnsiString Msg;
//Get the text sent from the client
try
{
Msg = AThread->Connection->ReadLn("",5000);
}
catch (...)
{
}
// Get the clients package info
if (Msg.Length()==0)return;
Client = (TSimpleClient *)(AThread->Data);
// Check to see if the clients name has been assigned yet
if (Client->Name == "Logging In")
{
// if not, assign the name and announce the client
Client->Name = Msg;
UpdateClientList();
BroadcastMessage("System", Msg + " has just logged in.");
AThread->Connection->WriteLn(memEntry->Lines->Text);
}
else
// If name is set, then send the message
if (Msg[1] != '@')
{
// Not a system command
BroadcastMessage(Client->Name, Msg);
}
else
{
// System command
Com = UpperCase(Trim(Msg.SubString(2, Msg.Pos(":") -2)));
Msg = UpperCase(Trim(Msg.SubString(Msg.Pos(":") +1, Msg.Length())));
if (Com == "CLIENTS")
AThread->Connection->WriteLn( AnsiString("@") + AnsiString("clients:") +
lbClients->Items->CommaText);
if (Com == "KILL")
KillClient(Msg);
}
}
static void BadClient(unsigned int clientID) //deal with a bad message
{
unsigned int currentTime = (unsigned int)GameTime();
if(badMessageCount[clientID] > 1)
{
if((currentTime - badMessage[clientID][badMessageCount[clientID]]) < 10)
{ // kick on 2nd in 10 seconds
KillClient(clientID);
return;
}
}
badMessageCount[clientID]++;
badMessage[clientID][badMessageCount[clientID]] = currentTime;
}
// Modef rdv@202
void
vncServer::SetNewSWSize(long w,long h,BOOL desktop)
{
vncClientList::iterator i;
omni_mutex_lock l(m_clientsLock);
// Post this screen size update to all the connected clients
for (i = m_authClients.begin(); i != m_authClients.end(); i++)
{
// Post the update
if (!GetClient(*i)->SetNewSWSize(w,h,desktop)) {
vnclog.Print(LL_INTINFO, VNCLOG("Unable to set new desktop size\n"));
KillClient(*i);
}
}
}
/** Window menu action callback. */
void RunWindowCommand(const MenuAction *action)
{
switch(action->type) {
case MA_STICK:
if(client->state.status & STAT_STICKY) {
SetClientSticky(client, 0);
} else {
SetClientSticky(client, 1);
}
break;
case MA_MAXIMIZE:
if(client->state.maxFlags) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_VERT | MAX_HORIZ);
}
break;
case MA_MAXIMIZE_H:
MaximizeClient(client, MAX_HORIZ);
break;
case MA_MAXIMIZE_V:
MaximizeClient(client, MAX_VERT);
break;
case MA_MINIMIZE:
MinimizeClient(client, 1);
break;
case MA_RESTORE:
RestoreClient(client, 1);
break;
case MA_CLOSE:
DeleteClient(client);
break;
case MA_SENDTO:
case MA_DESKTOP:
SetClientDesktop(client, action->data.i);
break;
case MA_SHADE:
if(client->state.status & STAT_SHADED) {
UnshadeClient(client);
} else {
ShadeClient(client);
}
break;
case MA_MOVE:
MoveClientKeyboard(client);
break;
case MA_RESIZE:
ResizeClientKeyboard(client);
break;
case MA_KILL:
KillClient(client);
break;
case MA_LAYER:
SetClientLayer(client, action->data.i);
break;
default:
Debug("unknown window command: %d", action->type);
break;
}
}
/** Window menu action callback. */
void RunWindowCommand(MenuAction *action, unsigned button)
{
ClientNode *client = action->context;
switch(action->type) {
case MA_STICK:
if(client->state.status & STAT_STICKY) {
SetClientSticky(client, 0);
} else {
SetClientSticky(client, 1);
}
break;
case MA_MAXIMIZE:
if((client->state.maxFlags & MAX_HORIZ)
&& (client->state.maxFlags & MAX_VERT)
&& !(client->state.status & STAT_MINIMIZED)) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_VERT | MAX_HORIZ);
}
break;
case MA_MAXIMIZE_H:
if((client->state.maxFlags & MAX_HORIZ)
&& !(client->state.maxFlags & MAX_VERT)
&& !(client->state.status & STAT_MINIMIZED)) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_HORIZ);
}
break;
case MA_MAXIMIZE_V:
if((client->state.maxFlags & MAX_VERT)
&& !(client->state.maxFlags & MAX_HORIZ)
&& !(client->state.status & STAT_MINIMIZED)) {
MaximizeClient(client, MAX_NONE);
} else {
MaximizeClient(client, MAX_VERT);
}
break;
case MA_MINIMIZE:
MinimizeClient(client, 1);
break;
case MA_RESTORE:
RestoreClient(client, 1);
break;
case MA_CLOSE:
DeleteClient(client);
break;
case MA_SENDTO:
case MA_DESKTOP:
SetClientDesktop(client, action->value);
break;
case MA_SHADE:
if(client->state.status & STAT_SHADED) {
UnshadeClient(client);
} else {
ShadeClient(client);
}
break;
case MA_MOVE:
MoveClientKeyboard(client);
break;
case MA_RESIZE:
ResizeClientKeyboard(client);
break;
case MA_KILL:
KillClient(client);
break;
case MA_LAYER:
SetClientLayer(client, action->value);
break;
default:
break;
}
}
Message* GetMessage ()
{
ENetEvent event;
if (enet_host_service(serverHost, &event, 0))
{
Message* msg = NULL;
unsigned int clientID = 0;
for (ClientMap::iterator iter = clients.begin(); iter != clients.end(); iter++)
{
if (iter->second == event.peer)
{
clientID = iter->first;
}
}
switch (event.type)
{
case ENET_EVENT_TYPE_CONNECT:
msg = new Message ( "CONNECT", NULL, 0 );
clientID = nextClientID++;
msg->clientID = clientID;
clients[clientID] = event.peer;
badMessage[clientID][0] = 0; //clear bad-message entry so it can be used
Message* keymsg;
Message* ivmsg;
//make and share encryption keys
//ADAM makeBlowKey[clientID];
//ADAM keymsg = new Message( "BLOWKEY", sessionKey[clientID], 16 ); //make a message with the blowkey
//ADAM SendMessage( clientID, keymsg ); //send the blowkey
//ADAM ivmsg = new Message( "BLOWIV" , sessionIV[clientID], 8 ); //make a message with the blowIV
//ADAM SendMessage( clientID, ivmsg ); //send the IV
break;
case ENET_EVENT_TYPE_DISCONNECT:
{
msg = new Message ( "DISCONNECT", NULL, 0 );
msg->clientID = clientID;
ClientMap::iterator iter = clients.find(clientID);
clients.erase(iter);
}
break;
case ENET_EVENT_TYPE_RECEIVE:
msg = MessageEncoding::Decode(event.packet);
if(msg == NULL)
{
if (badMessageCount[clientID] >= 4)
{
KillClient(clientID);
}
else
{
BadClient(clientID);
}
}
else
{
msg->clientID = clientID;
/*
if( Blowfish::do_decrypt(msg, sessionKey[clientID], sessionIV[clientID]) == false) // msg is passed by reference. Return 0 on error.
{
//do something with the bad message
} else {
//do something with the recieved message
}
*/ //disabled until finished implementation
}
enet_packet_destroy(event.packet);
break;
}
return msg;
}
return NULL;
}
void CBOINCClientManager::ShutdownBOINCCore(bool ShuttingDownManager) {
wxLogTrace(wxT("Function Start/End"), wxT("CBOINCClientManager::ShutdownBOINCCore - Function Begin"));
CMainDocument* pDoc = wxGetApp().GetDocument();
wxInt32 iCount = 0;
bool bClientQuit = false;
wxString strConnectedCompter = wxEmptyString;
wxString strPassword = wxEmptyString;
double startTime = 0;
wxDateTime zeroTime = wxDateTime((time_t)0);
wxDateTime rpcCompletionTime = zeroTime;
ASYNC_RPC_REQUEST request;
int quit_result;
wxASSERT(pDoc);
wxASSERT(wxDynamicCast(pDoc, CMainDocument));
#ifdef __WXMAC__
// Mac Manager shuts down client only if Manager started client
if (!m_bBOINCStartedByManager) return;
#endif
#ifdef __WXMSW__
if (IsBOINCConfiguredAsDaemon()) {
stop_daemon_via_daemonctrl();
bClientQuit = true;
} else
#endif
{
pDoc->GetConnectedComputerName(strConnectedCompter);
if (!pDoc->IsComputerNameLocal(strConnectedCompter)) {
RPC_CLIENT rpc;
if (!rpc.init("localhost")) {
pDoc->m_pNetworkConnection->GetLocalPassword(strPassword);
rpc.authorize((const char*)strPassword.mb_str());
if (IsBOINCCoreRunning()) {
rpc.quit();
for (iCount = 0; iCount <= 10; iCount++) {
if (!bClientQuit && !IsBOINCCoreRunning()) {
wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - (localhost) Application Exit Detected"));
bClientQuit = true;
break;
}
wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - (localhost) Application Exit NOT Detected, Sleeping..."));
::wxSleep(1);
}
} else {
bClientQuit = true;
}
}
rpc.close();
} else {
if (IsBOINCCoreRunning()) {
if (ShuttingDownManager) {
// Set event filtering to allow RPC completion
// events but not events which start new RPCs
wxGetApp().SetEventFiltering(true);
}
quit_result = -1;
request.clear();
request.which_rpc = RPC_QUIT;
request.rpcType = RPC_TYPE_ASYNC_NO_REFRESH;
request.completionTime = &rpcCompletionTime;
request.resultPtr = &quit_result;
pDoc->RequestRPC(request); // Issue an asynchronous Quit RPC
// Client needs time to shut down project applications, so don't wait
// for it to shut down; assume it will exit OK if Quit RPC succeeds.
startTime = dtime();
while ((dtime() - startTime) < 10.0) { // Allow 10 seconds
boinc_sleep(0.25); // Check 4 times per second
wxSafeYield(NULL, true); // To allow handling RPC completion events
if (!bClientQuit && (rpcCompletionTime != zeroTime)) {
// If Quit RPC finished, check its returned value
if (quit_result) {
break; // Quit RPC returned an error
}
wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - Application Exit Detected"));
bClientQuit = true;
break;
}
wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::ShutdownBOINCCore - Application Exit NOT Detected, Sleeping..."));
}
} else {
bClientQuit = true;
}
}
}
if (!bClientQuit) {
KillClient();
}
m_lBOINCCoreProcessId = 0;
wxLogTrace(wxT("Function Start/End"), wxT("CBOINCClientManager::ShutdownBOINCCore - Function End"));
}
