src/common/net/NetServerTCP3.cpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 //    Scorched3D (c) 2000-2009
   3 //
   4 //    This file is part of Scorched3D.
   5 //
   6 //    Scorched3D is free software; you can redistribute it and/or modify
   7 //    it under the terms of the GNU General Public License as published by
   8 //    the Free Software Foundation; either version 2 of the License, or
   9 //    (at your option) any later version.
  10 //
  11 //    Scorched3D is distributed in the hope that it will be useful,
  12 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //    GNU General Public License for more details.
  15 //
  16 //    You should have received a copy of the GNU General Public License
  17 //    along with Scorched3D; if not, write to the Free Software
  18 //    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 ////////////////////////////////////////////////////////////////////////////////
  20
  21 #include <net/NetServerTCP3.h>
  22 #include <net/NetMessagePool.h>
  23 #include <net/NetOptions.h>
  24 #include <common/Logger.h>
  25 #include <common/Clock.h>
  26 #include <limits.h>
  27
  28 NetServerTCP3::NetServerTCP3() :
  29         serverDestinationId_(UINT_MAX), nextDestinationId_(1),
  30         sendRecvThread_(0),
  31         serverSock_(0), serverSockSet_(0),
  32         stopped_(false)
  33 {
  34         NetOptions::instance()->readOptionsFromFile();
  35         NetOptions::instance()->writeOptionsToFile();
  36
  37         serverSockSet_ = SDLNet_AllocSocketSet(1);
  38 }
  39
  40 NetServerTCP3::~NetServerTCP3()
  41 {
  42         SDLNet_FreeSocketSet(serverSockSet_);
  43         serverSockSet_ = 0;
  44 }
  45
  46 bool NetServerTCP3::started()
  47 {
  48         // Do we have a valid send/recieve thread
  49         return (sendRecvThread_ != 0);
  50 }
  51
  52 bool NetServerTCP3::connect(const char *hostName, int portNo)
  53 {
  54         if(SDLNet_Init()==-1)
  55         {
  56                 return false;
  57         }
  58
  59         // Resolve server address
  60         IPaddress serverAddress;
  61         if (SDLNet_ResolveHost(&serverAddress, hostName, portNo) != 0)
  62         {
  63                 Logger::log(S3D::formatStringBuffer("NetServerTCP3: Failed to resolve host %s:%i",
  64                         hostName, portNo));
  65                 return false;
  66         }
  67
  68         // Stop any previous connections
  69         stop();
  70
  71         // Create a new socket for the client
  72         TCPsocket clientSock = SDLNet_TCP_Open(&serverAddress);
  73         if (!clientSock)
  74         {
  75                 Logger::log(S3D::formatStringBuffer("NetServerTCP3: Failed to open client socket : %s",
  76                         SDLNet_GetError()));
  77                 return false;
  78         }
  79
  80         // Add client socket
  81         serverDestinationId_ = addDestination(clientSock);
  82
  83         // Start sending/recieving on the anon port
  84         if (!startProcessing()) return false;
  85
  86         return true;
  87 }
  88
  89 bool NetServerTCP3::start(int portNo)
  90 {
  91         if(SDLNet_Init()==-1)
  92         {
  93                 return false;
  94         }
  95
  96         // Stop any previous connections
  97         stop();
  98
  99         // Get the local ip address
 100         IPaddress localip;
 101         if(SDLNet_ResolveHost(&localip, NULL, portNo)==-1)
 102         {
 103                 return false;
 104         }
 105
 106         // we seem to be able to open the same port
 107         // multiple times!!!
 108         // This is fixed as the server info port catches it
 109         serverSock_ = SDLNet_TCP_Open(&localip);
 110         if (!serverSock_)
 111         {
 112                 Logger::log(S3D::formatStringBuffer("NetServerTCP3: Failed to open server socket %i", portNo));
 113                 return false;
 114         }
 115         SDLNet_TCP_AddSocket(serverSockSet_, serverSock_);
 116
 117         // Start sending/recieving on this socket
 118         if (!startProcessing()) return false;
 119
 120         return true;
 121 }
 122
 123 void NetServerTCP3::stop()
 124 {
 125         if (started())
 126         {
 127                 disconnectAllClients();
 128                 while (started()) SDL_Delay(100);
 129         }
 130 }
 131
 132 bool NetServerTCP3::startProcessing()
 133 {
 134         // Check if we are already running
 135         DIALOG_ASSERT(!sendRecvThread_);
 136
 137         // We are going to process all incoming message
 138         outgoingMessageHandler_.setMessageHandler(this);
 139
 140         // Create the processing thread
 141         sendRecvThread_ = SDL_CreateThread(
 142                 NetServerTCP3::sendRecvThreadFunc, (void *) this);
 143         if (sendRecvThread_ == 0)
 144         {
 145                 Logger::log(S3D::formatStringBuffer("NetServerTCP3: Failed to create NetServerTCP3 thread"));
 146                 return false;
 147         }
 148
 149         return true;
 150 }
 151
 152 int NetServerTCP3::sendRecvThreadFunc(void *c)
 153 {
 154         // Call a non-static class thread to do the processing in (just for convienience)
 155         NetServerTCP3 *th = (NetServerTCP3*) c;
 156         th->actualSendRecvFunc();
 157
 158         th->sendRecvThread_ = 0;
 159         Logger::log(S3D::formatStringBuffer("NetServerTCP3: shutdown"));
 160         return 0;
 161 }
 162
 163 void NetServerTCP3::actualSendRecvFunc()
 164 {
 165         float timeDiff;
 166         stopped_ = false;
 167         Clock netClock;
 168         while(!stopped_)
 169         {
 170                 // Send/recv packets
 171                 checkClients();
 172                 timeDiff = netClock.getTimeDifference();
 173                 if (timeDiff > 1.0f)
 174                 {
 175                         Logger::log(S3D::formatStringBuffer(
 176                                 "NetServerTCP3: checkClients took %.2f seconds",
 177                                 timeDiff));
 178                 }
 179
 180                 // Check for new connections
 181                 checkNewConnections();
 182                 timeDiff = netClock.getTimeDifference();
 183                 if (timeDiff > 1.0f)
 184                 {
 185                         Logger::log(S3D::formatStringBuffer(
 186                                 "NetServerTCP3: checkNewConnections took %.2f seconds",
 187                                 timeDiff));
 188                 }
 189
 190                 // sleep so we don't go into an infinite loop
 191                 SDL_Delay(10);
 192                 netClock.getTimeDifference();
 193
 194                 // Check for any new messages we should send and process them
 195                 outgoingMessageHandler_.processMessages();
 196                 timeDiff = netClock.getTimeDifference();
 197                 if (timeDiff > 1.0f)
 198                 {
 199                         Logger::log(S3D::formatStringBuffer(
 200                                 "NetServerTCP3: processMessages took %.2f seconds",
 201                                 timeDiff));
 202                 }
 203         }
 204
 205         if (serverSock_) SDLNet_TCP_Close(serverSock_);
 206         serverSock_ = 0;
 207 }
 208
 209 void NetServerTCP3::checkNewConnections()
 210 {
 211         if (!serverSock_) return; // Check if we are running a server
 212
 213         int numready = SDLNet_CheckSockets(serverSockSet_, 10);
 214         if (numready == -1) return;
 215         if (numready == 0) return;
 216
 217         if(SDLNet_SocketReady(serverSock_))
 218         {
 219                 TCPsocket clientSock = SDLNet_TCP_Accept(serverSock_);
 220                 if (clientSock)
 221                 {
 222                         // add client
 223                         addDestination(clientSock);
 224                 }
 225         }
 226 }
 227
 228 void NetServerTCP3::checkClients()
 229 {
 230         // Check each destination to see if it has closed
 231         std::map<unsigned int, NetServerTCP3Destination *>::iterator itor;
 232         for (itor = destinations_.begin();
 233                 itor != destinations_.end();
 234                 itor++)
 235         {
 236                 NetServerTCP3Destination *destination = itor->second;
 237                 if (destination->anyFinished())
 238                 {
 239                         destroyDestination(itor->first, NetMessage::UserDisconnect);
 240                         break;
 241                 }
 242         }
 243
 244         // Check each destination that is closing to see if it has finished
 245         if (finishedDestinations_.empty()) return;
 246
 247         NetServerTCP3Destination *destination = finishedDestinations_.front();
 248         if (destination->allFinished())
 249         {
 250                 delete destination;
 251                 finishedDestinations_.pop_front();
 252         }
 253 }
 254
 255 void NetServerTCP3::processMessage(NetMessage &message)
 256 {
 257         // We have been told to send a message to a client
 258
 259         // Check if we have been told to disconect all clients
 260         if (message.getMessageType() == NetMessage::DisconnectAllMessage)
 261         {
 262                 // Foreach client
 263                 while (!destinations_.empty())
 264                 {
 265                         // Get the first client
 266                         std::map<unsigned int, NetServerTCP3Destination *>::iterator itor =
 267                                 destinations_.begin();
 268                         unsigned int destinationId = (*itor).first;
 269                         NetServerTCP3Destination *destination = (*itor).second;
 270
 271                         // This is a message telling us to kick the client, do so
 272                         destroyDestination(destinationId, NetMessage::KickDisconnect);
 273                 }
 274
 275                 stopped_ = true;
 276                 return;
 277         }
 278
 279         // Look up this destination in the list of current
 280         std::map<unsigned int, NetServerTCP3Destination *>::iterator itor =
 281                 destinations_.find(message.getDestinationId());
 282         if (itor == destinations_.end())
 283         {
 284                 return;
 285         }
 286
 287         NetServerTCP3Destination *destination = (*itor).second;
 288         if (message.getMessageType() == NetMessage::DisconnectMessage)
 289         {
 290                 // This is a message telling us to kick the client, do so
 291                 destroyDestination(message.getDestinationId(), NetMessage::KickDisconnect);
 292         }
 293         else
 294         {
 295                 // Add this buffer to the list of items to be sent
 296                 NetMessage *newMessage = NetMessagePool::instance()->getFromPool(
 297                         message.getMessageType(), message.getDestinationId(),
 298                         message.getIpAddress(), message.getFlags());
 299                 newMessage->getBuffer().allocate(message.getBuffer().getBufferUsed());
 300                 memcpy(newMessage->getBuffer().getBuffer(),
 301                         message.getBuffer().getBuffer(),
 302                         message.getBuffer().getBufferUsed());
 303                 newMessage->getBuffer().setBufferUsed(message.getBuffer().getBufferUsed());
 304
 305                 destination->sendMessage(newMessage);
 306         }
 307 }
 308
 309 void NetServerTCP3::disconnectAllClients()
 310 {
 311         // Get a new buffer from the pool (with the discconect type set)
 312         NetMessage *message = NetMessagePool::instance()->
 313                 getFromPool(NetMessage::DisconnectAllMessage, 0, 0);
 314
 315         // Send Mesage
 316         outgoingMessageHandler_.addMessage(message);
 317 }
 318
 319 void NetServerTCP3::disconnectClient(unsigned int destination)
 320 {
 321         // Get a new buffer from the pool (with the discconect type set)
 322         NetMessage *message = NetMessagePool::instance()->
 323                 getFromPool(NetMessage::DisconnectMessage, destination, 0);
 324
 325         // Send Mesage
 326         outgoingMessageHandler_.addMessage(message);
 327 }
 328
 329 void NetServerTCP3::sendMessageServer(NetBuffer &buffer,
 330         unsigned int flags)
 331 {
 332         // Send a message to the server
 333         sendMessageDest(buffer, serverDestinationId_, flags);
 334 }
 335
 336 void NetServerTCP3::sendMessageDest(NetBuffer &buffer,
 337         unsigned int destination, unsigned int flags)
 338 {
 339         // Get a new buffer from the pool
 340         NetMessage *message = NetMessagePool::instance()->
 341                 getFromPool(NetMessage::BufferMessage,
 342                                 destination, 0, flags);
 343
 344         // Add message to new buffer
 345         message->getBuffer().allocate(buffer.getBufferUsed());
 346         memcpy(message->getBuffer().getBuffer(),
 347                 buffer.getBuffer(), buffer.getBufferUsed());
 348         message->getBuffer().setBufferUsed(buffer.getBufferUsed());
 349
 350         // Send Mesage
 351         outgoingMessageHandler_.addMessage(message);
 352 }
 353
 354 int NetServerTCP3::processMessages()
 355 {
 356         // Process any messages that we have recieved
 357         return incomingMessageHandler_.processMessages();
 358 }
 359
 360 void NetServerTCP3::setMessageHandler(NetMessageHandlerI *handler)
 361 {
 362         // Set the message handler to process any messages that we recieve
 363         incomingMessageHandler_.setMessageHandler(handler);
 364 }
 365
 366 void NetServerTCP3::destroyDestination(unsigned int destinationId,
 367         NetMessage::DisconnectFlags type)
 368 {
 369         // Destroy this destination
 370         std::map<unsigned int, NetServerTCP3Destination *>::iterator itor =
 371                 destinations_.find(destinationId);
 372         if (itor == destinations_.end())
 373         {
 374                 return;
 375         }
 376
 377         if (serverDestinationId_ == destinationId)
 378         {
 379                 stopped_ = true;
 380                 serverDestinationId_ = UINT_MAX;
 381         }
 382
 383         NetServerTCP3Destination *destination = (*itor).second;
 384
 385         // Get a new buffer from the pool (with the discconect type set)
 386         NetMessage *message = NetMessagePool::instance()->
 387                 getFromPool(NetMessage::DisconnectMessage,
 388                         destinationId, destination->getIpAddress());
 389         message->setFlags((unsigned int) type);
 390
 391         destinations_.erase(itor);
 392         destination->printStats();
 393         destination->close();
 394         finishedDestinations_.push_back(destination);
 395
 396         // Add to outgoing message pool
 397         incomingMessageHandler_.addMessage(message);
 398 }
 399
 400 unsigned int NetServerTCP3::addDestination(TCPsocket &socket)
 401 {
 402         NetInterface::getConnects() ++;
 403
 404         // Allocate new destination id
 405         do {
 406                 nextDestinationId_++;
 407         } while (nextDestinationId_ == 0 || nextDestinationId_ == UINT_MAX);
 408         unsigned int destinationId = nextDestinationId_;
 409
 410         // Create new destination
 411         NetServerTCP3Destination *destination =
 412                 new NetServerTCP3Destination(
 413                         &incomingMessageHandler_, socket, destinationId);
 414         destinations_[destinationId] = destination;
 415
 416         // Get a new buffer from the pool (with the connect type set)
 417         NetMessage *message = NetMessagePool::instance()->
 418                 getFromPool(NetMessage::ConnectMessage,
 419                         destinationId, destination->getIpAddress());
 420         incomingMessageHandler_.addMessage(message);
 421
 422         // Return new id
 423         return destinationId;
 424 }