1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
# Copyright (C) 2007-2008 by the Free Software Foundation, Inc.
#
# This file is part of GNU Mailman.
#
# GNU Mailman 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 3 of the License, or (at your option)
# any later version.
#
# GNU Mailman 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
# GNU Mailman. If not, see <http://www.gnu.org/licenses/>.
"""The header-matching chain."""
__all__ = ['HeaderMatchChain']
__metaclass__ = type
import re
import logging
import itertools
from zope.interface import implements
from mailman.interfaces import IChainIterator, IRule, LinkAction
from mailman.chains.base import Chain, Link
from mailman.i18n import _
from mailman.configuration import config
log = logging.getLogger('mailman.vette')
def make_link(entry):
"""Create a Link object.
:param entry: a 2- or 3-tuple describing a link. If a 2-tuple, it is a
header and a pattern, and a default chain of 'hold' will be used. If
a 3-tuple, the third item is the chain name to use.
:return: an ILink.
"""
if len(entry) == 2:
header, pattern = entry
chain_name = 'hold'
elif len(entry) == 3:
header, pattern, chain_name = entry
# We don't assert that the chain exists here because the jump
# chain may not yet have been created.
else:
raise AssertionError('Bad link description: %s' % entry)
rule = HeaderMatchRule(header, pattern)
chain = config.chains[chain_name]
return Link(rule, LinkAction.jump, chain)
class HeaderMatchRule:
"""Header matching rule used by header-match chain."""
implements(IRule)
# Sequential rule counter.
_count = 1
def __init__(self, header, pattern):
self._header = header
self._pattern = pattern
self.name = 'header-match-%002d' % HeaderMatchRule._count
HeaderMatchRule._count += 1
self.description = u'%s: %s' % (header, pattern)
# XXX I think we should do better here, somehow recording that a
# particular header matched a particular pattern, but that gets ugly
# with RFC 2822 headers. It also doesn't match well with the rule
# name concept. For now, we just record the rather useless numeric
# rule name. I suppose we could do the better hit recording in the
# check() method, and set self.record = False.
self.record = True
def check(self, mlist, msg, msgdata):
"""See `IRule`."""
for value in msg.get_all(self._header, []):
if re.search(self._pattern, value, re.IGNORECASE):
return True
return False
class HeaderMatchChain(Chain):
"""Default header matching chain.
This could be extended by header match rules in the database.
"""
def __init__(self):
super(HeaderMatchChain, self).__init__(
'header-match', _('The built-in header matching chain'))
# The header match rules are not global, so don't register them.
# These are the only rules that the header match chain can execute.
self._links = []
# Initialize header check rules with those from the global
# HEADER_MATCHES variable.
for entry in config.HEADER_MATCHES:
self._links.append(make_link(entry))
# Keep track of how many global header matching rules we've seen.
# This is so the flush() method will only delete those that were added
# via extend() or append_link().
self._permanent_link_count = len(self._links)
def extend(self, header, pattern, chain_name='hold'):
"""Extend the existing header matches.
:param header: The case-insensitive header field name.
:param pattern: The pattern to match the header's value again. The
match is not anchored and is done case-insensitively.
:param chain: Option chain to jump to if the pattern matches any of
the named header values. If not given, the 'hold' chain is used.
"""
self._links.append(make_link((header, pattern, chain_name)))
def flush(self):
"""See `IMutableChain`."""
del self._links[self._permanent_link_count:]
def get_links(self, mlist, msg, msgdata):
"""See `IChain`."""
list_iterator = HeaderMatchIterator(mlist)
return itertools.chain(iter(self._links), iter(list_iterator))
def __iter__(self):
for link in self._links:
yield link
class HeaderMatchIterator:
"""An iterator of both the global and list-specific chain links."""
implements(IChainIterator)
def __init__(self, mlist):
self._mlist = mlist
def __iter__(self):
"""See `IChainIterator`."""
for entry in self._mlist.header_matches:
yield make_link(entry)
|
