2010-04-03 07:50:07 +02:00
|
|
|
// ==============================================================
|
|
|
|
// This file is part of Glest (www.glest.org)
|
|
|
|
//
|
|
|
|
// Copyright (C) 2001-2008 Martio Figueroa
|
|
|
|
//
|
|
|
|
// You can redistribute this code and/or modify it under
|
|
|
|
// the terms of the GNU General Public License as published
|
|
|
|
// by the Free Software Foundation; either version 2 of the
|
|
|
|
// License, or (at your option) any later version
|
|
|
|
// ==============================================================
|
|
|
|
|
|
|
|
#ifndef _GLEST_GAME_CONNECTIONSLOT_H_
|
|
|
|
#define _GLEST_GAME_CONNECTIONSLOT_H_
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include "socket.h"
|
|
|
|
#include "network_interface.h"
|
2010-05-12 17:25:56 +02:00
|
|
|
#include <time.h>
|
2010-05-28 01:46:38 +02:00
|
|
|
#include "base_thread.h"
|
2010-09-07 07:25:40 +02:00
|
|
|
#include "leak_dumper.h"
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
using Shared::Platform::ServerSocket;
|
|
|
|
using Shared::Platform::Socket;
|
|
|
|
using std::vector;
|
|
|
|
|
|
|
|
namespace Glest{ namespace Game{
|
|
|
|
|
|
|
|
class ServerInterface;
|
2010-05-28 01:46:38 +02:00
|
|
|
class ConnectionSlot;
|
|
|
|
|
|
|
|
// =====================================================
|
|
|
|
// class ConnectionSlotThread
|
|
|
|
// =====================================================
|
|
|
|
|
2010-06-03 23:49:41 +02:00
|
|
|
enum ConnectionSlotEventType
|
|
|
|
{
|
|
|
|
eNone,
|
|
|
|
eReceiveSocketData,
|
|
|
|
eSendSocketData
|
|
|
|
};
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
class ConnectionSlotEvent {
|
|
|
|
public:
|
|
|
|
|
2010-06-03 09:52:17 +02:00
|
|
|
ConnectionSlotEvent() {
|
2010-06-03 23:49:41 +02:00
|
|
|
eventType = eNone;
|
2010-06-03 09:52:17 +02:00
|
|
|
triggerId = -1;
|
|
|
|
connectionSlot = NULL;
|
|
|
|
networkMessage = NULL;
|
|
|
|
socketTriggered = false;
|
|
|
|
eventCompleted = false;
|
2011-01-11 09:45:58 +01:00
|
|
|
eventId = -1;
|
2010-06-03 09:52:17 +02:00
|
|
|
}
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
int64 triggerId;
|
|
|
|
ConnectionSlot* connectionSlot;
|
2010-06-03 23:49:41 +02:00
|
|
|
ConnectionSlotEventType eventType;
|
|
|
|
const NetworkMessage *networkMessage;
|
2010-05-28 01:46:38 +02:00
|
|
|
bool socketTriggered;
|
|
|
|
bool eventCompleted;
|
2011-01-11 09:45:58 +01:00
|
|
|
int64 eventId;
|
2010-05-28 01:46:38 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
|
|
// This interface describes the methods a callback object must implement
|
|
|
|
//
|
|
|
|
class ConnectionSlotCallbackInterface {
|
|
|
|
public:
|
|
|
|
virtual void slotUpdateTask(ConnectionSlotEvent *event) = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
class ConnectionSlotThread : public BaseThread
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
|
|
|
|
ConnectionSlotCallbackInterface *slotInterface;
|
|
|
|
Semaphore semTaskSignalled;
|
|
|
|
Mutex triggerIdMutex;
|
2011-01-11 09:45:58 +01:00
|
|
|
vector<ConnectionSlotEvent> eventList;
|
2010-06-28 05:17:50 +02:00
|
|
|
int slotIndex;
|
2010-05-28 01:46:38 +02:00
|
|
|
|
|
|
|
virtual void setQuitStatus(bool value);
|
2011-01-11 09:45:58 +01:00
|
|
|
virtual void setTaskCompleted(int eventId);
|
2011-01-11 19:39:18 +01:00
|
|
|
virtual bool canShutdown(bool deleteSelfIfShutdownDelayed=false);
|
2010-05-28 01:46:38 +02:00
|
|
|
|
2011-11-23 09:00:09 +01:00
|
|
|
void slotUpdateTask(ConnectionSlotEvent *event);
|
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
public:
|
2011-11-27 06:27:50 +01:00
|
|
|
ConnectionSlotThread(int slotIndex);
|
|
|
|
ConnectionSlotThread(ConnectionSlotCallbackInterface *slotInterface,int slotIndex);
|
2010-05-28 01:46:38 +02:00
|
|
|
virtual void execute();
|
|
|
|
void signalUpdate(ConnectionSlotEvent *event);
|
2010-12-25 09:14:35 +01:00
|
|
|
bool isSignalCompleted(ConnectionSlotEvent *event);
|
2010-06-28 05:17:50 +02:00
|
|
|
int getSlotIndex() const {return slotIndex; }
|
2011-01-11 09:45:58 +01:00
|
|
|
|
|
|
|
void purgeCompletedEvents();
|
2011-01-11 21:02:07 +01:00
|
|
|
void purgeAllEvents();
|
|
|
|
void setAllEventsCompleted();
|
2010-05-28 01:46:38 +02:00
|
|
|
};
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
// =====================================================
|
|
|
|
// class ConnectionSlot
|
|
|
|
// =====================================================
|
|
|
|
|
2011-01-13 09:17:18 +01:00
|
|
|
class ConnectionSlot: public NetworkInterface {
|
2010-04-03 07:50:07 +02:00
|
|
|
private:
|
|
|
|
ServerInterface* serverInterface;
|
2011-11-23 09:00:09 +01:00
|
|
|
|
2011-11-27 06:27:50 +01:00
|
|
|
Mutex mutexSocket;
|
2010-04-03 07:50:07 +02:00
|
|
|
Socket* socket;
|
|
|
|
int playerIndex;
|
|
|
|
string name;
|
|
|
|
bool ready;
|
|
|
|
vector<std::pair<string,int32> > vctFileList;
|
|
|
|
bool receivedNetworkGameStatus;
|
2010-05-12 17:25:56 +02:00
|
|
|
time_t connectedTime;
|
|
|
|
bool gotIntro;
|
2010-12-24 09:43:09 +01:00
|
|
|
|
2011-05-20 21:44:33 +02:00
|
|
|
Mutex mutexCloseConnection;
|
|
|
|
|
2010-12-24 09:43:09 +01:00
|
|
|
Mutex mutexPendingNetworkCommandList;
|
2010-05-26 07:33:15 +02:00
|
|
|
vector<NetworkCommand> vctPendingNetworkCommandList;
|
2010-05-28 01:46:38 +02:00
|
|
|
ConnectionSlotThread* slotThreadWorker;
|
2010-06-15 07:36:07 +02:00
|
|
|
int currentFrameCount;
|
|
|
|
int currentLagCount;
|
|
|
|
time_t lastReceiveCommandListTime;
|
2010-06-17 02:08:27 +02:00
|
|
|
bool gotLagCountWarning;
|
2010-08-05 07:58:14 +02:00
|
|
|
string versionString;
|
2010-08-23 17:40:43 +02:00
|
|
|
int sessionKey;
|
2010-12-30 16:56:02 +01:00
|
|
|
uint32 connectedRemoteIPAddress;
|
2011-03-11 12:11:46 +01:00
|
|
|
int playerStatus;
|
2011-04-05 20:39:47 +02:00
|
|
|
string playerLanguage;
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
public:
|
|
|
|
ConnectionSlot(ServerInterface* serverInterface, int playerIndex);
|
|
|
|
~ConnectionSlot();
|
|
|
|
|
2011-11-25 22:56:36 +01:00
|
|
|
void update(bool checkForNewClients,int lockedSlotIndex);
|
2010-04-30 03:08:29 +02:00
|
|
|
void setPlayerIndex(int value) { playerIndex = value; }
|
2011-09-01 03:11:23 +02:00
|
|
|
int getPlayerIndex() const {return playerIndex;}
|
2010-04-03 07:50:07 +02:00
|
|
|
|
2010-12-30 16:56:02 +01:00
|
|
|
uint32 getConnectedRemoteIPAddress() const { return connectedRemoteIPAddress; }
|
|
|
|
|
2010-04-03 07:50:07 +02:00
|
|
|
void setReady() {ready= true;}
|
|
|
|
const string &getName() const {return name;}
|
2010-08-21 15:04:52 +02:00
|
|
|
void setName(string value) {name = value;}
|
2010-04-03 07:50:07 +02:00
|
|
|
bool isReady() const {return ready;}
|
|
|
|
|
2011-11-25 10:12:53 +01:00
|
|
|
virtual Socket* getSocket(bool mutexLock=true);
|
2011-11-25 06:37:55 +01:00
|
|
|
pair<bool,Socket*> getSocketInfo();
|
2010-04-03 07:50:07 +02:00
|
|
|
|
|
|
|
virtual void close();
|
|
|
|
//virtual bool getFogOfWar();
|
|
|
|
|
2011-09-01 03:11:23 +02:00
|
|
|
bool getReceivedNetworkGameStatus() const { return receivedNetworkGameStatus; }
|
2010-04-03 07:50:07 +02:00
|
|
|
void setReceivedNetworkGameStatus(bool value) { receivedNetworkGameStatus = value; }
|
|
|
|
|
2011-11-27 06:27:50 +01:00
|
|
|
bool hasValidSocketId();
|
2010-05-13 09:13:53 +02:00
|
|
|
virtual bool getConnectHasHandshaked() const { return gotIntro; }
|
2010-05-25 20:06:42 +02:00
|
|
|
std::vector<std::string> getThreadErrorList() const { return threadErrorList; }
|
|
|
|
void clearThreadErrorList() { threadErrorList.clear(); }
|
2010-05-21 18:36:08 +02:00
|
|
|
|
2010-12-24 09:43:09 +01:00
|
|
|
vector<NetworkCommand> getPendingNetworkCommandList(bool clearList=false);
|
|
|
|
void clearPendingNetworkCommandList();
|
2010-05-26 07:33:15 +02:00
|
|
|
|
2010-05-28 01:46:38 +02:00
|
|
|
void signalUpdate(ConnectionSlotEvent *event);
|
2010-12-25 09:14:35 +01:00
|
|
|
bool updateCompleted(ConnectionSlotEvent *event);
|
2010-05-28 01:46:38 +02:00
|
|
|
|
2010-06-03 09:52:17 +02:00
|
|
|
virtual void sendMessage(const NetworkMessage* networkMessage);
|
2010-06-15 07:36:07 +02:00
|
|
|
int getCurrentFrameCount() const { return currentFrameCount; }
|
|
|
|
|
|
|
|
int getCurrentLagCount() const { return currentLagCount; }
|
|
|
|
void setCurrentLagCount(int value) { currentLagCount = value; }
|
|
|
|
|
|
|
|
time_t getLastReceiveCommandListTime() const { return lastReceiveCommandListTime; }
|
2010-06-03 09:52:17 +02:00
|
|
|
|
2010-06-17 02:08:27 +02:00
|
|
|
bool getLagCountWarning() const { return gotLagCountWarning; }
|
|
|
|
void setLagCountWarning(bool value) { gotLagCountWarning = value; }
|
|
|
|
|
2010-08-05 07:58:14 +02:00
|
|
|
const string &getVersionString() const {return versionString;}
|
|
|
|
|
2010-08-20 22:03:06 +02:00
|
|
|
void validateConnection();
|
2010-08-21 15:04:52 +02:00
|
|
|
virtual string getHumanPlayerName(int index=-1);
|
2010-10-22 09:28:55 +02:00
|
|
|
virtual int getHumanPlayerIndex() const {return playerIndex;}
|
2010-08-20 22:03:06 +02:00
|
|
|
|
2011-03-11 12:11:46 +01:00
|
|
|
int getNetworkPlayerStatus() const { return playerStatus;}
|
|
|
|
|
2011-04-05 20:39:47 +02:00
|
|
|
string getNetworkPlayerLanguage() const { return playerLanguage; }
|
|
|
|
|
2011-09-24 09:46:56 +02:00
|
|
|
time_t getConnectedTime() const { return connectedTime; }
|
|
|
|
int getSessionKey() const { return sessionKey; }
|
|
|
|
|
2011-11-25 22:56:36 +01:00
|
|
|
void updateSlot(ConnectionSlotEvent *event);
|
2011-11-23 09:00:09 +01:00
|
|
|
virtual bool isConnected();
|
|
|
|
|
2011-11-25 00:15:21 +01:00
|
|
|
PLATFORM_SOCKET getSocketId();
|
|
|
|
|
2010-05-21 18:36:08 +02:00
|
|
|
protected:
|
|
|
|
|
|
|
|
Mutex * getServerSynchAccessor();
|
2010-05-25 20:06:42 +02:00
|
|
|
std::vector<std::string> threadErrorList;
|
2010-06-03 09:52:17 +02:00
|
|
|
Mutex socketSynchAccessor;
|
2011-01-13 09:17:18 +01:00
|
|
|
|
2011-11-23 09:00:09 +01:00
|
|
|
void setSocket(Socket *newSocket);
|
|
|
|
void deleteSocket();
|
2011-01-13 09:17:18 +01:00
|
|
|
virtual void update() {}
|
2011-11-25 22:56:36 +01:00
|
|
|
|
|
|
|
bool hasDataToRead();
|
2010-04-03 07:50:07 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
}}//end namespace
|
|
|
|
|
|
|
|
#endif
|