(*) when someone requests a subscription,"
" mailman sends them a notice with a unique"
" subscription request number that they must"
" reply to in order to subscribe.
This"
" prevents mischievous (or malicious) people"
" from creating subscriptions for others"
" without their consent."
)
else:
sub_cfentry = ('subscribe_policy', mm_cfg.Radio,
('confirm', 'require approval',
'confirm+approval'), 1,
"What steps are required for subscription?
",
"confirm (*) - email confirmation required
"
"require approval - require list administrator"
" approval for subscriptions
"
"confirm+approval - both confirm and approve"
"
(*) when someone requests a subscription,"
" mailman sends them a notice with a unique"
" subscription request number that they must"
" reply to in order to subscribe.
This"
" prevents mischievous (or malicious) people"
" from creating subscriptions for others"
" without their consent."
)
config_info['privacy'] = [
"List access policies, including anti-spam measures,"
" covering members and outsiders."
' (See also the Archival Options'
' section for separate archive-privacy settings.)'
% (self.GetRelativeScriptURL('admin')),
"Subscribing",
('advertised', mm_cfg.Radio, ('No', 'Yes'), 0,
'Advertise this list when people ask what lists are on '
'this machine?'),
sub_cfentry,
"Membership exposure",
('private_roster', mm_cfg.Radio,
('Anyone', 'List members', 'List admin only'), 0,
'Who can view subscription list?',
"When set, the list of subscribers is protected by"
" member or admin password authentication."),
('obscure_addresses', mm_cfg.Radio, ('No', 'Yes'), 0,
"Show member addrs so they're not directly recognizable"
' as email addrs?',
"Setting this option causes member email addresses to be"
" transformed when they are presented on list web pages (both"
" in text and as links), so they're not trivially"
" recognizable as email addresses. The intention is to"
" to prevent the addresses from being snarfed up by"
" automated web scanners for use by spammers."),
"General posting filters",
('moderated', mm_cfg.Radio, ('No', 'Yes'), 0,
'Must posts be approved by an administrator?'),
('member_posting_only', mm_cfg.Radio, ('No', 'Yes'), 0,
'Restrict posting privilege to list members?',
"Use this option if you want to restrict posting to list members."
" If you want list members to be able to"
" post, plus a handful of other posters, see the posters "
" setting below"),
('posters', mm_cfg.EmailList, (5, 30), 1,
'Addresses of members accepted for posting to this'
' list with no required approval. (See'
' member_posting_only , above, for whether or not'
' list member posting is affected by adding addresses here.',
"Adding any entries here will have one of two effects,"
" according to the setting of member_posting_only:"
"
If member_posting_only is 'yes', then" " adding entries here will allow list members and anyone" " listed here to post without going through admin approval." "
If member_posting_only is 'no', then only" " the posters listed here will be able to post without admin" " approval. "), "Spam-specific posting filters", ('require_explicit_destination', mm_cfg.Radio, ('No', 'Yes'), 0, 'Must posts have list named in destination (to, cc) field' ' (or be among the acceptable alias names, specified below)?', "Many (in fact, most) spams do not explicitly name their myriad" " destinations in the explicit destination addresses - in fact," " often the to field has a totally bogus address for" " obfuscation. The constraint applies only to the stuff in" " the address before the '@' sign, but still catches all such" " spams." "
The cost is that the list will not accept unhindered any" " postings relayed from other addresses, unless
For example:
to: .*@public.comsays" " to hold all postings with a to mail header" " containing '@public.com' anywhere among the addresses." "
Note that leading whitespace is trimmed from the" " regexp. This can be circumvented in a number of ways, eg" " by escaping or bracketing it." "
See also the forbidden_posters option for" " a related mechanism."), ('anonymous_list', mm_cfg.Radio, ('No', 'Yes'), 0, 'Hide the sender of a message, replacing it with the list ' 'address (Removes From, Sender and Reply-To fields)'), ] config_info['nondigest'] = [ "Policies concerning immediately delivered list traffic.", ('nondigestable', mm_cfg.Toggle, ('No', 'Yes'), 1, 'Can subscribers choose to receive mail immediately,' ' rather than in batched digests?'), ('msg_header', mm_cfg.Text, (4, 55), 0, 'Header added to mail sent to regular list members', "Text prepended to the top of every immediately-delivery" " message.
" + Errors.MESSAGE_DECORATION_NOTE), ('msg_footer', mm_cfg.Text, (4, 55), 0, 'Footer added to mail sent to regular list members', "Text appended to the bottom of every immediately-delivery" " message.
" + Errors.MESSAGE_DECORATION_NOTE), ] config_info['bounce'] = Bouncer.GetConfigInfo(self) return config_info def Create(self, name, admin, crypted_password): if name in Utils.list_names(): raise ValueError, 'List %s already exists.' % name else: Utils.MakeDirTree(os.path.join(mm_cfg.LIST_DATA_DIR, name)) self._full_path = os.path.join(mm_cfg.LIST_DATA_DIR, name) self._internal_name = name self.Lock() self.InitVars(name, admin, crypted_password) self._ready = 1 self.InitTemplates() self.Save() self.CreateFiles() def CreateFiles(self): # Touch these files so they have the right dir perms no matter what. # A "just-in-case" thing. This shouldn't have to be here. ou = os.umask(002) try: open(os.path.join(mm_cfg.LOCK_DIR, '%s.lock' % self._internal_name), 'a+').close() open(os.path.join(self._full_path, "next-digest"), "a+").close() open(os.path.join(self._full_path, "next-digest-topics"), "a+").close() finally: os.umask(ou) def Save(self): # If more than one client is manipulating the database at once, we're # pretty hosed. That's a good reason to make this a daemon not a # program. self.IsListInitialized() fname = os.path.join(self._full_path, 'config.db') fname_last = fname + ".last" file = aside_new(fname, fname_last, reopen=1) dict = {} for (key, value) in self.__dict__.items(): if key[0] <> '_': dict[key] = value try: marshal.dump(dict, file) file.close() except IOError, status: # Darn - try to resurrect the old config.db. file = aside_new(fname_last, fname, reopen=0) self.LogMsg("error", "Failed config file write '%s'," " old config resurrected." % `status.args`) raise self.CheckHTMLArchiveDir() def Load(self, check_version = 1): if self._tmp_lock: self.Lock() try: file = open(os.path.join(self._full_path, 'config.db'), 'r') except IOError: raise mm_cfg.MMBadListError, 'Failed to access config info' try: dict = marshal.load(file) except (EOFError, ValueError, TypeError): raise mm_cfg.MMBadListError, 'Failed to unmarshal config info' for (key, value) in dict.items(): setattr(self, key, value) file.close() self._ready = 1 if check_version: self.CheckValues() self.CheckVersion(dict) def LogMsg(self, kind, msg, *args): """Append a message to the log file for messages of specified kind.""" # For want of a better fallback, we use sys.stderr if we can't get # a log file. We need a better way to warn of failed log access... if self._log_files.has_key(kind): logf = self._log_files[kind] else: logf = self._log_files[kind] = StampedLogger(kind) logf.write("%s\n" % (msg % args)) logf.flush() def CheckVersion(self, stored_state): """Migrate prior version's state to new structure, if changed.""" if (self.data_version >= mm_cfg.DATA_FILE_VERSION and type(self.data_version) == type(mm_cfg.DATA_FILE_VERSION)): return else: self.InitVars() # Init any new variables, self.Load(check_version = 0) # then reload the file from versions import Update Update(self, stored_state) self.data_version = mm_cfg.DATA_FILE_VERSION self.Save() def CheckValues(self): """Normalize selected values to known formats.""" if self.web_page_url and self.web_page_url[-1] != '/': self.web_page_url = self.web_page_url + '/' def IsListInitialized(self): if not self._ready: raise Errors.MMListNotReady def AddMember(self, name, password, digest=0, remote=None): self.IsListInitialized() # Remove spaces... it's a common thing for people to add... name = string.join(string.split(name), '') # lower case only the domain part name = Utils.LCDomain(name) # Validate the e-mail address to some degree. if not Utils.ValidEmail(name): raise Errors.MMBadEmailError if self.IsMember(name): raise Errors.MMAlreadyAMember if name == string.lower(self.GetListEmail()): # Trying to subscribe the list to itself! raise mm_err.MMBadEmailError if digest and not self.digestable: raise Errors.MMCantDigestError elif not digest and not self.nondigestable: raise Errors.MMMustDigestError if self.subscribe_policy == 0: # no confirmation or approval necessary: self.ApprovedAddMember(name, password, digest) elif self.subscribe_policy == 1 or self.subscribe_policy == 3: # confirmation: from Pending import Pending cookie = Pending().new(name, password, digest) if remote is not None: by = " " + remote remote = " from %s" % remote else: by = "" remote = "" recipient = self.GetMemberAdminEmail(name) text = Utils.maketext('verify.txt', {"email" : name, "listaddr" : self.GetListEmail(), "listname" : self.real_name, "cookie" : cookie, "hostname" : remote, "requestaddr": self.GetRequestEmail(), "remote" : remote, "listadmin" : self.GetAdminEmail(), }) self.SendTextToUser( subject=("%s -- confirmation of subscription -- request %d" % (self.real_name, cookie)), recipient = recipient, sender = self.GetRequestEmail(), text = text, add_headers = ["Reply-to: %s" % self.GetRequestEmail(), "Errors-To: %s" % self.GetAdminEmail()]) if recipient != name: who = "%s (%s)" % (name, string.split(recipient, '@')[0]) else: who = name self.LogMsg("subscribe", "%s: pending %s %s", self._internal_name, who, by) raise Errors.MMSubscribeNeedsConfirmation else: # approval needed self.AddRequest('add_member', digest, name, password) raise Errors.MMNeedApproval, self.GetAdminEmail() def ApprovedAddMember(self, name, password, digest, ack=None, admin_notif=None): if ack is None: if self.send_welcome_msg: ack = 1 else: ack = 0 if admin_notif is None: if self.admin_notify_mchanges: admin_notif = 1 else: admin_notif = 0 name = Utils.LCDomain(name) if self.IsMember(name): raise Errors.MMAlreadyAMember self.__AddMember(name, digest) if digest: kind = " (D)" else: kind = "" self.SetUserOption(name, mm_cfg.DisableMime, 1 - self.mime_is_default_digest) self.LogMsg("subscribe", "%s: new%s %s", self._internal_name, kind, name) self.passwords[name] = password if ack: self.SendSubscribeAck(name, password, digest) if admin_notif: import Message txt = Utils.maketext("adminsubscribeack.txt", {"mmowner": mm_cfg.MAILMAN_OWNER, "admin_email": self.GetAdminEmail(), "listname": self.real_name, "member": name}, 1) msg = Message.IncomingMessage(txt) self.DeliverToOwner(msg, self.owner) def ProcessConfirmation(self, cookie): from Pending import Pending got = Pending().confirmed(cookie) if not got: raise Errors.MMBadConfirmation else: (email_addr, password, digest) = got if self.subscribe_policy == 3: # confirm + approve self.AddRequest('add_member', digest, email_addr, password) raise Errors.MMNeedApproval, self.GetAdminEmail() self.ApprovedAddMember(email_addr, password, digest) self.Save() def DeleteMember(self, name, whence=None, admin_notif=None): self.IsListInitialized() # FindMatchingAddresses *should* never return more than 1 address. # However, should log this, just to make sure. aliases = Utils.FindMatchingAddresses(name, self.members, self.digest_members) if not len(aliases): raise Errors.MMNoSuchUserError def DoActualRemoval(alias, me=self): kind = "(unfound)" try: del me.passwords[alias] except KeyError: pass if me.user_options.has_key(alias): del me.user_options[alias] try: del me.members[alias] kind = "regular" except KeyError: pass try: del me.digest_members[alias] kind = "digest" except KeyError: pass map(DoActualRemoval, aliases) if self.goodbye_msg and len(self.goodbye_msg): self.SendUnsubscribeAck(name) self.ClearBounceInfo(name) self.Save() if admin_notif is None: if self.admin_notify_mchanges: admin_notif = 1 else: admin_notif = 0 if admin_notif: import Message txt = Utils.maketext("adminunsubscribeack.txt", {"mmowner": mm_cfg.MAILMAN_OWNER, "admin_email": self.GetAdminEmail(), "listname": self.real_name, "member": name}, 1) msg = Message.IncomingMessage(txt) self.DeliverToOwner(msg, self.owner) if whence: whence = "; %s" % whence else: whence = "" self.LogMsg("subscribe", "%s: deleted %s%s", self._internal_name, name, whence) def IsMember(self, address): return len(Utils.FindMatchingAddresses(address, self.members, self.digest_members)) def HasExplicitDest(self, msg): """True if list name or any acceptable_alias is included among the to or cc addrs.""" # Note that qualified host can be different! This allows, eg, for # relaying from remote lists that have the same name. Still # stringent, but offers a way to provide for remote exploders. lowname = string.lower(self.real_name) recips = [] # First check all dests against simple name: for recip in msg.getaddrlist('to') + msg.getaddrlist('cc'): curr = string.lower(string.split(recip[1], '@')[0]) if lowname == curr: return 1 recips.append(curr) # ... and only then try the regexp acceptable aliases. for recip in recips: for alias in string.split(self.acceptable_aliases, '\n'): stripped = string.strip(alias) if stripped and re.match(stripped, recip): return 1 return 0 def parse_matching_header_opt(self): """Return a list of triples [(field name, regex, line), ...].""" # - Blank lines and lines with '#' as first char are skipped. # - Leading whitespace in the matchexp is trimmed - you can defeat # that by, eg, containing it in gratuitous square brackets. all = [] for line in string.split(self.bounce_matching_headers, '\n'): stripped = string.strip(line) if not stripped or (stripped[0] == "#"): # Skip blank lines and lines *starting* with a '#'. continue else: try: h, e = re.split(":[ ]*", stripped) all.append((h, e, stripped)) except ValueError: # Whoops - some bad data got by: self.LogMsg("config", "%s - " "bad bounce_matching_header line %s" % (self.real_name, `stripped`)) return all def HasMatchingHeader(self, msg): """True if named header field (case-insensitive) matches regexp. Case insensitive. Returns constraint line which matches or empty string for no matches.""" pairs = self.parse_matching_header_opt() for field, matchexp, line in pairs: fragments = msg.getallmatchingheaders(field) subjs = [] l = len(field) for f in fragments: # Consolidate header lines, stripping header name & whitespace. if (len(f) > l and f[l] == ":" and string.lower(field) == string.lower(f[0:l])): # Non-continuation line - trim header name: subjs.append(f[l+2:]) elif not subjs: # Whoops - non-continuation that matches? subjs.append(f) else: # Continuation line. subjs[-1] = subjs[-1] + f for s in subjs: if re.search(matchexp, s, re.I): return line return 0 # msg should be an IncomingMessage object. def Post(self, msg, approved=0): self.IsListInitialized() # Be sure to ExtractApproval, whether or not flag is already set! msgapproved = self.ExtractApproval(msg) if not approved: approved = msgapproved sender = msg.GetEnvelopeSender() if not sender: sender = msg.GetSender() # If it's the admin, which we know by the approved variable, # we can skip a large number of checks. if not approved: beentheres = map(lambda x: string.split(x, ": ")[1][:-1], msg.getallmatchingheaders('x-beenthere')) if self.GetListEmail() in beentheres: self.AddRequest('post', Utils.SnarfMessage(msg), Errors.LOOPING_POST, msg.getheader('subject')) if len(self.forbidden_posters): forbidden_posters = Utils.List2Dict(self.forbidden_posters) addrs = Utils.FindMatchingAddresses(sender, forbidden_posters) if len(addrs): self.AddRequest('post', Utils.SnarfMessage(msg), Errors.FORBIDDEN_SENDER_MSG, msg.getheader('subject')) if self.moderated and not len(self.posters): self.AddRequest('post', Utils.SnarfMessage(msg), Errors.MODERATED_LIST_MSG, msg.getheader('subject')) elif self.moderated and len(self.posters): addrs = Utils.FindMatchingAddresses( sender, Utils.List2Dict(self.posters)) if not len(addrs): self.AddRequest('post', Utils.SnarfMessage(msg), Errors.MODERATED_LIST_MSG, msg.getheader('subject')) # # not moderated # elif len(self.posters): addrs = Utils.FindMatchingAddresses( sender, Utils.List2Dict(self.posters)) if not len(addrs): if self.member_posting_only: if not self.IsMember(sender): self.AddRequest('post', Utils.SnarfMessage(msg), 'Only approved posters may post' ' without moderator approval.', msg.getheader('subject')) else: self.AddRequest('post', Utils.SnarfMessage(msg), 'Only approved posters may post' ' without moderator approval.', msg.getheader('subject')) elif self.member_posting_only and not self.IsMember(sender): self.AddRequest('post', Utils.SnarfMessage(msg), 'Postings from member addresses only.', msg.getheader('subject')) if self.max_num_recipients > 0: recips = [] toheader = msg.getheader('to') if toheader: recips = recips + string.split(toheader, ',') ccheader = msg.getheader('cc') if ccheader: recips = recips + string.split(ccheader, ',') if len(recips) > self.max_num_recipients: self.AddRequest('post', Utils.SnarfMessage(msg), 'Too many recipients.', msg.getheader('subject')) if (self.require_explicit_destination and not self.HasExplicitDest(msg)): self.AddRequest('post', Utils.SnarfMessage(msg), Errors.IMPLICIT_DEST_MSG, msg.getheader('subject')) if self.administrivia and Utils.IsAdministrivia(msg): self.AddRequest('post', Utils.SnarfMessage(msg), 'possible administrivia to list', msg.getheader("subject")) if self.bounce_matching_headers: triggered = self.HasMatchingHeader(msg) if triggered: # Darn - can't include the matching line for the admin # message because the info would also go to the sender. self.AddRequest('post', Utils.SnarfMessage(msg), Errors.SUSPICIOUS_HEADER_MSG, msg.getheader('subject')) if self.max_message_size > 0: if len(msg.body)/1024. > self.max_message_size: self.AddRequest('post', Utils.SnarfMessage(msg), 'Message body too long (>%dk)' % self.max_message_size, msg.getheader('subject')) # Prepend the subject_prefix to the subject line. subj = msg.getheader('subject') prefix = self.subject_prefix if not subj: msg.SetHeader('Subject', '%s(no subject)' % prefix) elif not re.match("(re:? *)?" + re.escape(self.subject_prefix), subj, re.I): msg.SetHeader('Subject', '%s%s' % (prefix, subj)) if self.anonymous_list: del msg['reply-to'] del msg['sender'] msg.SetHeader('From', self.GetAdminEmail()) if self.digestable: self.SaveForDigest(msg) if self.archive: self.ArchiveMail(msg) if self.gateway_to_news: self.SendMailToNewsGroup(msg) dont_send_to_sender = 0 ack_post = 0 # Try to get the address the list thinks this sender is sender = self.FindUser(msg.GetSender()) if sender: if self.GetUserOption(sender, mm_cfg.DontReceiveOwnPosts): dont_send_to_sender = 1 if self.GetUserOption(sender, mm_cfg.AcknowlegePosts): ack_post = 1 # Deliver the mail. members = self.GetDeliveryMembers() if dont_send_to_sender: try: recipients.remove(members) # # sender not in list (case sensitive username problem?) # except ValueError: self.LogMsg("error", "couldn't remove %s from recipient list: %s", sender, str(members)) recipients = [] for m in members: if not self.GetUserOption(m, mm_cfg.DisableDelivery): recipients.append(m) self.LogMsg("post", "post to %s from %s size=%d", self._internal_name, msg.GetSender(), len(msg.body)) self.DeliverToList(msg, recipients, header = self.msg_header % self.__dict__, footer = self.msg_footer % self.__dict__) if ack_post: self.SendPostAck(msg, sender) self.last_post_time = time.time() self.post_id = self.post_id + 1 self.Save() def Locked(self): try: return self._lock_file and 1 except AttributeError: return 0 def Lock(self): try: if self._lock_file: return except AttributeError: return ou = os.umask(0) try: self._lock_file = posixfile.open( os.path.join(mm_cfg.LOCK_DIR, '%s.lock' % self._internal_name), 'a+') finally: os.umask(ou) self._lock_file.lock('w|', 1) def Unlock(self): if self.Locked(): self._lock_file.lock('u') self._lock_file.close() self._lock_file = None def __repr__(self): if self.Locked(): status = " (locked)" else: status = "" return ("<%s.%s %s%s at %s>" % (self.__module__, self.__class__.__name__, `self._internal_name`, status, hex(id(self))[2:])) def aside_new(old_name, new_name, reopen=0): """Utility to move aside a file, optionally returning a fresh open version. We ensure maintanance of proper umask in the process.""" ou = os.umask(002) try: if os.path.exists(new_name): os.unlink(new_name) if os.path.exists(old_name): os.link(old_name, new_name) os.unlink(old_name) if reopen: file = open(old_name, 'w') return file finally: os.umask(ou)