]> git.saurik.com Git - wxWidgets.git/blob - samples/sockets/client.cpp
more wxFD_XXX renamings (patch 1488371)
[wxWidgets.git] / samples / sockets / client.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: client.cpp
3 // Purpose: Client for wxSocket demo
4 // Author: Guillermo Rodriguez Garcia <guille@iies.es>
5 // Modified by:
6 // Created: 1999/09/19
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999 Guillermo Rodriguez Garcia
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ==========================================================================
13 // declarations
14 // ==========================================================================
15
16 // --------------------------------------------------------------------------
17 // headers
18 // --------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx/wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 # pragma hdrstop
25 #endif
26
27 // for all others, include the necessary headers
28 #ifndef WX_PRECOMP
29 # include "wx/wx.h"
30 #endif
31
32 #include "wx/socket.h"
33 #include "wx/url.h"
34 #include "wx/wfstream.h"
35
36 // --------------------------------------------------------------------------
37 // resources
38 // --------------------------------------------------------------------------
39
40 // the application icon
41 #if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) || defined(__WXMAC__)
42 # include "mondrian.xpm"
43 #endif
44
45 // --------------------------------------------------------------------------
46 // classes
47 // --------------------------------------------------------------------------
48
49 // Define a new application type
50 class MyApp : public wxApp
51 {
52 public:
53 virtual bool OnInit();
54 };
55
56 // Define a new frame type: this is going to be our main frame
57 class MyFrame : public wxFrame
58 {
59 public:
60 MyFrame();
61 ~MyFrame();
62
63 // event handlers for File menu
64 void OnQuit(wxCommandEvent& event);
65 void OnAbout(wxCommandEvent& event);
66
67 // event handlers for Socket menu
68 void OnOpenConnection(wxCommandEvent& event);
69 void OnTest1(wxCommandEvent& event);
70 void OnTest2(wxCommandEvent& event);
71 void OnTest3(wxCommandEvent& event);
72 void OnCloseConnection(wxCommandEvent& event);
73
74 #if wxUSE_URL
75 // event handlers for Protocols menu
76 void OnTestURL(wxCommandEvent& event);
77 #endif
78
79 // event handlers for DatagramSocket menu (stub)
80 void OnDatagram(wxCommandEvent& event);
81
82 // socket event handler
83 void OnSocketEvent(wxSocketEvent& event);
84
85 // convenience functions
86 void UpdateStatusBar();
87
88 private:
89 wxSocketClient *m_sock;
90 wxTextCtrl *m_text;
91 wxMenu *m_menuFile;
92 wxMenu *m_menuSocket;
93 wxMenu *m_menuDatagramSocket;
94 wxMenu *m_menuProtocols;
95 wxMenuBar *m_menuBar;
96 bool m_busy;
97
98 // any class wishing to process wxWidgets events must use this macro
99 DECLARE_EVENT_TABLE()
100 };
101
102 // --------------------------------------------------------------------------
103 // constants
104 // --------------------------------------------------------------------------
105
106 // IDs for the controls and the menu commands
107 enum
108 {
109 // menu items
110 CLIENT_QUIT = wxID_EXIT,
111 CLIENT_ABOUT = wxID_ABOUT,
112 CLIENT_OPEN = 100,
113 CLIENT_TEST1,
114 CLIENT_TEST2,
115 CLIENT_TEST3,
116 CLIENT_CLOSE,
117 #if wxUSE_URL
118 CLIENT_TESTURL,
119 #endif
120 CLIENT_DGRAM,
121
122 // id for socket
123 SOCKET_ID
124 };
125
126 // --------------------------------------------------------------------------
127 // event tables and other macros for wxWidgets
128 // --------------------------------------------------------------------------
129
130 BEGIN_EVENT_TABLE(MyFrame, wxFrame)
131 EVT_MENU(CLIENT_QUIT, MyFrame::OnQuit)
132 EVT_MENU(CLIENT_ABOUT, MyFrame::OnAbout)
133 EVT_MENU(CLIENT_OPEN, MyFrame::OnOpenConnection)
134 EVT_MENU(CLIENT_TEST1, MyFrame::OnTest1)
135 EVT_MENU(CLIENT_TEST2, MyFrame::OnTest2)
136 EVT_MENU(CLIENT_TEST3, MyFrame::OnTest3)
137 EVT_MENU(CLIENT_CLOSE, MyFrame::OnCloseConnection)
138 EVT_MENU(CLIENT_DGRAM, MyFrame::OnDatagram)
139 #if wxUSE_URL
140 EVT_MENU(CLIENT_TESTURL, MyFrame::OnTestURL)
141 #endif
142 EVT_SOCKET(SOCKET_ID, MyFrame::OnSocketEvent)
143 END_EVENT_TABLE()
144
145 IMPLEMENT_APP(MyApp)
146
147 // ==========================================================================
148 // implementation
149 // ==========================================================================
150
151 // --------------------------------------------------------------------------
152 // the application class
153 // --------------------------------------------------------------------------
154
155 bool MyApp::OnInit()
156 {
157 // Create the main application window
158 MyFrame *frame = new MyFrame();
159
160 // Show it and tell the application that it's our main window
161 frame->Show(true);
162 SetTopWindow(frame);
163
164 // success
165 return true;
166 }
167
168 // --------------------------------------------------------------------------
169 // main frame
170 // --------------------------------------------------------------------------
171
172 // frame constructor
173 MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, wxID_ANY,
174 _("wxSocket demo: Client"),
175 wxDefaultPosition, wxSize(300, 200))
176 {
177 // Give the frame an icon
178 SetIcon(wxICON(mondrian));
179
180 // Make menus
181 m_menuFile = new wxMenu();
182 m_menuFile->Append(CLIENT_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
183 m_menuFile->AppendSeparator();
184 m_menuFile->Append(CLIENT_QUIT, _("E&xit\tAlt-X"), _("Quit client"));
185
186 m_menuSocket = new wxMenu();
187 m_menuSocket->Append(CLIENT_OPEN, _("&Open session"), _("Connect to server"));
188 m_menuSocket->AppendSeparator();
189 m_menuSocket->Append(CLIENT_TEST1, _("Test &1"), _("Test basic functionality"));
190 m_menuSocket->Append(CLIENT_TEST2, _("Test &2"), _("Test ReadMsg and WriteMsg"));
191 m_menuSocket->Append(CLIENT_TEST3, _("Test &3"), _("Test large data transfer"));
192 m_menuSocket->AppendSeparator();
193 m_menuSocket->Append(CLIENT_CLOSE, _("&Close session"), _("Close connection"));
194
195 m_menuDatagramSocket = new wxMenu();
196 m_menuDatagramSocket->Append(CLIENT_DGRAM, _("Send Datagram"), _("Test UDP sockets"));
197
198 #if wxUSE_URL
199 m_menuProtocols = new wxMenu();
200 m_menuProtocols->Append(CLIENT_TESTURL, _("Test URL"), _("Get data from the specified URL"));
201 #endif
202
203 // Append menus to the menubar
204 m_menuBar = new wxMenuBar();
205 m_menuBar->Append(m_menuFile, _("&File"));
206 m_menuBar->Append(m_menuSocket, _("&SocketClient"));
207 m_menuBar->Append(m_menuDatagramSocket, _("&DatagramSocket"));
208 #if wxUSE_URL
209 m_menuBar->Append(m_menuProtocols, _("&Protocols"));
210 #endif
211 SetMenuBar(m_menuBar);
212
213 #if wxUSE_STATUSBAR
214 // Status bar
215 CreateStatusBar(2);
216 #endif // wxUSE_STATUSBAR
217
218 // Make a textctrl for logging
219 m_text = new wxTextCtrl(this, wxID_ANY,
220 _("Welcome to wxSocket demo: Client\nClient ready\n"),
221 wxDefaultPosition, wxDefaultSize,
222 wxTE_MULTILINE | wxTE_READONLY);
223
224 // Create the socket
225 m_sock = new wxSocketClient();
226
227 // Setup the event handler and subscribe to most events
228 m_sock->SetEventHandler(*this, SOCKET_ID);
229 m_sock->SetNotify(wxSOCKET_CONNECTION_FLAG |
230 wxSOCKET_INPUT_FLAG |
231 wxSOCKET_LOST_FLAG);
232 m_sock->Notify(true);
233
234 m_busy = false;
235 UpdateStatusBar();
236 }
237
238 MyFrame::~MyFrame()
239 {
240 // No delayed deletion here, as the frame is dying anyway
241 delete m_sock;
242 }
243
244 // event handlers
245
246 void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
247 {
248 // true is to force the frame to close
249 Close(true);
250 }
251
252 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
253 {
254 wxMessageBox(_("wxSocket demo: Client\n(c) 1999 Guillermo Rodriguez Garcia\n"),
255 _("About Client"),
256 wxOK | wxICON_INFORMATION, this);
257 }
258
259 void MyFrame::OnOpenConnection(wxCommandEvent& WXUNUSED(event))
260 {
261 wxIPV4address addr;
262
263 m_menuSocket->Enable(CLIENT_OPEN, false);
264 m_menuSocket->Enable(CLIENT_CLOSE, false);
265
266 // Ask user for server address
267 wxString hostname = wxGetTextFromUser(
268 _("Enter the address of the wxSocket demo server:"),
269 _("Connect ..."),
270 _("localhost"));
271
272 addr.Hostname(hostname);
273 addr.Service(3000);
274
275 // Mini-tutorial for Connect() :-)
276 // ---------------------------
277 //
278 // There are two ways to use Connect(): blocking and non-blocking,
279 // depending on the value passed as the 'wait' (2nd) parameter.
280 //
281 // Connect(addr, true) will wait until the connection completes,
282 // returning true on success and false on failure. This call blocks
283 // the GUI (this might be changed in future releases to honour the
284 // wxSOCKET_BLOCK flag).
285 //
286 // Connect(addr, false) will issue a nonblocking connection request
287 // and return immediately. If the return value is true, then the
288 // connection has been already successfully established. If it is
289 // false, you must wait for the request to complete, either with
290 // WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST
291 // events (please read the documentation).
292 //
293 // WaitOnConnect() itself never blocks the GUI (this might change
294 // in the future to honour the wxSOCKET_BLOCK flag). This call will
295 // return false on timeout, or true if the connection request
296 // completes, which in turn might mean:
297 //
298 // a) That the connection was successfully established
299 // b) That the connection request failed (for example, because
300 // it was refused by the peer.
301 //
302 // Use IsConnected() to distinguish between these two.
303 //
304 // So, in a brief, you should do one of the following things:
305 //
306 // For blocking Connect:
307 //
308 // bool success = client->Connect(addr, true);
309 //
310 // For nonblocking Connect:
311 //
312 // client->Connect(addr, false);
313 //
314 // bool waitmore = true;
315 // while (! client->WaitOnConnect(seconds, millis) && waitmore )
316 // {
317 // // possibly give some feedback to the user,
318 // // update waitmore if needed.
319 // }
320 // bool success = client->IsConnected();
321 //
322 // And that's all :-)
323
324 m_text->AppendText(_("\nTrying to connect (timeout = 10 sec) ...\n"));
325 m_sock->Connect(addr, false);
326 m_sock->WaitOnConnect(10);
327
328 if (m_sock->IsConnected())
329 m_text->AppendText(_("Succeeded ! Connection established\n"));
330 else
331 {
332 m_sock->Close();
333 m_text->AppendText(_("Failed ! Unable to connect\n"));
334 wxMessageBox(_("Can't connect to the specified host"), _("Alert !"));
335 }
336
337 UpdateStatusBar();
338 }
339
340 void MyFrame::OnTest1(wxCommandEvent& WXUNUSED(event))
341 {
342 const wxChar *buf1;
343 wxChar *buf2;
344 unsigned char len;
345
346 // Disable socket menu entries (exception: Close Session)
347 m_busy = true;
348 UpdateStatusBar();
349
350 m_text->AppendText(_("\n=== Test 1 begins ===\n"));
351
352 // Tell the server which test we are running
353 unsigned char c = 0xBE;
354 m_sock->Write(&c, 1);
355
356 // Send some data and read it back. We know the size of the
357 // buffer, so we can specify the exact number of bytes to be
358 // sent or received and use the wxSOCKET_WAITALL flag. Also,
359 // we have disabled menu entries which could interfere with
360 // the test, so we can safely avoid the wxSOCKET_BLOCK flag.
361 //
362 // First we send a byte with the length of the string, then
363 // we send the string itself (do NOT try to send any integral
364 // value larger than a byte "as is" across the network, or
365 // you might be in trouble! Ever heard about big and little
366 // endian computers?)
367
368 m_sock->SetFlags(wxSOCKET_WAITALL);
369
370 buf1 = _("Test string (less than 256 chars!)");
371 len = (unsigned char)((wxStrlen(buf1) + 1) * sizeof(wxChar));
372 buf2 = new wxChar[wxStrlen(buf1) + 1];
373
374 m_text->AppendText(_("Sending a test buffer to the server ..."));
375 m_sock->Write(&len, 1);
376 m_sock->Write(buf1, len);
377 m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
378
379 m_text->AppendText(_("Receiving the buffer back from server ..."));
380 m_sock->Read(buf2, len);
381 m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
382
383 m_text->AppendText(_("Comparing the two buffers ..."));
384 if (memcmp(buf1, buf2, len) != 0)
385 {
386 m_text->AppendText(_("failed!\n"));
387 m_text->AppendText(_("Test 1 failed !\n"));
388 }
389 else
390 {
391 m_text->AppendText(_("done\n"));
392 m_text->AppendText(_("Test 1 passed !\n"));
393 }
394 m_text->AppendText(_("=== Test 1 ends ===\n"));
395
396 delete[] buf2;
397 m_busy = false;
398 UpdateStatusBar();
399 }
400
401 void MyFrame::OnTest2(wxCommandEvent& WXUNUSED(event))
402 {
403 const wxChar *msg1;
404 wxChar *msg2;
405 size_t len;
406
407 // Disable socket menu entries (exception: Close Session)
408 m_busy = true;
409 UpdateStatusBar();
410
411 m_text->AppendText(_("\n=== Test 2 begins ===\n"));
412
413 // Tell the server which test we are running
414 unsigned char c = 0xCE;
415 m_sock->Write(&c, 1);
416
417 // Here we use ReadMsg and WriteMsg to send messages with
418 // a header with size information. Also, the reception is
419 // event triggered, so we test input events as well.
420 //
421 // We need to set no flags here (ReadMsg and WriteMsg are
422 // not affected by flags)
423
424 m_sock->SetFlags(wxSOCKET_WAITALL);
425
426 wxString s = wxGetTextFromUser(
427 _("Enter an arbitrary string to send to the server:"),
428 _("Test 2 ..."),
429 _("Yes I like wxWidgets!"));
430
431 msg1 = s.c_str();
432 len = (wxStrlen(msg1) + 1) * sizeof(wxChar);
433 msg2 = new wxChar[wxStrlen(msg1) + 1];
434
435 m_text->AppendText(_("Sending the string with WriteMsg ..."));
436 m_sock->WriteMsg(msg1, len);
437 m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
438 m_text->AppendText(_("Waiting for an event (timeout = 2 sec)\n"));
439
440 // Wait until data available (will also return if the connection is lost)
441 m_sock->WaitForRead(2);
442
443 if (m_sock->IsData())
444 {
445 m_text->AppendText(_("Reading the string back with ReadMsg ..."));
446 m_sock->ReadMsg(msg2, len);
447 m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
448 m_text->AppendText(_("Comparing the two buffers ..."));
449 if (memcmp(msg1, msg2, len) != 0)
450 {
451 m_text->AppendText(_("failed!\n"));
452 m_text->AppendText(_("Test 2 failed !\n"));
453 }
454 else
455 {
456 m_text->AppendText(_("done\n"));
457 m_text->AppendText(_("Test 2 passed !\n"));
458 }
459 }
460 else
461 m_text->AppendText(_("Timeout ! Test 2 failed.\n"));
462
463 m_text->AppendText(_("=== Test 2 ends ===\n"));
464
465 delete[] msg2;
466 m_busy = false;
467 UpdateStatusBar();
468 }
469
470 void MyFrame::OnTest3(wxCommandEvent& WXUNUSED(event))
471 {
472 char *buf1;
473 char *buf2;
474 unsigned char len;
475
476 // Disable socket menu entries (exception: Close Session)
477 m_busy = true;
478 UpdateStatusBar();
479
480 m_text->AppendText(_("\n=== Test 3 begins ===\n"));
481
482 // Tell the server which test we are running
483 unsigned char c = 0xDE;
484 m_sock->Write(&c, 1);
485
486 // This test also is similar to the first one but it sends a
487 // large buffer so that wxSocket is actually forced to split
488 // it into pieces and take care of sending everything before
489 // returning.
490
491 m_sock->SetFlags(wxSOCKET_WAITALL);
492
493 // Note that len is in kbytes here!
494 len = 32;
495 buf1 = new char[len * 1024];
496 buf2 = new char[len * 1024];
497
498 for (int i = 0; i < len * 1024; i ++)
499 buf1[i] = (char)(i % 256);
500
501 m_text->AppendText(_("Sending a large buffer (32K) to the server ..."));
502 m_sock->Write(&len, 1);
503 m_sock->Write(buf1, len * 1024);
504 m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
505
506 m_text->AppendText(_("Receiving the buffer back from server ..."));
507 m_sock->Read(buf2, len * 1024);
508 m_text->AppendText(m_sock->Error() ? _("failed !\n") : _("done\n"));
509
510 m_text->AppendText(_("Comparing the two buffers ..."));
511 if (memcmp(buf1, buf2, len) != 0)
512 {
513 m_text->AppendText(_("failed!\n"));
514 m_text->AppendText(_("Test 3 failed !\n"));
515 }
516 else
517 {
518 m_text->AppendText(_("done\n"));
519 m_text->AppendText(_("Test 3 passed !\n"));
520 }
521 m_text->AppendText(_("=== Test 3 ends ===\n"));
522
523 delete[] buf2;
524 m_busy = false;
525 UpdateStatusBar();
526 }
527
528 void MyFrame::OnCloseConnection(wxCommandEvent& WXUNUSED(event))
529 {
530 m_sock->Close();
531 UpdateStatusBar();
532 }
533
534 void MyFrame::OnDatagram(wxCommandEvent& WXUNUSED(event))
535 {
536 m_text->AppendText(_("\n=== Datagram test begins ===\n"));
537 m_text->AppendText(_("Sorry, not implemented\n"));
538 m_text->AppendText(_("=== Datagram test ends ===\n"));
539 }
540
541 #if wxUSE_URL
542
543 void MyFrame::OnTestURL(wxCommandEvent& WXUNUSED(event))
544 {
545 // Note that we are creating a new socket here, so this
546 // won't mess with the client/server demo.
547
548 // Ask for the URL
549 m_text->AppendText(_("\n=== URL test begins ===\n"));
550 wxString urlname = wxGetTextFromUser(_("Enter an URL to get"),
551 _("URL:"),
552 _T("http://localhost"));
553
554 // Parse the URL
555 wxURL url(urlname);
556 if (url.GetError() != wxURL_NOERR)
557 {
558 m_text->AppendText(_("Error: couldn't parse URL\n"));
559 m_text->AppendText(_("=== URL test ends ===\n"));
560 return;
561 }
562
563 // Try to get the input stream (connects to the given URL)
564 m_text->AppendText(_("Trying to establish connection...\n"));
565 wxYield();
566 wxInputStream *data = url.GetInputStream();
567 if (!data)
568 {
569 m_text->AppendText(_("Error: couldn't read from URL\n"));
570 m_text->AppendText(_("=== URL test ends ===\n"));
571 return;
572 }
573
574 // Print the contents type and file size
575 wxString s;
576 s.Printf(_("Contents type: %s\nFile size: %i\nStarting to download...\n"),
577 url.GetProtocol().GetContentType().c_str(),
578 data->GetSize());
579 m_text->AppendText(s);
580 wxYield();
581
582 // Get the data
583 wxFile fileTest(wxT("test.url"), wxFile::write);
584 wxFileOutputStream sout(fileTest);
585 if (!sout.Ok())
586 {
587 m_text->AppendText(_("Error: couldn't open file for output\n"));
588 m_text->AppendText(_("=== URL test ends ===\n"));
589 return;
590 }
591
592 data->Read(sout);
593 m_text->AppendText(_("Results written to file: test.url\n"));
594 m_text->AppendText(_("Done.\n"));
595 m_text->AppendText(_("=== URL test ends ===\n"));
596
597 delete data;
598 }
599
600 #endif
601
602 void MyFrame::OnSocketEvent(wxSocketEvent& event)
603 {
604 wxString s = _("OnSocketEvent: ");
605
606 switch(event.GetSocketEvent())
607 {
608 case wxSOCKET_INPUT : s.Append(_("wxSOCKET_INPUT\n")); break;
609 case wxSOCKET_LOST : s.Append(_("wxSOCKET_LOST\n")); break;
610 case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
611 default : s.Append(_("Unexpected event !\n")); break;
612 }
613
614 m_text->AppendText(s);
615 UpdateStatusBar();
616 }
617
618 // convenience functions
619
620 void MyFrame::UpdateStatusBar()
621 {
622 wxString s;
623
624 if (!m_sock->IsConnected())
625 {
626 s.Printf(_("Not connected"));
627 }
628 else
629 {
630 wxIPV4address addr;
631
632 m_sock->GetPeer(addr);
633 s.Printf(_("%s : %d"), (addr.Hostname()).c_str(), addr.Service());
634 }
635
636 #if wxUSE_STATUSBAR
637 SetStatusText(s, 1);
638 #endif // wxUSE_STATUSBAR
639
640 m_menuSocket->Enable(CLIENT_OPEN, !m_sock->IsConnected() && !m_busy);
641 m_menuSocket->Enable(CLIENT_TEST1, m_sock->IsConnected() && !m_busy);
642 m_menuSocket->Enable(CLIENT_TEST2, m_sock->IsConnected() && !m_busy);
643 m_menuSocket->Enable(CLIENT_TEST3, m_sock->IsConnected() && !m_busy);
644 m_menuSocket->Enable(CLIENT_CLOSE, m_sock->IsConnected());
645 }