]> git.saurik.com Git - wxWidgets.git/blob - src/unix/dialup.cpp
changed version number
[wxWidgets.git] / src / unix / dialup.cpp
1 // -*- c++ -*- ////////////////////////////////////////////////////////////////
2 // Name: unix/dialup.cpp
3 // Purpose: Network related wxWindows classes and functions
4 // Author: Karsten Ballüder
5 // Modified by:
6 // Created: 03.10.99
7 // RCS-ID: $Id$
8 // Copyright: (c) Karsten Ballüder
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/setup.h"
13
14 #ifdef __GNUG__
15 # pragma implementation "dialup.h"
16 #endif
17
18 #if wxUSE_DIALUP_MANAGER
19
20 #ifndef WX_PRECOMP
21 # include "wx/defs.h"
22 #endif // !PCH
23
24 #include "wx/string.h"
25 #include "wx/event.h"
26 #include "wx/dialup.h"
27 #include "wx/timer.h"
28 #include "wx/filefn.h"
29 #include "wx/utils.h"
30 #include "wx/log.h"
31 #include "wx/ffile.h"
32 #include "wx/process.h"
33 #include "wx/intl.h"
34 #include "wx/app.h"
35 #include "wx/wxchar.h"
36
37 #include <stdlib.h>
38
39 #include <signal.h>
40 #include <fcntl.h>
41 #include <unistd.h>
42 #define __STRICT_ANSI__
43 #include <sys/socket.h>
44 #include <netdb.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
47 #include <errno.h>
48
49 DEFINE_EVENT_TYPE(wxEVT_DIALUP_CONNECTED)
50 DEFINE_EVENT_TYPE(wxEVT_DIALUP_DISCONNECTED)
51
52 // ----------------------------------------------------------------------------
53 // A class which groups functions dealing with connecting to the network from a
54 // workstation using dial-up access to the net. There is at most one instance
55 // of this class in the program accessed via GetDialUpManager().
56 // ----------------------------------------------------------------------------
57
58 /* TODO
59 *
60 * 1. more configurability for Unix: i.e. how to initiate the connection, how
61 * to check for online status, &c.
62 * 2. add a "long Dial(long connectionId = -1)" function which asks the user
63 * about which connection to dial (this may be done using native dialogs
64 * under NT, need generic dialogs for all others) and returns the identifier
65 * of the selected connection (it's opaque to the application) - it may be
66 * reused later to dial the same connection later (or use strings instead of
67 * longs may be?)
68 * 3. add an async version of dialing functions which notify the caller about
69 * the progress (or may be even start another thread to monitor it)
70 * 4. the static creation/accessor functions are not MT-safe - but is this
71 * really crucial? I think we may suppose they're always called from the
72 * main thread?
73 */
74
75 class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
76 {
77 public:
78 wxDialUpManagerImpl();
79 ~wxDialUpManagerImpl();
80
81 /** Could the dialup manager be initialized correctly? If this function
82 returns FALSE, no other functions will work neither, so it's a good idea
83 to call this function and check its result before calling any other
84 wxDialUpManager methods.
85 */
86 virtual bool IsOk() const
87 { return TRUE; }
88
89 /** The simplest way to initiate a dial up: this function dials the given
90 ISP (exact meaning of the parameter depends on the platform), returns
91 TRUE on success or FALSE on failure and logs the appropriate error
92 message in the latter case.
93 @param nameOfISP optional paramater for dial program
94 @param username unused
95 @param password unused
96 */
97 virtual bool Dial(const wxString& nameOfISP,
98 const wxString& WXUNUSED(username),
99 const wxString& WXUNUSED(password),
100 bool async);
101
102 // Hang up the currently active dial up connection.
103 virtual bool HangUp();
104
105 // returns TRUE if the computer is connected to the network: under Windows,
106 // this just means that a RAS connection exists, under Unix we check that
107 // the "well-known host" (as specified by SetWellKnownHost) is reachable
108 virtual bool IsOnline() const
109 {
110 CheckStatus();
111 return m_IsOnline == Net_Connected;
112 }
113
114 // do we have a constant net connection?
115 virtual bool IsAlwaysOnline() const;
116
117 // returns TRUE if (async) dialing is in progress
118 virtual bool IsDialing() const
119 { return m_DialProcess != NULL; }
120
121 // cancel dialing the number initiated with Dial(async = TRUE)
122 // NB: this won't result in DISCONNECTED event being sent
123 virtual bool CancelDialing();
124
125 size_t GetISPNames(class wxArrayString &) const
126 { return 0; }
127
128 // sometimes the built-in logic for determining the online status may fail,
129 // so, in general, the user should be allowed to override it. This function
130 // allows to forcefully set the online status - whatever our internal
131 // algorithm may think about it.
132 virtual void SetOnlineStatus(bool isOnline = TRUE)
133 { m_IsOnline = isOnline ? Net_Connected : Net_No; }
134
135 // set misc wxDialUpManager options
136 // --------------------------------
137
138 // enable automatical checks for the connection status and sending of
139 // wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
140 // parameter is only for Unix where we do the check manually: under
141 // Windows, the notification about the change of connection status is
142 // instantenous.
143 //
144 // Returns FALSE if couldn't set up automatic check for online status.
145 virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
146
147 // disable automatic check for connection status change - notice that the
148 // wxEVT_DIALUP_XXX events won't be sent any more neither.
149 virtual void DisableAutoCheckOnlineStatus();
150
151 // under Unix, the value of well-known host is used to check whether we're
152 // connected to the internet. It's unused under Windows, but this function
153 // is always safe to call. The default value is www.yahoo.com.
154 virtual void SetWellKnownHost(const wxString& hostname,
155 int portno = 80);
156 /** Sets the commands to start up the network and to hang up
157 again. Used by the Unix implementations only.
158 */
159 virtual void SetConnectCommand(const wxString &command, const wxString &hupcmd)
160 { m_ConnectCommand = command; m_HangUpCommand = hupcmd; }
161
162 //private: -- Sun CC 4.2 objects to using NetConnection enum as the return
163 // type if it is declared private
164
165 // the possible results of testing for Online() status
166 enum NetConnection
167 {
168 Net_Unknown = -1, // we couldn't learn anything
169 Net_No, // no network connection [currently]
170 Net_Connected // currently connected
171 };
172
173 // the possible net connection types
174 enum NetDeviceType
175 {
176 NetDevice_None = 0x0000, // no network devices (authoritative)
177 NetDevice_Unknown = 0x0001, // test doesn't work on this OS
178 NetDevice_Modem = 0x0002, // we have a modem
179 NetDevice_LAN = 0x0004 // a network card
180 };
181
182 private:
183 // the current status
184 NetConnection m_IsOnline;
185
186 // the connection we have with the network card
187 NetConnection m_connCard;
188
189 // Can we use ifconfig to list active devices?
190 int m_CanUseIfconfig;
191
192 // The path to ifconfig
193 wxString m_IfconfigPath;
194
195 // Can we use ping to find hosts?
196 int m_CanUsePing;
197 // The path to ping program
198 wxString m_PingPath;
199
200 // beacon host:
201 wxString m_BeaconHost;
202 // beacon host portnumber for connect:
203 int m_BeaconPort;
204
205 // command to connect to network
206 wxString m_ConnectCommand;
207 // command to hang up
208 wxString m_HangUpCommand;
209 // name of ISP
210 wxString m_ISPname;
211 // a timer for regular testing
212 class AutoCheckTimer *m_timer;
213 friend class AutoCheckTimer;
214
215 // a wxProcess for dialling in background
216 class wxDialProcess *m_DialProcess;
217 // pid of dial process
218 int m_DialPId;
219 friend class wxDialProcess;
220
221 // determine status
222 void CheckStatus(bool fromAsync = FALSE) const;
223
224 // real status check
225 void CheckStatusInternal();
226
227 // check /proc/net (Linux only) for ppp/eth interfaces, returns the bit
228 // mask of NetDeviceType constants
229 int CheckProcNet();
230
231 // check output of ifconfig command for PPP/SLIP/PLIP devices, returns the
232 // bit mask of NetDeviceType constants
233 int CheckIfconfig();
234
235 // combines the 2 possible checks for determining the connection status
236 NetConnection CheckConnectAndPing();
237
238 // pings a host
239 NetConnection CheckPing();
240
241 // check by connecting to host on given port.
242 NetConnection CheckConnect();
243 };
244
245
246 class AutoCheckTimer : public wxTimer
247 {
248 public:
249 AutoCheckTimer(wxDialUpManagerImpl *dupman)
250 {
251 m_dupman = dupman;
252 m_started = FALSE;
253 }
254
255 virtual bool Start( int millisecs = -1, bool WXUNUSED(one_shot) = FALSE )
256 { m_started = TRUE; return wxTimer::Start(millisecs, FALSE); }
257
258 virtual void Notify()
259 { wxLogTrace(wxT("Checking dial up network status.")); m_dupman->CheckStatus(); }
260
261 virtual void Stop()
262 { if ( m_started ) wxTimer::Stop(); }
263 public:
264 bool m_started;
265 wxDialUpManagerImpl *m_dupman;
266 };
267
268 class wxDialProcess : public wxProcess
269 {
270 public:
271 wxDialProcess(wxDialUpManagerImpl *dupman)
272 {
273 m_DupMan = dupman;
274 }
275 void Disconnect() { m_DupMan = NULL; }
276 virtual void OnTerminate(int WXUNUSED(pid), int WXUNUSED(status))
277 {
278 if(m_DupMan)
279 {
280 m_DupMan->m_DialProcess = NULL;
281 m_DupMan->CheckStatus(TRUE);
282 }
283 }
284 private:
285 wxDialUpManagerImpl *m_DupMan;
286 };
287
288
289 wxDialUpManagerImpl::wxDialUpManagerImpl()
290 {
291 m_IsOnline =
292 m_connCard = Net_Unknown;
293 m_DialProcess = NULL;
294 m_timer = NULL;
295 m_CanUseIfconfig = -1; // unknown
296 m_CanUsePing = -1; // unknown
297 m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
298 m_BeaconPort = 80;
299
300 #ifdef __SGI__
301 m_ConnectCommand = _T("/usr/etc/ppp");
302 #elif defined(__LINUX__)
303 // default values for Debian/GNU linux
304 m_ConnectCommand = _T("pon");
305 m_HangUpCommand = _T("poff");
306 #endif
307
308 wxChar * dial = wxGetenv(_T("WXDIALUP_DIALCMD"));
309 wxChar * hup = wxGetenv(_T("WXDIALUP_HUPCMD"));
310 SetConnectCommand(dial ? wxString(dial) : m_ConnectCommand,
311 hup ? wxString(hup) : m_HangUpCommand);
312 }
313
314 wxDialUpManagerImpl::~wxDialUpManagerImpl()
315 {
316 if(m_timer) delete m_timer;
317 if(m_DialProcess)
318 {
319 m_DialProcess->Disconnect();
320 m_DialProcess->Detach();
321 }
322 }
323
324 bool
325 wxDialUpManagerImpl::Dial(const wxString &isp,
326 const wxString & WXUNUSED(username),
327 const wxString & WXUNUSED(password),
328 bool async)
329 {
330 if(m_IsOnline == Net_Connected)
331 return FALSE;
332 m_ISPname = isp;
333 wxString cmd;
334 if(m_ConnectCommand.Find(wxT("%s")))
335 cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
336 else
337 cmd = m_ConnectCommand;
338
339 if ( async )
340 {
341 m_DialProcess = new wxDialProcess(this);
342 m_DialPId = (int)wxExecute(cmd, FALSE, m_DialProcess);
343 if(m_DialPId == 0)
344 {
345 delete m_DialProcess;
346 m_DialProcess = NULL;
347 return FALSE;
348 }
349 else
350 return TRUE;
351 }
352 else
353 return wxExecute(cmd, /* sync */ TRUE) == 0;
354 }
355
356 bool wxDialUpManagerImpl::HangUp()
357 {
358 if(m_IsOnline == Net_No)
359 return FALSE;
360 if(IsDialing())
361 {
362 wxLogError(_("Already dialling ISP."));
363 return FALSE;
364 }
365 wxString cmd;
366 if(m_HangUpCommand.Find(wxT("%s")))
367 cmd.Printf(m_HangUpCommand,m_ISPname.c_str(), m_DialProcess);
368 else
369 cmd = m_HangUpCommand;
370 return wxExecute(cmd, /* sync */ TRUE) == 0;
371 }
372
373
374 bool wxDialUpManagerImpl::CancelDialing()
375 {
376 if(! IsDialing())
377 return FALSE;
378 return kill(m_DialPId, SIGTERM) > 0;
379 }
380
381 bool wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
382 {
383 DisableAutoCheckOnlineStatus();
384 m_timer = new AutoCheckTimer(this);
385 bool rc = m_timer->Start(nSeconds*1000);
386 if(! rc)
387 {
388 delete m_timer;
389 m_timer = NULL;
390 }
391 return rc;
392 }
393
394 void wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
395 {
396 if(m_timer != NULL)
397 {
398 m_timer->Stop();
399 delete m_timer;
400 m_timer = NULL;
401 }
402 }
403
404
405 void wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
406 {
407 if(hostname.Length() == 0)
408 {
409 m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
410 m_BeaconPort = 80;
411 return;
412 }
413
414 // does hostname contain a port number?
415 wxString port = hostname.After(wxT(':'));
416 if(port.Length())
417 {
418 m_BeaconHost = hostname.Before(wxT(':'));
419 m_BeaconPort = wxAtoi(port);
420 }
421 else
422 {
423 m_BeaconHost = hostname;
424 m_BeaconPort = portno;
425 }
426 }
427
428
429 void wxDialUpManagerImpl::CheckStatus(bool fromAsync) const
430 {
431 // This function calls the CheckStatusInternal() helper function
432 // which is OS - specific and then sends the events.
433
434 NetConnection oldIsOnline = m_IsOnline;
435 ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
436
437 // now send the events as appropriate: i.e. if the status changed and
438 // if we're in defined state
439 if(m_IsOnline != oldIsOnline
440 && m_IsOnline != Net_Unknown
441 && oldIsOnline != Net_Unknown )
442 {
443 wxDialUpEvent event(m_IsOnline == Net_Connected, ! fromAsync);
444 (void)wxTheApp->ProcessEvent(event);
445 }
446 }
447
448 /*
449 We first try to find out if ppp interface is active. If it is, we assume
450 that we're online but don't have a permanent connection (this is false if a
451 networked machine uses modem to connect to somewhere else, but we can't do
452 anything in this case anyhow).
453
454 If no ppp interface is detected, we check for eth interface. If it is
455 found, we check that we can, indeed, connect to an Internet host. The logic
456 here is that connection check should be fast enough in this case and we
457 don't want to give false positives in a (common) case of a machine on a LAN
458 which is not connected to the outside.
459
460 If we didn't find either ppp or eth interfaces, we stop here and decide
461 that we're connected. However, if couldn't check for this, we try to ping a
462 remote host just in case.
463
464 NB1: Checking for the interface presence can be done in 2 ways
465 a) reading /proc/net/dev under Linux
466 b) spawning ifconfig under any OS
467
468 The first method is faster but only works under Linux.
469
470 NB2: pinging, actually, means that we first try to connect "manually" to
471 a port on remove machine and if it fails, we run ping.
472 */
473
474 void wxDialUpManagerImpl::CheckStatusInternal()
475 {
476 m_IsOnline = Net_Unknown;
477
478 // first do quick checks to determine what kind of network devices do we
479 // have
480 int netDeviceType = CheckProcNet();
481 if ( netDeviceType == NetDevice_Unknown )
482 {
483 // nothing found, try ifconfig too
484 netDeviceType = CheckIfconfig();
485 }
486
487 switch ( netDeviceType )
488 {
489 case NetDevice_None:
490 // no network devices, no connection
491 m_IsOnline = Net_No;
492 break;
493
494 case NetDevice_LAN:
495 // we still do ping to confirm that we're connected but we only do
496 // it once and hope that the purpose of the network card (i.e.
497 // whether it used for connecting to the Internet or just to a
498 // LAN) won't change during the program lifetime
499 if ( m_connCard == Net_Unknown )
500 {
501 m_connCard = CheckConnectAndPing();
502 }
503 m_IsOnline = m_connCard;
504 break;
505
506 case NetDevice_Unknown:
507 // try to ping just in case
508 m_IsOnline = CheckConnectAndPing();
509 break;
510
511 case NetDevice_LAN + NetDevice_Modem:
512 case NetDevice_Modem:
513 // assume we're connected
514 m_IsOnline = Net_Connected;
515 break;
516
517 default:
518 wxFAIL_MSG(_T("Unexpected netDeviceType"));
519 }
520 }
521
522 bool wxDialUpManagerImpl::IsAlwaysOnline() const
523 {
524 wxDialUpManagerImpl *self = wxConstCast(this, wxDialUpManagerImpl);
525
526 int netDeviceType = self->CheckProcNet();
527 if ( netDeviceType == NetDevice_Unknown )
528 {
529 // nothing found, try ifconfig too
530 netDeviceType = self->CheckIfconfig();
531 }
532
533 if ( netDeviceType == NetDevice_Unknown )
534 {
535 // this is the only thing we can do unfortunately...
536 self->HangUp();
537 return IsOnline();
538 }
539 else
540 {
541 // we are only permanently online if we have a network card
542 return (netDeviceType & NetDevice_LAN) != 0;
543 }
544 }
545
546 wxDialUpManagerImpl::NetConnection wxDialUpManagerImpl::CheckConnectAndPing()
547 {
548 NetConnection conn;
549
550 // first try connecting - faster
551 conn = CheckConnect();
552 if ( conn == Net_Unknown )
553 {
554 // try pinging too
555 conn = CheckPing();
556 }
557
558 return conn;
559 }
560
561 wxDialUpManagerImpl::NetConnection wxDialUpManagerImpl::CheckConnect()
562 {
563 // second method: try to connect to a well known host:
564 // This can be used under Win 9x, too!
565 struct hostent *hp;
566 struct sockaddr_in serv_addr;
567
568 if((hp = gethostbyname(m_BeaconHost.mb_str())) == NULL)
569 return Net_No; // no DNS no net
570
571 serv_addr.sin_family = hp->h_addrtype;
572 memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
573 serv_addr.sin_port = htons(m_BeaconPort);
574
575 int sockfd;
576 if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
577 {
578 return Net_Unknown; // no info
579 }
580
581 if( connect(sockfd, (struct sockaddr *) &serv_addr,
582 sizeof(serv_addr)) >= 0)
583 {
584 close(sockfd);
585 return Net_Connected; // we can connect, so we have a network!
586 }
587 else // failed to connect
588 {
589 if(errno == ENETUNREACH)
590 return Net_No; // network is unreachable
591 else
592 return Net_Unknown; // connect failed, but don't know why
593 }
594 }
595
596
597 int
598 wxDialUpManagerImpl::CheckProcNet()
599 {
600 // assume that the test doesn't work
601 int netDevice = NetDevice_Unknown;
602
603 #ifdef __LINUX__
604 if (wxFileExists(_T("/proc/net/route")))
605 {
606 // cannot use wxFile::Length because file doesn't support seeking, so
607 // use stdio directly
608 FILE *f = fopen("/proc/net/route", "rt");
609 if (f != NULL)
610 {
611 // now we know that we will find all devices we may have
612 netDevice = NetDevice_None;
613
614 char output[256];
615
616 while (fgets(output, 256, f) != NULL)
617 {
618 if ( strstr(output, "eth") ) // network card
619 {
620 netDevice |= NetDevice_LAN;
621 }
622 else if (strstr(output,"ppp") // ppp
623 || strstr(output,"sl") // slip
624 || strstr(output,"pl")) // plip
625 {
626 netDevice |= NetDevice_Modem;
627 }
628 }
629
630 fclose(f);
631 }
632 }
633 #endif // __LINUX__
634
635 return netDevice;
636 }
637
638
639 int
640 wxDialUpManagerImpl::CheckIfconfig()
641 {
642 // assume that the test doesn't work
643 int netDevice = NetDevice_Unknown;
644
645 // first time check for ifconfig location
646 if ( m_CanUseIfconfig == -1 ) // unknown
647 {
648 static const wxChar *ifconfigLocations[] =
649 {
650 _T("/sbin"), // Linux, FreeBSD
651 _T("/usr/sbin"), // SunOS, Solaris, AIX, HP-UX
652 _T("/usr/etc"), // IRIX
653 };
654
655 for ( size_t n = 0; n < WXSIZEOF(ifconfigLocations); n++ )
656 {
657 wxString path(ifconfigLocations[n]);
658 path << _T("/ifconfig");
659
660 if ( wxFileExists(path) )
661 {
662 m_IfconfigPath = path;
663 break;
664 }
665 }
666 }
667
668 if ( m_CanUseIfconfig != 0 ) // unknown or yes
669 {
670 wxLogNull ln; // suppress all error messages
671
672 wxASSERT_MSG( m_IfconfigPath.length(),
673 _T("can't use ifconfig if it wasn't found") );
674
675 wxString tmpfile = wxGetTempFileName("_wxdialuptest");
676 wxString cmd = "/bin/sh -c \'";
677 cmd << m_IfconfigPath;
678 #if defined(__SOLARIS__) || defined (__SUNOS__)
679 // need to add -a flag
680 cmd << " -a";
681 #elif defined(__LINUX__) || defined(__SGI__)
682 // nothing to be added to ifconfig
683 #elif defined(__FREEBSD__) || defined(__WXMAC__)
684 // add -l flag
685 cmd << " -l";
686 #elif defined(__HPUX__)
687 // VZ: a wild guess (but without it, ifconfig fails completely)
688 cmd << _T(" ppp0");
689 #else
690 # pragma warning "No ifconfig information for this OS."
691 m_CanUseIfconfig = 0;
692 return -1;
693 #endif
694 cmd << " >" << tmpfile << '\'';
695 /* I tried to add an option to wxExecute() to not close stdout,
696 so we could let ifconfig write directly to the tmpfile, but
697 this does not work. That should be faster, as it doesn´t call
698 the shell first. I have no idea why. :-( (KB) */
699 if ( wxExecute(cmd,TRUE /* sync */) == 0 )
700 {
701 m_CanUseIfconfig = 1;
702 wxFFile file;
703 if( file.Open(tmpfile) )
704 {
705 wxString output;
706 if ( file.ReadAll(&output) )
707 {
708 // FIXME shouldn't we grep for "^ppp"? (VZ)
709
710 bool hasModem = FALSE,
711 hasLAN = FALSE;
712
713 #if defined(__SOLARIS__) || defined (__SUNOS__)
714 // dialup device under SunOS/Solaris
715 hasModem = strstr(output,"ipdptp") != (char *)NULL;
716 hasLAN = strstr(output, "hme") != (char *)NULL;
717 #elif defined(__LINUX__) || defined (__FREEBSD__)
718 hasModem = strstr(output,"ppp") // ppp
719 || strstr(output,"sl") // slip
720 || strstr(output,"pl"); // plip
721 hasLAN = strstr(output, "eth") != NULL;
722 #elif defined(__SGI__) // IRIX
723 hasModem = strstr(output, "ppp") != NULL; // PPP
724 #elif defined(__HPUX__)
725 // if could run ifconfig on interface, then it exists
726 hasModem = TRUE;
727 #endif
728
729 netDevice = NetDevice_None;
730 if ( hasModem )
731 netDevice |= NetDevice_Modem;
732 if ( hasLAN )
733 netDevice |= NetDevice_LAN;
734 }
735 //else: error reading the file
736 }
737 //else: error opening the file
738 }
739 else // could not run ifconfig correctly
740 {
741 m_CanUseIfconfig = 0; // don´t try again
742 }
743
744 (void) wxRemoveFile(tmpfile);
745 }
746
747 return netDevice;
748 }
749
750 wxDialUpManagerImpl::NetConnection wxDialUpManagerImpl::CheckPing()
751 {
752 // First time check for ping location. We only use the variant
753 // which does not take arguments, a la GNU.
754 if(m_CanUsePing == -1) // unknown
755 {
756 if(wxFileExists("/bin/ping"))
757 m_PingPath = "/bin/ping";
758 else if(wxFileExists("/usr/sbin/ping"))
759 m_PingPath = "/usr/sbin/ping";
760 if(! m_PingPath)
761 {
762 m_CanUsePing = 0;
763 }
764 }
765
766 if(! m_CanUsePing)
767 {
768 // we didn't find ping
769 return Net_Unknown;
770 }
771
772 wxLogNull ln; // suppress all error messages
773 wxASSERT(m_PingPath.length());
774 wxString cmd;
775 cmd << m_PingPath << ' ';
776 #if defined(__SOLARIS__) || defined (__SUNOS__)
777 // nothing to add to ping command
778 #elif defined(__LINUX__) || defined ( __FREEBSD__) || defined(__WXMAC__)
779 cmd << "-c 1 "; // only ping once
780 #elif defined(__HPUX__)
781 cmd << "64 1 "; // only ping once (need also specify the packet size)
782 #else
783 # pragma warning "No Ping information for this OS."
784 m_CanUsePing = 0;
785 return Net_Unknown;
786 #endif
787 cmd << m_BeaconHost;
788 if(wxExecute(cmd, TRUE /* sync */) == 0)
789 return Net_Connected;
790 else
791 return Net_No;
792 }
793
794 /* static */
795 wxDialUpManager *wxDialUpManager::Create()
796 {
797 return new wxDialUpManagerImpl;
798 }
799
800 #endif // wxUSE_DIALUP_MANAGER