samples/sockets/baseclient.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/sockbase/client.cpp
   3 // Purpose:     Sockets sample for wxBase
   4 // Author:      Lukasz Michalski
   5 // Modified by:
   6 // Created:     27.06.2005
   7 // Copyright:   (c) 2005 Lukasz Michalski <lmichalski@sf.net>
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // ============================================================================
  12 // declarations
  13 // ============================================================================
  14
  15 // ----------------------------------------------------------------------------
  16 // headers
  17 // ----------------------------------------------------------------------------
  18
  19 #include "wx/wx.h"
  20 #include "wx/socket.h"
  21 #include "wx/event.h"
  22 #include "wx/list.h"
  23 #include "wx/cmdline.h"
  24 #include "wx/ffile.h"
  25 #include "wx/datetime.h"
  26 #include "wx/timer.h"
  27 #include "wx/thread.h"
  28
  29 const wxEventType wxEVT_WORKER = wxNewEventType();
  30 #define EVT_WORKER(func) DECLARE_EVENT_TABLE_ENTRY( wxEVT_WORKER, -1, -1, (wxObjectEventFunction) (wxEventFunction) (WorkerEventFunction) & func, (wxObject *) NULL ),
  31
  32 const int timeout_val = 1000;
  33
  34 class WorkerEvent : public wxEvent {
  35 public:
  36     typedef enum {
  37         CONNECTING,
  38         SENDING,
  39         RECEIVING,
  40         DISCONNECTING,
  41         DONE
  42     } evt_type;
  43     WorkerEvent(void* pSender, evt_type type)
  44     {
  45         SetId(-1);
  46         SetEventType(wxEVT_WORKER);
  47         m_sender = pSender;
  48         m_eventType = type;
  49         m_isFailed = false;
  50     }
  51
  52     void setFailed() { m_isFailed = true; }
  53     bool isFailed() const { return m_isFailed; }
  54
  55     virtual wxEvent* Clone() const
  56     {
  57         return new WorkerEvent(*this);
  58     }
  59     void* m_sender;
  60     bool m_isFailed;
  61     wxString m_workerIdent;
  62     evt_type m_eventType;
  63 };
  64
  65 typedef void (wxEvtHandler::*WorkerEventFunction)(WorkerEvent&);
  66
  67 class ThreadWorker;
  68 class EventWorker;
  69
  70 WX_DECLARE_LIST(ThreadWorker, TList);
  71 WX_DECLARE_LIST(EventWorker, EList);
  72
  73 class Client : public wxApp {
  74     DECLARE_EVENT_TABLE()
  75 public:
  76     void RemoveEventWorker(EventWorker* p_worker);
  77 private:
  78     typedef enum
  79     {
  80       THREADS,
  81       EVENTS
  82     } workMode;
  83
  84     typedef enum
  85     {
  86       SEND_RANDOM,
  87       SEND_MESSAGE,
  88       STRESS_TEST
  89     } sendType;
  90
  91     workMode m_workMode;
  92     sendType m_sendType;
  93     wxString m_message;
  94     wxString m_host;
  95     long m_stressWorkers;
  96
  97     virtual bool OnInit();
  98     virtual int OnRun();
  99     virtual int OnExit();
 100     void OnInitCmdLine(wxCmdLineParser& pParser);
 101     bool OnCmdLineParsed(wxCmdLineParser& pParser);
 102     void OnWorkerEvent(WorkerEvent& pEvent);
 103     void OnTimerEvent(wxTimerEvent& pEvent);
 104
 105     void StartWorker(workMode pMode, const wxString& pMessage);
 106     void StartWorker(workMode pMode);
 107     char* CreateBuffer(int *msgsize);
 108
 109     void dumpStatistics();
 110
 111     TList m_threadWorkers;
 112     EList m_eventWorkers;
 113
 114     unsigned m_statConnecting;
 115     unsigned m_statSending;
 116     unsigned m_statReceiving;
 117     unsigned m_statDisconnecting;
 118     unsigned m_statDone;
 119     unsigned m_statFailed;
 120
 121     wxTimer mTimer;
 122 };
 123
 124 DECLARE_APP(Client);
 125
 126 class ThreadWorker : public wxThread
 127 {
 128 public:
 129     ThreadWorker(const wxString& p_host, char* p_buf, int p_size);
 130     virtual ExitCode Entry();
 131 private:
 132     wxString m_host;
 133     wxSocketClient* m_clientSocket;
 134     char* m_inbuf;
 135     char* m_outbuf;
 136     int m_outsize;
 137     int m_insize;
 138     wxString m_workerIdent;
 139 };
 140
 141 class EventWorker : public wxEvtHandler
 142 {
 143     DECLARE_EVENT_TABLE()
 144 public:
 145     EventWorker(const wxString& p_host, char* p_buf, int p_size);
 146     void Run();
 147     virtual ~EventWorker();
 148 private:
 149     wxString m_host;
 150     wxSocketClient* m_clientSocket;
 151     char* m_inbuf;
 152     char* m_outbuf;
 153     int m_outsize;
 154     int m_written;
 155     int m_insize;
 156     int m_readed;
 157
 158     WorkerEvent::evt_type m_currentType;
 159     bool m_doneSent;
 160     wxIPV4address m_localaddr;
 161
 162     void OnSocketEvent(wxSocketEvent& pEvent);
 163     void SendEvent(bool failed);
 164 };
 165
 166 /******************* Implementation ******************/
 167 IMPLEMENT_APP_CONSOLE(Client);
 168
 169 #include <wx/listimpl.cpp>
 170 WX_DEFINE_LIST(TList);
 171 WX_DEFINE_LIST(EList);
 172
 173 wxString
 174 CreateIdent(const wxIPV4address& addr)
 175 {
 176     return wxString::Format(wxT("%s:%d"),addr.IPAddress().c_str(),addr.Service());
 177 }
 178
 179 void
 180 Client::OnInitCmdLine(wxCmdLineParser& pParser)
 181 {
 182     wxApp::OnInitCmdLine(pParser);
 183     pParser.AddSwitch(wxT("e"),wxT("event"),_("Use event based worker (default)"),wxCMD_LINE_PARAM_OPTIONAL);
 184     pParser.AddSwitch(wxT("t"),wxT("thread"),_("Use thread based worker"),wxCMD_LINE_PARAM_OPTIONAL);
 185     pParser.AddSwitch(wxT("r"),wxT("random"),_("Send radnom data (default)"),wxCMD_LINE_PARAM_OPTIONAL);
 186     pParser.AddOption(wxT("m"),wxT("message"),_("Send message from <str>"),wxCMD_LINE_VAL_STRING,wxCMD_LINE_PARAM_OPTIONAL);
 187     pParser.AddOption(wxT("f"),wxT("file"),_("Send contents of <file>"),wxCMD_LINE_VAL_STRING,wxCMD_LINE_PARAM_OPTIONAL);
 188     pParser.AddOption(wxT("H"),wxT("hostname"),_("IP or name of host to connect to"),wxCMD_LINE_VAL_STRING,wxCMD_LINE_PARAM_OPTIONAL);
 189     pParser.AddOption(wxT("s"),wxT("stress"),_("stress test with <num> concurrent connections"),wxCMD_LINE_VAL_NUMBER,wxCMD_LINE_PARAM_OPTIONAL);
 190 }
 191
 192
 193 bool
 194 Client::OnCmdLineParsed(wxCmdLineParser& pParser)
 195 {
 196     wxString fname;
 197     m_workMode = EVENTS;
 198     m_stressWorkers = 50;
 199
 200     if (pParser.Found(_("verbose")))
 201     {
 202         wxLog::AddTraceMask(wxT("wxSocket"));
 203         wxLog::AddTraceMask(wxT("epolldispatcher"));
 204         wxLog::AddTraceMask(wxT("selectdispatcher"));
 205         wxLog::AddTraceMask(wxT("thread"));
 206         wxLog::AddTraceMask(wxT("events"));
 207     }
 208
 209     if (pParser.Found(wxT("t")))
 210         m_workMode = THREADS;
 211     m_sendType = SEND_RANDOM;
 212
 213     if (pParser.Found(wxT("m"),&m_message))
 214         m_sendType = SEND_MESSAGE;
 215     else if (pParser.Found(wxT("f"),&fname))
 216     {
 217         wxFFile file(fname);
 218         if (!file.IsOpened()) {
 219             wxLogError(wxT("Cannot open file %s"),fname.c_str());
 220             return false;
 221         };
 222         if (!file.ReadAll(&m_message)) {
 223             wxLogError(wxT("Cannot read conten of file %s"),fname.c_str());
 224             return false;
 225         };
 226         m_sendType = SEND_MESSAGE;
 227     };
 228
 229     if (pParser.Found(wxT("s"),&m_stressWorkers))
 230         m_sendType = STRESS_TEST;
 231
 232     m_host = wxT("127.0.0.1");
 233     pParser.Found(wxT("H"),&m_host);
 234     return wxApp::OnCmdLineParsed(pParser);
 235 };
 236
 237 bool
 238 Client::OnInit()
 239 {
 240     if (!wxApp::OnInit())
 241         return false;
 242     srand(wxDateTime::Now().GetTicks());
 243     mTimer.SetOwner(this);
 244     m_statConnecting = 0;
 245     m_statSending = 0;
 246     m_statReceiving = 0;
 247     m_statDisconnecting = 0;
 248     m_statDone = 0;
 249     m_statFailed = 0;
 250     return true;
 251 }
 252
 253 int
 254 Client::OnRun()
 255 {
 256     int i;
 257     switch(m_sendType)
 258     {
 259         case STRESS_TEST:
 260             switch(m_workMode)
 261             {
 262                 case THREADS:
 263                     for (i = 0; i < m_stressWorkers; i++) {
 264                         if (m_message.empty())
 265                             StartWorker(THREADS);
 266                         else
 267                             StartWorker(THREADS, m_message);
 268                     }
 269                     break;
 270                 case EVENTS:
 271                     for (i = 0; i < m_stressWorkers; i++) {
 272                         if (m_message.empty())
 273                             StartWorker(EVENTS);
 274                         else
 275                             StartWorker(EVENTS, m_message);
 276                     }
 277                     break;
 278                 default:
 279                     for (i = 0; i < m_stressWorkers; i++) {
 280                         if (m_message.empty())
 281                             StartWorker(i % 5 == 0 ? THREADS : EVENTS);
 282                         else
 283                             StartWorker(i % 5 == 0 ? THREADS : EVENTS, m_message);
 284                     }
 285                 break;
 286             }
 287         break;
 288         case SEND_MESSAGE:
 289             StartWorker(m_workMode,m_message);
 290         break;
 291         case SEND_RANDOM:
 292             StartWorker(m_workMode);
 293         break;
 294     }
 295     mTimer.Start(timeout_val,true);
 296     return wxApp::OnRun();
 297 }
 298
 299 int
 300 Client::OnExit()
 301 {
 302     for(EList::compatibility_iterator it = m_eventWorkers.GetFirst(); it ; it->GetNext()) {
 303         delete it->GetData();
 304     }
 305     return 0;
 306 }
 307
 308 // Create buffer to be sent by client. Buffer contains test indicator
 309 // message size and place for data
 310 // msgsize parameter contains size of data in bytes and
 311 // if input value does not fit into 250 bytes then
 312 // on exit is updated to new value that is multiply of 1024 bytes
 313 char*
 314 Client::CreateBuffer(int* msgsize)
 315 {
 316     int bufsize = 0;
 317     char* buf;
 318     //if message should have more than 256 bytes then set it as
 319     //test3 for compatibility with GUI server sample
 320     if ((*msgsize) > 250)
 321     {
 322         //send at least one kb of data
 323         int size = (*msgsize)/1024 + 1;
 324         //returned buffer will contain test indicator, message size in kb and data
 325         bufsize = size*1024+2;
 326         buf = new char[bufsize];
 327         buf[0] = (unsigned char)0xDE; //second byte contains size in kilobytes
 328         buf[1] = (char)(size);
 329         *msgsize = size*1024;
 330     }
 331     else
 332     {
 333         //returned buffer will contain test indicator, message size in kb and data
 334         bufsize = (*msgsize)+2;
 335         buf = new char[bufsize];
 336         buf[0] = (unsigned char)0xBE; //second byte contains size in bytes
 337         buf[1] = (char)(*msgsize);
 338     }
 339     return buf;
 340 }
 341
 342 void
 343 Client::StartWorker(workMode pMode) {
 344     int msgsize = 1 + (int) (250000.0 * (rand() / (RAND_MAX + 1.0)));
 345     char* buf = CreateBuffer(&msgsize);
 346
 347     //fill data part of buffer with random bytes
 348     for (int i = 2; i < (msgsize); i++) {
 349         buf[i] = i % 256;
 350     }
 351
 352     if (pMode == THREADS) {
 353         ThreadWorker* c = new ThreadWorker(m_host,buf,msgsize+2);
 354         if (c->Create() != wxTHREAD_NO_ERROR) {
 355             wxLogError(wxT("Cannot create more threads"));
 356         } else {
 357             c->Run();
 358             m_threadWorkers.Append(c);
 359         }
 360     } else {
 361         EventWorker* e = new EventWorker(m_host,buf,msgsize+2);
 362         e->Run();
 363         m_eventWorkers.Append(e);
 364     }
 365     m_statConnecting++;
 366 }
 367
 368 void
 369 Client::StartWorker(workMode pMode, const wxString& pMessage) {
 370     char* tmpbuf = wxStrdup(pMessage.mb_str());
 371     int msgsize = strlen(tmpbuf);
 372     char* buf = CreateBuffer(&msgsize);
 373     memset(buf+2,0x0,msgsize);
 374     memcpy(buf+2,tmpbuf,msgsize);
 375     free(tmpbuf);
 376
 377     if (pMode == THREADS) {
 378         ThreadWorker* c = new ThreadWorker(m_host,buf,msgsize+2);
 379         if (c->Create() != wxTHREAD_NO_ERROR) {
 380             wxLogError(wxT("Cannot create more threads"));
 381         } else {
 382             c->Run();
 383             m_threadWorkers.Append(c);
 384         }
 385     } else {
 386         EventWorker* e = new EventWorker(m_host,buf,msgsize+2);
 387         e->Run();
 388         m_eventWorkers.Append(e);
 389     }
 390     m_statConnecting++;
 391 }
 392
 393 void
 394 Client::OnWorkerEvent(WorkerEvent& pEvent) {
 395     switch (pEvent.m_eventType) {
 396         case WorkerEvent::CONNECTING:
 397             if (pEvent.isFailed())
 398             {
 399                 m_statConnecting--;
 400                 m_statFailed++;
 401             }
 402         break;
 403         case WorkerEvent::SENDING:
 404             if (pEvent.isFailed())
 405             {
 406                 m_statFailed++;
 407                 m_statSending--;
 408             }
 409             else
 410             {
 411                 m_statConnecting--;
 412                 m_statSending++;
 413             }
 414         break;
 415         case WorkerEvent::RECEIVING:
 416             if (pEvent.isFailed())
 417             {
 418                 m_statReceiving--;
 419                 m_statFailed++;
 420             }
 421             else
 422             {
 423                 m_statSending--;
 424                 m_statReceiving++;
 425             }
 426         break;
 427         case WorkerEvent::DISCONNECTING:
 428             if (pEvent.isFailed())
 429             {
 430                 m_statDisconnecting--;
 431                 m_statFailed++;
 432             }
 433             else
 434             {
 435                 m_statReceiving--;
 436                 m_statDisconnecting++;
 437             }
 438         break;
 439         case WorkerEvent::DONE:
 440             m_statDone++;
 441             m_statDisconnecting--;
 442         break;
 443     };
 444
 445     if (pEvent.isFailed() || pEvent.m_eventType == WorkerEvent::DONE)
 446     {
 447         for(TList::compatibility_iterator it = m_threadWorkers.GetFirst(); it ; it = it->GetNext()) {
 448             if (it->GetData() == pEvent.m_sender) {
 449                 m_threadWorkers.DeleteNode(it);
 450                 break;
 451             }
 452         }
 453         for(EList::compatibility_iterator it2 = m_eventWorkers.GetFirst(); it2 ; it2 = it2->GetNext())
 454         {
 455             if (it2->GetData() == pEvent.m_sender) {
 456                 delete it2->GetData();
 457                 m_eventWorkers.DeleteNode(it2);
 458                 break;
 459             }
 460         }
 461         if ((m_threadWorkers.GetCount() == 0) && (m_eventWorkers.GetCount() == 0))
 462         {
 463             mTimer.Stop();
 464             dumpStatistics();
 465             wxSleep(2);
 466             ExitMainLoop();
 467         }
 468         else
 469         {
 470             mTimer.Start(timeout_val,true);
 471         }
 472     }
 473 }
 474
 475 void
 476 Client::RemoveEventWorker(EventWorker* p_worker) {
 477     for(EList::compatibility_iterator it = m_eventWorkers.GetFirst(); it ; it = it->GetNext()) {
 478         if (it->GetData() == p_worker) {
 479             //wxLogDebug(wxT("Deleting event worker"));
 480             delete it->GetData();
 481             m_eventWorkers.DeleteNode(it);
 482             return;
 483         }
 484     }
 485 }
 486
 487 void
 488 Client::dumpStatistics() {
 489     wxString msg(
 490         wxString::Format(_("Connecting:\t%d\nSending\t\t%d\nReceiving\t%d\nDisconnecting:\t%d\nDone:\t\t%d\nFailed:\t\t%d\n"),
 491                 m_statConnecting,
 492                 m_statSending,
 493                 m_statReceiving,
 494                 m_statDisconnecting,
 495                 m_statDone,
 496                 m_statFailed
 497                 ));
 498
 499     wxLogMessage(wxT("Current status:\n%s\n"),msg.c_str());
 500 }
 501
 502 void
 503 Client::OnTimerEvent(wxTimerEvent&) {
 504     dumpStatistics();
 505 }
 506
 507 BEGIN_EVENT_TABLE(Client,wxEvtHandler)
 508     EVT_WORKER(Client::OnWorkerEvent)
 509     EVT_TIMER(wxID_ANY,Client::OnTimerEvent)
 510 END_EVENT_TABLE()
 511
 512
 513
 514 EventWorker::EventWorker(const wxString& p_host, char* p_buf, int p_size)
 515   : m_host(p_host),
 516     m_outbuf(p_buf),
 517     m_outsize(p_size),
 518     m_written(0),
 519     m_readed(0)
 520 {
 521     m_clientSocket = new wxSocketClient(wxSOCKET_NOWAIT);
 522     m_clientSocket->SetEventHandler(*this);
 523     m_insize = m_outsize - 2;
 524     m_inbuf = new char[m_insize];
 525 }
 526
 527 void
 528 EventWorker::Run() {
 529     wxIPV4address ca;
 530     ca.Hostname(m_host);
 531     ca.Service(3000);
 532     m_clientSocket->SetNotify(wxSOCKET_CONNECTION_FLAG|wxSOCKET_LOST_FLAG|wxSOCKET_OUTPUT_FLAG|wxSOCKET_INPUT_FLAG);
 533     m_clientSocket->Notify(true);
 534     m_currentType = WorkerEvent::CONNECTING;
 535     m_doneSent = false;
 536     //wxLogMessage(wxT("EventWorker: Connecting....."));
 537     m_clientSocket->Connect(ca,false);
 538 }
 539
 540 void
 541 EventWorker::OnSocketEvent(wxSocketEvent& pEvent) {
 542     switch(pEvent.GetSocketEvent()) {
 543         case wxSOCKET_INPUT:
 544             //wxLogDebug(wxT("EventWorker: INPUT"));
 545             do {
 546                 if (m_readed == m_insize)
 547                     return; //event already posted
 548                 m_clientSocket->Read(m_inbuf + m_readed, m_insize - m_readed);
 549                 if (m_clientSocket->Error())
 550                 {
 551                     if (m_clientSocket->LastError() != wxSOCKET_WOULDBLOCK)
 552                     {
 553                         wxLogError(wxT("%s: read error"),CreateIdent(m_localaddr).c_str());
 554                         SendEvent(true);
 555                     }
 556                 }
 557
 558                 m_readed += m_clientSocket->LastCount();
 559                 //wxLogDebug(wxT("EventWorker: readed %d bytes, %d bytes to do"),m_clientSocket->LastCount(), m_insize - m_readed);
 560                 if (m_readed == m_insize)
 561                 {
 562                     if (!memcmp(m_inbuf,m_outbuf,m_insize)) {
 563                         wxLogError(wxT("%s: data mismatch"),CreateIdent(m_localaddr).c_str());
 564                         SendEvent(true);
 565                     }
 566                     m_currentType = WorkerEvent::DISCONNECTING;
 567                     wxLogDebug(wxT("%s: DISCONNECTING"),CreateIdent(m_localaddr).c_str());
 568                     SendEvent(false);
 569
 570                     //wxLogDebug(wxT("EventWorker %p closing"),this);
 571                     m_clientSocket->Close();
 572
 573                     m_currentType = WorkerEvent::DONE;
 574                     wxLogDebug(wxT("%s: DONE"),CreateIdent(m_localaddr).c_str());
 575                     SendEvent(false);
 576                 }
 577             } while (!m_clientSocket->Error());
 578         break;
 579         case wxSOCKET_OUTPUT:
 580             //wxLogDebug(wxT("EventWorker: OUTPUT"));
 581             do {
 582                 if (m_written == m_outsize)
 583                     return;
 584                 if (m_written == 0)
 585                 {
 586                     m_currentType = WorkerEvent::SENDING;
 587                     wxLogDebug(wxT("%s: SENDING"),CreateIdent(m_localaddr).c_str());
 588                 }
 589                 m_clientSocket->Write(m_outbuf + m_written, m_outsize - m_written);
 590                 if (m_clientSocket->Error())
 591                 {
 592                     if (m_clientSocket->LastError() != wxSOCKET_WOULDBLOCK) {
 593                         wxLogError(wxT("%s: Write error"),CreateIdent(m_localaddr).c_str());
 594                         SendEvent(true);
 595                     }
 596                 }
 597                 m_written += m_clientSocket->LastCount();
 598                 if (m_written != m_outsize)
 599                 {
 600                     //wxLogDebug(wxT("EventWorker: written %d bytes, %d bytes to do"),m_clientSocket->LastCount(),m_outsize - m_written);
 601                 }
 602                 else
 603                 {
 604                     //wxLogDebug(wxT("EventWorker %p SENDING->RECEIVING"),this);
 605                     m_currentType = WorkerEvent::RECEIVING;
 606                     wxLogDebug(wxT("%s: RECEIVING"),CreateIdent(m_localaddr).c_str());
 607                     SendEvent(false);
 608                 }
 609             } while(!m_clientSocket->Error());
 610         break;
 611         case wxSOCKET_CONNECTION:
 612         {
 613             //wxLogMessage(wxT("EventWorker: got connection"));
 614             wxLogMessage(wxT("%s: starting writing message (2 bytes for signature and %d bytes of data to write)"),CreateIdent(m_localaddr).c_str(),m_outsize-2);
 615             if (!m_clientSocket->GetLocal(m_localaddr))
 616             {
 617                 wxLogError(_("Cannot get peer data for socket %p"),m_clientSocket);
 618             }
 619             m_currentType = WorkerEvent::SENDING;
 620             wxLogDebug(wxT("%s: CONNECTING"),CreateIdent(m_localaddr).c_str());
 621             SendEvent(false);
 622         }
 623         break;
 624         case wxSOCKET_LOST:
 625         {
 626             wxLogError(_("%s: connection lost"),CreateIdent(m_localaddr).c_str());
 627             SendEvent(true);
 628         }
 629         break;
 630     }
 631 }
 632
 633 void
 634 EventWorker::SendEvent(bool failed) {
 635     if (m_doneSent)
 636         return;
 637     WorkerEvent e(this,m_currentType);
 638     if (failed) e.setFailed();
 639     wxGetApp().AddPendingEvent(e);
 640     m_doneSent = failed || m_currentType == WorkerEvent::DONE;
 641 };
 642
 643 EventWorker::~EventWorker() {
 644     m_clientSocket->Destroy();
 645     delete [] m_outbuf;
 646     delete [] m_inbuf;
 647 }
 648
 649 BEGIN_EVENT_TABLE(EventWorker,wxEvtHandler)
 650     EVT_SOCKET(wxID_ANY,EventWorker::OnSocketEvent)
 651 END_EVENT_TABLE()
 652
 653
 654 ThreadWorker::ThreadWorker(const wxString& p_host, char* p_buf, int p_size)
 655   : wxThread(wxTHREAD_DETACHED),
 656     m_host(p_host),
 657     m_outbuf(p_buf),
 658     m_outsize(p_size)
 659 {
 660     m_clientSocket = new wxSocketClient(wxSOCKET_BLOCK|wxSOCKET_WAITALL);
 661     m_insize = m_outsize - 2;
 662     m_inbuf = new char[m_insize];
 663 }
 664
 665 wxThread::ExitCode ThreadWorker::Entry()
 666 {
 667     wxIPV4address ca;
 668     ca.Hostname(m_host);
 669     ca.Service(5678);
 670     //wxLogDebug(wxT("ThreadWorker: Connecting....."));
 671     m_clientSocket->SetTimeout(60);
 672     bool failed = false;
 673     WorkerEvent::evt_type etype = WorkerEvent::CONNECTING;
 674     if (!m_clientSocket->Connect(ca)) {
 675         wxLogError(wxT("Cannot connect to %s:%d"),ca.IPAddress().c_str(), ca.Service());
 676         failed = true;
 677     } else {
 678         //wxLogMessage(wxT("ThreadWorker: Connected. Sending %d bytes of data"),m_outsize);
 679         etype = WorkerEvent::SENDING;
 680         WorkerEvent e(this,etype);
 681         wxGetApp().AddPendingEvent(e);
 682         int to_process = m_outsize;
 683         do {
 684             m_clientSocket->Write(m_outbuf,m_outsize);
 685             if (m_clientSocket->Error()) {
 686                 wxLogError(wxT("ThreadWorker: Write error"));
 687                 failed  = true;
 688             }
 689             to_process -= m_clientSocket->LastCount();
 690             //wxLogDebug(wxT("EventWorker: written %d bytes, %d bytes to do"),m_clientSocket->LastCount(),to_process);
 691         } while(!m_clientSocket->Error() && to_process != 0);
 692
 693         if (!failed) {
 694             etype = WorkerEvent::RECEIVING;
 695             WorkerEvent e(this,etype);
 696             wxGetApp().AddPendingEvent(e);
 697             to_process = m_insize;
 698             do {
 699                 m_clientSocket->Read(m_inbuf,m_insize);
 700                 if (m_clientSocket->Error()) {
 701                     wxLogError(wxT("ThreadWorker: Read error"));
 702                     failed = true;
 703                     break;
 704                 }
 705                 to_process -= m_clientSocket->LastCount();
 706                 //wxLogDebug(wxT("EventWorker: readed %d bytes, %d bytes to do"),m_clientSocket->LastCount(),to_process);
 707             } while(!m_clientSocket->Error() && to_process != 0);
 708         }
 709
 710         char* outdat = (char*)m_outbuf+2;
 711         if (!failed && (memcmp(m_inbuf,outdat,m_insize) != 0))
 712         {
 713             wxLogError(wxT("Data mismatch"));
 714             failed = true;
 715         }
 716     }
 717     //wxLogDebug(wxT("ThreadWorker: Finished"));
 718     if (!failed) {
 719         etype = WorkerEvent::DISCONNECTING;
 720         WorkerEvent e(this,etype);
 721         wxGetApp().AddPendingEvent(e);
 722     };
 723     m_clientSocket->Close();
 724     m_clientSocket->Destroy();
 725     m_clientSocket = NULL;
 726     delete [] m_outbuf;
 727     delete [] m_inbuf;
 728     if (!failed)
 729         etype = WorkerEvent::DONE;
 730     WorkerEvent e(this,etype);
 731     if (failed) e.setFailed();
 732     wxGetApp().AddPendingEvent(e);
 733     return 0;
 734 }
 735