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, sizeof(serv_addr)) < 0)
 458    {
 459       close(sockfd);
 460       return 1; // we can connect, so we have a network!
 461    }
 462    //connected!
 463    close(sockfd);
 464    if(errno == ENETUNREACH)
 465       return 0; // network is unreachable
 466    // connect failed, but don't know why
 467    return -1;
 468 }
 469
 470 int
 471 wxDialUpManagerImpl::CheckIfconfig(void)
 472 {
 473    int rc = -1;
 474    // First time check for ifconfig location. We only use the variant
 475    // which does not take arguments, a la GNU.
 476    if(m_CanUseIfconfig == -1) // unknown
 477    {
 478       if(wxFileExists("/sbin/ifconfig"))
 479          m_IfconfigPath = "/sbin/ifconfig";
 480       else if(wxFileExists("/usr/sbin/ifconfig"))
 481          m_IfconfigPath = "/usr/sbin/ifconfig";
 482    }
 483
 484    wxLogNull ln; // suppress all error messages
 485    // Let´s try the ifconfig method first, should be fastest:
 486    if(m_CanUseIfconfig != 0) // unknown or yes
 487    {
 488       wxASSERT(m_IfconfigPath.length());
 489
 490       wxString tmpfile = wxGetTempFileName("_wxdialuptest");
 491       wxString cmd = "/bin/sh -c \'";
 492       cmd << m_IfconfigPath;
 493 #if defined(__SOLARIS__) || defined (__SUNOS__)
 494       // need to add -a flag
 495       cmd << " -a";
 496 #elif defined(__LINUX__) || defined (__FREEBSD__)
 497       // nothing to be added to ifconfig
 498 #else
 499 #   pragma warning "No ifconfig information for this OS."
 500       m_CanUseIfconfig = 0;
 501       return -1;
 502 #endif
 503       cmd << " >" << tmpfile <<  '\'';
 504       /* I tried to add an option to wxExecute() to not close stdout,
 505          so we could let ifconfig write directly to the tmpfile, but
 506          this does not work. That should be faster, as it doesn´t call
 507          the shell first. I have no idea why. :-(  (KB) */
 508       if(wxExecute(cmd,TRUE /* sync */) == 0)
 509       {
 510          m_CanUseIfconfig = 1;
 511          wxFile file;
 512          if( file.Open(tmpfile) )
 513          {
 514             char *output = new char [file.Length()+1];
 515             output[file.Length()] = '\0';
 516             if(file.Read(output,file.Length()) == file.Length())
 517             {
 518                if(
 519 #if defined(__SOLARIS__) || defined (__SUNOS__)
 520                   strstr(output,"ipdptp")   // dialup device
 521 #elif defined(__LINUX__) || defined (__FREEBSD__)
 522                   strstr(output,"ppp")   // ppp
 523                   || strstr(output,"sl") // slip
 524                   || strstr(output,"pl") // plip
 525 #else
 526                   wxASSERT(0); // unreachable code
 527 #endif
 528                   )
 529                   rc = 1;
 530                else
 531                   rc = 0;
 532             }
 533             file.Close();
 534             delete [] output;
 535          }
 536          // else rc remains -1 as we don't know for sure
 537       }
 538       else // could not run ifconfig correctly
 539          m_CanUseIfconfig = 0; // don´t try again
 540       (void) wxRemoveFile(tmpfile);
 541    }
 542       return rc;
 543 }
 544
 545 int
 546 wxDialUpManagerImpl::CheckPing(void)
 547 {
 548    if(! m_CanUsePing)
 549       return -1;
 550
 551    // First time check for ping location. We only use the variant
 552    // which does not take arguments, a la GNU.
 553    if(m_CanUsePing == -1) // unknown
 554    {
 555       if(wxFileExists("/bin/ping"))
 556          m_PingPath = "/bin/ping";
 557       else if(wxFileExists("/usr/sbin/ping"))
 558          m_PingPath = "/usr/sbin/ping";
 559       if(! m_PingPath)
 560       {
 561          m_CanUsePing = 0;
 562          return -1;
 563       }
 564    }
 565
 566    wxLogNull ln; // suppress all error messages
 567    wxASSERT(m_PingPath.length());
 568    wxString cmd;
 569    cmd << m_PingPath << ' ';
 570 #if defined(__SOLARIS__) || defined (__SUNOS__)
 571    // nothing to add to ping command
 572 #elif defined(__LINUX__)
 573    cmd << "-c 1 "; // only ping once
 574 #else
 575 #   pragma warning "No Ping information for this OS."
 576    m_CanUsePing = 0;
 577    return -1;
 578 #endif
 579    cmd << m_BeaconHost;
 580    if(wxExecute(cmd, TRUE /* sync */) == 0)
 581       return 1;
 582    else
 583       return 0;
 584 }
 585
 586 /* static */
 587 wxDialUpManager *
 588 wxDialUpManager::Create(void)
 589 {
 590    return new wxDialUpManagerImpl;
 591 }
 592
 593 #endif // wxUSE_DIALUP_MANAGER