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