nospamdlg.cpp

maybe is knn or maybe not i m not sure about it it s a temp file

    CFile f(fname, CFile::modeCreate | CFile::modeWrite);
    for (int i = 0; i < m_ruleTypes.GetSize(); ++i)
    {
        CString tmp;
        tmp.Format(
            "%d %s %s\r\n",
            m_ruleTypes[i],
            CRuleList::DWord2DateString(m_ruleDate[i]),
            m_rulePatterns[i]
            );
        f.Write(tmp, tmp.GetLength());
    }
}

void CNoSpamDlg::GetRuleFileName(CString &fname)
{
    CWinApp* pApp = AfxGetApp();
    fname = pApp->m_pszHelpFilePath;
    int idx = fname.ReverseFind('\\');
    fname = fname.Left(idx+1) + "rules.txt";
}

void CNoSpamDlg::LoadRules()
{
    CString fname;
    GetRuleFileName(fname);
    FILE* fp = fopen(fname, "r");
    if (fp != NULL)
    {
        char linebuf[1024];
        while (fgets(linebuf, sizeof(linebuf), fp) != NULL)
        {
            int ruleType;
            int month, day, year;
            if (sscanf(linebuf, "%d %d/%d/%d", &ruleType, &month, &day, &year) == 4)
            {
                char* p = strchr(linebuf, ' ');
                if (p != NULL)
                {
                    if ((p = strchr(++p, ' ')) != NULL)
                    {
                        ++p;
                        for (int i = 0; p[i] != '\0'; ++i)
                        {
                            if (p[i] == '\r' || p[i] == '\n')
                            {
                                p[i] = '\0';
                                AddUniqueRule(
                                    (const BYTE)ruleType,
                                    p,
                                    Date2DWord(year, month, day)
                                    );
                                break;
                            }
                        }
                    }
                }
            }
        }
        fclose(fp);
    }
}

void CNoSpamDlg::OnRulelist() 
{
	CRuleList ruleList(&m_ruleTypes, &m_rulePatterns, &m_ruleDate);
	ruleList.DoModal();
}

BOOL CNoSpamDlg::IsDupRule(const BYTE ruleType, LPCTSTR pattern)
{
    // check for duplicated rules
    for (int i = 0; i < m_ruleTypes.GetSize(); ++i)
    {
        if (m_ruleTypes[i] == ruleType && 
            m_rulePatterns[i].CompareNoCase(pattern) == 0) {
            break;
        }
    }
    return (i < m_ruleTypes.GetSize());
}

BOOL CNoSpamDlg::AddUniqueRule(const BYTE ruleType, LPCTSTR pattern, DWORD ruleDate)
{
    if (!IsDupRule(ruleType, pattern))
    {
        m_ruleTypes.Add((BYTE)ruleType);
        m_rulePatterns.Add(pattern);
        m_ruleDate.Add(ruleDate);
        return TRUE;
    }
    return FALSE;
}

BOOL CNoSpamDlg::DlgAddRule(LPCTSTR email, LPCTSTR name, LPCTSTR subject)
{
    CSetRule setRule;
    if (email) {
        setRule.m_emailPattern = email;
    }
    if (name) {
        setRule.m_namePattern = name;
    }
    if (subject) {
        setRule.m_subjectPattern = subject;
    }
    if (setRule.DoModal() == IDOK)
    {
        LPCTSTR pattern = NULL;
        switch (setRule.m_matchWhat)
        {
        case 0:
            pattern = setRule.m_emailPattern;
            ++setRule.m_matchWhat;
            break;
        case 1:
            pattern = setRule.m_domainPattern;
            break;
        case 2:
            pattern = setRule.m_namePattern;
            break;
        case 3:
            pattern = setRule.m_subjectPattern;
            break;
        }
        if (pattern)
        {
            if (AddUniqueRule((const BYTE)(setRule.m_matchWhat-1), pattern, GetCurrentDate()))
            {
                SaveRules();
                return TRUE;
            }
        }
    }
    return FALSE;
}

BOOL CNoSpamDlg::DlgEditRule(const int idx)
{
    CSetRule setRule;
    setRule.m_matchWhat = m_ruleTypes[idx] + 1;
    if (setRule.m_matchWhat == 1) {
        setRule.m_matchWhat = 0;
    }
    switch (m_ruleTypes[idx])
    {
    case 0:
        setRule.m_emailPattern = m_rulePatterns[idx];
        break;
    case 1:
        setRule.m_namePattern = m_rulePatterns[idx];
        break;
    case 2:
        setRule.m_subjectPattern = m_rulePatterns[idx];
        break;
    }
    if (setRule.DoModal() == IDOK)
    {
        LPCTSTR pattern = NULL;
        switch (setRule.m_matchWhat)
        {
        case 0:
            pattern = setRule.m_emailPattern;
            ++setRule.m_matchWhat;
            break;
        case 1:
            pattern = setRule.m_domainPattern;
            break;
        case 2:
            pattern = setRule.m_namePattern;
            break;
        case 3:
            pattern = setRule.m_subjectPattern;
            break;
        }
        if (pattern)
        {
            m_ruleTypes[idx] = setRule.m_matchWhat-1;
            m_rulePatterns[idx] = pattern;
            m_ruleDate[idx] = GetCurrentDate();
            SaveRules();
            return TRUE;
        }
    }
    return FALSE;
}

