src/unix/net.cpp

   1 // -*- c++ -*- ///////////////////////////////////////////////////////////////
   2 // Name:        unix/net.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 #if wxUSE_DIALUP_MANAGER
  15
  16 #ifndef  WX_PRECOMP
  17 #   include "wx/defs.h"
  18 #endif // !PCH
  19
  20 #include "wx/string.h"
  21 #include "wx/event.h"
  22 #include "wx/net.h"
  23 #include "wx/timer.h"
  24 #include "wx/filename.h"
  25 #include "wx/utils.h"
  26 #include "wx/log.h"
  27 #include "wx/file.h"
  28
  29 #include <stdlib.h>
  30 #include <signal.h>
  31 #include <fcntl.h>
  32 #include <unistd.h>
  33 #define __STRICT_ANSI__
  34 #include <sys/socket.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <netdb.h>
  38 #include <netinet/in.h>
  39 #include <arpa/inet.h>
  40
  41 // ----------------------------------------------------------------------------
  42 // A class which groups functions dealing with connecting to the network from a
  43 // workstation using dial-up access to the net. There is at most one instance
  44 // of this class in the program accessed via GetDialUpManager().
  45 // ----------------------------------------------------------------------------
  46
  47 /* TODO
  48  *
  49  * 1. more configurability for Unix: i.e. how to initiate the connection, how
  50  *    to check for online status, &c.
  51  * 2. add a "long Dial(long connectionId = -1)" function which asks the user
  52  *    about which connection to dial (this may be done using native dialogs
  53  *    under NT, need generic dialogs for all others) and returns the identifier
  54  *    of the selected connection (it's opaque to the application) - it may be
  55  *    reused later to dial the same connection later (or use strings instead of
  56  *    longs may be?)
  57  * 3. add an async version of dialing functions which notify the caller about
  58  *    the progress (or may be even start another thread to monitor it)
  59  * 4. the static creation/accessor functions are not MT-safe - but is this
  60  *    really crucial? I think we may suppose they're always called from the
  61  *    main thread?
  62  */
  63
  64 class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
  65 {
  66 public:
  67    wxDialUpManagerImpl()
  68       {
  69          m_IsOnline = -1; // unknown
  70          m_timer = NULL;
  71          m_CanUseIfconfig = -1; // unknown
  72          m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
  73          m_BeaconPort = 80;
  74       }
  75
  76    /** Could the dialup manager be initialized correctly? If this function
  77        returns FALSE, no other functions will work neither, so it's a good idea
  78        to call this function and check its result before calling any other
  79        wxDialUpManager methods.
  80    */
  81    virtual bool IsOk() const
  82       { return true; }
  83
  84    /** The simplest way to initiate a dial up: this function dials the given
  85        ISP (exact meaning of the parameter depends on the platform), returns
  86        TRUE on success or FALSE on failure and logs the appropriate error
  87        message in the latter case.
  88        @param nameOfISP optional paramater for dial program
  89        @param username unused
  90        @param password unused
  91    */
  92    virtual bool Dial(const wxString& nameOfISP,
  93                      const wxString& WXUNUSED(username),
  94                      const wxString& WXUNUSED(password));
  95
  96    /// Hang up the currently active dial up connection.
  97    virtual bool HangUp();
  98
  99    // returns TRUE if the computer is connected to the network: under Windows,
 100    // this just means that a RAS connection exists, under Unix we check that
 101    // the "well-known host" (as specified by SetWellKnownHost) is reachable
 102    virtual bool IsOnline() const
 103       {
 104          if( (! m_timer) // we are not polling, so test now:
 105              || m_IsOnline == -1
 106             )
 107             CheckStatus();
 108          return m_IsOnline != 0;
 109       }
 110
 111    // sometimes the built-in logic for determining the online status may fail,
 112    // so, in general, the user should be allowed to override it. This function
 113    // allows to forcefully set the online status - whatever our internal
 114    // algorithm may think about it.
 115    virtual void SetOnlineStatus(bool isOnline = true)
 116       { m_IsOnline = isOnline; }
 117
 118    // set misc wxDialUpManager options
 119    // --------------------------------
 120
 121    // enable automatical checks for the connection status and sending of
 122    // wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
 123    // parameter is only for Unix where we do the check manually: under
 124    // Windows, the notification about the change of connection status is
 125    // instantenous.
 126    //
 127    // Returns FALSE if couldn't set up automatic check for online status.
 128    virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
 129
 130    // disable automatic check for connection status change - notice that the
 131    // wxEVT_DIALUP_XXX events won't be sent any more neither.
 132    virtual void DisableAutoCheckOnlineStatus();
 133
 134    // under Unix, the value of well-known host is used to check whether we're
 135    // connected to the internet. It's unused under Windows, but this function
 136    // is always safe to call. The default value is www.yahoo.com.
 137    virtual void SetWellKnownHost(const wxString& hostname,
 138                                  int portno = 80);
 139    /** Sets the commands to start up the network and to hang up
 140        again. Used by the Unix implementations only.
 141    */
 142    virtual void SetConnectCommand(const wxString &command, const wxString &hupcmd)
 143       { m_ConnectCommand = command; m_HangUpCommand = hupcmd; }
 144
 145 private:
 146    /// -1: don't know, 0 = no, 1 = yes
 147    int m_IsOnline;
 148
 149    ///  Can we use ifconfig to list active devices?
 150    int m_CanUseIfconfig;
 151    /// The path to ifconfig
 152    wxString m_IfconfigPath;
 153
 154    /// beacon host:
 155    wxString m_BeaconHost;
 156    /// beacon host portnumber for connect:
 157    int m_BeaconPort;
 158
 159    /// command to connect to network
 160    wxString m_ConnectCommand;
 161    /// command to hang up
 162    wxString m_HangUpCommand;
 163    /// name of ISP
 164    wxString m_ISPname;
 165    /// a timer for regular testing
 166    class AutoCheckTimer *m_timer;
 167
 168    friend class AutoCheckTimer;
 169    /// determine status
 170    void CheckStatus(void) const;
 171
 172    /// real status check
 173    void CheckStatusInternal(void);
 174 };
 175
 176
 177 class AutoCheckTimer : public wxTimer
 178 {
 179 public:
 180    AutoCheckTimer(wxDialUpManagerImpl *dupman)
 181       {
 182          m_dupman = dupman;
 183          m_started = false;
 184       }
 185
 186    virtual bool Start( int millisecs = -1 )
 187       { m_started = true; return wxTimer::Start(millisecs, false); }
 188
 189    virtual void Notify()
 190       { wxLogTrace("Checking dial up network status."); m_dupman->CheckStatus(); }
 191
 192    virtual void Stop()
 193       { if ( m_started ) wxTimer::Stop(); }
 194 public:
 195    bool m_started;
 196    wxDialUpManagerImpl *m_dupman;
 197 };
 198
 199 bool
 200 wxDialUpManagerImpl::Dial(const wxString &isp,
 201                           const wxString & WXUNUSED(username),
 202                           const wxString & WXUNUSED(password))
 203 {
 204    if(m_IsOnline == 1)
 205       return false;
 206    m_IsOnline = -1;
 207    m_ISPname = isp;
 208    wxString cmd;
 209    if(m_ConnectCommand.Find("%s"))
 210       cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
 211    else
 212       cmd = m_ConnectCommand;
 213    return wxExecute(cmd, /* sync */ TRUE) == 0;
 214 }
 215
 216 bool
 217 wxDialUpManagerImpl::HangUp(void)
 218 {
 219    if(m_IsOnline == 0)
 220       return false;
 221    m_IsOnline = -1;
 222    wxString cmd;
 223    if(m_HangUpCommand.Find("%s"))
 224       cmd.Printf(m_HangUpCommand,m_ISPname.c_str());
 225    else
 226       cmd = m_HangUpCommand;
 227    return wxExecute(cmd, /* sync */ TRUE) == 0;
 228 }
 229
 230
 231 bool
 232 wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
 233 {
 234    wxASSERT(m_timer == NULL);
 235    m_timer = new AutoCheckTimer(this);
 236    bool rc = m_timer->Start(nSeconds*1000);
 237    if(! rc)
 238    {
 239       wxDELETE(m_timer);
 240    }
 241    return rc;
 242 }
 243
 244 void
 245 wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
 246 {
 247    wxASSERT(m_timer != NULL);
 248    m_timer->Stop();
 249    wxDELETE(m_timer);
 250 }
 251
 252
 253 void
 254 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
 255 {
 256    /// does hostname contain a port number?
 257    wxString port = hostname.After(':');
 258    if(port.Length())
 259    {
 260       m_BeaconHost = hostname.Before(':');
 261       m_BeaconPort = atoi(port);
 262    }
 263    else
 264    {
 265       m_BeaconHost = hostname;
 266       m_BeaconPort = portno;
 267    }
 268 }
 269
 270
 271 void
 272 wxDialUpManagerImpl::CheckStatus(void) const
 273 {
 274    // This function calls the CheckStatusInternal() helper function
 275    // which is OS - specific and then sends the events.
 276
 277    int oldIsOnline = m_IsOnline;
 278    ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
 279
 280    // now send the events as appropriate:
 281    if(m_IsOnline != oldIsOnline)
 282    {
 283       if(m_IsOnline)
 284          ; // send ev
 285       else
 286          ; // send ev
 287    }
 288 }
 289
 290 /*
 291   We have three methods that we can use:
 292
 293   1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
 294      --> should be fast enough for regular polling
 295   2. test if we can reach the well known beacon host
 296      --> too slow for polling
 297   3. check /proc/net/dev on linux??
 298      This method should be preferred, if possible. Need to do more
 299      testing.
 300
 301 */
 302
 303 void
 304 wxDialUpManagerImpl::CheckStatusInternal(void)
 305 {
 306    m_IsOnline = -1;
 307
 308    // First time check for ifconfig location. We only use the variant
 309    // which does not take arguments, a la GNU.
 310    if(m_CanUseIfconfig == -1) // unknown
 311    {
 312       if(wxFileExists("/sbin/ifconfig"))
 313          m_IfconfigPath = "/sbin/ifconfig";
 314       else if(wxFileExists("/usr/sbin/ifconfig"))
 315          m_IfconfigPath = "/usr/sbin/ifconfig";
 316    }
 317
 318    wxLogNull ln; // suppress all error messages
 319    // Let's try the ifconfig method first, should be fastest:
 320    if(m_CanUseIfconfig != 0) // unknown or yes
 321    {
 322       wxASSERT(m_IfconfigPath.length());
 323
 324       wxString tmpfile = wxFileName::CreateTempFileName("_wxdialuptest");
 325       wxString cmd = "/bin/sh -c \'";
 326       cmd << m_IfconfigPath << " >" << tmpfile <<  '\'';
 327       /* I tried to add an option to wxExecute() to not close stdout,
 328          so we could let ifconfig write directly to the tmpfile, but
 329          this does not work. That should be faster, as it doesn't call
 330          the shell first. I have no idea why. :-(  (KB) */
 331 #if 0
 332       // temporarily redirect stdout/stderr:
 333       int
 334          new_stdout = dup(STDOUT_FILENO),
 335          new_stderr = dup(STDERR_FILENO);
 336       close(STDOUT_FILENO);
 337       close(STDERR_FILENO);
 338
 339       int
 340          // new stdout:
 341          output_fd = open(tmpfile, O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR),
 342          // new stderr:
 343          null_fd = open("/dev/null", O_CREAT, S_IRUSR|S_IWUSR);
 344       // verify well behaved unix behaviour:
 345       wxASSERT(output_fd == STDOUT_FILENO);
 346       wxASSERT(null_fd == STDERR_FILENO);
 347       int rc = wxExecute(m_IfconfigPath,TRUE /* sync */,NULL ,wxEXECUTE_DONT_CLOSE_FDS);
 348       close(null_fd); close(output_fd);
 349       // restore old stdout, stderr:
 350       int test;
 351       test = dup(new_stdout); close(new_stdout); wxASSERT(test == STDOUT_FILENO);
 352       test = dup(new_stderr); close(new_stderr); wxASSERT(test == STDERR_FILENO);
 353       if(rc == 0)
 354 #endif
 355       if(wxExecute(cmd,TRUE /* sync */) == 0)
 356       {
 357          m_CanUseIfconfig = 1;
 358          wxFile file;
 359          if( file.Open(tmpfile) )
 360          {
 361             char *output = new char [file.Length()+1];
 362             output[file.Length()] = '\0';
 363             if(file.Read(output,file.Length()) == file.Length())
 364             {
 365                if(strstr(output,"ppp")   // ppp
 366                   || strstr(output,"sl") // slip
 367                   || strstr(output,"pl") // plip
 368                   )
 369                   m_IsOnline = 1;
 370                else
 371                   m_IsOnline = 0;
 372             }
 373             file.Close();
 374             delete [] output;
 375          }
 376          // else m_IsOnline remains -1 as we don't know for sure
 377       }
 378       else // could not run ifconfig correctly
 379          m_CanUseIfconfig = 0; // don't try again
 380       (void) wxRemoveFile(tmpfile);
 381       if(m_IsOnline != -1) // we are done
 382          return;
 383    }
 384
 385    // second method: try to connect to well known host:
 386    // This can be used under Win 9x, too!
 387    struct hostent     *hp;
 388    struct sockaddr_in  serv_addr;
 389    int sockfd;
 390
 391    m_IsOnline = 0; // assume false
 392    if((hp = gethostbyname(m_BeaconHost)) == NULL)
 393       return; // no DNS no net
 394
 395    serv_addr.sin_family = hp->h_addrtype;
 396    memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
 397    serv_addr.sin_port = htons(m_BeaconPort);
 398    if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
 399    {
 400       //  sys_error("cannot create socket for gw");
 401       return;
 402    }
 403    if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
 404    {
 405       //sys_error("cannot connect to server");
 406       return;
 407    }
 408    //connected!
 409    close(sockfd);
 410 }
 411
 412
 413 /* static */
 414 wxDialUpManager *
 415 wxDialUpManager::wxDialUpManager::Create(void)
 416 {
 417    return new wxDialUpManagerImpl;
 418 }
 419
 420 #endif // wxUSE_DIALUP_MANAGER