rnaapp.c

See Hanoi.cpp for the implementation of this cla

{
	TCHAR			szTemp[128];
	
	LoadString (v_hInstance, StringID, szTemp,
				sizeof(szTemp)/sizeof(TCHAR));
	SetWindowText(GetDlgItem(v_hMainWnd, IDC_STATUSMSG),
				  szTemp);
}

DWORD
RasErrorToStringID (DWORD RasError, DWORD Default, BOOL fOnRasDial)
{
	DWORD StringID;
	
	switch (RasError) {
	case ERROR_PORT_DISCONNECTED :
		StringID = IDS_CARRIER_DROPPED;
		break;
	case ERROR_NO_CARRIER :
		if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Modem)) {
			// Dialup
			StringID = IDS_NO_CARRIER;
		} else {
			// Direct
			StringID = IDS_DCC_NO_CARRIER;
		}
		break;
	case ERROR_NO_DIALTONE :
		StringID = IDS_NO_DIALTONE;
		break;
	case ERROR_DEVICE_NOT_READY :
		StringID = IDS_DEVICE_NOT_READY;
		break;
	case ERROR_LINE_BUSY :
		StringID = IDS_LINE_BUSY;
		break;
	case ERROR_NO_ANSWER :
		StringID = IDS_NO_ANSWER;
		break;
	case ERROR_PORT_NOT_AVAILABLE :
		StringID = IDS_PORT_NOT_AVAIL;
		break;
	default :
		StringID = Default;
		break;
	}
	return StringID;
}

