UnsignedByte/Core/UBSocket.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <assert.h>
  22 #include <stdarg.h>
  23
  24 #include <Parse.h>
  25
  26 #include "UBSocket.h"
  27 #include "PCharacter.h"
  28
  29 #include "DatabaseMgr.h"
  30 #include "EditorAccountLogin.h"
  31 #include "EditorOOC.h"
  32 #include "Global.h"
  33 #include "Account.h"
  34 #include "AccountManager.h"
  35 #include "Colour.h"
  36 #include "ColourManager.h"
  37
  38 UBSocket::UBSocket(ISocketHandler& h) :
  39 TcpSocket(h),
  40 m_prompt(),
  41 m_account(),
  42 m_popeditor(false),
  43 m_popLast(false),
  44 m_editors(),
  45 m_nexteditor(NULL),
  46 m_forcer(NULL),
  47 m_lowforced(false),
  48 m_forced(false),
  49 m_highforced(false),
  50 m_hascolor(true),
  51 m_colorcode('`')
  52 {
  53         SetLineProtocol();
  54 }
  55
  56 UBSocket::~UBSocket(void)
  57 {
  58         while(!m_editors.empty())
  59         {
  60                 delete m_editors.top();
  61                 m_editors.pop();
  62         }
  63
  64         if(m_nexteditor != NULL)
  65         {
  66                 delete m_nexteditor;
  67                 m_nexteditor = NULL;
  68         }
  69 }
  70
  71 void UBSocket::OnAccept()
  72 {
  73         Global::Get()->logf("Login from: %s\n", GetRemoteAddress().c_str());
  74         Sendf("Welcome to %s.\n", game::vname);
  75         Editor* p = new EditorAccountLogin(this);
  76         if(!m_editors.empty())
  77                 throw std::logic_error("UBSocket::OnAccept(), m_editor != NULL!");
  78
  79         m_editors.push(p);
  80 }
  81
  82 void UBSocket::OnLine(const std::string &line)
  83 {
  84         bool popLast = false;
  85
  86         SwitchEditors();
  87
  88         if(m_editors.empty())
  89         {
  90                 Global::Get()->bugf("UBSocket::OnLine(), m_editor == NULL!");
  91                 Send("You don't have an editor mode set?\n");
  92                 Send("Closing your connection now.\n");
  93                 SetCloseAndDelete();
  94                 return;
  95         }
  96
  97         if(line.size() && line[0] == Global::Get()->OOCIdentifier)
  98         {
  99                 m_editors.push(new EditorOOC(this));
 100                 popLast = true;
 101         }
 102
 103         m_editors.top()->OnLine(line);
 104
 105         if(popLast)
 106                 PopEditor();
 107
 108         return;
 109 }
 110
 111 mud::Account* UBSocket::GetAccount() const
 112 {
 113         if(!m_account)
 114                 throw std::logic_error("UBSocket::GetAccount(), m_account == NULL!");
 115
 116         return m_account.get();
 117 }
 118
 119 UBSocket* UBSocket::GetForcer() const
 120 {
 121         if(m_forcer == NULL)
 122                 throw std::logic_error("UBSocket::GetForcer(), m_forcer == NULL!");
 123
 124         return m_forcer;
 125 }
 126
 127 bool UBSocket::hasAccount() const
 128 {
 129         return m_account;
 130 }
 131
 132 void UBSocket::SetPrompt(const std::string& prompt)
 133 {
 134         m_prompt = prompt;
 135 }
 136
 137 void UBSocket::SendPrompt()
 138 {
 139         Send(m_prompt);
 140 }
 141
 142 void UBSocket::SetEditor(Editor* edit, bool popLast)
 143 {
 144         if(m_nexteditor)
 145         {
 146                 Global::Get()->bug("UBSocket::SetEditor() was called while we are already waiting to switch to a next editor!\n");
 147                 Send("Something went wrong, somehow you are switching to another editor while you were already doing just that!\n");
 148                 Send("Closing your connection now.\n");
 149                 SetCloseAndDelete();
 150                 return;
 151         }
 152
 153         SetPrompt();
 154         m_nexteditor = edit;
 155         m_popLast = popLast;
 156         return;
 157 }
 158
 159 void UBSocket::SwitchEditors()
 160 {
 161         if(!m_popeditor && !m_nexteditor)
 162                 return;
 163
 164         if(m_popeditor && m_nexteditor)
 165         {
 166                 Global::Get()->bug("UBSocket::SwitchEditors() was called, but we don't have both a new editor and we want to pop one?!");
 167                 Send("Something went wrong, somehow you are switching to another editor but you're also deleting the top one?!\n");
 168                 Send("Closing your connection now.\n");
 169                 SetCloseAndDelete();
 170                 return;
 171         }
 172
 173         if(m_popeditor || m_popLast)
 174         {
 175                 if(m_editors.empty()) // should never happen
 176                 {
 177                         Global::Get()->bug("UBSocket::SwitchEditors() was called, but we don't have a current editor?!");
 178                         Send("Something went wrong, somehow you are switching to another editor but you don't have one set?!\n");
 179                         Send("Closing your connection now.\n");
 180                         SetCloseAndDelete();
 181                         return;
 182                 }
 183
 184                 delete m_editors.top();
 185                 m_editors.pop();
 186                 m_popeditor = false;
 187                 m_popLast = false;
 188                 SetPrompt(m_editors.top()->prompt());
 189         }
 190
 191         if(m_nexteditor)
 192         {
 193                 m_editors.push(m_nexteditor);
 194                 m_nexteditor = NULL;
 195                 SetPrompt(m_editors.top()->prompt());
 196         }
 197
 198         m_editors.top()->OnFocus();
 199
 200         if(m_nexteditor)
 201                 SwitchEditors();
 202         else
 203                 SendPrompt();
 204 }
 205
 206 void UBSocket::PopEditor()
 207 {
 208         if(m_popeditor)
 209         {
 210                 Global::Get()->bug("UBSocket::PopEditor() was called, but the top editor is already being popped?!");
 211                 Send("Something went wrong, somehow you are popping the top editor but it was already being popped?!\n");
 212                 Send("Closing your connection now.\n");
 213                 SetCloseAndDelete();
 214                 return;
 215         }
 216
 217         m_popeditor = true;
 218         SetPrompt();
 219 }
 220
 221 void UBSocket::Send(const std::string& msg)
 222 {
 223         if(!m_hascolor || msg.find(m_colorcode) == std::string::npos)
 224         {
 225                 SendBuf(msg.c_str(), msg.size());
 226                 return;
 227         }
 228
 229         std::string buf = msg;
 230         buf.append("`^");
 231
 232         for(size_t i = buf.find(m_colorcode); i != std::string::npos; i = buf.find(m_colorcode))
 233         {
 234                 if(i >= buf.size())
 235                 {
 236                         Global::Get()->bugf("Colour code %c was found as last character in output '%s'!\n", m_colorcode, msg.c_str());
 237                         std::string err = Global::Get()->sprintf("Colour code %c was found as last character in output '%s'!\n", m_colorcode, msg.c_str());
 238                         SendBuf(err.c_str(), err.size());
 239                         return;
 240                 }
 241
 242                 std::string code = buf.substr(i+1, 1);
 243
 244                 buf.erase(i+1, 1);
 245                 buf.erase(i, 1);
 246
 247                 try
 248                 {
 249                         mud::ColourPtr colour = mud::ColourManager::Get()->GetByCode(code);
 250                         buf.insert(i, colour->getColourString());
 251                 }
 252                 catch(RowNotFoundException& e)
 253                 {
 254                         Global::Get()->bugf("Unknown colour code %s!\n", code.c_str());
 255                         continue;
 256                 }
 257         }
 258
 259         SendBuf(buf.c_str(), buf.size());
 260
 261 }
 262
 263 void UBSocket::Sendf(const char* format, ...)
 264 {
 265         va_list args;
 266         va_start(args, format);
 267         Send(Global::Get()->sprint(args, format));
 268         va_end(args);
 269 }
 270
 271 UBSocket* UBSocket::Cast(Socket *sock, bool Error)
 272 {
 273         UBSocket* sock2 = dynamic_cast<UBSocket*>(sock);
 274         if(!sock2)
 275         {
 276                 if(Error)
 277                 {
 278                         Global::Get()->bugf("BUG: UBSocket::Cast(), Error = true, but sock could not be casted to an UBSocket!");
 279                 }
 280                 return NULL;
 281         }
 282         return sock2;
 283 }