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, bool WXUNUSED(one_shot) = FALSE )
 212       { m_started = TRUE; return wxTimer::Start(millisecs, FALSE); }
 213
 214    virtual void Notify()
 215       { wxLogTrace(wxT("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    virtual void OnTerminate(int WXUNUSED(pid), int WXUNUSED(status))
 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 #if 0
 255    wxChar * dial = wxGetenv(_T("WXDIALUP_DIALCMD"));
 256    wxChar * hup = wxGetenv(_T("WXDIALUP_HUPCMD"));
 257    if(dial || hup)
 258       SetConnectCommand(dial ? wxString(dial) : m_ConnectCommand,
 259                         hup ? wxString(hup) : m_HangUpCommand);
 260 #endif
 261 }
 262
 263 wxDialUpManagerImpl::~wxDialUpManagerImpl()
 264 {
 265    if(m_timer) delete m_timer;
 266    if(m_DialProcess)
 267    {
 268       m_DialProcess->Disconnect();
 269       m_DialProcess->Detach();
 270    }
 271 }
 272
 273 bool
 274 wxDialUpManagerImpl::Dial(const wxString &isp,
 275                           const wxString & WXUNUSED(username),
 276                           const wxString & WXUNUSED(password),
 277                           bool async)
 278 {
 279    if(m_IsOnline == 1)
 280       return FALSE;
 281    m_IsOnline = -1;
 282    m_ISPname = isp;
 283    wxString cmd;
 284    if(m_ConnectCommand.Find(wxT("%s")))
 285       cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
 286    else
 287       cmd = m_ConnectCommand;
 288
 289    if ( async )
 290    {
 291       m_DialProcess = new wxDialProcess(this);
 292       m_DialPId = wxExecute(cmd, FALSE, m_DialProcess);
 293       if(m_DialPId == 0)
 294       {
 295          delete m_DialProcess;
 296          m_DialProcess = NULL;
 297          return FALSE;
 298       }
 299       else
 300          return TRUE;
 301    }
 302    else
 303        return wxExecute(cmd, /* sync */ TRUE) == 0;
 304 }
 305
 306 bool
 307 wxDialUpManagerImpl::HangUp(void)
 308 {
 309    if(m_IsOnline == 0)
 310       return FALSE;
 311    if(IsDialing())
 312    {
 313       wxLogError(_("Already dialling ISP."));
 314       return FALSE;
 315    }
 316    m_IsOnline = -1;
 317    wxString cmd;
 318    if(m_HangUpCommand.Find(wxT("%s")))
 319       cmd.Printf(m_HangUpCommand,m_ISPname.c_str(), m_DialProcess);
 320    else
 321       cmd = m_HangUpCommand;
 322    return wxExecute(cmd, /* sync */ TRUE) == 0;
 323 }
 324
 325
 326 bool
 327 wxDialUpManagerImpl::CancelDialing()
 328 {
 329    if(! IsDialing())
 330       return FALSE;
 331    return kill(m_DialPId, SIGTERM) > 0;
 332 }
 333
 334 bool
 335 wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
 336 {
 337    DisableAutoCheckOnlineStatus();
 338    m_timer = new AutoCheckTimer(this);
 339    bool rc = m_timer->Start(nSeconds*1000);
 340    if(! rc)
 341    {
 342       delete m_timer;
 343       m_timer = NULL;
 344    }
 345    return rc;
 346 }
 347
 348 void
 349 wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
 350 {
 351    if(m_timer != NULL)
 352    {
 353       m_timer->Stop();
 354       delete m_timer;
 355       m_timer = NULL;
 356    }
 357 }
 358
 359
 360 void
 361 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
 362 {
 363    /// does hostname contain a port number?
 364    wxString port = hostname.After(wxT(':'));
 365    if(port.Length())
 366    {
 367       m_BeaconHost = hostname.Before(wxT(':'));
 368       m_BeaconPort = wxAtoi(port);
 369    }
 370    else
 371    {
 372       m_BeaconHost = hostname;
 373       m_BeaconPort = portno;
 374    }
 375 }
 376
 377
 378 void
 379 wxDialUpManagerImpl::CheckStatus(bool fromAsync) const
 380 {
 381    // This function calls the CheckStatusInternal() helper function
 382    // which is OS - specific and then sends the events.
 383
 384    int oldIsOnline = m_IsOnline;
 385    ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
 386
 387    // now send the events as appropriate:
 388    if(m_IsOnline != oldIsOnline && m_IsOnline != -1 && oldIsOnline != -2) // -2: first time!
 389    {
 390       wxDialUpEvent event(m_IsOnline, ! fromAsync);
 391       (void)wxTheApp->ProcessEvent(event);
 392    }
 393 }
 394
 395 /*
 396   We have three methods that we can use:
 397
 398   1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
 399      --> should be fast enough for regular polling
 400   2. test if we can reach the well known beacon host
 401      --> too slow for polling
 402   3. check /proc/net/dev on linux??
 403      This method should be preferred, if possible. Need to do more
 404      testing.
 405
 406 */
 407
 408 void
 409 wxDialUpManagerImpl::CheckStatusInternal(void)
 410 {
 411    m_IsOnline = -1;
 412
 413    // First time check for ifconfig location. We only use the variant
 414    // which does not take arguments, a la GNU.
 415    if(m_CanUseIfconfig == -1) // unknown
 416    {
 417       if(wxFileExists("/sbin/ifconfig"))
 418          m_IfconfigPath = "/sbin/ifconfig";
 419       else if(wxFileExists("/usr/sbin/ifconfig"))
 420          m_IfconfigPath = "/usr/sbin/ifconfig";
 421    }
 422
 423    wxLogNull ln; // suppress all error messages
 424    // Let´s try the ifconfig method first, should be fastest:
 425    if(m_CanUseIfconfig != 0) // unknown or yes
 426    {
 427       wxASSERT(m_IfconfigPath.length());
 428
 429       wxString tmpfile = wxGetTempFileName("_wxdialuptest");
 430       wxString cmd = "/bin/sh -c \'";
 431       cmd << m_IfconfigPath << " >" << tmpfile <<  '\'';
 432       /* I tried to add an option to wxExecute() to not close stdout,
 433          so we could let ifconfig write directly to the tmpfile, but
 434          this does not work. That should be faster, as it doesn´t call
 435          the shell first. I have no idea why. :-(  (KB) */
 436       if(wxExecute(cmd,TRUE /* sync */) == 0)
 437       {
 438          m_CanUseIfconfig = 1;
 439          wxFile file;
 440          if( file.Open(tmpfile) )
 441          {
 442             char *output = new char [file.Length()+1];
 443             output[file.Length()] = '\0';
 444             if(file.Read(output,file.Length()) == file.Length())
 445             {
 446                if(strstr(output,"ppp")   // ppp
 447                   || strstr(output,"sl") // slip
 448                   || strstr(output,"pl") // plip
 449                   )
 450                   m_IsOnline = 1;
 451                else
 452                   m_IsOnline = 0;
 453             }
 454             file.Close();
 455             delete [] output;
 456          }
 457          // else m_IsOnline remains -1 as we don't know for sure
 458       }
 459       else // could not run ifconfig correctly
 460          m_CanUseIfconfig = 0; // don´t try again
 461       (void) wxRemoveFile(tmpfile);
 462       if(m_IsOnline != -1) // we are done
 463          return;
 464    }
 465
 466    // this was supposed to work like ping(8), but doesn´t.
 467    // second method: try to connect to a well known host:
 468    // This can be used under Win 9x, too!
 469    struct hostent     *hp;
 470    struct sockaddr_in  serv_addr;
 471
 472    m_IsOnline = 0; // assume false
 473    if((hp = gethostbyname(m_BeaconHost.mb_str())) == NULL)
 474       return; // no DNS no net
 475
 476    serv_addr.sin_family         = hp->h_addrtype;
 477    memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
 478    serv_addr.sin_port           = htons(m_BeaconPort);
 479
 480       // PING method:
 481
 482    int  sockfd;
 483    if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
 484    {
 485       //  sys_error("cannot create socket for gw");
 486       return;
 487    }
 488
 489 #if 0
 490    // this "ping" method does not work.
 491    if(sendto(sockfd, "hello",
 492              strlen("hello"), /* flags */ 0,
 493              (struct  sockaddr *) &serv_addr,
 494              sizeof(serv_addr)) == -1)
 495    {
 496       close(sockfd);
 497       return;
 498    }
 499 #endif
 500
 501    if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
 502    {
 503       //sys_error("cannot connect to server");
 504       close(sockfd);
 505       return;
 506    }
 507    //connected!
 508    close(sockfd);
 509    m_IsOnline = TRUE;
 510 }
 511
 512
 513 /* static */
 514 wxDialUpManager *
 515 wxDialUpManager::Create(void)
 516 {
 517    return new wxDialUpManagerImpl;
 518 }
 519
 520 #endif // wxUSE_DIALUP_MANAGER