func (spmf *SubjectPrefixMatchFilter) Filter(mail mailfile.Mail) Result {
	log.Printf("Run %s, Mail:%s\n", spmf, mail.Name())
	spmf.total.Inc(1)

	matched := false
	for _, subjectPrefix := range spmf.subjectPrefixes {
		if strings.HasPrefix(mail.Subject(), subjectPrefix) {
			matched = true
			spmf.matched.Inc(1)
			break
		}
	}

	if !matched {
		return Incoming
	}

	return spmf.next.Filter(mail)
}
Пример #2
0
func (sof *RelayOnlyFilter) Filter(mail mailfile.Mail) Result {
	log.Printf("Run %s, Mail:%s\n", sof, mail.Name())
	sof.total.Inc(1)

	sendOut := false
	for _, address := range mail.To() {
		if !strings.HasSuffix(address.Address, sof.localDomain) {
			sendOut = true
			sof.numOfRelay.Inc(1)
			break
		}
	}

	if !sendOut {
		return Incoming
	}

	return sof.next.Filter(mail)
}
func (cif *ContentInspectionFilter) Filter(mail mailfile.Mail) Result {
	log.Printf("Run %s, Mail:%s\n", cif, mail.Name())
	cif.total.Inc(1)

	post, err := mailpost.Parse(mail)
	mail.Close()
	if err != nil {
		cif.malformed.Inc(1)
		log.Printf("ContentInspectionFilter: Err:%v, Mail:%s\n", err, mail.Path())
		return cif.next.Filter(mail)
	}

	class := cif.anlz.Test(post.Subject + " " + post.Content)
	cif.counters[class].Inc(1)
	if cif.allPass || analyzer.Good == class {
		return cif.next.Filter(mail)
	}

	return Quarantine
}
Пример #4
0
func (df *DeliverFilter) Filter(mail mailfile.Mail) Result {
	log.Printf("Run %s, Mail:%s\n", df, mail.Name())
	df.total.Inc(1)

	result := df.next.Filter(mail)

	df.counters[result].Inc(1)

	if result == None {
		log.Fatalf("DeliverFilter: the filter result should not be None, Mail:%s\n", mail.Name())
	}

	destination := filepath.Join(df.paths[result], mail.Name())
	log.Printf("Move to %s, Mail:%s\n", destination, mail.Name())

	err := os.Rename(mail.Path(), destination)
	if err != nil {
		log.Printf("DeliverFilter: Err:%v, Mail:%s\n", err, mail.Name())
	}

	return None
}
func (cih *ContentInspectionUpdater) Update(mail mailfile.Mail) {
	if leaner, ok := cih.anlz.(analyzer.Learner); ok {
		log.Printf("Run %s, Mail:%s\n", cih, mail.Name())
		cih.total.Inc(1)

		post, err := mailpost.Parse(mail)
		mail.Close()
		if err != nil {
			cih.malformed.Inc(1)
			log.Printf("ContentInspectionUpdater: Err:%v, Mail:%s\n", err, mail.Path())
			return
		}

		leaner.Learn(post.Subject, cih.class)
		leaner.Learn(post.Content, cih.class)

		err = os.Remove(mail.Path())
		if err != nil {
			log.Println(err)
		}
	}
}
Пример #6
0
func (cf *CachingProxy) Filter(mail mailfile.Mail) Result {
	log.Printf("Run %s, Mail:%s\n", cf, mail.Name())
	cf.total.Inc(1)

	keyer, ok := cf.target.(CacheKey)

	if !ok {
		log.Fatalf("%s should implement CacheKey interface\n", cf.target)
		return None
	}

	key := keyer.Key(mail)

	cf.rwm.RLock()
	for e := cf.l.Front(); e != nil; e = e.Next() {
		if t, ok := e.Value.(*CacheEntry); ok {
			if key == t.key {
				cf.rwm.RUnlock()
				cf.hit.Inc(1)
				return t.result
			}
		}
	}
	cf.rwm.RUnlock()

	result := cf.target.Filter(mail)

	cf.rwm.Lock()
	cf.l.PushFront(&CacheEntry{key, result})
	if cf.l.Len() > cf.size {
		cf.l.Remove(cf.l.Back())
	}
	cf.cached.Update(int64(cf.l.Len()))
	cf.rwm.Unlock()

	return result
}
func (ddf *DefaultDestinationFilter) Filter(mail mailfile.Mail) Result {
	log.Printf("Run %s, Mail:%s\n", ddf, mail.Name())
	ddf.total.Inc(1)
	return Incoming
}