DlgSecureRule.cpp

Go to the documentation of this file.

//
// DlgSecureRule.cpp
//
// Copyright (c) Shareaza Development Team, 2002-2005.
// This file is part of SHAREAZA (www.shareaza.com)
//
// Shareaza is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Shareaza is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Shareaza; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

#include "StdAfx.h"
#include "Shareaza.h"
#include "Settings.h"
#include "Security.h"
#include "Network.h"
#include "Skin.h"
#include "DlgSecureRule.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

BEGIN_MESSAGE_MAP(CSecureRuleDlg, CSkinDialog)
        //{{AFX_MSG_MAP(CSecureRuleDlg)
        ON_CBN_SELCHANGE(IDC_RULE_EXPIRE, OnSelChangeRuleExpire)
        ON_CBN_SELCHANGE(IDC_RULE_TYPE, OnSelChangeRuleType)
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()


// CSecureRuleDlg dialog

CSecureRuleDlg::CSecureRuleDlg(CWnd* pParent, CSecureRule* pRule) : CSkinDialog(CSecureRuleDlg::IDD, pParent)
{
        //{{AFX_DATA_INIT(CSecureRuleDlg)
        m_nExpireD = 0;
        m_nExpireH = 0;
        m_nExpireM = 0;
        m_nAction = -1;
        m_nExpire = -1;
        m_sComment = _T("");
        m_nType = -1;
        m_sContent = _T("");
        m_nMatch = -1;
        //}}AFX_DATA_INIT
        m_pRule = pRule;
        m_bNew  = FALSE;
}

CSecureRuleDlg::~CSecureRuleDlg()
{
        if ( m_pRule && m_bNew ) delete m_pRule;
}

void CSecureRuleDlg::DoDataExchange(CDataExchange* pDX)
{
        CSkinDialog::DoDataExchange(pDX);
        //{{AFX_DATA_MAP(CSecureRuleDlg)
        DDX_Control(pDX, IDC_RULE_CONTENT, m_wndContent);
        DDX_Control(pDX, IDC_GROUP_CONTENT, m_wndGroupContent);
        DDX_Control(pDX, IDC_GROUP_NETWORK, m_wndGroupNetwork);
        DDX_Control(pDX, IDC_EXPIRE_M, m_wndExpireM);
        DDX_Control(pDX, IDC_EXPIRE_H, m_wndExpireH);
        DDX_Control(pDX, IDC_EXPIRE_D, m_wndExpireD);
        DDX_Control(pDX, IDC_MASK_4, m_wndMask4);
        DDX_Control(pDX, IDC_MASK_3, m_wndMask3);
        DDX_Control(pDX, IDC_MASK_2, m_wndMask2);
        DDX_Control(pDX, IDC_MASK_1, m_wndMask1);
        DDX_Control(pDX, IDC_IP_4, m_wndIP4);
        DDX_Control(pDX, IDC_IP_3, m_wndIP3);
        DDX_Control(pDX, IDC_IP_2, m_wndIP2);
        DDX_Control(pDX, IDC_IP_1, m_wndIP1);
        DDX_Text(pDX, IDC_EXPIRE_D, m_nExpireD);
        DDX_Text(pDX, IDC_EXPIRE_H, m_nExpireH);
        DDX_Text(pDX, IDC_EXPIRE_M, m_nExpireM);
        DDX_CBIndex(pDX, IDC_RULE_ACTION, m_nAction);
        DDX_CBIndex(pDX, IDC_RULE_EXPIRE, m_nExpire);
        DDX_Text(pDX, IDC_RULE_COMMENT, m_sComment);
        DDX_CBIndex(pDX, IDC_RULE_TYPE, m_nType);
        DDX_Text(pDX, IDC_RULE_CONTENT, m_sContent);
        DDX_Radio(pDX, IDC_RULE_MATCH_0, m_nMatch);
        //}}AFX_DATA_MAP
}

