AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Unix implementation of wxDialUpManager.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3798 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Karsten Ballüder 1999-10-02 18:29:54 +00:00
parent 6782163029
commit 1c8515f9ab
6 changed files with 1121 additions and 702 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Makefile.in
View File

@ -190,6 +190,7 @@ WX_HEADERS = \
gifdecod.h \
grid.h \
gsocket.h \
net.h \
hash.h \
help.h \
helpbase.h \
@ -838,6 +839,7 @@ GTK_GUIOBJS = \
gauge.o \
gdiobj.o \
gsockgtk.o \
net.o \
icon.o \
listbox.o \
main.o \
@ -1551,6 +1553,7 @@ MSW_GUIOBJS = \
gauge95.o \
gdiobj.o \
gsocket.o \
net.o \
helpwin.o \
icon.o \
imaglist.o \
@ -1637,6 +1640,7 @@ MSW_GUIDEPS = \
gauge95.d \
gdiobj.d \
gsocket.d \
net.d \
helpwin.d \
icon.d \
imaglist.d \
@ -1729,11 +1733,13 @@ HTMLDEPS = \
UNIXOBJS = \
gsocket.o \
net.o \
threadpsx.o \
utilsunx.o
UNIXDEPS = \
gsocket.d \
net.d \
threadpsx.d \
utilsunx.d

1373
configure vendored
View File

File diff suppressed because it is too large Load Diff

7
configure.in
View File

@ -673,6 +673,7 @@ if test $DEBUG_CONFIGURE = 1; then
DEFAULT_wxUSE_CONFIG=no
DEFAULT_wxUSE_STREAMS=no
DEFAULT_wxUSE_SOCKETS=no
DEFAULT_wxUSE_DIALUP_MANAGER=no
DEFAULT_wxUSE_SERIAL=no
DEFAULT_wxUSE_JOYSTICK=no
DEFAULT_wxUSE_DYNLIB_CLASS=no
@ -783,6 +784,7 @@ else
DEFAULT_wxUSE_CONFIG=yes
DEFAULT_wxUSE_STREAMS=yes
DEFAULT_wxUSE_SOCKETS=yes
DEFAULT_wxUSE_DIALUP_MANAGER=yes
DEFAULT_wxUSE_SERIAL=yes
DEFAULT_wxUSE_JOYSTICK=yes
DEFAULT_wxUSE_DYNLIB_CLASS=yes
@ -943,6 +945,7 @@ dnl ---------------------------------------------------------------------------
WX_ARG_ENABLE(intl, [ --enable-intl use internationalization system], wxUSE_INTL)
WX_ARG_ENABLE(config, [ --enable-config use wxConfig (and derived) classes], wxUSE_CONFIG)
WX_ARG_ENABLE(sockets, [ --enable-sockets use socket/network classes], wxUSE_SOCKETS)
WX_ARG_ENABLE(dialupman, [ --enable-dialupman use dialup network classes], wxUSE_DIALUP_MANAGER)
WX_ARG_ENABLE(ipc, [ --enable-ipc use interprocess communication (wxSocket etc.)], wxUSE_IPC)
WX_ARG_ENABLE(apple_ieee, [ --enable-apple_ieee use the Apple IEEE codec], wxUSE_APPLE_IEEE)
WX_ARG_ENABLE(timedate, [ --enable-timedate use date/time classes], wxUSE_TIMEDATE)
@ -2228,6 +2231,10 @@ if test "$wxUSE_SOCKETS" = "yes" ; then
fi
fi
if test "$wxUSE_DIALUP_MANAGER" = "yes" ; then
AC_DEFINE(wxUSE_DIALUP_MANAGER)
fi
if test "$wxUSE_STREAMS" = "yes" ; then
AC_DEFINE(wxUSE_STREAMS)
fi

54
include/wx/net.h
View File

@ -37,19 +37,15 @@
* main thread?
*/
#define WXDIALUP_MANAGER_DEFAULT_BEACONHOST "www.yahoo.com"
class WXDLLEXPORT wxDialUpManager
{
public:
// get the pointer to the global wxDialUpManager object
static wxDialUpManager *Get()
{
if ( !ms_dialUpManager )
{
ms_dialUpManager = Create();
}
return ms_dialUpManager;
}
// this function should create and return the object of the
// platform-specific class derived from wxDialUpManager. It's implemented
// in the platform-specific source files.
static wxDialUpManager *Create();
// could the dialup manager be initialized correctly? If this function
// returns FALSE, no other functions will work neither, so it's a good idea
@ -67,9 +63,9 @@ public:
// 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.
virtual bool Dial(const wxString& nameOfISP,
const wxString& username,
const wxString& password) = 0;
virtual bool Dial(const wxString& nameOfISP = "",
const wxString& username = "",
const wxString& password = "") = 0;
// hang up the currently active dial up connection
virtual bool HangUp() = 0;
@ -80,7 +76,7 @@ public:
// 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() = 0;
virtual bool IsOnline() const = 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
@ -107,28 +103,14 @@ public:
// 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) = 0;
private:
friend class WXDLLEXPORT wxApp;
// only for wxApp usage: clean up.
static void Delete()
{
if ( ms_dialUpManager )
{
delete ms_dialUpManager;
ms_dialUpManager = (wxDialUpManager *)NULL;
}
}
// this function should create and return the object of the
// platform-specific class derived from wxDialUpManager. It's implemented
// in the platform-specific source files.
static wxDialUpManager *Create();
// the unique instance of this class
static wxDialUpManager *ms_dialUpManager;
virtual void SetWellKnownHost(const wxString& hostname,
int portno = 80) = 0;
/** 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 = "/usr/bin/pon",
const wxString &hupcmd = "/usr/bin/poff")
{ }
};
// ----------------------------------------------------------------------------

4
setup.h.in
View File

@ -337,6 +337,10 @@
* Use sockets
*/
#define wxUSE_SOCKETS 0
/*
* Use dialup manager
*/
#define wxUSE_DIALUP_MANAGER 0
/*
* Use standard C++ streams if 1. If 0, use wxWin
* streams implementation.

379
src/unix/net.cpp Normal file
View File

@ -0,0 +1,379 @@
// -*- 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 <stdlib.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#define __STRICT_ANSI__
#include <sys/socket.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";
}
// 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 = m_IfconfigPath;
cmd << " >" << tmpfile;
if(wxExecute(m_IfconfigPath,TRUE /* sync */) == 0)
{
m_CanUseIfconfig = 1;
wxString cmd1 = "grep ppp <"+tmpfile; // PPP
wxString cmd2 = "grep sl <"+tmpfile; // SLIP
wxString cmd3 = "grep pl <"+tmpfile; // PLIP
if(wxExecute(cmd1,TRUE) == 0
|| wxExecute(cmd2,TRUE) == 0
|| wxExecute(cmd3,TRUE) == 0
)
m_IsOnline = 1;
}
else // could not run ifconfig correctly
m_CanUseIfconfig = 0; // don´t try again
wxRemoveFile(tmpfile);
if(m_IsOnline != -1) // we are done
return;
}
// second method: try to connect to well known host:
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