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