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    m_IsOnline = -2; // -1 or -2, unknown
 262    m_DialProcess = NULL;
 263    m_timer = NULL;
 264    m_CanUseIfconfig = -1; // unknown
 265    m_CanUsePing = -1; // unknown
 266    m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
 267    m_BeaconPort = 80;
 268    SetConnectCommand("pon", "poff"); // default values for Debian/GNU linux
 269    wxChar * dial = wxGetenv(_T("WXDIALUP_DIALCMD"));
 270    wxChar * hup = wxGetenv(_T("WXDIALUP_HUPCMD"));
 271    if(dial || hup)
 272       SetConnectCommand(dial ? wxString(dial) : m_ConnectCommand,
 273                         hup ? wxString(hup) : m_HangUpCommand);
 274 }
 275
 276 wxDialUpManagerImpl::~wxDialUpManagerImpl()
 277 {
 278    if(m_timer) delete m_timer;
 279    if(m_DialProcess)
 280    {
 281       m_DialProcess->Disconnect();
 282       m_DialProcess->Detach();
 283    }
 284 }
 285
 286 bool
 287 wxDialUpManagerImpl::Dial(const wxString &isp,
 288                           const wxString & WXUNUSED(username),
 289                           const wxString & WXUNUSED(password),
 290                           bool async)
 291 {
 292    if(m_IsOnline == 1)
 293       return FALSE;
 294    m_IsOnline = -1;
 295    m_ISPname = isp;
 296    wxString cmd;
 297    if(m_ConnectCommand.Find(wxT("%s")))
 298       cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
 299    else
 300       cmd = m_ConnectCommand;
 301
 302    if ( async )
 303    {
 304       m_DialProcess = new wxDialProcess(this);
 305       m_DialPId = wxExecute(cmd, FALSE, m_DialProcess);
 306       if(m_DialPId == 0)
 307       {
 308          delete m_DialProcess;
 309          m_DialProcess = NULL;
 310          return FALSE;
 311       }
 312       else
 313          return TRUE;
 314    }
 315    else
 316        return wxExecute(cmd, /* sync */ TRUE) == 0;
 317 }
 318
 319 bool
 320 wxDialUpManagerImpl::HangUp(void)
 321 {
 322    if(m_IsOnline == 0)
 323       return FALSE;
 324    if(IsDialing())
 325    {
 326       wxLogError(_("Already dialling ISP."));
 327       return FALSE;
 328    }
 329    m_IsOnline = -1;
 330    wxString cmd;
 331    if(m_HangUpCommand.Find(wxT("%s")))
 332       cmd.Printf(m_HangUpCommand,m_ISPname.c_str(), m_DialProcess);
 333    else
 334       cmd = m_HangUpCommand;
 335    return wxExecute(cmd, /* sync */ TRUE) == 0;
 336 }
 337
 338
 339 bool
 340 wxDialUpManagerImpl::CancelDialing()
 341 {
 342    if(! IsDialing())
 343       return FALSE;
 344    return kill(m_DialPId, SIGTERM) > 0;
 345 }
 346
 347 bool
 348 wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
 349 {
 350    DisableAutoCheckOnlineStatus();
 351    m_timer = new AutoCheckTimer(this);
 352    bool rc = m_timer->Start(nSeconds*1000);
 353    if(! rc)
 354    {
 355       delete m_timer;
 356       m_timer = NULL;
 357    }
 358    return rc;
 359 }
 360
 361 void
 362 wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
 363 {
 364    if(m_timer != NULL)
 365    {
 366       m_timer->Stop();
 367       delete m_timer;
 368       m_timer = NULL;
 369    }
 370 }
 371
 372
 373 void
 374 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
 375 {
 376    /// does hostname contain a port number?
 377    wxString port = hostname.After(wxT(':'));
 378    if(port.Length())
 379    {
 380       m_BeaconHost = hostname.Before(wxT(':'));
 381       m_BeaconPort = wxAtoi(port);
 382    }
 383    else
 384    {
 385       m_BeaconHost = hostname;
 386       m_BeaconPort = portno;
 387    }
 388 }
 389
 390
 391 void
 392 wxDialUpManagerImpl::CheckStatus(bool fromAsync) const
 393 {
 394    // This function calls the CheckStatusInternal() helper function
 395    // which is OS - specific and then sends the events.
 396
 397    int oldIsOnline = m_IsOnline;
 398    ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
 399
 400    // now send the events as appropriate:
 401    if(m_IsOnline != oldIsOnline && m_IsOnline != -1 && oldIsOnline != -2) // -2: first time!
 402    {
 403       wxDialUpEvent event(m_IsOnline, ! fromAsync);
 404       (void)wxTheApp->ProcessEvent(event);
 405    }
 406 }
 407
 408 /*
 409   We have three methods that we can use:
 410
 411   1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
 412      --> should be fast enough for regular polling
 413   2. test if we can reach the well known beacon host
 414      --> too slow for polling
 415   3. check /proc/net/dev on linux??
 416      This method should be preferred, if possible. Need to do more
 417      testing.
 418
 419 */
 420
 421 void
 422 wxDialUpManagerImpl::CheckStatusInternal(void)
 423 {
 424    m_IsOnline = -1;
 425
 426    int testResult;
 427
 428    testResult = CheckConnect();
 429    if(testResult == -1)
 430       testResult = CheckIfconfig();
 431    if(testResult == -1)
 432       testResult = CheckPing();
 433       m_IsOnline = testResult;
 434 }
 435
 436 int
 437 wxDialUpManagerImpl::CheckConnect(void)
 438 {
 439    // second method: try to connect to a well known host:
 440    // This can be used under Win 9x, too!
 441    struct hostent     *hp;
 442    struct sockaddr_in  serv_addr;
 443
 444    if((hp = gethostbyname(m_BeaconHost.mb_str())) == NULL)
 445       return 0; // no DNS no net
 446
 447    serv_addr.sin_family         = hp->h_addrtype;
 448    memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
 449    serv_addr.sin_port           = htons(m_BeaconPort);
 450
 451    int  sockfd;
 452    if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
 453    {
 454       return -1;  // no info
 455    }
 456
 457    if( connect(sockfd, (struct sockaddr *) &serv_addr,
 458                sizeof(serv_addr)) >= 0)
 459    {
 460       close(sockfd);
 461       return 1; // we cant connect, so we have a network!
 462    }
 463    //connected!
 464    close(sockfd);
 465    if(errno == ENETUNREACH)
 466       return 0; // network is unreachable
 467    // connect failed, but don't know why
 468    return -1;
 469 }
 470
 471 int
 472 wxDialUpManagerImpl::CheckIfconfig(void)
 473 {
 474    int rc = -1;
 475    // First time check for ifconfig location. We only use the variant
 476    // which does not take arguments, a la GNU.
 477    if(m_CanUseIfconfig == -1) // unknown
 478    {
 479       if(wxFileExists("/sbin/ifconfig"))
 480          m_IfconfigPath = "/sbin/ifconfig";
 481       else if(wxFileExists("/usr/sbin/ifconfig"))
 482          m_IfconfigPath = "/usr/sbin/ifconfig";
 483    }
 484
 485    wxLogNull ln; // suppress all error messages
 486    // Let´s try the ifconfig method first, should be fastest:
 487    if(m_CanUseIfconfig != 0) // unknown or yes
 488    {
 489       wxASSERT(m_IfconfigPath.length());
 490
 491       wxString tmpfile = wxGetTempFileName("_wxdialuptest");
 492       wxString cmd = "/bin/sh -c \'";
 493       cmd << m_IfconfigPath;
 494 #if defined(__SOLARIS__) || defined (__SUNOS__)
 495       // need to add -a flag
 496       cmd << " -a";
 497 #elif defined(__LINUX__) || defined (__FREEBSD__)
 498       // nothing to be added to ifconfig
 499 #else
 500 #   pragma warning "No ifconfig information for this OS."
 501       m_CanUseIfconfig = 0;
 502       return -1;
 503 #endif
 504       cmd << " >" << tmpfile <<  '\'';
 505       /* I tried to add an option to wxExecute() to not close stdout,
 506          so we could let ifconfig write directly to the tmpfile, but
 507          this does not work. That should be faster, as it doesn´t call
 508          the shell first. I have no idea why. :-(  (KB) */
 509       if(wxExecute(cmd,TRUE /* sync */) == 0)
 510       {
 511          m_CanUseIfconfig = 1;
 512          wxFile file;
 513          if( file.Open(tmpfile) )
 514          {
 515             char *output = new char [file.Length()+1];
 516             output[file.Length()] = '\0';
 517             if(file.Read(output,file.Length()) == file.Length())
 518             {
 519                if(
 520 #if defined(__SOLARIS__) || defined (__SUNOS__)
 521                   strstr(output,"ipdptp")   // dialup device
 522 #elif defined(__LINUX__) || defined (__FREEBSD__)
 523                   strstr(output,"ppp")   // ppp
 524                   || strstr(output,"sl") // slip
 525                   || strstr(output,"pl") // plip
 526 #else
 527                   FALSE
 528 #endif
 529                   )
 530                   rc = 1;
 531                else
 532                   rc = 0;
 533             }
 534             file.Close();
 535             delete [] output;
 536          }
 537          // else rc remains -1 as we don't know for sure
 538       }
 539       else // could not run ifconfig correctly
 540          m_CanUseIfconfig = 0; // don´t try again
 541       (void) wxRemoveFile(tmpfile);
 542    }
 543       return rc;
 544 }
 545
 546 int
 547 wxDialUpManagerImpl::CheckPing(void)
 548 {
 549    if(! m_CanUsePing)
 550       return -1;
 551
 552    // First time check for ping location. We only use the variant
 553    // which does not take arguments, a la GNU.
 554    if(m_CanUsePing == -1) // unknown
 555    {
 556       if(wxFileExists("/bin/ping"))
 557          m_PingPath = "/bin/ping";
 558       else if(wxFileExists("/usr/sbin/ping"))
 559          m_PingPath = "/usr/sbin/ping";
 560       if(! m_PingPath)
 561       {
 562          m_CanUsePing = 0;
 563          return -1;
 564       }
 565    }
 566
 567    wxLogNull ln; // suppress all error messages
 568    wxASSERT(m_PingPath.length());
 569    wxString cmd;
 570    cmd << m_PingPath << ' ';
 571 #if defined(__SOLARIS__) || defined (__SUNOS__)
 572    // nothing to add to ping command
 573 #elif defined(__LINUX__)
 574    cmd << "-c 1 "; // only ping once
 575 #else
 576 #   pragma warning "No Ping information for this OS."
 577    m_CanUsePing = 0;
 578    return -1;
 579 #endif
 580    cmd << m_BeaconHost;
 581    if(wxExecute(cmd, TRUE /* sync */) == 0)
 582       return 1;
 583    else
 584       return 0;
 585 }
 586
 587 /* static */
 588 wxDialUpManager *
 589 wxDialUpManager::Create(void)
 590 {
 591    return new wxDialUpManagerImpl;
 592 }
 593
 594 #endif // wxUSE_DIALUP_MANAGER