src/common/coms/ComsMessageHandler.cpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 //    Scorched3D (c) 2000-2003
   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 <coms/ComsMessageHandler.h>
  22 #include <common/Defines.h>
  23 #include <common/Logger.h>
  24
  25 ComsMessageConnectionHandlerI::~ComsMessageConnectionHandlerI()
  26 {
  27 }
  28
  29 ComsMessageHandlerI::~ComsMessageHandlerI()
  30 {
  31 }
  32
  33 ComsMessageHandlerSentI::~ComsMessageHandlerSentI()
  34 {
  35 }
  36
  37 ComsMessageHandler::ComsMessageHandler(const char *instanceName) :
  38         instanceName_(instanceName),
  39         connectionHandler_(0), comsMessageLogging_(false)
  40 {
  41 }
  42
  43 ComsMessageHandler::~ComsMessageHandler()
  44 {
  45 }
  46
  47 void ComsMessageHandler::setConnectionHandler(
  48                 ComsMessageConnectionHandlerI *handler)
  49 {
  50         connectionHandler_ = handler;
  51 }
  52
  53 void ComsMessageHandler::addHandler(const char *messageType,
  54                 ComsMessageHandlerI *handler)
  55 {
  56         std::map<std::string, ComsMessageHandlerI *>::iterator itor =
  57                 recvHandlerMap_.find(messageType);
  58         DIALOG_ASSERT(itor == recvHandlerMap_.end());
  59
  60         recvHandlerMap_[messageType] = handler;
  61 }
  62
  63 void ComsMessageHandler::addSentHandler(const char *messageType,
  64                 ComsMessageHandlerSentI *handler)
  65 {
  66         std::map<std::string, ComsMessageHandlerSentI *>::iterator itor =
  67                 sentHandlerMap_.find(messageType);
  68         DIALOG_ASSERT(itor == sentHandlerMap_.end());
  69
  70         sentHandlerMap_[messageType] = handler;
  71 }
  72
  73 void ComsMessageHandler::processMessage(NetMessage &message)
  74 {
  75         switch(message.getMessageType())
  76         {
  77                 case NetMessage::BufferMessage:
  78                         if (connectionHandler_)
  79                                 connectionHandler_->messageRecv(message.getDestinationId());
  80                         processReceiveMessage(message);
  81                         break;
  82                 case NetMessage::SentMessage:
  83                         if (connectionHandler_)
  84                                 connectionHandler_->messageSent(message.getDestinationId());
  85                         processSentMessage(message);
  86                         break;
  87                 case NetMessage::DisconnectMessage:
  88                         if (comsMessageLogging_)
  89                         {
  90                                 Logger::log(S3D::formatStringBuffer("ComsMessage::Disconnected(%i, %i)",
  91                                         message.getDestinationId(), message.getFlags()));
  92                         }
  93
  94                         if (connectionHandler_)
  95                                 connectionHandler_->clientDisconnected(message);
  96                         break;
  97                 case NetMessage::ConnectMessage:
  98                         if (comsMessageLogging_)
  99                         {
 100                                 Logger::log(S3D::formatStringBuffer("ComsMessage::Connected(%i)",
 101                                         message.getDestinationId()));
 102                         }
 103
 104                         if (connectionHandler_)
 105                                 connectionHandler_->clientConnected(message);
 106                         break;
 107                 default:
 108                         if (connectionHandler_)
 109                                 connectionHandler_->clientError(message,
 110                                         "Failed to recognise message type");
 111                         break;
 112         }
 113 }
 114
 115 void ComsMessageHandler::processReceiveMessage(NetMessage &message)
 116 {
 117         unsigned int bufferUsed = message.getBuffer().getBufferUsed();
 118         if (!message.getBuffer().uncompressBuffer())
 119         {
 120                 if (connectionHandler_)
 121                         connectionHandler_->clientError(message,
 122                                 "Failed to uncompress RECV message type");
 123         }
 124         NetBufferReader reader(message.getBuffer());
 125
 126         std::string messageType;
 127         if (!reader.getFromBuffer(messageType))
 128         {
 129                 if (connectionHandler_)
 130                         connectionHandler_->clientError(message,
 131                                 "Failed to decode RECV message type");
 132                 return;
 133         }
 134
 135         if (comsMessageLogging_)
 136         {
 137                 Logger::log(S3D::formatStringBuffer("%s::process(%s, %i, %u)",
 138                         instanceName_.c_str(),
 139                         messageType.c_str(), message.getDestinationId(),
 140                         bufferUsed));
 141         }
 142
 143         std::map<std::string, ComsMessageHandlerI *>::iterator itor =
 144                 recvHandlerMap_.find(messageType);
 145         if (itor == recvHandlerMap_.end())
 146         {
 147                 char buffer[1024];
 148                 snprintf(buffer, 1024, "Failed to find RECV message type handler \"%s\"",
 149                         messageType.c_str());
 150
 151                 if (connectionHandler_)
 152                         connectionHandler_->clientError(message,
 153                                 buffer);
 154                 return;
 155         }
 156
 157         ComsMessageHandlerI *handler = (*itor).second;
 158         const char *messageTypeStr = messageType.c_str();
 159         if (!handler->processMessage(
 160                 message, messageTypeStr, reader))
 161         {
 162                 char buffer[1024];
 163                 snprintf(buffer, 1024, "Failed to handle RECV message type \"%s\"",
 164                         messageType.c_str());
 165
 166                 if (connectionHandler_)
 167                         connectionHandler_->clientError(message,
 168                                 buffer);
 169                 return;
 170         }
 171
 172         if (comsMessageLogging_)
 173         {
 174                 Logger::log(S3D::formatStringBuffer("%s::processFinished(%s, %i)",
 175                         instanceName_.c_str(),
 176                         messageType.c_str(), message.getDestinationId()));
 177         }
 178 }
 179
 180 void ComsMessageHandler::processSentMessage(NetMessage &message)
 181 {
 182         if (sentHandlerMap_.empty()) return;
 183
 184         message.getBuffer().uncompressBuffer();
 185         NetBufferReader reader(message.getBuffer());
 186
 187         std::string messageType;
 188         if (!reader.getFromBuffer(messageType))
 189         {
 190                 if (connectionHandler_)
 191                         connectionHandler_->clientError(message,
 192                                 "Failed to decode SENT message type");
 193                 return;
 194         }
 195
 196         if (comsMessageLogging_)
 197         {
 198                 Logger::log(S3D::formatStringBuffer("%s::processSentMessage(%s, %i)",
 199                         instanceName_.c_str(),
 200                         messageType.c_str(), message.getDestinationId()));
 201         }
 202
 203         std::map<std::string, ComsMessageHandlerSentI *>::iterator itor =
 204                 sentHandlerMap_.find(messageType);
 205         if (itor == sentHandlerMap_.end()) return;
 206
 207         ComsMessageHandlerSentI *handler = (*itor).second;
 208         const char *messageTypeStr = messageType.c_str();
 209         if (!handler->processSentMessage(message.getDestinationId(),
 210                 messageTypeStr, reader))
 211         {
 212                 char buffer[1024];
 213                 snprintf(buffer, 1024, "Failed to handle SENT message type \"%s\"",
 214                         messageType.c_str());
 215
 216                 if (connectionHandler_)
 217                         connectionHandler_->clientError(message,
 218                                 buffer);
 219                 return;
 220         }
 221 }