]> git.saurik.com Git - wxWidgets.git/blob - src/msw/dialup.cpp
fixed ambiguous call to wxMacCarbonEvent::SetParameter
[wxWidgets.git] / src / msw / dialup.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: msw/dialup.cpp
3 // Purpose: MSW implementation of network/dialup classes and functions
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 07.07.99
7 // RCS-ID: $Id$
8 // Copyright: (c) Vadim Zeitlin
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // for compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_DIALUP_MANAGER
28
29 #ifndef WX_PRECOMP
30 #include "wx/log.h"
31 #include "wx/intl.h"
32 #include "wx/event.h"
33 #endif
34
35 #include "wx/timer.h"
36 #include "wx/app.h"
37 #include "wx/generic/choicdgg.h"
38
39 #include "wx/dynlib.h"
40 #include "wx/dialup.h"
41
42 DEFINE_EVENT_TYPE(wxEVT_DIALUP_CONNECTED)
43 DEFINE_EVENT_TYPE(wxEVT_DIALUP_DISCONNECTED)
44
45 // Doesn't yet compile under VC++ 4, BC++, Watcom C++,
46 // Wine: no wininet.h
47 #if (!defined(__BORLANDC__) || (__BORLANDC__>=0x550)) && \
48 (!defined(__GNUWIN32__) || wxCHECK_W32API_VERSION(0, 5)) && \
49 !defined(__GNUWIN32_OLD__) && \
50 !defined(__WINE__) && \
51 (!defined(__VISUALC__) || (__VISUALC__ >= 1020))
52
53 #include <ras.h>
54 #include <raserror.h>
55
56 #include <wininet.h>
57
58 // Not in VC++ 5
59 #ifndef INTERNET_CONNECTION_LAN
60 #define INTERNET_CONNECTION_LAN 2
61 #endif
62 #ifndef INTERNET_CONNECTION_PROXY
63 #define INTERNET_CONNECTION_PROXY 4
64 #endif
65
66 // ----------------------------------------------------------------------------
67 // constants
68 // ----------------------------------------------------------------------------
69
70 // this message is sent by the secondary thread when RAS status changes
71 #define wxWM_RAS_STATUS_CHANGED (WM_USER + 10010)
72 #define wxWM_RAS_DIALING_PROGRESS (WM_USER + 10011)
73
74 // ----------------------------------------------------------------------------
75 // types
76 // ----------------------------------------------------------------------------
77
78 // the signatures of RAS functions: all this is quite heavy, but we must do it
79 // to allow running wxWin programs on machine which don't have RAS installed
80 // (this does exist) - if we link with rasapi32.lib, the program will fail on
81 // startup because of the missing DLL...
82
83 #ifndef UNICODE
84 typedef DWORD (APIENTRY * RASDIAL)( LPRASDIALEXTENSIONS, LPCSTR, LPRASDIALPARAMSA, DWORD, LPVOID, LPHRASCONN );
85 typedef DWORD (APIENTRY * RASENUMCONNECTIONS)( LPRASCONNA, LPDWORD, LPDWORD );
86 typedef DWORD (APIENTRY * RASENUMENTRIES)( LPCSTR, LPCSTR, LPRASENTRYNAMEA, LPDWORD, LPDWORD );
87 typedef DWORD (APIENTRY * RASGETCONNECTSTATUS)( HRASCONN, LPRASCONNSTATUSA );
88 typedef DWORD (APIENTRY * RASGETERRORSTRING)( UINT, LPSTR, DWORD );
89 typedef DWORD (APIENTRY * RASHANGUP)( HRASCONN );
90 typedef DWORD (APIENTRY * RASGETPROJECTIONINFO)( HRASCONN, RASPROJECTION, LPVOID, LPDWORD );
91 typedef DWORD (APIENTRY * RASCREATEPHONEBOOKENTRY)( HWND, LPCSTR );
92 typedef DWORD (APIENTRY * RASEDITPHONEBOOKENTRY)( HWND, LPCSTR, LPCSTR );
93 typedef DWORD (APIENTRY * RASSETENTRYDIALPARAMS)( LPCSTR, LPRASDIALPARAMSA, BOOL );
94 typedef DWORD (APIENTRY * RASGETENTRYDIALPARAMS)( LPCSTR, LPRASDIALPARAMSA, LPBOOL );
95 typedef DWORD (APIENTRY * RASENUMDEVICES)( LPRASDEVINFOA, LPDWORD, LPDWORD );
96 typedef DWORD (APIENTRY * RASGETCOUNTRYINFO)( LPRASCTRYINFOA, LPDWORD );
97 typedef DWORD (APIENTRY * RASGETENTRYPROPERTIES)( LPCSTR, LPCSTR, LPRASENTRYA, LPDWORD, LPBYTE, LPDWORD );
98 typedef DWORD (APIENTRY * RASSETENTRYPROPERTIES)( LPCSTR, LPCSTR, LPRASENTRYA, DWORD, LPBYTE, DWORD );
99 typedef DWORD (APIENTRY * RASRENAMEENTRY)( LPCSTR, LPCSTR, LPCSTR );
100 typedef DWORD (APIENTRY * RASDELETEENTRY)( LPCSTR, LPCSTR );
101 typedef DWORD (APIENTRY * RASVALIDATEENTRYNAME)( LPCSTR, LPCSTR );
102 typedef DWORD (APIENTRY * RASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
103
104 static const wxChar gs_funcSuffix = _T('A');
105 #else // Unicode
106 typedef DWORD (APIENTRY * RASDIAL)( LPRASDIALEXTENSIONS, LPCWSTR, LPRASDIALPARAMSW, DWORD, LPVOID, LPHRASCONN );
107 typedef DWORD (APIENTRY * RASENUMCONNECTIONS)( LPRASCONNW, LPDWORD, LPDWORD );
108 typedef DWORD (APIENTRY * RASENUMENTRIES)( LPCWSTR, LPCWSTR, LPRASENTRYNAMEW, LPDWORD, LPDWORD );
109 typedef DWORD (APIENTRY * RASGETCONNECTSTATUS)( HRASCONN, LPRASCONNSTATUSW );
110 typedef DWORD (APIENTRY * RASGETERRORSTRING)( UINT, LPWSTR, DWORD );
111 typedef DWORD (APIENTRY * RASHANGUP)( HRASCONN );
112 typedef DWORD (APIENTRY * RASGETPROJECTIONINFO)( HRASCONN, RASPROJECTION, LPVOID, LPDWORD );
113 typedef DWORD (APIENTRY * RASCREATEPHONEBOOKENTRY)( HWND, LPCWSTR );
114 typedef DWORD (APIENTRY * RASEDITPHONEBOOKENTRY)( HWND, LPCWSTR, LPCWSTR );
115 typedef DWORD (APIENTRY * RASSETENTRYDIALPARAMS)( LPCWSTR, LPRASDIALPARAMSW, BOOL );
116 typedef DWORD (APIENTRY * RASGETENTRYDIALPARAMS)( LPCWSTR, LPRASDIALPARAMSW, LPBOOL );
117 typedef DWORD (APIENTRY * RASENUMDEVICES)( LPRASDEVINFOW, LPDWORD, LPDWORD );
118 typedef DWORD (APIENTRY * RASGETCOUNTRYINFO)( LPRASCTRYINFOW, LPDWORD );
119 typedef DWORD (APIENTRY * RASGETENTRYPROPERTIES)( LPCWSTR, LPCWSTR, LPRASENTRYW, LPDWORD, LPBYTE, LPDWORD );
120 typedef DWORD (APIENTRY * RASSETENTRYPROPERTIES)( LPCWSTR, LPCWSTR, LPRASENTRYW, DWORD, LPBYTE, DWORD );
121 typedef DWORD (APIENTRY * RASRENAMEENTRY)( LPCWSTR, LPCWSTR, LPCWSTR );
122 typedef DWORD (APIENTRY * RASDELETEENTRY)( LPCWSTR, LPCWSTR );
123 typedef DWORD (APIENTRY * RASVALIDATEENTRYNAME)( LPCWSTR, LPCWSTR );
124 typedef DWORD (APIENTRY * RASCONNECTIONNOTIFICATION)( HRASCONN, HANDLE, DWORD );
125
126 static const wxChar gs_funcSuffix = _T('W');
127 #endif // ASCII/Unicode
128
129 // structure passed to the secondary thread
130 struct WXDLLEXPORT wxRasThreadData
131 {
132 wxRasThreadData()
133 {
134 hWnd = 0;
135 hEventRas =
136 hEventQuit = 0;
137 dialUpManager = NULL;
138 }
139
140 ~wxRasThreadData()
141 {
142 if ( hWnd )
143 DestroyWindow(hWnd);
144
145 if ( hEventQuit )
146 CloseHandle(hEventQuit);
147
148 if ( hEventRas )
149 CloseHandle(hEventRas);
150 }
151
152 HWND hWnd; // window to send notifications to
153 HANDLE hEventRas, // automatic event which RAS signals when status changes
154 hEventQuit; // manual event which we signal when we terminate
155
156 class WXDLLEXPORT wxDialUpManagerMSW *dialUpManager; // the owner
157 };
158
159 // ----------------------------------------------------------------------------
160 // wxDialUpManager class for MSW
161 // ----------------------------------------------------------------------------
162
163 class WXDLLEXPORT wxDialUpManagerMSW : public wxDialUpManager
164 {
165 public:
166 // ctor & dtor
167 wxDialUpManagerMSW();
168 virtual ~wxDialUpManagerMSW();
169
170 // implement base class pure virtuals
171 virtual bool IsOk() const;
172 virtual size_t GetISPNames(wxArrayString& names) const;
173 virtual bool Dial(const wxString& nameOfISP,
174 const wxString& username,
175 const wxString& password,
176 bool async);
177 virtual bool IsDialing() const;
178 virtual bool CancelDialing();
179 virtual bool HangUp();
180 virtual bool IsAlwaysOnline() const;
181 virtual bool IsOnline() const;
182 virtual void SetOnlineStatus(bool isOnline = TRUE);
183 virtual bool EnableAutoCheckOnlineStatus(size_t nSeconds);
184 virtual void DisableAutoCheckOnlineStatus();
185 virtual void SetWellKnownHost(const wxString& hostname, int port);
186 virtual void SetConnectCommand(const wxString& commandDial,
187 const wxString& commandHangup);
188
189 // for RasTimer
190 void CheckRasStatus();
191
192 // for wxRasStatusWindowProc
193 void OnConnectStatusChange();
194 void OnDialProgress(RASCONNSTATE rasconnstate, DWORD dwError);
195
196 // for wxRasDialFunc
197 static HWND GetRasWindow() { return ms_hwndRas; }
198 static wxDialUpManagerMSW *GetDialer() { return ms_dialer; }
199
200 private:
201 // return the error string for the given RAS error code
202 static wxString GetErrorString(DWORD error);
203
204 // find the (first) handle of the active connection
205 static HRASCONN FindActiveConnection();
206
207 // notify the application about status change
208 void NotifyApp(bool connected, bool fromOurselves = FALSE) const;
209
210 // destroy the thread data and the thread itself
211 void CleanUpThreadData();
212
213 // number of times EnableAutoCheckOnlineStatus() had been called minus the
214 // number of times DisableAutoCheckOnlineStatus() had been called
215 int m_autoCheckLevel;
216
217 // timer used for polling RAS status
218 class WXDLLEXPORT RasTimer : public wxTimer
219 {
220 public:
221 RasTimer(wxDialUpManagerMSW *dialUpManager)
222 { m_dialUpManager = dialUpManager; }
223
224 virtual void Notify() { m_dialUpManager->CheckRasStatus(); }
225
226 private:
227 wxDialUpManagerMSW *m_dialUpManager;
228
229 DECLARE_NO_COPY_CLASS(RasTimer)
230 } m_timerStatusPolling;
231
232 // thread handle for the thread sitting on connection change event
233 HANDLE m_hThread;
234
235 // data used by this thread and our hidden window to send messages between
236 // each other
237 wxRasThreadData *m_data;
238
239 // the handle of rasapi32.dll when it's loaded
240 wxDynamicLibrary m_dllRas;
241
242 // the hidden window we use for passing messages between threads
243 static HWND ms_hwndRas;
244
245 // the handle of the connection we initiated or 0 if none
246 static HRASCONN ms_hRasConnection;
247
248 // the pointers to RAS functions
249 static RASDIAL ms_pfnRasDial;
250 static RASENUMCONNECTIONS ms_pfnRasEnumConnections;
251 static RASENUMENTRIES ms_pfnRasEnumEntries;
252 static RASGETCONNECTSTATUS ms_pfnRasGetConnectStatus;
253 static RASGETERRORSTRING ms_pfnRasGetErrorString;
254 static RASHANGUP ms_pfnRasHangUp;
255 static RASGETPROJECTIONINFO ms_pfnRasGetProjectionInfo;
256 static RASCREATEPHONEBOOKENTRY ms_pfnRasCreatePhonebookEntry;
257 static RASEDITPHONEBOOKENTRY ms_pfnRasEditPhonebookEntry;
258 static RASSETENTRYDIALPARAMS ms_pfnRasSetEntryDialParams;
259 static RASGETENTRYDIALPARAMS ms_pfnRasGetEntryDialParams;
260 static RASENUMDEVICES ms_pfnRasEnumDevices;
261 static RASGETCOUNTRYINFO ms_pfnRasGetCountryInfo;
262 static RASGETENTRYPROPERTIES ms_pfnRasGetEntryProperties;
263 static RASSETENTRYPROPERTIES ms_pfnRasSetEntryProperties;
264 static RASRENAMEENTRY ms_pfnRasRenameEntry;
265 static RASDELETEENTRY ms_pfnRasDeleteEntry;
266 static RASVALIDATEENTRYNAME ms_pfnRasValidateEntryName;
267
268 // this function is not supported by Win95
269 static RASCONNECTIONNOTIFICATION ms_pfnRasConnectionNotification;
270
271 // if this flag is different from -1, it overrides IsOnline()
272 static int ms_userSpecifiedOnlineStatus;
273
274 // this flag tells us if we're online
275 static int ms_isConnected;
276
277 // this flag tells us whether a call to RasDial() is in progress
278 static wxDialUpManagerMSW *ms_dialer;
279
280 DECLARE_NO_COPY_CLASS(wxDialUpManagerMSW)
281 };
282
283 // ----------------------------------------------------------------------------
284 // private functions
285 // ----------------------------------------------------------------------------
286
287 static LRESULT WINAPI wxRasStatusWindowProc(HWND hWnd, UINT message,
288 WPARAM wParam, LPARAM lParam);
289
290 static DWORD wxRasMonitorThread(wxRasThreadData *data);
291
292 static void WINAPI wxRasDialFunc(UINT unMsg,
293 RASCONNSTATE rasconnstate,
294 DWORD dwError);
295
296 // ============================================================================
297 // implementation
298 // ============================================================================
299
300 // ----------------------------------------------------------------------------
301 // init the static variables
302 // ----------------------------------------------------------------------------
303
304 HRASCONN wxDialUpManagerMSW::ms_hRasConnection = 0;
305
306 HWND wxDialUpManagerMSW::ms_hwndRas = 0;
307
308 RASDIAL wxDialUpManagerMSW::ms_pfnRasDial = 0;
309 RASENUMCONNECTIONS wxDialUpManagerMSW::ms_pfnRasEnumConnections = 0;
310 RASENUMENTRIES wxDialUpManagerMSW::ms_pfnRasEnumEntries = 0;
311 RASGETCONNECTSTATUS wxDialUpManagerMSW::ms_pfnRasGetConnectStatus = 0;
312 RASGETERRORSTRING wxDialUpManagerMSW::ms_pfnRasGetErrorString = 0;
313 RASHANGUP wxDialUpManagerMSW::ms_pfnRasHangUp = 0;
314 RASGETPROJECTIONINFO wxDialUpManagerMSW::ms_pfnRasGetProjectionInfo = 0;
315 RASCREATEPHONEBOOKENTRY wxDialUpManagerMSW::ms_pfnRasCreatePhonebookEntry = 0;
316 RASEDITPHONEBOOKENTRY wxDialUpManagerMSW::ms_pfnRasEditPhonebookEntry = 0;
317 RASSETENTRYDIALPARAMS wxDialUpManagerMSW::ms_pfnRasSetEntryDialParams = 0;
318 RASGETENTRYDIALPARAMS wxDialUpManagerMSW::ms_pfnRasGetEntryDialParams = 0;
319 RASENUMDEVICES wxDialUpManagerMSW::ms_pfnRasEnumDevices = 0;
320 RASGETCOUNTRYINFO wxDialUpManagerMSW::ms_pfnRasGetCountryInfo = 0;
321 RASGETENTRYPROPERTIES wxDialUpManagerMSW::ms_pfnRasGetEntryProperties = 0;
322 RASSETENTRYPROPERTIES wxDialUpManagerMSW::ms_pfnRasSetEntryProperties = 0;
323 RASRENAMEENTRY wxDialUpManagerMSW::ms_pfnRasRenameEntry = 0;
324 RASDELETEENTRY wxDialUpManagerMSW::ms_pfnRasDeleteEntry = 0;
325 RASVALIDATEENTRYNAME wxDialUpManagerMSW::ms_pfnRasValidateEntryName = 0;
326 RASCONNECTIONNOTIFICATION wxDialUpManagerMSW::ms_pfnRasConnectionNotification = 0;
327
328 int wxDialUpManagerMSW::ms_userSpecifiedOnlineStatus = -1;
329 int wxDialUpManagerMSW::ms_isConnected = -1;
330 wxDialUpManagerMSW *wxDialUpManagerMSW::ms_dialer = NULL;
331
332 // ----------------------------------------------------------------------------
333 // ctor and dtor: the dynamic linking happens here
334 // ----------------------------------------------------------------------------
335
336 // the static creator function is implemented here
337 wxDialUpManager *wxDialUpManager::Create()
338 {
339 return new wxDialUpManagerMSW;
340 }
341
342 #ifdef __VISUALC__
343 // warning about "'this' : used in base member initializer list" - so what?
344 #pragma warning(disable:4355)
345 #endif // VC++
346
347 wxDialUpManagerMSW::wxDialUpManagerMSW()
348 : m_timerStatusPolling(this),
349 m_dllRas(_T("RASAPI32"))
350 {
351 // initialize our data
352 m_autoCheckLevel = 0;
353 m_hThread = 0;
354 m_data = new wxRasThreadData;
355
356 if ( !m_dllRas.IsLoaded() )
357 {
358 wxLogError(_("Dial up functions are unavailable because the remote access service (RAS) is not installed on this machine. Please install it."));
359 }
360 else if ( !ms_pfnRasDial )
361 {
362 // resolve the functions we need
363
364 // this will contain the name of the function we failed to resolve
365 // if any at the end
366 const char *funcName = NULL;
367
368 // get the function from rasapi32.dll and abort if it's not found
369 #define RESOLVE_RAS_FUNCTION(type, name) \
370 ms_pfn##name = (type)m_dllRas.GetSymbol( wxString(_T(#name)) \
371 + gs_funcSuffix); \
372 if ( !ms_pfn##name ) \
373 { \
374 funcName = #name; \
375 goto exit; \
376 }
377
378 // a variant of above macro which doesn't abort if the function is
379 // not found in the DLL
380 #define RESOLVE_OPTIONAL_RAS_FUNCTION(type, name) \
381 ms_pfn##name = (type)m_dllRas.GetSymbol( wxString(_T(#name)) \
382 + gs_funcSuffix);
383
384 RESOLVE_RAS_FUNCTION(RASDIAL, RasDial);
385 RESOLVE_RAS_FUNCTION(RASENUMCONNECTIONS, RasEnumConnections);
386 RESOLVE_RAS_FUNCTION(RASENUMENTRIES, RasEnumEntries);
387 RESOLVE_RAS_FUNCTION(RASGETCONNECTSTATUS, RasGetConnectStatus);
388 RESOLVE_RAS_FUNCTION(RASGETERRORSTRING, RasGetErrorString);
389 RESOLVE_RAS_FUNCTION(RASHANGUP, RasHangUp);
390 RESOLVE_RAS_FUNCTION(RASGETENTRYDIALPARAMS, RasGetEntryDialParams);
391
392 // suppress error messages about missing (non essential) functions
393 {
394 wxLogNull noLog;
395
396 RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETPROJECTIONINFO, RasGetProjectionInfo);
397 RESOLVE_OPTIONAL_RAS_FUNCTION(RASCREATEPHONEBOOKENTRY, RasCreatePhonebookEntry);
398 RESOLVE_OPTIONAL_RAS_FUNCTION(RASEDITPHONEBOOKENTRY, RasEditPhonebookEntry);
399 RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYDIALPARAMS, RasSetEntryDialParams);
400 RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETENTRYPROPERTIES, RasGetEntryProperties);
401 RESOLVE_OPTIONAL_RAS_FUNCTION(RASSETENTRYPROPERTIES, RasSetEntryProperties);
402 RESOLVE_OPTIONAL_RAS_FUNCTION(RASRENAMEENTRY, RasRenameEntry);
403 RESOLVE_OPTIONAL_RAS_FUNCTION(RASDELETEENTRY, RasDeleteEntry);
404 RESOLVE_OPTIONAL_RAS_FUNCTION(RASVALIDATEENTRYNAME, RasValidateEntryName);
405 RESOLVE_OPTIONAL_RAS_FUNCTION(RASGETCOUNTRYINFO, RasGetCountryInfo);
406 RESOLVE_OPTIONAL_RAS_FUNCTION(RASENUMDEVICES, RasEnumDevices);
407 RESOLVE_OPTIONAL_RAS_FUNCTION(RASCONNECTIONNOTIFICATION, RasConnectionNotification);
408 }
409
410 // keep your preprocessor name space clean
411 #undef RESOLVE_RAS_FUNCTION
412 #undef RESOLVE_OPTIONAL_RAS_FUNCTION
413
414 exit:
415 if ( funcName )
416 {
417 static const wxChar *msg = wxTRANSLATE(
418 "The version of remote access service (RAS) installed on this machine is too\
419 old, please upgrade (the following required function is missing: %s)."
420 );
421
422 wxLogError(wxGetTranslation(msg), funcName);
423 m_dllRas.Unload();
424 return;
425 }
426 }
427
428 // enable auto check by default
429 EnableAutoCheckOnlineStatus(0);
430 }
431
432 wxDialUpManagerMSW::~wxDialUpManagerMSW()
433 {
434 CleanUpThreadData();
435 }
436
437 // ----------------------------------------------------------------------------
438 // helper functions
439 // ----------------------------------------------------------------------------
440
441 wxString wxDialUpManagerMSW::GetErrorString(DWORD error)
442 {
443 wxChar buffer[512]; // this should be more than enough according to MS docs
444 DWORD dwRet = ms_pfnRasGetErrorString(error, buffer, WXSIZEOF(buffer));
445 switch ( dwRet )
446 {
447 case ERROR_INVALID_PARAMETER:
448 // this was a standard Win32 error probably
449 return wxString(wxSysErrorMsg(error));
450
451 default:
452 {
453 wxLogSysError(dwRet,
454 _("Failed to retrieve text of RAS error message"));
455
456 wxString msg;
457 msg.Printf(_("unknown error (error code %08x)."), error);
458 return msg;
459 }
460
461 case 0:
462 // we want the error message to start from a lower case letter
463 buffer[0] = wxTolower(buffer[0]);
464
465 return wxString(buffer);
466 }
467 }
468
469 HRASCONN wxDialUpManagerMSW::FindActiveConnection()
470 {
471 // enumerate connections
472 DWORD cbBuf = sizeof(RASCONN);
473 LPRASCONN lpRasConn = (LPRASCONN)malloc(cbBuf);
474 if ( !lpRasConn )
475 {
476 // out of memory
477 return 0;
478 }
479
480 lpRasConn->dwSize = sizeof(RASCONN);
481
482 DWORD nConnections = 0;
483 DWORD dwRet = ERROR_BUFFER_TOO_SMALL;
484
485 while ( dwRet == ERROR_BUFFER_TOO_SMALL )
486 {
487 dwRet = ms_pfnRasEnumConnections(lpRasConn, &cbBuf, &nConnections);
488
489 if ( dwRet == ERROR_BUFFER_TOO_SMALL )
490 {
491 LPRASCONN lpRasConnOld = lpRasConn;
492 lpRasConn = (LPRASCONN)realloc(lpRasConn, cbBuf);
493 if ( !lpRasConn )
494 {
495 // out of memory
496 free(lpRasConnOld);
497
498 return 0;
499 }
500 }
501 else if ( dwRet == 0 )
502 {
503 // ok, success
504 break;
505 }
506 else
507 {
508 // an error occured
509 wxLogError(_("Cannot find active dialup connection: %s"),
510 GetErrorString(dwRet).c_str());
511 return 0;
512 }
513 }
514
515 HRASCONN hrasconn;
516
517 switch ( nConnections )
518 {
519 case 0:
520 // no connections
521 hrasconn = 0;
522 break;
523
524 default:
525 // more than 1 connection - we don't know what to do with this
526 // case, so give a warning but continue (taking the first
527 // connection) - the warning is really needed because this function
528 // is used, for example, to select the connection to hang up and so
529 // we may hang up the wrong connection here...
530 wxLogWarning(_("Several active dialup connections found, choosing one randomly."));
531 // fall through
532
533 case 1:
534 // exactly 1 connection, great
535 hrasconn = lpRasConn->hrasconn;
536 }
537
538 free(lpRasConn);
539
540 return hrasconn;
541 }
542
543 void wxDialUpManagerMSW::CleanUpThreadData()
544 {
545 if ( m_hThread )
546 {
547 if ( !SetEvent(m_data->hEventQuit) )
548 {
549 wxLogLastError(_T("SetEvent(RasThreadQuit)"));
550 }
551 else // sent quit request to the background thread
552 {
553 // the thread still needs m_data so we can't free it here, rather
554 // let the thread do it itself
555 m_data = NULL;
556 }
557
558 CloseHandle(m_hThread);
559
560 m_hThread = 0;
561 }
562
563 if ( m_data )
564 {
565 delete m_data;
566 m_data = NULL;
567 }
568 }
569
570 // ----------------------------------------------------------------------------
571 // connection status
572 // ----------------------------------------------------------------------------
573
574 void wxDialUpManagerMSW::CheckRasStatus()
575 {
576 // use int, not bool to compare with -1
577 int isConnected = FindActiveConnection() != 0;
578 if ( isConnected != ms_isConnected )
579 {
580 if ( ms_isConnected != -1 )
581 {
582 // notify the program
583 NotifyApp(isConnected != 0);
584 }
585 // else: it's the first time we're called, just update the flag
586
587 ms_isConnected = isConnected;
588 }
589 }
590
591 void wxDialUpManagerMSW::NotifyApp(bool connected, bool fromOurselves) const
592 {
593 wxDialUpEvent event(connected, fromOurselves);
594 (void)wxTheApp->ProcessEvent(event);
595 }
596
597 // this function is called whenever the status of any RAS connection on this
598 // machine changes by RAS itself
599 void wxDialUpManagerMSW::OnConnectStatusChange()
600 {
601 // we know that status changed, but we don't know whether we're connected
602 // or not - so find it out
603 CheckRasStatus();
604 }
605
606 // this function is called by our callback which we give to RasDial() when
607 // calling it asynchronously
608 void wxDialUpManagerMSW::OnDialProgress(RASCONNSTATE rasconnstate,
609 DWORD dwError)
610 {
611 if ( !GetDialer() )
612 {
613 // this probably means that CancelDialing() was called and we get
614 // "disconnected" notification
615 return;
616 }
617
618 // we're only interested in 2 events: connected and disconnected
619 if ( dwError )
620 {
621 wxLogError(_("Failed to establish dialup connection: %s"),
622 GetErrorString(dwError).c_str());
623
624 // we should still call RasHangUp() if we got a non 0 connection
625 if ( ms_hRasConnection )
626 {
627 ms_pfnRasHangUp(ms_hRasConnection);
628 ms_hRasConnection = 0;
629 }
630
631 ms_dialer = NULL;
632
633 NotifyApp(FALSE /* !connected */, TRUE /* we dialed ourselves */);
634 }
635 else if ( rasconnstate == RASCS_Connected )
636 {
637 ms_isConnected = TRUE;
638 ms_dialer = NULL;
639
640 NotifyApp(TRUE /* connected */, TRUE /* we dialed ourselves */);
641 }
642 }
643
644 // ----------------------------------------------------------------------------
645 // implementation of wxDialUpManager functions
646 // ----------------------------------------------------------------------------
647
648 bool wxDialUpManagerMSW::IsOk() const
649 {
650 return m_dllRas.IsLoaded();
651 }
652
653 size_t wxDialUpManagerMSW::GetISPNames(wxArrayString& names) const
654 {
655 // fetch the entries
656 DWORD size = sizeof(RASENTRYNAME);
657 RASENTRYNAME *rasEntries = (RASENTRYNAME *)malloc(size);
658 rasEntries->dwSize = sizeof(RASENTRYNAME);
659
660 DWORD nEntries;
661 DWORD dwRet;
662 do
663 {
664 dwRet = ms_pfnRasEnumEntries
665 (
666 NULL, // reserved
667 NULL, // default phone book (or all)
668 rasEntries, // [out] buffer for the entries
669 &size, // [in/out] size of the buffer
670 &nEntries // [out] number of entries fetched
671 );
672
673 if ( dwRet == ERROR_BUFFER_TOO_SMALL )
674 {
675 // reallocate the buffer
676 rasEntries = (RASENTRYNAME *)realloc(rasEntries, size);
677 }
678 else if ( dwRet != 0 )
679 {
680 // some other error - abort
681 wxLogError(_("Failed to get ISP names: %s"),
682 GetErrorString(dwRet).c_str());
683
684 free(rasEntries);
685
686 return 0u;
687 }
688 }
689 while ( dwRet != 0 );
690
691 // process them
692 names.Empty();
693 for ( size_t n = 0; n < (size_t)nEntries; n++ )
694 {
695 names.Add(rasEntries[n].szEntryName);
696 }
697
698 free(rasEntries);
699
700 // return the number of entries
701 return names.GetCount();
702 }
703
704 bool wxDialUpManagerMSW::Dial(const wxString& nameOfISP,
705 const wxString& username,
706 const wxString& password,
707 bool async)
708 {
709 // check preconditions
710 wxCHECK_MSG( IsOk(), FALSE, wxT("using uninitialized wxDialUpManager") );
711
712 if ( ms_hRasConnection )
713 {
714 wxFAIL_MSG(wxT("there is already an active connection"));
715
716 return TRUE;
717 }
718
719 // get the default ISP if none given
720 wxString entryName(nameOfISP);
721 if ( !entryName )
722 {
723 wxArrayString names;
724 size_t count = GetISPNames(names);
725 switch ( count )
726 {
727 case 0:
728 // no known ISPs, abort
729 wxLogError(_("Failed to connect: no ISP to dial."));
730
731 return FALSE;
732
733 case 1:
734 // only one ISP, choose it
735 entryName = names[0u];
736 break;
737
738 default:
739 // several ISPs, let the user choose
740 {
741 wxString *strings = new wxString[count];
742 for ( size_t i = 0; i < count; i++ )
743 {
744 strings[i] = names[i];
745 }
746
747 entryName = wxGetSingleChoice
748 (
749 _("Choose ISP to dial"),
750 _("Please choose which ISP do you want to connect to"),
751 count,
752 strings
753 );
754
755 delete [] strings;
756
757 if ( !entryName )
758 {
759 // cancelled by user
760 return FALSE;
761 }
762 }
763 }
764 }
765
766 RASDIALPARAMS rasDialParams;
767 rasDialParams.dwSize = sizeof(rasDialParams);
768 wxStrncpy(rasDialParams.szEntryName, entryName, RAS_MaxEntryName);
769
770 // do we have the username and password?
771 if ( !username || !password )
772 {
773 BOOL gotPassword;
774 DWORD dwRet = ms_pfnRasGetEntryDialParams
775 (
776 NULL, // default phonebook
777 &rasDialParams, // [in/out] the params of this entry
778 &gotPassword // [out] did we get password?
779 );
780
781 if ( dwRet != 0 )
782 {
783 wxLogError(_("Failed to connect: missing username/password."));
784
785 return FALSE;
786 }
787 }
788 else
789 {
790 wxStrncpy(rasDialParams.szUserName, username, UNLEN);
791 wxStrncpy(rasDialParams.szPassword, password, PWLEN);
792 }
793
794 // default values for other fields
795 rasDialParams.szPhoneNumber[0] = '\0';
796 rasDialParams.szCallbackNumber[0] = '\0';
797 rasDialParams.szCallbackNumber[0] = '\0';
798
799 rasDialParams.szDomain[0] = '*';
800 rasDialParams.szDomain[1] = '\0';
801
802 // apparently, this is not really necessary - passing NULL instead of the
803 // phone book has the same effect
804 #if 0
805 wxString phoneBook;
806 if ( wxGetOsVersion() == wxWINDOWS_NT )
807 {
808 // first get the length
809 UINT nLen = ::GetSystemDirectory(NULL, 0);
810 nLen++;
811
812 if ( !::GetSystemDirectory(phoneBook.GetWriteBuf(nLen), nLen) )
813 {
814 wxLogSysError(_("Cannot find the location of address book file"));
815 }
816
817 phoneBook.UngetWriteBuf();
818
819 // this is the default phone book
820 phoneBook << "\\ras\\rasphone.pbk";
821 }
822 #endif // 0
823
824 // TODO may be we should disable auto check while async dialing is in
825 // progress?
826
827 ms_dialer = this;
828
829 DWORD dwRet = ms_pfnRasDial
830 (
831 NULL, // no extended features
832 NULL, // default phone book file (NT only)
833 &rasDialParams,
834 0, // use callback for notifications
835 async ? (void *)wxRasDialFunc // cast needed for gcc 3.1
836 : 0, // no notifications, sync operation
837 &ms_hRasConnection
838 );
839
840 if ( dwRet != 0 )
841 {
842 // can't pass a wxWCharBuffer through ( ... )
843 wxLogError(_("Failed to %s dialup connection: %s"),
844 wxString(async ? _("initiate") : _("establish")).c_str(),
845 GetErrorString(dwRet).c_str());
846
847 // we should still call RasHangUp() if we got a non 0 connection
848 if ( ms_hRasConnection )
849 {
850 ms_pfnRasHangUp(ms_hRasConnection);
851 ms_hRasConnection = 0;
852 }
853
854 ms_dialer = NULL;
855
856 return FALSE;
857 }
858
859 // for async dialing, we're not yet connected
860 if ( !async )
861 {
862 ms_isConnected = TRUE;
863 }
864
865 return TRUE;
866 }
867
868 bool wxDialUpManagerMSW::IsDialing() const
869 {
870 return GetDialer() != NULL;
871 }
872
873 bool wxDialUpManagerMSW::CancelDialing()
874 {
875 if ( !GetDialer() )
876 {
877 // silently ignore
878 return FALSE;
879 }
880
881 wxASSERT_MSG( ms_hRasConnection, wxT("dialing but no connection?") );
882
883 ms_dialer = NULL;
884
885 return HangUp();
886 }
887
888 bool wxDialUpManagerMSW::HangUp()
889 {
890 wxCHECK_MSG( IsOk(), FALSE, wxT("using uninitialized wxDialUpManager") );
891
892 // we may terminate either the connection we initiated or another one which
893 // is active now
894 HRASCONN hRasConn;
895 if ( ms_hRasConnection )
896 {
897 hRasConn = ms_hRasConnection;
898
899 ms_hRasConnection = 0;
900 }
901 else
902 {
903 hRasConn = FindActiveConnection();
904 }
905
906 if ( !hRasConn )
907 {
908 wxLogError(_("Cannot hang up - no active dialup connection."));
909
910 return FALSE;
911 }
912
913 DWORD dwRet = ms_pfnRasHangUp(hRasConn);
914 if ( dwRet != 0 )
915 {
916 wxLogError(_("Failed to terminate the dialup connection: %s"),
917 GetErrorString(dwRet).c_str());
918 }
919
920 ms_isConnected = FALSE;
921
922 return TRUE;
923 }
924
925 bool wxDialUpManagerMSW::IsAlwaysOnline() const
926 {
927 // assume no permanent connection by default
928 bool isAlwaysOnline = FALSE;
929
930 // try to use WinInet functions
931
932 // NB: we could probably use wxDynamicLibrary here just as well,
933 // but we allow multiple instances of wxDialUpManagerMSW so
934 // we might as well use the ref counted version here too.
935
936 wxDynamicLibrary hDll(_T("WININET"));
937 if ( hDll.IsLoaded() )
938 {
939 typedef BOOL (WINAPI *INTERNETGETCONNECTEDSTATE)(LPDWORD, DWORD);
940 INTERNETGETCONNECTEDSTATE pfnInternetGetConnectedState;
941
942 #define RESOLVE_FUNCTION(type, name) \
943 pfn##name = (type)hDll.GetSymbol(_T(#name))
944
945 RESOLVE_FUNCTION(INTERNETGETCONNECTEDSTATE, InternetGetConnectedState);
946
947 if ( pfnInternetGetConnectedState )
948 {
949 DWORD flags = 0;
950 if ( pfnInternetGetConnectedState(&flags, 0 /* reserved */) )
951 {
952 // there is some connection to the net, see of which type
953 isAlwaysOnline = (flags & (INTERNET_CONNECTION_LAN |
954 INTERNET_CONNECTION_PROXY)) != 0;
955 }
956 //else: no Internet connection at all
957 }
958 }
959
960 return isAlwaysOnline;
961 }
962
963 bool wxDialUpManagerMSW::IsOnline() const
964 {
965 wxCHECK_MSG( IsOk(), FALSE, wxT("using uninitialized wxDialUpManager") );
966
967 if ( IsAlwaysOnline() )
968 {
969 // always => now
970 return true;
971 }
972
973 if ( ms_userSpecifiedOnlineStatus != -1 )
974 {
975 // user specified flag overrides our logic
976 return ms_userSpecifiedOnlineStatus != 0;
977 }
978 else
979 {
980 // return TRUE if there is at least one active connection
981 return FindActiveConnection() != 0;
982 }
983 }
984
985 void wxDialUpManagerMSW::SetOnlineStatus(bool isOnline)
986 {
987 wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );
988
989 ms_userSpecifiedOnlineStatus = isOnline;
990 }
991
992 bool wxDialUpManagerMSW::EnableAutoCheckOnlineStatus(size_t nSeconds)
993 {
994 wxCHECK_MSG( IsOk(), FALSE, wxT("using uninitialized wxDialUpManager") );
995
996 if ( m_autoCheckLevel++ )
997 {
998 // already checking
999 return TRUE;
1000 }
1001
1002 bool ok = ms_pfnRasConnectionNotification != 0;
1003
1004 if ( ok )
1005 {
1006 // we're running under NT 4.0, Windows 98 or later and can use
1007 // RasConnectionNotification() to be notified by a secondary thread
1008
1009 // first, see if we don't have this thread already running
1010 if ( m_hThread != 0 )
1011 {
1012 if ( ::ResumeThread(m_hThread) != (DWORD)-1 )
1013 return TRUE;
1014
1015 // we're leaving a zombie thread... but what else can we do?
1016 wxLogLastError(wxT("ResumeThread(RasThread)"));
1017
1018 ok = FALSE;
1019 }
1020 }
1021
1022 // create all the stuff we need to be notified about RAS connection
1023 // status change
1024
1025 if ( ok )
1026 {
1027 // first create an event to wait on
1028 m_data->hEventRas = CreateEvent
1029 (
1030 NULL, // security attribute (default)
1031 FALSE, // manual reset (no, it is automatic)
1032 FALSE, // initial state (not signaled)
1033 NULL // name (no)
1034 );
1035 if ( !m_data->hEventRas )
1036 {
1037 wxLogLastError(wxT("CreateEvent(RasStatus)"));
1038
1039 ok = FALSE;
1040 }
1041 }
1042
1043 if ( ok )
1044 {
1045 // create the event we use to quit the thread: using a manual event
1046 // here avoids problems with missing the event if wxDialUpManagerMSW
1047 // is created and destroyed immediately, before wxRasStatusWindowProc
1048 // starts waiting on the event
1049 m_data->hEventQuit = CreateEvent
1050 (
1051 NULL, // default security
1052 TRUE, // manual event
1053 FALSE, // initially non signalled
1054 NULL // nameless
1055 );
1056 if ( !m_data->hEventQuit )
1057 {
1058 wxLogLastError(wxT("CreateEvent(RasThreadQuit)"));
1059
1060 CleanUpThreadData();
1061
1062 ok = FALSE;
1063 }
1064 }
1065
1066 if ( ok && !ms_hwndRas )
1067 {
1068 // create a hidden window to receive notification about connections
1069 // status change
1070 extern const wxChar *wxCanvasClassName;
1071 ms_hwndRas = ::CreateWindow(wxCanvasClassName, NULL,
1072 0, 0, 0, 0,
1073 0, NULL,
1074 (HMENU)NULL, wxGetInstance(), 0);
1075 if ( !ms_hwndRas )
1076 {
1077 wxLogLastError(wxT("CreateWindow(RasHiddenWindow)"));
1078
1079 CleanUpThreadData();
1080
1081 ok = FALSE;
1082 }
1083
1084 // and subclass it
1085 wxSetWindowProc(ms_hwndRas, wxRasStatusWindowProc);
1086 }
1087
1088 m_data->hWnd = ms_hwndRas;
1089
1090 if ( ok )
1091 {
1092 // start the secondary thread
1093 m_data->dialUpManager = this;
1094
1095 DWORD tid;
1096 m_hThread = CreateThread
1097 (
1098 NULL,
1099 0,
1100 (LPTHREAD_START_ROUTINE)wxRasMonitorThread,
1101 (void *)m_data,
1102 0,
1103 &tid
1104 );
1105
1106 if ( !m_hThread )
1107 {
1108 wxLogLastError(wxT("CreateThread(RasStatusThread)"));
1109
1110 CleanUpThreadData();
1111 }
1112 }
1113
1114 if ( ok )
1115 {
1116 // start receiving RAS notifications
1117 DWORD dwRet = ms_pfnRasConnectionNotification
1118 (
1119 (HRASCONN)INVALID_HANDLE_VALUE,
1120 m_data->hEventRas,
1121 3 /* RASCN_Connection | RASCN_Disconnection */
1122 );
1123
1124 if ( dwRet != 0 )
1125 {
1126 wxLogDebug(wxT("RasConnectionNotification() failed: %s"),
1127 GetErrorString(dwRet).c_str());
1128
1129 CleanUpThreadData();
1130 }
1131 else
1132 {
1133 return TRUE;
1134 }
1135 }
1136
1137 // we're running under Windows 95 and have to poll ourselves
1138 // (or, alternatively, the code above for NT/98 failed)
1139 m_timerStatusPolling.Stop();
1140 if ( nSeconds == 0 )
1141 {
1142 // default value
1143 nSeconds = 60;
1144 }
1145 m_timerStatusPolling.Start(nSeconds * 1000);
1146
1147 return TRUE;
1148 }
1149
1150 void wxDialUpManagerMSW::DisableAutoCheckOnlineStatus()
1151 {
1152 wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );
1153
1154 if ( --m_autoCheckLevel )
1155 {
1156 // still checking
1157 return;
1158 }
1159
1160 if ( m_hThread )
1161 {
1162 // we have running secondary thread, it's just enough to suspend it
1163 if ( SuspendThread(m_hThread) == (DWORD)-1 )
1164 {
1165 wxLogLastError(wxT("SuspendThread(RasThread)"));
1166 }
1167 }
1168 else
1169 {
1170 // even simpler - just stop the timer
1171 m_timerStatusPolling.Stop();
1172 }
1173 }
1174
1175 // ----------------------------------------------------------------------------
1176 // stubs which don't do anything in MSW version
1177 // ----------------------------------------------------------------------------
1178
1179 void wxDialUpManagerMSW::SetWellKnownHost(const wxString& WXUNUSED(hostname),
1180 int WXUNUSED(port))
1181 {
1182 wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );
1183
1184 // nothing to do - we don't use this
1185 }
1186
1187 void wxDialUpManagerMSW::SetConnectCommand(const wxString& WXUNUSED(dial),
1188 const wxString& WXUNUSED(hangup))
1189 {
1190 wxCHECK_RET( IsOk(), wxT("using uninitialized wxDialUpManager") );
1191
1192 // nothing to do - we don't use this
1193 }
1194
1195 // ----------------------------------------------------------------------------
1196 // callbacks
1197 // ----------------------------------------------------------------------------
1198
1199 static DWORD wxRasMonitorThread(wxRasThreadData *data)
1200 {
1201 HANDLE handles[2];
1202 handles[0] = data->hEventRas;
1203 handles[1] = data->hEventQuit;
1204
1205 bool cont = TRUE;
1206 while ( cont )
1207 {
1208 DWORD dwRet = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
1209
1210 switch ( dwRet )
1211 {
1212 case WAIT_OBJECT_0:
1213 // RAS connection status changed
1214 SendMessage(data->hWnd, wxWM_RAS_STATUS_CHANGED,
1215 0, (LPARAM)data);
1216 break;
1217
1218 case WAIT_OBJECT_0 + 1:
1219 cont = FALSE;
1220 break;
1221
1222 default:
1223 wxFAIL_MSG( _T("unexpected return of WaitForMultipleObjects()") );
1224 // fall through
1225
1226 case WAIT_FAILED:
1227 #ifdef __WXDEBUG__
1228 // using wxLogLastError() from here is dangerous: we risk to
1229 // deadlock the main thread if wxLog sends output to GUI
1230 DWORD err = GetLastError();
1231 wxMessageOutputDebug().Printf
1232 (
1233 wxT("WaitForMultipleObjects(RasMonitor) failed: 0x%08lx (%s)"),
1234 err,
1235 wxSysErrorMsg(err)
1236 );
1237 #endif // __WXDEBUG__
1238
1239 // no sense in continuing, who knows if the handles we're
1240 // waiting for even exist yet...
1241 return (DWORD)-1;
1242 }
1243 }
1244
1245 // we don't need it any more now and if this thread ran, it is our
1246 // responsability to free the data
1247 delete data;
1248
1249 return 0;
1250 }
1251
1252 static LRESULT APIENTRY wxRasStatusWindowProc(HWND hWnd, UINT message,
1253 WPARAM wParam, LPARAM lParam)
1254 {
1255 switch ( message )
1256 {
1257 case wxWM_RAS_STATUS_CHANGED:
1258 {
1259 wxRasThreadData *data = (wxRasThreadData *)lParam;
1260 data->dialUpManager->OnConnectStatusChange();
1261 }
1262 break;
1263
1264 case wxWM_RAS_DIALING_PROGRESS:
1265 {
1266 wxDialUpManagerMSW *dialMan = wxDialUpManagerMSW::GetDialer();
1267
1268 dialMan->OnDialProgress((RASCONNSTATE)wParam, lParam);
1269 }
1270 break;
1271
1272 default:
1273 return ::DefWindowProc(hWnd, message, wParam, lParam);
1274 }
1275
1276 return 0;
1277 }
1278
1279 static void WINAPI wxRasDialFunc(UINT WXUNUSED(unMsg),
1280 RASCONNSTATE rasconnstate,
1281 DWORD dwError)
1282 {
1283 wxDialUpManagerMSW *dialUpManager = wxDialUpManagerMSW::GetDialer();
1284
1285 wxCHECK_RET( dialUpManager, wxT("who started to dial then?") );
1286
1287 SendMessage(dialUpManager->GetRasWindow(), wxWM_RAS_DIALING_PROGRESS,
1288 rasconnstate, dwError);
1289 }
1290
1291 #endif // __BORLANDC__
1292
1293 #endif // wxUSE_DIALUP_MANAGER
1294