bool
BabelClient::answer(ISocket *client)
{
BabelClient *_this = BabelClient::getInstance();
IMutex *mutex = (*MutexVault::getMutexVault())["peer"];
mutex->lock(true);
if (_this->_peer != NULL && _this->_peer->getStatus() == ISocket::Ready)
{
//attach handlers
if (_this->_peer->start() == -1) {
std::cout << "Connection failed" << std::endl;
client->writePacket(new Packet(ENDCALL));
_this->_peer->cancel();
#ifdef _WIN_32
Sleep(100);
#else
usleep(100);
#endif
delete _this->_peer;
_this->_peer = NULL;
}
else
{
//send ok!
client->writePacket(new Packet(CALLESTABLISHED));
mutex->unlock();
return (true);
}
}
mutex->unlock();
return (false);
}
void
ISocket::write(const std::vector<unsigned char> &data, unsigned int id)
{
IMutex *mutex;
if (this->_type == ISocket::Client)
{
mutex = (*MutexVault::getMutexVault())["write" + MutexVault::toString(this->_id)];
mutex->lock(true);
for (unsigned int i = 0; i < data.size(); i++)
this->_write_buffer.push_back(data[i]);
mutex->unlock();
}
else
{
mutex = (*MutexVault::getMutexVault())["serverTargets"];
mutex->lock(true);
if (id != 0 && id < this->_targets.size() && this->_targets[id - 1]->getStatus() == ISocket::Running)
this->_targets[id - 1]->write(data);
else if (id == 0)
for (unsigned int i = 0; i < this->_targets.size(); i++)
this->_targets[i]->write(data);
mutex->unlock();
}
}
void ThreadsManager::launcher(void *data)
{
struct thread_data_container *nice_bullshit;
void *(*func)(void *);
void *tosend;
IThread *me;
std::vector<IThread*> *threads;
std::size_t i;
IMutex *locker;
i = 0;
nice_bullshit = (struct thread_data_container *)data;
me = nice_bullshit->me;
threads = nice_bullshit->threads;
func = nice_bullshit->function;
tosend = nice_bullshit->data;
locker = nice_bullshit->locker;
delete nice_bullshit;
func(tosend);
locker->lockMutex();
while (i < threads->size() && me != threads->at(i))
i++;
if (i < threads->size())
threads->erase(threads->begin() + i);
locker->unlockMutex();
}
bool
GameRoom::startGame(User *user) {
RTypeServer *server = RTypeServer::getInstance();
ISocket *sock;
bool res = false;
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
std::cout << "starting" << std::endl;
mutex->lock(true);
if (this->getState() != GameRoom::Running && user == this->owner)
{
res = true;
#ifdef _WIN_32
this->th = new WinThread<void, GameRoom *>(GameRoom::gameLoop);
#else
this->th = new LinuxThread<void, GameRoom *>(GameRoom::gameLoop);
#endif
this->state = GameRoom::Running;
(*this->th)(this);
for (std::vector<User *>::iterator it = this->users.begin(); it != this->users.end(); it++)
{
if ((sock = server->getUserSocket(*it)) != NULL)
sock->attachOnReceive(RTypeServer::tcpHold);
}
}
mutex->unlock();
return (res);
}
bool
RTypeServer::leaveRoom(User *user) {
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
GameRoom *room;
bool mustSend = false;
bool res = false;
mutex->lock(true);
if ((room = user->getRoom()) != NULL) {
if (room->owner != user)
mustSend = true;
user->getRoom()->removeUser(user);
if (mustSend)
{
std::vector<User *> tmp = room->getUsers();
Instruction i = room->getUsersInstruction();
for (std::vector<User *>::iterator it = tmp.begin(); it != tmp.end(); it++)
RTypeServer::getInstance()->getInstance()->sendToClient(*it, i);
}
res = true;
}
mutex->unlock();
return (res);
}
bool lock(bool wait)
{
IMutex *mutex;
if ((mutex = (*this->_mutex_vault)[this->_id]) == NULL)
return (false);
this->setStatus(Paused);
return (mutex->lock(wait));
}
bool unlock()
{
IMutex *mutex;
if ((mutex = (*this->_mutex_vault)[this->_id]) == NULL)
return (false);
this->setStatus(Running);
return (mutex->unlock());
}
void
BabelClient::addContact(Identity *id)
{
IMutex *mutex = (*MutexVault::getMutexVault())["contacts"];
mutex->lock(true);
std::cout << "new contact : " << id->getUsername() << std::endl;
this->_contacts.push_back(id);
mutex->unlock();
}
GameRoom::State
GameRoom::getState() const
{
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
State state;
mutex->lock(true);
state = this->state;
mutex->unlock();
return (state);
}
void RTypeServer::tcpHold(ISocket *client) {
IMutex *mutex = (*MutexVault::getMutexVault())["instantiation"];
mutex->lock(true);
#ifdef _WIN_32
Sleep(1000);
#else
sleep(1);
#endif
client->attachOnReceive(RTypeServer::tcpGamePlay);
mutex->unlock();
}
Instruction
GameRoom::getUsersInstruction() const {
Instruction instruct(Instruction::GETALLUSERSINROOM);
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
mutex->lock(true);
for (std::vector<User *>::const_iterator it = this->users.begin(); it != this->users.end(); it++)
instruct.addName((*it)->getName());
mutex->unlock();
return (instruct);
}
bool
GameRoom::hasUser(User *user) const
{
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
bool res = false;
mutex->lock(true);
if (std::find(this->users.begin(), this->users.end(), user) != this->users.end())
res = true;
mutex->unlock();
return (res);
}
bool
RTypeServer::startGame(User *user) {
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
bool res = false;
mutex->lock(true);
if (user->getRoom() != NULL)
res = user->getRoom()->setState(GameRoom::Running, user);
mutex->unlock();
return (res);
}
std::vector<Identity>
BabelClient::getContacts()
{
IMutex *mutex = (*MutexVault::getMutexVault())["contacts"];
std::vector<Identity> contacts;
mutex->lock(true);
for (unsigned int i = 0; i < this->_contacts.size(); i++)
if (this->_contacts[i] != NULL)
contacts.push_back(*(this->_contacts[i]));
mutex->unlock();
return (contacts);
}
bool
RTypeServer::roomNameExists(const std::string &roomName) {
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
bool res = false;
mutex->lock(true);
for (std::vector<GameRoom *>::iterator it = this->rooms.begin(); it != this->rooms.end(); it++)
if ((*it)->getName() == roomName) {
res = true;
break;
}
mutex->unlock();
return (res);
}
void
GameRoom::sendToEveryUser(Packet *p) {
ISocket *sock;
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
mutex->lock(true);
for (std::vector<User *>::iterator it = this->users.begin(); it != this->users.end(); it++) {
if ((sock = RTypeServer::getInstance()->getUserSocket(*it)) != NULL)
sock->writePacket(p, 0, false);
}
delete p;
mutex->unlock();
}
void
BabelClient::waitingForAnswer(ISocket *client)
{
Packet *packet;
Instruct *instruct;
Identity *id;
BabelClient *_this = BabelClient::getInstance();
std::cout << "Waiting for answer" << std::endl;
if ((packet = client->readPacket()) != NULL) {
if (packet->getType() == Packet::Inst &&
(instruct = packet->unpack<Instruct>()) != NULL) {
if (*instruct == KO) {
std::cout << "No such user or whatever" << std::endl;
client->attachOnReceive(BabelClient::onReceiveLogged);
}
delete instruct;
}
else if (packet->getType() == Packet::Id)
{
if ((id = packet->unpack<Identity>()) != NULL) {
if (id->getInstruct() == OK) {
std::cout << "Creating server" << std::endl;
IMutex *mutex = (*MutexVault::getMutexVault())["peer"];
mutex->lock(true);
_this->_peer = ISocket::getServer(5555);
_this->_peer->attachOnReceive(BabelClient::receiveSound);
_this->getSound();
_this->_peer->start();
#ifdef _WIN_32
_this->_peerthread = new WinThread<void, ISocket *>(BabelClient::sendSound);
#else
_this->_peerthread = new LinuxThread<void, ISocket *>(BabelClient::sendSound);
#endif
(*_this->_peerthread)(_this->_peer);
client->attachOnReceive(BabelClient::onReceiveLogged);
mutex->unlock();
}
delete id;
}
}
delete packet;
}
}
bool
GameRoom::setState(State state, User *user)
{
if (this->owner != user)
return (false);
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
mutex->lock(true);
if ((this->state = state) == Running)
for (std::vector<User *>::iterator it = this->users.begin(); it != this->users.end(); it++)
(*it)->setState(User::Playing);
mutex->unlock();
return (true);
}
bool
GameRoom::addUser(User *user)
{
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
bool res = false;
mutex->lock(true);
if (!this->hasUser(user) && this->users.size() < 4 && !this->hasUser(user)) {
this->users.push_back(user);
user->attachRoom(this);
res = true;
}
mutex->unlock();
return (res);
}
ISocket *RTypeServer::getUserSocket(User *user) {
ISocket *client = NULL;
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
mutex->lock(true);
for (std::map<ISocket *, User *>::iterator it = this->userLinks.begin(); it != this->userLinks.end(); it++)
if (it->second == user)
{
client = it->first;
break;
}
mutex->unlock();
return (client);
}
bool
GameRoom::removeAllUsers() {
RTypeServer *server = RTypeServer::getInstance();
IMutex *mutex = (*MutexVault::getMutexVault())["room" + this->name];
Instruction instruct(Instruction::LEAVE_ROOM);
mutex->lock(true);
while (this->users.size() > 0) {
server->sendToClient(this->users[0], instruct);
this->users[0]->detachRoom();
}
mutex->unlock();
return (true);
}
bool
RTypeServer::userNameExists(const std::string &username) {
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
bool res = false;
mutex->lock(true);
for (std::map<ISocket *, User *>::iterator it = this->userLinks.begin(); it != this->userLinks.end(); it++)
if (it->second != NULL && it->second->getName() == username) {
res = true;
break;
}
mutex->unlock();
return (res);
}
bool RTypeServer::sendToClient(User *user, Instruction &instruct) {
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
mutex->lock(true);
bool res = false;
for (std::map<ISocket *, User *>::iterator it = this->userLinks.begin(); it != this->userLinks.end(); it++)
if (it->second == user)
{
it->first->writePacket(Packet::pack(instruct));
res = true;
break;
}
mutex->unlock();
return (res);
}
bool
RTypeServer::newUser(const std::string &userName, ISocket *client) {
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
bool res = false;
mutex->lock(true);
if (!userName.empty() && !this->userNameExists(userName))
{
std::cout << "New user : " << userName << std::endl;
this->userLinks[client] = new User(userName);
res = true;
}
mutex->unlock();
return (res);
}
void
BabelClient::removeContact(Identity *id)
{
IMutex *mutex = (*MutexVault::getMutexVault())["contacts"];
mutex->lock(true);
std::cout << "remove contact : " << id->getUsername() << std::endl;
for (unsigned int i = 0; i < this->_contacts.size(); i++)
if (this->_contacts[i] == id)
{
delete this->_contacts[i];
this->_contacts[i] = NULL;
break;
}
mutex->unlock();
}
void
BabelClient::executeIdentity(Identity *id, ISocket *client)
{
IMutex *mutex;
BabelClient *_this = BabelClient::getInstance();
if (id == NULL)
return;
switch (id->getInstruct())
{
case (ADDCONTACT) :
_this->addContact(id);
return; //no delete
case (DELCONTACT) :
_this->removeContact(id);
break;
case (ASKCALL) :
mutex = (*MutexVault::getMutexVault())["peer"];
mutex->lock(true);
std::cout << "asked to call " << id->getIp() << std::endl;
if (id->hasAdressAndName() && _this->_peer == NULL) {
_this->_peer = ISocket::getClient(id->getIp(), id->getPort());
_this->_peer->attachOnReceive(BabelClient::receiveSound);
_this->_peer->attachOnDisconnect(BabelClient::endPeer);
if (_this->_peer->start() == -1) {
std::cout << "Failed to connect!" << std::endl;
delete _this->_peer;
_this->_peer = NULL;
client->writePacket(new Packet(ENDCALL));
}
else {
_this->getSound();
#ifdef _WIN_32
_this->_peerthread = new WinThread<void, ISocket *>(BabelClient::sendSound);
#else
_this->_peerthread = new LinuxThread<void, ISocket *>(BabelClient::sendSound);
#endif
(*_this->_peerthread)(_this->_peer);
}
}
mutex->unlock();
}
delete id;
return;
}
bool RTypeServer::removeRoom(GameRoom *room) {
std::vector<GameRoom *>::iterator it;
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
bool res = false;
mutex->lock(true);
if ((it = std::find(this->rooms.begin(), this->rooms.end(), room)) != this->rooms.end())
{
std::cout << "Removing room " << (*it)->getName() << std::endl;
delete *it;
this->rooms.erase(it);
res = true;
}
mutex->unlock();
return (res);
}
std::vector<ISocket *>
ISocket::getActiveClients()
{
std::vector<ISocket *> tmp;
IMutex *mutex;
if (this->getType() == ISocket::Server)
{
mutex = (*MutexVault::getMutexVault())["serverTargets"];
mutex->lock(true);
for (unsigned int i = 0; i < this->_targets.size(); i++)
if (this->_targets[i]->getStatus() == ISocket::Running)
tmp.push_back(this->_targets[i]);
mutex->unlock();
}
return tmp;
}
//! Decrements the reference count of an object and deletes it if both automaticDelete() is \p true the count reaches 0.
void decReference()
{
// Save local copy in case of deletion.
IMutex* mutex = mRefCountMutex;
// Lock mutex.
if (mutex)
mutex->lock();
VL_CHECK(mReferenceCount)
--mReferenceCount;
if (mReferenceCount == 0 && automaticDelete())
delete this;
// Unlock mutex.
if (mutex)
mutex->unlock();
}
bool RTypeServer::removeUser(ISocket *client) {
std::map<ISocket *, User *>::iterator it;
IMutex *mutex = (*MutexVault::getMutexVault())["serverType"];
bool res = false;
mutex->lock(true);
if ((it = this->userLinks.find(client)) != this->userLinks.end())
{
std::cout << "Removing user : " << this->userLinks[client]->getName() << std::endl;
RTypeServer::getInstance()->leaveRoom(RTypeServer::getInstance()->userLinks[client]);
delete it->second;
client->attachOnReceive(RTypeServer::tcpGuestRoom);
this->userLinks.erase(it);
res = true;
}
mutex->unlock();
return (res);
}