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