BOOL CNoSpamDlg::IsTempEmailAddress(LPCTSTR email)
{
    static char *emailDomains[] = {
        "*@aol.com",
        "*@hotmail.com",
        "*@yahoo.com",
        "*@msn.com",
        "*@netscape.com",
        "*@netscape.net",
        "*@earthlink.net",
        "*@earthlink.com",
        "*@att.com",
        "*@att.net",
        "*@microsoft.com",
        "*@mindspring.com",
        "*@mail.com",
        "*@compuserve.com",
        "*@compuserve.net",
        "*@excite.com",
        "*@lycos.com",
        "*@verizon.com",
        "*@sprint.com",
        "*@126.com",
        "*@126.net",
        "*@163.com",
        "*@163.net",
        "*@altavista.com",
        "*@pacbell.com",
        "\0"  // end mark
    };

    for (int i = 0; emailDomains[i][0] != '\0'; ++i)
    {
        // is it a "large" email domain?
        if (PatternMatch(email, emailDomains[i]))
        {
            // scan the user name
            char* pend = strrchr(email, '@');
            BOOL bDig = FALSE;
            int digCount = 0;
            for (LPCTSTR p = email; p < pend; ++p)
            {
                if (*p >= '0' && *p <= '9')
                {
                    if (!bDig)
                    {
                        bDig = TRUE;
                        ++digCount;
                    }
                }
                else {
                    bDig = FALSE;
                }
            }

            // if number sequence occurs 2 times or more, consider spam
            return (digCount >= 2);
        }
    }

    return FALSE;
}

BOOL CNoSpamDlg::IsSpam(LPCTSTR email, LPCTSTR name, LPCTSTR subject)
{
    if (lstrlen(email) == 0) {
        return TRUE;
    }
    if (IsTempEmailAddress(email)) {
        return TRUE;
    }
    for (int i = 0; i < m_ruleTypes.GetSize(); ++i)
    {
        switch (m_ruleTypes[i])
        {
        case 0:
            if (PatternMatch(email, m_rulePatterns[i]))
            {
                m_ruleDate[i] = GetCurrentDate();
                return TRUE;
            }
            break;
        case 1:
            if (PatternMatch(name, m_rulePatterns[i]))
            {
                m_ruleDate[i] = GetCurrentDate();
                return TRUE;
            }
            break;
        case 2:
            if (PatternMatch(subject, m_rulePatterns[i]))
            {
                m_ruleDate[i] = GetCurrentDate();
                return TRUE;
            }
            break;
        }
    }
    return FALSE;
}

BOOL CNoSpamDlg::PatternMatch(LPCTSTR text, LPCTSTR pattern)
{
    if (pattern[0] == '\0') {
        return text[0] == '\0';
    }
    switch (pattern[0])
    {
    case '?':
        return PatternMatch(&text[1], &pattern[1]);

    case '*':
        if (pattern[1] == '\0') {
            return TRUE;
        }
        else
        {
            for (LPCTSTR p = text; ; ++p)
            {
                if (PatternMatch(p, &pattern[1])) {
                    return TRUE;
                }
                if (*p == '\0') {
                    break;
                }
            }
        }
        break;

    default:
        if (tolower(text[0]) == tolower(pattern[0])) {
            return PatternMatch(&text[1], &pattern[1]);
        }
    }
    return FALSE;
}

#define	WM_ICON_NOTIFY			WM_USER+10

int CNoSpamDlg::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CDialog::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	// Create the tray icon
	if (!m_trayIcon.Create(NULL,                            // Parent window
                           WM_ICON_NOTIFY,                  // Icon notify message to use
                           _T("No Spam"),                   // tooltip
                           AfxGetApp()->LoadIcon(IDR_MAINFRAME),  // Icon to use
                           IDR_MENU_POPUP))                 // ID of tray icon
		return -1;
    m_trayIcon.SetMenuDefaultItem(0, TRUE);
    m_trayIcon.HideIcon();
	
	return 0;
}

void CNoSpamDlg::OnPopupOpen() 
{
    m_trayIcon.HideIcon();
    ShowWindow(SW_RESTORE);
    ShowWindow(SW_SHOW);
}

void CNoSpamDlg::OnUseTimer() 
{
    m_minuteCounter = 0;
	UpdateData();
	GetDlgItem(IDC_MINUTES)->EnableWindow(m_bUseTimer);
}

void CNoSpamDlg::OnTimer(UINT nIDEvent) 
{
	if (nIDEvent == m_nTimer)
    {
        if (m_bUseTimer)
        {
            if (m_minuteCounter >= m_minutes)
            {
                m_minuteCounter = 0;
                OnCheck();
            }
            else {
                ++m_minuteCounter;
            }
        }
    }
    else {
	    CDialog::OnTimer(nIDEvent);
    }
}

void CNoSpamDlg::OnChangeMinutes() 
{
	UpdateData();
}

DWORD CNoSpamDlg::Date2DWord(int year, int month, int day)
{
    return ((year << 16) & 0xffff0000) | ((month << 8) & 0x0000ff00) | (day & 0x000000ff);
}

DWORD CNoSpamDlg::GetCurrentDate()
{
    CTime t = CTime::GetCurrentTime();
    return Date2DWord(t.GetYear(), t.GetMonth(), t.GetDay());
}

void CNoSpamDlg::OnDblclkMaillist(NMHDR* pNMHDR, LRESULT* pResult) 
{
	OnSetrule();
	*pResult = 0;
}