BOOL
RasDialEvent( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    RASCONNSTATE    RasState = (RASCONNSTATE)wParam;
	TCHAR			szTemp[128];
	TCHAR			szFmtStr[128];
	LPTSTR			pPhoneStr;
	DWORD			StringID;
    DWORD           Flag;

	DEBUGMSG (ZONE_RAS, (TEXT("RasDialEvent: wParam: 0x%X\r\n"), wParam));

    switch(RasState) {
    case RASCS_OpenPort:
		SetStatusWnd (IDS_OPENING_PORT);
        break;

    case RASCS_PortOpened:
		if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Modem)) {
			pPhoneStr = NULL;
			
	        Flag = 0;
	        if (v_RasEntry.dwfOptions & RASEO_UseCountryAndAreaCodes){
		        Flag |= LINETRANSLATEOPTION_FORCELD;
	        }
				        
	        if (v_RasEntry.dwfOptions & RASEO_DialAsLocalCall) {
		        Flag |= LINETRANSLATEOPTION_FORCELOCAL;
	        }
	
			// Get the displayable phone and dialing from location from TAPI
			pPhoneStr = TapiLineTranslateAddress(v_dwDeviceID,
				v_RasEntry.dwCountryCode,
				v_RasEntry.szAreaCode, v_RasEntry.szLocalPhoneNumber, FALSE, Flag);

			if (pPhoneStr) {
				LoadString (v_hInstance, IDS_DIAL_WITH_NUMBER, szFmtStr,
							sizeof(szFmtStr)/sizeof(TCHAR));
				wsprintf (szTemp, szFmtStr, pPhoneStr);
				LocalFree (pPhoneStr);
				SetWindowText (GetDlgItem(v_hMainWnd, IDC_STATUSMSG), szTemp);
			} else	{
				SetStatusWnd (IDS_DIAL_NO_NUMBER);
			}
		} else {
			if (v_RetryCnt++) {
				LoadString (v_hInstance, IDS_CONNECTING_TO_HOST_RETRY,
							szFmtStr, sizeof(szFmtStr)/sizeof(TCHAR));
				wsprintf (szTemp, szFmtStr, v_RetryCnt);
				SetWindowText(GetDlgItem(v_hMainWnd, IDC_STATUSMSG), szTemp);
			} else {
				SetStatusWnd (IDS_CONNECTING_TO_HOST);
			}
		}
        break;

    case RASCS_ConnectDevice:
		SetStatusWnd (IDS_CONNECTING_DEVICE);
        break;

    case RASCS_DeviceConnected:
		SetStatusWnd (IDS_DEVICE_CONNECTED);
        break;

    case RASCS_AllDevicesConnected:
		SetStatusWnd (IDS_PHY_EST);
        break;

    case RASCS_Authenticate:
		SetStatusWnd (IDS_AUTH_USER);
        break;

    case RASCS_AuthNotify:
		SetStatusWnd (IDS_AUTH_EVENT);

        // Process the lParam 

        switch( lParam ) {
        case ERROR_RESTRICTED_LOGON_HOURS:
			StringID = IDS_AUTH_ERR_REST_HOUR;
			break;
		case ERROR_ACCT_DISABLED:
			StringID = IDS_AUTH_ERR_ACCT_DISABLED;
			break;
        case ERROR_PASSWD_EXPIRED:
			StringID = IDS_AUTH_ERR_PWD_EXP;
			break;
		case ERROR_NO_DIALIN_PERMISSION:
			StringID = IDS_AUTH_ERR_NO_DIALIN;
			break;
        case ERROR_CHANGING_PASSWORD:
			StringID = IDS_AUTH_ERR_CHG_PWD;
			break;
		default :
			StringID = IDS_AUTH_ERR_UNKNOWN;
			break;

		}
		// Clear the saved authentication params
		v_RasDialParams.szUserName[0] = TEXT('\0');
		v_RasDialParams.szPassword[0] = TEXT('\0');
		v_RasDialParams.szDomain[0] = TEXT('\0');
		RasSetEntryDialParams( NULL, &v_RasDialParams, FALSE );

		// Save the error code.
		if (!v_RNAAppInfo.ErrorCode) {
			v_RNAAppInfo.ErrorCode = lParam;
		}
		
		if( !v_fNoMsgBox ) {
			// Let everyone know we're in a message box
			v_fInErrorBox = TRUE;

			// Get the Message box title for error
			ShowError (StringID, IDS_AUTH_ERROR_TITLE);

			if (v_fReturnFalse) {
				return FALSE;
			}
				
		}
        break;

    case RASCS_AuthRetry:
    case RASCS_AuthCallback:
    case RASCS_AuthChangePassword:
        break;

    case RASCS_AuthProject:
		SetStatusWnd (IDS_AUTH_PROJ);
        break;

    case RASCS_AuthLinkSpeed:
        break;

    case RASCS_AuthAck:
		SetStatusWnd (IDS_AUTH_RESP);
        break;

    case RASCS_ReAuthenticate:
        break;

    case RASCS_Authenticated:
		SetStatusWnd (IDS_USER_AUTH);
        break;

    case RASCS_PrepareForCallback:
    case RASCS_WaitForModemReset:
    case RASCS_WaitForCallback:
    case RASCS_Projected:
    case RASCS_Interactive:
    case RASCS_RetryAuthentication:
    case RASCS_CallbackSetByCaller:
    case RASCS_PasswordExpired:

        break;

    case RASCS_Connected:

        // We are CONNECTED - Update Status window
		SetStatusWnd (IDS_CONNECTED);

		// Change button label
		LoadString (v_hInstance, IDS_DISCONNECT, szTemp,
					sizeof(szTemp)/sizeof(TCHAR));
        SetWindowText(GetDlgItem(v_hMainWnd, IDCANCEL), szTemp);
		SetWindowText(GetDlgItem(v_hMainWnd, IDC_CANCEL_TEXT), TEXT(""));

		// Set our window title
		LoadString (v_hInstance, IDS_CONNECTED_TO, szFmtStr,
					sizeof(szFmtStr)/sizeof(TCHAR));
        wsprintf( szTemp, szFmtStr, EntryName );
        SetWindowText( hWnd, szTemp );
		
        if (v_fMinOnConnect) {
	        if(IsAPIReady(SH_SHELL))
   				ShowWindow(v_hMainWnd, SW_HIDE);
   			else
				SetWindowPos(v_hMainWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
        }
        // Send the BROADCAST CONNECTED message

        RETAILMSG( 1, (TEXT("Posting WM_NETCONNECT(TRUE) message\r\n")));
		v_RNAAppInfo.dwSize = sizeof(v_RNAAppInfo);
		v_RNAAppInfo.hWndRNAApp = (DWORD)hWnd;
		v_RNAAppInfo.ErrorCode = 0;
		_tcscpy (v_RNAAppInfo.RasEntryName, EntryName);
        SendNotifyMessage( HWND_BROADCAST, WM_NETCONNECT, (WPARAM)TRUE,
							(LPARAM)&v_RNAAppInfo );
		sndPlaySound(TEXT("RNBegin"), SND_ALIAS|SND_ASYNC|SND_NODEFAULT);
        break;

    case RASCS_Disconnected:
		RETAILMSG (1, (TEXT("RASCS_Disconnected: Ecode=%d\r\n"),
					   lParam));

        // We are DISCONNECTED
		if( CredentialPrompt ) {
			// If the credential window is active cancel it.

			NetDisconnect = TRUE;
			SendMessage( hCredentials, WM_COMMAND, IDCANCEL, 0 );
			NetDisconnect = FALSE;
		}

        // Update Status window
		SetStatusWnd (IDS_DISCONNECTED);

		sndPlaySound(TEXT("RNIntr"), SND_ALIAS|SND_ASYNC|SND_NODEFAULT);
		
		if (!v_RNAAppInfo.ErrorCode) {
			v_RNAAppInfo.ErrorCode = lParam;
		}
		
		// Hangup the RAS connection
        if( v_hRasConn ) {
            RasHangup( v_hRasConn );
            v_hRasConn = 0;
		}

		if( !v_fNoMsgBox && !v_fInErrorBox) {
			
			StringID = RasErrorToStringID (lParam, IDS_DISCONNECTED, FALSE);

			ShowError (StringID, IDS_REM_NET);
		}

		if (v_fInErrorBox) {
		  v_fReturnFalse = TRUE;
		  return TRUE;
		} else {
		  return( FALSE );
		}
        break;
    }
    return TRUE;
}

