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