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