void PositionSIP(int nSipState)
{
#ifdef USE_SIP
    // Do we have the sip function?
    if (v_lpfnSipGetInfo && v_lpfnSipSetInfo)
    {
	    SIPINFO si;

        // See whether the SIP is up or down
        memset(&si, 0, sizeof(SIPINFO));
        si.cbSize = sizeof(SIPINFO);
        if ((*v_lpfnSipGetInfo)(&si))
        {
            // Has the SIP state changed?
            if ((!(si.fdwFlags & SIPF_ON) && SIP_UP == nSipState) ||
                (si.fdwFlags & SIPF_ON && !(SIP_UP == nSipState)))
            {
                si.fdwFlags ^= SIPF_ON;
		        (*v_lpfnSipSetInfo)(&si);
            }
        }
	}
#endif
}

void LoadSIP(void)
{
#ifdef USE_SIP        
    if( (v_hSipLib = LoadLibrary( TEXT("coredll.dll") )) &&
        (v_lpfnSipStatus = (LPFNSIPSTATUS)GetProcAddress( v_hSipLib, TEXT("SipStatus"))) &&
	    (v_lpfnSipGetInfo = (LPFNSIP)GetProcAddress( v_hSipLib, TEXT("SipGetInfo"))) &&
	    (v_lpfnSipSetInfo = (LPFNSIP)GetProcAddress( v_hSipLib, TEXT("SipSetInfo"))) &&
	    (SIP_STATUS_AVAILABLE == v_lpfnSipStatus()) )
	{
		DEBUGMSG(1, (L"RNAAPP: Sip Loaded & ready\r\n"));
    }
    else
    {
		FreeLibrary(v_hSipLib);
		v_hSipLib = NULL;
        v_lpfnSipStatus = NULL;
	    v_lpfnSipGetInfo = v_lpfnSipSetInfo = NULL;
	}
#endif
}


