]> git.saurik.com Git - wxWidgets.git/blame - src/unix/net.cpp
Correct Mac OX/iPhone check in libpng.
[wxWidgets.git] / src / unix / net.cpp
CommitLineData
275abf24
KB
1// -*- c++ -*- ///////////////////////////////////////////////////////////////
2// Name: unix/net.cpp
3// Purpose: Network related wxWindows classes and functions
e9670814 4// Author: Karsten Ballüder
275abf24
KB
5// Modified by:
6// Created: 03.10.99
7// RCS-ID: $Id$
e9670814 8// Copyright: (c) Karsten Ballüder
275abf24
KB
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"
a51e601e 24#include "wx/filename.h"
275abf24
KB
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
64class WXDLLEXPORT wxDialUpManagerImpl : public wxDialUpManager
65{
66public:
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
65391c8f 82 { return true; }
275abf24
KB
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();
03647350 98
275abf24
KB
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.
65391c8f 115 virtual void SetOnlineStatus(bool isOnline = true)
275abf24
KB
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
145private:
e9670814 146 /// -1: don't know, 0 = no, 1 = yes
275abf24 147 int m_IsOnline;
03647350 148
275abf24
KB
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
177class AutoCheckTimer : public wxTimer
178{
179public:
180 AutoCheckTimer(wxDialUpManagerImpl *dupman)
181 {
182 m_dupman = dupman;
65391c8f 183 m_started = false;
275abf24
KB
184 }
185
186 virtual bool Start( int millisecs = -1 )
65391c8f 187 { m_started = true; return wxTimer::Start(millisecs, false); }
275abf24
KB
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(); }
194public:
195 bool m_started;
196 wxDialUpManagerImpl *m_dupman;
197};
198
199bool
200wxDialUpManagerImpl::Dial(const wxString &isp,
201 const wxString & WXUNUSED(username),
202 const wxString & WXUNUSED(password))
203{
204 if(m_IsOnline == 1)
65391c8f 205 return false;
275abf24
KB
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
216bool
217wxDialUpManagerImpl::HangUp(void)
218{
219 if(m_IsOnline == 0)
65391c8f 220 return false;
275abf24
KB
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
231bool
232wxDialUpManagerImpl::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 {
5276b0a5 239 wxDELETE(m_timer);
275abf24
KB
240 }
241 return rc;
242}
243
244void
245wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
246{
247 wxASSERT(m_timer != NULL);
248 m_timer->Stop();
5276b0a5 249 wxDELETE(m_timer);
275abf24
KB
250}
251
252
253void
254wxDialUpManagerImpl::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
271void
272wxDialUpManagerImpl::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.
03647350 300
275abf24
KB
301*/
302
303void
304wxDialUpManagerImpl::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
e9670814 319 // Let's try the ifconfig method first, should be fastest:
275abf24
KB
320 if(m_CanUseIfconfig != 0) // unknown or yes
321 {
322 wxASSERT(m_IfconfigPath.length());
03647350 323
a51e601e 324 wxString tmpfile = wxFileName::CreateTempFileName("_wxdialuptest");
275abf24
KB
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
e9670814 329 this does not work. That should be faster, as it doesn't call
275abf24
KB
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
e9670814 379 m_CanUseIfconfig = 0; // don't try again
275abf24
KB
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;
03647350 389 int sockfd;
275abf24
KB
390
391 m_IsOnline = 0; // assume false
392 if((hp = gethostbyname(m_BeaconHost)) == NULL)
393 return; // no DNS no net
03647350
VZ
394
395 serv_addr.sin_family = hp->h_addrtype;
275abf24 396 memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
03647350
VZ
397 serv_addr.sin_port = htons(m_BeaconPort);
398 if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
399 {
275abf24
KB
400 // sys_error("cannot create socket for gw");
401 return;
402 }
403 if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
03647350 404 {
275abf24
KB
405 //sys_error("cannot connect to server");
406 return;
407 }
408 //connected!
409 close(sockfd);
410}
411
412
413/* static */
414wxDialUpManager *
415wxDialUpManager::wxDialUpManager::Create(void)
416{
417 return new wxDialUpManagerImpl;
418}
419
420#endif // wxUSE_DIALUP_MANAGER