initial GPLv2 releaseHEADmaster

1 files changed, 728 insertions, 0 deletions

diff --git a/tsconnectionthread.cpp b/tsconnectionthread.cpp
new file mode 100644
index 0000000..018afdf
--- /dev/null
+++ b/tsconnectionthread.cpp
@@ -0,0 +1,728 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Authors: Manuel Mausz (manuel@mausz.at)
+ *          Christian Raschko (c.raschko@netcore.at)
+ */
+
+// Header
+#include "tsconnectionthread.h"
+#include "wxbufferex.h"
+
+//Libraries
+#include <wx/txtstrm.h>
+#include <wx/mstream.h>
+#include <wx/buffer.h>
+#include <wx/sckstrm.h>
+#include <wx/sstream.h>
+#include <wx/listimpl.cpp>
+
+WX_DEFINE_LIST(TSQueue);
+
+IMPLEMENT_CLASS(TSConnectionThread, wxObject)
+
+//------------------------------------------------------------------------------
+// Default CTor, Initializes the object
+TSConnectionThread::TSConnectionThread(TSClient *client, wxMutex *mutex)
+  : wxThread(wxTHREAD_JOINABLE)
+{
+  m_pMutex = mutex;
+
+  Create();
+  m_pClient    = client;
+  m_ppCommands = new TSpCommandArray;
+  m_pMySock    = new wxDatagramSocket(m_ClientAddr);
+  m_InQueue    = new TSQueue;
+  m_OutQueue   = new TSQueue;
+
+  m_Exit      = false;
+  m_Error     = false;
+  m_Timer     = false;
+  m_pCurCmd   = NULL;
+  m_LocalCmd  = true;
+  m_Connected = false;
+  m_pMySock   = NULL;
+
+  //register known commands
+  RegisterCommand(new TSCmdSendLogin);
+  RegisterCommand(new TSCmdRecvServer);
+  RegisterCommand(new TSCmdSendDefault);
+  RegisterCommand(new TSCmdRecvChannel);
+  RegisterCommand(new TSCmdRecvUser);
+  RegisterCommand(new TSCmdRecvAck);
+  RegisterCommand(new TSCmdSendAck);
+  RegisterCommand(new TSCmdRecvUrl);
+  RegisterCommand(new TSCmdSendPing);
+  RegisterCommand(new TSCmdRecvPing);
+  RegisterCommand(new TSCmdSendLogout);
+  RegisterCommand(new TSCmdRecvLogout);
+  RegisterCommand(new TSCmdRecvAddPlayer);
+  RegisterCommand(new TSCmdRecvPlayerFlags);
+  RegisterCommand(new TSCmdRecvAddChannel);
+  RegisterCommand(new TSCmdRecvMovePlayer);
+  RegisterCommand(new TSCmdRecvMovePlayer2);
+  RegisterCommand(new TSCmdRecvDelChannel);
+  RegisterCommand(new TSCmdRecvServerUpdate);
+  RegisterCommand(new TSCmdSendAddChannel);
+  RegisterCommand(new TSCmdSendDelChannel);
+  RegisterCommand(new TSCmdSendMovePlayer);
+  RegisterCommand(new TSCmdSendSetChannelPassword);
+  RegisterCommand(new TSCmdSendSetChannelName);
+  RegisterCommand(new TSCmdSendSetChannelTopic);
+  RegisterCommand(new TSCmdSendSetChannelDescription);
+  RegisterCommand(new TSCmdSendSetChannelMaxPlayers);
+  RegisterCommand(new TSCmdSendSetChannelFlagsCodec);
+  RegisterCommand(new TSCmdSendSetChannelOrder);
+  RegisterCommand(new TSCmdRecvSetChannelName);
+  RegisterCommand(new TSCmdRecvSetChannelTopic);
+  RegisterCommand(new TSCmdRecvSetChannelDescription);
+  RegisterCommand(new TSCmdRecvSetChannelMaxPlayers);
+  RegisterCommand(new TSCmdRecvSetChannelFlagsCodec);
+  RegisterCommand(new TSCmdRecvSetChannelOrder);
+  RegisterCommand(new TSCmdSendKickPlayer);
+  RegisterCommand(new TSCmdRecvChannelPasswordChanged);
+
+  //for all unknown commands
+  RegisterCommand(new TSCmdRecvUnknown);
+}
+
+//------------------------------------------------------------------------------
+//Default DTor
+TSConnectionThread::~TSConnectionThread()
+{
+  /* DON'T USE THIS */
+}
+
+//------------------------------------------------------------------------------
+// thread execution starts here
+wxThread::ExitCode TSConnectionThread::Entry()
+{
+  wxLogMessage(_T("TSConnection: thread started."));
+
+  m_ClientAddr.AnyAddress();
+  m_ClientAddr.Service(0);
+
+  m_ServerAddr.Hostname(m_pClient->GetServer()->GetServerAddress());
+  m_ServerAddr.Service(m_pClient->GetServer()->GetPort());
+
+  //no methode to reset socket
+  if (m_pMySock)
+  {
+    wxASSERT(m_pMySock != NULL);
+    m_pMySock->Destroy();
+    m_pMySock = NULL;
+  }
+
+  m_pMySock = new wxDatagramSocket(m_ClientAddr);
+  if(m_pMySock->Error())
+  {
+    wxLogError(_T("creating socket, terminating thread."));
+    return wxThread::ExitCode(EXIT_FAILURE);
+  }
+
+  m_pMySock->SetTimeout(SOCKET_TIMEOUT);
+
+  //empty dgram to initialize and remember peer
+  //allows us to use wxSocketOutputStream afterwards
+  m_pMySock->SendTo(m_ServerAddr, NULL, 0);
+
+  if(!MainLoop())
+  {
+    wxLogDebug(_T("Error: %s"), GetLastError().c_str());
+    return wxThread::ExitCode(EXIT_FAILURE);
+  }
+
+  return wxThread::ExitCode(EXIT_SUCCESS);
+}
+
+//------------------------------------------------------------------------------
+// and stops here
+void TSConnectionThread::OnExit()
+{
+  wxLogDebug(_T("TSConnection: thread terminated."));
+
+  //do the necessary cleanup
+  for(size_t i = 0; i < m_ppCommands->GetCount(); i++)
+    delete m_ppCommands->Item(i);
+
+  m_InQueue->DeleteContents(true);
+  m_OutQueue->DeleteContents(true);
+
+  wxASSERT(m_InQueue != NULL);
+  delete m_InQueue;
+  m_InQueue = NULL;
+
+  wxASSERT(m_OutQueue != NULL);
+  delete m_OutQueue;
+  m_OutQueue = NULL;
+
+  wxASSERT(m_ppCommands != NULL);
+  delete m_ppCommands;
+  m_ppCommands = NULL;
+
+  wxASSERT(m_pMySock != NULL);
+  m_pMySock->Destroy();
+  m_pMySock = NULL;
+
+  if(m_pCurCmd != NULL)
+  {
+    delete m_pCurCmd;
+    m_pCurCmd = NULL;
+  }
+}
+
+//------------------------------------------------------------------------------
+// SyncSendCmdError
+bool TSConnectionThread::SyncSendCmdLastError()
+{
+  //wxLogDebug(_T("SyncSendCmdLastError"));
+  m_LocalCmd = true;
+
+  m_SWTimeout.Start();
+  m_SWTimeout.Pause();
+
+  TSCmd *cmd = m_pClient->GetSync();
+  cmd->error = true;
+  cmd->lasterror = m_LastError;
+  cmd->executed = true;
+  m_pClient->m_Lock = false;
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// Sync with TSClient and send command
+bool TSConnectionThread::SyncSendCmd()
+{
+  //wxLogDebug(_T("SyncSendCmd"));
+  TSCmd *cmd = m_pClient->GetSync();
+  m_pCurCmd = cmd;
+
+  if(cmd->id == 0)
+  {
+    SetLastError(_T("no command id"));
+    SyncSendCmdLastError();
+    return true;
+  }
+
+  if(cmd->id != TS_CMD_SEND_LOGIN &&
+     cmd->id != TS_CMD_SEND_DEFAULT &&
+     !m_Connected)
+  {
+    SetLastError(_T("no connection to server"));
+    SyncSendCmdLastError();
+    return true;
+  }
+
+  m_LocalCmd = false;
+  SendCommand(cmd);
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// Register a Command, the class takes care of this pointer.
+void TSConnectionThread::RegisterCommand(TSCommand *cmd)
+{
+  wxASSERT(cmd != NULL);
+  m_ppCommands->Add(cmd);
+}
+
+//------------------------------------------------------------------------------
+// Executes a command.
+bool TSConnectionThread::ExecuteCommand(wxInputStream &istrm,
+                                        wxOutputStream &ostrm,
+                                        TSCmd *cmd)
+{
+  wxLogDebug(_T("ExecuteCommand: 0x%X"), cmd->id);
+  for(size_t i = 0; i < m_ppCommands->GetCount(); i++)
+  {
+    if(m_ppCommands->Item(i)->IsCommand(cmd->id))
+    {
+      if(m_ppCommands->Item(i)->ProcessCommand(istrm, ostrm, cmd))
+        return true;
+      else
+      {
+        SetLastError(m_ppCommands->Item(i)->GetLastError());
+        return false;
+      }
+    }
+  }
+
+  #ifdef IGNORE_UNKNOWN_COMMANDS
+    //used for unknown commands
+    cmd->id = TS_CMD_RECV_UNKNOWN;
+    return ExecuteCommand(istrm, ostrm, cmd);
+  #else
+    SetLastError(_T("invalid command"));
+    return false;
+  #endif
+}
+
+//------------------------------------------------------------------------------
+// Dumps object.
+void TSConnectionThread::Dump(wxOutputStream &ostrm) const
+{
+  wxTextOutputStream out(ostrm);
+  out << _T("Object: TSConnection (")  << wxString::Format(_T("0x%X"), this) << _T(")") << endl;
+  out << _T("-wxString m_LastError: ") << m_LastError << endl;
+}
+
+//------------------------------------------------------------------------------
+// send command.
+bool TSConnectionThread::SendOutputCommand(TSCmd *cmd)
+{
+  //wxLogDebug(_T("SendOutputCommand: 0x%X"), cmd->id);
+  if(!SendCommandToSocket(cmd))
+    return false;
+
+  /* this m_pCurCmd code possibly contains a memleak
+   * the lines below solves ~95% of them
+   */
+  /*if(m_pCurCmd != NULL)
+  {
+    delete m_pCurCmd;
+    m_pCurCmd = NULL;
+  }*/
+
+  switch(cmd->id)
+  {
+    case TS_CMD_SEND_LOGIN:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_SERVER, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_SERVER, cmd);
+      break;
+    case TS_CMD_SEND_DEFAULT:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_PING:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_PING, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_PING, cmd);
+      break;
+    case TS_CMD_SEND_LOGOUT:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_ADD_CHANNEL:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_DEL_CHANNEL:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_MOVE_PLAYER:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_PASSWORD:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_NAME:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_TOPIC:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_DESCRIPTION:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_MAXPLAYERS:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_FLAGSCODEC:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_SET_CHANNEL_ORDER:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_KICK_PLAYER:
+      AddInputCommand(new TSCmd(TS_CMD_RECV_ACK, cmd));
+      m_pCurCmd = new TSCmd(TS_CMD_RECV_ACK, cmd);
+      break;
+    case TS_CMD_SEND_ACK:
+      break;
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// SendQueuedCommand.
+bool TSConnectionThread::SendQueuedCommand()
+{
+  //wxLogDebug(_T("SendQueuedCommand"));
+  wxTSQueueNode *node = m_OutQueue->GetFirst();
+  TSCmd *t = node->GetData();
+  if(!SendOutputCommand(t))
+    return false;
+
+  delete t;
+  if(!m_OutQueue->DeleteNode(node))
+  {
+    SetLastError(_T("deleting node"));
+    return false;
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// Send command.
+bool TSConnectionThread::SendCommand(TSCmd *cmd)
+{
+  //wxLogDebug(_T("SendCommand: 0x%X"), cmd->id);
+  if(m_pCurCmd == NULL)
+    m_pCurCmd = cmd;
+
+  m_SWTimeout.Start();
+
+  if(!SendOutputCommand(cmd))
+    return false;
+  m_Retries = 0;
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// Send command to socket.
+bool TSConnectionThread::SendCommandToSocket(TSCmd *cmd)
+{
+  //wxLogDebug(_T("SendCommandToSocket: 0x%X"), cmd->id);
+  wxLogVerbose(_T("TSClient: command %#x sent"),cmd->id);
+
+  wxSocketOutputStream so(*m_pMySock);
+  wxBufferedOutputStream out(so);
+  wxSocketInputStream si(*m_pMySock);
+  wxBufferedInputStream in(si);
+
+  if(!ExecuteCommand(in, out, cmd))
+  {
+    SetLastError(_T("execute command"));
+    return false;
+  }
+
+  out.Sync();
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// Add command.
+void TSConnectionThread::AddOutputCommand(TSCmd *cmd)
+{
+  //wxLogDebug(_T("AddOutputCommand: 0x%X"), cmd->id);
+  m_OutQueue->Append(cmd);
+}
+
+//------------------------------------------------------------------------------
+// CheckInputQueue
+bool TSConnectionThread::CheckInputQueue(TSCmd *cmd)
+{
+  wxLogDebug(_T("CheckInputQueue: 0x%X, 0x%X"), cmd->id, cmd->pktid);
+
+  switch(cmd->id)
+  {
+    case TS_CMD_RECV_CHANNEL:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_USER:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_URL:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      wxLogVerbose(_T("TSClient: connected"));
+      m_Connected = true;
+      m_Timer = true;
+      break;
+    case TS_CMD_RECV_LOGOUT:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_UNKNOWN:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_ACK:
+      break;
+    case TS_CMD_RECV_SERVER:
+      //AddOutputCommand(new TSCmd(TS_CMD_SEND_DEFAULT, cmd));
+      break;
+    case TS_CMD_RECV_ADD_PLAYER:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_PLAYER_FLAGS:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_ADD_CHANNEL:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_MOVE_PLAYER:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_MOVE_PLAYER2:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_DEL_CHANNEL:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_SERVER_UPDATE:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      // force reconnect for the sake of consistency
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_LOGOUT, cmd));
+      break;
+    case TS_CMD_RECV_SET_CHANNEL_NAME:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_SET_CHANNEL_TOPIC:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_SET_CHANNEL_DESCRIPTION:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_SET_CHANNEL_MAXPLAYERS:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_SET_CHANNEL_FLAGSCODEC:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_SET_CHANNEL_ORDER:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_CHANNEL_PASSWORD_CHANGED:
+      AddOutputCommand(new TSCmd(TS_CMD_SEND_ACK, cmd));
+      break;
+    case TS_CMD_RECV_PING:
+      break;
+    default:
+      wxLogWarning(_T("input queue: invalid command %#x, ignoring"), cmd->id);
+      break;
+  }
+
+  for(wxTSQueueNode *node = m_InQueue->GetFirst(); node != NULL; node = node->GetNext())
+  {
+    TSCmd *cur = node->GetData();
+    //cmd found
+    if(cur->id == cmd->id)
+    {
+      delete cur;
+      if(!m_InQueue->DeleteNode(node))
+      {
+        SetLastError(_T("deleting node"));
+        return false;
+      }
+      //return true;
+    }
+
+    if(m_pCurCmd->id == cmd->id)
+    {
+      m_pMutex->Lock();
+
+      wxLogDebug(_T("found in queue: 0x%X"), cmd->id);
+      delete m_pCurCmd;
+      m_pCurCmd = NULL;
+      if (!m_LocalCmd)
+      {
+        m_pClient->m_Lock = false;
+        m_pClient->GetSync()->executed = true;
+      }
+      m_LocalCmd = true;
+
+      m_SWTimeout.Pause();
+
+      m_pMutex->Unlock();
+
+      return true;
+    }
+  }
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// ReadQueuedCommand.
+bool TSConnectionThread::RecvCommand()
+{
+  wxSocketOutputStream so(*m_pMySock);
+  wxMemoryBufferEx buf(1024);
+  m_pMySock->RecvFrom(m_ServerAddr, buf.GetData(), 1024);
+  buf.SetDataLen(m_pMySock->LastCount());
+  wxMemoryInputStream in(buf.GetData(), buf.GetDataLen());
+  wxDataInputStream data(in);
+
+  TSCmd cmd;
+  cmd.id     = data.Read32(); //read id
+  data.Read32();              //Session id
+  data.Read32();              //Player id
+  cmd.pktid  = data.Read32(); //Packet count
+  cmd.client = m_pClient;
+  in.SeekI(0);
+
+  wxLogVerbose(_T("TSClient: command %#x received"), cmd.id);
+
+  // dirty workaround for crappy teamspeak protocol, which splits off pakets
+  if(cmd.id == TS_CMD_RECV_CHANNEL)
+  {
+    in.SeekI(-1, wxFromEnd);
+    if(data.Read8() != 0)
+    {
+      wxMemoryBuffer buf_b2(1024);
+      m_pMySock->RecvFrom(m_ServerAddr, buf_b2.GetData(), 1024);
+      buf_b2.SetDataLen(m_pMySock->LastCount());
+      wxMemoryInputStream in_b2(buf_b2.GetData(), buf_b2.GetDataLen());
+      wxDataInputStream data_b2(in_b2);
+
+      if(data_b2.Read32() != cmd.id)
+      {
+        SetLastError(_T("invalid command, perhaps wrong paket order (udp?)"));
+        return false;
+      }
+
+      data_b2.Read32();               //Session id
+      data_b2.Read32();               //Player id
+      cmd.pktid = data_b2.Read32();   //Packet count
+      data_b2.Read32();               //read unknown
+      data_b2.Read32();               //CRC
+
+      // send acknowledge for 2nd packet
+      if(!CheckInputQueue(&cmd))
+        return false;
+
+      // append bytes
+      while(!in_b2.Eof())
+        buf.AppendByte(in_b2.GetC());
+    }
+    in.SeekI(0);
+  }
+
+  // update streams (dirty, but copy-operator is private)
+  wxMemoryInputStream in2(buf.GetData(), buf.GetDataLen());
+  wxDataInputStream data2(in2);
+  if(!ExecuteCommand(in2, so, &cmd))
+  {
+    switch(cmd.id)
+    {
+      case TS_CMD_RECV_SERVER:
+        SyncSendCmdLastError();
+        break;
+    }
+
+    return false;
+  }
+  if(!CheckInputQueue(&cmd))
+    return false;
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+// Add command.
+void TSConnectionThread::AddInputCommand(TSCmd *cmd)
+{
+  //wxLogDebug(_T("AddInputCommand: 0x%X"), cmd->id);
+  m_InQueue->Append(cmd);
+}
+
+//------------------------------------------------------------------------------
+// StartMainLoop
+bool TSConnectionThread::MainLoop()
+{
+  wxStopWatch sw;
+  sw.Start();
+  m_Retries = 0;
+
+  while(1)
+  {
+    //Is new command available
+    m_pMutex->Lock();
+    if((m_pClient->GetSync() != NULL) &&
+       (m_pCurCmd == NULL) &&
+       (m_pClient->m_Lock) &&
+       (m_OutQueue->GetCount() == 0))
+    {
+      m_SWTimeout.Start();
+      SyncSendCmd();
+    }
+    m_pMutex->Unlock();
+
+    //Is some data in queue
+    if(m_OutQueue->GetCount() != 0)
+    {
+      if(!SendQueuedCommand())
+        return false;
+    }
+
+    //Is new data available
+    if(m_pMySock->IsData())
+    {
+      if(!RecvCommand())
+        return false;
+    }
+
+    //Send ping
+    if((sw.Time() >= PING_INTERMITTENT) && m_Timer)
+    {
+      sw.Start();
+      TSCmd tmp;
+      tmp.client = m_pClient;
+      if(m_pCurCmd == NULL)
+        SendCommand(new TSCmd(TS_CMD_SEND_PING, &tmp));
+    }
+
+    //Check for timeout
+    if(m_SWTimeout.Time() > CMD_TIMEOUT)
+    {
+      SetLastError(_T("command timeout"));
+
+      m_pCurCmd = NULL;
+
+      if(!m_LocalCmd)
+      {
+        SyncSendCmdLastError();
+      }
+
+      m_LocalCmd = true;
+      //reset timer
+      m_SWTimeout.Start();
+      m_SWTimeout.Pause();
+
+      wxLogVerbose(_T("TSClient: disconnected"));
+      m_Connected = false;
+      /*
+      if(++m_Retries <= MAX_RETRIES)
+      {
+        m_Connected = false;
+      }
+      */
+      return false;
+    }
+
+    //Check if we should delete our self
+    if(TestDestroy())
+       return true;
+
+    //If an error occurred, end thread
+    if(m_Error)
+      return false;
+
+    //If m_Exit is set, end thread
+    if(m_Exit)
+      return true;
+
+    Sleep(10);
+  }
+}
+