LRESULT CALLBACK
WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
    TCHAR           szTemp[128];
	TCHAR			szTemp2[128];
	DWORD			RetVal;
    NOTIFYICONDATA  tnid;
	DWORD			StringID;
    int				cxScreen;

    switch( message ) {
    case WM_INITDIALOG:
		// Do the icon
		if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Modem)) {
            SendMessage(GetDlgItem(hWnd, IDC_STATUSICON), STM_SETIMAGE,
                        IMAGE_ICON, (LPARAM) v_hDialupIcon);
		} else if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Direct)) {
            SendMessage(GetDlgItem(hWnd, IDC_STATUSICON), STM_SETIMAGE,
                        IMAGE_ICON, (LPARAM) v_hDirectIcon);
		} else if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Vpn)) {
            SendMessage(GetDlgItem(hWnd, IDC_STATUSICON), STM_SETIMAGE,
                        IMAGE_ICON, (LPARAM) v_hVPNIcon);
		} else {
			RETAILMSG (1, (TEXT("Error, unhandled Device Type\r\n")));
			ASSERT (0);
		}

		
		LoadString (v_hInstance, IDS_CONNECTING_TO, szTemp,
					sizeof(szTemp)/sizeof(TCHAR));
        wsprintf( szTemp2, szTemp, EntryName );
        SetWindowText( hWnd, szTemp2 );

		// Set notification icon
        tnid.cbSize = sizeof(NOTIFYICONDATA); 
        tnid.hWnd = hWnd; 
        tnid.uID = 13; 
        tnid.uFlags = NIF_MESSAGE | NIF_ICON; 
        tnid.uCallbackMessage = IDM_TASKBAR_NOTIFY;
		
		if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Modem)) {
			v_hNotifyIcon = (HICON )LoadImage( v_hInstance,
											   MAKEINTRESOURCE(IDI_DIALUP),
											   IMAGE_ICON, 16, 16,
											   LR_DEFAULTCOLOR);
		} else if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Direct)) {
			v_hNotifyIcon = (HICON )LoadImage( v_hInstance,
											   MAKEINTRESOURCE(IDI_DIRECTCC),
											   IMAGE_ICON, 16, 16,
											   LR_DEFAULTCOLOR);
		} else if (!_tcscmp (v_RasEntry.szDeviceType, RASDT_Vpn)) {
			v_hNotifyIcon = (HICON )LoadImage( v_hInstance,
											   MAKEINTRESOURCE(IDI_VPN),
											   IMAGE_ICON, 16, 16,
											   LR_DEFAULTCOLOR);
		} else {
			RETAILMSG (1, (TEXT("Error, unhandled Device Type\r\n")));
			ASSERT (0);
		}
		tnid.hIcon = v_hNotifyIcon;
			
        if(IsAPIReady(SH_SHELL))
	        Shell_NotifyIcon( NIM_ADD, &tnid );
        // We didn't set the focus so return TRUE....
        return TRUE;
        
    case WM_CREATE:
        break;

    case IDM_START_RASDIAL:
		cxScreen = GetSystemMetrics(SM_CXSCREEN);

        // Start a RAS Session 

        memset( (char *)&v_RasDialParams, 0, sizeof( RASDIALPARAMS ) );

        v_RasDialParams.dwSize = sizeof(RASDIALPARAMS);
        _tcscpy( v_RasDialParams.szEntryName, EntryName );
        RasGetEntryDialParams( NULL, &v_RasDialParams, &v_fPassword );

		// If this is a dial-up entry, show them the user params 
		// (Username/Password, etc) to modify before continuing.

		// Is this a dial-up entry? (and secret no-password not specified)

        ShowWindow( hWnd, SW_SHOW );
		
		if(!v_fNoPassword && !_tcscmp (v_RasEntry.szDeviceType, RASDT_Modem)) {