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