src/unix/dialup.cpp

   1 // -*- c++ -*- ////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #   pragma implementation "dialup.h"
  14 #endif
  15
  16 // for compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #include "wx/setup.h"
  20
  21 #if wxUSE_DIALUP_MANAGER
  22
  23 #ifndef  WX_PRECOMP
  24 #   include "wx/defs.h"
  25 #endif // !PCH
  26
  27 #include "wx/string.h"
  28 #include "wx/event.h"
  29 #include "wx/dialup.h"
  30 #include "wx/timer.h"
  31 #include "wx/filefn.h"
  32 #include "wx/utils.h"
  33 #include "wx/log.h"
  34 #include "wx/ffile.h"
  35 #include "wx/process.h"
  36 #include "wx/intl.h"
  37 #include "wx/app.h"
  38 #include "wx/wxchar.h"
  39
  40 #include <stdlib.h>
  41
  42 #include <signal.h>
  43 #include <fcntl.h>
  44 #include <unistd.h>
  45 #define __STRICT_ANSI__
  46 #include <sys/socket.h>
  47 #include <netdb.h>
  48 #include <netinet/in.h>
  49 #include <arpa/inet.h>
  50 #include <errno.h>
  51
  52 DEFINE_EVENT_TYPE(wxEVT_DIALUP_CONNECTED)
  53 DEFINE_EVENT_TYPE(wxEVT_DIALUP_DISCONNECTED)
  54
  55 // ----------------------------------------------------------------------------
  56 // A class which groups functions dealing with connecting to the network from a
  57 // workstation using dial-up access to the net. There is at most one instance
  58 // of this class in the program accessed via GetDialUpManager().
  59 // ----------------------------------------------------------------------------
  60
  61 /* TODO
  62  *
  63  * 1. more configurability for Unix: i.e. how to initiate the connection, how
  64  *    to check for online status, &c.
  65  * 2. add a "long Dial(long connectionId = -1)" function which asks the user
  66  *    about which connection to dial (this may be done using native dialogs
  67  *    under NT, need generic dialogs for all others) and returns the identifier
  68  *    of the selected connection (it's opaque to the application) - it may be
  69  *    reused later to dial the same connection later (or use strings instead of
  70  *    longs may be?)
  71  * 3. add an async version of dialing functions which notify the caller about
  72  *    the progress (or may be even start another thread to monitor it)
  73  * 4. the static creation/accessor functions are not MT-safe - but is this
  74  *    really crucial? I think we may suppose they're always called from the
  75  *    main thread?
  76  */
  77
  78 class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
  79 {
  80 public:
  81    wxDialUpManagerImpl();
  82    ~wxDialUpManagerImpl();
  83
  84    /** Could the dialup manager be initialized correctly? If this function
  85        returns FALSE, no other functions will work neither, so it's a good idea
  86        to call this function and check its result before calling any other
  87        wxDialUpManager methods.
  88    */
  89    virtual bool IsOk() const
  90       { return TRUE; }
  91
  92    /** The simplest way to initiate a dial up: this function dials the given
  93        ISP (exact meaning of the parameter depends on the platform), returns
  94        TRUE on success or FALSE on failure and logs the appropriate error
  95        message in the latter case.
  96        @param nameOfISP optional paramater for dial program
  97        @param username unused
  98        @param password unused
  99    */
 100    virtual bool Dial(const wxString& nameOfISP,
 101                      const wxString& WXUNUSED(username),
 102                      const wxString& WXUNUSED(password),
 103                      bool async);
 104
 105    // Hang up the currently active dial up connection.
 106    virtual bool HangUp();
 107
 108    // returns TRUE if the computer is connected to the network: under Windows,
 109    // this just means that a RAS connection exists, under Unix we check that
 110    // the "well-known host" (as specified by SetWellKnownHost) is reachable
 111    virtual bool IsOnline() const
 112       {
 113          CheckStatus();
 114          return m_IsOnline == Net_Connected;
 115       }
 116
 117    // do we have a constant net connection?
 118    virtual bool IsAlwaysOnline() const;
 119
 120    // returns TRUE if (async) dialing is in progress
 121    virtual bool IsDialing() const
 122       { return m_DialProcess != NULL; }
 123
 124    // cancel dialing the number initiated with Dial(async = TRUE)
 125    // NB: this won't result in DISCONNECTED event being sent
 126    virtual bool CancelDialing();
 127
 128    size_t GetISPNames(class wxArrayString &) const
 129       { return 0; }
 130
 131    // sometimes the built-in logic for determining the online status may fail,
 132    // so, in general, the user should be allowed to override it. This function
 133    // allows to forcefully set the online status - whatever our internal
 134    // algorithm may think about it.
 135    virtual void SetOnlineStatus(bool isOnline = TRUE)
 136       { m_IsOnline = isOnline ? Net_Connected : Net_No; }
 137
 138    // set misc wxDialUpManager options
 139    // --------------------------------
 140
 141    // enable automatical checks for the connection status and sending of
 142    // wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
 143    // parameter is only for Unix where we do the check manually: under
 144    // Windows, the notification about the change of connection status is
 145    // instantenous.
 146    //
 147    // Returns FALSE if couldn't set up automatic check for online status.
 148    virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
 149
 150    // disable automatic check for connection status change - notice that the
 151    // wxEVT_DIALUP_XXX events won't be sent any more neither.
 152    virtual void DisableAutoCheckOnlineStatus();
 153
 154    // under Unix, the value of well-known host is used to check whether we're
 155    // connected to the internet. It's unused under Windows, but this function
 156    // is always safe to call. The default value is www.yahoo.com.
 157    virtual void SetWellKnownHost(const wxString& hostname,
 158                                  int portno = 80);
 159    /** Sets the commands to start up the network and to hang up
 160        again. Used by the Unix implementations only.
 161    */
 162    virtual void SetConnectCommand(const wxString &command, const wxString &hupcmd)
 163       { m_ConnectCommand = command; m_HangUpCommand = hupcmd; }
 164
 165 //private: -- Sun CC 4.2 objects to using NetConnection enum as the return
 166 //            type if it is declared private
 167
 168    // the possible results of testing for Online() status
 169    enum NetConnection
 170    {
 171        Net_Unknown = -1,    // we couldn't learn anything
 172        Net_No,              // no network connection [currently]
 173        Net_Connected        // currently connected
 174    };
 175
 176    // the possible net connection types
 177    enum NetDeviceType
 178    {
 179        NetDevice_None    = 0x0000,  // no network devices (authoritative)
 180        NetDevice_Unknown = 0x0001,  // test doesn't work on this OS
 181        NetDevice_Modem   = 0x0002,  // we have a modem
 182        NetDevice_LAN     = 0x0004   //         a network card
 183    };
 184
 185 private:
 186    // the current status
 187    NetConnection m_IsOnline;
 188
 189    // the connection we have with the network card
 190    NetConnection m_connCard;
 191
 192    // Can we use ifconfig to list active devices?
 193    int m_CanUseIfconfig;
 194
 195    // The path to ifconfig
 196    wxString m_IfconfigPath;
 197
 198    //  Can we use ping to find hosts?
 199    int m_CanUsePing;
 200    // The path to ping program
 201    wxString m_PingPath;
 202
 203    // beacon host:
 204    wxString m_BeaconHost;
 205    // beacon host portnumber for connect:
 206    int m_BeaconPort;
 207
 208    // command to connect to network
 209    wxString m_ConnectCommand;
 210    // command to hang up
 211    wxString m_HangUpCommand;
 212    // name of ISP
 213    wxString m_ISPname;
 214    // a timer for regular testing
 215    class AutoCheckTimer *m_timer;
 216    friend class AutoCheckTimer;
 217
 218    // a wxProcess for dialling in background
 219    class wxDialProcess *m_DialProcess;
 220    // pid of dial process
 221    int m_DialPId;
 222    friend class wxDialProcess;
 223
 224    // determine status
 225    void CheckStatus(bool fromAsync = FALSE) const;
 226
 227    // real status check
 228    void CheckStatusInternal();
 229
 230    // check /proc/net (Linux only) for ppp/eth interfaces, returns the bit
 231    // mask of NetDeviceType constants
 232    int CheckProcNet();
 233
 234    // check output of ifconfig command for PPP/SLIP/PLIP devices, returns the
 235    // bit mask of NetDeviceType constants
 236    int CheckIfconfig();
 237
 238    // combines the 2 possible checks for determining the connection status
 239    NetConnection CheckConnectAndPing();
 240
 241    // pings a host
 242    NetConnection CheckPing();
 243
 244    // check by connecting to host on given port.
 245    NetConnection CheckConnect();
 246 };
 247
 248
 249 class AutoCheckTimer : public wxTimer
 250 {
 251 public:
 252    AutoCheckTimer(wxDialUpManagerImpl *dupman)
 253    {
 254        m_dupman = dupman;
 255    }
 256
 257    virtual void Notify()
 258    {
 259        wxLogTrace(_T("dialup"), wxT("Checking dial up network status."));
 260
 261        m_dupman->CheckStatus();
 262    }
 263
 264 public:
 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 #ifdef __VMS
 643        m_CanUseIfconfig = 0;
 644         return -1;
 645 #else
 646    // assume that the test doesn't work
 647     int netDevice = NetDevice_Unknown;
 648
 649     // first time check for ifconfig location
 650     if ( m_CanUseIfconfig == -1 ) // unknown
 651     {
 652         static const wxChar *ifconfigLocations[] =
 653         {
 654             _T("/sbin"),         // Linux, FreeBSD, Darwin
 655             _T("/usr/sbin"),     // SunOS, Solaris, AIX, HP-UX
 656             _T("/usr/etc"),      // IRIX
 657         };
 658
 659         for ( size_t n = 0; n < WXSIZEOF(ifconfigLocations); n++ )
 660         {
 661             wxString path(ifconfigLocations[n]);
 662             path << _T("/ifconfig");
 663
 664             if ( wxFileExists(path) )
 665             {
 666                 m_IfconfigPath = path;
 667                 break;
 668             }
 669         }
 670     }
 671
 672     if ( m_CanUseIfconfig != 0 ) // unknown or yes
 673     {
 674         wxLogNull ln; // suppress all error messages
 675
 676         wxASSERT_MSG( m_IfconfigPath.length(),
 677                       _T("can't use ifconfig if it wasn't found") );
 678
 679         wxString tmpfile = wxGetTempFileName( wxT("_wxdialuptest") );
 680         wxString cmd = wxT("/bin/sh -c \'");
 681         cmd << m_IfconfigPath;
 682 #if defined(__SOLARIS__) || defined (__SUNOS__)
 683         // need to add -a flag
 684         cmd << wxT(" -a");
 685 #elif defined(__LINUX__) || defined(__SGI__)
 686         // nothing to be added to ifconfig
 687 #elif defined(__FREEBSD__) || defined(__DARWIN__)
 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 # pragma warning "No ifconfig information for this OS."
 695        m_CanUseIfconfig = 0;
 696         return -1;
 697 #endif
 698        cmd << wxT(" >") << tmpfile <<  wxT('\'');
 699         /* I tried to add an option to wxExecute() to not close stdout,
 700            so we could let ifconfig write directly to the tmpfile, but
 701            this does not work. That should be faster, as it doesn´t call
 702            the shell first. I have no idea why. :-(  (KB) */
 703         if ( wxExecute(cmd,TRUE /* sync */) == 0 )
 704         {
 705             m_CanUseIfconfig = 1;
 706             wxFFile file;
 707             if( file.Open(tmpfile) )
 708             {
 709                 wxString output;
 710                 if ( file.ReadAll(&output) )
 711                 {
 712                     // FIXME shouldn't we grep for "^ppp"? (VZ)
 713
 714                     bool hasModem = FALSE,
 715                          hasLAN = FALSE;
 716
 717 #if defined(__SOLARIS__) || defined (__SUNOS__)
 718                     // dialup device under SunOS/Solaris
 719                     hasModem = strstr(output.fn_str(),"ipdptp") != (char *)NULL;
 720                     hasLAN = strstr(output.fn_str(), "hme") != (char *)NULL;
 721 #elif defined(__LINUX__) || defined (__FREEBSD__)
 722                     hasModem = strstr(output.fn_str(),"ppp")    // ppp
 723                         || strstr(output.fn_str(),"sl")  // slip
 724                         || strstr(output.fn_str(),"pl"); // plip
 725                     hasLAN = strstr(output.fn_str(), "eth") != NULL;
 726 #elif defined(__SGI__)  // IRIX
 727                     hasModem = strstr(output, "ppp") != NULL; // PPP
 728 #elif defined(__HPUX__)
 729                     // if could run ifconfig on interface, then it exists
 730                     hasModem = TRUE;
 731 #endif
 732
 733                     netDevice = NetDevice_None;
 734                     if ( hasModem )
 735                         netDevice |= NetDevice_Modem;
 736                     if ( hasLAN )
 737                         netDevice |= NetDevice_LAN;
 738                 }
 739                 //else: error reading the file
 740             }
 741             //else: error opening the file
 742         }
 743         else // could not run ifconfig correctly
 744         {
 745             m_CanUseIfconfig = 0; // don´t try again
 746         }
 747
 748         (void) wxRemoveFile(tmpfile);
 749     }
 750
 751     return netDevice;
 752 #endif
 753 }
 754
 755 wxDialUpManagerImpl::NetConnection wxDialUpManagerImpl::CheckPing()
 756 {
 757     // First time check for ping location. We only use the variant
 758     // which does not take arguments, a la GNU.
 759     if(m_CanUsePing == -1) // unknown
 760     {
 761 #ifdef __VMS
 762         if (wxFileExists( wxT("SYS$SYSTEM:TCPIP$PING.EXE") ))
 763             m_PingPath = wxT("$SYS$SYSTEM:TCPIP$PING");
 764 #else
 765         if (wxFileExists( wxT("/bin/ping") ))
 766             m_PingPath = wxT("/bin/ping");
 767         else if (wxFileExists( wxT("/usr/sbin/ping") ))
 768             m_PingPath = wxT("/usr/sbin/ping");
 769 #endif
 770         if (!m_PingPath)
 771         {
 772             m_CanUsePing = 0;
 773         }
 774     }
 775
 776     if(! m_CanUsePing)
 777     {
 778        // we didn't find ping
 779        return Net_Unknown;
 780     }
 781
 782    wxLogNull ln; // suppress all error messages
 783    wxASSERT(m_PingPath.length());
 784    wxString cmd;
 785    cmd << m_PingPath << wxT(' ');
 786 #if defined(__SOLARIS__) || defined (__SUNOS__)
 787    // nothing to add to ping command
 788 #elif defined(__LINUX__) || defined (__BSD__) || defined( __VMS )
 789    cmd << wxT("-c 1 "); // only ping once
 790 #elif defined(__HPUX__)
 791    cmd << wxT("64 1 "); // only ping once (need also specify the packet size)
 792 #else
 793 #   pragma warning "No Ping information for this OS."
 794    m_CanUsePing = 0;
 795    return Net_Unknown;
 796 #endif
 797    cmd << m_BeaconHost;
 798    if(wxExecute(cmd, TRUE /* sync */) == 0)
 799       return Net_Connected;
 800    else
 801       return Net_No;
 802 }
 803
 804 /* static */
 805 wxDialUpManager *wxDialUpManager::Create()
 806 {
 807    return new wxDialUpManagerImpl;
 808 }
 809
 810 #endif // wxUSE_DIALUP_MANAGER