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