]> git.saurik.com Git - wxWidgets.git/blob - src/unix/net.cpp
added missing includes after wxUniv merge
[wxWidgets.git] / 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/filefn.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 delete m_timer;
240 m_timer = NULL;
241 }
242 return rc;
243 }
244
245 void
246 wxDialUpManagerImpl::DisableAutoCheckOnlineStatus()
247 {
248 wxASSERT(m_timer != NULL);
249 m_timer->Stop();
250 delete m_timer;
251 m_timer = NULL;
252 }
253
254
255 void
256 wxDialUpManagerImpl::SetWellKnownHost(const wxString& hostname, int portno)
257 {
258 /// does hostname contain a port number?
259 wxString port = hostname.After(':');
260 if(port.Length())
261 {
262 m_BeaconHost = hostname.Before(':');
263 m_BeaconPort = atoi(port);
264 }
265 else
266 {
267 m_BeaconHost = hostname;
268 m_BeaconPort = portno;
269 }
270 }
271
272
273 void
274 wxDialUpManagerImpl::CheckStatus(void) const
275 {
276 // This function calls the CheckStatusInternal() helper function
277 // which is OS - specific and then sends the events.
278
279 int oldIsOnline = m_IsOnline;
280 ( /* non-const */ (wxDialUpManagerImpl *)this)->CheckStatusInternal();
281
282 // now send the events as appropriate:
283 if(m_IsOnline != oldIsOnline)
284 {
285 if(m_IsOnline)
286 ; // send ev
287 else
288 ; // send ev
289 }
290 }
291
292 /*
293 We have three methods that we can use:
294
295 1. test via /sbin/ifconfig and grep for "sl", "ppp", "pl"
296 --> should be fast enough for regular polling
297 2. test if we can reach the well known beacon host
298 --> too slow for polling
299 3. check /proc/net/dev on linux??
300 This method should be preferred, if possible. Need to do more
301 testing.
302
303 */
304
305 void
306 wxDialUpManagerImpl::CheckStatusInternal(void)
307 {
308 m_IsOnline = -1;
309
310 // First time check for ifconfig location. We only use the variant
311 // which does not take arguments, a la GNU.
312 if(m_CanUseIfconfig == -1) // unknown
313 {
314 if(wxFileExists("/sbin/ifconfig"))
315 m_IfconfigPath = "/sbin/ifconfig";
316 else if(wxFileExists("/usr/sbin/ifconfig"))
317 m_IfconfigPath = "/usr/sbin/ifconfig";
318 }
319
320 wxLogNull ln; // suppress all error messages
321 // Let´s try the ifconfig method first, should be fastest:
322 if(m_CanUseIfconfig != 0) // unknown or yes
323 {
324 wxASSERT(m_IfconfigPath.length());
325
326 wxString tmpfile = wxGetTempFileName("_wxdialuptest");
327 wxString cmd = "/bin/sh -c \'";
328 cmd << m_IfconfigPath << " >" << tmpfile << '\'';
329 /* I tried to add an option to wxExecute() to not close stdout,
330 so we could let ifconfig write directly to the tmpfile, but
331 this does not work. That should be faster, as it doesn´t call
332 the shell first. I have no idea why. :-( (KB) */
333 #if 0
334 // temporarily redirect stdout/stderr:
335 int
336 new_stdout = dup(STDOUT_FILENO),
337 new_stderr = dup(STDERR_FILENO);
338 close(STDOUT_FILENO);
339 close(STDERR_FILENO);
340
341 int
342 // new stdout:
343 output_fd = open(tmpfile, O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR),
344 // new stderr:
345 null_fd = open("/dev/null", O_CREAT, S_IRUSR|S_IWUSR);
346 // verify well behaved unix behaviour:
347 wxASSERT(output_fd == STDOUT_FILENO);
348 wxASSERT(null_fd == STDERR_FILENO);
349 int rc = wxExecute(m_IfconfigPath,TRUE /* sync */,NULL ,wxEXECUTE_DONT_CLOSE_FDS);
350 close(null_fd); close(output_fd);
351 // restore old stdout, stderr:
352 int test;
353 test = dup(new_stdout); close(new_stdout); wxASSERT(test == STDOUT_FILENO);
354 test = dup(new_stderr); close(new_stderr); wxASSERT(test == STDERR_FILENO);
355 if(rc == 0)
356 #endif
357 if(wxExecute(cmd,TRUE /* sync */) == 0)
358 {
359 m_CanUseIfconfig = 1;
360 wxFile file;
361 if( file.Open(tmpfile) )
362 {
363 char *output = new char [file.Length()+1];
364 output[file.Length()] = '\0';
365 if(file.Read(output,file.Length()) == file.Length())
366 {
367 if(strstr(output,"ppp") // ppp
368 || strstr(output,"sl") // slip
369 || strstr(output,"pl") // plip
370 )
371 m_IsOnline = 1;
372 else
373 m_IsOnline = 0;
374 }
375 file.Close();
376 delete [] output;
377 }
378 // else m_IsOnline remains -1 as we don't know for sure
379 }
380 else // could not run ifconfig correctly
381 m_CanUseIfconfig = 0; // don´t try again
382 (void) wxRemoveFile(tmpfile);
383 if(m_IsOnline != -1) // we are done
384 return;
385 }
386
387 // second method: try to connect to well known host:
388 // This can be used under Win 9x, too!
389 struct hostent *hp;
390 struct sockaddr_in serv_addr;
391 int sockfd;
392
393 m_IsOnline = 0; // assume false
394 if((hp = gethostbyname(m_BeaconHost)) == NULL)
395 return; // no DNS no net
396
397 serv_addr.sin_family = hp->h_addrtype;
398 memcpy(&serv_addr.sin_addr,hp->h_addr, hp->h_length);
399 serv_addr.sin_port = htons(m_BeaconPort);
400 if( ( sockfd = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0)
401 {
402 // sys_error("cannot create socket for gw");
403 return;
404 }
405 if( connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
406 {
407 //sys_error("cannot connect to server");
408 return;
409 }
410 //connected!
411 close(sockfd);
412 }
413
414
415 /* static */
416 wxDialUpManager *
417 wxDialUpManager::wxDialUpManager::Create(void)
418 {
419 return new wxDialUpManagerImpl;
420 }
421
422 #endif // wxUSE_DIALUP_MANAGER