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
  48 // ----------------------------------------------------------------------------
  49 // A class which groups functions dealing with connecting to the network from a
  50 // workstation using dial-up access to the net. There is at most one instance
  51 // of this class in the program accessed via GetDialUpManager().
  52 // ----------------------------------------------------------------------------
  53
  54 /* TODO
  55  *
  56  * 1. more configurability for Unix: i.e. how to initiate the connection, how
  57  *    to check for online status, &c.
  58  * 2. add a "long Dial(long connectionId = -1)" function which asks the user
  59  *    about which connection to dial (this may be done using native dialogs
  60  *    under NT, need generic dialogs for all others) and returns the identifier
  61  *    of the selected connection (it's opaque to the application) - it may be
  62  *    reused later to dial the same connection later (or use strings instead of
  63  *    longs may be?)
  64  * 3. add an async version of dialing functions which notify the caller about
  65  *    the progress (or may be even start another thread to monitor it)
  66  * 4. the static creation/accessor functions are not MT-safe - but is this
  67  *    really crucial? I think we may suppose they're always called from the
  68  *    main thread?
  69  */
  70
  71 class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
  72 {
  73 public:
  74    wxDialUpManagerImpl();
  75    ~wxDialUpManagerImpl();
  76
  77    /** Could the dialup manager be initialized correctly? If this function
  78        returns FALSE, no other functions will work neither, so it's a good idea
  79        to call this function and check its result before calling any other
  80        wxDialUpManager methods.
  81    */
  82    virtual bool IsOk() const
  83       { return TRUE; }
  84
  85    /** The simplest way to initiate a dial up: this function dials the given
  86        ISP (exact meaning of the parameter depends on the platform), returns
  87        TRUE on success or FALSE on failure and logs the appropriate error
  88        message in the latter case.
  89        @param nameOfISP optional paramater for dial program
  90        @param username unused
  91        @param password unused
  92    */
  93    virtual bool Dial(const wxString& nameOfISP,
  94                      const wxString& WXUNUSED(username),
  95                      const wxString& WXUNUSED(password),
  96                      bool async);
  97
  98    /// Hang up the currently active dial up connection.
  99    virtual bool HangUp();
 100
 101    // returns TRUE if the computer is connected to the network: under Windows,
 102    // this just means that a RAS connection exists, under Unix we check that
 103    // the "well-known host" (as specified by SetWellKnownHost) is reachable
 104    virtual bool IsOnline() const
 105       {
 106          if( (! m_timer) // we are not polling, so test now:
 107              || m_IsOnline < 0
 108             )
 109             CheckStatus();
 110          return m_IsOnline != 0;
 111       }
 112
 113    /// do we have a constant net connection? -- GUESS!
 114    bool IsAlwaysOnline() const
 115       {
 116          ((wxDialUpManagerImpl *) this)->HangUp(); // brutal but necessary
 117          return IsOnline();
 118       }
 119    /// returns TRUE if (async) dialing is in progress
 120    inline virtual bool IsDialing() const
 121       { return m_DialProcess != NULL; }
 122
 123    // cancel dialing the number initiated with Dial(async = TRUE)
 124    // NB: this won't result in DISCONNECTED event being sent
 125    virtual bool CancelDialing();
 126
 127    size_t GetISPNames(class wxArrayString &) const
 128       { return 0; }
 129
 130    // sometimes the built-in logic for determining the online status may fail,
 131    // so, in general, the user should be allowed to override it. This function
 132    // allows to forcefully set the online status - whatever our internal
 133    // algorithm may think about it.
 134    virtual void SetOnlineStatus(bool isOnline = TRUE)
 135       { m_IsOnline = isOnline; }
 136
 137    // set misc wxDialUpManager options
 138    // --------------------------------
 139
 140    // enable automatical checks for the connection status and sending of
 141    // wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
 142    // parameter is only for Unix where we do the check manually: under
 143    // Windows, the notification about the change of connection status is
 144    // instantenous.
 145    //
 146    // Returns FALSE if couldn't set up automatic check for online status.
 147    virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
 148
 149    // disable automatic check for connection status change - notice that the
 150    // wxEVT_DIALUP_XXX events won't be sent any more neither.
 151    virtual void DisableAutoCheckOnlineStatus();
 152
 153    // under Unix, the value of well-known host is used to check whether we're
 154    // connected to the internet. It's unused under Windows, but this function
 155    // is always safe to call. The default value is www.yahoo.com.
 156    virtual void SetWellKnownHost(const wxString& hostname,
 157                                  int portno = 80);
 158    /** Sets the commands to start up the network and to hang up
 159        again. Used by the Unix implementations only.
 160    */
 161    virtual void SetConnectCommand(const wxString &command, const wxString &hupcmd)
 162       { m_ConnectCommand = command; m_HangUpCommand = hupcmd; }
 163
 164 private:
 165    /// -1: don´t know, 0 = no, 1 = yes
 166    int m_IsOnline;
 167
 168    ///  Can we use ifconfig to list active devices?
 169    int m_CanUseIfconfig;
 170    /// The path to ifconfig
 171    wxString m_IfconfigPath;
 172
 173    /// beacon host:
 174    wxString m_BeaconHost;
 175    /// beacon host portnumber for connect:
 176    int m_BeaconPort;
 177
 178    /// command to connect to network
 179    wxString m_ConnectCommand;
 180    /// command to hang up
 181    wxString m_HangUpCommand;
 182    /// name of ISP
 183    wxString m_ISPname;
 184    /// a timer for regular testing
 185    class AutoCheckTimer *m_timer;
 186    friend class AutoCheckTimer;
 187
 188    /// a wxProcess for dialling in background
 189    class wxDialProcess *m_DialProcess;
 190    /// pid of dial process
 191    int m_DialPId;
 192    friend class wxDialProcess;
 193
 194    /// determine status
 195    void CheckStatus(bool fromAsync = FALSE) const;
 196
 197    /// real status check
 198    void CheckStatusInternal(void);
 199 };
 200
 201
 202 class AutoCheckTimer : public wxTimer
 203 {
 204 public:
 205    AutoCheckTimer(wxDialUpManagerImpl *dupman)
 206       {
 207          m_dupman = dupman;
 208          m_started = FALSE;
 209       }
 210
 211    virtual bool Start( int millisecs = -1 )
 212       { m_started = TRUE; return wxTimer::Start(millisecs, FALSE); }
 213
 214    virtual void Notify()
 215       { wxLogTrace("Checking dial up network status."); m_dupman->CheckStatus(); }
 216
 217    virtual void Stop()
 218       { if ( m_started ) wxTimer::Stop(); }
 219 public:
 220    bool m_started;
 221    wxDialUpManagerImpl *m_dupman;
 222 };
 223
 224 class wxDialProcess : public wxProcess
 225 {
 226 public:
 227    wxDialProcess(wxDialUpManagerImpl *dupman)
 228       {
 229          m_DupMan = dupman;
 230       }
 231    void Disconnect(void) { m_DupMan = NULL; }
 232    void OnTerminate(int WXUNUSED(pid), int WXUNUSED(status)) const
 233       {
 234          if(m_DupMan)
 235          {
 236             m_DupMan->m_DialProcess = NULL;
 237             m_DupMan->CheckStatus(TRUE);
 238          }
 239       }
 240 private:
 241       wxDialUpManagerImpl *m_DupMan;
 242 };
 243
 244
 245 wxDialUpManagerImpl::wxDialUpManagerImpl()
 246 {
 247    m_IsOnline = -2; // -1 or -2, unknown
 248    m_DialProcess = NULL;
 249    m_timer = NULL;
 250    m_CanUseIfconfig = -1; // unknown
 251    m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
 252    m_BeaconPort = 80;
 253    SetConnectCommand("pon", "poff"); // default values for Debian/GNU linux
 254    wxChar * dial = wxGetenv(_T("WXDIALUP_DIALCMD"));
 255    wxChar * hup = wxGetenv(_T("WXDIALUP_HUPCMD"));
 256    if(dial || hup)
 257       SetConnectCommand(dial ? wxString(dial) : m_ConnectCommand,
 258                         hup ? wxString(hup) : m_HangUpCommand);
 259 }
 260
 261 wxDialUpManagerImpl::~wxDialUpManagerImpl()
 262 {
 263    if(m_timer) delete m_timer;
 264    if(m_DialProcess)
 265    {
 266       m_DialProcess->Disconnect();
 267       m_DialProcess->Detach();
 268    }
 269 }
 270
 271 bool
 272 wxDialUpManagerImpl::Dial(const wxString &isp,
 273                           const wxString & WXUNUSED(username),
 274                           const wxString & WXUNUSED(password),
 275                           bool async)
 276 {
 277    if(m_IsOnline == 1)
 278       return FALSE;
 279    m_IsOnline = -1;
 280    m_ISPname = isp;
 281    wxString cmd;
 282    if(m_ConnectCommand.Find("%s"))
 283       cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
 284    else
 285       cmd = m_ConnectCommand;
 286
 287    if ( async )
 288    {
 289       m_DialProcess = new wxDialProcess(this);
 290       m_DialPId = wxExecute(cmd, FALSE, m_DialProcess);
 291       if(m_DialPId == 0)
 292       {
 293          delete m_DialProcess;
 294          m_DialProcess = NULL;
 295          return FALSE;
 296       }
 297       else
 298          return TRUE;
 299    }
 300    else
 301        return wxExecute(cmd, /* sync */ TRUE) == 0;
 302 }
 303
 304 bool
 305 wxDialUpManagerImpl::HangUp(void)
 306 {
 307    if(m_IsOnline == 0)
 308       return FALSE;
 309    if(IsDialing())
 310    {
 311       wxLogError(_("Already dialling ISP."));
 312       return FALSE;
 313    }
 314    m_IsOnline = -1;
 315    wxString cmd;
 316    if(m_HangUpCommand.Find("%s"))
 317       cmd.Printf(m_HangUpCommand,m_ISPname.c_str(), m_DialProcess);
 318    else
 319       cmd = m_HangUpCommand;
 320    return wxExecute(cmd, /* sync */ TRUE) == 0;
 321 }
 322
 323
 324 bool
 325 wxDialUpManagerImpl::CancelDialing()
 326 {
 327    if(! IsDialing())
 328       return FALSE;
 329    return kill(m_DialPId, SIGTERM) > 0;
 330 }
 331
 332 bool
 333 wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
 334 {
 335    wxASSERT(m_timer == NULL);
 336    m_timer = new AutoCheckTimer(this);
 337    bool rc = m_timer->Start(nSeconds*1000);
 338    if(! rc)
 339    {
 340       delete m_timer;
 341       m_timer = NULL;
 342    }
 343    return rc;
 344 }
 345
 346 void
 347 wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
 348 {
 349    wxASSERT(m_timer != NULL);
 350    m_timer->Stop();
 351    delete m_timer;
 352    m_timer = NULL;
 353 }
 354
 355
 356 void
 357 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
 358 {
 359    /// does hostname contain a port number?
 360    wxString port = hostname.After(':');
 361    if(port.Length())
 362    {
 363       m_BeaconHost = hostname.Before(':');
 364       m_BeaconPort = atoi(port);
 365    }
 366    else
 367    {
 368       m_BeaconHost = hostname;
 369       m_BeaconPort = portno;
 370    }
 371 }
 372
 373
 374 void
 375 wxDialUpManagerImpl::CheckStatus(bool fromAsync) const
 376 {
 377    // This function calls the CheckStatusInternal() helper function
 378    // which is OS - specific and then sends the events.
 379
 380    int oldIsOnline = m_IsOnline;
 381    ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
 382
 383    // now send the events as appropriate:
 384    if(m_IsOnline != oldIsOnline && m_IsOnline != -1 && oldIsOnline != -2) // -2: first time!
 385    {
 386       wxDialUpEvent event(m_IsOnline, ! fromAsync);
 387       (void)wxTheApp->ProcessEvent(event);
 388    }
 389 }
 390
 391 /*
 392   We have three methods that we can use:
 393
 394   1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
 395      --> should be fast enough for regular polling
 396   2. test if we can reach the well known beacon host
 397      --> too slow for polling
 398   3. check /proc/net/dev on linux??
 399      This method should be preferred, if possible. Need to do more
 400      testing.
 401
 402 */
 403
 404 void
 405 wxDialUpManagerImpl::CheckStatusInternal(void)
 406 {
 407    m_IsOnline = -1;
 408
 409    // First time check for ifconfig location. We only use the variant
 410    // which does not take arguments, a la GNU.
 411    if(m_CanUseIfconfig == -1) // unknown
 412    {
 413       if(wxFileExists("/sbin/ifconfig"))
 414          m_IfconfigPath = "/sbin/ifconfig";
 415       else if(wxFileExists("/usr/sbin/ifconfig"))
 416          m_IfconfigPath = "/usr/sbin/ifconfig";
 417    }
 418
 419    wxLogNull ln; // suppress all error messages
 420    // Let´s try the ifconfig method first, should be fastest:
 421    if(m_CanUseIfconfig != 0) // unknown or yes
 422    {
 423       wxASSERT(m_IfconfigPath.length());
 424
 425       wxString tmpfile = wxGetTempFileName("_wxdialuptest");
 426       wxString cmd = "/bin/sh -c \'";
 427       cmd << m_IfconfigPath << " >" << tmpfile <<  '\'';
 428       /* I tried to add an option to wxExecute() to not close stdout,
 429          so we could let ifconfig write directly to the tmpfile, but
 430          this does not work. That should be faster, as it doesn´t call
 431          the shell first. I have no idea why. :-(  (KB) */
 432       if(wxExecute(cmd,TRUE /* sync */) == 0)
 433       {
 434          m_CanUseIfconfig = 1;
 435          wxFile file;
 436          if( file.Open(tmpfile) )
 437          {
 438             char *output = new char [file.Length()+1];
 439             output[file.Length()] = '\0';
 440             if(file.Read(output,file.Length()) == file.Length())
 441             {
 442                if(strstr(output,"ppp")   // ppp
 443                   || strstr(output,"sl") // slip
 444                   || strstr(output,"pl") // plip
 445                   )
 446                   m_IsOnline = 1;
 447                else
 448                   m_IsOnline = 0;
 449             }
 450             file.Close();
 451             delete [] output;
 452          }
 453          // else m_IsOnline remains -1 as we don't know for sure
 454       }
 455       else // could not run ifconfig correctly
 456          m_CanUseIfconfig = 0; // don´t try again
 457       (void) wxRemoveFile(tmpfile);
 458       if(m_IsOnline != -1) // we are done
 459          return;
 460    }
 461
 462    // this was supposed to work like ping(8), but doesn´t.
 463    // second method: try to connect to a well known host:
 464    // This can be used under Win 9x, too!
 465    struct hostent     *hp;
 466    struct sockaddr_in  serv_addr;
 467
 468    m_IsOnline = 0; // assume false
 469    if((hp = gethostbyname(m_BeaconHost)) == NULL)
 470       return; // no DNS no net
 471
 472    serv_addr.sin_family         = hp->h_addrtype;
 473    memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
 474    serv_addr.sin_port           = htons(m_BeaconPort);
 475
 476       // PING method:
 477
 478    int  sockfd;
 479    if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
 480    {
 481       //  sys_error("cannot create socket for gw");
 482       return;
 483    }
 484
 485 #if 0
 486    // this "ping" method does not work.
 487    if(sendto(sockfd, "hello",
 488              strlen("hello"), /* flags */ 0,
 489              (struct  sockaddr *) &serv_addr,
 490              sizeof(serv_addr)) == -1)
 491    {
 492       close(sockfd);
 493       return;
 494    }
 495 #endif
 496
 497    if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
 498    {
 499       //sys_error("cannot connect to server");
 500       close(sockfd);
 501       return;
 502    }
 503    //connected!
 504    close(sockfd);
 505    m_IsOnline = TRUE;
 506 }
 507
 508
 509 /* static */
 510 wxDialUpManager *
 511 wxDialUpManager::Create(void)
 512 {
 513    return new wxDialUpManagerImpl;
 514 }
 515
 516 #endif // wxUSE_DIALUP_MANAGER