275abf24e1
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3805 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
423 lines
13 KiB
C++
423 lines
13 KiB
C++
// -*- c++ -*- ///////////////////////////////////////////////////////////////
|
||
// Name: unix/net.cpp
|
||
// Purpose: Network related wxWindows classes and functions
|
||
// Author: Karsten Ballüder
|
||
// Modified by:
|
||
// Created: 03.10.99
|
||
// RCS-ID: $Id$
|
||
// Copyright: (c) Karsten Ballüder
|
||
// Licence: wxWindows licence
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
|
||
#include "wx/setup.h"
|
||
|
||
#if wxUSE_DIALUP_MANAGER
|
||
|
||
#ifndef WX_PRECOMP
|
||
# include "wx/defs.h"
|
||
#endif // !PCH
|
||
|
||
#include "wx/string.h"
|
||
#include "wx/event.h"
|
||
#include "wx/net.h"
|
||
#include "wx/timer.h"
|
||
#include "wx/filefn.h"
|
||
#include "wx/utils.h"
|
||
#include "wx/log.h"
|
||
#include "wx/file.h"
|
||
|
||
#include <stdlib.h>
|
||
#include <signal.h>
|
||
#include <fcntl.h>
|
||
#include <unistd.h>
|
||
#define __STRICT_ANSI__
|
||
#include <sys/socket.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <netdb.h>
|
||
#include <netinet/in.h>
|
||
#include <arpa/inet.h>
|
||
|
||
// ----------------------------------------------------------------------------
|
||
// A class which groups functions dealing with connecting to the network from a
|
||
// workstation using dial-up access to the net. There is at most one instance
|
||
// of this class in the program accessed via GetDialUpManager().
|
||
// ----------------------------------------------------------------------------
|
||
|
||
/* TODO
|
||
*
|
||
* 1. more configurability for Unix: i.e. how to initiate the connection, how
|
||
* to check for online status, &c.
|
||
* 2. add a "long Dial(long connectionId = -1)" function which asks the user
|
||
* about which connection to dial (this may be done using native dialogs
|
||
* under NT, need generic dialogs for all others) and returns the identifier
|
||
* of the selected connection (it's opaque to the application) - it may be
|
||
* reused later to dial the same connection later (or use strings instead of
|
||
* longs may be?)
|
||
* 3. add an async version of dialing functions which notify the caller about
|
||
* the progress (or may be even start another thread to monitor it)
|
||
* 4. the static creation/accessor functions are not MT-safe - but is this
|
||
* really crucial? I think we may suppose they're always called from the
|
||
* main thread?
|
||
*/
|
||
|
||
class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
|
||
{
|
||
public:
|
||
wxDialUpManagerImpl()
|
||
{
|
||
m_IsOnline = -1; // unknown
|
||
m_timer = NULL;
|
||
m_CanUseIfconfig = -1; // unknown
|
||
m_BeaconHost = WXDIALUP_MANAGER_DEFAULT_BEACONHOST;
|
||
m_BeaconPort = 80;
|
||
}
|
||
|
||
/** Could the dialup manager be initialized correctly? If this function
|
||
returns FALSE, no other functions will work neither, so it's a good idea
|
||
to call this function and check its result before calling any other
|
||
wxDialUpManager methods.
|
||
*/
|
||
virtual bool IsOk() const
|
||
{ return TRUE; }
|
||
|
||
/** The simplest way to initiate a dial up: this function dials the given
|
||
ISP (exact meaning of the parameter depends on the platform), returns
|
||
TRUE on success or FALSE on failure and logs the appropriate error
|
||
message in the latter case.
|
||
@param nameOfISP optional paramater for dial program
|
||
@param username unused
|
||
@param password unused
|
||
*/
|
||
virtual bool Dial(const wxString& nameOfISP,
|
||
const wxString& WXUNUSED(username),
|
||
const wxString& WXUNUSED(password));
|
||
|
||
/// Hang up the currently active dial up connection.
|
||
virtual bool HangUp();
|
||
|
||
// returns TRUE if the computer is connected to the network: under Windows,
|
||
// this just means that a RAS connection exists, under Unix we check that
|
||
// the "well-known host" (as specified by SetWellKnownHost) is reachable
|
||
virtual bool IsOnline() const
|
||
{
|
||
if( (! m_timer) // we are not polling, so test now:
|
||
|| m_IsOnline == -1
|
||
)
|
||
CheckStatus();
|
||
return m_IsOnline != 0;
|
||
}
|
||
|
||
// sometimes the built-in logic for determining the online status may fail,
|
||
// so, in general, the user should be allowed to override it. This function
|
||
// allows to forcefully set the online status - whatever our internal
|
||
// algorithm may think about it.
|
||
virtual void SetOnlineStatus(bool isOnline = TRUE)
|
||
{ m_IsOnline = isOnline; }
|
||
|
||
// set misc wxDialUpManager options
|
||
// --------------------------------
|
||
|
||
// enable automatical checks for the connection status and sending of
|
||
// wxEVT_DIALUP_CONNECTED/wxEVT_DIALUP_DISCONNECTED events. The interval
|
||
// parameter is only for Unix where we do the check manually: under
|
||
// Windows, the notification about the change of connection status is
|
||
// instantenous.
|
||
//
|
||
// Returns FALSE if couldn't set up automatic check for online status.
|
||
virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
|
||
|
||
// disable automatic check for connection status change - notice that the
|
||
// wxEVT_DIALUP_XXX events won't be sent any more neither.
|
||
virtual void DisableAutoCheckOnlineStatus();
|
||
|
||
// under Unix, the value of well-known host is used to check whether we're
|
||
// connected to the internet. It's unused under Windows, but this function
|
||
// is always safe to call. The default value is www.yahoo.com.
|
||
virtual void SetWellKnownHost(const wxString& hostname,
|
||
int portno = 80);
|
||
/** Sets the commands to start up the network and to hang up
|
||
again. Used by the Unix implementations only.
|
||
*/
|
||
virtual void SetConnectCommand(const wxString &command, const wxString &hupcmd)
|
||
{ m_ConnectCommand = command; m_HangUpCommand = hupcmd; }
|
||
|
||
private:
|
||
/// -1: don´t know, 0 = no, 1 = yes
|
||
int m_IsOnline;
|
||
|
||
/// Can we use ifconfig to list active devices?
|
||
int m_CanUseIfconfig;
|
||
/// The path to ifconfig
|
||
wxString m_IfconfigPath;
|
||
|
||
/// beacon host:
|
||
wxString m_BeaconHost;
|
||
/// beacon host portnumber for connect:
|
||
int m_BeaconPort;
|
||
|
||
/// command to connect to network
|
||
wxString m_ConnectCommand;
|
||
/// command to hang up
|
||
wxString m_HangUpCommand;
|
||
/// name of ISP
|
||
wxString m_ISPname;
|
||
/// a timer for regular testing
|
||
class AutoCheckTimer *m_timer;
|
||
|
||
friend class AutoCheckTimer;
|
||
/// determine status
|
||
void CheckStatus(void) const;
|
||
|
||
/// real status check
|
||
void CheckStatusInternal(void);
|
||
};
|
||
|
||
|
||
class AutoCheckTimer : public wxTimer
|
||
{
|
||
public:
|
||
AutoCheckTimer(wxDialUpManagerImpl *dupman)
|
||
{
|
||
m_dupman = dupman;
|
||
m_started = FALSE;
|
||
}
|
||
|
||
virtual bool Start( int millisecs = -1 )
|
||
{ m_started = TRUE; return wxTimer::Start(millisecs, FALSE); }
|
||
|
||
virtual void Notify()
|
||
{ wxLogTrace("Checking dial up network status."); m_dupman->CheckStatus(); }
|
||
|
||
virtual void Stop()
|
||
{ if ( m_started ) wxTimer::Stop(); }
|
||
public:
|
||
bool m_started;
|
||
wxDialUpManagerImpl *m_dupman;
|
||
};
|
||
|
||
bool
|
||
wxDialUpManagerImpl::Dial(const wxString &isp,
|
||
const wxString & WXUNUSED(username),
|
||
const wxString & WXUNUSED(password))
|
||
{
|
||
if(m_IsOnline == 1)
|
||
return FALSE;
|
||
m_IsOnline = -1;
|
||
m_ISPname = isp;
|
||
wxString cmd;
|
||
if(m_ConnectCommand.Find("%s"))
|
||
cmd.Printf(m_ConnectCommand,m_ISPname.c_str());
|
||
else
|
||
cmd = m_ConnectCommand;
|
||
return wxExecute(cmd, /* sync */ TRUE) == 0;
|
||
}
|
||
|
||
bool
|
||
wxDialUpManagerImpl::HangUp(void)
|
||
{
|
||
if(m_IsOnline == 0)
|
||
return FALSE;
|
||
m_IsOnline = -1;
|
||
wxString cmd;
|
||
if(m_HangUpCommand.Find("%s"))
|
||
cmd.Printf(m_HangUpCommand,m_ISPname.c_str());
|
||
else
|
||
cmd = m_HangUpCommand;
|
||
return wxExecute(cmd, /* sync */ TRUE) == 0;
|
||
}
|
||
|
||
|
||
bool
|
||
wxDialUpManagerImpl::EnableAutoCheckOnlineStatus(size_t nSeconds)
|
||
{
|
||
wxASSERT(m_timer == NULL);
|
||
m_timer = new AutoCheckTimer(this);
|
||
bool rc = m_timer->Start(nSeconds*1000);
|
||
if(! rc)
|
||
{
|
||
delete m_timer;
|
||
m_timer = NULL;
|
||
}
|
||
return rc;
|
||
}
|
||
|
||
void
|
||
wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
|
||
{
|
||
wxASSERT(m_timer != NULL);
|
||
m_timer->Stop();
|
||
delete m_timer;
|
||
m_timer = NULL;
|
||
}
|
||
|
||
|
||
void
|
||
wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
|
||
{
|
||
/// does hostname contain a port number?
|
||
wxString port = hostname.After(':');
|
||
if(port.Length())
|
||
{
|
||
m_BeaconHost = hostname.Before(':');
|
||
m_BeaconPort = atoi(port);
|
||
}
|
||
else
|
||
{
|
||
m_BeaconHost = hostname;
|
||
m_BeaconPort = portno;
|
||
}
|
||
}
|
||
|
||
|
||
void
|
||
wxDialUpManagerImpl::CheckStatus(void) const
|
||
{
|
||
// This function calls the CheckStatusInternal() helper function
|
||
// which is OS - specific and then sends the events.
|
||
|
||
int oldIsOnline = m_IsOnline;
|
||
( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
|
||
|
||
// now send the events as appropriate:
|
||
if(m_IsOnline != oldIsOnline)
|
||
{
|
||
if(m_IsOnline)
|
||
; // send ev
|
||
else
|
||
; // send ev
|
||
}
|
||
}
|
||
|
||
/*
|
||
We have three methods that we can use:
|
||
|
||
1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
|
||
--> should be fast enough for regular polling
|
||
2. test if we can reach the well known beacon host
|
||
--> too slow for polling
|
||
3. check /proc/net/dev on linux??
|
||
This method should be preferred, if possible. Need to do more
|
||
testing.
|
||
|
||
*/
|
||
|
||
void
|
||
wxDialUpManagerImpl::CheckStatusInternal(void)
|
||
{
|
||
m_IsOnline = -1;
|
||
|
||
// First time check for ifconfig location. We only use the variant
|
||
// which does not take arguments, a la GNU.
|
||
if(m_CanUseIfconfig == -1) // unknown
|
||
{
|
||
if(wxFileExists("/sbin/ifconfig"))
|
||
m_IfconfigPath = "/sbin/ifconfig";
|
||
else if(wxFileExists("/usr/sbin/ifconfig"))
|
||
m_IfconfigPath = "/usr/sbin/ifconfig";
|
||
}
|
||
|
||
wxLogNull ln; // suppress all error messages
|
||
// Let´s try the ifconfig method first, should be fastest:
|
||
if(m_CanUseIfconfig != 0) // unknown or yes
|
||
{
|
||
wxASSERT(m_IfconfigPath.length());
|
||
|
||
wxString tmpfile = wxGetTempFileName("_wxdialuptest");
|
||
wxString cmd = "/bin/sh -c \'";
|
||
cmd << m_IfconfigPath << " >" << tmpfile << '\'';
|
||
/* I tried to add an option to wxExecute() to not close stdout,
|
||
so we could let ifconfig write directly to the tmpfile, but
|
||
this does not work. That should be faster, as it doesn´t call
|
||
the shell first. I have no idea why. :-( (KB) */
|
||
#if 0
|
||
// temporarily redirect stdout/stderr:
|
||
int
|
||
new_stdout = dup(STDOUT_FILENO),
|
||
new_stderr = dup(STDERR_FILENO);
|
||
close(STDOUT_FILENO);
|
||
close(STDERR_FILENO);
|
||
|
||
int
|
||
// new stdout:
|
||
output_fd = open(tmpfile, O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR),
|
||
// new stderr:
|
||
null_fd = open("/dev/null", O_CREAT, S_IRUSR|S_IWUSR);
|
||
// verify well behaved unix behaviour:
|
||
wxASSERT(output_fd == STDOUT_FILENO);
|
||
wxASSERT(null_fd == STDERR_FILENO);
|
||
int rc = wxExecute(m_IfconfigPath,TRUE /* sync */,NULL ,wxEXECUTE_DONT_CLOSE_FDS);
|
||
close(null_fd); close(output_fd);
|
||
// restore old stdout, stderr:
|
||
int test;
|
||
test = dup(new_stdout); close(new_stdout); wxASSERT(test == STDOUT_FILENO);
|
||
test = dup(new_stderr); close(new_stderr); wxASSERT(test == STDERR_FILENO);
|
||
if(rc == 0)
|
||
#endif
|
||
if(wxExecute(cmd,TRUE /* sync */) == 0)
|
||
{
|
||
m_CanUseIfconfig = 1;
|
||
wxFile file;
|
||
if( file.Open(tmpfile) )
|
||
{
|
||
char *output = new char [file.Length()+1];
|
||
output[file.Length()] = '\0';
|
||
if(file.Read(output,file.Length()) == file.Length())
|
||
{
|
||
if(strstr(output,"ppp") // ppp
|
||
|| strstr(output,"sl") // slip
|
||
|| strstr(output,"pl") // plip
|
||
)
|
||
m_IsOnline = 1;
|
||
else
|
||
m_IsOnline = 0;
|
||
}
|
||
file.Close();
|
||
delete [] output;
|
||
}
|
||
// else m_IsOnline remains -1 as we don't know for sure
|
||
}
|
||
else // could not run ifconfig correctly
|
||
m_CanUseIfconfig = 0; // don´t try again
|
||
(void) wxRemoveFile(tmpfile);
|
||
if(m_IsOnline != -1) // we are done
|
||
return;
|
||
}
|
||
|
||
// second method: try to connect to well known host:
|
||
// This can be used under Win 9x, too!
|
||
struct hostent *hp;
|
||
struct sockaddr_in serv_addr;
|
||
int sockfd;
|
||
|
||
m_IsOnline = 0; // assume false
|
||
if((hp = gethostbyname(m_BeaconHost)) == NULL)
|
||
return; // no DNS no net
|
||
|
||
serv_addr.sin_family = hp->h_addrtype;
|
||
memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
|
||
serv_addr.sin_port = htons(m_BeaconPort);
|
||
if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
|
||
{
|
||
// sys_error("cannot create socket for gw");
|
||
return;
|
||
}
|
||
if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
|
||
{
|
||
//sys_error("cannot connect to server");
|
||
return;
|
||
}
|
||
//connected!
|
||
close(sockfd);
|
||
}
|
||
|
||
|
||
/* static */
|
||
wxDialUpManager *
|
||
wxDialUpManager::wxDialUpManager::Create(void)
|
||
{
|
||
return new wxDialUpManagerImpl;
|
||
}
|
||
|
||
#endif // wxUSE_DIALUP_MANAGER
|