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/file.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 // ----------------------------------------------------------------------------
  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    ~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          if( (! m_timer) // we are not polling, so test now:
 108              || m_IsOnline < 0
 109             )
 110             CheckStatus();
 111          return m_IsOnline != 0;
 112       }
 113
 114    /// do we have a constant net connection? -- GUESS!
 115    bool IsAlwaysOnline() const
 116       {
 117          ((wxDialUpManagerImpl *) this)->HangUp(); // brutal but necessary
 118          return IsOnline();
 119       }
 120    /// returns TRUE if (async) dialing is in progress
 121    inline 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; }
 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:
 166    /// -1: don´t know, 0 = no, 1 = yes
 167    int m_IsOnline;
 168
 169    ///  Can we use ifconfig to list active devices?
 170    int m_CanUseIfconfig;
 171    /// The path to ifconfig
 172    wxString m_IfconfigPath;
 173
 174    ///  Can we use ping to find hosts?
 175    int m_CanUsePing;
 176    /// The path to ping program
 177    wxString m_PingPath;
 178
 179    /// beacon host:
 180    wxString m_BeaconHost;
 181    /// beacon host portnumber for connect:
 182    int m_BeaconPort;
 183
 184    /// command to connect to network
 185    wxString m_ConnectCommand;
 186    /// command to hang up
 187    wxString m_HangUpCommand;
 188    /// name of ISP
 189    wxString m_ISPname;
 190    /// a timer for regular testing
 191    class AutoCheckTimer *m_timer;
 192    friend class AutoCheckTimer;
 193
 194    /// a wxProcess for dialling in background
 195    class wxDialProcess *m_DialProcess;
 196    /// pid of dial process
 197    int m_DialPId;
 198    friend class wxDialProcess;
 199
 200    /// determine status
 201    void CheckStatus(bool fromAsync = FALSE) const;
 202
 203    /// real status check
 204    void CheckStatusInternal(void);
 205
 206    /// Check output of ifconfig command for PPP/SLIP/PLIP devices
 207    int CheckIfconfig(void);
 208    /// Ping a host: 1 on success, -1 if it cannot be used, 0 if unreachable
 209    int CheckPing(void);
 210    /// Check by connecting to host on given port.
 211    int CheckConnect(void);
 212
 213 };
 214
 215
 216 class AutoCheckTimer : public wxTimer
 217 {
 218 public:
 219    AutoCheckTimer(wxDialUpManagerImpl *dupman)
 220       {
 221          m_dupman = dupman;
 222          m_started = FALSE;
 223       }
 224
 225    virtual bool Start( int millisecs = -1, bool WXUNUSED(one_shot) = FALSE )
 226       { m_started = TRUE; return wxTimer::Start(millisecs, FALSE); }
 227
 228    virtual void Notify()
 229       { wxLogTrace(wxT("Checking dial up network status.")); m_dupman->CheckStatus(); }
 230
 231    virtual void Stop()
 232       { if ( m_started ) wxTimer::Stop(); }
 233 public:
 234    bool m_started;
 235    wxDialUpManagerImpl *m_dupman;
 236 };
 237
 238 class wxDialProcess : public wxProcess
 239 {
 240 public:
 241    wxDialProcess(wxDialUpManagerImpl *dupman)
 242       {
 243          m_DupMan = dupman;
 244       }
 245    void Disconnect(void) { m_DupMan = NULL; }
 246    virtual void OnTerminate(int WXUNUSED(pid), int WXUNUSED(status))
 247       {
 248          if(m_DupMan)
 249          {
 250             m_DupMan->m_DialProcess = NULL;
 251             m_DupMan->CheckStatus(TRUE);
 252          }
 253       }
 254 private:
 255       wxDialUpManagerImpl *m_DupMan;
 256 };
 257
 258
 259 wxDialUpManagerImpl::wxDialUpManagerImpl()
 260 {
 261    /* The isOnline flag can have the following values internally:
 262       0  : not connected
 263       1  : connected
 264       -1 : unknown/undefined status
 265    */
 266    m_IsOnline = -1;
 267    m_DialProcess = NULL;
 268    m_timer = NULL;
 269    m_CanUseIfconfig = -1; // unknown
 270    m_CanUsePing = -1; // unknown
 271    m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
 272    m_BeaconPort = 80;
 273
 274 #ifdef __SGI__
 275    m_ConnectCommand = _T("/usr/etc/ppp");
 276 #elif defined(__LINUX__)
 277    // default values for Debian/GNU linux
 278    m_ConnectCommand = _T("pon");
 279    m_HangUpCommand = _T("poff");
 280 #endif
 281
 282    wxChar * dial = wxGetenv(_T("WXDIALUP_DIALCMD"));
 283    wxChar * hup = wxGetenv(_T("WXDIALUP_HUPCMD"));
 284    SetConnectCommand(dial ? wxString(dial) : m_ConnectCommand,
 285                      hup ? wxString(hup) : m_HangUpCommand);
 286 }
 287
 288 wxDialUpManagerImpl::~wxDialUpManagerImpl()
 289 {
 290    if(m_timer) delete m_timer;
 291    if(m_DialProcess)
 292    {
 293       m_DialProcess->Disconnect();
 294       m_DialProcess->Detach();
 295    }
 296 }
 297
 298 bool
 299 wxDialUpManagerImpl::Dial(const wxString &isp,
 300                           const wxString & WXUNUSED(username),
 301                           const wxString & WXUNUSED(password),
 302                           bool async)
 303 {
 304    if(m_IsOnline == 1)
 305       return FALSE;
 306    m_ISPname = isp;
 307    wxString cmd;
 308    if(m_ConnectCommand.Find(wxT("%s")))
 309       cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
 310    else
 311       cmd = m_ConnectCommand;
 312
 313    if ( async )
 314    {
 315       m_DialProcess = new wxDialProcess(this);
 316       m_DialPId = wxExecute(cmd, FALSE, m_DialProcess);
 317       if(m_DialPId == 0)
 318       {
 319          delete m_DialProcess;
 320          m_DialProcess = NULL;
 321          return FALSE;
 322       }
 323       else
 324          return TRUE;
 325    }
 326    else
 327        return wxExecute(cmd, /* sync */ TRUE) == 0;
 328 }
 329
 330 bool
 331 wxDialUpManagerImpl::HangUp(void)
 332 {
 333    if(m_IsOnline == 0)
 334       return FALSE;
 335    if(IsDialing())
 336    {
 337       wxLogError(_("Already dialling ISP."));
 338       return FALSE;
 339    }
 340    wxString cmd;
 341    if(m_HangUpCommand.Find(wxT("%s")))
 342       cmd.Printf(m_HangUpCommand,m_ISPname.c_str(), m_DialProcess);
 343    else
 344       cmd = m_HangUpCommand;
 345    return wxExecute(cmd, /* sync */ TRUE) == 0;
 346 }
 347
 348
 349 bool
 350 wxDialUpManagerImpl::CancelDialing()
 351 {
 352    if(! IsDialing())
 353       return FALSE;
 354    return kill(m_DialPId, SIGTERM) > 0;
 355 }
 356
 357 bool
 358 wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
 359 {
 360    DisableAutoCheckOnlineStatus();
 361    m_timer = new AutoCheckTimer(this);
 362    bool rc = m_timer->Start(nSeconds*1000);
 363    if(! rc)
 364    {
 365       delete m_timer;
 366       m_timer = NULL;
 367    }
 368    return rc;
 369 }
 370
 371 void
 372 wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
 373 {
 374    if(m_timer != NULL)
 375    {
 376       m_timer->Stop();
 377       delete m_timer;
 378       m_timer = NULL;
 379    }
 380 }
 381
 382
 383 void
 384 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
 385 {
 386    /// does hostname contain a port number?
 387    wxString port = hostname.After(wxT(':'));
 388    if(port.Length())
 389    {
 390       m_BeaconHost = hostname.Before(wxT(':'));
 391       m_BeaconPort = wxAtoi(port);
 392    }
 393    else
 394    {
 395       m_BeaconHost = hostname;
 396       m_BeaconPort = portno;
 397    }
 398 }
 399
 400
 401 void
 402 wxDialUpManagerImpl::CheckStatus(bool fromAsync) const
 403 {
 404    // This function calls the CheckStatusInternal() helper function
 405    // which is OS - specific and then sends the events.
 406
 407    int oldIsOnline = m_IsOnline;
 408    ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
 409
 410    // now send the events as appropriate:
 411    if(m_IsOnline != oldIsOnline // it changed
 412       && ( m_IsOnline == 1      // and it is a defined status
 413            || m_IsOnline == 0)
 414       // only send events for well defined transitions
 415       && ( oldIsOnline == 1 || oldIsOnline == 0)
 416       )
 417    {
 418       wxDialUpEvent event(m_IsOnline, ! fromAsync);
 419       (void)wxTheApp->ProcessEvent(event);
 420    }
 421 }
 422
 423 /*
 424   We have three methods that we can use:
 425
 426   1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
 427      --> should be fast enough for regular polling
 428   2. test if we can reach the well known beacon host
 429      --> too slow for polling
 430   3. check /proc/net/dev on linux??
 431      This method should be preferred, if possible. Need to do more
 432      testing.
 433
 434 */
 435
 436 void
 437 wxDialUpManagerImpl::CheckStatusInternal(void)
 438 {
 439    m_IsOnline = -1;
 440
 441    int testResult;
 442
 443    testResult = CheckConnect();
 444    if(testResult == -1)
 445       testResult = CheckIfconfig();
 446    if(testResult == -1)
 447       testResult = CheckPing();
 448       m_IsOnline = testResult;
 449 }
 450
 451 int
 452 wxDialUpManagerImpl::CheckConnect(void)
 453 {
 454    // second method: try to connect to a well known host:
 455    // This can be used under Win 9x, too!
 456    struct hostent     *hp;
 457    struct sockaddr_in  serv_addr;
 458
 459    if((hp = gethostbyname(m_BeaconHost.mb_str())) == NULL)
 460       return 0; // no DNS no net
 461
 462    serv_addr.sin_family = hp->h_addrtype;
 463    memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
 464    serv_addr.sin_port = htons(m_BeaconPort);
 465
 466    int sockfd;
 467    if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
 468    {
 469       return -1;  // no info
 470    }
 471
 472    if( connect(sockfd, (struct sockaddr *) &serv_addr,
 473                sizeof(serv_addr)) >= 0)
 474    {
 475       close(sockfd);
 476       return 1; // we cant connect, so we have a network!
 477    }
 478    //connected!
 479    close(sockfd);
 480    if(errno == ENETUNREACH)
 481       return 0; // network is unreachable
 482    // connect failed, but don't know why
 483    return -1;
 484 }
 485
 486 int
 487 wxDialUpManagerImpl::CheckIfconfig(void)
 488 {
 489    int rc = -1;
 490
 491    // First time check for ifconfig location. We only use the variant which
 492    // does not take arguments, a la GNU.
 493    if ( m_CanUseIfconfig == -1 ) // unknown
 494    {
 495        static const wxChar *ifconfigLocations[] =
 496        {
 497            _T("/sbin"),         // Linux, FreeBSD
 498            _T("/usr/sbin"),     // SunOS, Solaris, AIX, HP-UX
 499            _T("/usr/etc"),      // IRIX
 500        };
 501
 502        for ( size_t n = 0; n < WXSIZEOF(ifconfigLocations); n++ )
 503        {
 504            wxString path(ifconfigLocations[n]);
 505            path << _T("/ifconfig");
 506
 507            if ( wxFileExists(path) )
 508            {
 509                m_IfconfigPath = path;
 510                break;
 511            }
 512        }
 513    }
 514
 515    wxLogNull ln; // suppress all error messages
 516    // Let´s try the ifconfig method first, should be fastest:
 517    if(m_CanUseIfconfig != 0) // unknown or yes
 518    {
 519       wxASSERT(m_IfconfigPath.length());
 520
 521       wxString tmpfile = wxGetTempFileName("_wxdialuptest");
 522       wxString cmd = "/bin/sh -c \'";
 523       cmd << m_IfconfigPath;
 524 #if defined(__SOLARIS__) || defined (__SUNOS__)
 525       // need to add -a flag
 526       cmd << " -a";
 527 #elif defined(__LINUX__) || defined (__FREEBSD__) || defined(__SGI__)
 528       // nothing to be added to ifconfig
 529 #else
 530 #     pragma warning "No ifconfig information for this OS."
 531       m_CanUseIfconfig = 0;
 532       return -1;
 533 #endif
 534       cmd << " >" << tmpfile <<  '\'';
 535       /* I tried to add an option to wxExecute() to not close stdout,
 536          so we could let ifconfig write directly to the tmpfile, but
 537          this does not work. That should be faster, as it doesn´t call
 538          the shell first. I have no idea why. :-(  (KB) */
 539       if(wxExecute(cmd,TRUE /* sync */) == 0)
 540       {
 541          m_CanUseIfconfig = 1;
 542          wxFile file;
 543          if( file.Open(tmpfile) )
 544          {
 545             char *output = new char [file.Length()+1];
 546             output[file.Length()] = '\0';
 547             if(file.Read(output,file.Length()) == file.Length())
 548             {
 549                // FIXME shouldn't we grep for "^ppp"? (VZ)
 550
 551 #if defined(__SOLARIS__) || defined (__SUNOS__)
 552                // dialup device under SunOS/Solaris
 553                rc = strstr(output,"ipdptp") != (char *)NULL;
 554 #elif defined(__LINUX__) || defined (__FREEBSD__)
 555                rc = strstr(output,"ppp")    // ppp
 556                     || strstr(output,"sl")  // slip
 557                     || strstr(output,"pl"); // plip
 558 #elif defined(__SGI__)  // IRIX
 559                rc = strstr(output, "ppp"); // PPP
 560 #endif
 561             }
 562             file.Close();
 563             delete [] output;
 564          }
 565          // else rc remains -1 as we don't know for sure
 566       }
 567       else // could not run ifconfig correctly
 568          m_CanUseIfconfig = 0; // don´t try again
 569       (void) wxRemoveFile(tmpfile);
 570    }
 571       return rc;
 572 }
 573
 574 int
 575 wxDialUpManagerImpl::CheckPing(void)
 576 {
 577    if(! m_CanUsePing)
 578       return -1;
 579
 580    // First time check for ping location. We only use the variant
 581    // which does not take arguments, a la GNU.
 582    if(m_CanUsePing == -1) // unknown
 583    {
 584       if(wxFileExists("/bin/ping"))
 585          m_PingPath = "/bin/ping";
 586       else if(wxFileExists("/usr/sbin/ping"))
 587          m_PingPath = "/usr/sbin/ping";
 588       if(! m_PingPath)
 589       {
 590          m_CanUsePing = 0;
 591          return -1;
 592       }
 593    }
 594
 595    wxLogNull ln; // suppress all error messages
 596    wxASSERT(m_PingPath.length());
 597    wxString cmd;
 598    cmd << m_PingPath << ' ';
 599 #if defined(__SOLARIS__) || defined (__SUNOS__)
 600    // nothing to add to ping command
 601 #elif defined(__LINUX__)
 602    cmd << "-c 1 "; // only ping once
 603 #else
 604 #   pragma warning "No Ping information for this OS."
 605    m_CanUsePing = 0;
 606    return -1;
 607 #endif
 608    cmd << m_BeaconHost;
 609    if(wxExecute(cmd, TRUE /* sync */) == 0)
 610       return 1;
 611    else
 612       return 0;
 613 }
 614
 615 /* static */
 616 wxDialUpManager *
 617 wxDialUpManager::Create(void)
 618 {
 619    return new wxDialUpManagerImpl;
 620 }
 621
 622 #endif // wxUSE_DIALUP_MANAGER