// CSecureRuleDlg message handlers

BOOL CSecureRuleDlg::OnInitDialog()
{
        CSkinDialog::OnInitDialog();

        SkinMe( _T("CSecureRuleDlg"), IDR_SECURITYFRAME );

        CSingleLock pLock( &Network.m_pSection, TRUE );

        m_bNew = ! Security.Check( m_pRule );
        if ( m_bNew ) m_pRule = new CSecureRule();

        m_nType         = m_pRule->m_nType;
        m_sComment      = m_pRule->m_sComment;
        m_nAction       = m_pRule->m_nAction;
        m_nExpire       = min( m_pRule->m_nExpire, DWORD(2) );
        m_nMatch        = 0;

        if ( m_pRule->m_nType == CSecureRule::srAddress )
        {
                CEdit* pwIP[4]          = { &m_wndIP1, &m_wndIP2, &m_wndIP3, &m_wndIP4 };
                CEdit* pwMask[4]        = { &m_wndMask1, &m_wndMask2, &m_wndMask3, &m_wndMask4 };

                for ( int nByte = 0 ; nByte < 4 ; nByte++ )
                {
                        CString strItem;

                        strItem.Format( _T("%lu"), m_pRule->m_nMask[ nByte ] );
                        pwMask[ nByte ]->SetWindowText( strItem );

                        if ( m_pRule->m_nMask[ nByte ] == 0 )
                        {
                                pwIP[ nByte ]->SetWindowText( _T("*") );
                        }
                        else
                        {
                                strItem.Format( _T("%lu"), m_pRule->m_nIP[ nByte ] );
                                pwIP[ nByte ]->SetWindowText( strItem );
                        }
                }
        }
        else if ( m_pRule->m_nType == CSecureRule::srContent )
        {
                m_sContent = m_pRule->GetContentWords();
                m_nMatch = m_pRule->m_nIP[0] == 1;
        }

        if ( m_nExpire == 2 )
        {
                DWORD nTime = m_pRule->m_nExpire - time( NULL );
                m_nExpireD = nTime / 86400;
                m_nExpireH = ( nTime % 86400 ) / 3600;
                m_nExpireM = ( nTime % 3600 ) / 60;
        }

        pLock.Unlock();

        UpdateData( FALSE );

        OnSelChangeRuleExpire();
        OnSelChangeRuleType();

        return FALSE;
}

void CSecureRuleDlg::ShowGroup(CWnd* pWnd, BOOL bShow)
{
        while ( pWnd )
        {
                pWnd->ShowWindow( bShow ? SW_SHOW : SW_HIDE );
                pWnd = pWnd->GetNextWindow();

                if ( pWnd->GetStyle() & WS_GROUP )
                {
                        if ( pWnd->GetDlgCtrlID() != IDC_RULE_MATCH_0 ) break;
                }
        }
}

void CSecureRuleDlg::OnSelChangeRuleType()
{
        UpdateData();

        ShowGroup( &m_wndGroupNetwork, m_nType == CSecureRule::srAddress );
        ShowGroup( &m_wndGroupContent, m_nType == CSecureRule::srContent );

        switch ( m_nType )
        {
        case CSecureRule::srAddress:
                m_wndIP1.SetFocus();
                m_wndIP1.SetSel( 0, -1 );
                break;
        case CSecureRule::srContent:
                m_wndContent.SetFocus();
                break;
        }
}

void CSecureRuleDlg::OnSelChangeRuleExpire()
{
        UpdateData();
        m_wndExpireD.EnableWindow( m_nExpire == 2 );
        m_wndExpireH.EnableWindow( m_nExpire == 2 );
        m_wndExpireM.EnableWindow( m_nExpire == 2 );
}

