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    if(m_timer != NULL)
 350    {
 351       m_timer->Stop();
 352       delete m_timer;
 353       m_timer = NULL;
 354    }
 355 }
 356
 357
 358 void
 359 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
 360 {
 361    /// does hostname contain a port number?
 362    wxString port = hostname.After(':');
 363    if(port.Length())
 364    {
 365       m_BeaconHost = hostname.Before(':');
 366       m_BeaconPort = atoi(port);
 367    }
 368    else
 369    {
 370       m_BeaconHost = hostname;
 371       m_BeaconPort = portno;
 372    }
 373 }
 374
 375
 376 void
 377 wxDialUpManagerImpl::CheckStatus(bool fromAsync) const
 378 {
 379    // This function calls the CheckStatusInternal() helper function
 380    // which is OS - specific and then sends the events.
 381
 382    int oldIsOnline = m_IsOnline;
 383    ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
 384
 385    // now send the events as appropriate:
 386    if(m_IsOnline != oldIsOnline && m_IsOnline != -1 && oldIsOnline != -2) // -2: first time!
 387    {
 388       wxDialUpEvent event(m_IsOnline, ! fromAsync);
 389       (void)wxTheApp->ProcessEvent(event);
 390    }
 391 }
 392
 393 /*
 394   We have three methods that we can use:
 395
 396   1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
 397      --> should be fast enough for regular polling
 398   2. test if we can reach the well known beacon host
 399      --> too slow for polling
 400   3. check /proc/net/dev on linux??
 401      This method should be preferred, if possible. Need to do more
 402      testing.
 403
 404 */
 405
 406 void
 407 wxDialUpManagerImpl::CheckStatusInternal(void)
 408 {
 409    m_IsOnline = -1;
 410
 411    // First time check for ifconfig location. We only use the variant
 412    // which does not take arguments, a la GNU.
 413    if(m_CanUseIfconfig == -1) // unknown
 414    {
 415       if(wxFileExists("/sbin/ifconfig"))
 416          m_IfconfigPath = "/sbin/ifconfig";
 417       else if(wxFileExists("/usr/sbin/ifconfig"))
 418          m_IfconfigPath = "/usr/sbin/ifconfig";
 419    }
 420
 421    wxLogNull ln; // suppress all error messages
 422    // Let´s try the ifconfig method first, should be fastest:
 423    if(m_CanUseIfconfig != 0) // unknown or yes
 424    {
 425       wxASSERT(m_IfconfigPath.length());
 426
 427       wxString tmpfile = wxGetTempFileName("_wxdialuptest");
 428       wxString cmd = "/bin/sh -c \'";
 429       cmd << m_IfconfigPath << " >" << tmpfile <<  '\'';
 430       /* I tried to add an option to wxExecute() to not close stdout,
 431          so we could let ifconfig write directly to the tmpfile, but
 432          this does not work. That should be faster, as it doesn´t call
 433          the shell first. I have no idea why. :-(  (KB) */
 434       if(wxExecute(cmd,TRUE /* sync */) == 0)
 435       {
 436          m_CanUseIfconfig = 1;
 437          wxFile file;
 438          if( file.Open(tmpfile) )
 439          {
 440             char *output = new char [file.Length()+1];
 441             output[file.Length()] = '\0';
 442             if(file.Read(output,file.Length()) == file.Length())
 443             {
 444                if(strstr(output,"ppp")   // ppp
 445                   || strstr(output,"sl") // slip
 446                   || strstr(output,"pl") // plip
 447                   )
 448                   m_IsOnline = 1;
 449                else
 450                   m_IsOnline = 0;
 451             }
 452             file.Close();
 453             delete [] output;
 454          }
 455          // else m_IsOnline remains -1 as we don't know for sure
 456       }
 457       else // could not run ifconfig correctly
 458          m_CanUseIfconfig = 0; // don´t try again
 459       (void) wxRemoveFile(tmpfile);
 460       if(m_IsOnline != -1) // we are done
 461          return;
 462    }
 463
 464    // this was supposed to work like ping(8), but doesn´t.
 465    // second method: try to connect to a well known host:
 466    // This can be used under Win 9x, too!
 467    struct hostent     *hp;
 468    struct sockaddr_in  serv_addr;
 469
 470    m_IsOnline = 0; // assume false
 471    if((hp = gethostbyname(m_BeaconHost)) == NULL)
 472       return; // no DNS no net
 473
 474    serv_addr.sin_family         = hp->h_addrtype;
 475    memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
 476    serv_addr.sin_port           = htons(m_BeaconPort);
 477
 478       // PING method:
 479
 480    int  sockfd;
 481    if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
 482    {
 483       //  sys_error("cannot create socket for gw");
 484       return;
 485    }
 486
 487 #if 0
 488    // this "ping" method does not work.
 489    if(sendto(sockfd, "hello",
 490              strlen("hello"), /* flags */ 0,
 491              (struct  sockaddr *) &serv_addr,
 492              sizeof(serv_addr)) == -1)
 493    {
 494       close(sockfd);
 495       return;
 496    }
 497 #endif
 498
 499    if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
 500    {
 501       //sys_error("cannot connect to server");
 502       close(sockfd);
 503       return;
 504    }
 505    //connected!
 506    close(sockfd);
 507    m_IsOnline = TRUE;
 508 }
 509
 510
 511 /* static */
 512 wxDialUpManager *
 513 wxDialUpManager::Create(void)
 514 {
 515    return new wxDialUpManagerImpl;
 516 }
 517
 518 #endif // wxUSE_DIALUP_MANAGER