BOOL CSecureRuleDlg::PreTranslateMessage(MSG* pMsg)
{
        if ( pMsg->message == WM_CHAR )
        {
                CEdit* pwIP[4]          = { &m_wndIP1, &m_wndIP2, &m_wndIP3, &m_wndIP4 };
                CEdit* pwMask[4]        = { &m_wndMask1, &m_wndMask2, &m_wndMask3, &m_wndMask4 };
                CWnd* pFocus            = GetFocus();

                for ( int nByte = 0 ; nByte < 4 && pFocus ; nByte++ )
                {
                        if ( pFocus == pwIP[ nByte ] || pFocus == pwMask[ nByte ] )
                        {
                                if ( pMsg->wParam == '.' )
                                {
                                        if ( nByte == 3 ) return TRUE;

                                        if ( pFocus == pwIP[ nByte ] )
                                        {
                                                pwIP[ nByte + 1 ]->SetFocus();
                                                pwIP[ nByte + 1 ]->SetSel( 0, -1 );
                                        }
                                        else
                                        {
                                                pwMask[ nByte + 1 ]->SetFocus();
                                                pwMask[ nByte + 1 ]->SetSel( 0, -1 );
                                        }

                                        return TRUE;
                                }
                                else if ( pMsg->wParam == '*' )
                                {
                                        if ( pFocus != pwIP[ nByte ] ) return TRUE;
                                        pwIP[ nByte ]->SetWindowText( _T("*") );
                                        pwMask[ nByte ]->SetWindowText( _T("0") );
                                        pwIP[ nByte ]->SetSel( 0, 1 );
                                        pwMask[ nByte ]->SetSel( 0, 1 );
                                        return TRUE;
                                }
                                else if ( pMsg->wParam >= 32 && ! _istdigit( (TCHAR)pMsg->wParam ) )
                                {
                                        return TRUE;
                                }

                                break;
                        }
                }
        }

        return CSkinDialog::PreTranslateMessage(pMsg);
}

void CSecureRuleDlg::OnOK()
{
        UpdateData( TRUE );

        CSingleLock pLock( &Network.m_pSection, TRUE );

        if ( ! m_bNew && ! Security.Check( m_pRule ) ) m_pRule = new CSecureRule();

        m_pRule->m_nType        = m_nType;
        m_pRule->m_sComment     = m_sComment;
        m_pRule->m_nAction      = m_nAction;
        m_pRule->m_nExpire      = m_nExpire;

        if ( m_nExpire == 2 )
        {
                m_pRule->m_nExpire      = time( NULL ) + m_nExpireD * 86400
                                                        + m_nExpireH * 3600 + m_nExpireM * 60;
        }

        if ( m_pRule->m_nType == CSecureRule::srAddress )
        {
                CEdit* pwIP[4]          = { &m_wndIP1, &m_wndIP2, &m_wndIP3, &m_wndIP4 };
                CEdit* pwMask[4]        = { &m_wndMask1, &m_wndMask2, &m_wndMask3, &m_wndMask4 };

                for ( int nByte = 0 ; nByte < 4 ; nByte++ )
                {
                        CString strItem;
                        int nValue = 0;

                        pwIP[ nByte ]->GetWindowText( strItem );
                        if ( _stscanf( strItem, _T("%lu"), &nValue ) != 1 ) nValue = 0;
                        m_pRule->m_nIP[ nByte ] = (BYTE)max( 0, min( 255, nValue ) );

                        pwMask[ nByte ]->GetWindowText( strItem );
                        if ( _stscanf( strItem, _T("%lu"), &nValue ) != 1 ) nValue = 0;
                        m_pRule->m_nMask[ nByte ] = (BYTE)max( 0, min( 255, nValue ) );
                }
        }
        else if ( m_pRule->m_nType == CSecureRule::srContent )
        {
                m_pRule->SetContentWords( m_sContent );
                m_pRule->m_nIP[0] = m_nMatch;
        }

        Security.Add( m_pRule );
        m_pRule = NULL;

        pLock.Unlock();

        CSkinDialog::OnOK();
}

---